@openfin/core 25.68.26

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

@@ -0,0 +1,48 @@
+import Transport from '../../../transport/transport';
+import { InitLayoutOptions, PresetLayoutOptions } from './shapes';
+import { Base } from '../../base';
+import Identity = OpenFin.Identity;
+/**
+ * @lends Platform#Layout
+ */
+export declare class Layout extends Base {
+    init: (options?: InitLayoutOptions) => Promise<Layout>;
+    identity: Identity;
+    private platform;
+    wire: Transport;
+    constructor(identity: OpenFin.Identity, wire: Transport);
+    /**
+     * Returns the configuration of the window's layout.  Returns the same information that is returned for all windows in getSnapshot.
+     * @return { Promise<LayoutConfig> }
+     * @tutorial Layout.getConfig
+     */
+    getConfig(): Promise<any>;
+    /**
+     * Replaces a Platform window's layout with a new layout.  Any views that were in the old layout but not the new layout
+     * will be destroyed.
+     * @param { LayoutConfig } layout New layout to implement in the target window.
+     * Please see explanation of a layout {@link https://developers.openfin.co/docs/platform-api#section-layout here}.
+     * @return { Promise<void> }
+     * @tutorial Layout.replace
+     */
+    replace: (layout: any) => Promise<void>;
+    /**
+     * Replaces the specified view with a view with the provided configuration.
+     * The old view is stripped of its listeners and either closed or attached to the provider window
+     * depending on `detachOnClose` view option.
+     * @param { Identity } viewToReplace Identity of the view to be replaced
+     * @param { View~options } newView Creation options of the new view.
+     * @return { Promise<void> }
+     * @tutorial Layout.replaceView
+     */
+    replaceView: (viewToReplace: Identity, newView: OpenFin.PlatformViewCreationOptions) => Promise<void>;
+    /**
+     * Replaces a Platform window's layout with a preset layout arrangement using the existing Views attached to the window.
+     * The preset options are `columns`, `grid`, `rows`, and `tabs`.
+     * @param { PresetLayoutOptions } options Mandatory object with `presetType` property that sets which preset layout arrangement to use.
+     * The preset options are `columns`, `grid`, `rows`, and `tabs`.
+     * @return { Promise<void> }
+     * @tutorial Layout.applyPreset
+     */
+    applyPreset: (options: PresetLayoutOptions) => Promise<void>;
+}

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

