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

package/src/electronWindow.test.ts

@@ -1,15 +1,30 @@
-import { createApplicationWindow } from '@flighthq/application/contract';
+import { createAppWindow } from '@flighthq/app';
 import { connectSignal } from '@flighthq/signals/contract';
-import type { ElectronApi, ElectronBrowserWindowOptions, ElectronRectangle } from '@flighthq/types/contract';
 
 import {
-  createElectronWindowBackend,
-  getApplicationWindowForElectronId,
+  electronHostWindow,
+  electronHostWindowAppearance,
+  electronHostWindowAttach,
+  electronHostWindowAttention,
+  electronHostWindowContentProtection,
+  electronHostWindowFocus,
+  electronHostWindowFullscreen,
+  electronHostWindowGeometry,
+  electronHostWindowHierarchy,
+  electronHostWindowLifecycle,
+  electronHostWindowProgress,
+  electronHostWindowShadow,
+  electronHostWindowShell,
+  electronHostWindowSizeConstraints,
+  electronHostWindowState,
+  electronHostWindowVisibility,
+  electronHostWindowZOrder,
+  getAppWindowForElectronId,
   getElectronBrowserWindow,
   getElectronWindowId,
-  initializeElectronWindowBackend,
-  resetElectronWindowBackendForTest,
-} from './electronWindow';
+  resetElectronHostWindowForTest,
+} from './electronWindow.ts';
+import type { ElectronApi, ElectronBrowserWindowOptions, ElectronRectangle } from './types/index.ts';
 
 interface FakeBrowserWindow {
   id: number;
@@ -142,90 +157,107 @@ function fakeElectron(): { electron: ElectronApi; created: FakeBrowserWindow[] }
   return { electron, created };
 }
 
-beforeEach(() => resetElectronWindowBackendForTest());
+beforeEach(() => resetElectronHostWindowForTest());
 
