@flighthq/host-tauri 0.1.0

package/src/tauriMenu.test.ts

@@ -0,0 +1,129 @@
+import type { MenuItemTemplate } from '@flighthq/types';
+
+import { createTauriMenuBackend } from './tauriMenu';
+import type { TauriApi, TauriMenuItemOptions } from './tauriModule';
+
+function fakeTauri() {
+  const state = {
+    appMenuSet: 0,
+    popups: 0,
+    // Action callbacks captured from built MenuItems, keyed by their id.
+    actions: new Map<string, (id: string) => void>(),
+    predefined: 0,
+  };
+  const makeMenu = () => ({
+    async setAsAppMenu() {
+      state.appMenuSet++;
+    },
+    async popup() {
+      state.popups++;
+    },
+  });
+  const tauri = {
+    menu: {
+      Menu: {
+        async new() {
+          return makeMenu();
+        },
+      },
+      MenuItem: {
+        async new(options?: TauriMenuItemOptions) {
+          if (options?.id && options.action) state.actions.set(options.id, options.action);
+          return { id: options?.id ?? '' };
+        },
+      },
+      Submenu: {
+        async new() {
+          return { id: 'submenu' };
+        },
+      },
+      PredefinedMenuItem: {
+        async new() {
+          state.predefined++;
+          return { id: 'separator' };
+        },
+      },
+    },
+    window: {
+      LogicalPosition: class {
+        constructor(
+          public x: number,
+          public y: number,
+        ) {}
+      },
+    },
+  } as unknown as TauriApi;
+  return { tauri, state };
+}
+
+const template: MenuItemTemplate[] = [
+  { id: 'open', label: 'Open' },
+  { type: 'separator' },
+  { label: 'More', submenu: [{ id: 'nested', label: 'Nested' }] },
+];
+
+describe('createTauriMenuBackend', () => {
+  it('installs an application menu and routes item clicks to the select listener', async () => {
+    const { tauri, state } = fakeTauri();
+    const backend = createTauriMenuBackend(tauri);
+    const selected: string[] = [];
+    backend.subscribeSelect((id) => selected.push(id));
+    expect(backend.setApplicationMenu(template)).toBe(true);
+    // Let the async build + setAsAppMenu settle.
+    await flush();
+    expect(state.appMenuSet).toBe(1);
+    expect(state.predefined).toBe(1);
+    state.actions.get('open')!('open');
+    expect(selected).toEqual(['open']);
+  });
+
+  it('resolves popupContextMenu with the clicked item id', async () => {
+    const { tauri, state } = fakeTauri();
+    const backend = createTauriMenuBackend(tauri);
+    const pending = backend.popupContextMenu([{ id: 'cut', label: 'Cut' }], 10, 20);
+    await flush();
+    expect(state.popups).toBe(1);
+    state.actions.get('cut')!('cut');
+    expect(await pending).toBe('cut');
+  });
+
+  it('resolves popupContextMenu null when the build throws', async () => {
+    const tauri = {
+      menu: {
+        Menu: {
+          async new() {
+            throw new Error('no menu');
+          },
+        },
+        MenuItem: {
+          async new() {
+            return { id: 'x' };
+          },
+        },
+        Submenu: {
+          async new() {
+            return { id: 's' };
+          },
+        },
+        PredefinedMenuItem: {
+          async new() {
+            return { id: 'sep' };
+          },
+        },
+      },
+      window: {
+        LogicalPosition: class {
+          constructor(
+            public x: number,
+            public y: number,
+          ) {}
+        },
+      },
+    } as unknown as TauriApi;
+    expect(await createTauriMenuBackend(tauri).popupContextMenu([{ id: 'a', label: 'A' }], 0, 0)).toBeNull();
+  });
+});
+
+async function flush(): Promise<void> {
+  for (let i = 0; i < 24; i++) await Promise.resolve();
+}

package/src/tauriNotification.test.ts

