feat: native platfrom window event emitting in Phoenix.app and tests

abose · abose · commit 72c39a7220d4 · 2026-02-01T10:20:44.000+05:30
diff --git a/src/phoenix/shell.js b/src/phoenix/shell.js
@@ -729,7 +729,72 @@ Phoenix.app = {
     getTimeSinceStartup: function () {
         return Date.now() - Phoenix.startTime; // milliseconds elapsed since app start
     },
-    language: navigator.language
+    language: navigator.language,
+    /**
+     * Broadcast an event to all windows (excludes sender).
+     * @param {string} eventName - Name of the event
+     * @param {*} payload - Event data
+     * @returns {Promise<void>}
+     */
+    emitToAllWindows: async function (eventName, payload) {
+        if (!Phoenix.isNativeApp) {
+            throw new Error("emitToAllWindows is not supported in browsers");
+        }
+        if (window.__TAURI__) {
+            return window.__TAURI__.event.emit(eventName, payload);
+        }
+        if (window.__ELECTRON__) {
+            return window.electronAPI.emitToAllWindows(eventName, payload);
+        }
+    },
+    /**
+     * Send an event to a specific window by label.
+     * @param {string} targetLabel - Window label to send to
+     * @param {string} eventName - Name of the event
+     * @param {*} payload - Event data
+     * @returns {Promise<boolean>} True if window found and event sent
+     */
+    emitToWindow: async function (targetLabel, eventName, payload) {
+        if (!Phoenix.isNativeApp) {
+            throw new Error("emitToWindow is not supported in browsers");
+        }
+        if (window.__TAURI__) {
+            // Tauri doesn't have direct window-to-window emit, use global emit
+            // The listener filters by source if needed
+            return window.__TAURI__.event.emit(eventName, payload);
+        }
+        if (window.__ELECTRON__) {
+            return window.electronAPI.emitToWindow(targetLabel, eventName, payload);
+        }
+        return false;
+    },
+    /**
+     * Listen for events from other windows.
+     * @param {string} eventName - Name of the event to listen for
+     * @param {Function} callback - Called with (payload) when event received
+     * @returns {Function} Unlisten function to remove the listener
+     */
+    onWindowEvent: function (eventName, callback) {
+        if (!Phoenix.isNativeApp) {
+            throw new Error("onWindowEvent is not supported in browsers");
+        }
+        if (window.__TAURI__) {
+            let unlisten = null;
+            window.__TAURI__.event.listen(eventName, (event) => {
+                callback(event.payload);
+            }).then(fn => { unlisten = fn; });
+            // Return a function that will unlisten when called
+            return () => {
+                if (unlisten) {
+                    unlisten();
+                }
+            };
+        }
+        if (window.__ELECTRON__) {
+            return window.electronAPI.onWindowEvent(eventName, callback);
+        }
+        return () => {}; // No-op for unsupported platforms
+    }
 };
 
 if(!window.appshell){
diff --git a/test/spec/Native-platform-test.js b/test/spec/Native-platform-test.js
@@ -75,8 +75,8 @@ define(function (require, exports, module) {
         // Window management - returns platform-specific window object
         // For window spawning tests, we use a helper HTML file
         getTestHtmlPath: () => isElectron
-            ? 'spec/Electron-platform-test.html'
-            : 'spec/Tauri-platform-test.html',
+            ? 'spec/native-platform-electron-test.html'
+            : 'spec/native-platform-tauri-test.html',
 
         // Close window by label (uses platform-agnostic Phoenix.app API)
         closeWindow: (windowObj) => Phoenix.app.closeWindowByLabel(windowObj.label)
@@ -253,44 +253,32 @@ define(function (require, exports, module) {
 
                     let newURL = currentURL.href;
 
-                    if (isElectron) {
-                        // For Electron, use the event system (mirrors Tauri)
-                        // We need to handle race: event might fire before or after window reference is available
-                        let electronWindow = null;
-                        let eventReceived = false;
+                    // Use unified event API for both platforms
+                    let nativeWindow = null;
+                    let eventReceived = false;
 
-                        const tryResolve = () => {
-                            if (electronWindow && eventReceived) {
-                                resolve(electronWindow);
-                            }
-                        };
-
-                        const unlisten = window.electronAPI.onWindowEvent('PLATFORM_API_WORKING', () => {
-                            unlisten();
-                            eventReceived = true;
+                    const tryResolve = () => {
+                        if (nativeWindow && eventReceived) {
+                            resolve(nativeWindow);
+                        }
+                    };
+
+                    const unlisten = Phoenix.app.onWindowEvent('PLATFORM_API_WORKING', () => {
+                        unlisten();
+                        eventReceived = true;
+                        tryResolve();
+                    });
+
+                    Phoenix.app.openURLInPhoenixWindow(newURL)
+                        .then(win => {
+                            expect(win.label.startsWith("extn-")).toBeTrue();
+                            expect(win.isNativeWindow).toBeTrue();
+                            nativeWindow = win;
                             tryResolve();
+                        }).catch(err => {
+                            unlisten();
+                            reject(err);
                         });
-
-                        Phoenix.app.openURLInPhoenixWindow(newURL)
-                            .then(win => {
-                                expect(win.label.startsWith("extn-")).toBeTrue();
-                                expect(win.isNativeWindow).toBeTrue();
-                                electronWindow = win;
-                                tryResolve();
-                            }).catch(err => {
-                                unlisten();
-                                reject(err);
-                            });
-                    } else {
-                        // For Tauri, use the event system
-                        Phoenix.app.openURLInPhoenixWindow(newURL)
-                            .then(tauriWindow => {
-                                expect(tauriWindow.label.startsWith("extn-")).toBeTrue();
-                                tauriWindow.listen('TAURI_API_WORKING', function () {
-                                    resolve(tauriWindow);
-                                });
-                            }).catch(reject);
-                    }
                 });
             }
 
@@ -318,6 +306,90 @@ define(function (require, exports, module) {
             }, 120000);
         });
 
+        describe("Inter-window Event API Tests", function () {
+            // Note: emitToAllWindows excludes the sender, so we test cross-window communication
+            // using spawned windows that emit PLATFORM_API_WORKING event
+
+            it("Should receive events from spawned windows using unified API", async function () {
+                let eventReceived = false;
+                let receivedPayload = null;
+                const unlisten = Phoenix.app.onWindowEvent('PLATFORM_API_WORKING', (payload) => {
+                    eventReceived = true;
+                    receivedPayload = payload;
+                });
+
+                // Small delay for listener registration (Tauri's listen is async)
+                await new Promise(resolve => setTimeout(resolve, 100));
+
+                let currentURL = new URL(location.href);
+                let pathParts = currentURL.pathname.split('/');
+                pathParts[pathParts.length - 1] = platform.getTestHtmlPath();
+                currentURL.pathname = pathParts.join('/');
+
+                const win = await Phoenix.app.openURLInPhoenixWindow(currentURL.href);
+                expect(win.label.startsWith("extn-")).toBeTrue();
+
+                // Wait for the spawned window to emit the event
+                await new Promise(resolve => setTimeout(resolve, 1000));
+
+                expect(eventReceived).toBeTrue();
+                expect(receivedPayload).toBeDefined();
+
+                unlisten();
+                await platform.closeWindow(win);
+            });
+
+            it("Should unlisten properly and not receive events after unlisten", async function () {
+                let callCount = 0;
+                const unlisten = Phoenix.app.onWindowEvent('PLATFORM_API_WORKING', () => {
+                    callCount++;
+                });
+
+                // Small delay for listener registration
+                await new Promise(resolve => setTimeout(resolve, 100));
+
+                // Spawn first window - should receive event
+                let currentURL = new URL(location.href);
+                let pathParts = currentURL.pathname.split('/');
+                pathParts[pathParts.length - 1] = platform.getTestHtmlPath();
+                currentURL.pathname = pathParts.join('/');
+
+                const win1 = await Phoenix.app.openURLInPhoenixWindow(currentURL.href);
+                await new Promise(resolve => setTimeout(resolve, 1000));
+                expect(callCount).toBeGreaterThanOrEqual(1);
+                const countAfterFirst = callCount;
+
+                // Unlisten
+                unlisten();
+                await new Promise(resolve => setTimeout(resolve, 100));
+
+                // Spawn second window - should NOT receive event
+                const win2 = await Phoenix.app.openURLInPhoenixWindow(currentURL.href);
+                await new Promise(resolve => setTimeout(resolve, 1000));
+                expect(callCount).toEqual(countAfterFirst); // Count should not increase
+
+                await platform.closeWindow(win1);
+                await platform.closeWindow(win2);
+            });
+
+            it("Should not throw when emitting events", async function () {
+                // Basic sanity test that emit APIs don't throw
+                await expectAsync(
+                    Phoenix.app.emitToAllWindows('TEST_EVENT', { test: true })
+                ).toBeResolved();
+
+                await expectAsync(
+                    Phoenix.app.emitToWindow('nonexistent-window', 'TEST_EVENT', { test: true })
+                ).toBeResolved();
+            });
+
+            it("Should return unlisten function from onWindowEvent", function () {
+                const unlisten = Phoenix.app.onWindowEvent('TEST_EVENT', () => {});
+                expect(typeof unlisten).toEqual('function');
+                unlisten(); // Should not throw
+            });
+        });
+
         describe("Credentials OTP API Tests", function () {
             const scopeName = "testScope";
             const trustRing = window.specRunnerTestKernalModeTrust;
diff --git a/test/spec/native-platform-electron-test.html b/test/spec/native-platform-electron-test.html
diff --git a/test/spec/native-platform-tauri-test.html b/test/spec/native-platform-tauri-test.html
@@ -4,7 +4,8 @@
     <meta charset="UTF-8">
     <title>Test tauri apis accessible</title>
     <script>
-        window.__TAURI__.event.emit('TAURI_API_WORKING', { data: 'Hello from Window!' });
+        // Use same event name as Electron for unified API testing
+        window.__TAURI__.event.emit('PLATFORM_API_WORKING', { data: 'Hello from Window!' });
     </script>
 </head>
 <body>
