@flighthq/host-electron 0.5.1-next.920.da8f530 → 0.6.0

package/src/electronApp.test.ts

@@ -1,38 +1,36 @@
-import type { ElectronApi, ElectronMenu, ElectronMenuItemOptions } from '@flighthq/types/contract';
-import { EntityRuntimeKey } from '@flighthq/types/contract';
 import { describe, expect, it, vi } from 'vitest';
 
 import {
-  createElectronAppCapabilities,
-  initializeAppActivateBackend,
-  initializeAppActivationPolicyBackend,
-  initializeAppAllWindowsClosedBackend,
-  initializeAppBadgeBackend,
-  initializeAppDockBackend,
-  initializeAppFocusBackend,
-  initializeAppHideBackend,
-  initializeAppLocaleBackend,
-  initializeAppLoginItemBackend,
-  initializeAppNameBackend,
-  initializeAppNameWriteBackend,
-  initializeAppOpenFileBackend,
-  initializeAppPathBackend,
-  initializeAppQuitBackend,
-  initializeAppQuitRequestBackend,
-  initializeAppReadyBackend,
-  initializeAppRecentDocumentsBackend,
-  initializeAppRelaunchBackend,
-  initializeAppSecondInstanceBackend,
-  initializeAppShowBackend,
-  initializeAppSingleInstanceBackend,
-  initializeAppUserModelIdBackend,
-  initializeAppVersionBackend,
-  initializeAppVisibilityQueryBackend,
-  initializeElectronCommonAppCapabilities,
-  initializeElectronLinuxAppCapabilities,
-  initializeElectronMacosAppCapabilities,
-  initializeElectronWindowsAppCapabilities,
-} from './electronApp';
+  electronHostApp,
+  populateElectronHostAppActivate,
+  populateElectronHostAppActivationPolicy,
+  populateElectronHostAppAllWindowsClosed,
+  populateElectronHostAppBadge,
+  populateElectronHostAppDock,
+  populateElectronHostAppFocus,
+  populateElectronHostAppHide,
+  populateElectronHostAppLocale,
+  populateElectronHostAppLoginItem,
+  populateElectronHostAppName,
+  populateElectronHostAppNameWrite,
+  populateElectronHostAppOpenFile,
+  populateElectronHostAppPath,
+  populateElectronHostAppQuit,
+  populateElectronHostAppQuitRequest,
+  populateElectronHostAppReady,
+  populateElectronHostAppRecentDocuments,
+  populateElectronHostAppRelaunch,
+  populateElectronHostAppSecondInstance,
+  populateElectronHostAppShow,
+  populateElectronHostAppSingleInstance,
+  populateElectronHostAppUserModelId,
+  populateElectronHostAppVersion,
+  populateElectronHostAppCommon,
+  populateElectronHostAppLinux,
+  populateElectronHostAppMacos,
+  populateElectronHostAppWindows,
+} from './electronApp.ts';
+import type { ElectronApi, ElectronMenu, ElectronMenuItemOptions } from './types/index.ts';
 
 function fakeElectron() {
   const calls: string[] = [];
@@ -99,12 +97,19 @@ function fakeElectron() {
   };
 }
 
