@flighthq/host-electron 0.1.0

package/src/electronScreen.test.ts

@@ -0,0 +1,92 @@
+import type { ScreenInfo } from '@flighthq/types';
+
+import type { ElectronApi, ElectronDisplay } from './electronModule';
+import { createElectronScreenBackend } from './electronScreen';
+
+function display(id: number, x: number): ElectronDisplay {
+  return {
+    id,
+    bounds: { x, y: 0, width: 1920, height: 1080 },
+    workArea: { x, y: 0, width: 1920, height: 1040 },
+    scaleFactor: 2,
+  };
+}
+
+function fakeElectron(): {
+  electron: ElectronApi;
+  listeners: Map<string, (() => void)[]>;
+} {
+  const listeners = new Map<string, (() => void)[]>();
+  const primary = display(1, 0);
+  const secondary = display(2, 1920);
+  const electron = {
+    screen: {
+      getPrimaryDisplay: () => primary,
+      getAllDisplays: () => [primary, secondary],
+      on: (event: string, listener: () => void) => {
+        const list = listeners.get(event) ?? [];
+        list.push(listener);
+        listeners.set(event, list);
+      },
+      removeListener: (event: string, listener: () => void) => {
+        const list = listeners.get(event) ?? [];
+        listeners.set(
+          event,
+          list.filter((l) => l !== listener),
+        );
+      },
+    },
+  } as unknown as ElectronApi;
+  return { electron, listeners };
+}
+
+describe('createElectronScreenBackend', () => {
+  it('fills the primary screen into out', () => {
+    const { electron } = fakeElectron();
+    const backend = createElectronScreenBackend(electron);
+    const out = {} as ScreenInfo;
+    const result = backend.getPrimaryScreen(out);
+    expect(result).toBe(out);
+    expect(out).toEqual({
+      id: 1,
+      x: 0,
+      y: 0,
+      width: 1920,
+      height: 1080,
+      workWidth: 1920,
+      workHeight: 1040,
+      scaleFactor: 2,
+      isPrimary: true,
+    });
+  });
+
+  it('enumerates all screens marking the primary', () => {
+    const { electron } = fakeElectron();
+    const backend = createElectronScreenBackend(electron);
+    const out: ScreenInfo[] = [];
+    backend.getScreens(out);
+    expect(out).toHaveLength(2);
+    expect(out[0].id).toBe(1);
+    expect(out[0].isPrimary).toBe(true);
+    expect(out[1].id).toBe(2);
+    expect(out[1].isPrimary).toBe(false);
+    expect(out[1].x).toBe(1920);
+  });
+
+  it('subscribes to all change events and unsubscribes from all', () => {
+    const fake = fakeElectron();
+    const backend = createElectronScreenBackend(fake.electron);
+    let count = 0;
+    const off = backend.subscribe(() => {
+      count++;
+    });
+    for (const event of ['display-added', 'display-removed', 'display-metrics-changed']) {
+      for (const l of fake.listeners.get(event) ?? []) l();
+    }
+    expect(count).toBe(3);
+    off();
+    expect(fake.listeners.get('display-added')).toHaveLength(0);
+    expect(fake.listeners.get('display-removed')).toHaveLength(0);
+    expect(fake.listeners.get('display-metrics-changed')).toHaveLength(0);
+  });
+});

package/src/electronShell.test.ts

