@openfin/core 31.74.21 → 31.74.23

package/package.json

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

package/src/OpenFin.d.ts

@@ -1,21 +1,23 @@
-import type { Application } from './api/application';
+import type { Application } from './api/application/index';
 import { AppVersionEvent } from './api/events/system';
 import { TypedEventEmitter } from './api/events/typedEventEmitter';
-import type { ExternalApplication } from './api/external-application';
+import type { ExternalApplication } from './api/external-application/index';
 import { FinApi } from './api/fin';
-import type { _Frame } from './api/frame';
+import type { _Frame } from './api/frame/index';
 import type ChannelClient from './api/interappbus/channel/client';
-import { MessagingProtocols } from './api/interappbus/channel/protocols';
+import { MessagingProtocols } from './api/interappbus/channel/protocols/index';
 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 { InteropBroker, InteropClient } from './api/interop/index';
+import type { Platform } from './api/platform/index';
+import type { Layout } from './api/platform/layout/index';
 import { PlatformProvider } from './api/platform/provider';
-import { SnapshotSource } from './api/snapshot-source';
-import type { View } from './api/view';
-import { _Window } from './api/window';
+import { SnapshotSource } from './api/snapshot-source/index';
+import type { View } from './api/view/index';
+import { _Window } from './api/window/index';
+import { ColumnOrRow, TabStack } from './api/platform/layout/entities/layout-entities';
 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 = {
@@ -244,7 +246,7 @@ export type DisplayMetadata = {
      */
     readonly glyph?: string;
 };
-export type LegacyWinOptionsInAppOptions = Pick<WindowCreationOptions, 'accelerator' | 'alwaysOnTop' | 'api' | 'aspectRatio' | 'autoplayPolicy' | 'autoShow' | 'backgroundColor' | 'contentNavigation' | 'contextMenu' | 'cornerRounding' | 'customData' | 'customRequestHeaders' | 'defaultCentered' | 'defaultHeight' | 'defaultLeft' | 'defaultTop' | 'defaultWidth' | 'frame' | 'hideOnClose' | 'icon' | 'maxHeight' | 'maximizable' | 'maxWidth' | 'minHeight' | 'minimizable' | 'minWidth' | 'opacity' | 'preloadScripts' | 'resizable' | 'resizeRegion' | 'saveWindowState' | 'ignoreSavedWindowState' | 'shadow' | 'showTaskbarIcon' | 'smallWindow' | 'state' | 'taskbarIconGroup' | 'waitForPageLoad'>;
+export type LegacyWinOptionsInAppOptions = Pick<WindowCreationOptions, 'accelerator' | 'alwaysOnTop' | 'api' | 'aspectRatio' | 'autoplayPolicy' | 'autoShow' | 'backgroundColor' | 'contentNavigation' | 'contextMenu' | 'cornerRounding' | 'customData' | 'customRequestHeaders' | 'defaultCentered' | 'defaultHeight' | 'defaultLeft' | 'defaultTop' | 'defaultWidth' | 'frame' | 'hideOnClose' | 'icon' | 'maxHeight' | 'maximizable' | 'maxWidth' | 'minHeight' | 'minimizable' | 'minWidth' | 'opacity' | 'preloadScripts' | 'resizable' | 'resizeRegion' | 'saveWindowState' | 'ignoreSavedWindowState' | 'shadow' | 'showTaskbarIcon' | 'smallWindow' | 'state' | 'taskbarIconGroup' | 'waitForPageLoad' | '_internalWorkspaceData'>;
 export type Snapshot = {
     windows: WindowCreationOptions[];
     snapshotDetails?: {
@@ -792,6 +794,11 @@ export type MutableWindowOptions = {
      */
     showTaskbarIcon: boolean;
     interop: InteropConfig;
+    /**
+     * @internal
+     * Used by Workspace to store custom data. Overwriting or modifying this field may impact the functionality of Workspace
+     */
+    _internalWorkspaceData: any;
     workspacePlatform: WorkspacePlatformOptions;
 };
 export type WorkspacePlatformOptions = {
@@ -1191,6 +1198,11 @@ export type MutableViewOptions = {
      */
     preventDragOut: boolean;
     interop?: InteropConfig;
+    /**
+     * @internal
+     * Used by Workspace to store custom data. Overwriting or modifying this field may impact the functionality of Workspace
+     */
+    _internalWorkspaceData: any;
 };
 /**
  * User-facing options for a view.
@@ -1330,6 +1342,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 +1366,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 = {
@@ -1460,10 +1488,7 @@ export type PlatformWindowOptions = WindowCreationOptions & {
      */
     stylesheetUrl: string;
 };
-export type PlatformViewCreationOptions = Partial<ViewOptions> & {
-    url: string;
-    target: Identity;
-};
+export type PlatformViewCreationOptions = Partial<ViewOptions>;
 /**
  * Strategy to assign views to process affinity by domain.
  *
@@ -1898,6 +1923,7 @@ export type Margins = {
  * Options for printing a webpage in OpenFin.
  */
 export type PrintOptions = {
+    content?: 'self';
     /**
      * Disables prompting the user for print settings.
      */
@@ -1941,7 +1967,7 @@ export type PrintOptions = {
     /**
      * Page range to print.
      */
-    pageRanges?: Record<'from' | 'to', number>;
+    pageRanges?: Array<Record<'from' | 'to', number>>;
     /**
      * Duplex mode of the printed webpage.
      */
@@ -1951,6 +1977,14 @@ export type PrintOptions = {
      */
     dpi?: Dpi;
 };
+export type ScreenshotPrintOptions = {
+    content: 'screenshot';
+};
+export type WindowViewsPrintOptions = {
+    content: 'views';
+    includeSelf?: boolean;
+};
+export type WindowPrintOptions = PrintOptions | ScreenshotPrintOptions | WindowViewsPrintOptions;
 /**
  * A request to write data to the clipboard.
  */
@@ -2218,6 +2252,7 @@ export type FindInPageResult = {
 export type FrameInfo = {
     name: string;
     uuid: string;
+    url: string;
     entityType: EntityType;
     parent: Identity;
 };
@@ -2894,6 +2929,9 @@ export interface PopupResult<T = any> {
     data?: T;
     lastDispatchResult?: PopupResult;
 }
+export type SystemShutdownHandler = (shutdownEvent: {
+    proceed: () => void;
+}) => void;
 export type AppVersionProgressEvent = {
     type: 'app-version-progress';
 } & AppVersionProgress;
@@ -2956,3 +2994,24 @@ export interface InteropActionLoggingOption {
 export type InteropLoggingActions = 'beforeAction' | 'afterAction';
 export type InteropLoggingOptions = Record<InteropLoggingActions, InteropActionLoggingOption>;
 export type { Me } from './api/me';
+/**
+ * Configuration for page capture.
+ */
+export interface CapturePageOptions {
+    /**
+     * The area of the window to be captured.
+     */
+    area?: Rectangle;
+    /**
+     * @defaultValue 'png'
+     *
+     * The format of the captured image.  Can be 'png', 'jpg', or 'bmp'.
+     */
+    format?: 'bmp' | 'jpg' | 'png';
+    /**
+     * @defaultValue 100
+     *
+     * Quality of JPEG image. Between 0 - 100.
+     */
+    quality?: number;
+}

package/src/api/api-exposer/api-consumer.d.ts

@@ -0,0 +1,28 @@
+import { ExposedProp } from "./decorators";
+export type ConsumeStrategy<TMetaConsumeOptions, TPropConsumeDefinition> = {
+    getExposedFunctions: (options: TMetaConsumeOptions) => Promise<ExposedProp<TPropConsumeDefinition>[]>;
+    createFunction: (options: ExposedProp<TPropConsumeDefinition>, meta: TMetaConsumeOptions) => Function;
+};
+type PickOfType<T extends Record<any, any>, TTarget> = {
+    [key in keyof T as T[key] extends TTarget | undefined ? key : never]: T[key];
+};
+export type ApiClient<T extends Record<any, any>> = {
+    [key in keyof PickOfType<T, Function>]: (...args: Parameters<T[key]>) => ReturnType<T[key]> extends Promise<any> ? ReturnType<T[key]> : Promise<ReturnType<T[key]>>;
+};
+/**
+ * Consumer for apis exposed with {@see ApiExposer}.
+ *
+ * A strategy that matches the strategy used to expose a target API must be provided.
+ */
+export declare class ApiConsumer<TMetaConsumeOptions = any, TPropConsumptionOptions = any> {
+    private strategy;
+    constructor(strategy: ConsumeStrategy<TMetaConsumeOptions, TPropConsumptionOptions>);
+    /**
+     * Consumes an api exposed using a given transport strategy, and generates a client
+     * for easy, type safe consumption of that client.
+     * @param options Strategy specific consumption options.
+     * @returns An api client matching the given type.
+     */
+    consume: <T extends Record<any, any>>(options: TMetaConsumeOptions) => Promise<ApiClient<T>>;
+}
+export {};

package/src/api/api-exposer/api-consumer.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ApiConsumer = void 0;
+/**
+ * Consumer for apis exposed with {@see ApiExposer}.
+ *
+ * A strategy that matches the strategy used to expose a target API must be provided.
+ */
+class ApiConsumer {
+    // eslint-disable-next-line
+    constructor(strategy) {
+        this.strategy = strategy;
+        /**
+         * Consumes an api exposed using a given transport strategy, and generates a client
+         * for easy, type safe consumption of that client.
+         * @param options Strategy specific consumption options.
+         * @returns An api client matching the given type.
+         */
+        this.consume = async (options) => {
+            const exposedProperties = await this.strategy.getExposedFunctions(options);
+            return exposedProperties.reduce((client, prop) => ({
+                ...client,
+                [prop.key]: this.strategy.createFunction(prop, options)
+            }), {});
+        };
+    }
+}
+exports.ApiConsumer = ApiConsumer;

package/src/api/api-exposer/api-exposer.d.ts

@@ -0,0 +1,35 @@
+import { ExposedProp } from './decorators';
+export type ConsumptionConfig<T> = {
+    key: string;
+    options: T;
+};
+export type ExposeStrategy<TInstanceExposeOptions, TPropExposeOptions, TPropConsumeOptions> = {
+    /**
+     * Exposes the given function on the strategy.
+     */
+    exposeFunction: (target: Function, config: {
+        key: string;
+        options: TPropExposeOptions;
+        meta: TInstanceExposeOptions;
+    }) => Promise<TPropConsumeOptions>;
+    /**
+     * Exposes metadata to enable creation of client objects.
+     */
+    exposeMeta: (instanceOptions: TInstanceExposeOptions, props: ExposedProp<TPropConsumeOptions>[]) => Promise<void>;
+};
+/**
+ * Exposes api services on the transport of choice.
+ */
+export declare class ApiExposer<TInstanceExposeOptions = any, TPropExposeOptions = any, TPropConsumptionOptions = any> {
+    private strategy;
+    /**
+     * @param strategy The expose strategy to use to expose instances.
+     */
+    constructor(strategy: ExposeStrategy<TInstanceExposeOptions, TPropExposeOptions, TPropConsumptionOptions>);
+    /**
+     * Exposes an instance of a given api on
+     * @param instance Instance of a class which has been decorated to indicate which functions can be exposed.
+     * @param instanceOptions Transport strategy specific options to use when exposing.
+     */
+    exposeInstance: (instance: Record<any, any>, instanceOptions: TInstanceExposeOptions) => Promise<void>;
+}

package/src/api/api-exposer/api-exposer.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ApiExposer = void 0;
+const decorators_1 = require("./decorators");
+/**
+ * Exposes api services on the transport of choice.
+ */
+class ApiExposer {
+    /**
+     * @param strategy The expose strategy to use to expose instances.
+     */
+    // eslint-disable-next-line
+    constructor(strategy) {
+        this.strategy = strategy;
+        /**
+         * Exposes an instance of a given api on
+         * @param instance Instance of a class which has been decorated to indicate which functions can be exposed.
+         * @param instanceOptions Transport strategy specific options to use when exposing.
+         */
+        this.exposeInstance = async (instance, instanceOptions) => {
+            const exposableProps = (0, decorators_1.getExposedProperties)(instance);
+            const exposedProps = await Promise.all(exposableProps.map(async ({ key, options }) => {
+                const customConsumptionOptions = await this.strategy.exposeFunction(instance[key].bind(instance), {
+                    key,
+                    options,
+                    meta: instanceOptions
+                });
+                return {
+                    key,
+                    options: customConsumptionOptions
+                };
+            }));
+            await this.strategy.exposeMeta(instanceOptions, exposedProps);
+        };
+    }
+    ;
+}
+exports.ApiExposer = ApiExposer;

package/src/api/api-exposer/decorators.d.ts

@@ -0,0 +1,10 @@
+export type ExposedProp<T> = {
+    key: string;
+    options: T;
+};
+export declare const getExposedProperties: <T>(target: Record<any, any>) => ExposedProp<T>[];
+/**
+ * Indicates that a class member function can be exposed using {@link ApiExposer}.
+ * @param options Options specific to the strategy used in {@link ApiExposer}
+ */
+export declare const expose: <T = undefined>(options?: T) => any;

package/src/api/api-exposer/decorators.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.expose = exports.getExposedProperties = void 0;
+const exposedProperties = Symbol('exposedProperties');
+const getExposedProperties = (target) => {
+    return target[exposedProperties] || target.prototype[exposedProperties] || [];
+};
+exports.getExposedProperties = getExposedProperties;
+/**
+ * Indicates that a class member function can be exposed using {@link ApiExposer}.
+ * @param options Options specific to the strategy used in {@link ApiExposer}
+ */
+// Returns any as decorator typing is weird.
+const expose = (options) => (target, key, descriptor) => {
+    target[exposedProperties] = target[exposedProperties] || [];
+    target[exposedProperties].push({ key, descriptor, options });
+};
+exports.expose = expose;

package/src/api/api-exposer/index.d.ts

@@ -0,0 +1,4 @@
+export * from './api-consumer';
+export * from './api-exposer';
+export * from './strategies';
+export * from './decorators';

package/src/api/api-exposer/index.js

@@ -0,0 +1,20 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (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" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./api-consumer"), exports);
+__exportStar(require("./api-exposer"), exports);
+__exportStar(require("./strategies"), exports);
+__exportStar(require("./decorators"), exports);

package/src/api/api-exposer/strategies/index.d.ts

@@ -0,0 +1 @@
+export * from './openfin-channels';

package/src/api/api-exposer/strategies/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (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" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./openfin-channels"), exports);

package/src/api/api-exposer/strategies/openfin-channels/channels-consumer.d.ts

@@ -0,0 +1,14 @@
+import { ConsumeStrategy } from "../../api-consumer";
+import { ExposedProp } from "../../decorators";
+export type ChannelConsumeOptions = {
+    id: string;
+};
+export type ChannelsPropConfig = {
+    action: string;
+};
+export declare class ChannelsConsumer implements ConsumeStrategy<ChannelConsumeOptions, ChannelsPropConfig> {
+    private channel;
+    constructor(channel: any);
+    getExposedFunctions: (options: ChannelConsumeOptions) => Promise<ExposedProp<ChannelsPropConfig>[]>;
+    createFunction: (prop: ExposedProp<ChannelsPropConfig>) => Function;
+}

package/src/api/api-exposer/strategies/openfin-channels/channels-consumer.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ChannelsConsumer = void 0;
+class ChannelsConsumer {
+    // eslint-disable-next-line
+    constructor(channel) {
+        this.channel = channel;
+        this.getExposedFunctions = async (options) => {
+            const { id } = options;
+            const { props } = await this.channel.dispatch(`api-meta:${id}`);
+            return props;
+        };
+        this.createFunction = (prop) => (...args) => {
+            const { action } = prop.options;
+            return this.channel.dispatch(action, { args });
+        };
+    }
+    ;
+}
+exports.ChannelsConsumer = ChannelsConsumer;

package/src/api/api-exposer/strategies/openfin-channels/channels-exposer.d.ts

@@ -0,0 +1,20 @@
+import { ExposeStrategy } from '../../api-exposer';
+import { ExposedProp } from '../../decorators';
+import { ChannelsPropConfig } from './channels-consumer';
+type ChannelInstanceExposeOptions = {
+    id: string;
+};
+export type ChannelsPropOptions = {
+    action?: string;
+} | undefined;
+export declare class ChannelsExposer implements ExposeStrategy<ChannelInstanceExposeOptions, ChannelsPropOptions, ChannelsPropConfig> {
+    private channelProviderOrClient;
+    constructor(channelProviderOrClient: any);
+    exposeFunction: (target: Function, config: {
+        key: string;
+        options: ChannelsPropOptions;
+        meta: ChannelInstanceExposeOptions;
+    }) => Promise<ChannelsPropConfig>;
+    exposeMeta: ({ id }: ChannelInstanceExposeOptions, props: ExposedProp<ChannelsPropOptions>[]) => Promise<void>;
+}
+export {};

package/src/api/api-exposer/strategies/openfin-channels/channels-exposer.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ChannelsExposer = void 0;
+class ChannelsExposer {
+    // eslint-disable-next-line
+    constructor(channelProviderOrClient) {
+        this.channelProviderOrClient = channelProviderOrClient;
+        this.exposeFunction = async (target, config) => {
+            const { key, options, meta } = config;
+            const { id } = meta;
+            const action = `${id}.${(options === null || options === void 0 ? void 0 : options.action) || key}`;
+            await this.channelProviderOrClient.register(action, async ({ args }) => {
+                return target(...args);
+            });
+            return { action };
+        };
+        this.exposeMeta = async ({ id }, props) => {
+            const action = `api-meta:${id}`;
+            await this.channelProviderOrClient.register(action, () => ({ props }));
+        };
+    }
+}
+exports.ChannelsExposer = ChannelsExposer;

package/src/api/api-exposer/strategies/openfin-channels/index.d.ts

@@ -0,0 +1,2 @@
+export * from './channels-consumer';
+export * from './channels-exposer';

package/src/api/api-exposer/strategies/openfin-channels/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (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" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./channels-consumer"), exports);
+__exportStar(require("./channels-exposer"), exports);

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/application/Instance.js

@@ -141,11 +141,29 @@ class Application extends base_1.EmitterBase {
      * @tutorial Application.quit
      */
     async quit(force = false) {
-        await this._close(force);
-        await this.wire.sendAction('destroy-application', { force, ...this.identity });
-    }
-    _close(force = false) {
-        return this.wire.sendAction('close-application', { force, ...this.identity }).then(() => undefined);
+        try {
+            await this._close(force);
+            await this.wire.sendAction('destroy-application', { force, ...this.identity });
+        }
+        catch (error) {
+            const acceptableErrors = [
+                'Remote connection has closed',
+                'Could not locate the requested application'
+            ];
+            if (!acceptableErrors.some(msg => error.message.includes(msg))) {
+                throw error;
+            }
+        }
+    }
+    async _close(force = false) {
+        try {
+            await this.wire.sendAction('close-application', { force, ...this.identity });
+        }
+        catch (error) {
+            if (!error.message.includes('Remote connection has closed')) {
+                throw error;
+            }
+        }
     }
     close(force = false) {
         console.warn('Deprecation Warning: Application.close is deprecated Please use Application.quit');

package/src/api/base.d.ts

@@ -2,14 +2,13 @@
 import { EventEmitter } from 'events';
 import { Transport } from '../transport/transport';
 import type * as OpenFin from '../OpenFin';
-import Fin from './fin';
 import { BaseEvent, EventHandler } from './events/base';
 type ApplicationIdentity = OpenFin.ApplicationIdentity;
 type Identity = OpenFin.Identity;
 export declare class Base {
     wire: Transport;
     constructor(wire: Transport);
-    protected get fin(): Fin;
+    protected get fin(): OpenFin.Fin<OpenFin.EntityType>;
     get me(): Identity;
     protected isNodeEnvironment: () => boolean;
     protected isOpenFinEnvironment: () => boolean;

package/src/api/base.js

@@ -14,7 +14,6 @@ var _EmitterBase_emitterAccessor;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Reply = exports.EmitterBase = exports.Base = void 0;
 const promises_1 = require("../util/promises");
-const fin_store_1 = require("../transport/fin_store");
 class Base {
     constructor(wire) {
         this.isNodeEnvironment = () => {
@@ -29,7 +28,7 @@ class Base {
         this.wire = wire;
     }
     get fin() {
-        return (0, fin_store_1.getFin)(this.wire);
+        return this.wire.getFin();
     }
     get me() {
         return this.wire.me;

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

@@ -1,6 +1,6 @@
 import type * as OpenFin from '../../OpenFin';
 import { PropagatedApplicationEvent } from './application';
-import { BaseEvent } from './base';
+import { BaseEvent, IdentityEvent } from './base';
 import { PropagatedViewEvent } from './view';
 import { PropagatedWindowEvent } from './window';
 import { AppVersionCompleteEvent, AppVersionErrorEvent, AppVersionProgressEvent, AppVersionRuntimeStatusEvent } from '../../OpenFin';
@@ -38,13 +38,16 @@ export type EventWithId<Event extends AppVersionEvent> = Event extends infer E e
     appVersionId: string;
 } : never;
 export type AppVersionEventWithId = EventWithId<AppVersionEvent>;
-export type ApplicationCreatedEvent = BaseEvent & {
+export type ApplicationCreatedEvent = IdentityEvent & {
     type: 'application-created';
 };
 export type DesktopIconClickedEvent = BaseEvent & {
     type: 'desktop-icon-clicked';
 };
+export type SystemShutdownEvent = BaseEvent & {
+    type: 'system-shutdown';
+};
 export type SystemEvent = {
     topic: 'system';
-} & (ExcludeRequested<PropagatedWindowEvent> | PropagatedViewEvent | PropagatedApplicationEvent | ApplicationCreatedEvent | DesktopIconClickedEvent | IdleEvent | MonitorEvent | SessionChangedEvent | AppVersionEventWithId);
+} & (ExcludeRequested<PropagatedWindowEvent> | PropagatedViewEvent | PropagatedApplicationEvent | ApplicationCreatedEvent | DesktopIconClickedEvent | IdleEvent | MonitorEvent | SessionChangedEvent | AppVersionEventWithId | SystemShutdownEvent);
 export type SystemEventType = SystemEvent['type'];

package/src/api/fin.js

@@ -13,13 +13,11 @@ const index_8 = require("./global-hotkey/index");
 const index_9 = require("./view/index");
 const index_10 = require("./platform/index");
 const me_1 = require("./me");
-const fin_store_1 = require("../transport/fin_store");
 const interop_1 = require("./interop");
 const snapshot_source_1 = require("./snapshot-source");
 class Fin extends events_1.EventEmitter {
     constructor(wire) {
         super();
-        (0, fin_store_1.registerFin)(wire, this);
         this.wire = wire;
         this.System = new index_1.default(wire);
         this.Window = new index_2.default(wire);
@@ -33,6 +31,7 @@ class Fin extends events_1.EventEmitter {
         this.View = new index_9.default(wire);
         this.Interop = new interop_1.default(wire);
         this.SnapshotSource = new snapshot_source_1.default(wire);
+        wire.registerFin(this);
         this.me = (0, me_1.getMe)(wire);
         // Handle disconnect events
         wire.on('disconnected', () => {

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

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