or run

npx @tessl/cli init
Log in

Version

Tile

Overview

Evals

Files

docs

app-lifecycle.mdcore-ipc.mdevents.mdindex.mdmenu-system.mdsystem-integration.mdtesting.mdutilities.mdwindow-management.md
tile.json

tessl/npm-tauri-apps--api

TypeScript/JavaScript API bindings for Tauri applications providing comprehensive desktop app functionality

Workspace
tessl
Visibility
Public
Created
Last updated
Describes
npmpkg:npm/@tauri-apps/api@2.8.x

To install, run

npx @tessl/cli install tessl/npm-tauri-apps--api@2.8.0

index.mddocs/

Tauri API

The Tauri API provides comprehensive TypeScript/JavaScript bindings for building cross-platform desktop applications with web technologies. It enables frontend frameworks to communicate with Rust-based backend functionality through a complete message-passing interface, offering desktop-specific APIs for window management, system integration, file access, and native platform features.

Package Information

  • Package Name: @tauri-apps/api
  • Package Type: npm
  • Language: TypeScript
  • Installation: npm install @tauri-apps/api

Core Imports

import { app, window, event, core, path, menu, tray, image, dpi } from '@tauri-apps/api';

Individual module imports:

import { getCurrentWindow } from '@tauri-apps/api/window';
import { listen } from '@tauri-apps/api/event';
import { invoke } from '@tauri-apps/api/core';
import { getVersion, getName } from '@tauri-apps/api/app';
import { Menu, MenuItem } from '@tauri-apps/api/menu';
import { TrayIcon } from '@tauri-apps/api/tray';

CommonJS (if needed):

const { app, window, event, core, menu, tray } = require('@tauri-apps/api');

Basic Usage

import { getCurrentWindow } from '@tauri-apps/api/window';
import { listen } from '@tauri-apps/api/event';
import { invoke } from '@tauri-apps/api/core';

// Get current window and modify it
const currentWindow = getCurrentWindow();
await currentWindow.setTitle('My Tauri App');
await currentWindow.setSize({ width: 800, height: 600 });

// Listen for window events
await listen('window-close-requested', (event) => {
  console.log('Window close requested');
});

// Invoke Rust backend commands
const result = await invoke('my_custom_command', { 
  message: 'Hello from frontend' 
});

Architecture

The Tauri API is organized into focused modules that provide different aspects of desktop functionality:

  • Core IPC System: Foundation for communicating with Rust backend (core)
  • Window Management: Control over application windows and webviews (window, webview, webviewWindow)
  • System Integration: Native desktop features like menus, tray icons, and app lifecycle (app, menu, tray)
  • Event System: Real-time communication between frontend and backend (event)
  • Utilities: Cross-platform helpers for paths, images, and device pixels (path, image, dpi)
  • Testing: Mock implementations for development and testing (mocks)

Capabilities

Core IPC Communication

Foundation for all backend communication, including command invocation, plugin system, and resource management.

function invoke<T>(cmd: string, args?: InvokeArgs, options?: InvokeOptions): Promise<T>;
function isTauri(): boolean;
function convertFileSrc(filePath: string, protocol?: string): string;

class Channel<T> {
  constructor(onmessage?: (response: T) => void);
  readonly id: number;
  onmessage: (response: T) => void;
}

type InvokeArgs = Record<string, unknown> | number[] | ArrayBuffer | Uint8Array;
interface InvokeOptions {
  headers: HeadersInit;
}

Core IPC & Plugins

Application Lifecycle & Metadata

Control application behavior, retrieve metadata, and manage lifecycle events including visibility, theming, and platform-specific features.

// Application metadata
function getVersion(): Promise<string>;
function getName(): Promise<string>;
function getTauriVersion(): Promise<string>;
function getIdentifier(): Promise<string>;
function getBundleType(): Promise<BundleType>;

// Application visibility and state
function show(): Promise<void>;
function hide(): Promise<void>;
function setTheme(theme?: Theme | null): Promise<void>;
function setDockVisibility(visible: boolean): Promise<void>;

// Application icon and data
function defaultWindowIcon(): Promise<Image | null>;
function fetchDataStoreIdentifiers(): Promise<DataStoreIdentifier[]>;
function removeDataStore(identifier: DataStoreIdentifier): Promise<void>;

enum BundleType {
  Nsis = 'nsis',
  Msi = 'msi',
  Deb = 'deb',
  Rpm = 'rpm',
  AppImage = 'appimage',
  App = 'app'
}

Application Lifecycle

Window & Webview Management

Complete control over application windows, webviews, and their properties including size, position, decorations, and advanced features.