@@ -0,0 +1,67 @@
+import type { ElectronApi } from './electronModule';
+import { createElectronShellBackend } from './electronShell';
+
+function fakeElectron(shell: Partial<ElectronApi['shell']>): ElectronApi {
+  return { shell } as unknown as ElectronApi;
+}
+
+describe('createElectronShellBackend', () => {
+  it('openExternal returns true on success and false on throw', async () => {
+    const ok = createElectronShellBackend(fakeElectron({ openExternal: async () => {} }));
+    expect(await ok.openExternal('https://example.test')).toBe(true);
+    const bad = createElectronShellBackend(
+      fakeElectron({
+        openExternal: async () => {
+          throw new Error('no');
+        },
+      }),
+    );
+    expect(await bad.openExternal('https://example.test')).toBe(false);
+  });
+
+  it('openPath maps the empty-string success convention to true', async () => {
+    const ok = createElectronShellBackend(fakeElectron({ openPath: async () => '' }));
+    expect(await ok.openPath('/a')).toBe(true);
+    const err = createElectronShellBackend(fakeElectron({ openPath: async () => 'no such file' }));
+    expect(await err.openPath('/a')).toBe(false);
+  });
+
+  it('showItemInFolder returns true after revealing the path', async () => {
+    let revealed = '';
+    const backend = createElectronShellBackend(
+      fakeElectron({
+        showItemInFolder: (path: string) => {
+          revealed = path;
+        },
+      }),
+    );
+    expect(await backend.showItemInFolder('/a/b')).toBe(true);
+    expect(revealed).toBe('/a/b');
+  });
+
+  it('moveToTrash returns true on success and false on throw', async () => {
+    const ok = createElectronShellBackend(fakeElectron({ trashItem: async () => {} }));
+    expect(await ok.moveToTrash('/a')).toBe(true);
+    const bad = createElectronShellBackend(
+      fakeElectron({
+        trashItem: async () => {
+          throw new Error('no');
+        },
+      }),
+    );
+    expect(await bad.moveToTrash('/a')).toBe(false);
+  });
+
+  it('beep delegates to the shell', () => {
+    let beeped = false;
+    const backend = createElectronShellBackend(
+      fakeElectron({
+        beep: () => {
+          beeped = true;
+        },
+      }),
+    );
+    backend.beep();
+    expect(beeped).toBe(true);
+  });
+});

package/src/electronShortcut.test.ts

@@ -0,0 +1,56 @@
+import type { ElectronApi } from './electronModule';
+import { createElectronShortcutBackend } from './electronShortcut';
+
+function fakeElectron(): { electron: ElectronApi; registered: Map<string, () => void> } {
+  const registered = new Map<string, () => void>();
+  const electron = {
+    globalShortcut: {
+      register: (accelerator: string, callback: () => void) => {
+        registered.set(accelerator, callback);
+        return true;
+      },
+      unregister: (accelerator: string) => {
+        registered.delete(accelerator);
+      },
+      unregisterAll: () => {
+        registered.clear();
+      },
+      isRegistered: (accelerator: string) => registered.has(accelerator),
+    },
+  } as unknown as ElectronApi;
+  return { electron, registered };
+}
+
+describe('createElectronShortcutBackend', () => {
+  it('registers and reports a shortcut, invoking its listener', () => {
+    const fake = fakeElectron();
+    const backend = createElectronShortcutBackend(fake.electron);
+    let fired = 0;
+    expect(
+      backend.register('CommandOrControl+X', () => {
+        fired++;
+      }),
+    ).toBe(true);
+    expect(backend.isRegistered('CommandOrControl+X')).toBe(true);
+    fake.registered.get('CommandOrControl+X')?.();
+    expect(fired).toBe(1);
+  });
+
+  it('unregisters one shortcut, returning true', () => {
+    const fake = fakeElectron();
+    const backend = createElectronShortcutBackend(fake.electron);
+    backend.register('Ctrl+A', () => {});
+    expect(backend.unregister('Ctrl+A')).toBe(true);
+    expect(backend.isRegistered('Ctrl+A')).toBe(false);
+  });
+
+  it('unregisters all shortcuts', () => {
+    const fake = fakeElectron();
+    const backend = createElectronShortcutBackend(fake.electron);
+    backend.register('Ctrl+A', () => {});
+    backend.register('Ctrl+B', () => {});
+    backend.unregisterAll();
+    expect(backend.isRegistered('Ctrl+A')).toBe(false);
+    expect(backend.isRegistered('Ctrl+B')).toBe(false);
+  });
+});

