@openfin/core 30.73.28 → 30.74.7

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

@@ -0,0 +1,270 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LayoutEntitiesController = void 0;
+const decorators_1 = require("../../../api-exposer/decorators");
+const layout_traversal_1 = require("../utils/layout-traversal");
+/**
+ * @internal
+ * Controller for the layout entities apis, allowing alterations to be applied
+ * to an instance of layout manager in a structured manner.
+ */
+class LayoutEntitiesController {
+    constructor(
+    // workaround to prevent importing entire GoldenLayouts, also re-written at build time to type any
+    layoutManager, layoutContentCache) {
+        this.layoutManager = layoutManager;
+        this.layoutContentCache = layoutContentCache;
+        /**
+         * @internal
+         * @returns the root contentItem of the layout.
+         */
+        this.getRoot = () => {
+            const root = this.layoutManager.layout.root.contentItems[0];
+            return {
+                // TODO: fix typing
+                type: root.type,
+                entityId: this.layoutContentCache.getOrCreateEntityId(root)
+            };
+        };
+        /**
+         * @internal
+         * Retrieves the containing stack of a given view identity.
+         * @param view Identity of the view to retrieve the stack of.
+         * @returns Stack containing the given view.
+         * @throws If the view does not belong to a stack within the layout manager.
+         */
+        this.getStackByView = async (view) => {
+            var _a, _b, _c, _d;
+            const viewComponent = this.layoutManager.getViewComponent(view);
+            if (!viewComponent || ((_b = (_a = viewComponent.container) === null || _a === void 0 ? void 0 : _a.parent) === null || _b === void 0 ? void 0 : _b.parent.type) !== 'stack') {
+                return undefined;
+            }
+            const stack = (_d = (_c = viewComponent.container) === null || _c === void 0 ? void 0 : _c.parent) === null || _d === void 0 ? void 0 : _d.parent;
+            return { entityId: this.layoutContentCache.getOrCreateEntityId(stack), type: 'stack' };
+        };
+        /**
+         * @internal
+         * Returns all views belonging to a given stack
+         *
+         * NOTE: Due to (TODO: ticket) Golden Layouts has an issue which changes the order of tabs
+         * when the amount of new views to add overflows the width of the container. This results
+         * in tabs being re-ordered in the UI, while the underlying content item array remains in the
+         * original order specified. So calling getStackViews() will return this underlying array order,
+         * with indexes that will not match up to the render-order of the tabs.
+         *
+         * @param id - Entity id of the stack.
+         * @returns A list of view identities in order of appearance.
+         * @throws if the content item associated with the entity id does not exist or is not a stack.
+         */
+        this.getStackViews = (id) => {
+            const stack = this.layoutContentCache.getContentItemOrThrow(id, ['stack']);
+            const views = stack.contentItems.map((ci) => {
+                var _a;
+                return ({
+                    name: (_a = ci.config.componentState) === null || _a === void 0 ? void 0 : _a.name,
+                    uuid: this.layoutManager.ofWindow.identity.uuid
+                });
+            });
+            return views;
+        };
+        /**
+         * @internal
+         * @param id Entity id associated with a layout content item.
+         * @returns true if the given entity is the root content item, false otherwise.
+         */
+        this.isRoot = (id) => {
+            var _a;
+            const ci = this.layoutContentCache.getContentItemOrThrow(id);
+            return !!((_a = ci.parent) === null || _a === void 0 ? void 0 : _a.isRoot);
+        };
+        /**
+         * @internal
+         * Checks whether the given entity exists.
+         * @param entityId Id of a content item within the layout
+         * @returns True if the content item exists and belongs to the layout.
+         */
+        this.exists = (entityId) => {
+            return this.layoutContentCache.hasKey(entityId);
+        };
+        /**
+         * @internal
+         * Adds an existing view to the stack, or creates and adds a view to the given stack.
+         *
+         * NOTE: Due to (TODO: ticket) Golden Layouts has an issue which changes the order of tabs
+         * when the amount of new views to add overflows the width of the container. This results
+         * in tabs being re-ordered in the UI, while the underlying content item array remains in the
+         * original order specified. So calling getStackViews() will return this underlying array order,
+         * with indexes that will not match up to the render-order of the tabs.
+         *
+         * @param stackEntityId Entity id of the stack content item within the layout.
+         * @param viewCreationOrReference View identity or creation options
+         * @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 Promise resolving with the identity of the newly added view.
+         * @throws If the view does not exist, fails to create, or the stack does not exist.
+         */
+        this.addViewToStack = async (stackEntityId, viewCreationOrReference, { index } = { index: 0 }) => {
+            const currentStack = this.layoutContentCache.getContentItemOrThrow(stackEntityId);
+            if (index && index > currentStack.contentItems.length + 1) {
+                throw new Error(`Index '${index}' out of range, please exclude the index or specify a number between 0 and ${currentStack.contentItems.length}`);
+            }
+            const location = {
+                id: stackEntityId,
+                index
+            };
+            const { identity } = await this.layoutManager.platform.createView(viewCreationOrReference, {
+                ...this.layoutManager.ofWindow.identity,
+                location,
+            });
+            return identity;
+        };
+        this.findViewInStack = (stack, viewIdentity) => {
+            return stack.contentItems.find((ci) => { var _a, _b; return ((_b = (_a = ci.config) === null || _a === void 0 ? void 0 : _a.componentState) === null || _b === void 0 ? void 0 : _b.name) === viewIdentity.name; });
+        };
+        /**
+         * @internal
+         * Removes a view from the given stack. If it's the only view, the stack will be destroyed, unless window creation
+         * option closeOnLastViewRemoved is set to false.
+         *
+         * @param stackEntityId Entity id of a stack content item to remove the view from.
+         * @param view Identity of the view to remove.
+         * @throws If the stack does not exist or the view does not exist or belong to the stack.
+         */
+        this.removeViewFromStack = async (stackEntityId, view) => {
+            const stack = this.layoutContentCache.getContentItemOrThrow(stackEntityId, ['stack']);
+            const viewInstance = this.findViewInStack(stack, view);
+            if (!viewInstance) {
+                throw new Error(`Tried to remove a view ('${view.name}') which does not belong to the stack.`);
+            }
+            await this.layoutManager.platform.closeView(view);
+        };
+        /**
+         * @internal
+         * 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'
+         * @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.');
+            }
+            const { position = 'right' } = options;
+            if (!['top', 'bottom', 'left', 'right'].includes(position)) {
+                throw new Error(`Invalid position '${position}' specified.`);
+            }
+            const currentStack = this.layoutContentCache.getContentItemOrThrow(targetId);
+            const { parent } = currentStack;
+            const containerType = ['top', 'bottom'].includes(position) ? 'column' : 'row';
+            const newContainer = this.layoutManager.layout.createContentItem({
+                type: containerType,
+            });
+            const newStack = this.layoutManager.layout.createContentItem({
+                type: 'stack'
+            });
+            parent.replaceChild(currentStack, newContainer);
+            newContainer.addChild(currentStack);
+            const offset = ['left', 'top'].includes(position) ? -1 : 1;
+            const newStackIndex = newContainer.contentItems.indexOf(currentStack) + offset;
+            newContainer.addChild(newStack, newStackIndex);
+            const entityId = this.layoutContentCache.getOrCreateEntityId(newStack);
+            // !! reverse the views list so we can utilize index=0 (prepending each tab)
+            // which will maintain correct order in the underlying GL structure and avoids the reflow bug
+            await Promise.all(views.reverse().map((view) => this.addViewToStack(entityId, view)));
+            return entityId;
+        };
+        this.getAdjacentStacks = async ({ targetId, edge }) => {
+            const contentItem = this.layoutContentCache.getContentItemOrThrow(targetId);
+            // call utils helper to traverse and return adjacent stacks
+            return (0, layout_traversal_1.getAdjacentStacks)(contentItem, edge).map((stack) => ({
+                entityId: this.layoutContentCache.getOrCreateEntityId(stack),
+            }));
+        };
+        this.setStackActiveView = async (stackEntityId, viewIdentity) => {
+            const stack = this.layoutContentCache.getContentItemOrThrow(stackEntityId, ['stack']);
+            const view = this.findViewInStack(stack, viewIdentity);
+            if (!view) {
+                throw new Error(`Tried to set a view ('${viewIdentity.name}') as active when it does not belong to the stack.`);
+            }
+            stack.setActiveContentItem(view, true);
+        };
+    }
+    /**
+     * @internal
+     * Retrieves the content of a column or row and adds each to the
+     * entity cache to allow them to be addressed externally.
+     * @param id Entity id of the Column Or Row to retrieve the content of.
+     * @returns Array of layout entity definitions
+     * @throws if the entity associated with {@link id} is not in the entity cache, does not belogn to a layout, or is not a column/row.
+     */
+    getContent(id) {
+        const ci = this.layoutContentCache.getContentItemOrThrow(id, ['column', 'row']);
+        return ci.contentItems.map((item) => ({
+            type: item.type,
+            entityId: this.layoutContentCache.getOrCreateEntityId(item)
+        }));
+    }
+    ;
+    /**
+     * @internal
+     * Retrieves the parent content item of the given entity, and adds it to the entity cache
+     * so it can be addressed externally.
+     * @param id Entity id associated with a layout content item.
+     * @returns An entity definition for the given entity's parent, or undefined if the entity is the top level
+     * content item or has been removed from the layout entirely.
+     */
+    getParent(id) {
+        const ci = this.layoutContentCache.getContentItemOrThrow(id);
+        if (ci.parent && !ci.parent.isRoot && ci.parent.contentItems.includes(ci)) {
+            return {
+                type: ci.parent.type,
+                entityId: this.layoutContentCache.getOrCreateEntityId(ci.parent)
+            };
+        }
+        return undefined;
+    }
+    ;
+}
+__decorate([
+    (0, decorators_1.expose)()
+], LayoutEntitiesController.prototype, "getRoot", void 0);
+__decorate([
+    (0, decorators_1.expose)()
+], LayoutEntitiesController.prototype, "getStackByView", void 0);
+__decorate([
+    (0, decorators_1.expose)()
+], LayoutEntitiesController.prototype, "getStackViews", void 0);
+__decorate([
+    (0, decorators_1.expose)()
+], LayoutEntitiesController.prototype, "getContent", null);
+__decorate([
+    (0, decorators_1.expose)()
+], LayoutEntitiesController.prototype, "getParent", null);
+__decorate([
+    (0, decorators_1.expose)()
+], LayoutEntitiesController.prototype, "isRoot", void 0);
+__decorate([
+    (0, decorators_1.expose)()
+], LayoutEntitiesController.prototype, "exists", void 0);
+__decorate([
+    (0, decorators_1.expose)()
+], LayoutEntitiesController.prototype, "addViewToStack", void 0);
+__decorate([
+    (0, decorators_1.expose)()
+], LayoutEntitiesController.prototype, "removeViewFromStack", void 0);
+__decorate([
+    (0, decorators_1.expose)()
+], LayoutEntitiesController.prototype, "createAdjacentStack", void 0);
+__decorate([
+    (0, decorators_1.expose)()
+], LayoutEntitiesController.prototype, "getAdjacentStacks", void 0);
+__decorate([
+    (0, decorators_1.expose)()
+], LayoutEntitiesController.prototype, "setStackActiveView", void 0);
+exports.LayoutEntitiesController = LayoutEntitiesController;

package/src/api/platform/layout/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 declare type LayoutEntityTypes = Exclude<GoldenLayout.ItemType, 'component' | 'root'>;
+export declare type LayoutPosition = 'top' | 'bottom' | 'left' | 'right';
+export declare 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';
 declare 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 declare 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[];