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

package/dist/electronWindow.js

@@ -1,73 +1,39 @@
-import { notifyWindowClosed } from '@flighthq/application/contract';
-import { allocateEntity, finishEntity } from '@flighthq/entity/contract';
+import { notifyWindowClosed } from '@flighthq/app/contract';
 import { emitSignal } from '@flighthq/signals/contract';
-export function createElectronWindowBackend(electron) {
-    const out = allocateEntity();
-    initializeElectronWindowBackend(out, electron);
-    return finishEntity(out);
-}
-// Returns the ApplicationWindow mapped to the given Electron BrowserWindow id, or null when unknown.
-// Allows tray/menu/protocol handlers to resolve a native window id back into a Flight window entity.
-export function getApplicationWindowForElectronId(id) {
-    return _windowsById.get(id) ?? null;
-}
-// The Electron BrowserWindow backing a Flight window opened via openWindow, or null if not (yet)
-// opened. The escape hatch a host app needs to do Electron-specific things the seam doesn't cover —
-// most importantly loadFile/loadURL to put content in the window. Host-adapter-only by design.
-export function getElectronBrowserWindow(win) {
-    return _windows.get(win) ?? null;
-}
-// Returns the Electron BrowserWindow id for a Flight window, or -1 when the window is not mapped.
-// Useful for tray/menu click handlers that receive a native window id and need to resolve back to an
-// ApplicationWindow; pair with getApplicationWindowForElectronId.
-export function getElectronWindowId(win) {
-    return _windows.get(win)?.id ?? -1;
-}
-// Maps Flight's WindowBackend onto Electron's BrowserWindow, one BrowserWindow per ApplicationWindow.
-// open() constructs the real OS window from WindowOptions and wires BrowserWindow OS events back to
-// the entity: each native event mutates the matching ApplicationWindow field and emits its signal, so
-// user-driven state changes (minimize, move, focus, …) flow through the same signals the command
-// functions emit. Other methods look up the BrowserWindow and no-op when it is absent (already closed
-// or never opened). Risky native calls are wrapped so a destroyed window cannot throw across the seam.
-export function initializeElectronWindowBackend(out, electron) {
-    out.attach = (win, handle, ownership) => {
-        if (!isElectronBrowserWindow(handle))
-            return false;
-        return attachElectronWindow(win, handle, ownership);
-    };
-    out.open = (win, options) => {
-        if (_windowRecords.has(win))
-            return true;
-        const bw = new electron.BrowserWindow({
-            title: options.title,
-            x: options.x,
-            y: options.y,
-            width: options.width,
-            height: options.height,
-            resizable: options.resizable,
-            alwaysOnTop: options.alwaysOnTop,
-            fullscreen: options.fullscreen,
-            show: options.visible,
-            minWidth: options.minWidth,
-            minHeight: options.minHeight,
-            maxWidth: options.maxWidth,
-            maxHeight: options.maxHeight,
-            frame: options.frame,
-            transparent: options.transparent,
-        });
-        if (attachElectronWindow(win, bw, 'flight'))
-            return true;
-        try {
-            bw.close();
-        }
-        catch {
-            /* construction succeeded but attachment failed */
-        }
-        return false;
-    };
-    out.close = (win) => {
-        detachElectronWindow(win, true);
+// Maps Flight's window capability slots onto Electron's BrowserWindow, one BrowserWindow per
+// AppWindow. open() constructs the real OS window from WindowOptions and wires BrowserWindow OS
+// events back to the entity: each native event mutates the matching AppWindow field and emits
+// its signal, so user-driven state changes (minimize, move, focus, …) flow through the same signals the
+// command functions emit. Other methods look up the BrowserWindow and no-op when it is absent (already
+// closed or never opened). Risky native calls are wrapped so a destroyed window cannot throw across the
+// seam.
+//
+// Electron covers every window capability slot. It omits the subscribe hooks inside geometry, lifecycle
+// and visibility (subscribeMove, subscribeResize, subscribeClose, subscribeVisibility): an attached
+// BrowserWindow's OS events are wired straight to the window's own signals in attachElectronWindow, so a
+// second host-side subscription would report every change twice.
+export function electronHostWindow(electron) {
+    return {
+        appearance: electronHostWindowAppearance(),
+        attach: electronHostWindowAttach(),
+        attention: electronHostWindowAttention(),
+        contentProtection: electronHostWindowContentProtection(),
+        focus: electronHostWindowFocus(),
+        fullscreen: electronHostWindowFullscreen(),
+        geometry: electronHostWindowGeometry(),
+        hierarchy: electronHostWindowHierarchy(),
+        lifecycle: electronHostWindowLifecycle(electron),
+        progress: electronHostWindowProgress(),
+        shadow: electronHostWindowShadow(),
+        shell: electronHostWindowShell(),
+        sizeConstraints: electronHostWindowSizeConstraints(),
+        state: electronHostWindowState(),
+        visibility: electronHostWindowVisibility(),
+        zOrder: electronHostWindowZOrder(),
     };
+}
+export function electronHostWindowAppearance() {
+    const out = {};
     out.setTitle = (win, title) => {
         const bw = _windows.get(win);
         if (bw === undefined)
@@ -79,121 +45,158 @@ export function initializeElectronWindowBackend(out, electron) {
             /* window already destroyed */
         }
     };
-    out.setPosition = (win, x, y) => {
+    out.setIcon = (win, icon) => {
         const bw = _windows.get(win);
         if (bw === undefined)
             return;
         try {
-            bw.setPosition(x, y);
+            bw.setIcon(icon);
         }
         catch {
             /* window already destroyed */
         }
     };
-    out.setSize = (win, width, height) => {
+    out.setOpacity = (win, opacity) => {
         const bw = _windows.get(win);
         if (bw === undefined)
             return;
         try {
-            bw.setSize(width, height);
+            bw.setOpacity(opacity);
         }
         catch {
             /* window already destroyed */
         }
     };
-    out.getBounds = (win, out) => {
+    return out;
+}
+export function electronHostWindowAttach() {
+    const out = {};
+    out.attach = (win, handle, ownership) => {
+        if (!isElectronBrowserWindow(handle))
+            return false;
+        return attachElectronWindow(win, handle, ownership);
+    };
+    return out;
+}
+export function electronHostWindowAttention() {
+    const out = {};
+    out.requestAttention = (win, attention) => {
         const bw = _windows.get(win);
-        if (bw === undefined) {
-            out.x = win.x;
-            out.y = win.y;
-            out.width = win.width;
-            out.height = win.height;
-            return out;
-        }
+        if (bw === undefined)
+            return;
         try {
-            const bounds = bw.getBounds();
-            out.x = bounds.x;
-            out.y = bounds.y;
-            out.width = bounds.width;
-            out.height = bounds.height;
+            bw.flashFrame(attention);
         }
         catch {
-            out.x = win.x;
-            out.y = win.y;
-            out.width = win.width;
-            out.height = win.height;
+            /* window already destroyed */
         }
-        return out;
     };
-    out.minimize = (win) => {
+    out.flashWindowFrame = (win) => {
         const bw = _windows.get(win);
         if (bw === undefined)
             return;
         try {
-            bw.minimize();
+            bw.flashFrame(true);
         }
         catch {
             /* window already destroyed */
         }
     };
-    out.maximize = (win) => {
+    return out;
+}
+export function electronHostWindowContentProtection() {
+    const out = {};
+    out.setContentProtection = (win, enabled) => {
         const bw = _windows.get(win);
         if (bw === undefined)
             return;
         try {
-            bw.maximize();
+            bw.setContentProtection(enabled);
         }
         catch {
             /* window already destroyed */
         }
     };
-    out.restore = (win) => {
+    return out;
+}
+export function electronHostWindowFocus() {
+    const out = {};
+    out.focus = (win) => {
         const bw = _windows.get(win);
         if (bw === undefined)
             return;
         try {
-            if (bw.isMinimized())
-                bw.restore();
-            else
-                bw.unmaximize();
+            bw.focus();
         }
         catch {
             /* window already destroyed */
         }
     };
-    out.focus = (win) => {
+    return out;
+}
+export function electronHostWindowFullscreen() {
+    const out = {};
+    out.setFullscreen = (win, fullscreen) => {
         const bw = _windows.get(win);
         if (bw === undefined)
             return;
         try {
-            bw.focus();
+            bw.setFullScreen(fullscreen);
         }
         catch {
             /* window already destroyed */
         }
     };
-    out.show = (win) => {
+    return out;
+}
+export function electronHostWindowGeometry() {
+    const out = {};
+    out.setPosition = (win, x, y) => {
         const bw = _windows.get(win);
         if (bw === undefined)
             return;
         try {
-            bw.show();
+            bw.setPosition(x, y);
         }
         catch {
             /* window already destroyed */
         }
     };
-    out.hide = (win) => {
+    out.setSize = (win, width, height) => {
         const bw = _windows.get(win);
         if (bw === undefined)
             return;
         try {
-            bw.hide();
+            bw.setSize(width, height);
         }
         catch {
             /* window already destroyed */
         }
     };
+    out.getBounds = (win, out) => {
+        const bw = _windows.get(win);
+        if (bw === undefined) {
+            out.x = win.x;
+            out.y = win.y;
+            out.width = win.width;
+            out.height = win.height;
+            return out;
+        }
+        try {
+            const bounds = bw.getBounds();
+            out.x = bounds.x;
+            out.y = bounds.y;
+            out.width = bounds.width;
+            out.height = bounds.height;
+        }
+        catch {
+            out.x = win.x;
+            out.y = win.y;
+            out.width = win.width;
+            out.height = win.height;
+        }
+        return out;
+    };
     out.center = (win) => {
         const bw = _windows.get(win);
         if (bw === undefined)
@@ -205,183 +208,262 @@ export function initializeElectronWindowBackend(out, electron) {
             /* window already destroyed */
         }
     };
-    out.setResizable = (win, resizable) => {
+    return out;
+}
+export function electronHostWindowHierarchy() {
+    const out = {};
+    out.setParent = (win, parent) => {
         const bw = _windows.get(win);
         if (bw === undefined)
             return;
+        const parentBw = parent === null ? null : (_windows.get(parent) ?? null);
         try {
-            bw.setResizable(resizable);
+            bw.setParentWindow(parentBw);
         }
         catch {
             /* window already destroyed */
         }
     };
-    out.setAlwaysOnTop = (win, alwaysOnTop) => {
-        const bw = _windows.get(win);
-        if (bw === undefined)
-            return;
+    return out;
+}
+export function electronHostWindowLifecycle(electron) {
+    const out = {};
+    out.open = (win, options) => {
+        if (_windowRecords.has(win))
+            return true;
+        const bw = new electron.BrowserWindow({
+            title: options.title,
+            x: options.x,
+            y: options.y,
+            width: options.width,
+            height: options.height,
+            resizable: options.resizable,
+            alwaysOnTop: options.alwaysOnTop,
+            fullscreen: options.fullscreen,
+            show: options.visible,
+            minWidth: options.minWidth,
+            minHeight: options.minHeight,
+            maxWidth: options.maxWidth,
+            maxHeight: options.maxHeight,
+            frame: options.frame,
+            transparent: options.transparent,
+        });
+        if (attachElectronWindow(win, bw, 'flight'))
+            return true;
         try {
-            bw.setAlwaysOnTop(alwaysOnTop);
+            bw.close();
         }
         catch {
-            /* window already destroyed */
+            /* construction succeeded but attachment failed */
         }
+        return false;
     };
-    out.setMinimumSize = (win, width, height) => {
+    out.close = (win) => {
+        detachElectronWindow(win, true);
+    };
+    return out;
+}
+export function electronHostWindowProgress() {
+    const out = {};
+    out.setProgress = (win, progress) => {
         const bw = _windows.get(win);
         if (bw === undefined)
             return;
         try {
-            bw.setMinimumSize(width, height);
+            bw.setProgressBar(progress);
         }
         catch {
             /* window already destroyed */
         }
     };
-    out.setMaximumSize = (win, width, height) => {
+    return out;
+}
+export function electronHostWindowShadow() {
+    const out = {};
+    out.setHasShadow = (win, hasShadow) => {
         const bw = _windows.get(win);
         if (bw === undefined)
             return;
         try {
-            bw.setMaximumSize(width, height);
+            bw.setHasShadow(hasShadow);
         }
         catch {
             /* window already destroyed */
         }
     };
-    out.setFullscreen = (win, fullscreen) => {
+    return out;
+}
+export function electronHostWindowShell() {
+    const out = {};
+    out.setSkipTaskbar = (win, skip) => {
         const bw = _windows.get(win);
         if (bw === undefined)
             return;
         try {
-            bw.setFullScreen(fullscreen);
+            bw.setSkipTaskbar(skip);
         }
         catch {
             /* window already destroyed */
         }
     };
-    out.setIcon = (win, icon) => {
+    out.setMenuBarVisible = (win, visible) => {
         const bw = _windows.get(win);
         if (bw === undefined)
             return;
         try {
-            bw.setIcon(icon);
+            bw.setMenuBarVisibility(visible);
         }
         catch {
             /* window already destroyed */
         }
     };
-    out.setOpacity = (win, opacity) => {
+    return out;
+}
+export function electronHostWindowSizeConstraints() {
+    const out = {};
+    out.setMinimumSize = (win, width, height) => {
         const bw = _windows.get(win);
         if (bw === undefined)
             return;
         try {
-            bw.setOpacity(opacity);
+            bw.setMinimumSize(width, height);
         }
         catch {
             /* window already destroyed */
         }
     };
-    out.setSkipTaskbar = (win, skip) => {
+    out.setMaximumSize = (win, width, height) => {
         const bw = _windows.get(win);
         if (bw === undefined)
             return;
         try {
-            bw.setSkipTaskbar(skip);
+            bw.setMaximumSize(width, height);
         }
         catch {
             /* window already destroyed */
         }
     };
-    out.setMenuBarVisible = (win, visible) => {
+    out.setResizable = (win, resizable) => {
         const bw = _windows.get(win);
         if (bw === undefined)
             return;
         try {
-            bw.setMenuBarVisibility(visible);
+            bw.setResizable(resizable);
         }
         catch {
             /* window already destroyed */
         }
     };
-    out.setParent = (win, parent) => {
+    return out;
+}
+export function electronHostWindowState() {
+    const out = {};
+    out.minimize = (win) => {
         const bw = _windows.get(win);
         if (bw === undefined)
             return;
-        const parentBw = parent === null ? null : (_windows.get(parent) ?? null);
         try {
-            bw.setParentWindow(parentBw);
+            bw.minimize();
         }
         catch {
             /* window already destroyed */
         }
     };
-    out.setProgress = (win, progress) => {
+    out.maximize = (win) => {
         const bw = _windows.get(win);
         if (bw === undefined)
             return;
         try {
-            bw.setProgressBar(progress);
+            bw.maximize();
         }
         catch {
             /* window already destroyed */
         }
     };
-    out.requestAttention = (win, attention) => {
+    out.restore = (win) => {
         const bw = _windows.get(win);
         if (bw === undefined)
             return;
         try {
-            bw.flashFrame(attention);
+            if (bw.isMinimized())
+                bw.restore();
+            else
+                bw.unmaximize();
         }
         catch {
             /* window already destroyed */
         }
     };
-    out.setContentProtection = (win, enabled) => {
+    return out;
+}
+export function electronHostWindowVisibility() {
+    const out = {};
+    out.show = (win) => {
         const bw = _windows.get(win);
         if (bw === undefined)
             return;
         try {
-            bw.setContentProtection(enabled);
+            bw.show();
         }
         catch {
             /* window already destroyed */
         }
     };
-    out.flashWindowFrame = (win) => {
+    out.hide = (win) => {
         const bw = _windows.get(win);
         if (bw === undefined)
             return;
         try {
-            bw.flashFrame(true);
+            bw.hide();
         }
         catch {
             /* window already destroyed */
         }
     };
-    out.setHasShadow = (win, hasShadow) => {
+    return out;
+}
+export function electronHostWindowZOrder() {
+    const out = {};
+    out.setAlwaysOnTop = (win, alwaysOnTop) => {
         const bw = _windows.get(win);
         if (bw === undefined)
             return;
         try {
-            bw.setHasShadow(hasShadow);
+            bw.setAlwaysOnTop(alwaysOnTop);
         }
         catch {
             /* window already destroyed */
         }
     };
+    return out;
+}
+// Returns the AppWindow mapped to the given Electron BrowserWindow id, or null when unknown.
+// Allows tray/menu/protocol handlers to resolve a native window id back into a Flight window entity.
+export function getAppWindowForElectronId(id) {
+    return _windowsById.get(id) ?? null;
+}
+// The Electron BrowserWindow backing a Flight window opened via openWindow, or null if not (yet)
+// opened. The escape hatch a host app needs to do Electron-specific things the seam doesn't cover —
+// most importantly loadFile/loadURL to put content in the window. Host-adapter-only by design.
+export function getElectronBrowserWindow(win) {
+    return _windows.get(win) ?? null;
+}
+// Returns the Electron BrowserWindow id for a Flight window, or -1 when the window is not mapped.
+// Useful for tray/menu click handlers that receive a native window id and need to resolve back to an
+// AppWindow; pair with getAppWindowForElectronId.
+export function getElectronWindowId(win) {
+    return _windows.get(win)?.id ?? -1;
 }
-export function resetElectronWindowBackendForTest() {
+export function resetElectronHostWindowForTest() {
     _windows = new WeakMap();
     _windowRecords = new WeakMap();
     _windowsById.clear();
 }
-// Side table mapping each Flight ApplicationWindow to its Electron BrowserWindow, kept off the public
+// Side table mapping each Flight AppWindow to its Electron BrowserWindow, kept off the public
 // entity. Entries are removed on close so a stale BrowserWindow is never reused.
 let _windows = new WeakMap();
 let _windowRecords = new WeakMap();
-// Reverse lookup by Electron BrowserWindow id for getApplicationWindowForElectronId. Maintained in
+// Reverse lookup by Electron BrowserWindow id for getAppWindowForElectronId. Maintained in
 // lockstep with _windows; entries are removed on close as well.
 const _windowsById = new Map();
 function attachElectronWindow(win, handle, ownership) {
@@ -399,44 +481,44 @@ function attachElectronWindow(win, handle, ownership) {
         const bounds = handle.getBounds();
         win.x = bounds.x;
         win.y = bounds.y;
-        emitSignal(win.onMove);
+        emitSignal(win.onMove, undefined);
     });
     addElectronWindowListener(record, 'resize', () => {
         const bounds = handle.getBounds();
         win.width = bounds.width;
         win.height = bounds.height;
-        emitSignal(win.onResize);
+        emitSignal(win.onResize, undefined);
     });
     addElectronWindowListener(record, 'minimize', () => {
         win.minimized = true;
-        emitSignal(win.onMinimize);
+        emitSignal(win.onMinimize, undefined);
     });
     addElectronWindowListener(record, 'maximize', () => {
         win.maximized = true;
-        emitSignal(win.onMaximize);
+        emitSignal(win.onMaximize, undefined);
     });
     const onUnmaximize = () => {
         win.minimized = false;
         win.maximized = false;
-        emitSignal(win.onRestore);
+        emitSignal(win.onRestore, undefined);
     };
     addElectronWindowListener(record, 'unmaximize', onUnmaximize);
     addElectronWindowListener(record, 'restore', onUnmaximize);
     addElectronWindowListener(record, 'enter-full-screen', () => {
         win.fullscreen = true;
-        emitSignal(win.onFullscreenChanged);
+        emitSignal(win.onFullscreenChanged, undefined);
     });
     addElectronWindowListener(record, 'leave-full-screen', () => {
         win.fullscreen = false;
-        emitSignal(win.onFullscreenChanged);
+        emitSignal(win.onFullscreenChanged, undefined);
     });
     addElectronWindowListener(record, 'focus', () => {
         win.focused = true;
-        emitSignal(win.onFocusIn);
+        emitSignal(win.onFocusIn, undefined);
     });
     addElectronWindowListener(record, 'blur', () => {
         win.focused = false;
-        emitSignal(win.onFocusOut);
+        emitSignal(win.onFocusOut, undefined);
     });
     addElectronWindowListener(record, 'closed', () => {
         detachElectronWindow(win, false);