-describe('createElectronAppCapabilities', () => {
+function appLeaf(profile: 'linux' | 'macos' | 'windows', slot: string): () => void {
+  return () => {
+    it('constructs an Entity-backed provider in the application group', () => {
+      const app = electronHostApp(fakeElectron().electron, profile) as unknown as Record<string, object>;
+    });
+  };
+}
+
+describe('electronHostApp', () => {
   it('publishes common application identity, control, and event slots on every profile', async () => {
     const fake = fakeElectron();
-    const app = createElectronAppCapabilities(fake.electron, 'linux');
-    expect(EntityRuntimeKey in app).toBe(true);
-    expect(Object.keys(app).sort()).toEqual([
+    const app = electronHostApp(fake.electron, 'linux');
+    const common = [
       'allWindowsClosed',
       'badge',
       'focus',
@@ -119,20 +124,24 @@ describe('createElectronAppCapabilities', () => {
       'secondInstance',
       'singleInstance',
       'version',
-    ]);
+    ];
+    const profileOnly = [
+      ...Object.keys(electronHostApp(fakeElectron().electron, 'macos')),
+      ...Object.keys(electronHostApp(fakeElectron().electron, 'windows')),
+    ].filter((slot) => !common.includes(slot));
+    expect(Object.keys(app)).toEqual(expect.arrayContaining(common));
+    expect(Object.keys(app).filter((slot) => profileOnly.includes(slot))).toEqual([]);
     expect(app.name.getName()).toBe('Flight');
     expect(app.version.getVersion()).toBe('1.2.3');
     expect(app.locale.getPreferredSystemLanguages()).toEqual(['en-US', 'fr']);
     expect(app.path.getAppDirectoryPath('logs')).toBe('/path/logs');
     expect(app.singleInstance.requestSingleInstanceLock()).toBe(true);
     await expect(app.badge.setBadgeCount(2)).resolves.toBe(true);
-    for (const provider of Object.values(app)) expect(EntityRuntimeKey in provider).toBe(true);
   });
 
-  it('publishes macOS-only dock, visibility, login, open-file, and activation slots', () => {
+  it('publishes macOS-only dock, login, open-file, and activation slots', () => {
     const fake = fakeElectron();
-    const app = createElectronAppCapabilities(fake.electron, 'macos');
-    expect(app.hiddenQuery.isAppHidden()).toBe(true);
+    const app = electronHostApp(fake.electron, 'macos');
     app.dock.setDockMenu([{ id: 'a', label: 'A', submenu: [{ id: 'b', label: 'B' }] }]);
     expect(fake.dockMenuTemplate?.[0]?.submenu).toHaveLength(1);
     expect(app.dock.requestAttention(true)).toBe(7);
@@ -146,7 +155,7 @@ describe('createElectronAppCapabilities', () => {
 
   it('publishes Windows login, recent-document, and app-user-model slots', () => {
     const fake = fakeElectron();
-    const app = createElectronAppCapabilities(fake.electron, 'windows');
+    const app = electronHostApp(fake.electron, 'windows');
     app.recentDocuments.addRecentDocument('/tmp/a');
     app.userModelId.setUserModelId('flight.app');
     expect(fake.calls).toEqual(['recent:/tmp/a', 'userModel:flight.app']);
@@ -155,7 +164,7 @@ describe('createElectronAppCapabilities', () => {
 
   it('adapts quit-veto and second-instance event arguments', () => {
     const fake = fakeElectron();
-    const app = createElectronAppCapabilities(fake.electron, 'linux');
+    const app = electronHostApp(fake.electron, 'linux');
     const preventDefault = vi.fn();
     const cancel = vi.fn((cancelHost: () => void) => cancelHost());
     let argv: readonly string[] = [];
@@ -171,173 +180,191 @@ describe('createElectronAppCapabilities', () => {
   it('rejects a macOS facade whose dock API is absent', () => {
     const electron = fakeElectron().electron;
     Object.assign(electron.app, { dock: undefined });
-    expect(() => createElectronAppCapabilities(electron, 'macos')).toThrow('require app.dock');
+    expect(() => electronHostApp(electron, 'macos')).toThrow('require app.dock');
   });
 });
-describe('initializeAppActivateBackend', () => {
-  it('is the construction initializer of createAppActivateBackend', () => {
-    expect(typeof initializeAppActivateBackend).toBe('function');
-  });
-});
-
-describe('initializeAppActivationPolicyBackend', () => {
-  it('is the construction initializer of createAppActivationPolicyBackend', () => {
-    expect(typeof initializeAppActivationPolicyBackend).toBe('function');
+describe('electronHostAppActivate', appLeaf('macos', 'activate'));
+describe('electronHostAppActivationPolicy', appLeaf('macos', 'activationPolicy'));
+describe('electronHostAppAllWindowsClosed', appLeaf('linux', 'allWindowsClosed'));
+describe('electronHostAppBadge', appLeaf('linux', 'badge'));
+describe('electronHostAppDock', appLeaf('macos', 'dock'));
+describe('electronHostAppFocus', appLeaf('linux', 'focus'));
+describe('electronHostAppHide', appLeaf('macos', 'hide'));
+describe('electronHostAppLocale', appLeaf('linux', 'locale'));
+describe('electronHostAppLoginItem', appLeaf('windows', 'loginItem'));
+describe('electronHostAppName', appLeaf('linux', 'name'));
+describe('electronHostAppNameWrite', appLeaf('linux', 'nameWrite'));
+describe('electronHostAppOpenFile', appLeaf('macos', 'openFile'));
+describe('electronHostAppPath', appLeaf('linux', 'path'));
+describe('electronHostAppQuit', appLeaf('linux', 'quit'));
+describe('electronHostAppQuitRequest', appLeaf('linux', 'quitRequest'));
+describe('electronHostAppReady', appLeaf('linux', 'ready'));
+describe('electronHostAppRecentDocuments', appLeaf('windows', 'recentDocuments'));
+describe('electronHostAppRelaunch', appLeaf('linux', 'relaunch'));
+describe('electronHostAppSecondInstance', appLeaf('linux', 'secondInstance'));
+describe('electronHostAppShow', appLeaf('macos', 'show'));
+describe('electronHostAppSingleInstance', appLeaf('linux', 'singleInstance'));
+describe('electronHostAppUserModelId', appLeaf('windows', 'userModelId'));
+
+describe('electronHostAppVersion', appLeaf('linux', 'version'));
+describe('populateElectronHostAppActivate', () => {
+  it('is the construction initializer of electronHostAppActivate', () => {
+    expect(typeof populateElectronHostAppActivate).toBe('function');
   });
 });
 
-describe('initializeAppAllWindowsClosedBackend', () => {
-  it('is the construction initializer of createAppAllWindowsClosedBackend', () => {
-    expect(typeof initializeAppAllWindowsClosedBackend).toBe('function');
+describe('populateElectronHostAppActivationPolicy', () => {
+  it('is the construction initializer of electronHostAppActivationPolicy', () => {
+    expect(typeof populateElectronHostAppActivationPolicy).toBe('function');
   });
 });
 
-describe('initializeAppBadgeBackend', () => {
-  it('is the construction initializer of createAppBadgeBackend', () => {
-    expect(typeof initializeAppBadgeBackend).toBe('function');
+describe('populateElectronHostAppAllWindowsClosed', () => {
+  it('is the construction initializer of electronHostAppAllWindowsClosed', () => {
+    expect(typeof populateElectronHostAppAllWindowsClosed).toBe('function');
   });
 });
 
-describe('initializeAppDockBackend', () => {
-  it('is the construction initializer of createAppDockBackend', () => {
-    expect(typeof initializeAppDockBackend).toBe('function');
+describe('populateElectronHostAppBadge', () => {
+  it('is the construction initializer of electronHostAppBadge', () => {
+    expect(typeof populateElectronHostAppBadge).toBe('function');
   });
 });
 
-describe('initializeAppFocusBackend', () => {
-  it('is the construction initializer of createAppFocusBackend', () => {
-    expect(typeof initializeAppFocusBackend).toBe('function');
+describe('populateElectronHostAppCommon', () => {
+  it('is the construction initializer of electronHostApp', () => {
+    expect(typeof populateElectronHostAppCommon).toBe('function');
   });
 });
 
-describe('initializeAppHideBackend', () => {
-  it('is the construction initializer of createAppHideBackend', () => {
-    expect(typeof initializeAppHideBackend).toBe('function');
+describe('populateElectronHostAppDock', () => {
+  it('is the construction initializer of electronHostAppDock', () => {
+    expect(typeof populateElectronHostAppDock).toBe('function');
   });
 });
 
-describe('initializeAppLocaleBackend', () => {
-  it('is the construction initializer of createAppLocaleBackend', () => {
-    expect(typeof initializeAppLocaleBackend).toBe('function');
+describe('populateElectronHostAppFocus', () => {
+  it('is the construction initializer of electronHostAppFocus', () => {
+    expect(typeof populateElectronHostAppFocus).toBe('function');
   });
 });
 
-describe('initializeAppLoginItemBackend', () => {
-  it('is the construction initializer of createAppLoginItemBackend', () => {
-    expect(typeof initializeAppLoginItemBackend).toBe('function');
+describe('populateElectronHostAppHide', () => {
+  it('is the construction initializer of electronHostAppHide', () => {
+    expect(typeof populateElectronHostAppHide).toBe('function');
   });
 });
 
-describe('initializeAppNameBackend', () => {
-  it('is the construction initializer of createAppNameBackend', () => {
-    expect(typeof initializeAppNameBackend).toBe('function');
+describe('populateElectronHostAppLinux', () => {
+  it('is the construction initializer of electronHostApp', () => {
+    expect(typeof populateElectronHostAppLinux).toBe('function');
   });
 });
 
-describe('initializeAppNameWriteBackend', () => {
-  it('is the construction initializer of createAppNameWriteBackend', () => {
-    expect(typeof initializeAppNameWriteBackend).toBe('function');
+describe('populateElectronHostAppLocale', () => {
+  it('is the construction initializer of electronHostAppLocale', () => {
+    expect(typeof populateElectronHostAppLocale).toBe('function');
   });
 });
 
-describe('initializeAppOpenFileBackend', () => {
-  it('is the construction initializer of createAppOpenFileBackend', () => {
-    expect(typeof initializeAppOpenFileBackend).toBe('function');
+describe('populateElectronHostAppLoginItem', () => {
+  it('is the construction initializer of electronHostAppLoginItem', () => {
+    expect(typeof populateElectronHostAppLoginItem).toBe('function');
   });
 });
 
-describe('initializeAppPathBackend', () => {
-  it('is the construction initializer of createAppPathBackend', () => {
-    expect(typeof initializeAppPathBackend).toBe('function');
+describe('populateElectronHostAppMacos', () => {
+  it('is the construction initializer of electronHostApp', () => {
+    expect(typeof populateElectronHostAppMacos).toBe('function');
   });
 });
 
-describe('initializeAppQuitBackend', () => {
-  it('is the construction initializer of createAppQuitBackend', () => {
-    expect(typeof initializeAppQuitBackend).toBe('function');
+describe('populateElectronHostAppName', () => {
+  it('is the construction initializer of electronHostAppName', () => {
+    expect(typeof populateElectronHostAppName).toBe('function');
   });
 });
 
-describe('initializeAppQuitRequestBackend', () => {
-  it('is the construction initializer of createAppQuitRequestBackend', () => {
-    expect(typeof initializeAppQuitRequestBackend).toBe('function');
+describe('populateElectronHostAppNameWrite', () => {
+  it('is the construction initializer of electronHostAppNameWrite', () => {
+    expect(typeof populateElectronHostAppNameWrite).toBe('function');
   });
 });
 
-describe('initializeAppReadyBackend', () => {
-  it('is the construction initializer of createAppReadyBackend', () => {
-    expect(typeof initializeAppReadyBackend).toBe('function');
+describe('populateElectronHostAppOpenFile', () => {
+  it('is the construction initializer of electronHostAppOpenFile', () => {
+    expect(typeof populateElectronHostAppOpenFile).toBe('function');
   });
 });
 
-describe('initializeAppRecentDocumentsBackend', () => {
-  it('is the construction initializer of createAppRecentDocumentsBackend', () => {
-    expect(typeof initializeAppRecentDocumentsBackend).toBe('function');
+describe('populateElectronHostAppPath', () => {
+  it('is the construction initializer of electronHostAppPath', () => {
+    expect(typeof populateElectronHostAppPath).toBe('function');
   });
 });
 
-describe('initializeAppRelaunchBackend', () => {
-  it('is the construction initializer of createAppRelaunchBackend', () => {
-    expect(typeof initializeAppRelaunchBackend).toBe('function');
+describe('populateElectronHostAppQuit', () => {
+  it('is the construction initializer of electronHostAppQuit', () => {
+    expect(typeof populateElectronHostAppQuit).toBe('function');
   });
 });
 
-describe('initializeAppSecondInstanceBackend', () => {
-  it('is the construction initializer of createAppSecondInstanceBackend', () => {
-    expect(typeof initializeAppSecondInstanceBackend).toBe('function');
+describe('populateElectronHostAppQuitRequest', () => {
+  it('is the construction initializer of electronHostAppQuitRequest', () => {
+    expect(typeof populateElectronHostAppQuitRequest).toBe('function');
   });
 });
 
-describe('initializeAppShowBackend', () => {
-  it('is the construction initializer of createAppShowBackend', () => {
-    expect(typeof initializeAppShowBackend).toBe('function');
+describe('populateElectronHostAppReady', () => {
+  it('is the construction initializer of electronHostAppReady', () => {
+    expect(typeof populateElectronHostAppReady).toBe('function');
   });
 });
 
-describe('initializeAppSingleInstanceBackend', () => {
-  it('is the construction initializer of createAppSingleInstanceBackend', () => {
-    expect(typeof initializeAppSingleInstanceBackend).toBe('function');
+describe('populateElectronHostAppRecentDocuments', () => {
+  it('is the construction initializer of electronHostAppRecentDocuments', () => {
+    expect(typeof populateElectronHostAppRecentDocuments).toBe('function');
   });
 });
 
-describe('initializeAppUserModelIdBackend', () => {
-  it('is the construction initializer of createAppUserModelIdBackend', () => {
-    expect(typeof initializeAppUserModelIdBackend).toBe('function');
+describe('populateElectronHostAppRelaunch', () => {
+  it('is the construction initializer of electronHostAppRelaunch', () => {
+    expect(typeof populateElectronHostAppRelaunch).toBe('function');
   });
 });
 
-describe('initializeAppVersionBackend', () => {
-  it('is the construction initializer of createAppVersionBackend', () => {
-    expect(typeof initializeAppVersionBackend).toBe('function');
+describe('populateElectronHostAppSecondInstance', () => {
+  it('is the construction initializer of electronHostAppSecondInstance', () => {
+    expect(typeof populateElectronHostAppSecondInstance).toBe('function');
   });
 });
 
-describe('initializeAppVisibilityQueryBackend', () => {
-  it('is the construction initializer of createAppVisibilityQueryBackend', () => {
-    expect(typeof initializeAppVisibilityQueryBackend).toBe('function');
+describe('populateElectronHostAppShow', () => {
+  it('is the construction initializer of electronHostAppShow', () => {
+    expect(typeof populateElectronHostAppShow).toBe('function');
   });
 });
 
-describe('initializeElectronCommonAppCapabilities', () => {
-  it('is the construction initializer of createElectronCommonAppCapabilities', () => {
-    expect(typeof initializeElectronCommonAppCapabilities).toBe('function');
+describe('populateElectronHostAppSingleInstance', () => {
+  it('is the construction initializer of electronHostAppSingleInstance', () => {
+    expect(typeof populateElectronHostAppSingleInstance).toBe('function');
   });
 });
 
-describe('initializeElectronLinuxAppCapabilities', () => {
-  it('is the construction initializer of createElectronLinuxAppCapabilities', () => {
-    expect(typeof initializeElectronLinuxAppCapabilities).toBe('function');
+describe('populateElectronHostAppUserModelId', () => {
+  it('is the construction initializer of electronHostAppUserModelId', () => {
+    expect(typeof populateElectronHostAppUserModelId).toBe('function');
   });
 });
 
-describe('initializeElectronMacosAppCapabilities', () => {
-  it('is the construction initializer of createElectronMacosAppCapabilities', () => {
-    expect(typeof initializeElectronMacosAppCapabilities).toBe('function');
+describe('populateElectronHostAppVersion', () => {
+  it('is the construction initializer of electronHostAppVersion', () => {
+    expect(typeof populateElectronHostAppVersion).toBe('function');
   });
 });
 
-describe('initializeElectronWindowsAppCapabilities', () => {
-  it('is the construction initializer of createElectronWindowsAppCapabilities', () => {
-    expect(typeof initializeElectronWindowsAppCapabilities).toBe('function');
+describe('populateElectronHostAppWindows', () => {
+  it('is the construction initializer of electronHostApp', () => {
+    expect(typeof populateElectronHostAppWindows).toBe('function');
   });
 });

package/src/electronClipboard.test.ts

@@ -1,7 +1,16 @@
-import type { ElectronApi, ElectronNativeImage } from '@flighthq/types/contract';
-import { EntityRuntimeKey } from '@flighthq/types/contract';
+import {
+  electronHostClipboard,
+  electronHostClipboardBookmark,
+  electronHostClipboardFormats,
+  electronHostClipboardImage,
+  electronHostClipboardText,
+} from './electronClipboard.ts';
+import type { ElectronApi, ElectronNativeImage } from './types/index.ts';
 
-import { createElectronClipboardBackend, initializeElectronClipboardBackend } from './electronClipboard';
+function clipboardProvider(electron: ElectronApi) {
+  const clipboard = electronHostClipboard(electron);
+  return Object.assign(clipboard.bookmark, clipboard.formats, clipboard.image, clipboard.text);
+}
 
 function fakeElectron(): ElectronApi {
   const store = { text: '', html: '', rtf: '', imageDataUrl: '', bookmarkTitle: '', bookmarkUrl: '' };
@@ -49,17 +58,16 @@ function fakeElectron(): ElectronApi {
   } as unknown as ElectronApi;
 }
 
-describe('createElectronClipboardBackend', () => {
+describe('electronHostClipboard', () => {
   it('round-trips text through the Electron clipboard', async () => {
-    const backend = createElectronClipboardBackend(fakeElectron());
-    expect(EntityRuntimeKey in backend).toBe(true);
+    const backend = clipboardProvider(fakeElectron());
     expect(await backend.writeText('hi')).toBe(true);
     expect(await backend.readText()).toBe('hi');
     expect(await backend.hasText()).toBe(true);
   });
 
   it('round-trips HTML and RTF', async () => {
-    const backend = createElectronClipboardBackend(fakeElectron());
+    const backend = clipboardProvider(fakeElectron());
     await backend.writeHtml('<b>x</b>');
     await backend.writeRTF('{\\rtf1 x}');
     expect(await backend.readHtml()).toBe('<b>x</b>');
@@ -67,7 +75,7 @@ describe('createElectronClipboardBackend', () => {
   });
 
   it('round-trips an image as a data URL', async () => {
-    const backend = createElectronClipboardBackend(fakeElectron());
+    const backend = clipboardProvider(fakeElectron());
     expect(await backend.hasImage()).toBe(false);
     await backend.writeImage('data:image/png;base64,AAAA');
     expect(await backend.readImage()).toBe('data:image/png;base64,AAAA');
@@ -75,21 +83,40 @@ describe('createElectronClipboardBackend', () => {
   });
 
   it('returns null for an empty bookmark and round-trips a set one', async () => {
-    const backend = createElectronClipboardBackend(fakeElectron());
+    const backend = clipboardProvider(fakeElectron());
     expect(await backend.readBookmark()).toBeNull();
     await backend.writeBookmark('Flight', 'https://example.test');
     expect(await backend.readBookmark()).toEqual({ title: 'Flight', url: 'https://example.test' });
   });
 
   it('clears all formats', async () => {
-    const backend = createElectronClipboardBackend(fakeElectron());
+    const backend = clipboardProvider(fakeElectron());
     await backend.writeText('x');
     expect(await backend.clear()).toBe(true);
     expect(await backend.readText()).toBe('');
   });
 });
-describe('initializeElectronClipboardBackend', () => {
-  it('is the construction initializer of createElectronClipboardBackend', () => {
-    expect(typeof initializeElectronClipboardBackend).toBe('function');
+
+describe('electronHostClipboardBookmark', () => {
+  it('constructs a clipboard bookmark provider', () => {
+    expect(electronHostClipboardBookmark(fakeElectron())).toBeDefined();
+  });
+});
+
+describe('electronHostClipboardFormats', () => {
+  it('constructs a clipboard formats provider', () => {
+    expect(electronHostClipboardFormats(fakeElectron())).toBeDefined();
+  });
+});
+
+describe('electronHostClipboardImage', () => {
+  it('constructs a clipboard image provider', () => {
+    expect(electronHostClipboardImage(fakeElectron())).toBeDefined();
+  });
+});
+
+describe('electronHostClipboardText', () => {
+  it('constructs a clipboard text provider', () => {
+    expect(electronHostClipboardText(fakeElectron())).toBeDefined();
   });
 });