@@ -0,0 +1,99 @@
+"use strict";
+/* eslint-disable no-undef, import/prefer-default-export */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Layout = void 0;
+const validate_1 = require("../../../util/validate");
+const common_utils_1 = require("../common-utils");
+const base_1 = require("../../base");
+/**
+ * @lends Platform#Layout
+ */
+class Layout extends base_1.Base {
+    // eslint-disable-next-line no-shadow
+    constructor(identity, wire) {
+        super(wire);
+        /**
+         * Replaces a Platform window's layout with a new layout.  Any views that were in the old layout but not the new layout
+         * will be destroyed.
+         * @param { LayoutConfig } layout New layout to implement in the target window.
+         * Please see explanation of a layout {@link https://developers.openfin.co/docs/platform-api#section-layout here}.
+         * @return { Promise<void> }
+         * @tutorial Layout.replace
+         */
+        this.replace = async (layout) => {
+            this.wire.sendAction('layout-replace').catch((e) => {
+                // don't expose
+            });
+            const client = await this.platform.getClient();
+            await client.dispatch('replace-layout', {
+                target: this.identity,
+                opts: { layout }
+            });
+        };
+        /**
+         * Replaces the specified view with a view with the provided configuration.
+         * The old view is stripped of its listeners and either closed or attached to the provider window
+         * depending on `detachOnClose` view option.
+         * @param { Identity } viewToReplace Identity of the view to be replaced
+         * @param { View~options } newView Creation options of the new view.
+         * @return { Promise<void> }
+         * @tutorial Layout.replaceView
+         */
+        this.replaceView = async (viewToReplace, newView) => {
+            this.wire.sendAction('layout-replace-view').catch((e) => {
+                // don't expose
+            });
+            const client = await this.platform.getClient();
+            await client.dispatch('replace-view', {
+                target: this.identity,
+                opts: { viewToReplace, newView }
+            });
+        };
+        /**
+         * Replaces a Platform window's layout with a preset layout arrangement using the existing Views attached to the window.
+         * The preset options are `columns`, `grid`, `rows`, and `tabs`.
+         * @param { PresetLayoutOptions } options Mandatory object with `presetType` property that sets which preset layout arrangement to use.
+         * The preset options are `columns`, `grid`, `rows`, and `tabs`.
+         * @return { Promise<void> }
+         * @tutorial Layout.applyPreset
+         */
+        this.applyPreset = async (options) => {
+            this.wire.sendAction('layout-apply-preset').catch((e) => {
+                // don't expose
+            });
+            const client = await this.platform.getClient();
+            const { presetType } = options;
+            if (!presetType || !common_utils_1.isValidPresetType(presetType)) {
+                throw new Error('Cannot apply preset layout, please include an applicable presetType property in the PresetLayoutOptions.');
+            }
+            await client.dispatch('apply-preset-layout', {
+                target: this.identity,
+                opts: { presetType }
+            });
+        };
+        const errorMsg = validate_1.validateIdentity(identity);
+        if (errorMsg) {
+            throw new Error(errorMsg);
+        }
+        this.identity = identity;
+        this.platform = this.fin.Platform.wrapSync({ uuid: identity.uuid });
+        if (identity.uuid === this.fin.me.uuid && identity.name === this.fin.me.name) {
+            this.init = this.fin.Platform.Layout.init;
+        }
+    }
+    /**
+     * Returns the configuration of the window's layout.  Returns the same information that is returned for all windows in getSnapshot.
+     * @return { Promise<LayoutConfig> }
+     * @tutorial Layout.getConfig
+     */
+    async getConfig() {
+        this.wire.sendAction('layout-get-config').catch((e) => {
+            // don't expose
+        });
+        const client = await this.platform.getClient();
+        return client.dispatch('get-frame-snapshot', {
+            target: this.identity
+        });
+    }
+}
+exports.Layout = Layout;

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

@@ -0,0 +1,3 @@
+export * from './Factory';
+export * from './Instance';
+export * from './shapes';

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

@@ -0,0 +1,15 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !exports.hasOwnProperty(p)) __createBinding(exports, m, p);
+}
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./Factory"), exports);
+__exportStar(require("./Instance"), exports);
+__exportStar(require("./shapes"), exports);

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

@@ -0,0 +1,11 @@
+import { LayoutPresetType } from '../../../shapes/LayoutPresetType';
+export interface InitLayoutOptions {
+    containerId?: string;
+}
+export interface PresetLayoutOptions {
+    presetType: LayoutPresetType;
+}
+export interface DragPayload {
+    'view-config': OpenFin.ViewCreationOptions;
+    'view-identity': [string, string, string];
+}

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

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

package/src/api/snapshot-source/Factory.d.ts

@@ -0,0 +1,36 @@
+import { Base } from '../base';
+import { SnapshotSource } from './Instance';
+/**
+ * @typedef { object } SnapshotProvider
+ * @property {getSnapshot} [getSnapshot]
+ * @property {applySnapshot} [applySnapshot]
+ */
+/**
+ * @lends SnapshotSource
+ */
+export default class SnapshotSourceModule extends Base {
+    /**
+     * Initializes a SnapshotSource with the getSnapshot and applySnapshot methods defined.
+     * @param { SnapshotProvider } provider
+     * @return { Promise<void> }
+     * @tutorial SnapshotSource.init
+     * @static
+     */
+    init<T = any>(provider: OpenFin.SnapshotProvider<T>): Promise<void>;
+    /**
+     * Synchronously returns a SnapshotSource object that represents the current SnapshotSource.
+     * @param { Identity } identity
+     * @return { SnapshotSource }
+     * @tutorial SnapshotSource.wrapSync
+     * @static
+     */
+    wrapSync(identity: OpenFin.ApplicationIdentity): SnapshotSource;
+    /**
+     * Asynchronously returns a SnapshotSource object that represents the current SnapshotSource.
+     * @param { Identity } identity
+     * @return { Promise.<SnapshotSource> }
+     * @tutorial SnapshotSource.wrap
+     * @static
+     */
+    wrap(identity: OpenFin.ApplicationIdentity): Promise<SnapshotSource>;
+}