class Window {
  static getCurrent(): Window;
  static getAll(): Promise<Window[]>;
  setTitle(title: string): Promise<void>;
  setSize(size: LogicalSize | PhysicalSize): Promise<void>;
  setPosition(position: LogicalPosition | PhysicalPosition): Promise<void>;
  show(): Promise<void>;
  hide(): Promise<void>;
  close(): Promise<void>;
}

class WebviewWindow {
  constructor(label: string, options?: WebviewWindowOptions);
  setBackgroundColor(color: Color): Promise<void>;
}

function getCurrentWindow(): Window;
function getCurrentWebviewWindow(): WebviewWindow;

Window & Webview Management

System Integration

Native desktop features including system tray icons and platform-specific functionality.

// System tray management
class TrayIcon {
  static new(options: TrayIconOptions): Promise<TrayIcon>;
  setIcon(icon: Image | string): Promise<void>;
  setMenu(menu: Menu): Promise<void>;
  setTooltip(tooltip: string): Promise<void>;
  setVisible(visible: boolean): Promise<void>;
  setTitle(title?: string): Promise<void>;
}

interface TrayIconOptions {
  id?: string;
  icon?: Image | string;
  tooltip?: string;
  title?: string;
  menu?: Menu;
}

System Integration

Menu System

Comprehensive native menu functionality including menu bars, context menus, and system tray menus with support for different item types.

// Main menu classes
class Menu {
  static new(opts?: MenuOptions): Promise<Menu>;
  static default(): Promise<Menu>;
  append<T extends MenuItemType>(items: T | T[]): Promise<void>;
  popup(at?: Position, window?: Window): Promise<void>;
  setAsAppMenu(): Promise<Menu | null>;
  items(): Promise<MenuItemInstance[]>;
}

class MenuItem {
  static new(opts: MenuItemOptions): Promise<MenuItem>;
  setText(text: string): Promise<void>;
  setEnabled(enabled: boolean): Promise<void>;
}

class Submenu {
  static new(opts: SubmenuOptions): Promise<Submenu>;
  append<T extends MenuItemType>(items: T | T[]): Promise<void>;
}

// Menu item types
interface MenuItemOptions {
  text: string;
  accelerator?: string;
  action?: () => void;
}

interface SubmenuOptions {
  text: string;
  items?: MenuItemType[];
}

Menu System

Event System

Real-time bidirectional communication between frontend and backend with support for custom events and built-in system events.

function listen<T>(event: EventName, handler: EventCallback<T>, options?: Options): Promise<UnlistenFn>;
function once<T>(event: EventName, handler: EventCallback<T>, options?: Options): Promise<UnlistenFn>;
function emit<T>(event: string, payload?: T): Promise<void>;
function emitTo<T>(target: EventTarget, event: string, payload?: T): Promise<void>;

type EventCallback<T> = (event: Event<T>) => void;
type UnlistenFn = () => void;

interface Event<T> {
  event: string;
  id: number;
  payload: T;
}

Event System

Utilities

Cross-platform utilities for path handling, image processing, device pixel calculations, and platform abstraction.

// Path utilities
function join(...paths: string[]): Promise<string>;
function resolve(...paths: string[]): Promise<string>;
function appDataDir(): Promise<string>;
function homeDir(): Promise<string>;

// Image handling
class Image {
  static fromPath(path: string): Promise<Image>;
  static fromBytes(bytes: Uint8Array): Promise<Image>;
  size(): Promise<ImageSize>;
  rgba(): Promise<Uint8Array>;
}

// DPI handling
class LogicalSize {
  constructor(width: number, height: number);
  toPhysical(scaleFactor: number): PhysicalSize;
}

Utilities

Testing Support

Mock implementations for testing Tauri applications without requiring the full Tauri runtime environment.

function mockIPC(cb: (cmd: string, payload?: InvokeArgs) => unknown, options?: MockIPCOptions): void;
function mockWindows(current: string, ...additionalWindows: string[]): void;
function clearMocks(): void;

interface MockIPCOptions {
  shouldMockEvents?: boolean;
}

Testing & Mocks

Error Handling

Most Tauri API functions return Promises that may reject with errors. Common error scenarios include:

  • Permission denied: Operations requiring elevated permissions
  • Invalid parameters: Malformed arguments or invalid values
  • Platform limitations: Features not available on current platform
  • IPC failures: Communication errors with Rust backend
try {
  await getCurrentWindow().setTitle('New Title');
} catch (error) {
  console.error('Failed to set window title:', error);
}

Platform Support

The Tauri API supports Windows, macOS, and Linux with platform-specific features clearly documented. Some functionality (like dock visibility) is only available on specific platforms and will be no-ops on unsupported systems.