@openfin/core 30.73.28 → 31.74.2

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

@@ -1,5 +1,5 @@
 import { ViewOverlay } from '../utils/view-overlay';
-export declare type SplitterItem = GoldenLayout.ContentItem & {
+export type SplitterItem = GoldenLayout.ContentItem & {
     viewEventsAdded: boolean;
     isVertical: boolean;
 };

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

@@ -0,0 +1,144 @@
+import type * as OpenFin from '../../../../OpenFin';
+import { LayoutEntitiesClient } from '../shapes';
+/**
+ * @internal
+ * Supplies an ApiClient for {@link LayoutEntitiesController} and helper methods
+ * for the entities {@link TabStack} AND {@link ColumnOrRow} to use.
+ */
+export declare abstract class LayoutNode {
+    #private;
+    /** @internal */
+    protected constructor(client: LayoutEntitiesClient, entityId: string);
+    /**
+     * @internal
+     * The type of this node, one of: 'row' | 'column' | 'stack';
+     */
+    readonly abstract type: OpenFin.LayoutEntityTypes;
+    /**
+     * @internal
+     * This instance's unique id used when calling the layout-entities-controller api client
+     */
+    protected readonly entityId: string;
+    /**
+     * @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
+     */
+    static newLayoutEntitiesClient: (client: OpenFin.ChannelClient, controllerId: string, identity: OpenFin.Identity) => Promise<LayoutEntitiesClient>;
+    static getEntity: (definition: OpenFin.LayoutEntityDefinition, client: LayoutEntitiesClient) => ColumnOrRow | TabStack;
+    /**
+     * 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.
+     */
+    isRoot: () => Promise<boolean>;
+    /**
+     * 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.
+     */
+    exists: () => Promise<boolean>;
+    /**
+     * 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.
+     */
+    getParent: () => Promise<ColumnOrRow | TabStack | undefined>;
+    /**
+     * 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
+     */
+    createAdjacentStack: (views: OpenFin.PlatformViewCreationOptions[], options: {
+        position?: OpenFin.LayoutPosition;
+    }) => Promise<TabStack>;
+    /**
+     * 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.
+     */
+    getAdjacentStacks: (edge: OpenFin.LayoutPosition) => Promise<TabStack[]>;
+}
+/**
+ * A {@link TabStack} is used to manage the state of a TabStack within an OpenFin Layout and
+ * traverse to its parent Content Item.
+ */
+export declare class TabStack extends LayoutNode {
+    #private;
+    /** @internal */
+    constructor(client: LayoutEntitiesClient, entityId: string);
+    /**
+     * Type of the content item. Always stack, but useful for distinguishing between a {@link TabStack} and {@link ColumnOrRow}.
+     */
+    readonly 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
+     */
+    getViews: () => Promise<OpenFin.Identity[]>;
+    /**
+     * 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
+     */
+    addView: (view: OpenFin.Identity | OpenFin.PlatformViewCreationOptions, options?: OpenFin.AddViewToStackOptions) => Promise<OpenFin.Identity>;
+    /**
+     * 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.
+     */
+    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.
+ */
+export declare class ColumnOrRow extends LayoutNode {
+    #private;
+    /** @internal */
+    constructor(client: LayoutEntitiesClient, entityId: string, type: 'row' | 'column');
+    /**
+     * The type of this {@link ColumnOrRow}. Either 'row' or 'column'.
+     */
+    readonly type: 'column' | 'row';
+    /**
+     * 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}.
+     */
+    getContent: () => Promise<(ColumnOrRow | TabStack)[]>;
+}

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,5 +1,7 @@
+import { ApiClient } from '../../api-exposer';
 import type * as OpenFin from '../../../OpenFin';
-declare type LayoutPresetType = OpenFin.LayoutPresetType;
+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/layout/utils/view-overlay.d.ts

@@ -1,5 +1,5 @@
 import type * as OpenFin from '../../../../OpenFin';
-import Transport from '../../../../transport/transport';
+import { Transport } from '../../../../transport/transport';
 /**
  * Api client allowing an empty electron BrowserView to be rendered
  * in the current window with the specified bounds.

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

@@ -0,0 +1,162 @@
+import { WindowOptionsChangedEvent } from '../events/window';
+import * as OpenFin from '../../OpenFin';
+/**
+ * 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}
+ * in order to implement custom Platform behavior. (See {@tutorial Platform.init})
+ *
+ * For an overview of Provider customization, see
+ * {@link https://developers.openfin.co/docs/platform-customization#section-customizing-platform-behavior}.
+ */
+export interface PlatformProvider {
+    /**
+     * Handles requests to create a window in the current platform.
+     * @param { WindowOption } payload Window options for the window to be created.
+     * @param { Identity } [identity] If {@link Platform#createWindow Platform.createWindow} was called, the identity of the caller will be here.
+     * If `createWindow` was called as part of applying a snapshot or creating a view without a target window, `identity` will be undefined.
+     */
+    createWindow(options: OpenFin.PlatformWindowCreationOptions, identity?: OpenFin.Identity): Promise<OpenFin.Window>;
+    /**
+     * Gets the current state of windows and their views and returns a snapshot object containing that info.
+     * @param { undefined } payload Undefined unless you've defined a custom `getSnapshot` protocol.
+     * @param { Identity } identity Identity of the entity that called {@link Platform#getSnapshot Platform.getSnapshot}.
+     * @return { Promise<Snapshot> } Snapshot of current platform state.
+     */
+    getSnapshot(payload: undefined, identity: OpenFin.Identity): Promise<OpenFin.Snapshot>;
+    /**
+     * **NOTE**: Internal use only. It is not recommended to manage the state of individual views.
+     * Gets the current state of a single view and returns an object with the options needed to restore that view as part of a snapshot.
+     * @param { Identity } payload Identity of the view.
+     * @return { Promise<ViewState> }
+     * @internal
+     * @experimental
+     */
+    getViewSnapshot(payload: {
+        viewIdentity: OpenFin.Identity;
+    }): Promise<OpenFin.ViewState>;
+    /**
+     * Called when a snapshot is being applied and some windows in that snapshot would be fully or partially off-screen.
+     * Returns an array of windows with modified positions, such that any off-screen windows are positioned in the top left
+     * corner of the main monitor.
+     * @param { Snapshot } snapshot The snapshot to be applied.
+     * @param { WindowOptions[] } outOfBoundsWindows An array of WindowOptions for any windows that would be off-screen.
+     * @return { Promise<WindowOptions[]> } An array of WindowOptions with their position modified to fit on screen.
+     */
+    positionOutOfBoundsWindows(snapshot: OpenFin.Snapshot, outOfBoundsWindows: OpenFin.WindowCreationOptions[]): Promise<OpenFin.WindowCreationOptions[]>;
+    /**
+     * Handles requests to apply a snapshot to the current Platform.
+     * @param { ApplySnapshotPayload } payload Payload containing the snapshot to be applied, as well as any options.
+     * @param { Identity } [identity] Identity of the entity that called {@link Platform#applySnapshot Platform.applySnapshot}.
+     * Undefined if called internally (e.g. when opening the initial snapshot).
+     * @return { Promise<void> }
+     */
+    applySnapshot(payload: OpenFin.ApplySnapshotPayload, identity?: OpenFin.Identity): Promise<void>;
+    /**
+     * Closes the current Platform and all child windows and views.
+     * @param { undefined } payload Undefined unless you have implemented a custom quite protocol.
+     * @param { Identity } identity Identity of the entity that called {@link Platform#quit Platform.quit}.
+     * @return { Promise<void> }
+     */
+    quit(payload: undefined, identity: OpenFin.Identity): Promise<void>;
+    /**
+     * Closes a view
+     * @param { CloseViewPayload } payload Specifies the `target` view to be closed.
+     * @param { Identity } identity Identity of the entity that called {@link Platform#closeView Platform.closeView}.
+     */
+    closeView(payload: OpenFin.CloseViewPayload, identity?: OpenFin.Identity): Promise<any>;
+    /**
+     * Creates a new view and attaches it to a specified target window.
+     * @param { CreateViewPayload } payload Creation options for the new view.
+     * @param { Identity } identity Identity of the entity that called {@link Platform#createView Platform.createView}.
+     * @return { Promise<void> }
+     */
+    createView(payload: OpenFin.CreateViewPayload, identity: OpenFin.Identity): Promise<OpenFin.View>;
+    /** Handles requests to fetch manifests in the current platform.
+     * @param { FetchManifestPayload } payload Payload containing the manifestUrl to be fetched.
+     * @param { Identity } callerIdentity If {@link Platform#fetchManifest Platform.fetchManifest}
+     * was called, the identity of the caller will be here.
+     * If `fetchManifest` was called internally, `callerIdentity` will be the provider's identity.
+     */
+    fetchManifest(payload: OpenFin.FetchManifestPayload, callerIdentity: OpenFin.Identity): Promise<any>;
+    /**
+     * Replaces a Platform window's layout with a new layout. Any views that were in the old layout but not the new layout will be destroyed.
+     * @param { ReplaceLayoutPayload } payload Contains the `target` window and an `opts` object with a `layout` property to apply.
+     * @param { Identity } [identity] Identity of the entity that called {@link Platform#replaceLayout Platform.replaceLayout}.
+     * Undefined if `replaceLayout` is called internally (e.g. while applying a snapshot).
+     * @return { Promise<void> }
+     */
+    replaceLayout(payload: OpenFin.ReplaceLayoutPayload, identity?: OpenFin.Identity): Promise<void>;
+    replaceView(payload: OpenFin.ReplaceViewPayload, identity?: OpenFin.Identity): Promise<void>;
+    launchIntoPlatform(payload: OpenFin.LaunchIntoPlatformPayload): Promise<void>;
+    /**
+     * Handles requests to set a window's context. `target` may be a window or a view.
+     * If it is a window, that window's `customContext` will be updated.
+     * If it is a view, the `customContext` of that view's current host window will be updated.
+     * @param { SetWindowContextPayload } payload Object containing the requested `context` update,
+     * the `target`'s identity, and the target's `entityType`.
+     * @param { Identity } [identity] Identity of the entity that called {@link Platform#setWindowContext Platform.setWindowContext}.
+     * Undefined if `setWindowContext` is called internally (e.g. while applying a snapshot).
+     * @return { Promise<any> } The new context.
+     */
+    setWindowContext(payload: OpenFin.SetWindowContextPayload, identity?: OpenFin.Identity): Promise<any>;
+    /**
+     * Handles requests to get a window's context. `target` may be a window or a view.
+     * If it is a window, that window's `customContext` will be returned.
+     * If it is a view, the `customContext` of that view's current host window will be returned.
+     * @param { GetWindowContextPayload } payload Object containing the requested `context` update,
+     * the `target`'s identity, and the target's `entityType`.
+     * @param { Identity } [identity] Identity of the entity that called {@link Platform#getWindowContext Platform.getWindowContext}.
+     * Undefined when `getWindowContext` is called internally
+     * (e.g. when getting a window's context for the purpose of raising a "host-context-changed" event on a reparented view).
+     * @return { Promise<any> } The new context.
+     */
+    getWindowContext(payload: OpenFin.GetWindowContextPayload, identity?: OpenFin.Identity): Promise<any>;
+    /**
+     * Called when a window's `customContext` is updated. Responsible for raising the `host-context-updated` event on that window's child views.
+     * @param { WindowOptionsChangedEvent<'window', 'options-changed'> } payload The event payload for the window whose context has changed.
+     * The new context will be contained as `payload.diff.customContext.newVal`.
+     * @return { Promise<HostContextChangedPayload> } The event that it raised.
+     */
+    onWindowContextUpdated(payload: WindowOptionsChangedEvent): 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: OpenFin.CloseWindowPayload, callerIdentity: OpenFin.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>;
+}

package/src/api/platform/provider.js

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