package/src/api/snapshot-source/Factory.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const base_1 = require("../base");
+const Instance_1 = require("./Instance");
+const utils_1 = require("./utils");
+/**
+ * @typedef { object } SnapshotProvider
+ * @property {getSnapshot} [getSnapshot]
+ * @property {applySnapshot} [applySnapshot]
+ */
+/**
+ * @lends SnapshotSource
+ */
+class SnapshotSourceModule extends base_1.Base {
+    /**
+     * Initializes a SnapshotSource with the getSnapshot and applySnapshot methods defined.
+     * @param { SnapshotProvider } provider
+     * @return { Promise<void> }
+     * @tutorial SnapshotSource.init
+     * @static
+     */
+    async init(provider) {
+        this.wire.sendAction('snapshot-source-init').catch((e) => {
+            // don't expose, analytics-only call
+        });
+        if (typeof provider !== 'object' ||
+            typeof provider.getSnapshot !== 'function' ||
+            typeof provider.applySnapshot !== 'function') {
+            throw new Error('you must pass in a valid SnapshotProvider');
+        }
+        const channel = await this.fin.InterApplicationBus.Channel.create(utils_1.getSnapshotSourceChannelName(fin.me.identity));
+        channel.register('get-snapshot', async () => {
+            const snapshot = await provider.getSnapshot();
+            return { snapshot };
+        });
+        channel.register('apply-snapshot', ({ snapshot }) => provider.applySnapshot(snapshot));
+    }
+    /**
+     * Synchronously returns a SnapshotSource object that represents the current SnapshotSource.
+     * @param { Identity } identity
+     * @return { SnapshotSource }
+     * @tutorial SnapshotSource.wrapSync
+     * @static
+     */
+    wrapSync(identity) {
+        this.wire.sendAction('snapshot-source-wrap-sync').catch((e) => {
+            // don't expose, analytics-only call
+        });
+        return new Instance_1.SnapshotSource(this.wire, identity);
+    }
+    /**
+     * Asynchronously returns a SnapshotSource object that represents the current SnapshotSource.
+     * @param { Identity } identity
+     * @return { Promise.<SnapshotSource> }
+     * @tutorial SnapshotSource.wrap
+     * @static
+     */
+    async wrap(identity) {
+        this.wire.sendAction('snapshot-source-wrap').catch((e) => {
+            // don't expose, analytics-only call
+        });
+        return this.wrapSync(identity);
+    }
+}
+exports.default = SnapshotSourceModule;

package/src/api/snapshot-source/Instance.d.ts

@@ -0,0 +1,30 @@
+import { Base } from '../base';
+import Transport from '../../transport/transport';
+/**
+ * Enables configuring a SnapshotSource with custom getSnapshot and applySnapshot methods.
+ * @namespace
+ */
+export declare class SnapshotSource<T = any> extends Base {
+    #private;
+    constructor(wire: Transport, id: OpenFin.ApplicationIdentity);
+    get identity(): OpenFin.ApplicationIdentity;
+    /**
+     * Method to determine if the SnapshotSource has been initialized.
+     *
+     * Use when the parent application is starting up to ensure the SnapshotSource is able to accept and
+     * apply a snapshot using the {@link SnapshotSource#applySnapshot applySnapshot} method.
+     * @return { Promise<void> }
+     * @tutorial SnapshotSource.ready
+     */
+    ready(): Promise<void>;
+    /**
+     * Call the SnapshotSource's getSnapshot method defined by {@link SnapshotSource#init init}.
+     * @return { Promise<any> }
+     */
+    getSnapshot(): Promise<T>;
+    /**
+     * Call the SnapshotSource's applySnapshot method defined by {@link SnapshotSource#init init}.
+     * @return { Promise<void> }
+     */
+    applySnapshot(snapshot: T): Promise<void>;
+}

