@openfin/core 31.74.25 → 31.74.28

package/package.json

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

package/src/OpenFin.d.ts

@@ -10,12 +10,14 @@ import type { ChannelProvider } from './api/interappbus/channel/provider';
 import type { InteropBroker, InteropClient } from './api/interop';
 import type { Platform } from './api/platform';
 import type { Layout } from './api/platform/layout';
+import type { ColumnOrRow, TabStack } from './api/platform/layout/entities/layout-entities';
 import { PlatformProvider } from './api/platform/provider';
 import { SnapshotSource } from './api/snapshot-source';
 import type { View } from './api/view';
 import { _Window } from './api/window';
 export type Fin<MeType extends EntityType = 'window' | 'view'> = FinApi<MeType>;
-export type { Application, ExternalApplication, _Frame as Frame, ChannelClient, ChannelProvider, Platform, Layout, View, _Window as Window, InteropClient, InteropBroker, SnapshotSource };
+export type { Application, ExternalApplication, _Frame as Frame, ChannelClient, ChannelProvider, Platform, Layout, View, ColumnOrRow, TabStack, _Window as Window, InteropClient, InteropBroker, SnapshotSource };
+export type { LayoutEntityDefinition, LayoutEntityTypes, LayoutPosition } from './api/platform/layout/entities/shapes';
 export type WebContent = View | _Window;
 export type { PlatformProvider };
 export type ApplicationIdentity = {
@@ -1330,6 +1332,22 @@ export type ApplySnapshotPayload = {
      */
     options?: ApplySnapshotOptions;
 };
+export type AddViewToStackOptions = {
+    /**
+     * Optional index within the stack to insert the view. Defaults to 0
+     */
+    index?: number;
+};
+export type CreateViewTarget = Identity & {
+    /**
+     * If specified, view creation will not attach to a window and caller must
+     * insert the view into the layout explicitly
+     */
+    location?: {
+        id: string;
+        index?: number;
+    };
+};
 export type CreateViewPayload = {
     /**
      * Options for the view to be added.
@@ -1338,7 +1356,7 @@ export type CreateViewPayload = {
     /**
      * Window the view will be added to. If no target is provided, a new window will be created.
      */
-    target?: Identity;
+    target?: CreateViewTarget;
     targetView?: Identity;
 };
 export type ReplaceViewPayload = {

package/src/api/application/Factory.js

@@ -203,7 +203,6 @@ class ApplicationModule extends base_1.Base {
             // we do not want to expose this error, just continue if this analytics-only call fails
         });
         const app = await this._createFromManifest(manifestUrl);
-        // eslint-disable-next-line @typescript-eslint/ban-ts-comment
         // @ts-expect-error using private method without warning.
         await app._run(opts); // eslint-disable-line no-underscore-dangle
         return app;

package/src/api/platform/Factory.js

@@ -152,8 +152,7 @@ class PlatformModule extends base_1.Base {
                 // TODO: fix typing (internal)
                 // @ts-expect-error
                 app.once('platform-api-ready', () => resolve(this.wrapSync({ uuid })));
-                // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-                // @ts-ignore using private variable.
+                // @ts-expect-error using private variable.
                 app._run({ uuid });
             }
             catch (e) {
@@ -177,13 +176,11 @@ class PlatformModule extends base_1.Base {
         // eslint-disable-next-line no-async-promise-executor
         return new Promise(async (resolve, reject) => {
             try {
-                // eslint-disable-next-line @typescript-eslint/ban-ts-comment
                 // @ts-expect-error using private variable.
                 const app = await this.fin.Application._createFromManifest(manifestUrl);
                 // TODO: fix typing (internal)
                 // @ts-expect-error
                 app.once('platform-api-ready', () => resolve(this.wrapSync({ uuid: app.identity.uuid })));
-                // eslint-disable-next-line @typescript-eslint/ban-ts-comment
                 // @ts-expect-error using private method without warning.
                 app._run(opts);
             }

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

@@ -27,7 +27,7 @@ export declare class Platform extends EmitterBase<OpenFin.PlatformEvent> {
      * @return { Promise<View> }
      * @tutorial Platform.createView
      */
-    createView(viewOptions: OpenFin.PlatformViewCreationOptions, target?: OpenFin.Identity, targetView?: OpenFin.Identity): Promise<View>;
+    createView(viewOptions: OpenFin.PlatformViewCreationOptions, target?: OpenFin.CreateViewTarget, targetView?: OpenFin.Identity): Promise<View>;
     /**
      * Creates a new Window.
      * @param { Window~options } options Window creation options

package/src/api/platform/Instance.js

@@ -78,7 +78,7 @@ class Platform extends base_1.EmitterBase {
         const response = await client.dispatch('create-view', {
             target,
             opts: viewOptions,
-            targetView
+            targetView,
         });
         if (!response || (0, validate_1.validateIdentity)(response.identity)) {
             throw new Error(`When overwriting the createView call, please return an object that has a valid 'identity' property: ${JSON.stringify(response)}`);

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

@@ -19,6 +19,10 @@ const Instance_1 = require("./Instance");
 const base_1 = require("../../base");
 const splitter_controller_1 = require("./controllers/splitter-controller");
 const view_overlay_1 = require("./utils/view-overlay");
+const api_exposer_1 = require("../../api-exposer");
+const layout_entities_controller_1 = require("./controllers/layout-entities-controller");
+const layout_constants_1 = require("./layout.constants");
+const layout_content_cache_1 = require("./controllers/layout-content-cache");
 /**
  * @PORTED
  * InitLayoutOptions interface
@@ -113,7 +117,8 @@ class LayoutModule extends base_1.Base {
             const viewOverlay = new view_overlay_1.ViewOverlay(this.wire);
             const splitterController = new splitter_controller_1.SplitterController(viewOverlay);
             const tabDragController = new tab_drag_controller_1.TabDragController(viewOverlay);
-            __classPrivateFieldSet(this, _LayoutModule_layoutManager, new ManagerConstructor(splitterController, tabDragController), "f");
+            const contentItemCache = new layout_content_cache_1.LayoutContentCache();
+            __classPrivateFieldSet(this, _LayoutModule_layoutManager, new ManagerConstructor(splitterController, tabDragController, contentItemCache), "f");
             // @ts-expect-error - layout warning here for backwards compatibility, can remove layout check in .52
             let { layout, containerId } = options;
             if (layout) {
@@ -128,6 +133,10 @@ class LayoutModule extends base_1.Base {
             // pull createChannelConnection out of LayoutManager and setup channel connections here using layoutmanager instance methods?
             await __classPrivateFieldGet(this, _LayoutModule_layoutManager, "f").initManager();
             await __classPrivateFieldGet(this, _LayoutModule_layoutManager, "f").createLayout(layout, container);
+            const { client, ofWindow } = ManagerConstructor.getClientAndWindow(__classPrivateFieldGet(this, _LayoutModule_layoutManager, "f"));
+            // expose LayoutEntitiesController instance for API consumption
+            const channelStrategy = new api_exposer_1.ChannelsExposer(client);
+            await new api_exposer_1.ApiExposer(channelStrategy).exposeInstance(new layout_entities_controller_1.LayoutEntitiesController(__classPrivateFieldGet(this, _LayoutModule_layoutManager, "f"), ofWindow.identity.uuid, contentItemCache), { id: layout_constants_1.LAYOUT_CONTROLLER_ID });
             // Adding this to the returned instance undocumented/typed for Browser.
             return Object.assign(this.getCurrentSync(), { layoutManager: __classPrivateFieldGet(this, _LayoutModule_layoutManager, "f") });
         };

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

@@ -8,6 +8,7 @@ type PresetLayoutOptions = OpenFin.PresetLayoutOptions;
  * @lends Platform#Layout
  */
 export declare class Layout extends Base {
+    #private;
     init: (options?: InitLayoutOptions) => Promise<Layout>;
     identity: Identity;
     private platform;
@@ -19,6 +20,11 @@ export declare class Layout extends Base {
      * @tutorial Layout.getConfig
      */
     getConfig(): Promise<any>;
+    /**
+     * Retrieves the top level content item of the layout.
+     * @return {Promise<TabStack | ColumnOrRow>}
+     */
+    getRootItem(): Promise<OpenFin.ColumnOrRow | OpenFin.TabStack>;
     /**
      * 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.

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

@@ -1,9 +1,18 @@
 "use strict";
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _Layout_layoutClient;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Layout = void 0;
+const lazy_1 = require("../../../util/lazy");
 const validate_1 = require("../../../util/validate");
-const common_utils_1 = require("../common-utils");
 const base_1 = require("../../base");
+const common_utils_1 = require("../common-utils");
+const layout_entities_1 = require("./entities/layout-entities");
+const layout_constants_1 = require("./layout.constants");
 /**
  * @lends Platform#Layout
  */
@@ -11,6 +20,12 @@ class Layout extends base_1.Base {
     // eslint-disable-next-line no-shadow
     constructor(identity, wire) {
         super(wire);
+        /**
+         * @internal
+         * Lazily constructed {@link LayoutEntitiesClient} bound to this platform's client and identity
+         * The client is for {@link LayoutEntitiesController}
+         */
+        _Layout_layoutClient.set(this, new lazy_1.Lazy(async () => layout_entities_1.LayoutNode.newLayoutEntitiesClient(await this.platform.getClient(), layout_constants_1.LAYOUT_CONTROLLER_ID, this.identity)));
         /**
          * 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.
@@ -94,5 +109,15 @@ class Layout extends base_1.Base {
             target: this.identity
         });
     }
+    /**
+     * Retrieves the top level content item of the layout.
+     * @return {Promise<TabStack | ColumnOrRow>}
+     */
+    async getRootItem() {
+        const client = await __classPrivateFieldGet(this, _Layout_layoutClient, "f").getValue();
+        const root = await client.getRoot();
+        return layout_entities_1.LayoutNode.getEntity(root, client);
+    }
 }
 exports.Layout = Layout;
+_Layout_layoutClient = new WeakMap();

package/src/api/platform/layout/controllers/layout-content-cache.d.ts

@@ -0,0 +1,9 @@
+export declare class LayoutContentCache {
+    private contentItemCache;
+    private contentItemCacheId;
+    private createCacheKey;
+    hasKey: (id: string) => boolean;
+    getItemOrUndefined: (id: string) => GoldenLayout.ContentItem | undefined;
+    getContentItemOrThrow: (id: string, expectedType?: string[]) => GoldenLayout.ContentItem;
+    getOrCreateEntityId: (contentItem: GoldenLayout.ContentItem) => string;
+}

package/src/api/platform/layout/controllers/layout-content-cache.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LayoutContentCache = void 0;
+const reversible_map_1 = require("../../../../util/reversible-map");
+class LayoutContentCache {
+    constructor() {
+        // ContentItems currently do not have a unique id, this helps us to lookup items by value
+        this.contentItemCache = new reversible_map_1.ReversibleMap();
+        this.contentItemCacheId = 0;
+        this.createCacheKey = () => {
+            const key = `entity-${this.contentItemCacheId.toString()}`;
+            this.contentItemCacheId += 1;
+            return key;
+        };
+        this.hasKey = (id) => {
+            return this.contentItemCache.hasKey(id);
+        };
+        this.getItemOrUndefined = (id) => {
+            try {
+                return this.getContentItemOrThrow(id);
+            }
+            catch (error) {
+                return undefined;
+            }
+        };
+        this.getContentItemOrThrow = (id, expectedType) => {
+            if (!this.contentItemCache.hasKey(id)) {
+                throw new Error('Layout component has been destroyed or detached from the current layout.');
+            }
+            const contentItem = this.contentItemCache.getValue(id);
+            if (expectedType && !expectedType.includes(contentItem.type)) {
+                throw new Error(`Layout item is not the expected type. Expected ${expectedType.join(', ')}, got ${contentItem.type}.`);
+            }
+            return contentItem;
+        };
+        this.getOrCreateEntityId = (contentItem) => {
+            if (this.contentItemCache.hasValue(contentItem)) {
+                return this.contentItemCache.getKey(contentItem);
+            }
+            // eslint-disable-next-line @typescript-eslint/no-unused-vars
+            const onItemDestroyed = ({ origin, ...rest }) => {
+                if (origin === contentItem) {
+                    this.contentItemCache.deleteValue(contentItem);
+                    contentItem.unbind('itemDestroyed', onItemDestroyed);
+                }
+            };
+            contentItem.on('itemDestroyed', onItemDestroyed);
+            const key = this.createCacheKey();
+            this.contentItemCache.setUnique(key, contentItem);
+            return key;
+        };
+    }
+}
+exports.LayoutContentCache = LayoutContentCache;

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

@@ -0,0 +1,116 @@
+import type * as OpenFin from '../../../../OpenFin';
+import type { LayoutContentCache } from './layout-content-cache';
+type ViewCreationOrReference = OpenFin.Identity | OpenFin.PlatformViewCreationOptions;
+/**
+ * @internal
+ * Controller for the layout entities apis, allowing alterations to be applied
+ * to an instance of layout manager in a structured manner.
+ */
+export declare class LayoutEntitiesController {
+    private layoutManager;
+    private uuid;
+    private layoutContentCache;
+    constructor(layoutManager: any, uuid: string, layoutContentCache: LayoutContentCache);
+    /**
+     * @internal
+     * @returns the root contentItem of the layout.
+     */
+    getRoot: () => OpenFin.LayoutEntityDefinition;
+    /**
+     * @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.
+     */
+    getStackByView: (view: OpenFin.Identity) => Promise<OpenFin.LayoutEntityDefinition | undefined>;
+    /**
+     * @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.
+     */
+    getStackViews: (id: string) => OpenFin.Identity[];
+    /**
+     * @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: string): OpenFin.LayoutEntityDefinition[];
+    /**
+     * @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: string): OpenFin.LayoutEntityDefinition | undefined;
+    /**
+     * @internal
+     * @param id Entity id associated with a layout content item.
+     * @returns true if the given entity is the root content item, false otherwise.
+     */
+    isRoot: (id: string) => boolean;
+    /**
+     * @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.
+     */
+    exists: (entityId: string) => boolean;
+    /**
+     * @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.
+     */
+    addViewToStack: (stackEntityId: string, viewCreationOrReference: ViewCreationOrReference, { index }?: OpenFin.AddViewToStackOptions) => Promise<OpenFin.Identity>;
+    /**
+     * @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.
+     */
+    removeViewFromStack: (stackEntityId: string, view: OpenFin.Identity) => Promise<void>;
+    /**
+     * @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
+     */
+    createAdjacentStack: (targetId: string, views: ViewCreationOrReference[], options: {
+        position?: OpenFin.LayoutPosition;
+    }) => Promise<string>;
+    getAdjacentStacks: ({ targetId, edge }: {
+        targetId: string;
+        edge: OpenFin.LayoutPosition;
+    }) => Promise<Pick<OpenFin.LayoutEntityDefinition, 'entityId'>[]>;
+}
+export {};

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

@@ -0,0 +1,256 @@
+"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, uuid, layoutContentCache) {
+        this.layoutManager = layoutManager;
+        this.uuid = uuid;
+        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.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;
+        };
+        /**
+         * @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 views = this.getStackViews(stackEntityId);
+            if (!views.find((existingView) => existingView.name === view.name)) {
+                throw new Error(`Tried to remove a view ('${view.name}') which does not exist in the stack.`);
+            }
+            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),
+            }));
+        };
+    }
+    /**
+     * @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);
+exports.LayoutEntitiesController = LayoutEntitiesController;