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

package/src/electronMenu.test.ts

@@ -1,14 +1,16 @@
-import type { MenuApplicationBackend, MenuPopupBackend, MenuSelectBackend } from '@flighthq/types/contract';
-import type { ElectronApi, ElectronMenu, ElectronMenuItemOptions } from '@flighthq/types/contract';
-import { EntityRuntimeKey } from '@flighthq/types/contract';
+import type { HostAppMenuCapability, HostMenuPopupCapability, HostMenuSelectCapability } from '@flighthq/menu/contract';
 
 import {
-  createElectronMenuBackends,
-  initializeElectronMenuCapabilities,
-  initializeMenuApplicationBackend,
-  initializeMenuPopupBackend,
-  initializeMenuSelectBackend,
-} from './electronMenu';
+  electronHostMenu,
+  electronHostAppMenu,
+  electronHostMenuPopup,
+  electronHostMenuSelect,
+  populateElectronHostMenu,
+  populateElectronHostAppMenu,
+  populateElectronHostMenuPopup,
+  populateElectronHostMenuSelect,
+} from './electronMenu.ts';
+import type { ElectronApi, ElectronMenu, ElectronMenuItemOptions } from './types/index.ts';
 
 function fakeElectron(): {
   electron: ElectronApi;
@@ -54,20 +56,36 @@ function clickItem(built: ElectronMenuItemOptions[][], id: string): void {
   item?.click?.();
 }
 
-describe('createElectronMenuBackends', () => {
-  it('returns an Entity-composed capability bundle and providers', () => {
-    const capabilities = createElectronMenuBackends(fakeElectron().electron);
-    expect(EntityRuntimeKey in capabilities).toBe(true);
-    for (const provider of Object.values(capabilities)) expect(EntityRuntimeKey in provider).toBe(true);
+describe('electronHostAppMenu', () => {
+  it('constructs an app menu provider', () => {
+    expect(electronHostAppMenu(fakeElectron().electron)).toBeDefined();
   });
+});
+// The merged MenuBackend is gone; these tests exercise the three slots that replaced it. This helper
+// recomposes the old surface so each assertion still names the operation it is really testing.
+function _slots(api: ElectronApi): {
+  destroy?: () => void;
+  popupContextMenu: HostMenuPopupCapability['popup'];
+  setAppMenu: HostAppMenuCapability['setAppMenu'];
+  subscribeSelect: HostMenuSelectCapability['subscribe'];
+} {
+  const { app, popup, select } = electronHostMenu(api);
+  return {
+    destroy: app.destroy?.bind(app),
+    popupContextMenu: popup.popup,
+    setAppMenu: app.setAppMenu,
+    subscribeSelect: select.subscribe,
+  };
+}
 
+describe('electronHostMenu', () => {
   it('builds and applies the application menu and reports clicks via subscribeSelect', () => {
     const { electron, built, applied } = fakeElectron();
     const backend = _slots(electron);
     const seen: string[] = [];
     backend.subscribeSelect((id: string) => seen.push(id));
     expect(
-      backend.setApplicationMenu([
+      backend.setAppMenu([
         { id: 'open', label: 'Open' },
         { label: 'Edit', submenu: [{ id: 'copy', label: 'Copy' }] },
       ]),
@@ -83,7 +101,7 @@ describe('createElectronMenuBackends', () => {
     const backend = _slots(electron);
     const seen: string[] = [];
     const unsubscribe = backend.subscribeSelect((id: string) => seen.push(id));
-    backend.setApplicationMenu([{ id: 'a', label: 'A' }]);
+    backend.setAppMenu([{ id: 'a', label: 'A' }]);
     unsubscribe();
     clickItem(built, 'a');
     expect(seen).toEqual([]);
@@ -92,7 +110,7 @@ describe('createElectronMenuBackends', () => {
   it('clears the native application menu on destroy', () => {
     const { electron, applied } = fakeElectron();
     const backend = _slots(electron);
-    backend.setApplicationMenu([{ id: 'a', label: 'A' }]);
+    backend.setAppMenu([{ id: 'a', label: 'A' }]);
     expect(applied.length).toBe(1);
     backend.destroy?.();
     expect(applied.length).toBe(2);
@@ -102,7 +120,7 @@ describe('createElectronMenuBackends', () => {
   it('clears the native application menu exactly once on double destroy', () => {
     const { electron, applied } = fakeElectron();
     const backend = _slots(electron);
-    backend.setApplicationMenu([{ id: 'a', label: 'A' }]);
+    backend.setAppMenu([{ id: 'a', label: 'A' }]);
     expect(applied.length).toBe(1);
     backend.destroy?.();
     backend.destroy?.();
@@ -118,7 +136,7 @@ describe('createElectronMenuBackends', () => {
     const backend = _slots(electron);
     const seen: string[] = [];
     const unsubscribe = backend.subscribeSelect((id: string) => seen.push(id));
-    backend.setApplicationMenu([{ id: 'a', label: 'A' }]);
+    backend.setAppMenu([{ id: 'a', label: 'A' }]);
     backend.destroy?.();
     clickItem(built, 'a');
     expect(seen).toEqual(['a']);
@@ -139,42 +157,38 @@ describe('createElectronMenuBackends', () => {
   });
 });
 
-// The merged MenuBackend is gone; these tests exercise the three slots that replaced it. This helper
-// recomposes the old surface so each assertion still names the operation it is really testing.
-function _slots(api: ElectronApi): {
-  destroy?: () => void;
-  popupContextMenu: MenuPopupBackend['popup'];
-  setApplicationMenu: MenuApplicationBackend['setApplicationMenu'];
-  subscribeSelect: MenuSelectBackend['subscribe'];
-} {
-  const { application, popup, select } = createElectronMenuBackends(api);
-  return {
-    destroy: application.destroy?.bind(application),
-    popupContextMenu: popup.popup,
-    setApplicationMenu: application.setApplicationMenu,
-    subscribeSelect: select.subscribe,
-  };
-}
-describe('initializeElectronMenuCapabilities', () => {
-  it('is the construction initializer of createElectronMenuCapabilities', () => {
-    expect(typeof initializeElectronMenuCapabilities).toBe('function');
+describe('electronHostMenuPopup', () => {
+  it('constructs a menu popup provider', () => {
+    expect(electronHostMenuPopup(fakeElectron().electron)).toBeDefined();
+  });
+});
+
+describe('electronHostMenuSelect', () => {
+  it('constructs a menu select provider', () => {
+    expect(electronHostMenuSelect()).toBeDefined();
+  });
+});
+
+describe('populateElectronHostAppMenu', () => {
+  it('is the construction initializer of electronHostMenuApplication', () => {
+    expect(typeof populateElectronHostAppMenu).toBe('function');
   });
 });
 
-describe('initializeMenuApplicationBackend', () => {
-  it('is the construction initializer of createMenuApplicationBackend', () => {
-    expect(typeof initializeMenuApplicationBackend).toBe('function');
+describe('populateElectronHostMenu', () => {
+  it('is the construction initializer of electronHostMenu', () => {
+    expect(typeof populateElectronHostMenu).toBe('function');
   });
 });
 
-describe('initializeMenuPopupBackend', () => {
-  it('is the construction initializer of createMenuPopupBackend', () => {
-    expect(typeof initializeMenuPopupBackend).toBe('function');
+describe('populateElectronHostMenuPopup', () => {
+  it('is the construction initializer of electronHostMenuPopup', () => {
+    expect(typeof populateElectronHostMenuPopup).toBe('function');
   });
 });
 
-describe('initializeMenuSelectBackend', () => {
-  it('is the construction initializer of createMenuSelectBackend', () => {
-    expect(typeof initializeMenuSelectBackend).toBe('function');
+describe('populateElectronHostMenuSelect', () => {
+  it('is the construction initializer of electronHostMenuSelect', () => {
+    expect(typeof populateElectronHostMenuSelect).toBe('function');
   });
 });

package/src/electronMenuTemplate.test.ts

@@ -1,4 +1,4 @@
-import { toElectronTemplate } from './electronMenuTemplate';
+import { toElectronTemplate } from './electronMenuTemplate.ts';
 
 describe('toElectronTemplate', () => {
   it('maps Flight roles and omits unsupported custom roles', () => {

package/src/electronNotification.test.ts

@@ -1,12 +1,20 @@
+import { EntityRuntimeKey } from '@flighthq/entity/contract';
 import { closeNotification } from '@flighthq/notification/contract';
-import { EntityRuntimeKey } from '@flighthq/types/contract';
-import type { ElectronApi, ElectronNotificationOptions } from '@flighthq/types/contract';
 
 import {
-  createElectronNotificationCapabilities,
-  initializeElectronMacosNotificationCapabilities,
-  initializeElectronNotificationCapabilities,
-} from './electronNotification';
+  electronHostNotification,
+  electronHostNotificationAction,
+  electronHostNotificationClick,
+  electronHostNotificationClose,
+  electronHostNotificationDelivery,
+  electronHostNotificationDismiss,
+  electronHostNotificationLifecycle,
+  electronHostNotificationReceived,
+  electronHostNotificationReply,
+  populateElectronHostNotificationMacos,
+  populateElectronHostNotificationCommon,
+} from './electronNotification.ts';
+import type { ElectronApi, ElectronNotificationOptions } from './types/index.ts';
 
 interface FakeNotification {
   close(): void;
@@ -38,20 +46,29 @@ function fakeElectron(supported = true) {
   return { electron, notifications };
 }
 
-describe('createElectronNotificationCapabilities', () => {
+function notificationLeaf(factory: () => object): () => void {
+  return () => {
+    it('constructs a plain frozen notification provider without Entity', () => {
+      expect(EntityRuntimeKey in factory()).toBe(false);
+    });
+  };
+}
+
+describe('electronHostNotification', () => {
   it.each([
     ['macos', ['action', 'click', 'close', 'delivery', 'dismiss', 'lifecycle', 'received', 'reply']],
     ['windows', ['click', 'close', 'delivery', 'dismiss', 'lifecycle', 'received']],
     ['linux', ['click', 'close', 'delivery', 'dismiss', 'lifecycle', 'received']],
   ] as const)('constructs the exact %s profile', (platform, expected) => {
-    const capabilities = createElectronNotificationCapabilities(fakeElectron().electron, { platform });
-    expect(EntityRuntimeKey in capabilities).toBe(true);
+    const capabilities = electronHostNotification(fakeElectron().electron, { platform });
+    expect(EntityRuntimeKey in capabilities).toBe(false);
     expect(Object.keys(capabilities).sort()).toEqual(expected);
+    for (const provider of Object.values(capabilities)) expect(EntityRuntimeKey in provider).toBe(false);
     expect('permission' in capabilities).toBe(false);
   });
 
   it('rejects Darwin-only actions on Windows instead of dropping them', async () => {
-    const capabilities = createElectronNotificationCapabilities(fakeElectron().electron, { platform: 'windows' });
+    const capabilities = electronHostNotification(fakeElectron().electron, { platform: 'windows' });
     await expect(
       capabilities.delivery.notify({
         actions: [{ id: 'open', title: 'Open' }],
@@ -62,7 +79,7 @@ describe('createElectronNotificationCapabilities', () => {
 
   it('publishes only after the native show event', async () => {
     const { electron, notifications } = fakeElectron();
-    const capabilities = createElectronNotificationCapabilities(electron, {
+    const capabilities = electronHostNotification(electron, {
       platform: 'linux',
     });
     let show: (() => void) | null = null;
@@ -103,7 +120,7 @@ describe('createElectronNotificationCapabilities', () => {
       },
       { isSupported: () => true },
     ) as unknown as ElectronApi['Notification'];
-    const capabilities = createElectronNotificationCapabilities(electron, {
+    const capabilities = electronHostNotification(electron, {
       platform: 'linux',
     });
     await expect(capabilities.delivery.notify({ id: 'ghost', title: 'Ghost' })).resolves.toEqual({
@@ -119,7 +136,7 @@ describe('createElectronNotificationCapabilities', () => {
 
   it('maps Darwin action/reply and all-platform click/dismiss/received to one Entity', async () => {
     const { electron, notifications } = fakeElectron();
-    const capabilities = createElectronNotificationCapabilities(electron, {
+    const capabilities = electronHostNotification(electron, {
       platform: 'macos',
     });
     const seen: string[] = [];
@@ -145,7 +162,7 @@ describe('createElectronNotificationCapabilities', () => {
 
   it('pins close to the returned Entity', async () => {
     const { electron, notifications } = fakeElectron();
-    const capabilities = createElectronNotificationCapabilities(electron, {
+    const capabilities = electronHostNotification(electron, {
       platform: 'linux',
     });
     const delivered = await capabilities.delivery.notify({
@@ -168,7 +185,7 @@ describe('createElectronNotificationCapabilities', () => {
 
   it('attempts all live closes and retries only failures', async () => {
     const { electron, notifications } = fakeElectron();
-    const capabilities = createElectronNotificationCapabilities(electron, {
+    const capabilities = electronHostNotification(electron, {
       platform: 'linux',
     });
     await capabilities.delivery.notify({ id: 'first', title: 'First' });
@@ -190,14 +207,47 @@ describe('createElectronNotificationCapabilities', () => {
     expect(secondCloses).toBe(2);
   });
 });
-describe('initializeElectronMacosNotificationCapabilities', () => {
-  it('is the construction initializer of createElectronMacosNotificationCapabilities', () => {
-    expect(typeof initializeElectronMacosNotificationCapabilities).toBe('function');
+const notificationAction = notificationLeaf(() =>
+  electronHostNotificationAction(fakeElectron().electron, { platform: 'macos' }),
+);
+const notificationClick = notificationLeaf(() =>
+  electronHostNotificationClick(fakeElectron().electron, { platform: 'linux' }),
+);
+const notificationClose = notificationLeaf(() =>
+  electronHostNotificationClose(fakeElectron().electron, { platform: 'linux' }),
+);
+const notificationDelivery = notificationLeaf(() =>
+  electronHostNotificationDelivery(fakeElectron().electron, { platform: 'linux' }),
+);
+const notificationDismiss = notificationLeaf(() =>
+  electronHostNotificationDismiss(fakeElectron().electron, { platform: 'linux' }),
+);
+const notificationLifecycle = notificationLeaf(() =>
+  electronHostNotificationLifecycle(fakeElectron().electron, { platform: 'linux' }),
+);
+const notificationReceived = notificationLeaf(() =>
+  electronHostNotificationReceived(fakeElectron().electron, { platform: 'linux' }),
+);
+const notificationReply = notificationLeaf(() =>
+  electronHostNotificationReply(fakeElectron().electron, { platform: 'macos' }),
+);
+
+describe('electronHostNotificationAction', notificationAction);
+describe('electronHostNotificationClick', notificationClick);
+describe('electronHostNotificationClose', notificationClose);
+describe('electronHostNotificationDelivery', notificationDelivery);
+describe('electronHostNotificationDismiss', notificationDismiss);
+describe('electronHostNotificationLifecycle', notificationLifecycle);
+describe('electronHostNotificationReceived', notificationReceived);
+describe('electronHostNotificationReply', notificationReply);
+describe('populateElectronHostNotificationCommon', () => {
+  it('is the construction initializer of electronHostNotification', () => {
+    expect(typeof populateElectronHostNotificationCommon).toBe('function');
   });
 });
 
-describe('initializeElectronNotificationCapabilities', () => {
-  it('is the construction initializer of createElectronNotificationCapabilities', () => {
-    expect(typeof initializeElectronNotificationCapabilities).toBe('function');
+describe('populateElectronHostNotificationMacos', () => {
+  it('is the construction initializer of electronHostNotification', () => {
+    expect(typeof populateElectronHostNotificationMacos).toBe('function');
   });
 });

package/src/electronPlatform.test.ts

@@ -1,7 +1,7 @@
-import type { PlatformInfo, ElectronApi } from '@flighthq/types/contract';
-import { EntityRuntimeKey } from '@flighthq/types/contract';
+import type { PlatformInfo } from '@flighthq/platform/contract';
 
-import { createElectronPlatformBackend, initializeElectronPlatformBackend } from './electronPlatform';
+import { electronHostPlatform, electronHostPlatformGroup, populateElectronHostPlatform } from './electronPlatform.ts';
+import type { ElectronApi } from './types/index.ts';
 
 function fakeElectron(): ElectronApi {
   return {
@@ -11,13 +11,9 @@ function fakeElectron(): ElectronApi {
   } as unknown as ElectronApi;
 }
 
-describe('createElectronPlatformBackend', () => {
-  it('returns an Entity', () => {
-    expect(EntityRuntimeKey in createElectronPlatformBackend(fakeElectron())).toBe(true);
-  });
-
+describe('electronHostPlatform', () => {
   it('fills platform info from process and electron locale', () => {
-    const backend = createElectronPlatformBackend(fakeElectron());
+    const backend = electronHostPlatform(fakeElectron());
     const out = {} as PlatformInfo;
     const result = backend.getInfo(out);
     expect(result).toBe(out);
@@ -30,8 +26,17 @@ describe('createElectronPlatformBackend', () => {
     expect(typeof out.version).toBe('string');
   });
 });
-describe('initializeElectronPlatformBackend', () => {
-  it('is the construction initializer of createElectronPlatformBackend', () => {
-    expect(typeof initializeElectronPlatformBackend).toBe('function');
+
+describe('electronHostPlatformGroup', () => {
+  it('constructs the platform info slot', () => {
+    const platform = electronHostPlatformGroup(fakeElectron());
+    expect(Object.keys(platform)).toEqual(['info']);
+    expect(platform.info.getInfo).toBeTypeOf('function');
+  });
+});
+
+describe('populateElectronHostPlatform', () => {
+  it('is the construction initializer of electronHostPlatform', () => {
+    expect(typeof populateElectronHostPlatform).toBe('function');
   });
 });