package/src/api/snapshot-source/Instance.js

@@ -0,0 +1,134 @@
+"use strict";
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, privateMap, value) {
+    if (!privateMap.has(receiver)) {
+        throw new TypeError("attempted to set private field on non-instance");
+    }
+    privateMap.set(receiver, value);
+    return value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, privateMap) {
+    if (!privateMap.has(receiver)) {
+        throw new TypeError("attempted to get private field on non-instance");
+    }
+    return privateMap.get(receiver);
+};
+var _identity, _getConnection, _getClient, _startConnection, _setUpConnectionListener;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SnapshotSource = void 0;
+/* eslint-disable @typescript-eslint/no-non-null-assertion */
+const base_1 = require("../base");
+const utils_1 = require("./utils");
+const connectionMap = new Map();
+/**
+ * Enables configuring a SnapshotSource with custom getSnapshot and applySnapshot methods.
+ * @namespace
+ */
+class SnapshotSource extends base_1.Base {
+    constructor(wire, id) {
+        super(wire);
+        _identity.set(this, void 0);
+        _getConnection.set(this, () => {
+            if (!connectionMap.has(this.identity.uuid)) {
+                connectionMap.set(this.identity.uuid, { eventFired: null, clientPromise: null });
+            }
+            return connectionMap.get(this.identity.uuid);
+        });
+        _getClient.set(this, () => {
+            if (!__classPrivateFieldGet(this, _getConnection).call(this).clientPromise) {
+                __classPrivateFieldGet(this, _getConnection).call(this).clientPromise = __classPrivateFieldGet(this, _startConnection).call(this);
+            }
+            return __classPrivateFieldGet(this, _getConnection).call(this).clientPromise;
+        });
+        _startConnection.set(this, async () => {
+            const channelName = utils_1.getSnapshotSourceChannelName(this.identity);
+            try {
+                if (!__classPrivateFieldGet(this, _getConnection).call(this).eventFired) {
+                    await __classPrivateFieldGet(this, _setUpConnectionListener).call(this);
+                }
+                const client = await this.fin.InterApplicationBus.Channel.connect(channelName, { wait: false });
+                client.onDisconnection(() => {
+                    __classPrivateFieldGet(this, _getConnection).call(this).clientPromise = null;
+                    __classPrivateFieldGet(this, _getConnection).call(this).eventFired = null;
+                });
+                return client;
+            }
+            catch (e) {
+                __classPrivateFieldGet(this, _getConnection).call(this).clientPromise = null;
+                throw new Error("The targeted SnapshotSource is not currently initialized. Await this object's ready() method.");
+            }
+        });
+        _setUpConnectionListener.set(this, async () => {
+            const channelName = utils_1.getSnapshotSourceChannelName(this.identity);
+            let resolve;
+            let reject;
+            const eventFired = new Promise((y, n) => {
+                resolve = y;
+                reject = n;
+            });
+            __classPrivateFieldGet(this, _getConnection).call(this).eventFired = eventFired;
+            const listener = async (e) => {
+                try {
+                    if (e.channelName === channelName) {
+                        resolve();
+                        await this.fin.InterApplicationBus.Channel.removeListener('connected', listener);
+                    }
+                }
+                catch (err) {
+                    reject(err);
+                }
+            };
+            await this.fin.InterApplicationBus.Channel.on('connected', listener);
+        });
+        __classPrivateFieldSet(this, _identity, id);
+    }
+    get identity() {
+        return __classPrivateFieldGet(this, _identity);
+    }
+    /**
+     * Method to determine if the SnapshotSource has been initialized.
+     *
+     * Use when the parent application is starting up to ensure the SnapshotSource is able to accept and
+     * apply a snapshot using the {@link SnapshotSource#applySnapshot applySnapshot} method.
+     * @return { Promise<void> }
+     * @tutorial SnapshotSource.ready
+     */
+    async ready() {
+        this.wire.sendAction('snapshot-source-ready').catch((e) => {
+            // don't expose, analytics-only call
+        });
+        // eslint-disable-next-line no-async-promise-executor
+        try {
+            // If getClient was already called before this, do we have a timing issue where the channel might have been created but we missed the event but this still fails?
+            await __classPrivateFieldGet(this, _getClient).call(this);
+        }
+        catch (e) {
+            // it was not running.
+            await __classPrivateFieldGet(this, _getConnection).call(this).eventFired;
+        }
+    }
+    /**
+     * Call the SnapshotSource's getSnapshot method defined by {@link SnapshotSource#init init}.
+     * @return { Promise<any> }
+     */
+    async getSnapshot() {
+        this.wire.sendAction('snapshot-source-get-snapshot').catch((e) => {
+            // don't expose, analytics-only call
+        });
+        const client = await __classPrivateFieldGet(this, _getClient).call(this);
+        const response = (await client.dispatch('get-snapshot'));
+        return (await response).snapshot;
+    }
+    /**
+     * Call the SnapshotSource's applySnapshot method defined by {@link SnapshotSource#init init}.
+     * @return { Promise<void> }
+     */
+    async applySnapshot(snapshot) {
+        this.wire.sendAction('snapshot-source-apply-snapshot').catch((e) => {
+            // don't expose, analytics-only call
+        });
+        const client = await __classPrivateFieldGet(this, _getClient).call(this);
+        return client.dispatch('apply-snapshot', { snapshot });
+    }
+}
+exports.SnapshotSource = SnapshotSource;
+_identity = new WeakMap(), _getConnection = new WeakMap(), _getClient = new WeakMap(), _startConnection = new WeakMap(), _setUpConnectionListener = new WeakMap();