package/src/electronStorage.test.ts

@@ -0,0 +1,70 @@
+import type { ElectronApi } from './electronModule';
+import { createElectronStorageBackend } from './electronStorage';
+
+function fakeElectron(initial?: Record<string, string>): {
+  electron: ElectronApi;
+  written: string[];
+} {
+  const written: string[] = [];
+  let fileContent: string | null = initial !== undefined ? JSON.stringify(initial) : null;
+  const fs = {
+    existsSync: () => fileContent !== null,
+    readFileSync: () => fileContent ?? '',
+    writeFileSync: (_path: string, data: string) => {
+      fileContent = data;
+      written.push(data);
+    },
+  };
+  const electron = {
+    app: { getPath: () => '/userData' },
+    fs,
+  } as unknown as ElectronApi;
+  return { electron, written };
+}
+
+describe('createElectronStorageBackend', () => {
+  it('clear removes all keys and persists', () => {
+    const { electron } = fakeElectron({ a: '1' });
+    const backend = createElectronStorageBackend(electron);
+    expect(backend.getItem('a')).toBe('1');
+    backend.clear();
+    expect(backend.getItem('a')).toBeNull();
+    expect(backend.keys()).toEqual([]);
+  });
+
+  it('getItem returns null for a missing key', () => {
+    const { electron } = fakeElectron({});
+    const backend = createElectronStorageBackend(electron);
+    expect(backend.getItem('missing')).toBeNull();
+  });
+
+  it('keys returns all stored keys', () => {
+    const { electron } = fakeElectron({ x: '1', y: '2' });
+    const backend = createElectronStorageBackend(electron);
+    expect(backend.keys().sort()).toEqual(['x', 'y']);
+  });
+
+  it('removeItem deletes a key and returns false for an unknown key', () => {
+    const { electron } = fakeElectron({ a: 'v' });
+    const backend = createElectronStorageBackend(electron);
+    expect(backend.removeItem('a')).toBe(true);
+    expect(backend.getItem('a')).toBeNull();
+    expect(backend.removeItem('a')).toBe(false);
+  });
+
+  it('setItem stores a value and persists it to disk', () => {
+    const { electron, written } = fakeElectron();
+    const backend = createElectronStorageBackend(electron);
+    expect(backend.setItem('k', 'v')).toBe(true);
+    expect(backend.getItem('k')).toBe('v');
+    expect(written.length).toBeGreaterThan(0);
+    expect(JSON.parse(written[written.length - 1])).toEqual({ k: 'v' });
+  });
+
+  it('starts fresh when the file does not exist', () => {
+    const { electron } = fakeElectron();
+    const backend = createElectronStorageBackend(electron);
+    expect(backend.keys()).toEqual([]);
+    expect(backend.getItem('any')).toBeNull();
+  });
+});

package/src/electronTray.test.ts

