@openfin/core 31.74.31 → 32.75.6

package/src/api/platform/layout/controllers/layout-entities-controller.d.ts

@@ -9,7 +9,9 @@ type ViewCreationOrReference = OpenFin.Identity | OpenFin.PlatformViewCreationOp
 export declare class LayoutEntitiesController {
     private layoutManager;
     private layoutContentCache;
+    private wire;
     constructor(layoutManager: any, layoutContentCache: LayoutContentCache);
+    private analytics;
     /**
      * @internal
      * @returns the root contentItem of the layout.
@@ -86,6 +88,7 @@ export declare class LayoutEntitiesController {
      * @throws If the view does not exist, fails to create, or the stack does not exist.
      */
     addViewToStack: (stackEntityId: string, viewCreationOrReference: ViewCreationOrReference, { index }?: OpenFin.AddViewToStackOptions) => Promise<OpenFin.Identity>;
+    private findViewInStack;
     /**
      * @internal
      * Removes a view from the given stack. If it's the only view, the stack will be destroyed, unless window creation
@@ -101,15 +104,16 @@ export declare class LayoutEntitiesController {
      * Creates a new adjacent 'stack' and adds the views to it at the specified position
      * @param targetId Entity id of the content item to add a stack adjacent to it
      * @param views List of identities or view creation options of the views to include in the stack
-     * @param options Creation options, defaults to position: 'right'
+     * @param options Creation options, defaults to { position: 'right' }
      * @returns the Entity Id of the new stack
      */
-    createAdjacentStack: (targetId: string, views: ViewCreationOrReference[], options: {
+    createAdjacentStack: (targetId: string, views: ViewCreationOrReference[], { position }?: {
         position?: OpenFin.LayoutPosition;
     }) => Promise<string>;
     getAdjacentStacks: ({ targetId, edge }: {
         targetId: string;
         edge: OpenFin.LayoutPosition;
     }) => Promise<Pick<OpenFin.LayoutEntityDefinition, 'entityId'>[]>;
+    setStackActiveView: (stackEntityId: string, viewIdentity: OpenFin.Identity) => Promise<void>;
 }
 export {};

package/src/api/platform/layout/controllers/layout-entities-controller.js

@@ -20,11 +20,17 @@ class LayoutEntitiesController {
     layoutManager, layoutContentCache) {
         this.layoutManager = layoutManager;
         this.layoutContentCache = layoutContentCache;
+        this.analytics = (topic) => {
+            this.wire.sendAction(`layout-controller-${topic}`).catch(() => {
+                // don't expose
+            });
+        };
         /**
          * @internal
          * @returns the root contentItem of the layout.
          */
         this.getRoot = () => {
+            this.analytics('get-root');
             const root = this.layoutManager.layout.root.contentItems[0];
             return {
                 // TODO: fix typing
@@ -41,6 +47,7 @@ class LayoutEntitiesController {
          */
         this.getStackByView = async (view) => {
             var _a, _b, _c, _d;
+            this.analytics('get-stack-by-view');
             const viewComponent = this.layoutManager.getViewComponent(view);
             if (!viewComponent || ((_b = (_a = viewComponent.container) === null || _a === void 0 ? void 0 : _a.parent) === null || _b === void 0 ? void 0 : _b.parent.type) !== 'stack') {
                 return undefined;
@@ -63,6 +70,7 @@ class LayoutEntitiesController {
          * @throws if the content item associated with the entity id does not exist or is not a stack.
          */
         this.getStackViews = (id) => {
+            this.analytics('get-stack-views');
             const stack = this.layoutContentCache.getContentItemOrThrow(id, ['stack']);
             const views = stack.contentItems.map((ci) => {
                 var _a;
@@ -80,6 +88,7 @@ class LayoutEntitiesController {
          */
         this.isRoot = (id) => {
             var _a;
+            this.analytics('is-root');
             const ci = this.layoutContentCache.getContentItemOrThrow(id);
             return !!((_a = ci.parent) === null || _a === void 0 ? void 0 : _a.isRoot);
         };
@@ -90,6 +99,7 @@ class LayoutEntitiesController {
          * @returns True if the content item exists and belongs to the layout.
          */
         this.exists = (entityId) => {
+            this.analytics('exists');
             return this.layoutContentCache.hasKey(entityId);
         };
         /**
@@ -109,6 +119,7 @@ class LayoutEntitiesController {
          * @throws If the view does not exist, fails to create, or the stack does not exist.
          */
         this.addViewToStack = async (stackEntityId, viewCreationOrReference, { index } = { index: 0 }) => {
+            this.analytics('add-view-to-stack');
             const currentStack = this.layoutContentCache.getContentItemOrThrow(stackEntityId);
             if (index && index > currentStack.contentItems.length + 1) {
                 throw new Error(`Index '${index}' out of range, please exclude the index or specify a number between 0 and ${currentStack.contentItems.length}`);
@@ -123,6 +134,9 @@ class LayoutEntitiesController {
             });
             return identity;
         };
+        this.findViewInStack = (stack, viewIdentity) => {
+            return stack.contentItems.find((ci) => { var _a, _b; return ((_b = (_a = ci.config) === null || _a === void 0 ? void 0 : _a.componentState) === null || _b === void 0 ? void 0 : _b.name) === viewIdentity.name; });
+        };
         /**
          * @internal
          * Removes a view from the given stack. If it's the only view, the stack will be destroyed, unless window creation
@@ -133,9 +147,11 @@ class LayoutEntitiesController {
          * @throws If the stack does not exist or the view does not exist or belong to the stack.
          */
         this.removeViewFromStack = async (stackEntityId, view) => {
-            const views = this.getStackViews(stackEntityId);
-            if (!views.find((existingView) => existingView.name === view.name)) {
-                throw new Error(`Tried to remove a view ('${view.name}') which does not exist in the stack.`);
+            this.analytics('remove-view-from-stack');
+            const stack = this.layoutContentCache.getContentItemOrThrow(stackEntityId, ['stack']);
+            const viewInstance = this.findViewInStack(stack, view);
+            if (!viewInstance) {
+                throw new Error(`Tried to remove a view ('${view.name}') which does not belong to the stack.`);
             }
             await this.layoutManager.platform.closeView(view);
         };
@@ -144,14 +160,14 @@ class LayoutEntitiesController {
          * Creates a new adjacent 'stack' and adds the views to it at the specified position
          * @param targetId Entity id of the content item to add a stack adjacent to it
          * @param views List of identities or view creation options of the views to include in the stack
-         * @param options Creation options, defaults to position: 'right'
+         * @param options Creation options, defaults to { position: 'right' }
          * @returns the Entity Id of the new stack
          */
-        this.createAdjacentStack = async (targetId, views, options) => {
-            if (views.length === 0) {
-                throw new Error('Cannot create stack with empty view array.');
+        this.createAdjacentStack = async (targetId, views, { position = 'right' } = {}) => {
+            this.analytics('create-adjacent-stack');
+            if (!Array.isArray(views) || views.length === 0) {
+                throw new Error('The parameter "views" must be an array with at least 1 element.');
             }
-            const { position = 'right' } = options;
             if (!['top', 'bottom', 'left', 'right'].includes(position)) {
                 throw new Error(`Invalid position '${position}' specified.`);
             }
@@ -176,12 +192,23 @@ class LayoutEntitiesController {
             return entityId;
         };
         this.getAdjacentStacks = async ({ targetId, edge }) => {
+            this.analytics('get-adjacent-stacks');
             const contentItem = this.layoutContentCache.getContentItemOrThrow(targetId);
             // call utils helper to traverse and return adjacent stacks
             return (0, layout_traversal_1.getAdjacentStacks)(contentItem, edge).map((stack) => ({
                 entityId: this.layoutContentCache.getOrCreateEntityId(stack),
             }));
         };
+        this.setStackActiveView = async (stackEntityId, viewIdentity) => {
+            this.analytics('set-stack-active-view');
+            const stack = this.layoutContentCache.getContentItemOrThrow(stackEntityId, ['stack']);
+            const view = this.findViewInStack(stack, viewIdentity);
+            if (!view) {
+                throw new Error(`Tried to set a view ('${viewIdentity.name}') as active when it does not belong to the stack.`);
+            }
+            stack.setActiveContentItem(view, true);
+        };
+        this.wire = this.layoutManager.platform.wire;
     }
     /**
      * @internal
@@ -192,6 +219,7 @@ class LayoutEntitiesController {
      * @throws if the entity associated with {@link id} is not in the entity cache, does not belogn to a layout, or is not a column/row.
      */
     getContent(id) {
+        this.analytics('get-content');
         const ci = this.layoutContentCache.getContentItemOrThrow(id, ['column', 'row']);
         return ci.contentItems.map((item) => ({
             type: item.type,
@@ -208,6 +236,7 @@ class LayoutEntitiesController {
      * content item or has been removed from the layout entirely.
      */
     getParent(id) {
+        this.analytics('get-parent');
         const ci = this.layoutContentCache.getContentItemOrThrow(id);
         if (ci.parent && !ci.parent.isRoot && ci.parent.contentItems.includes(ci)) {
             return {
@@ -252,4 +281,7 @@ __decorate([
 __decorate([
     (0, decorators_1.expose)()
 ], LayoutEntitiesController.prototype, "getAdjacentStacks", void 0);
+__decorate([
+    (0, decorators_1.expose)()
+], LayoutEntitiesController.prototype, "setStackActiveView", void 0);
 exports.LayoutEntitiesController = LayoutEntitiesController;

package/src/api/platform/layout/controllers/tab-drag-controller.d.ts

@@ -1,6 +1,6 @@
 import type * as OpenFin from '../../../../OpenFin';
 import { ViewOverlay } from '../utils/view-overlay';
-import { View } from '../../../view';
+type View = OpenFin.View;
 /**
  * Set of apis used to facilitate tab drag interactions without needing to hide views.
  * @ignore
@@ -56,3 +56,4 @@ export declare class TabDragController {
      */
     observeOverlay: (dropZonePreview: HTMLElement) => Promise<void>;
 }
+export {};

package/src/api/platform/layout/entities/layout-entities.d.ts

@@ -63,8 +63,8 @@ export declare abstract class LayoutNode {
     }) => Promise<TabStack>;
     /**
      * Finds the immediate adjacent layout item given an edge Position
-     * @param edgePosition
-     * @returns either {@link TabStack} or {@link ColumnOrRow} that was found, or `undefined` if there is no item with that edgePosition
+     * @param edge
+     * @returns an array of {@link TabStack} found, if none found returns an empty array.
      */
     getAdjacentStacks: (edge: OpenFin.LayoutPosition) => Promise<TabStack[]>;
 }
@@ -114,6 +114,16 @@ export declare class TabStack extends LayoutNode {
      * @throws If the {@link TabStack} has been destroyed.
      */
     removeView: (view: OpenFin.Identity) => Promise<void>;
+    /**
+     * Sets the active view of the {@link TabStack} without focusing it.
+     * @param view {@link OpenFin.Identity Identity} of the view to activate.
+     * @returns Promise which resolves with void once the view has been activated.
+     * @throws If the {@link TabStack} has been destroyed.
+     * @throws If the view does not exist.
+     * @tutorial TabStack.setActiveView
+     * @experimental
+     */
+    setActiveView: (view: OpenFin.Identity) => Promise<void>;
 }
 /**
  * A {@link ColumnOrRow} is used to manage the state of a ColumnOrRow within an OpenFin Layout.

package/src/api/platform/layout/entities/layout-entities.js

@@ -74,8 +74,8 @@ class LayoutNode {
         };
         /**
          * Finds the immediate adjacent layout item given an edge Position
-         * @param edgePosition
-         * @returns either {@link TabStack} or {@link ColumnOrRow} that was found, or `undefined` if there is no item with that edgePosition
+         * @param edge
+         * @returns an array of {@link TabStack} found, if none found returns an empty array.
          */
         this.getAdjacentStacks = async (edge) => {
             const adjacentStacks = await __classPrivateFieldGet(this, _LayoutNode_client, "f").getAdjacentStacks({
@@ -171,6 +171,18 @@ class TabStack extends LayoutNode {
         this.removeView = async (view) => {
             await __classPrivateFieldGet(this, _TabStack_client, "f").removeViewFromStack(this.entityId, view);
         };
+        /**
+         * Sets the active view of the {@link TabStack} without focusing it.
+         * @param view {@link OpenFin.Identity Identity} of the view to activate.
+         * @returns Promise which resolves with void once the view has been activated.
+         * @throws If the {@link TabStack} has been destroyed.
+         * @throws If the view does not exist.
+         * @tutorial TabStack.setActiveView
+         * @experimental
+         */
+        this.setActiveView = async (view) => {
+            await __classPrivateFieldGet(this, _TabStack_client, "f").setStackActiveView(this.entityId, view);
+        };
         __classPrivateFieldSet(this, _TabStack_client, client, "f");
     }
 }

package/src/api/platform/layout/utils/layout-traversal.d.ts

@@ -1,3 +1,4 @@
 import type * as OpenFin from '../../../../OpenFin';
 export declare const getAdjacentItem: (component: GoldenLayout.ContentItem, edge: OpenFin.LayoutPosition) => GoldenLayout.ContentItem | undefined;
+export declare const doShareEdge: (from: GoldenLayout.ContentItem, to: GoldenLayout.ContentItem, edge: OpenFin.LayoutPosition) => boolean;
 export declare const getAdjacentStacks: (item: GoldenLayout.ContentItem, edge: OpenFin.LayoutPosition) => GoldenLayout.ContentItem[];

package/src/api/platform/layout/utils/layout-traversal.js

@@ -1,9 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getAdjacentStacks = exports.getAdjacentItem = void 0;
+exports.getAdjacentStacks = exports.doShareEdge = exports.getAdjacentItem = void 0;
 const getAdjacentItem = (component, edge) => {
     const { parent } = component;
-    // need to handle the case where a stack is the parent content item
     if (parent.isRoot) {
         return undefined;
     }
@@ -19,25 +18,26 @@ const getAdjacentItem = (component, edge) => {
     return (0, exports.getAdjacentItem)(parent, edge);
 };
 exports.getAdjacentItem = getAdjacentItem;
-const doShareEdge = (a, b, edge) => {
+const doShareEdge = (from, to, edge) => {
     var _a, _b;
-    const boundsA = (_a = a.element.get(0)) === null || _a === void 0 ? void 0 : _a.getBoundingClientRect();
-    const boundsB = (_b = b.element.get(0)) === null || _b === void 0 ? void 0 : _b.getBoundingClientRect();
-    if (!boundsA || !boundsB) {
+    const boundsFrom = (_a = from.element.get(0)) === null || _a === void 0 ? void 0 : _a.getBoundingClientRect();
+    const boundsTo = (_b = to.element.get(0)) === null || _b === void 0 ? void 0 : _b.getBoundingClientRect();
+    if (!boundsFrom || !boundsTo) {
         return false;
     }
     if (['top', 'bottom'].includes(edge)) {
-        return ((boundsB.left >= boundsA.left && boundsB.left < boundsA.right) ||
-            (boundsB.right > boundsA.left && boundsB.right <= boundsA.right));
+        const horizontallyOutOfBounds = boundsFrom.right < boundsTo.left || boundsFrom.left > boundsTo.right;
+        return !horizontallyOutOfBounds;
     }
-    return ((boundsB.top >= boundsA.top && boundsB.top < boundsA.bottom) ||
-        (boundsB.bottom > boundsA.top && boundsB.bottom <= boundsA.bottom));
+    const verticallyOutOfBounds = boundsFrom.bottom < boundsTo.top || boundsFrom.top > boundsTo.bottom;
+    return !verticallyOutOfBounds;
 };
+exports.doShareEdge = doShareEdge;
 const getAdjacentStacks = (item, edge) => {
     const targetContainer = ['top', 'bottom'].includes(edge) ? 'row' : 'column';
     const findEdgeStacks = (component) => {
         if (component.type === 'stack') {
-            if (doShareEdge(item, component, edge)) {
+            if ((0, exports.doShareEdge)(item, component, edge)) {
                 return [component];
             }
             return [];

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

@@ -1,5 +1,5 @@
-import { WindowOptionsChangedEvent } from '../events/window';
 import * as OpenFin from '../../OpenFin';
+type WindowOptionsChangedEvent = OpenFin.WindowEvents.WindowOptionsChangedEvent;
 /**
  * This class handles Platform actions. It does not need to be used directly by developers.
  * However, its methods can be overriden by passing an `overrideCallback` to {@link Platform#init Platform.init}
@@ -160,3 +160,4 @@ export interface PlatformProvider {
      */
     handleViewsAndWindowClose(windowId: OpenFin.Identity, userDecision: OpenFin.BeforeUnloadUserDecision): Promise<void>;
 }
+export {};

package/src/api/system/index.d.ts

@@ -460,6 +460,15 @@ export default class System extends EmitterBase<OpenFin.SystemEvent> {
      */
     getServiceConfiguration(serviceIdentifier: OpenFin.ServiceIdentifier): Promise<OpenFin.ServiceConfiguration>;
     protected getSystemAppConfig(name: string): Promise<any>;
+    /**
+     * Registers a system shutdown handler so user can do some cleanup before system is shutting down.
+     * Note: Once system shutdown starts, you are unable to cancel it.
+     * @param { SystemShutdownHandler } handler system shutdown handler
+     * @return {Promise.<void>}
+     * @tutorial System.registerShutdownHandler
+     * @experimental
+     */
+    registerShutdownHandler(handler: OpenFin.SystemShutdownHandler): Promise<void>;
     /**
      * Signals the RVM to perform a health check and returns the results as json.
      * @return {Promise.<string[]>}

package/src/api/system/index.js

@@ -538,7 +538,7 @@ class System extends base_1.EmitterBase {
             const dlError = (payload) => {
                 cleanListeners();
                 const { reason, err: error } = payload;
-                reject(new transport_errors_1.RuntimeError({ reason, error }));
+                reject(new transport_errors_1.RuntimeError({ reason, error }, transport_errors_1.RuntimeError.getCallSite(3)));
             };
             const dlComplete = () => {
                 cleanListeners();
@@ -568,6 +568,7 @@ class System extends base_1.EmitterBase {
      * @tutorial System.downloadRuntime
      */
     downloadRuntime(options, progressListener) {
+        const callsites = transport_errors_1.RuntimeError.getCallSite();
         return new Promise((resolve, reject) => {
             // node.js environment not supported
             if (this.wire.environment.constructor.name === 'NodeEnvironment') {
@@ -593,7 +594,7 @@ class System extends base_1.EmitterBase {
             const dlError = (payload) => {
                 cleanListeners();
                 const { reason, err: error } = payload;
-                reject(new transport_errors_1.RuntimeError({ reason, error }));
+                reject(new transport_errors_1.RuntimeError({ reason, error }, callsites));
             };
             const dlComplete = () => {
                 cleanListeners();
@@ -735,6 +736,34 @@ class System extends base_1.EmitterBase {
         }
         return this.wire.sendAction('get-system-app-configuration', { name }).then(({ payload }) => payload.data);
     }
+    /**
+     * Registers a system shutdown handler so user can do some cleanup before system is shutting down.
+     * Note: Once system shutdown starts, you are unable to cancel it.
+     * @param { SystemShutdownHandler } handler system shutdown handler
+     * @return {Promise.<void>}
+     * @tutorial System.registerShutdownHandler
+     * @experimental
+     */
+    async registerShutdownHandler(handler) {
+        this.wire.sendAction('system-register-shutdown-handler').catch((e) => {
+            // don't expose, analytics-only call
+        });
+        const SystemShutdownEventName = 'system-shutdown';
+        const SystemShutdownHandledEventName = 'system-shutdown-handled';
+        const { uuid, name } = this.wire.me;
+        const shutdownHandler = (payload) => {
+            const proceed = () => {
+                // notify core that the app is ready for shutdown
+                this.wire.environment.raiseEvent(`application/${SystemShutdownHandledEventName}`, {
+                    uuid,
+                    name,
+                    topic: 'application'
+                });
+            };
+            handler({ proceed });
+        };
+        this.on(SystemShutdownEventName, shutdownHandler);
+    }
     /**
      * Signals the RVM to perform a health check and returns the results as json.
      * @return {Promise.<string[]>}

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

@@ -1,8 +1,8 @@
 import type * as OpenFin from '../../OpenFin';
 import { Transport } from '../../transport/transport';
-import { ViewEvent } from '../events/view';
 import { WebContents } from '../webcontents/main';
 type UpdatableViewOptions = OpenFin.UpdatableViewOptions;
+type ViewEvent = OpenFin.ViewEvent;
 /**
  * @PORTED
  * @typedef {object} View~options
@@ -144,6 +144,9 @@ type UpdatableViewOptions = OpenFin.UpdatableViewOptions;
  * @property {string} [processAffinity=<application uuid>]
  * A string to attempt to group renderers together. Will only be used if pages are on the same origin.
  *
+ * @property {boolean} [spellCheck=false]
+ * Enable spell check in input text fields for the view.
+ *
  * @property {Identity} [target]
  * The identity of the window this view should be attached to.
  *
@@ -447,10 +450,10 @@ export declare class View extends WebContents<ViewEvent> {
     getCurrentWindow: () => Promise<OpenFin.Window>;
     /**
      * Retrieves the current {@link TabStack} of the view if it belongs to one.
-     * @return {Promise<TabStack | undefined>} The {@link TabStack} this view belongs to.
+     * @return {Promise<TabStack>} The {@link TabStack} this view belongs to.
      * @throws if this view does not belong to a TabStack or if the window has been destroyed.
      */
-    getCurrentStack: () => Promise<OpenFin.TabStack | undefined>;
+    getCurrentStack: () => Promise<OpenFin.TabStack>;
     /**
      * 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.

package/src/api/view/Instance.js

@@ -155,6 +155,9 @@ const window_1 = require("../window");
  * @property {string} [processAffinity=<application uuid>]
  * A string to attempt to group renderers together. Will only be used if pages are on the same origin.
  *
+ * @property {boolean} [spellCheck=false]
+ * Enable spell check in input text fields for the view.
+ *
  * @property {Identity} [target]
  * The identity of the window this view should be attached to.
  *
@@ -459,23 +462,22 @@ class View extends main_1.WebContents {
         };
         /**
          * Retrieves the current {@link TabStack} of the view if it belongs to one.
-         * @return {Promise<TabStack | undefined>} The {@link TabStack} this view belongs to.
+         * @return {Promise<TabStack>} The {@link TabStack} this view belongs to.
          * @throws if this view does not belong to a TabStack or if the window has been destroyed.
          */
         this.getCurrentStack = async () => {
+            this.wire.sendAction('view-get-current-stack').catch(() => {
+                // don't expose
+            });
             try {
                 const layoutWindow = await this.getCurrentWindow();
                 const providerChannelClient = await __classPrivateFieldGet(this, _View_providerChannelClient, "f").getValue();
                 const client = await layout_entities_1.LayoutNode.newLayoutEntitiesClient(providerChannelClient, layout_constants_1.LAYOUT_CONTROLLER_ID, layoutWindow.identity);
-                const stackDefinition = await client.getStackByView(this.identity);
+                const stackDefinition = (await client.getStackByView(this.identity));
                 return layout_entities_1.LayoutNode.getEntity(stackDefinition, client);
             }
             catch (error) {
-                const e = new transport_errors_1.RuntimeError({ reason: 'This view does not belong to a stack.' });
-                // TODO: @pierre to fix
-                // @ts-expect-error pending PR !3459 to fix runtime errors
-                e.cause = error;
-                throw e;
+                throw new transport_errors_1.RuntimeError({ reason: 'This view does not belong to a stack.', error });
             }
         };
         /**

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

@@ -2,31 +2,10 @@ import type * as OpenFin from '../../OpenFin';
 import { EmitterBase } from '../base';
 import { Transport } from '../../transport/transport';
 import { BaseEvent } from '../events/base';
-/**
- * Configuration for page capture.
- */
-export interface CapturePageOptions {
-    /**
-     * The area of the window to be captured.
-     */
-    area?: OpenFin.Rectangle;
-    /**
-     * @defaultValue 'png'
-     *
-     * The format of the captured image.  Can be 'png', 'jpg', or 'bmp'.
-     */
-    format?: 'bmp' | 'jpg' | 'png';
-    /**
-     * @defaultValue 100
-     *
-     * Quality of JPEG image. Between 0 - 100.
-     */
-    quality?: number;
-}
 export declare class WebContents<T extends BaseEvent> extends EmitterBase<T> {
     entityType: string;
     constructor(wire: Transport, identity: OpenFin.Identity, entityType: string);
-    capturePage(options?: CapturePageOptions): Promise<string>;
+    capturePage(options?: OpenFin.CapturePageOptions): Promise<string>;
     executeJavaScript(code: string): Promise<void>;
     getZoomLevel(): Promise<number>;
     setZoomLevel(level: number): Promise<void>;

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

@@ -334,6 +334,9 @@ import { WebContents } from '../webcontents/main';
  * _Note: Caveats of small windows are no Aero Snap and drag to/from maximize._
  * _Windows 10: Requires `maximizable` to be false. Resizing with the mouse is only possible down to 38x39 px._
  *
+ * @property {boolean} [spellCheck=false]
+ * Enable spell check in input text fields for the window.
+ *
  * @property {string} [state="normal"]
  * The visible state of the window on creation.
  * One of:

package/src/api/window/Instance.js

@@ -341,6 +341,9 @@ const view_1 = require("../view");
  * _Note: Caveats of small windows are no Aero Snap and drag to/from maximize._
  * _Windows 10: Requires `maximizable` to be false. Resizing with the mouse is only possible down to 38x39 px._
  *
+ * @property {boolean} [spellCheck=false]
+ * Enable spell check in input text fields for the window.
+ *
  * @property {string} [state="normal"]
  * The visible state of the window on creation.
  * One of:

package/src/shapes/protocol.d.ts

@@ -148,6 +148,7 @@ export interface ProtocolMap extends ProtocolMapBase {
         request: void;
         response: OpenFin.PrinterInfo[];
     };
+    'system-register-shutdown-handler': VoidCall;
 }
 type ApiCall<Request, Response> = {
     request: Request;

package/src/transport/transport-errors.d.ts

@@ -1,3 +1,4 @@
+/// <reference types="node" />
 import { ErrorPlainObject } from '../util/errors';
 export type ReadyState = 'CONNECTING' | 'OPEN' | 'CLOSING' | 'CLOSED';
 export declare class DisconnectedError extends Error {
@@ -18,6 +19,13 @@ export type RuntimeErrorPayload = {
     reason: string;
     error?: ErrorPlainObject;
 };
+declare class InternalError<T extends ErrorPlainObject = ErrorPlainObject> extends Error {
+    constructor(err: T);
+}
 export declare class RuntimeError extends Error {
-    constructor(payload: RuntimeErrorPayload);
+    cause?: InternalError;
+    static getCallSite(callsToRemove?: number): NodeJS.CallSite[];
+    static prepareStackTrace(err: Error, callSites: NodeJS.CallSite[]): string;
+    constructor(payload: RuntimeErrorPayload, callSites?: NodeJS.CallSite[]);
 }
+export {};

package/src/transport/transport-errors.js

@@ -23,13 +23,56 @@ exports.NotImplementedError = NotImplementedError;
 class NotSupportedError extends Error {
 }
 exports.NotSupportedError = NotSupportedError;
+class InternalError extends Error {
+    constructor(err) {
+        const { message, name, stack, ...rest } = err;
+        super(message);
+        this.name = name || 'Error';
+        this.stack = stack !== null && stack !== void 0 ? stack : this.toString();
+        Object.keys(rest).forEach(key => {
+            this[key] = rest[key];
+        });
+    }
+}
+// For documentation of the error methods being used see here: https://v8.dev/docs/stack-trace-api
 class RuntimeError extends Error {
-    constructor(payload) {
+    static getCallSite(callsToRemove = 0) {
+        var _a, _b;
+        const length = Error.stackTraceLimit;
+        const realCallsToRemove = callsToRemove + 1; // remove this call;
+        Error.stackTraceLimit = length + realCallsToRemove;
+        // eslint-disable-next-line no-underscore-dangle
+        const _prepareStackTrace = Error.prepareStackTrace;
+        // This will be called when we access the `stack` property
+        Error.prepareStackTrace = (_, stack) => stack;
+        // stack is optional in non chromium contexts
+        const stack = (_b = (_a = new Error().stack) === null || _a === void 0 ? void 0 : _a.slice(realCallsToRemove)) !== null && _b !== void 0 ? _b : [];
+        Error.prepareStackTrace = _prepareStackTrace;
+        Error.stackTraceLimit = length;
+        return stack;
+    }
+    static prepareStackTrace(err, callSites) {
+        if (typeof Error.prepareStackTrace === 'function') {
+            return Error.prepareStackTrace(err, callSites);
+        }
+        let string = "";
+        string += err.name || "Error";
+        string += `: ${err.message || ""}`;
+        for (const callSite of callSites) {
+            string += `\n    at ${callSite.toString()}`;
+        }
+        return string;
+    }
+    ;
+    constructor(payload, callSites) {
         const { reason, error } = payload;
         super(reason);
         this.name = 'RuntimeError';
         if (error === null || error === void 0 ? void 0 : error.stack) {
-            this.stack = error.stack;
+            this.cause = new InternalError(error);
+        }
+        if (callSites) {
+            this.stack = RuntimeError.prepareStackTrace(this, callSites);
         }
     }
 }