@@ -0,0 +1,59 @@
+import type { TauriApi, TauriNotificationOptions, TauriNotificationPermission } from './tauriModule';
+import { createTauriNotificationBackend } from './tauriNotification';
+
+function fakeTauri(granted = true, permission: TauriNotificationPermission = 'granted') {
+  const sent: TauriNotificationOptions[] = [];
+  const tauri = {
+    notification: {
+      async isPermissionGranted() {
+        return granted;
+      },
+      async requestPermission() {
+        return permission;
+      },
+      sendNotification(options: TauriNotificationOptions) {
+        sent.push(options);
+      },
+    },
+  } as unknown as TauriApi;
+  return { tauri, sent };
+}
+
+describe('createTauriNotificationBackend', () => {
+  it('sends a notification and resolves the request id', async () => {
+    const { tauri, sent } = fakeTauri();
+    const backend = createTauriNotificationBackend(tauri);
+    const id = await backend.notify({ title: 'Hi', body: 'there', id: 'n1' });
+    expect(id).toBe('n1');
+    expect(sent[0]).toEqual({ title: 'Hi', body: 'there', icon: undefined });
+  });
+
+  it('generates an id when the request omits one', async () => {
+    const backend = createTauriNotificationBackend(fakeTauri().tauri);
+    expect(await backend.notify({ title: 'Hi' })).toMatch(/^notification-/);
+  });
+
+  it('maps requestPermission and then reads it back synchronously', async () => {
+    const backend = createTauriNotificationBackend(fakeTauri(false, 'granted').tauri);
+    expect(await backend.requestPermission()).toBe('granted');
+    expect(backend.getPermission()).toBe('granted');
+  });
+
+  it('reflects the prefetched permission after it resolves', async () => {
+    const backend = createTauriNotificationBackend(fakeTauri(true).tauri);
+    // Let the construction-time isPermissionGranted() prefetch settle.
+    await Promise.resolve();
+    await Promise.resolve();
+    expect(backend.getPermission()).toBe('granted');
+  });
+
+  it('reports conservative capabilities and unsupported-surface sentinels', async () => {
+    const backend = createTauriNotificationBackend(fakeTauri().tauri);
+    expect(backend.isSupported()).toBe(true);
+    expect(backend.getCapabilities().scheduling).toBe(false);
+    expect(await backend.getActiveNotifications()).toEqual([]);
+    expect(await backend.scheduleNotification({ title: 'x' }, { at: 0 })).toBe('');
+    expect(await backend.updateNotification('n1', {})).toBe(false);
+    expect(typeof backend.subscribeClick(() => {})).toBe('function');
+  });
+});

package/src/tauriPlatform.test.ts

@@ -0,0 +1,56 @@
+import type { PlatformInfo } from '@flighthq/types';
+
+import type { TauriApi } from './tauriModule';
+import { createTauriPlatformBackend } from './tauriPlatform';
+
+function fakeTauri(platform: string): TauriApi {
+  return {
+    os: {
+      arch: () => 'aarch64',
+      locale: () => 'en-US',
+      platform: () => platform,
+      version: () => '14.2.1',
+    },
+  } as unknown as TauriApi;
+}
+
+describe('createTauriPlatformBackend', () => {
+  it('fills platform info from the os plugin', () => {
+    const backend = createTauriPlatformBackend(fakeTauri('macos'));
+    const out = {} as PlatformInfo;
+    const result = backend.getInfo(out);
+    expect(result).toBe(out);
+    expect(out.name).toBe('macos');
+    expect(out.kind).toBe('desktop');
+    expect(out.version).toBe('14.2.1');
+    expect(out.arch).toBe('aarch64');
+    expect(out.locale).toBe('en-US');
+    expect(out.isTouch).toBe(false);
+    expect(out.runtime).toBe('tauri');
+  });
+
+  it('maps each known Tauri platform string to a PlatformName', () => {
+    const cases: Record<string, string> = {
+      windows: 'windows',
+      macos: 'macos',
+      linux: 'linux',
+      ios: 'ios',
+      android: 'android',
+      freebsd: 'unknown',
+    };
+    for (const [tauriName, expected] of Object.entries(cases)) {
+      const out = {} as PlatformInfo;
+      createTauriPlatformBackend(fakeTauri(tauriName)).getInfo(out);
+      expect(out.name).toBe(expected);
+    }
+  });
+
+  it('falls back to empty locale when the os plugin reports null', () => {
+    const tauri = {
+      os: { arch: () => '', locale: () => null, platform: () => 'linux', version: () => '' },
+    } as unknown as TauriApi;
+    const out = {} as PlatformInfo;
+    createTauriPlatformBackend(tauri).getInfo(out);
+    expect(out.locale).toBe('');
+  });
+});