@@ -0,0 +1,107 @@
+import type { TrayEventType } from '@flighthq/types';
+
+import type { ElectronApi, ElectronMenu, ElectronMenuItemOptions, ElectronTray } from './electronModule';
+import { createElectronTrayBackend } from './electronTray';
+
+interface FakeTray extends ElectronTray {
+  icon: string;
+  tooltip: string;
+  title: string;
+  contextMenu: ElectronMenu | null;
+  destroyed: boolean;
+  handlers: Record<string, () => void>;
+}
+
+function fakeElectron(): {
+  electron: ElectronApi;
+  trays: FakeTray[];
+  built: ElectronMenuItemOptions[][];
+} {
+  const trays: FakeTray[] = [];
+  const built: ElectronMenuItemOptions[][] = [];
+  const electron = {
+    Tray: function (this: FakeTray, icon: string) {
+      this.icon = icon;
+      this.tooltip = '';
+      this.title = '';
+      this.contextMenu = null;
+      this.destroyed = false;
+      this.handlers = {};
+      this.setToolTip = (t: string) => {
+        this.tooltip = t;
+      };
+      this.setTitle = (t: string) => {
+        this.title = t;
+      };
+      this.setContextMenu = (menu: ElectronMenu | null) => {
+        this.contextMenu = menu;
+      };
+      this.on = (event: string, listener: () => void) => {
+        this.handlers[event] = listener;
+      };
+      this.destroy = () => {
+        this.destroyed = true;
+      };
+      trays.push(this);
+    },
+    Menu: {
+      buildFromTemplate: (template: ElectronMenuItemOptions[]) => {
+        built.push(template);
+        return { template } as unknown as ElectronMenu;
+      },
+    },
+  } as unknown as ElectronApi;
+  return { electron, trays, built };
+}
+
+describe('createElectronTrayBackend', () => {
+  it('creates a tray with icon, tooltip, and title and returns a numeric id', () => {
+    const { electron, trays } = fakeElectron();
+    const backend = createElectronTrayBackend(electron);
+    const id = backend.create({ icon: 'i.png', tooltip: 'hello', title: 'T' });
+    expect(typeof id).toBe('number');
+    expect(trays[0].icon).toBe('i.png');
+    expect(trays[0].tooltip).toBe('hello');
+    expect(trays[0].title).toBe('T');
+  });
+
+  it('destroys a tray and ignores unknown ids', () => {
+    const { electron, trays } = fakeElectron();
+    const backend = createElectronTrayBackend(electron);
+    const id = backend.create({});
+    backend.destroy(id);
+    expect(trays[0].destroyed).toBe(true);
+    expect(() => backend.destroy(999)).not.toThrow();
+  });
+
+  it('updates tooltip, title, and context menu', () => {
+    const { electron, trays, built } = fakeElectron();
+    const backend = createElectronTrayBackend(electron);
+    const id = backend.create({});
+    backend.setTooltip(id, 'tip');
+    backend.setTitle(id, 'name');
+    backend.setContextMenu(id, [{ id: 'x', label: 'X' }]);
+    expect(trays[0].tooltip).toBe('tip');
+    expect(trays[0].title).toBe('name');
+    expect(trays[0].contextMenu).not.toBeNull();
+    expect(built[built.length - 1][0].id).toBe('x');
+  });
+
+  it('forwards click events to the subscribed listener and stops after unsubscribe', () => {
+    const { electron, trays } = fakeElectron();
+    const backend = createElectronTrayBackend(electron);
+    const id = backend.create({});
+    const events: [number, TrayEventType][] = [];
+    const unsubscribe = backend.subscribe((event) => events.push([event.id, event.type]));
+    trays[0].handlers['click']();
+    trays[0].handlers['right-click']();
+    trays[0].handlers['double-click']();
+    unsubscribe();
+    trays[0].handlers['click']();
+    expect(events).toEqual([
+      [id, 'click'],
+      [id, 'rightClick'],
+      [id, 'doubleClick'],
+    ]);
+  });
+});

package/src/electronUpdater.test.ts

