wasm-pack build

cargo xtask wasm check
cargo xtask wasm build

// Username for RDP authentication
username(username: string): SessionBuilder

// Destination server address
destination(destination: string): SessionBuilder

// User password
password(password: string): SessionBuilder

// WebSocket proxy address
proxy_address(address: string): SessionBuilder

// Authentication token for proxy
auth_token(token: string): SessionBuilder

// HTML canvas element for rendering
render_canvas(canvas: HTMLCanvasElement): SessionBuilder

// Cursor style change callback
set_cursor_style_callback(callback: Function): SessionBuilder

// Callback context (usually `this`)
set_cursor_style_callback_context(context: any): SessionBuilder

// Server domain (Active Directory domain)
server_domain(domain: string): SessionBuilder

// Desktop dimensions (default: 1280x720)
desktop_size(size: DesktopSize): SessionBuilder

// Remote clipboard change notification
remote_clipboard_changed_callback(callback: Function): SessionBuilder

// Force clipboard update request
force_clipboard_update_callback(callback: Function): SessionBuilder

// Canvas resize notification (unused in RDP)
canvas_resized_callback(callback: Function): SessionBuilder

// Configure optional features
extension(ext: Extension): SessionBuilder

// Establish the RDP connection
async connect(): Promise<Session>

// Start the session event loop (call once)
async run(): Promise<SessionTerminationInfo>

// Get desktop dimensions
desktop_size(): DesktopSize

// Apply buffered input events
apply_inputs(transaction: InputTransaction): void

// Release all pressed keys/buttons
release_all_inputs(): void

// Synchronize keyboard lock key states
synchronize_lock_keys(
  scroll_lock: boolean,
  num_lock: boolean, 
  caps_lock: boolean,
  kana_lock: boolean
): void

// Initiate graceful session termination
shutdown(): void

// Send local clipboard data to remote
async on_clipboard_paste(content: ClipboardData): Promise<void>

// Request desktop resize (requires Display Control)
resize(
  width: number,
  height: number,
  scale_factor?: number,
  physical_width?: number,
  physical_height?: number
): void

// Check if Unicode shortcuts are supported (false for RDP)
supports_unicode_keyboard_shortcuts(): boolean

// Mouse button events
DeviceEvent.mouse_button_pressed(button: number): DeviceEvent
DeviceEvent.mouse_button_released(button: number): DeviceEvent

// Mouse movement
DeviceEvent.mouse_move(x: number, y: number): DeviceEvent

// Mouse wheel scrolling
DeviceEvent.wheel_rotations(
  vertical: boolean,
  rotation_amount: number,
  rotation_unit: RotationUnit
): DeviceEvent

// Keyboard scancode events
DeviceEvent.key_pressed(scancode: number): DeviceEvent
DeviceEvent.key_released(scancode: number): DeviceEvent

// Unicode keyboard events
DeviceEvent.unicode_pressed(char: string): DeviceEvent
DeviceEvent.unicode_released(char: string): DeviceEvent

// Create new transaction
InputTransaction.create(): InputTransaction

// Add event to transaction
add_event(event: DeviceEvent): void

// Create empty clipboard data
ClipboardData.create(): ClipboardData

// Add text format
add_text(mime_type: string, text: string): void

// Add binary format
add_binary(mime_type: string, binary: Uint8Array): void

// Get all items
items(): ClipboardItem[]

// Get MIME type
mime_type(): string

// Get value (string or Uint8Array)
value(): string | Uint8Array

function setCursorStyle(
  kind: string,
  data?: string,
  hotspot_x?: number,
  hotspot_y?: number
): void

// Get human-readable termination reason
reason(): string

interface IronError {
  kind: IronErrorKind;
  message: string;
}

enum IronErrorKind {
  General,
  ProxyConnect,
  RDCleanPath,
  NegotiationFailure,
  // ... other kinds
}

interface DesktopSize {
  width: number;   // 0-65535
  height: number;  // 0-65535
}

type CursorStyle =
  | { kind: "Default" }
  | { kind: "Hidden" }
  | { kind: "Url"; data: string; hotspot_x: number; hotspot_y: number }

import { SessionBuilder, DeviceEvent, InputTransaction } from 'ironrdp-web';

// Configure session
const session = await SessionBuilder.create()
  .username('user')
  .password('pass')
  .destination('10.0.0.1:3389')
  .proxy_address('wss://proxy.example.com')
  .auth_token('token123')
  .desktop_size({ width: 1920, height: 1080 })
  .render_canvas(document.getElementById('rdp-canvas'))
  .set_cursor_style_callback(setCursorStyle)
  .set_cursor_style_callback_context(this)
  .remote_clipboard_changed_callback(onClipboardChanged)
  .extension({ display_control: true })
  .connect();

// Start session
const termination = await session.run();
console.log('Session ended:', termination.reason());

// Send input
const tx = InputTransaction.create();
tx.add_event(DeviceEvent.mouse_move(100, 200));
tx.add_event(DeviceEvent.mouse_button_pressed(0));
session.apply_inputs(tx);