package/src/tauriRegister.test.ts

@@ -0,0 +1,67 @@
+import { setAppBackend } from '@flighthq/app';
+import { setWindowBackend } from '@flighthq/application';
+import { readClipboardText, setClipboardBackend } from '@flighthq/clipboard';
+import { setDialogBackend } from '@flighthq/dialog';
+import { setMenuBackend } from '@flighthq/menu';
+import { setNotificationBackend } from '@flighthq/notification';
+import { getPlatformName, setPlatformBackend } from '@flighthq/platform';
+import { setShellBackend } from '@flighthq/shell';
+import { setShortcutBackend } from '@flighthq/shortcut';
+import { setTrayBackend } from '@flighthq/tray';
+
+import type { TauriApi } from './tauriModule';
+import { registerTauriBackends } from './tauriRegister';
+
+// A fake Tauri API broad enough that every createTauri*Backend constructs without touching missing
+// members. Backends close over `tauri` and only call in when their methods run (plus the app/
+// notification prefetches), so a thin fake proves registration routes the seams to the Tauri backends.
+function fakeTauri(): TauriApi {
+  const asyncNoop = async () => {};
+  return {
+    app: {
+      getName: async () => 'FlightApp',
+      getVersion: async () => '1.0.0',
+      hide: asyncNoop,
+      show: asyncNoop,
+    },
+    clipboard: {
+      readText: async () => 'TAURI-TEXT',
+      writeText: asyncNoop,
+      clear: asyncNoop,
+    },
+    dialog: {},
+    globalShortcut: {},
+    menu: {},
+    notification: {
+      isPermissionGranted: async () => true,
+      requestPermission: async () => 'granted',
+      sendNotification: () => {},
+    },
+    opener: {},
+    os: { arch: () => 'x86_64', locale: () => 'en-US', platform: () => 'linux', version: () => '' },
+    process: {},
+    tray: {},
+    window: { getCurrentWindow: () => ({}), LogicalPosition: class {}, LogicalSize: class {} },
+  } as unknown as TauriApi;
+}
+
+afterEach(() => {
+  setPlatformBackend(null);
+  setAppBackend(null);
+  setWindowBackend(null);
+  setDialogBackend(null);
+  setClipboardBackend(null);
+  setMenuBackend(null);
+  setTrayBackend(null);
+  setShortcutBackend(null);
+  setNotificationBackend(null);
+  setShellBackend(null);
+});
+
+describe('registerTauriBackends', () => {
+  it('routes capability seams to the Tauri backends without throwing', async () => {
+    registerTauriBackends(fakeTauri());
+    expect(getPlatformName()).toBe('linux');
+    expect(await readClipboardText()).toBe('TAURI-TEXT');
+  });
+});

package/src/tauriShell.test.ts

@@ -0,0 +1,63 @@
+import type { TauriApi } from './tauriModule';
+import { createTauriShellBackend } from './tauriShell';
+
+function fakeTauri(reject = false) {
+  const calls: { openUrl: string[]; openPath: string[]; reveal: string[] } = {
+    openUrl: [],
+    openPath: [],
+    reveal: [],
+  };
+  const guard = async () => {
+    if (reject) throw new Error('boom');
+  };
+  const tauri = {
+    opener: {
+      async openUrl(url: string) {
+        calls.openUrl.push(url);
+        await guard();
+      },
+      async openPath(path: string) {
+        calls.openPath.push(path);
+        await guard();
+      },
+      async revealItemInDir(path: string) {
+        calls.reveal.push(path);
+        await guard();
+      },
+    },
+  } as unknown as TauriApi;
+  return { tauri, calls };
+}
+
+describe('createTauriShellBackend', () => {
+  it('opens URLs and paths through the opener plugin', async () => {
+    const { tauri, calls } = fakeTauri();
+    const backend = createTauriShellBackend(tauri);
+    expect(await backend.openExternal('https://x.test')).toBe(true);
+    expect(await backend.openPath('/tmp/a')).toBe(true);
+    expect(await backend.showItemInFolder('/tmp/a')).toBe(true);
+    expect(calls.openUrl).toEqual(['https://x.test']);
+    expect(calls.openPath).toEqual(['/tmp/a']);
+    expect(calls.reveal).toEqual(['/tmp/a']);
+  });
+
+  it('reports the error message from openPathResult', async () => {
+    expect(await createTauriShellBackend(fakeTauri().tauri).openPathResult('/tmp/a')).toBe('');
+    expect(await createTauriShellBackend(fakeTauri(true).tauri).openPathResult('/tmp/a')).toBe('boom');
+  });
+
+  it('resolves false when the opener rejects', async () => {
+    const backend = createTauriShellBackend(fakeTauri(true).tauri);
+    expect(await backend.openExternal('https://x.test')).toBe(false);
+    expect(await backend.showItemInFolder('/tmp/a')).toBe(false);
+  });
+
+  it('reports sentinels for trash, shortcut links, and beep', async () => {
+    const backend = createTauriShellBackend(fakeTauri().tauri);
+    expect(await backend.moveToTrash('/tmp/a')).toBe(false);
+    expect(await backend.moveItemsToTrash(['/a', '/b'])).toEqual([false, false]);
+    expect(await backend.readShortcutLink('/a.lnk')).toBeNull();
+    expect(await backend.writeShortcutLink('/a.lnk', { target: '/t' })).toBe(false);
+    expect(() => backend.beep()).not.toThrow();
+  });
+});

