@openfin/core 26.70.3 → 27.70.3

package/OpenFin.d.ts

@@ -874,7 +874,56 @@ declare namespace OpenFin {
             payload: import('./src/api/events/window').WindowOptionsChangedEvent<'window', 'options-changed'>
         ): Promise<OpenFin.HostContextChangedPayload | undefined>;
 
+        /**
+         * Closes a Window.
+         * By default it will fire any before unload handler set by a View in the Window.
+         * This can be disabled by setting skipBeforeUnload in the options object of the payload.
+         * This method is called by {@link Platform#closeWindow Platform.closeWindow}.
+         * @param {CloseWindowPayload} payload Object that contains the Window Identity and related options.
+         * @param {Identity} callerIdentity
+         * @returns {Promise<void>}
+         */
         closeWindow(payload: CloseWindowPayload, callerIdentity: Identity): Promise<void>;
+
+        /**
+         * Gets all the Views attached to a Window that should close along with it. This is meant to be overridable
+         * in the case where you want to return other Views that may not be attached to the Window that is closing.
+         * @param winId Identity of the Window that is closing
+         * @returns { Promise<View> }
+         */
+        getViewsForWindowClose(windowId: OpenFin.Identity): Promise<OpenFin.View[]>;
+
+        /**
+         * It takes in an array of Views and returns an object specifying which of them are trying to prevent an unload and which are not.
+         * @param {View[]} views Array of Views
+         * @returns { Promise<ViewStatuses> }
+         */
+        checkViewsForPreventUnload(views: OpenFin.View[]): Promise<OpenFin.ViewStatuses>;
+
+        /**
+         * Handle the decision of whether a Window or specific View should close when trying to prevent an unload. This is meant to be overridden.
+         * Called in {@link PlatformProvider#closeWindow PlatformProvider.closeWindow}.
+         * Normally you would use this method to show a dialog indicating that there are Views that are trying to prevent an unload.
+         * By default it will always return all Views passed into it as meaning to close.
+         * @param {ViewsPreventingUnloadPayload} payload
+         * @tutorial PlatformProvider.getUserDecisionForBeforeUnload
+         * @returns {Promise<BeforeUnloadUserDecision>}
+         */
+        getUserDecisionForBeforeUnload(
+            payload: OpenFin.ViewsPreventingUnloadPayload
+        ): Promise<OpenFin.BeforeUnloadUserDecision>;
+
+        /**
+         * Handles the closing of a Window and/or its Views. Called in {@link PlatformProvider#closeWindow PlatformProvider.closeWindow}.
+         * The return of {@link PlatformProvider#getUserDecisionForBeforeUnload PlatformProvider.getUserDecisionForBeforeUnload} is passed into this method.
+         * @param {Identity} winId Identity of the Window
+         * @param {BeforeUnloadUserDecision} userDecision Decision object
+         * @returns {Promise<void>}
+         */
+        handleViewsAndWindowClose(
+            windowId: OpenFin.Identity,
+            userDecision: OpenFin.BeforeUnloadUserDecision
+        ): Promise<void>;
     };
 
     export type InitPlatformOptions = {
@@ -1572,8 +1621,9 @@ declare namespace OpenFin {
 
     export type PopupBlurBehavior = 'modal' | PopupBaseBehavior;
 
+    type Optional<T, K extends keyof T> = Pick<Partial<T>, K> & Omit<T, K>;
     export interface PopupOptions {
-        initialOptions?: OpenFin.WindowCreationOptions;
+        initialOptions?: Optional<OpenFin.WindowCreationOptions, 'name'>;
         additionalOptions?: OpenFin.UpdatableWindowOptions;
         name?: string;
         url?: string;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@openfin/core",
-    "version": "26.70.3",
+    "version": "27.70.3",
     "license": "Apache-2.0",
     "main": "./src/mock.js",
     "types": "./src/mock.d.ts",

package/src/api/platform/Instance.d.ts

@@ -119,6 +119,15 @@ export declare class Platform extends EmitterBase<PlatformEvents> {
      * @experimental
      */
     getWindowContext(target?: OpenFin.Identity): Promise<any>;
+    /**
+     * Closes a window. If enableBeforeUnload is enabled in the Platform options, any beforeunload handler set on Views will fire
+     * This behavior can be disabled by setting skipBeforeUnload to false in the options parameter.
+     * @param {Identity} winId
+     * @param {closeWindowoptions} [options]
+     * @returns {Promise<void>}
+     * @tutorial Platform.closeWindow
+     * @experimental
+     */
     closeWindow(windowId: OpenFin.Identity, options?: {
         skipBeforeUnload: boolean;
     }): Promise<void>;

package/src/api/platform/Instance.js

@@ -293,6 +293,15 @@ class Platform extends base_1.EmitterBase {
             entityType
         });
     }
+    /**
+     * Closes a window. If enableBeforeUnload is enabled in the Platform options, any beforeunload handler set on Views will fire
+     * This behavior can be disabled by setting skipBeforeUnload to false in the options parameter.
+     * @param {Identity} winId
+     * @param {closeWindowoptions} [options]
+     * @returns {Promise<void>}
+     * @tutorial Platform.closeWindow
+     * @experimental
+     */
     async closeWindow(windowId, options = { skipBeforeUnload: false }) {
         this.wire.sendAction('platform-close-window', this.identity).catch((e) => {
             // don't expose

package/src/api/view/Instance.d.ts

@@ -303,6 +303,15 @@ export declare class View extends WebContents<ViewEvents> {
      * @return {Promise.<void>}
      * @tutorial View.inspectServiceWorker
      */
+    /**
+     * Shows a popup window. If the window this view is currently attached to has a popup open, closes it.
+     * @function showPopupWindow
+     * @memberOf View
+     * @instance
+     * @param {PopupOptions} options
+     * @return {Promise<PopupResult>}
+     * @tutorial View.showPopupWindow
+     */
     /**
      * Attaches the current view to a the given window identity.
      * Identity must be the identity of a window in the same application.
@@ -384,5 +393,12 @@ export declare class View extends WebContents<ViewEvents> {
      * @experimental
      */
     getCurrentWindow: () => Promise<OpenFin.Window>;
+    /**
+     * Triggers the before-unload handler for the View, if one is set. Returns `true` if the handler is trying to prevent the View from unloading, and `false` if it isn't.
+     * Only enabled when setting enableBeforeUnload: true in your View options. If this option is not enabled it will always return false.
+     * @returns {Promise<boolean>}
+     * @tutorial View.triggerBeforeUnload
+     * @experimental
+     */
     triggerBeforeUnload: () => Promise<boolean>;
 }

package/src/api/view/Instance.js

@@ -2,6 +2,8 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.View = void 0;
 /* eslint-disable import/prefer-default-export */
+/* eslint-disable consistent-return */
+/* eslint-disable @typescript-eslint/no-non-null-assertion */
 const main_1 = require("../webcontents/main");
 const window_1 = require("../window");
 /**
@@ -273,6 +275,15 @@ class View extends main_1.WebContents {
          * @return {Promise.<void>}
          * @tutorial View.inspectServiceWorker
          */
+        /**
+         * Shows a popup window. If the window this view is currently attached to has a popup open, closes it.
+         * @function showPopupWindow
+         * @memberOf View
+         * @instance
+         * @param {PopupOptions} options
+         * @return {Promise<PopupResult>}
+         * @tutorial View.showPopupWindow
+         */
         /**
          * Attaches the current view to a the given window identity.
          * Identity must be the identity of a window in the same application.
@@ -349,7 +360,7 @@ class View extends main_1.WebContents {
          * @experimental
          */
         this.getParentLayout = async () => {
-            this.wire.sendAction('view-get-parent-layout', { ...this.identity }).catch((e) => {
+            this.wire.sendAction('view-get-parent-layout', { ...this.identity }).catch(() => {
                 // don't expose
             });
             const currentWindow = await this.getCurrentWindow();
@@ -383,6 +394,13 @@ class View extends main_1.WebContents {
             const { payload: { data } } = await this.wire.sendAction('get-view-window', { ...this.identity });
             return new window_1._Window(this.wire, data);
         };
+        /**
+         * Triggers the before-unload handler for the View, if one is set. Returns `true` if the handler is trying to prevent the View from unloading, and `false` if it isn't.
+         * Only enabled when setting enableBeforeUnload: true in your View options. If this option is not enabled it will always return false.
+         * @returns {Promise<boolean>}
+         * @tutorial View.triggerBeforeUnload
+         * @experimental
+         */
         this.triggerBeforeUnload = async () => {
             const message = await this.wire.sendAction('trigger-before-unload', { ...this.identity });
             return message.payload.data;

package/src/api/webcontents/main.d.ts

@@ -32,5 +32,6 @@ export declare class WebContents<T extends WebContentsEventMapping> extends Emit
     inspectSharedWorker(): Promise<void>;
     inspectSharedWorkerById(workerId: string): Promise<void>;
     inspectServiceWorker(): Promise<void>;
+    showPopupWindow(options: OpenFin.PopupOptions): Promise<OpenFin.PopupResult>;
 }
 export {};

package/src/api/webcontents/main.js

@@ -78,5 +78,68 @@ class WebContents extends base_1.EmitterBase {
     async inspectServiceWorker() {
         await this.wire.sendAction('inspect-service-worker', { ...this.identity });
     }
+    async showPopupWindow(options) {
+        this.wire.sendAction(`${this.entityType}-show-popup-window`, this.identity).catch(() => {
+            // we do not want to expose this error, just continue if this analytics-only call fails
+        });
+        if (options === null || options === void 0 ? void 0 : options.onPopupReady) {
+            const readyListener = async ({ popupName }) => {
+                try {
+                    const popupWindow = this.fin.Window.wrapSync({ uuid: this.fin.me.uuid, name: popupName });
+                    await options.onPopupReady(popupWindow);
+                }
+                catch (error) {
+                    throw new Error(`Something went wrong during onPopupReady execution: ${error}`);
+                }
+            };
+            await this.once('popup-ready', readyListener);
+        }
+        const { payload: tryCreatePayload } = await this.wire.sendAction('try-create-popup-window', {
+            options: {
+                ...options,
+                // Internal use only.
+                // @ts-expect-error
+                hasResultCallback: !!(options === null || options === void 0 ? void 0 : options.onPopupResult),
+                hasReadyCallback: !!(options === null || options === void 0 ? void 0 : options.onPopupReady)
+            },
+            ...this.identity
+        });
+        const { data: { willOpen, options: popupOptions } } = tryCreatePayload;
+        if (willOpen) {
+            await this.wire.environment.createChildContent({
+                options: popupOptions.initialOptions,
+                entityType: 'window'
+            });
+        }
+        const normalizePopupResult = (payload) => {
+            const { name, uuid, result, data } = payload;
+            const popupResult = {
+                identity: {
+                    name,
+                    uuid
+                },
+                result
+            };
+            if (data) {
+                popupResult.data = data;
+            }
+            return popupResult;
+        };
+        if (options === null || options === void 0 ? void 0 : options.onPopupResult) {
+            const dispatchResultListener = async (payload) => {
+                await options.onPopupResult(normalizePopupResult(payload));
+            };
+            const teardownListener = async () => {
+                await this.removeListener('popup-result', dispatchResultListener);
+            };
+            await this.on('popup-result', dispatchResultListener);
+            await this.once('popup-teardown', teardownListener);
+        }
+        const { payload } = await this.wire.sendAction('show-popup-window', {
+            options: popupOptions,
+            ...this.identity
+        });
+        return payload.data;
+    }
 }
 exports.WebContents = WebContents;

package/src/api/window/Instance.d.ts

@@ -994,11 +994,13 @@ export declare class _Window extends WebContents<WindowEvents> {
      */
     /**
      * Shows a popup window. If this window currently has a popup open, closes it.
+     * @function showPopupWindow
+     * @memberOf Window
+     * @instance
      * @param {PopupOptions} options
      * @return {Promise<PopupResult>}
      * @tutorial Window.showPopupWindow
      */
-    showPopupWindow(options: OpenFin.PopupOptions): Promise<OpenFin.PopupResult>;
     /**
      * Dispatch a result to the caller of `showPopupWindow`. If this window isn't currently being shown as a popup, this call will silently fail.
      * @param {*} data Serializable data to send to the caller window.

package/src/api/window/Instance.js

@@ -1233,70 +1233,13 @@ class _Window extends main_1.WebContents {
      */
     /**
      * Shows a popup window. If this window currently has a popup open, closes it.
+     * @function showPopupWindow
+     * @memberOf Window
+     * @instance
      * @param {PopupOptions} options
      * @return {Promise<PopupResult>}
      * @tutorial Window.showPopupWindow
      */
-    async showPopupWindow(options) {
-        this.wire.sendAction('window-show-popup-window', this.identity).catch((e) => {
-            // we do not want to expose this error, just continue if this analytics-only call fails
-        });
-        if (options === null || options === void 0 ? void 0 : options.onPopupReady) {
-            const readyListener = async ({ popupName }) => {
-                try {
-                    const popupWindow = this.fin.Window.wrapSync({ uuid: this.fin.me.uuid, name: popupName });
-                    await options.onPopupReady(popupWindow);
-                }
-                catch (error) {
-                    throw new Error(`Something went wrong during onPopupReady execution: ${error}`);
-                }
-            };
-            await this.once('popup-ready', readyListener);
-        }
-        const { payload: tryCreatePayload } = await this.wire.sendAction('try-create-popup-window', {
-            options: {
-                ...options,
-                // Internal use only.
-                // @ts-expect-error
-                hasResultCallback: !!(options === null || options === void 0 ? void 0 : options.onPopupResult),
-                hasReadyCallback: !!(options === null || options === void 0 ? void 0 : options.onPopupReady)
-            },
-            ...this.identity
-        });
-        const { data: { willOpen, options: popupOptions } } = tryCreatePayload;
-        if (willOpen) {
-            await this.wire.environment.createChildContent({
-                options: popupOptions.initialOptions,
-                entityType: 'window'
-            });
-        }
-        const normalizePopupResult = (payload) => {
-            const { name, uuid, result, data } = payload;
-            return {
-                identity: {
-                    name,
-                    uuid
-                },
-                result,
-                data
-            };
-        };
-        if (options === null || options === void 0 ? void 0 : options.onPopupResult) {
-            const dispatchResultListener = async (payload) => {
-                await options.onPopupResult(normalizePopupResult(payload));
-            };
-            const teardownListener = async () => {
-                await this.removeListener('popup-result', dispatchResultListener);
-            };
-            await this.on('popup-result', dispatchResultListener);
-            await this.once('popup-teardown', teardownListener);
-        }
-        const { payload } = await this.wire.sendAction('show-popup-window', {
-            options: popupOptions,
-            ...this.identity
-        });
-        return payload.data;
-    }
     /**
      * Dispatch a result to the caller of `showPopupWindow`. If this window isn't currently being shown as a popup, this call will silently fail.
      * @param {*} data Serializable data to send to the caller window.