@openfin/core 31.74.21 → 31.74.23

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

@@ -1,8 +1,8 @@
 import type * as OpenFin from '../../OpenFin';
 import { Base } from '../base';
-import { Channel } from '../interappbus/channel/index';
 import { Transport } from '../../transport/transport';
 import { LayoutModule } from './layout/index';
+type Channel = OpenFin.Fin['InterApplicationBus']['Channel'];
 /**
  * @PORTED
  * InitPlatformOptions interface
@@ -113,3 +113,4 @@ export default class PlatformModule extends Base {
      */
     startFromManifest(manifestUrl: string, opts?: OpenFin.RvmLaunchOptions): Promise<OpenFin.Platform>;
 }
+export {};

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

@@ -1,9 +1,9 @@
 import type * as OpenFin from '../../OpenFin';
-import { View } from '../view';
 import { EmitterBase } from '../base';
-import { Channel } from '../interappbus/channel/index';
-import ChannelClient from '../interappbus/channel/client';
-import { LayoutModule } from './layout';
+type View = OpenFin.View;
+type Channel = OpenFin.Fin['InterApplicationBus']['Channel'];
+type ChannelClient = OpenFin.ChannelClient;
+type LayoutModule = OpenFin.Fin['Platform']['Layout'];
 /** Manages the life cycle of windows and views in the application.
  *
  * Enables taking snapshots of itself and applyi
@@ -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
@@ -147,3 +147,4 @@ export declare class Platform extends EmitterBase<OpenFin.PlatformEvent> {
         skipBeforeUnload: boolean;
     }): Promise<void>;
 }
+export {};

package/src/api/platform/Instance.js

@@ -7,6 +7,7 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
 var _Platform_connectToProvider;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Platform = void 0;
+/* eslint-disable import/prefer-default-export, no-undef */
 const base_1 = require("../base");
 const validate_1 = require("../../util/validate");
 // Reuse clients to avoid overwriting already-registered client in provider

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 */
@@ -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
@@ -87,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`.
@@ -105,15 +110,17 @@ 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);
             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 +135,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"), 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") });
         };
@@ -194,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/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,18 @@ class Layout extends base_1.Base {
             target: this.identity
         });
     }
+    /**
+     * Retrieves the top level content item of the layout.
+     * @return {Promise<TabStack | ColumnOrRow>}
+     */
+    async getRootItem() {
+        this.wire.sendAction('layout-get-root-item').catch(() => {
+            // don't expose
+        });
+        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,119 @@
+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 layoutContentCache;
+    private wire;
+    constructor(layoutManager: any, layoutContentCache: LayoutContentCache);
+    private analytics;
+    /**
+     * @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>;
+    private findViewInStack;
+    /**
+     * @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[], { position }?: {
+        position?: OpenFin.LayoutPosition;
+    }) => Promise<string>;
+    getAdjacentStacks: ({ targetId, edge }: {
+        targetId: string;
+        edge: OpenFin.LayoutPosition;
+    }) => Promise<Pick<OpenFin.LayoutEntityDefinition, 'entityId'>[]>;
+    setStackActiveView: (stackEntityId: string, viewIdentity: OpenFin.Identity) => Promise<void>;
+}
+export {};