package/src/tauriShortcut.test.ts

@@ -0,0 +1,77 @@
+import type { TauriApi, TauriShortcutEvent } from './tauriModule';
+import { createTauriShortcutBackend } from './tauriShortcut';
+
+function fakeTauri() {
+  const handlers = new Map<string, (event: Readonly<TauriShortcutEvent>) => void>();
+  const calls: { register: string[]; unregister: string[]; unregisterAll: number } = {
+    register: [],
+    unregister: [],
+    unregisterAll: 0,
+  };
+  const tauri = {
+    globalShortcut: {
+      async register(shortcut: string, handler: (event: Readonly<TauriShortcutEvent>) => void) {
+        calls.register.push(shortcut);
+        handlers.set(shortcut, handler);
+      },
+      async unregister(shortcut: string) {
+        calls.unregister.push(shortcut);
+        handlers.delete(shortcut);
+      },
+      async unregisterAll() {
+        calls.unregisterAll++;
+        handlers.clear();
+      },
+      async isRegistered(shortcut: string) {
+        return handlers.has(shortcut);
+      },
+    },
+  } as unknown as TauriApi;
+  return { tauri, handlers, calls };
+}
+
+describe('createTauriShortcutBackend', () => {
+  it('optimistically mirrors registrations synchronously', () => {
+    const { tauri, calls } = fakeTauri();
+    const backend = createTauriShortcutBackend(tauri);
+    expect(backend.register('CmdOrCtrl+K', () => {})).toBe(true);
+    expect(backend.isRegistered('CmdOrCtrl+K')).toBe(true);
+    expect(backend.getRegistered()).toEqual(['CmdOrCtrl+K']);
+    expect(calls.register).toEqual(['CmdOrCtrl+K']);
+  });
+
+  it('delivers a ShortcutEvent only on the Pressed state', async () => {
+    const { tauri, handlers } = fakeTauri();
+    const backend = createTauriShortcutBackend(tauri);
+    let fired = 0;
+    let seen = '';
+    backend.register('Alt+P', (event) => {
+      fired++;
+      seen = event.accelerator;
+    });
+    await Promise.resolve();
+    const handler = handlers.get('Alt+P')!;
+    handler({ shortcut: 'Alt+P', state: 'Released' });
+    handler({ shortcut: 'Alt+P', state: 'Pressed' });
+    expect(fired).toBe(1);
+    expect(seen).toBe('Alt+P');
+  });
+
+  it('unregisters individually and en masse', () => {
+    const { tauri, calls } = fakeTauri();
+    const backend = createTauriShortcutBackend(tauri);
+    backend.register('A', () => {});
+    backend.register('B', () => {});
+    expect(backend.unregister('A')).toBe(true);
+    expect(backend.isRegistered('A')).toBe(false);
+    backend.unregisterAll();
+    expect(backend.getRegistered()).toEqual([]);
+    expect(calls.unregisterAll).toBe(1);
+  });
+
+  it('reports the enable-toggle sentinels', () => {
+    const backend = createTauriShortcutBackend(fakeTauri().tauri);
+    expect(backend.setEnabled('A', true)).toBe(false);
+    expect(() => backend.setAllEnabled(true)).not.toThrow();
+  });
+});

