@openfin/core 30.74.7 → 30.74.9

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@openfin/core",
-    "version": "30.74.7",
+    "version": "30.74.9",
     "license": "SEE LICENSE IN LICENSE.MD",
     "main": "./src/mock.js",
     "types": "./src/mock.d.ts",

package/src/OpenFin.d.ts

@@ -2248,6 +2248,7 @@ export declare type FindInPageResult = {
 export declare type FrameInfo = {
     name: string;
     uuid: string;
+    url: string;
     entityType: EntityType;
     parent: Identity;
 };

package/src/api/interappbus/channel/index.d.ts

@@ -15,6 +15,7 @@ export interface ChannelMessage extends Message<any> {
 export declare class Channel extends EmitterBase<ChannelEvent> {
     #private;
     constructor(wire: Transport);
+    private channelExists;
     getAllChannels(): Promise<ProviderIdentity[]>;
     onChannelConnect(listener: (...args: any[]) => void): Promise<void>;
     onChannelDisconnect(listener: (...args: any[]) => void): Promise<void>;

package/src/api/interappbus/channel/index.js

@@ -10,7 +10,7 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
     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 _Channel_connectionManager;
+var _Channel_connectionManager, _Channel_internalEmitter, _Channel_readyToConnect;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Channel = void 0;
 /* eslint-disable no-console */
@@ -18,16 +18,29 @@ const client_1 = require("./client");
 const provider_1 = require("./provider");
 const base_1 = require("../../base");
 const connection_manager_1 = require("./connection-manager");
-// eslint-disable-next-line @typescript-eslint/no-empty-function
-const noop = () => { };
+const events_1 = require("events");
+const lazy_1 = require("../../../util/lazy");
 class Channel extends base_1.EmitterBase {
     constructor(wire) {
         super(wire, 'channel');
         _Channel_connectionManager.set(this, void 0);
+        _Channel_internalEmitter.set(this, new events_1.EventEmitter());
+        // OpenFin API has not been injected at construction time, *must* wait for API to be ready.
+        _Channel_readyToConnect.set(this, new lazy_1.AsyncRetryableLazy(async () => {
+            await Promise.all([
+                this.on('disconnected', (eventPayload) => {
+                    client_1.default.handleProviderDisconnect(eventPayload);
+                }),
+                this.on('connected', (...args) => {
+                    __classPrivateFieldGet(this, _Channel_internalEmitter, "f").emit('connected', ...args);
+                })
+            ]).catch(() => new Error('error setting up channel connection listeners'));
+        }));
         __classPrivateFieldSet(this, _Channel_connectionManager, new connection_manager_1.ConnectionManager(wire), "f");
-        this.on('disconnected', (eventPayload) => {
-            client_1.default.handleProviderDisconnect(eventPayload);
-        }).catch((e) => console.error('Error setting up a disconnected listener:', e));
+    }
+    async channelExists(channelName) {
+        const channels = await this.getAllChannels();
+        return channels.some((providerIdentity) => providerIdentity.channelName === channelName);
     }
     async getAllChannels() {
         return this.wire.sendAction('get-all-channels').then(({ payload }) => payload.data);
@@ -38,47 +51,39 @@ class Channel extends base_1.EmitterBase {
     async onChannelDisconnect(listener) {
         await this.on('disconnected', listener);
     }
-    async connect(channelName, options) {
+    async connect(channelName, options = {}) {
+        // Make sure we don't connect before listeners are set up
+        // This also errors if we're not in OpenFin, ensuring we don't run unnecessary code
+        await __classPrivateFieldGet(this, _Channel_readyToConnect, "f").getValue();
         if (!channelName || typeof channelName !== 'string') {
             throw new Error('Please provide a channelName string to connect to a channel.');
         }
-        const opts = Object.assign(this.wire.environment.getDefaultChannelOptions().connect, options || {});
-        let resolver = noop;
-        let listener = noop;
-        const waitResponse = new Promise((resolve) => {
-            resolver = resolve;
-            listener = (payload) => {
-                if (channelName === payload.channelName) {
-                    this.removeListener('connected', listener);
-                    resolve(this.connect(channelName, opts));
-                }
-            };
-            this.on('connected', listener);
-        });
+        const opts = { wait: true, ...this.wire.environment.getDefaultChannelOptions().connect, ...options };
+        const shouldWait = opts.wait;
+        if (shouldWait) {
+            const channelExists = await this.channelExists(channelName);
+            if (!channelExists) {
+                console.warn(`Channel not found for channelName: ${channelName}, waiting for channel connection.`);
+                await new Promise((resolve) => {
+                    const connectedListener = (payload) => {
+                        if (channelName === payload.channelName) {
+                            __classPrivateFieldGet(this, _Channel_internalEmitter, "f").removeListener('connected', connectedListener);
+                            resolve();
+                        }
+                    };
+                    __classPrivateFieldGet(this, _Channel_internalEmitter, "f").on('connected', connectedListener);
+                });
+            }
+        }
         try {
             const { offer, rtc: rtcPacket } = await __classPrivateFieldGet(this, _Channel_connectionManager, "f").createClientOffer(opts);
-            let connectionUrl;
-            const entityType = this.wire.environment.getCurrentEntityType();
-            if (entityType === 'iframe') {
-                // @ts-expect-error
-                // TODO: type this correctly (frame types are broken)
-                connectionUrl = (await this.fin.me.getInfo()).url;
-            }
-            else if (entityType === 'window' || entityType === 'view') {
-                connectionUrl = (await this.fin.me.getInfo()).url;
-            }
-            const res = await this.wire.sendAction('connect-to-channel', {
+            const connectionUrl = (await this.fin.me.getInfo()).url;
+            const { payload: { data: routingInfo } } = await this.wire.sendAction('connect-to-channel', {
                 channelName,
                 ...opts,
                 offer,
                 connectionUrl
             });
-            const { payload: { data: routingInfo } } = res;
-            // If there isn't a matching channel, the above sendAction call will error out and go to catch, skipping the logic below.
-            if (resolver) {
-                resolver();
-            }
-            this.removeListener('connected', listener);
             const strategy = await __classPrivateFieldGet(this, _Channel_connectionManager, "f").createClientStrategy(rtcPacket, routingInfo);
             const channel = new client_1.default(routingInfo, this.wire, strategy);
             // It is the client's responsibility to handle endpoint disconnection to the provider.
@@ -97,18 +102,13 @@ class Channel extends base_1.EmitterBase {
             });
             return channel;
         }
-        catch (e) {
-            const shouldWait = { wait: true, ...opts }.wait;
+        catch (error) {
             const internalNackMessage = 'internal-nack';
-            if (shouldWait && e.message && e.message.includes(internalNackMessage)) {
-                console.warn(`Channel not found for channelName: ${channelName}, waiting for channel connection.`);
-                return waitResponse;
-            }
-            if (e.message === internalNackMessage) {
-                throw new Error(`No channel found for channelName: ${channelName}`);
+            if (error.message.includes(internalNackMessage)) {
+                throw new Error(`No channel found for channelName: ${channelName}.`);
             }
             else {
-                throw new Error(e);
+                throw new Error(error);
             }
         }
     }
@@ -129,4 +129,4 @@ class Channel extends base_1.EmitterBase {
     }
 }
 exports.Channel = Channel;
-_Channel_connectionManager = new WeakMap();
+_Channel_connectionManager = new WeakMap(), _Channel_internalEmitter = new WeakMap(), _Channel_readyToConnect = new WeakMap();

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

@@ -10,7 +10,7 @@ var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (
     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 _LayoutModule_layoutManager;
+var _LayoutModule_layoutManager, _LayoutModule_layoutInitializationAttempted;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.LayoutModule = void 0;
 /* eslint-disable no-undef, import/prefer-default-export */
@@ -91,6 +91,7 @@ class LayoutModule extends base_1.Base {
     constructor() {
         super(...arguments);
         _LayoutModule_layoutManager.set(this, void 0);
+        _LayoutModule_layoutInitializationAttempted.set(this, false);
         /**
          * Initialize the window's Layout.  Must be called from a custom window that has a 'layout' option set upon creation of that window.
          * If a containerId is not provided, this method attempts to find an element with the id `layout-container`.
@@ -109,9 +110,10 @@ class LayoutModule extends base_1.Base {
             if (!this.fin.me.isWindow) {
                 throw new Error('Layout.init can only be called from a Window context.');
             }
-            else if (__classPrivateFieldGet(this, _LayoutModule_layoutManager, "f")) {
+            else if (__classPrivateFieldGet(this, _LayoutModule_layoutInitializationAttempted, "f")) {
                 throw new Error('Layout for this window already initialized, please use Layout.replace call to replace the layout.');
             }
+            __classPrivateFieldSet(this, _LayoutModule_layoutInitializationAttempted, true, "f");
             // We need to go through environment to make sure it is only imported/bundled in OpenFin.
             const ManagerConstructor = await this.wire.environment.getManagerConstructor();
             const viewOverlay = new view_overlay_1.ViewOverlay(this.wire);
@@ -203,4 +205,4 @@ class LayoutModule extends base_1.Base {
     }
 }
 exports.LayoutModule = LayoutModule;
-_LayoutModule_layoutManager = new WeakMap();
+_LayoutModule_layoutManager = new WeakMap(), _LayoutModule_layoutInitializationAttempted = new WeakMap();

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

@@ -102,10 +102,10 @@ 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 }: {

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

@@ -148,14 +148,13 @@ 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' } = {}) => {
+            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.`);
             }

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

@@ -1,25 +1,27 @@
 import type * as OpenFin from '../../../../OpenFin';
 import { LayoutEntitiesClient } from '../shapes';
 /**
+ * @ignore
  * @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';
+     * @ignore
      */
-    readonly abstract type: OpenFin.LayoutEntityTypes;
+    protected constructor(client: LayoutEntitiesClient, entityId: string);
+    abstract readonly type: OpenFin.LayoutEntityTypes;
     /**
      * @internal
+     * @ignore
      * This instance's unique id used when calling the layout-entities-controller api client
      */
     protected readonly entityId: string;
     /**
+     * @ignore
      * @internal
      * Encapsulates Api consumption of {@link LayoutEntitiesController} with a relayed dispatch
      * @param client
@@ -29,51 +31,83 @@ export declare abstract class LayoutNode {
      */
     static newLayoutEntitiesClient: (client: OpenFin.ChannelClient, controllerId: string, identity: OpenFin.Identity) => Promise<LayoutEntitiesClient>;
     static getEntity: (definition: OpenFin.LayoutEntityDefinition, client: LayoutEntitiesClient) => ColumnOrRow | TabStack;
+    isRoot: () => Promise<boolean>;
+    exists: () => Promise<boolean>;
+    getParent: () => Promise<ColumnOrRow | TabStack | undefined>;
+    createAdjacentStack: (views: OpenFin.PlatformViewCreationOptions[], options: {
+        position?: OpenFin.LayoutPosition;
+    }) => Promise<TabStack>;
+    getAdjacentStacks: (edge: OpenFin.LayoutPosition) => Promise<TabStack[]>;
+}
+/**
+ * @typedef {string} LayoutPosition
+ * @summary Represents the position of an item in a layout relative to another. Possible values are 'top', 'bottom', 'left' and 'right'.
+ */
+/**
+ * @typedef {object} StackCreationOptions
+ * @summary Stack creation options.
+ * @property {LayoutPosition} [position] - The position to create the new {@link TabStack} in, relative to the given adjacent {@link TabStack}. Defaults to 'right'.
+ */
+/**
+ * @typedef {object} TabStack~AddViewOptions
+ * @summary Options to use when adding a view to a {@link TabStack}
+ * @property {number} [index] - Insertion index when adding the view. Defaults to 0.
+ */
+/**
+ * A TabStack is used to manage the state of a stack of tabs within an OpenFin Layout.
+ */
+export declare class TabStack extends LayoutNode {
+    #private;
     /**
-     * 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.
+     * Determines if this {@link TabStack} is the top level content item in the current layout.
+     * @function isRoot
+     * @memberof TabStack
+     * @instance
+     * @tutorial TabStack.isRoot
+     * @return {Promise<boolean>} Resolves true if this TabStack is the top level content item, or false if it is not.
      */
-    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.
+     * Determines if this  {@link TabStack} exists.
+     * @function exists
+     * @instance
+     * @memberof TabStack
+     * @tutorial TabStack.exists
+     * @return {Promise<boolean>} Resolves true if this is the TabStack exists, or false if it has been destroyed.
      */
-    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.
+     * Retrieves the parent {@link ColumnOrRow} of this {@link TabStack}, if one exists.
+     * @function getParent
+     * @instance
+     * @memberof TabStack
+     * @tutorial TabStack.getParent
+     * @return {Promise<ColumnOrRow | TabStack | undefined>} Promise resolving with the {@link ColumnOrRow} that contains this item, or undefined if this {@link TabStack} is the root content item or does not exist.
+     */
+    /**
+     * Returns all the adjacent stacks that share an edge with the given {@link TabStack}.
+     * @function getAdjacentStacks
+     * @instance
+     * @memberof TabStack
+     * @param  {LayoutPosition} edge - Edge to check for any adjacent stacks.
+     * @returns {Promise<TabStack[]>}
+     * @tutorial TabStack.getAdjacentStacks
      */
-    getParent: () => Promise<ColumnOrRow | TabStack | undefined>;
     /**
-     * Given a list of view creation options or references and a layout position, creates an adjacent {@link TabStack}
+     * Given a list of view creation options or references and a layout position, creates a {@link TabStack} adjacent to the current {@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
+     * @function createAdjacentStack
+     * @instance
+     * @memberof TabStack
+     * @param {View~options} views - List of identities or view creation options of the views to include in the stack
+     * @param {StackCreationOptions} options - Creation options.
+     * @returns {Promise<TabStack>} The created TabStack.
+     * @tutorial TabStack.createAdjacentStack
      * @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);
     /**
@@ -88,8 +122,9 @@ export declare class TabStack extends LayoutNode {
      * 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}.
+     * @returns {Promise<Identity[]>} 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.
+     * @tutorial TabStack.getViews
      * @experimental
      */
     getViews: () => Promise<OpenFin.Identity[]>;
@@ -99,25 +134,28 @@ export declare class TabStack extends LayoutNode {
      * 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.
+     * @param {View~options} view The identity of an existing view to add, or options to create a view.
+     * @param {TabStack~AddViewOptions} 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 {Promise<identity>} 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.
+     * @tutorial TabStack.addView
      * @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.
+     * @param {Identity} view - 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.
+     * @return {Promise<void>}
+     * @tutorial TabStack.removeView
      */
     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.
+     * @param {Identity} view - Identity of the view to activate.
+     * @returns {Promise<void>} 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
@@ -126,11 +164,63 @@ export declare class TabStack extends LayoutNode {
     setActiveView: (view: OpenFin.Identity) => Promise<void>;
 }
 /**
- * A {@link ColumnOrRow} is used to manage the state of a ColumnOrRow within an OpenFin Layout.
+ * A ColumnOrRow is used to manage the state of Column and Rows within an OpenFin Layout.
  */
 export declare class ColumnOrRow extends LayoutNode {
     #private;
-    /** @internal */
+    /**
+     * Determines if this {@link ColumnOrRow} is the top level content item in the current layout.
+     * @function isRoot
+     * @memberof ColumnOrRow
+     * @instance
+     * @tutorial ColumnOrRow.isRoot
+     * @return {Promise<boolean>} Resolves true if this TabStack is the top level content item, or false if it is not.
+     */
+    /**
+     * Determines if this  {@link ColumnOrRow} exists.
+     * @function exists
+     * @instance
+     * @memberof ColumnOrRow
+     * @tutorial ColumnOrRow.exists
+     * @return {Promise<boolean>} Resolves true if the TabStack exists, or false if it has been destroyed.
+     */
+    /**
+     * Retrieves the parent {@link ColumnOrRow} of this {@link ColumnOrRow}, if one exists.
+     * @function getParent
+     * @instance
+     * @memberof ColumnOrRow
+     * @tutorial ColumnOrRow.getParent
+     * @return {Promise<ColumnOrRow | undefined>} Promise resolving with the {@link ColumnOrRow} that contains this item, or undefined if this {@link ColumnOrRow} does not exist or is the root content item.
+     */
+    /**
+     * Returns all the adjacent stacks that share an edge with the given {@link ColumnOrRow}.
+     * @function getAdjacentStacks
+     * @instance
+     * @memberof ColumnOrRow
+     * @param  {LayoutPosition} edge - Edge to check for any adjacent stacks.
+     * @returns {Promise<TabStack[]>}
+     * @tutorial ColumnOrRow.getAdjacentStacks
+     */
+    /**
+     * Given a list of view creation options or references and a layout position, creates a {@link TabStack} adjacent to the given {@link ColumnOrRow}
+     *
+     * 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.
+     *
+     * @function createAdjacentStack
+     * @instance
+     * @memberof ColumnOrRow
+     * @param {View~options} views - List of identities or view creation options of the views to include in the stack
+     * @param {StackCreationOptions} options - Creation options.
+     * @returns {Promise<TabStack>} The created TabStack
+     * @tutorial ColumnOrRow.createAdjacentStack
+     * @experimental
+     */
+    /**
+     * @internal
+     */
     constructor(client: LayoutEntitiesClient, entityId: string, type: 'row' | 'column');
     /**
      * The type of this {@link ColumnOrRow}. Either 'row' or 'column'.
@@ -138,7 +228,8 @@ export declare class ColumnOrRow extends LayoutNode {
     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}.
+     * @returns {Promise<Array<ColumnOrRow | TabStack>>} Resolves with a list containing {@link ColumnOrRow} and {@link TabStack} items belonging to this {@link ColumnOrRow}.
+     * @tutorial ColumnOrRow.getContent
      */
     getContent: () => Promise<(ColumnOrRow | TabStack)[]>;
 }

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

@@ -21,33 +21,25 @@ const channel_api_relay_1 = require("../../../../util/channel-api-relay");
     refs, we define and export all the classes here.
 */
 /**
+ * @ignore
  * @internal
  * Supplies an ApiClient for {@link LayoutEntitiesController} and helper methods
  * for the entities {@link TabStack} AND {@link ColumnOrRow} to use.
  */
 class LayoutNode {
-    /** @internal */
+    /**
+     * @internal
+     * @ignore
+     */
     constructor(client, entityId) {
         /**
+         * @ignore
          * @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) {
@@ -55,34 +47,16 @@ class LayoutNode {
             }
             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({
+            return adjacentStacks.map((stack) => LayoutNode.getEntity({
                 type: 'stack',
                 entityId: stack.entityId
             }, __classPrivateFieldGet(this, _LayoutNode_client, "f")));
@@ -94,6 +68,7 @@ class LayoutNode {
 exports.LayoutNode = LayoutNode;
 _a = LayoutNode, _LayoutNode_client = new WeakMap();
 /**
+ * @ignore
  * @internal
  * Encapsulates Api consumption of {@link LayoutEntitiesController} with a relayed dispatch
  * @param client
@@ -119,10 +94,73 @@ LayoutNode.getEntity = (definition, client) => {
     }
 };
 /**
- * A {@link TabStack} is used to manage the state of a TabStack within an OpenFin Layout and
- * traverse to its parent Content Item.
+ * @typedef {string} LayoutPosition
+ * @summary Represents the position of an item in a layout relative to another. Possible values are 'top', 'bottom', 'left' and 'right'.
+ */
+/**
+ * @typedef {object} StackCreationOptions
+ * @summary Stack creation options.
+ * @property {LayoutPosition} [position] - The position to create the new {@link TabStack} in, relative to the given adjacent {@link TabStack}. Defaults to 'right'.
+ */
+/**
+ * @typedef {object} TabStack~AddViewOptions
+ * @summary Options to use when adding a view to a {@link TabStack}
+ * @property {number} [index] - Insertion index when adding the view. Defaults to 0.
+ */
+/**
+ * A TabStack is used to manage the state of a stack of tabs within an OpenFin Layout.
  */
 class TabStack extends LayoutNode {
+    /**
+     * Determines if this {@link TabStack} is the top level content item in the current layout.
+     * @function isRoot
+     * @memberof TabStack
+     * @instance
+     * @tutorial TabStack.isRoot
+     * @return {Promise<boolean>} Resolves true if this TabStack is the top level content item, or false if it is not.
+     */
+    /**
+     * Determines if this  {@link TabStack} exists.
+     * @function exists
+     * @instance
+     * @memberof TabStack
+     * @tutorial TabStack.exists
+     * @return {Promise<boolean>} Resolves true if this is the TabStack exists, or false if it has been destroyed.
+     */
+    /**
+     * Retrieves the parent {@link ColumnOrRow} of this {@link TabStack}, if one exists.
+     * @function getParent
+     * @instance
+     * @memberof TabStack
+     * @tutorial TabStack.getParent
+     * @return {Promise<ColumnOrRow | TabStack | undefined>} Promise resolving with the {@link ColumnOrRow} that contains this item, or undefined if this {@link TabStack} is the root content item or does not exist.
+     */
+    /**
+     * Returns all the adjacent stacks that share an edge with the given {@link TabStack}.
+     * @function getAdjacentStacks
+     * @instance
+     * @memberof TabStack
+     * @param  {LayoutPosition} edge - Edge to check for any adjacent stacks.
+     * @returns {Promise<TabStack[]>}
+     * @tutorial TabStack.getAdjacentStacks
+     */
+    /**
+     * Given a list of view creation options or references and a layout position, creates a {@link TabStack} adjacent to the current {@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.
+     *
+     * @function createAdjacentStack
+     * @instance
+     * @memberof TabStack
+     * @param {View~options} views - List of identities or view creation options of the views to include in the stack
+     * @param {StackCreationOptions} options - Creation options.
+     * @returns {Promise<TabStack>} The created TabStack.
+     * @tutorial TabStack.createAdjacentStack
+     * @experimental
+     */
     /** @internal */
     constructor(client, entityId) {
         super(client, entityId);
@@ -143,8 +181,9 @@ class TabStack extends LayoutNode {
          * 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}.
+         * @returns {Promise<Identity[]>} 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.
+         * @tutorial TabStack.getViews
          * @experimental
          */
         this.getViews = () => __classPrivateFieldGet(this, _TabStack_client, "f").getStackViews(this.entityId);
@@ -154,27 +193,30 @@ class TabStack extends LayoutNode {
          * 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.
+         * @param {View~options} view The identity of an existing view to add, or options to create a view.
+         * @param {TabStack~AddViewOptions} 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 {Promise<identity>} 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.
+         * @tutorial TabStack.addView
          * @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.
+         * @param {Identity} view - 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.
+         * @return {Promise<void>}
+         * @tutorial TabStack.removeView
          */
         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.
+         * @param {Identity} view - Identity of the view to activate.
+         * @returns {Promise<void>} 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
@@ -189,20 +231,74 @@ class TabStack extends LayoutNode {
 exports.TabStack = TabStack;
 _TabStack_client = new WeakMap();
 /**
- * A {@link ColumnOrRow} is used to manage the state of a ColumnOrRow within an OpenFin Layout.
+ * A ColumnOrRow is used to manage the state of Column and Rows within an OpenFin Layout.
  */
 class ColumnOrRow extends LayoutNode {
-    /** @internal */
+    /**
+     * Determines if this {@link ColumnOrRow} is the top level content item in the current layout.
+     * @function isRoot
+     * @memberof ColumnOrRow
+     * @instance
+     * @tutorial ColumnOrRow.isRoot
+     * @return {Promise<boolean>} Resolves true if this TabStack is the top level content item, or false if it is not.
+     */
+    /**
+     * Determines if this  {@link ColumnOrRow} exists.
+     * @function exists
+     * @instance
+     * @memberof ColumnOrRow
+     * @tutorial ColumnOrRow.exists
+     * @return {Promise<boolean>} Resolves true if the TabStack exists, or false if it has been destroyed.
+     */
+    /**
+     * Retrieves the parent {@link ColumnOrRow} of this {@link ColumnOrRow}, if one exists.
+     * @function getParent
+     * @instance
+     * @memberof ColumnOrRow
+     * @tutorial ColumnOrRow.getParent
+     * @return {Promise<ColumnOrRow | undefined>} Promise resolving with the {@link ColumnOrRow} that contains this item, or undefined if this {@link ColumnOrRow} does not exist or is the root content item.
+     */
+    /**
+     * Returns all the adjacent stacks that share an edge with the given {@link ColumnOrRow}.
+     * @function getAdjacentStacks
+     * @instance
+     * @memberof ColumnOrRow
+     * @param  {LayoutPosition} edge - Edge to check for any adjacent stacks.
+     * @returns {Promise<TabStack[]>}
+     * @tutorial ColumnOrRow.getAdjacentStacks
+     */
+    /**
+     * Given a list of view creation options or references and a layout position, creates a {@link TabStack} adjacent to the given {@link ColumnOrRow}
+     *
+     * 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.
+     *
+     * @function createAdjacentStack
+     * @instance
+     * @memberof ColumnOrRow
+     * @param {View~options} views - List of identities or view creation options of the views to include in the stack
+     * @param {StackCreationOptions} options - Creation options.
+     * @returns {Promise<TabStack>} The created TabStack
+     * @tutorial ColumnOrRow.createAdjacentStack
+     * @experimental
+     */
+    /**
+     * @internal
+     */
     constructor(client, entityId, type) {
         super(client, entityId);
         /**
+         * @ignore
          * @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}.
+         * @returns {Promise<Array<ColumnOrRow | TabStack>>} Resolves with a list containing {@link ColumnOrRow} and {@link TabStack} items belonging to this {@link ColumnOrRow}.
+         * @tutorial ColumnOrRow.getContent
          */
         this.getContent = async () => {
             const contentItemEntities = await __classPrivateFieldGet(this, _ColumnOrRow_client, "f").getContent(this.entityId);

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

@@ -1,4 +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 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

@@ -18,19 +18,19 @@ 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) => {

package/src/environment/mockEnvironment.d.ts

@@ -0,0 +1,27 @@
+import { Environment } from './environment';
+import type * as OpenFin from '../OpenFin';
+import { NewConnectConfig } from '../transport/wire';
+import { EntityType } from '../OpenFin';
+export declare class MockEnvironment implements Environment {
+    getDefaultChannelOptions(): {
+        create: OpenFin.ChannelCreateOptions;
+        connect: OpenFin.ChannelConnectOptions;
+    };
+    getRtcPeer(): RTCPeerConnection;
+    getManagerConstructor(): Promise<never>;
+    getProviderInitializer(): Promise<never>;
+    observeBounds(): never;
+    writeToken(path: string, token: string): Promise<string>;
+    retrievePort(config: NewConnectConfig): Promise<number>;
+    getNextMessageId(): string;
+    getRandomId(): string;
+    createChildContent(options: any): Promise<any>;
+    getWebWindow(identity: OpenFin.Identity): globalThis.Window;
+    getCurrentEntityIdentity(): OpenFin.EntityInfo;
+    getCurrentEntityType(): EntityType;
+    raiseEvent(eventName: string, eventArgs: any): void;
+    getUrl(): string;
+    whenReady(): Promise<void>;
+    childViews: boolean;
+    getWsConstructor(): any;
+}

package/src/environment/mockEnvironment.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MockEnvironment = void 0;
+const me_1 = require("../api/me");
+class MockEnvironment {
+    constructor() {
+        this.childViews = true;
+    }
+    getDefaultChannelOptions() {
+        throw new Error(me_1.environmentUnsupportedMessage);
+    }
+    getRtcPeer() {
+        throw new Error(me_1.environmentUnsupportedMessage);
+    }
+    getManagerConstructor() {
+        throw new Error(me_1.environmentUnsupportedMessage);
+    }
+    getProviderInitializer() {
+        throw new Error(me_1.environmentUnsupportedMessage);
+    }
+    observeBounds() {
+        throw new Error(me_1.environmentUnsupportedMessage);
+    }
+    writeToken(path, token) {
+        throw new Error(me_1.environmentUnsupportedMessage);
+    }
+    retrievePort(config) {
+        throw new Error(me_1.environmentUnsupportedMessage);
+    }
+    getNextMessageId() {
+        throw new Error(me_1.environmentUnsupportedMessage);
+    }
+    getRandomId() {
+        throw new Error(me_1.environmentUnsupportedMessage);
+    }
+    createChildContent(options) {
+        throw new Error(me_1.environmentUnsupportedMessage);
+    }
+    getWebWindow(identity) {
+        throw new Error(me_1.environmentUnsupportedMessage);
+    }
+    getCurrentEntityIdentity() {
+        throw new Error(me_1.environmentUnsupportedMessage);
+    }
+    getCurrentEntityType() {
+        return 'unknown';
+    }
+    raiseEvent(eventName, eventArgs) {
+        throw new Error(me_1.environmentUnsupportedMessage);
+    }
+    getUrl() {
+        throw new Error(me_1.environmentUnsupportedMessage);
+    }
+    whenReady() {
+        throw new Error(me_1.environmentUnsupportedMessage);
+    }
+    getWsConstructor() {
+        throw new Error('Method not implemented.');
+    }
+}
+exports.MockEnvironment = MockEnvironment;

package/src/mock.js

@@ -1,7 +1,6 @@
 "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 */
@@ -10,82 +9,12 @@ const events_1 = require("events");
 /// <reference path="../OpenFin.d.ts"/>
 const fin_1 = require("./api/fin");
 const transport_1 = require("./transport/transport");
-const me_1 = require("./api/me");
-class MockWire extends events_1.EventEmitter {
-    connect(address) {
-        throw new Error('You are not running in OpenFin.');
-    }
-    connectSync() {
-        throw new Error('You are not running in OpenFin.');
-    }
-    send(data) {
-        throw new Error('You are not running in OpenFin.');
-    }
-    shutdown() {
-        throw new Error('You are not running in OpenFin.');
-    }
-    // eslint-disable-next-line no-useless-constructor
-    constructor() {
-        super();
-    }
-}
-class MockEnvironment {
-    constructor() {
-        this.childViews = true;
-    }
-    getDefaultChannelOptions() {
-        throw new Error(me_1.environmentUnsupportedMessage);
-    }
-    getRtcPeer() {
-        throw new Error(me_1.environmentUnsupportedMessage);
-    }
-    getManagerConstructor() {
-        throw new Error(me_1.environmentUnsupportedMessage);
-    }
-    getProviderInitializer() {
-        throw new Error(me_1.environmentUnsupportedMessage);
-    }
-    writeToken(path, token) {
-        throw new Error(me_1.environmentUnsupportedMessage);
-    }
-    retrievePort(config) {
-        throw new Error(me_1.environmentUnsupportedMessage);
-    }
-    getNextMessageId() {
-        throw new Error(me_1.environmentUnsupportedMessage);
-    }
-    getRandomId() {
-        throw new Error(me_1.environmentUnsupportedMessage);
-    }
-    createChildContent(options) {
-        throw new Error(me_1.environmentUnsupportedMessage);
-    }
-    getWebWindow(identity) {
-        throw new Error(me_1.environmentUnsupportedMessage);
-    }
-    getCurrentEntityIdentity() {
-        throw new Error(me_1.environmentUnsupportedMessage);
-    }
-    getCurrentEntityType() {
-        return 'unknown';
-    }
-    raiseEvent(eventName, eventArgs) {
-        throw new Error(me_1.environmentUnsupportedMessage);
-    }
-    getUrl() {
-        throw new Error(me_1.environmentUnsupportedMessage);
-    }
-    whenReady() {
-        throw new Error(me_1.environmentUnsupportedMessage);
-    }
-    getWsConstructor() {
-        throw new Error('Method not implemented.');
-    }
-}
+const mockEnvironment_1 = require("./environment/mockEnvironment");
+const mockWire_1 = require("./transport/mockWire");
 exports.fin = ((typeof window !== 'undefined' && (window === null || window === void 0 ? void 0 : window.fin)) ||
     (() => {
-        const environment = new MockEnvironment();
-        const transport = new transport_1.Transport(MockWire, environment, {
+        const environment = new mockEnvironment_1.MockEnvironment();
+        const transport = new transport_1.Transport(mockWire_1.MockWire, environment, {
             uuid: '',
             name: ''
         });

package/src/shapes/protocol.d.ts

@@ -66,10 +66,8 @@ export interface ProtocolMap extends ProtocolMapBase {
         };
         response: OpenFin.NativeWindowIntegrationProviderAuthorization;
     };
-    'get-permissions': {
-        request: void;
-        response: any;
-    };
+    'get-permissions': GetterCall<any>;
+    'get-all-channels': GetterCall<OpenFin.ProviderIdentity[]>;
     'set-file-download-location': {
         request: OpenFin.ApplicationIdentity & {
             downloadLocation: string;
@@ -144,16 +142,14 @@ export interface ProtocolMap extends ProtocolMapBase {
         };
         response: void;
     };
-    'system-get-printers': {
-        request: void;
-        response: OpenFin.PrinterInfo[];
-    };
+    'system-get-printers': GetterCall<OpenFin.PrinterInfo[]>;
 }
 declare type ApiCall<Request, Response> = {
     request: Request;
     response: Response;
 };
 declare type VoidCall = ApiCall<void, void>;
+declare type GetterCall<T> = ApiCall<void, T>;
 declare type IdentityCall<AdditionalPayload = {}, Response = void> = ApiCall<AdditionalPayload & OpenFin.Identity, Response>;
 interface ProtocolMapBase {
     [action: string]: {

package/src/transport/mockWire.d.ts

@@ -0,0 +1,11 @@
+/// <reference types="node" />
+import { EventEmitter } from 'events';
+import { Wire } from './wire';
+export declare class MockWire extends EventEmitter implements Wire {
+    connect(address: string): Promise<any>;
+    connectSync(): any;
+    send(data: any): Promise<any>;
+    shutdown(): Promise<void>;
+    getPort(): string;
+    constructor();
+}

package/src/transport/mockWire.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MockWire = void 0;
+const events_1 = require("events");
+class MockWire extends events_1.EventEmitter {
+    connect(address) {
+        throw new Error('You are not running in OpenFin.');
+    }
+    connectSync() {
+        throw new Error('You are not running in OpenFin.');
+    }
+    send(data) {
+        throw new Error('You are not running in OpenFin.');
+    }
+    shutdown() {
+        throw new Error('You are not running in OpenFin.');
+    }
+    getPort() {
+        throw new Error('This transport has no port');
+    }
+    // eslint-disable-next-line no-useless-constructor
+    constructor() {
+        super();
+    }
+}
+exports.MockWire = MockWire;

package/src/util/lazy.d.ts

@@ -14,3 +14,21 @@ export declare class Lazy<T> {
      */
     getValue(): T;
 }
+/**
+ * Handy class for managing asynchronous dependencies of classes.
+ *
+ * Will call asynchronous producer only after `getValue` is called.  If the
+ * deferred code errors, we can try it again by re-calling `getValue` after
+ * the promise rejects.
+ */
+export declare class AsyncRetryableLazy<T> {
+    private producerFn;
+    constructor(producerFn: () => Promise<T>);
+    private promise?;
+    /**
+     * Lazily get the value returned by the async producer.
+     *
+     * @returns The value returned from the producer function
+     */
+    getValue(): Promise<T>;
+}

package/src/util/lazy.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Lazy = void 0;
+exports.AsyncRetryableLazy = exports.Lazy = void 0;
 /**
  * Handy class for managing asynchronous dependencies of classes.
  *
@@ -24,3 +24,31 @@ class Lazy {
     }
 }
 exports.Lazy = Lazy;
+/**
+ * Handy class for managing asynchronous dependencies of classes.
+ *
+ * Will call asynchronous producer only after `getValue` is called.  If the
+ * deferred code errors, we can try it again by re-calling `getValue` after
+ * the promise rejects.
+ */
+class AsyncRetryableLazy {
+    // eslint-disable-next-line
+    constructor(producerFn) {
+        this.producerFn = producerFn;
+    }
+    /**
+     * Lazily get the value returned by the async producer.
+     *
+     * @returns The value returned from the producer function
+     */
+    async getValue() {
+        if (!this.promise) {
+            this.promise = this.producerFn().catch((e) => {
+                delete this.promise;
+                throw e;
+            });
+        }
+        return this.promise;
+    }
+}
+exports.AsyncRetryableLazy = AsyncRetryableLazy;