@@ -0,0 +1,117 @@
+import type { ElectronApi } from './electronModule';
+import { createElectronUpdaterBackend } from './electronUpdater';
+
+function fakeElectron(): {
+  electron: ElectronApi;
+  listeners: Map<string, Set<(...args: unknown[]) => void>>;
+  calls: { feedUrl?: string; checks: number; quit: number };
+} {
+  const listeners = new Map<string, Set<(...args: unknown[]) => void>>();
+  const calls = { feedUrl: undefined as string | undefined, checks: 0, quit: 0 };
+  const electron = {
+    autoUpdater: {
+      setFeedUrl: (options: { url: string }) => {
+        calls.feedUrl = options.url;
+      },
+      checkForUpdates: () => {
+        calls.checks++;
+      },
+      quitAndInstall: () => {
+        calls.quit++;
+      },
+      on: (event: string, listener: (...args: unknown[]) => void) => {
+        if (!listeners.has(event)) listeners.set(event, new Set());
+        listeners.get(event)?.add(listener);
+      },
+      removeListener: (event: string, listener: (...args: unknown[]) => void) => {
+        listeners.get(event)?.delete(listener);
+      },
+    },
+  } as unknown as ElectronApi;
+  return { electron, listeners, calls };
+}
+
+function emit(listeners: Map<string, Set<(...args: unknown[]) => void>>, event: string, ...args: unknown[]): void {
+  for (const listener of listeners.get(event) ?? []) listener(...args);
+}
+
+describe('createElectronUpdaterBackend', () => {
+  it('drives feed URL, checks, auto-download, and quit commands', () => {
+    const { electron, calls } = fakeElectron();
+    const backend = createElectronUpdaterBackend(electron);
+    backend.setFeedUrl('https://feed.test');
+    expect(calls.feedUrl).toBe('https://feed.test');
+    backend.checkForUpdates();
+    backend.downloadUpdate();
+    expect(calls.checks).toBe(2);
+    backend.quitAndInstall();
+    expect(calls.quit).toBe(1);
+  });
+
+  it('subscribeChecking and subscribeUpdateNotAvailable forward bare events', () => {
+    const { electron, listeners } = fakeElectron();
+    const backend = createElectronUpdaterBackend(electron);
+    let checking = 0;
+    let notAvailable = 0;
+    const unsubA = backend.subscribeChecking(() => checking++);
+    const unsubB = backend.subscribeUpdateNotAvailable(() => notAvailable++);
+    emit(listeners, 'checking-for-update');
+    emit(listeners, 'update-not-available');
+    expect(checking).toBe(1);
+    expect(notAvailable).toBe(1);
+    unsubA();
+    unsubB();
+    emit(listeners, 'checking-for-update');
+    expect(checking).toBe(1);
+  });
+
+  it('maps update-available and update-downloaded args into UpdateInfo', () => {
+    const { electron, listeners } = fakeElectron();
+    const backend = createElectronUpdaterBackend(electron);
+    let available: unknown;
+    let downloaded: unknown;
+    backend.subscribeUpdateAvailable((info) => (available = info));
+    backend.subscribeUpdateDownloaded((info) => (downloaded = info));
+    emit(listeners, 'update-available', {}, 'release notes', '1.2.3', '2026-01-01');
+    emit(listeners, 'update-downloaded', {}, 'dl notes', '4.5.6', '2026-02-02');
+    expect(available).toEqual({
+      version: '1.2.3',
+      notes: 'release notes',
+      releaseDate: '2026-01-01',
+      deltaFromVersion: null,
+      downloadSizeBytes: -1,
+      isMandatory: false,
+      minimumOsVersion: null,
+      sha512: '',
+      stagedRolloutPercent: 100,
+    });
+    expect(downloaded).toEqual({
+      version: '4.5.6',
+      notes: 'dl notes',
+      releaseDate: '2026-02-02',
+      deltaFromVersion: null,
+      downloadSizeBytes: -1,
+      isMandatory: false,
+      minimumOsVersion: null,
+      sha512: '',
+      stagedRolloutPercent: 100,
+    });
+  });
+
+  it('subscribeDownloadProgress is inert for the built-in updater', () => {
+    const { electron, listeners } = fakeElectron();
+    const backend = createElectronUpdaterBackend(electron);
+    const unsubscribe = backend.subscribeDownloadProgress(() => {});
+    expect(listeners.has('download-progress')).toBe(false);
+    expect(() => unsubscribe()).not.toThrow();
+  });
+
+  it('subscribeError wraps the error payload message into an UpdaterError', () => {
+    const { electron, listeners } = fakeElectron();
+    const backend = createElectronUpdaterBackend(electron);
+    let message = '';
+    backend.subscribeError((error) => (message = error.message));
+    emit(listeners, 'error', new Error('boom'));
+    expect(message).toBe('boom');
+  });
+});