package/src/api/snapshot-source/index.d.ts

@@ -0,0 +1,3 @@
+import SnapshotModule from './Factory';
+export default SnapshotModule;
+export * from './Instance';

package/src/api/snapshot-source/index.js

@@ -0,0 +1,15 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !exports.hasOwnProperty(p)) __createBinding(exports, m, p);
+}
+Object.defineProperty(exports, "__esModule", { value: true });
+const Factory_1 = require("./Factory");
+exports.default = Factory_1.default;
+__exportStar(require("./Instance"), exports);

package/src/api/snapshot-source/utils.d.ts

@@ -0,0 +1 @@
+export declare const getSnapshotSourceChannelName: (id: OpenFin.ApplicationIdentity) => string;

package/src/api/snapshot-source/utils.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getSnapshotSourceChannelName = void 0;
+const channelPrefix = 'snapshot-source-provider-';
+exports.getSnapshotSourceChannelName = (id) => `${channelPrefix}${id.uuid}`;

package/src/api/system/application.d.ts

@@ -0,0 +1,6 @@
+export interface ApplicationInfo {
+    isPlatform: boolean;
+    isRunning: boolean;
+    uuid: string;
+    parentUuid?: string;
+}

package/src/api/system/application.js

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

package/src/api/system/entity.d.ts

@@ -0,0 +1,11 @@
+import Identity = OpenFin.Identity;
+export interface Entity {
+    type: string;
+    uuid: string;
+}
+export interface EntityInfo {
+    name: string;
+    uuid: string;
+    parent: Identity;
+    entityType: string;
+}

package/src/api/system/entity.js

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