package/src/tauriTray.test.ts

@@ -0,0 +1,123 @@
+import type { TauriApi, TauriTrayIconEvent, TauriTrayIconOptions } from './tauriModule';
+import { createTauriTrayBackend } from './tauriTray';
+
+function fakeTauri() {
+  const state = {
+    created: 0,
+    closed: 0,
+    lastTitle: '' as string | null,
+    lastIcon: '' as string | null,
+    menusSet: 0,
+    // The action callback the most recently created tray registered.
+    action: null as ((event: Readonly<TauriTrayIconEvent>) => void) | null,
+  };
+  const tauri = {
+    tray: {
+      TrayIcon: {
+        async new(options?: TauriTrayIconOptions) {
+          state.created++;
+          state.action = options?.action ?? null;
+          return {
+            async setIcon(icon: string | null) {
+              state.lastIcon = icon;
+            },
+            async setTitle(title: string | null) {
+              state.lastTitle = title;
+            },
+            async setTooltip() {},
+            async setMenu() {
+              state.menusSet++;
+            },
+            async close() {
+              state.closed++;
+            },
+          };
+        },
+      },
+    },
+    menu: {
+      Menu: {
+        async new() {
+          return { async setAsAppMenu() {}, async popup() {} };
+        },
+      },
+      MenuItem: {
+        async new(o?: { id?: string }) {
+          return { id: o?.id ?? '' };
+        },
+      },
+      Submenu: {
+        async new() {
+          return { id: 's' };
+        },
+      },
+      PredefinedMenuItem: {
+        async new() {
+          return { id: 'sep' };
+        },
+      },
+    },
+  } as unknown as TauriApi;
+  return { tauri, state };
+}
+
+async function flush(): Promise<void> {
+  for (let i = 0; i < 24; i++) await Promise.resolve();
+}
+
+describe('createTauriTrayBackend', () => {
+  it('allocates a numeric id synchronously and builds the tray asynchronously', async () => {
+    const { tauri, state } = fakeTauri();
+    const backend = createTauriTrayBackend(tauri);
+    const id = backend.create({ title: 'Flight', tooltip: 'tip' });
+    expect(typeof id).toBe('number');
+    expect(backend.getTitle(id)).toBe('Flight');
+    expect(backend.getTooltip(id)).toBe('tip');
+    expect(backend.listIds()).toContain(id);
+    await flush();
+    expect(state.created).toBe(1);
+  });
+
+  it('forwards clicks as tray events, discriminating left/right', async () => {
+    const { tauri, state } = fakeTauri();
+    const backend = createTauriTrayBackend(tauri);
+    const events: string[] = [];
+    backend.subscribe((event) => events.push(event.type));
+    const id = backend.create({});
+    await flush();
+    state.action!({ type: 'Click', button: 'Left' });
+    state.action!({ type: 'Click', button: 'Right' });
+    state.action!({ type: 'DoubleClick' });
+    state.action!({ type: 'Enter' });
+    expect(events).toEqual(['click', 'rightClick', 'doubleClick']);
+    expect(id).toBeGreaterThanOrEqual(0);
+  });
+
+  it('applies title/icon changes and a context menu to the resolved handle', async () => {
+    const { tauri, state } = fakeTauri();
+    const backend = createTauriTrayBackend(tauri);
+    const id = backend.create({});
+    await flush();
+    backend.setTitle(id, 'New');
+    backend.setIcon(id, '/icon.png');
+    backend.setContextMenu(id, [{ id: 'a', label: 'A' }, { type: 'separator' }]);
+    await flush();
+    expect(state.lastTitle).toBe('New');
+    expect(state.lastIcon).toBe('/icon.png');
+    expect(state.menusSet).toBe(1);
+    expect(backend.getTitle(id)).toBe('New');
+  });
+
+  it('destroys the tray and reports sentinels for unsupported surface', async () => {
+    const { tauri, state } = fakeTauri();
+    const backend = createTauriTrayBackend(tauri);
+    const id = backend.create({});
+    await flush();
+    expect(backend.getBounds(id)).toBeNull();
+    expect(backend.getCapabilities().balloon).toBe(false);
+    backend.destroy(id);
+    await flush();
+    expect(state.closed).toBe(1);
+    expect(backend.isDestroyed(id)).toBe(true);
+  });
+});