@openfin/core 31.74.9 → 31.74.11

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

@@ -0,0 +1,216 @@
+"use strict";
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _a, _LayoutNode_client, _TabStack_client, _ColumnOrRow_client;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ColumnOrRow = exports.TabStack = exports.LayoutNode = void 0;
+const api_exposer_1 = require("../../../api-exposer");
+const channel_api_relay_1 = require("../../../../util/channel-api-relay");
+/*
+    This file includes LayoutNode, ColumnOrRow and TabStack classes, which are all closely
+    intertwined, and share members via parent abstract class LayoutNode. To prevent circular
+    refs, we define and export all the classes here.
+*/
+/**
+ * @internal
+ * Supplies an ApiClient for {@link LayoutEntitiesController} and helper methods
+ * for the entities {@link TabStack} AND {@link ColumnOrRow} to use.
+ */
+class LayoutNode {
+    /** @internal */
+    constructor(client, entityId) {
+        /**
+         * @internal
+         * ApiClient for {@link LayoutEntitiesController}
+         */
+        _LayoutNode_client.set(this, void 0);
+        /**
+         * Determines if this {@link ColumnOrRow} or {@link TabStack} is the top level content item in the current layout.
+         * @returns Promise resolving true if this is the root, or false otherwise.
+         */
+        this.isRoot = () => __classPrivateFieldGet(this, _LayoutNode_client, "f").isRoot(this.entityId);
+        /**
+         * Determines if this {@link ColumnOrRow} or {@link TabStack} is the top level
+         * content item in the current layout.
+         * @returns Promise resolving true if this is the root, or false otherwise.
+         */
+        this.exists = () => __classPrivateFieldGet(this, _LayoutNode_client, "f").exists(this.entityId);
+        /**
+         * Retrieves the parent {@link ColumnOrRow} or {@link TabStack} of this item, if one exists.
+         * @returns Promise resolving with the {@link ColumnOrRow} or {@link TabStack} that contains this item, or undefined if this is the root content item.
+         */
+        this.getParent = async () => {
+            const parent = await __classPrivateFieldGet(this, _LayoutNode_client, "f").getParent(this.entityId);
+            if (!parent) {
+                return undefined;
+            }
+            return LayoutNode.getEntity(parent, __classPrivateFieldGet(this, _LayoutNode_client, "f"));
+        };
+        /**
+         * Given a list of view creation options or references and a layout position, creates an adjacent {@link TabStack}
+         *
+         * Known Issue: If the number of views to add overflows the tab-container, the added views will be set as active
+         * during each render, and then placed at the front of the tab-stack, while the underlying order of tabs will remain unchanged.
+         * This means the views you pass to createAdjacentStack() may not render in the order given by the array.
+         * Until fixed, this problem can be avoided only if your window is wide enough to fit creating all the views in the tabstack.
+         *
+         * @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'
+         * @returns an instance of {@link TabStack} containing the given views
+         * @experimental
+         */
+        this.createAdjacentStack = async (views, options) => {
+            const entityId = await __classPrivateFieldGet(this, _LayoutNode_client, "f").createAdjacentStack(this.entityId, views, options);
+            return LayoutNode.getEntity({ entityId, type: 'stack' }, __classPrivateFieldGet(this, _LayoutNode_client, "f"));
+        };
+        /**
+         * Finds the immediate adjacent layout item given an edge Position
+         * @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({
+                targetId: this.entityId,
+                edge
+            });
+            return adjacentStacks.map(stack => LayoutNode.getEntity({
+                type: 'stack',
+                entityId: stack.entityId
+            }, __classPrivateFieldGet(this, _LayoutNode_client, "f")));
+        };
+        __classPrivateFieldSet(this, _LayoutNode_client, client, "f");
+        this.entityId = entityId;
+    }
+}
+exports.LayoutNode = LayoutNode;
+_a = LayoutNode, _LayoutNode_client = new WeakMap();
+/**
+ * @internal
+ * Encapsulates Api consumption of {@link LayoutEntitiesController} with a relayed dispatch
+ * @param client
+ * @param controllerId
+ * @param identity
+ * @returns a new instance of {@link LayoutEntitiesClient} with bound to the controllerId
+ */
+LayoutNode.newLayoutEntitiesClient = async (client, controllerId, identity) => {
+    const dispatch = (0, channel_api_relay_1.createRelayedDispatch)(client, identity, 'layout-relay', 'You are trying to interact with a layout component on a window that has been destroyed.');
+    const consumer = new api_exposer_1.ApiConsumer(new api_exposer_1.ChannelsConsumer({ dispatch }));
+    return consumer.consume({ id: controllerId });
+};
+LayoutNode.getEntity = (definition, client) => {
+    const { entityId, type } = definition;
+    switch (type) {
+        case 'column':
+        case 'row':
+            return new ColumnOrRow(client, entityId, type);
+        case 'stack':
+            return new TabStack(client, entityId);
+        default:
+            throw new Error(`Unrecognised Layout Entity encountered ('${JSON.stringify(definition)})`);
+    }
+};
+/**
+ * A {@link TabStack} is used to manage the state of a TabStack within an OpenFin Layout and
+ * traverse to its parent Content Item.
+ */
+class TabStack extends LayoutNode {
+    /** @internal */
+    constructor(client, entityId) {
+        super(client, entityId);
+        /**
+         * @internal
+         * ApiClient for {@link LayoutEntitiesController}
+         */
+        _TabStack_client.set(this, void 0);
+        /**
+         * Type of the content item. Always stack, but useful for distinguishing between a {@link TabStack} and {@link ColumnOrRow}.
+         */
+        this.type = 'stack';
+        /**
+         * Retrieves a list of all views belonging to this {@link TabStack}.
+         *
+         * Known Issue: If adding a view overflows the tab-container width, the added view will be set as active
+         * and rendered at the front of the tab-stack, while the underlying order of tabs will remain unchanged.
+         * If that happens and then getViews() is called, it will return the identities in a different order than
+         * than the currently rendered tab order.
+         *
+         * @returns Resolves with a list containing the {@link OpenFin.Identity identities} of each view belonging to the {@link TabStack}.
+         * @throws If the {@link TabStack} has been destroyed.
+         * @experimental
+         */
+        this.getViews = () => __classPrivateFieldGet(this, _TabStack_client, "f").getStackViews(this.entityId);
+        /**
+         * Adds or creates a view in this {@link TabStack}.
+         *
+         * Known Issue: If adding a view overflows the tab-container, the added view will be set as active
+         * and rendered at the front of the tab-stack, while the underlying order of tabs will remain unchanged.
+         *
+         * @param view The identity of an existing view to add, or options to create a view.
+         * @param options Optional view options: index number used to insert the view into the stack at that index. Defaults to 0 (front of the stack)
+         * @returns Resolves with the {@link OpenFin.Identity identity} of the added view.
+         * @throws If the view does not exist or fails to create.
+         * @throws If the {@link TabStack} has been destroyed.
+         * @experimental
+         */
+        this.addView = async (view, options = { index: 0 }) => __classPrivateFieldGet(this, _TabStack_client, "f").addViewToStack(this.entityId, view, options);
+        /**
+         * Removes a view from this {@link TabStack}.
+         * @param view {@link OpenFin.Identiy Identity} of the view to remove.
+         * @throws If the view does not exist or does not belong to the stack.
+         * @throws If the {@link TabStack} has been destroyed.
+         */
+        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");
+    }
+}
+exports.TabStack = TabStack;
+_TabStack_client = new WeakMap();
+/**
+ * A {@link ColumnOrRow} is used to manage the state of a ColumnOrRow within an OpenFin Layout.
+ */
+class ColumnOrRow extends LayoutNode {
+    /** @internal */
+    constructor(client, entityId, type) {
+        super(client, entityId);
+        /**
+         * @internal
+         * ApiClient for {@link LayoutEntitiesController}
+         */
+        _ColumnOrRow_client.set(this, void 0);
+        /**
+         * Retrieves a list of all content items belonging to this {@link ColumnOrRow} in order of appearance.
+         * @returns Resolves with a list containing {@link ColumnOrRow} and {@link TabStack} items belonging to this {@link ColumnOrRow}.
+         */
+        this.getContent = async () => {
+            const contentItemEntities = await __classPrivateFieldGet(this, _ColumnOrRow_client, "f").getContent(this.entityId);
+            return contentItemEntities.map((entity) => LayoutNode.getEntity(entity, __classPrivateFieldGet(this, _ColumnOrRow_client, "f")));
+        };
+        __classPrivateFieldSet(this, _ColumnOrRow_client, client, "f");
+        this.type = type;
+    }
+}
+exports.ColumnOrRow = ColumnOrRow;
+_ColumnOrRow_client = new WeakMap();

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

@@ -0,0 +1,6 @@
+export type LayoutEntityTypes = Exclude<GoldenLayout.ItemType, 'component' | 'root'>;
+export type LayoutPosition = 'top' | 'bottom' | 'left' | 'right';
+export type LayoutEntityDefinition<TLayoutEntityType extends LayoutEntityTypes = LayoutEntityTypes> = {
+    type: TLayoutEntityType;
+    entityId: string;
+};

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

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/src/api/platform/layout/layout.constants.d.ts

@@ -0,0 +1 @@
+export declare const LAYOUT_CONTROLLER_ID = "layout-entities";

package/src/api/platform/layout/layout.constants.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LAYOUT_CONTROLLER_ID = void 0;
+exports.LAYOUT_CONTROLLER_ID = 'layout-entities';

package/src/api/platform/layout/shapes.d.ts

@@ -1,4 +1,6 @@
+import { ApiClient } from '../../api-exposer';
 import type * as OpenFin from '../../../OpenFin';
+import { LayoutEntitiesController } from './controllers/layout-entities-controller';
 type LayoutPresetType = OpenFin.LayoutPresetType;
 export interface InitLayoutOptions {
     containerId?: string;
@@ -10,4 +12,5 @@ export interface DragPayload {
     'view-config': OpenFin.ViewCreationOptions;
     'view-identity': [string, string, string];
 }
+export type LayoutEntitiesClient = ApiClient<LayoutEntitiesController>;
 export {};

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

@@ -0,0 +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: (a: GoldenLayout.ContentItem, b: 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

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getAdjacentStacks = exports.doShareEdge = exports.getAdjacentItem = void 0;
+const getAdjacentItem = (component, edge) => {
+    const { parent } = component;
+    if (parent.isRoot) {
+        return undefined;
+    }
+    const targetType = ['top', 'bottom'].includes(edge) ? 'column' : 'row';
+    const edgeSiblingOffset = ['top', 'left'].includes(edge) ? -1 : 1;
+    if (parent.type === targetType) {
+        const componentIndex = parent.contentItems.indexOf(component);
+        const targetIndex = componentIndex + edgeSiblingOffset;
+        if (targetIndex >= 0 && targetIndex < parent.contentItems.length) {
+            return parent.contentItems[targetIndex];
+        }
+    }
+    return (0, exports.getAdjacentItem)(parent, edge);
+};
+exports.getAdjacentItem = getAdjacentItem;
+const doShareEdge = (a, b, 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) {
+        return false;
+    }
+    if (['top', 'bottom'].includes(edge)) {
+        return ((boundsB.left >= boundsA.left && boundsB.left < boundsA.right) ||
+            (boundsB.right > boundsA.left && boundsB.right <= boundsA.right));
+    }
+    return ((boundsB.top >= boundsA.top && boundsB.top < boundsA.bottom) ||
+        (boundsB.bottom > boundsA.top && boundsB.bottom <= boundsA.bottom));
+};
+exports.doShareEdge = doShareEdge;
+const getAdjacentStacks = (item, edge) => {
+    const targetContainer = ['top', 'bottom'].includes(edge) ? 'row' : 'column';
+    const findEdgeStacks = (component) => {
+        if (component.type === 'stack') {
+            if ((0, exports.doShareEdge)(item, component, edge)) {
+                return [component];
+            }
+            return [];
+        }
+        if (component.type === 'root') {
+            return [];
+        }
+        if (component.type === targetContainer) {
+            return component.contentItems.map((contentItem) => findEdgeStacks(contentItem)).flat();
+        }
+        if (component.type !== targetContainer) {
+            if (['top', 'right'].includes(edge)) {
+                return findEdgeStacks(component.contentItems[component.contentItems.length - 1]);
+            }
+            return findEdgeStacks(component.contentItems[0]);
+        }
+        return [];
+    };
+    const edgeItem = (0, exports.getAdjacentItem)(item, edge);
+    if (edgeItem) {
+        return findEdgeStacks(edgeItem);
+    }
+    return [];
+};
+exports.getAdjacentStacks = getAdjacentStacks;

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.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();

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

@@ -1,9 +1,8 @@
 import type * as OpenFin from '../../OpenFin';
-import { WebContents } from '../webcontents/main';
 import { Transport } from '../../transport/transport';
-import { Layout } from '../platform/layout';
-import { ViewEvent } from '../events/view';
+import { WebContents } from '../webcontents/main';
 type UpdatableViewOptions = OpenFin.UpdatableViewOptions;
+type ViewEvent = OpenFin.ViewEvent;
 /**
  * @PORTED
  * @typedef {object} View~options
@@ -145,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.
  *
@@ -172,6 +174,7 @@ type UpdatableViewOptions = OpenFin.UpdatableViewOptions;
  * @hideconstructor
  */
 export declare class View extends WebContents<ViewEvent> {
+    #private;
     identity: OpenFin.Identity;
     constructor(wire: Transport, identity: OpenFin.Identity);
     /**
@@ -445,6 +448,12 @@ export declare class View extends WebContents<ViewEvent> {
      * @experimental
      */
     getCurrentWindow: () => Promise<OpenFin.Window>;
+    /**
+     * Retrieves the current {@link TabStack} of the view if it belongs to one.
+     * @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>;
     /**
      * 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.
@@ -457,6 +466,10 @@ export declare class View extends WebContents<ViewEvent> {
      * **NOTE**: Internal use only.
      * Attaches this view to an HTML element in the current context. The view will resize responsively when the element bounds change.
      *
+     * **Known issue**: View.bindToElement does not track position changes, if the element has fixed px width and height values it is possible for the view to not update responsively.
+     *
+     * **Known issue**: When View.bindToElement is used on a element that takes up the entire page in a platform window, the bound view will not respond responsively when the window is resized to be smaller.
+     *
      * @param {HTMLElement} element - HTML element to attach the view to.
      * @return {Function} - Cleanup function that will disconnect the element resize observer.
      * @internal

package/src/api/view/Instance.js

@@ -1,12 +1,19 @@
 "use strict";
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _View_providerChannelClient;
 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 transport_errors_1 = require("../../transport/transport-errors");
+const lazy_1 = require("../../util/lazy");
+const layout_entities_1 = require("../platform/layout/entities/layout-entities");
+const layout_constants_1 = require("../platform/layout/layout.constants");
+const bounds_observer_1 = require("../platform/layout/utils/bounds-observer");
 const main_1 = require("../webcontents/main");
 const window_1 = require("../window");
-const bounds_observer_1 = require("../platform/layout/utils/bounds-observer");
 /**
  * @PORTED
  * @typedef {object} View~options
@@ -148,6 +155,9 @@ const bounds_observer_1 = require("../platform/layout/utils/bounds-observer");
  * @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.
  *
@@ -178,6 +188,10 @@ class View extends main_1.WebContents {
     constructor(wire, identity) {
         super(wire, identity, 'view');
         this.identity = identity;
+        _View_providerChannelClient.set(this, new lazy_1.Lazy(() => {
+            const platform = this.fin.Platform.wrapSync(this.identity);
+            return platform.getClient();
+        }));
         /**
          * Returns the zoom level of the view.
          * @function getZoomLevel
@@ -446,6 +460,30 @@ 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);
         };
+        /**
+         * Retrieves the current {@link TabStack} of the view if it belongs to one.
+         * @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));
+                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;
+            }
+        };
         /**
          * 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.
@@ -461,6 +499,10 @@ class View extends main_1.WebContents {
          * **NOTE**: Internal use only.
          * Attaches this view to an HTML element in the current context. The view will resize responsively when the element bounds change.
          *
+         * **Known issue**: View.bindToElement does not track position changes, if the element has fixed px width and height values it is possible for the view to not update responsively.
+         *
+         * **Known issue**: When View.bindToElement is used on a element that takes up the entire page in a platform window, the bound view will not respond responsively when the window is resized to be smaller.
+         *
          * @param {HTMLElement} element - HTML element to attach the view to.
          * @return {Function} - Cleanup function that will disconnect the element resize observer.
          * @internal
@@ -511,3 +553,4 @@ class View extends main_1.WebContents {
     }
 }
 exports.View = View;
+_View_providerChannelClient = new WeakMap();

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/mock.d.ts

@@ -1,3 +1,3 @@
-import type * as OpenFin from './OpenFin';
+import * as OpenFin from './OpenFin';
 export declare const fin: OpenFin.Fin<"window" | "view">;
 export default OpenFin;

package/src/mock.js

@@ -1,13 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.fin = void 0;
-const events_1 = require("events");
 /* eslint-disable import/prefer-default-export */
 /* eslint-disable spaced-comment */
 /* eslint-disable @typescript-eslint/triple-slash-reference */
 /* eslint-disable @typescript-eslint/explicit-function-return-type */
 /* eslint-disable class-methods-use-this */
-/// <reference path="../OpenFin.d.ts"/>
+const events_1 = require("events");
+const OpenFin = require("./OpenFin");
 const fin_1 = require("./api/fin");
 const transport_1 = require("./transport/transport");
 const me_1 = require("./api/me");

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);
+    internalError?: InternalError;
+    static getCallSite(callsToRemove?: number): NodeJS.CallSite[];
+    static prepareStackTrace(err: Error, callSites: NodeJS.CallSite[]): string;
+    constructor(payload: RuntimeErrorPayload, callSites?: NodeJS.CallSite[]);
 }
+export {};