-describe('createElectronWindowBackend', () => {
-  it('adapter-roster axis: publishes all 28 P1 operations without false omissions', () => {
+describe('electronHostWindow', () => {
+  it('adapter-roster axis: publishes every window capability and P1 operation without false omissions', () => {
     const { electron } = fakeElectron();
-    const backend = createElectronWindowBackend(electron);
-
-    expect(
-      Object.keys(backend)
-        .filter((operation) => operation !== 'attach')
-        .sort(),
-    ).toEqual([
-      'center',
-      'close',
-      'flashWindowFrame',
+    const backend = electronHostWindow(electron);
+
+    expect(Object.keys(backend).sort()).toEqual([
+      'appearance',
+      'attach',
+      'attention',
+      'contentProtection',
       'focus',
-      'getBounds',
-      'hide',
-      'maximize',
-      'minimize',
-      'open',
-      'requestAttention',
-      'restore',
-      'setAlwaysOnTop',
-      'setContentProtection',
-      'setFullscreen',
-      'setHasShadow',
-      'setIcon',
-      'setMaximumSize',
-      'setMenuBarVisible',
-      'setMinimumSize',
-      'setOpacity',
-      'setParent',
-      'setPosition',
-      'setProgress',
-      'setResizable',
-      'setSize',
-      'setSkipTaskbar',
-      'setTitle',
-      'show',
+      'fullscreen',
+      'geometry',
+      'hierarchy',
+      'lifecycle',
+      'progress',
+      'shadow',
+      'shell',
+      'sizeConstraints',
+      'state',
+      'visibility',
+      'zOrder',
     ]);
+    const operations = Object.values(backend).flatMap((capability) => Object.keys(capability ?? {}));
+    expect(operations).toEqual(
+      expect.arrayContaining([
+        'center',
+        'close',
+        'flashWindowFrame',
+        'focus',
+        'getBounds',
+        'hide',
+        'maximize',
+        'minimize',
+        'open',
+        'requestAttention',
+        'restore',
+        'setAlwaysOnTop',
+        'setContentProtection',
+        'setFullscreen',
+        'setHasShadow',
+        'setIcon',
+        'setMaximumSize',
+        'setMenuBarVisible',
+        'setMinimumSize',
+        'setOpacity',
+        'setParent',
+        'setPosition',
+        'setProgress',
+        'setResizable',
+        'setSize',
+        'setSkipTaskbar',
+        'setTitle',
+        'show',
+      ]),
+    );
   });
 
   it('open creates a BrowserWindow and forwards commands to it', () => {
     const { electron, created } = fakeElectron();
-    const backend = createElectronWindowBackend(electron);
-    const win = createApplicationWindow();
-    expect(backend.open!(win, { title: 'Flight', width: 640, height: 480 })).toBe(true);
+    const backend = electronHostWindow(electron);
+    const win = createAppWindow();
+    expect(backend.lifecycle!.open(win, { title: 'Flight', width: 640, height: 480 })).toBe(true);
     expect(created).toHaveLength(1);
     expect(created[0].options.title).toBe('Flight');
-    backend.setTitle!(win, 'Renamed');
+    backend.appearance!.setTitle(win, 'Renamed');
     expect(created[0].calls).toContainEqual({ method: 'setTitle', args: ['Renamed'] });
   });
 
   it('getBounds reads from the BrowserWindow into out', () => {
     const { electron, created } = fakeElectron();
-    const backend = createElectronWindowBackend(electron);
-    const win = createApplicationWindow();
-    backend.open!(win, {});
+    const backend = electronHostWindow(electron);
+    const win = createAppWindow();
+    backend.lifecycle!.open(win, {});
     created[0].bounds = { x: 10, y: 20, width: 300, height: 400 };
     const out = { x: 0, y: 0, width: 0, height: 0 };
-    const result = backend.getBounds!(win, out);
+    const result = backend.geometry!.getBounds(win, out);
     expect(result).toBe(out);
     expect(out).toEqual({ x: 10, y: 20, width: 300, height: 400 });
   });
 
   it('getBounds falls back to the entity when no window is mapped', () => {
     const { electron } = fakeElectron();
-    const backend = createElectronWindowBackend(electron);
-    const win = createApplicationWindow();
+    const backend = electronHostWindow(electron);
+    const win = createAppWindow();
     win.x = 5;
     win.y = 6;
     win.width = 70;
     win.height = 80;
     const out = { x: 0, y: 0, width: 0, height: 0 };
-    backend.getBounds!(win, out);
+    backend.geometry!.getBounds(win, out);
     expect(out).toEqual({ x: 5, y: 6, width: 70, height: 80 });
   });
 
   it('forwards an OS minimize event to the entity and emits onMinimize', () => {
     const { electron, created } = fakeElectron();
-    const backend = createElectronWindowBackend(electron);
-    const win = createApplicationWindow();
-    backend.open!(win, {});
+    const backend = electronHostWindow(electron);
+    const win = createAppWindow();
+    backend.lifecycle!.open(win, {});
     let emitted = false;
     connectSignal(win.onMinimize, () => {
       emitted = true;
@@ -238,12 +270,12 @@ describe('createElectronWindowBackend', () => {
   it('attaches an existing BrowserWindow with stable identity and no duplicate listeners', () => {
     const { electron, created } = fakeElectron();
     const native = new electron.BrowserWindow({ title: 'Existing' }) as unknown as FakeBrowserWindow;
-    const backend = createElectronWindowBackend(electron);
-    const win = createApplicationWindow();
+    const backend = electronHostWindow(electron);
+    const win = createAppWindow();
 
-    expect(backend.attach?.(win, native, 'host')).toBe(true);
-    expect(backend.attach?.(win, native, 'host')).toBe(true);
-    expect(backend.attach?.(createApplicationWindow(), native, 'host')).toBe(false);
+    expect(backend.attach!.attach(win, native, 'host')).toBe(true);
+    expect(backend.attach!.attach(win, native, 'host')).toBe(true);
+    expect(backend.attach!.attach(createAppWindow(), native, 'host')).toBe(false);
     expect(created).toHaveLength(1);
     expect(getElectronBrowserWindow(win)).toBe(native);
     expect(native.listenerCount('move')).toBe(1);
@@ -252,12 +284,12 @@ describe('createElectronWindowBackend', () => {
   it('detaches host-owned windows without closing them and does so idempotently', () => {
     const { electron } = fakeElectron();
     const native = new electron.BrowserWindow({}) as unknown as FakeBrowserWindow;
-    const backend = createElectronWindowBackend(electron);
-    const win = createApplicationWindow();
-    expect(backend.attach?.(win, native, 'host')).toBe(true);
+    const backend = electronHostWindow(electron);
+    const win = createAppWindow();
+    expect(backend.attach!.attach(win, native, 'host')).toBe(true);
 
-    backend.close!(win);
-    backend.close!(win);
+    backend.lifecycle!.close(win);
+    backend.lifecycle!.close(win);
 
     expect(native.calls.filter((call) => call.method === 'close')).toHaveLength(0);
     expect(native.listenerCount('move')).toBe(0);
@@ -267,12 +299,12 @@ describe('createElectronWindowBackend', () => {
   it('closes a Flight-owned native window exactly once', () => {
     const { electron } = fakeElectron();
     const native = new electron.BrowserWindow({}) as unknown as FakeBrowserWindow;
-    const backend = createElectronWindowBackend(electron);
-    const win = createApplicationWindow();
-    expect(backend.attach?.(win, native, 'flight')).toBe(true);
+    const backend = electronHostWindow(electron);
+    const win = createAppWindow();
+    expect(backend.attach!.attach(win, native, 'flight')).toBe(true);
 
-    backend.close!(win);
-    backend.close!(win);
+    backend.lifecycle!.close(win);
+    backend.lifecycle!.close(win);
 
     expect(native.calls.filter((call) => call.method === 'close')).toHaveLength(1);
   });
@@ -280,40 +312,141 @@ describe('createElectronWindowBackend', () => {
   it('routes a native close through the application choke point once and drops identity maps', () => {
     const { electron } = fakeElectron();
     const native = new electron.BrowserWindow({}) as unknown as FakeBrowserWindow;
-    const backend = createElectronWindowBackend(electron);
-    const win = createApplicationWindow();
+    const backend = electronHostWindow(electron);
+    const win = createAppWindow();
     let closes = 0;
     connectSignal(win.onClose, () => closes++);
-    expect(backend.attach?.(win, native, 'host')).toBe(true);
+    expect(backend.attach!.attach(win, native, 'host')).toBe(true);
 
     native.fire('closed');
     native.fire('closed');
 
     expect(closes).toBe(1);
-    expect(getApplicationWindowForElectronId(native.id)).toBeNull();
+    expect(getAppWindowForElectronId(native.id)).toBeNull();
     expect(getElectronBrowserWindow(win)).toBeNull();
   });
 });
 
-describe('getApplicationWindowForElectronId', () => {
-  it('returns the ApplicationWindow for a known Electron id and null for an unknown one', () => {
+describe('electronHostWindowAppearance', () => {
+  it('publishes title, icon and opacity hooks', () => {
+    expect(Object.keys(electronHostWindowAppearance()).sort()).toEqual(['setIcon', 'setOpacity', 'setTitle']);
+  });
+});
+
+describe('electronHostWindowAttach', () => {
+  it('publishes the attach hook', () => {
+    expect(Object.keys(electronHostWindowAttach()).sort()).toEqual(['attach']);
+  });
+});
+
+describe('electronHostWindowAttention', () => {
+  it('publishes both attention hooks', () => {
+    expect(Object.keys(electronHostWindowAttention()).sort()).toEqual(['flashWindowFrame', 'requestAttention']);
+  });
+});
+
+describe('electronHostWindowContentProtection', () => {
+  it('publishes the content-protection hook', () => {
+    expect(Object.keys(electronHostWindowContentProtection()).sort()).toEqual(['setContentProtection']);
+  });
+});
+
+describe('electronHostWindowFocus', () => {
+  it('publishes the focus hook', () => {
+    expect(Object.keys(electronHostWindowFocus()).sort()).toEqual(['focus']);
+  });
+});
+
+describe('electronHostWindowFullscreen', () => {
+  it('publishes the window-fullscreen hook', () => {
+    expect(Object.keys(electronHostWindowFullscreen()).sort()).toEqual(['setFullscreen']);
+  });
+});
+
+describe('electronHostWindowGeometry', () => {
+  it('publishes the geometry hooks', () => {
+    expect(Object.keys(electronHostWindowGeometry()).sort()).toEqual(['center', 'getBounds', 'setPosition', 'setSize']);
+  });
+});
+
+describe('electronHostWindowHierarchy', () => {
+  it('publishes the parent hook', () => {
+    expect(Object.keys(electronHostWindowHierarchy()).sort()).toEqual(['setParent']);
+  });
+});
+
+describe('electronHostWindowLifecycle', () => {
+  it('publishes the open and close hooks', () => {
+    const { electron } = fakeElectron();
+    expect(Object.keys(electronHostWindowLifecycle(electron)).sort()).toEqual(['close', 'open']);
+  });
+});
+
+describe('electronHostWindowProgress', () => {
+  it('publishes the progress hook', () => {
+    expect(Object.keys(electronHostWindowProgress()).sort()).toEqual(['setProgress']);
+  });
+});
+
+describe('electronHostWindowShadow', () => {
+  it('publishes the shadow hook', () => {
+    expect(Object.keys(electronHostWindowShadow()).sort()).toEqual(['setHasShadow']);
+  });
+});
+
+describe('electronHostWindowShell', () => {
+  it('publishes both shell hooks', () => {
+    expect(Object.keys(electronHostWindowShell()).sort()).toEqual(['setMenuBarVisible', 'setSkipTaskbar']);
+  });
+});
+
+describe('electronHostWindowSizeConstraints', () => {
+  it('publishes the sizing hooks', () => {
+    expect(Object.keys(electronHostWindowSizeConstraints()).sort()).toEqual([
+      'setMaximumSize',
+      'setMinimumSize',
+      'setResizable',
+    ]);
+  });
+});
+
+describe('electronHostWindowState', () => {
+  it('publishes all three state hooks', () => {
+    expect(Object.keys(electronHostWindowState()).sort()).toEqual(['maximize', 'minimize', 'restore']);
+  });
+});
+
+describe('electronHostWindowVisibility', () => {
+  it('publishes the show and hide hooks', () => {
+    expect(Object.keys(electronHostWindowVisibility()).sort()).toEqual(['hide', 'show']);
+  });
+});
+
+describe('electronHostWindowZOrder', () => {
+  it('publishes the always-on-top hook', () => {
+    expect(Object.keys(electronHostWindowZOrder()).sort()).toEqual(['setAlwaysOnTop']);
+  });
+});
+
+describe('getAppWindowForElectronId', () => {
+  it('returns the AppWindow for a known Electron id and null for an unknown one', () => {
     const { electron, created } = fakeElectron();
-    const backend = createElectronWindowBackend(electron);
-    const win = createApplicationWindow();
-    backend.open!(win, {});
+    const backend = electronHostWindow(electron);
+    const win = createAppWindow();
+    backend.lifecycle!.open(win, {});
     const id = created[0].id;
-    expect(getApplicationWindowForElectronId(id)).toBe(win);
-    expect(getApplicationWindowForElectronId(9999)).toBeNull();
+    expect(getAppWindowForElectronId(id)).toBe(win);
+    expect(getAppWindowForElectronId(9999)).toBeNull();
   });
 });
 
 describe('getElectronBrowserWindow', () => {
   it('returns the backing BrowserWindow after open and null before', () => {
     const { electron, created } = fakeElectron();
-    const backend = createElectronWindowBackend(electron);
-    const win = createApplicationWindow();
+    const backend = electronHostWindow(electron);
+    const win = createAppWindow();
     expect(getElectronBrowserWindow(win)).toBeNull();
-    backend.open!(win, {});
+    backend.lifecycle!.open(win, {});
     expect(getElectronBrowserWindow(win)).toBe(created[0]);
   });
 });
@@ -321,31 +454,26 @@ describe('getElectronBrowserWindow', () => {
 describe('getElectronWindowId', () => {
   it('returns the numeric Electron window id after open and -1 before', () => {
     const { electron, created } = fakeElectron();
-    const backend = createElectronWindowBackend(electron);
-    const win = createApplicationWindow();
+    const backend = electronHostWindow(electron);
+    const win = createAppWindow();
     expect(getElectronWindowId(win)).toBe(-1);
-    backend.open!(win, {});
+    backend.lifecycle!.open(win, {});
     const expectedId = created[0].id;
     expect(getElectronWindowId(win)).toBe(expectedId);
   });
 });
 
-describe('initializeElectronWindowBackend', () => {
-  it('is the construction initializer of createElectronWindowBackend', () => {
-    expect(typeof initializeElectronWindowBackend).toBe('function');
-  });
-});
-describe('resetElectronWindowBackendForTest', () => {
+describe('resetElectronHostWindowForTest', () => {
   it('clears the window identity maps', () => {
     const { electron, created } = fakeElectron();
-    const backend = createElectronWindowBackend(electron);
-    const win = createApplicationWindow();
-    expect(backend.open!(win, {})).toBe(true);
+    const backend = electronHostWindow(electron);
+    const win = createAppWindow();
+    expect(backend.lifecycle!.open(win, {})).toBe(true);
     expect(getElectronBrowserWindow(win)).toBe(created[0]);
 
-    resetElectronWindowBackendForTest();
+    resetElectronHostWindowForTest();
 
     expect(getElectronBrowserWindow(win)).toBeNull();
-    expect(getApplicationWindowForElectronId(created[0].id)).toBeNull();
+    expect(getAppWindowForElectronId(created[0].id)).toBeNull();
   });
 });