@openfin/core 27.70.1 → 27.70.2

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 = {

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@openfin/core",
-    "version": "27.70.1",
+    "version": "27.70.2",
     "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

@@ -384,5 +384,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

@@ -383,6 +383,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;