tessl/npm-tauri-apps--api
TypeScript/JavaScript API bindings for Tauri applications providing comprehensive desktop app functionality
—
Pending
Does it follow best practices?
Impact
Pending
No eval scenarios have been run
Pending
The risk profile of this skill
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;
}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'
}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;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;
}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[];
}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;
}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;
}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;
}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.
- Workspace
- tessl
- Visibility
- Public
- Created
- Last updated
- Describes
- Publish Source
- CLI
- Badge
