@openfin/core 25.68.26

package/src/api/frame/Factory.js

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const base_1 = require("../base");
+const validate_1 = require("../../util/validate");
+const Instance_1 = require("./Instance");
+/**
+ * @lends Frame
+ */
+class _FrameModule extends base_1.Base {
+    /**
+     * Asynchronously returns a reference to the specified frame. The frame does not have to exist
+     * @param {Identity} identity - the identity of the frame you want to wrap
+     * @return {Promise.<_Frame>}
+     * @tutorial Frame.wrap
+     * @static
+     */
+    async wrap(identity) {
+        this.wire.sendAction('frame-wrap').catch((e) => {
+            // we do not want to expose this error, just continue if this analytics-only call fails
+        });
+        const errorMsg = validate_1.validateIdentity(identity);
+        if (errorMsg) {
+            throw new Error(errorMsg);
+        }
+        return new Instance_1._Frame(this.wire, identity);
+    }
+    /**
+     * Synchronously returns a reference to the specified frame. The frame does not have to exist
+     * @param {Identity} identity - the identity of the frame you want to wrap
+     * @return {_Frame}
+     * @tutorial Frame.wrapSync
+     * @static
+     */
+    wrapSync(identity) {
+        this.wire.sendAction('frame-wrap-sync').catch((e) => {
+            // we do not want to expose this error, just continue if this analytics-only call fails
+        });
+        const errorMsg = validate_1.validateIdentity(identity);
+        if (errorMsg) {
+            throw new Error(errorMsg);
+        }
+        return new Instance_1._Frame(this.wire, identity);
+    }
+    /**
+     * Asynchronously returns a reference to the current frame
+     * @return {Promise.<_Frame>}
+     * @tutorial Frame.getCurrent
+     * @static
+     */
+    getCurrent() {
+        this.wire.sendAction('frame-get-current').catch((e) => {
+            // we do not want to expose this error, just continue if this analytics-only call fails
+        });
+        return Promise.resolve(new Instance_1._Frame(this.wire, this.wire.environment.getCurrentEntityIdentity()));
+    }
+    /**
+     * Synchronously returns a reference to the current frame
+     * @return {_Frame}
+     * @tutorial Frame.getCurrentSync
+     * @static
+     */
+    getCurrentSync() {
+        this.wire.sendAction('frame-get-current-sync').catch((e) => {
+            // we do not want to expose this error, just continue if this analytics-only call fails
+        });
+        return new Instance_1._Frame(this.wire, this.wire.environment.getCurrentEntityIdentity());
+    }
+}
+exports.default = _FrameModule;

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

@@ -0,0 +1,121 @@
+import { EmitterBase } from '../base';
+import Transport from '../../transport/transport';
+import { FrameEvents } from '../events/frame';
+/**
+ * @classdesc
+ * An iframe represents an embedded HTML page within a parent HTML page. Because this embedded page
+ * has its own DOM and global JS context (which may or may not be linked to that of the parent depending
+ * on if it is considered out of the root domain or not), it represents a unique endpoint as an OpenFin
+ * connection. Iframes may be generated dynamically, or be present on initial page load and each non-CORS
+ * iframe has the OpenFin API injected by default. It is possible to opt into cross-origin iframes having
+ * the API by setting api.iframe.crossOriginInjection to true in a window's options. To block all iframes
+ * from getting the API injected you can set api.frame.sameOriginInjection
+ * to false <a href="Window.html#~options" target="_blank">(see Window~options)</a>.
+ *
+ * To be able to directly address this context for eventing and messaging purposes, it needs a
+ * unique uuid name pairing. For OpenFin applications and windows this is provided via a configuration
+ * object in the form of a manifest URL or options object, but there is no configuration object for iframes.
+ * Just as a call to window.open outside of our Window API returns a new window with a random GUID assigned
+ * for the name, each iframe that has the API injected will be assigned a GUID as its name, the UUID will be
+ * the same as the parent window's.
+ *
+ * The fin.Frame namespace represents a way to interact with `iframes` and facilitates the discovery of current context
+ * (iframe or main window) as well as the ability to listen for <a href="tutorial-Frame.EventEmitter.html">frame-specific events</a>.
+ * @class
+ * @alias Frame
+ * @hideconstructor
+ */
+export declare class _Frame extends EmitterBase<FrameEvents> {
+    identity: OpenFin.Identity;
+    constructor(wire: Transport, identity: OpenFin.Identity);
+    /**
+     * Adds the listener function to the end of the listeners array for the specified event type.
+     * @param { string | symbol } eventType  - The type of the event.
+     * @param { Function } listener - Called whenever an event of the specified type occurs.
+     * @param { SubOptions } [options] - Option to support event timestamps.
+     * @return {Promise.<this>}
+     * @function addListener
+     * @memberof Frame
+     * @instance
+     * @tutorial Frame.EventEmitter
+     */
+    /**
+     * Adds a listener to the end of the listeners array for the specified event.
+     * @param { string | symbol } eventType  - The type of the event.
+     * @param { Function } listener - Called whenever an event of the specified type occurs.
+     * @param { SubOptions } [options] - Option to support event timestamps.
+     * @return {Promise.<this>}
+     * @function on
+     * @memberof Frame
+     * @instance
+     * @tutorial Frame.EventEmitter
+     */
+    /**
+     * Adds a one time listener for the event. The listener is invoked only the first time the event is fired, after which it is removed.
+     * @param { string | symbol } eventType  - The type of the event.
+     * @param { Function } listener - The callback function.
+     * @param { SubOptions } [options] - Option to support event timestamps.
+     * @return {Promise.<this>}
+     * @function once
+     * @memberof Frame
+     * @instance
+     * @tutorial Frame.EventEmitter
+     */
+    /**
+     * Adds a listener to the beginning of the listeners array for the specified event.
+     * @param { string | symbol } eventType  - The type of the event.
+     * @param { Function } listener - The callback function.
+     * @param { SubOptions } [options] - Option to support event timestamps.
+     * @return {Promise.<this>}
+     * @function prependListener
+     * @memberof Frame
+     * @instance
+     * @tutorial Frame.EventEmitter
+     */
+    /**
+     * Adds a one time listener for the event. The listener is invoked only the first time the event is fired, after which it is removed.
+     * The listener is added to the beginning of the listeners array.
+     * @param { string | symbol } eventType  - The type of the event.
+     * @param { Function } listener - The callback function.
+     * @param { SubOptions } [options] - Option to support event timestamps.
+     * @return {Promise.<this>}
+     * @function prependOnceListener
+     * @memberof Frame
+     * @instance
+     * @tutorial Frame.EventEmitter
+     */
+    /**
+     * Remove a listener from the listener array for the specified event.
+     * Caution: Calling this method changes the array indices in the listener array behind the listener.
+     * @param { string | symbol } eventType  - The type of the event.
+     * @param { Function } listener - The callback function.
+     * @param { SubOptions } [options] - Option to support event timestamps.
+     * @return {Promise.<this>}
+     * @function removeListener
+     * @memberof Frame
+     * @instance
+     * @tutorial Frame.EventEmitter
+     */
+    /**
+     * Removes all listeners, or those of the specified event.
+     * @param { string | symbol } [eventType]  - The type of the event.
+     * @return {Promise.<this>}
+     * @function removeAllListeners
+     * @memberof Frame
+     * @instance
+     * @tutorial Frame.EventEmitter
+     */
+    /**
+     * Returns a frame info object for the represented frame
+     * @return {Promise.<FrameInfo>}
+     * @tutorial Frame.getInfo
+     */
+    getInfo(): Promise<OpenFin.FrameInfo>;
+    /**
+     * Returns a frame info object representing the window that the referenced iframe is
+     * currently embedded in
+     * @return {Promise.<FrameInfo>}
+     * @tutorial Frame.getParentWindow
+     */
+    getParentWindow(): Promise<OpenFin.FrameInfo>;
+}

package/src/api/frame/Instance.js

@@ -0,0 +1,130 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports._Frame = void 0;
+/* eslint-disable import/prefer-default-export */
+const base_1 = require("../base");
+/**
+ * @classdesc
+ * An iframe represents an embedded HTML page within a parent HTML page. Because this embedded page
+ * has its own DOM and global JS context (which may or may not be linked to that of the parent depending
+ * on if it is considered out of the root domain or not), it represents a unique endpoint as an OpenFin
+ * connection. Iframes may be generated dynamically, or be present on initial page load and each non-CORS
+ * iframe has the OpenFin API injected by default. It is possible to opt into cross-origin iframes having
+ * the API by setting api.iframe.crossOriginInjection to true in a window's options. To block all iframes
+ * from getting the API injected you can set api.frame.sameOriginInjection
+ * to false <a href="Window.html#~options" target="_blank">(see Window~options)</a>.
+ *
+ * To be able to directly address this context for eventing and messaging purposes, it needs a
+ * unique uuid name pairing. For OpenFin applications and windows this is provided via a configuration
+ * object in the form of a manifest URL or options object, but there is no configuration object for iframes.
+ * Just as a call to window.open outside of our Window API returns a new window with a random GUID assigned
+ * for the name, each iframe that has the API injected will be assigned a GUID as its name, the UUID will be
+ * the same as the parent window's.
+ *
+ * The fin.Frame namespace represents a way to interact with `iframes` and facilitates the discovery of current context
+ * (iframe or main window) as well as the ability to listen for <a href="tutorial-Frame.EventEmitter.html">frame-specific events</a>.
+ * @class
+ * @alias Frame
+ * @hideconstructor
+ */
+class _Frame extends base_1.EmitterBase {
+    constructor(wire, identity) {
+        super(wire, 'frame', identity.uuid, identity.name);
+        this.identity = identity;
+    }
+    /**
+     * Adds the listener function to the end of the listeners array for the specified event type.
+     * @param { string | symbol } eventType  - The type of the event.
+     * @param { Function } listener - Called whenever an event of the specified type occurs.
+     * @param { SubOptions } [options] - Option to support event timestamps.
+     * @return {Promise.<this>}
+     * @function addListener
+     * @memberof Frame
+     * @instance
+     * @tutorial Frame.EventEmitter
+     */
+    /**
+     * Adds a listener to the end of the listeners array for the specified event.
+     * @param { string | symbol } eventType  - The type of the event.
+     * @param { Function } listener - Called whenever an event of the specified type occurs.
+     * @param { SubOptions } [options] - Option to support event timestamps.
+     * @return {Promise.<this>}
+     * @function on
+     * @memberof Frame
+     * @instance
+     * @tutorial Frame.EventEmitter
+     */
+    /**
+     * Adds a one time listener for the event. The listener is invoked only the first time the event is fired, after which it is removed.
+     * @param { string | symbol } eventType  - The type of the event.
+     * @param { Function } listener - The callback function.
+     * @param { SubOptions } [options] - Option to support event timestamps.
+     * @return {Promise.<this>}
+     * @function once
+     * @memberof Frame
+     * @instance
+     * @tutorial Frame.EventEmitter
+     */
+    /**
+     * Adds a listener to the beginning of the listeners array for the specified event.
+     * @param { string | symbol } eventType  - The type of the event.
+     * @param { Function } listener - The callback function.
+     * @param { SubOptions } [options] - Option to support event timestamps.
+     * @return {Promise.<this>}
+     * @function prependListener
+     * @memberof Frame
+     * @instance
+     * @tutorial Frame.EventEmitter
+     */
+    /**
+     * Adds a one time listener for the event. The listener is invoked only the first time the event is fired, after which it is removed.
+     * The listener is added to the beginning of the listeners array.
+     * @param { string | symbol } eventType  - The type of the event.
+     * @param { Function } listener - The callback function.
+     * @param { SubOptions } [options] - Option to support event timestamps.
+     * @return {Promise.<this>}
+     * @function prependOnceListener
+     * @memberof Frame
+     * @instance
+     * @tutorial Frame.EventEmitter
+     */
+    /**
+     * Remove a listener from the listener array for the specified event.
+     * Caution: Calling this method changes the array indices in the listener array behind the listener.
+     * @param { string | symbol } eventType  - The type of the event.
+     * @param { Function } listener - The callback function.
+     * @param { SubOptions } [options] - Option to support event timestamps.
+     * @return {Promise.<this>}
+     * @function removeListener
+     * @memberof Frame
+     * @instance
+     * @tutorial Frame.EventEmitter
+     */
+    /**
+     * Removes all listeners, or those of the specified event.
+     * @param { string | symbol } [eventType]  - The type of the event.
+     * @return {Promise.<this>}
+     * @function removeAllListeners
+     * @memberof Frame
+     * @instance
+     * @tutorial Frame.EventEmitter
+     */
+    /**
+     * Returns a frame info object for the represented frame
+     * @return {Promise.<FrameInfo>}
+     * @tutorial Frame.getInfo
+     */
+    getInfo() {
+        return this.wire.sendAction('get-frame-info', this.identity).then(({ payload }) => payload.data);
+    }
+    /**
+     * Returns a frame info object representing the window that the referenced iframe is
+     * currently embedded in
+     * @return {Promise.<FrameInfo>}
+     * @tutorial Frame.getParentWindow
+     */
+    getParentWindow() {
+        return this.wire.sendAction('get-parent-window', this.identity).then(({ payload }) => payload.data);
+    }
+}
+exports._Frame = _Frame;

package/src/api/frame/index.d.ts

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

package/src/api/frame/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/global-hotkey/index.d.ts

@@ -0,0 +1,38 @@
+import { EmitterBase } from '../base';
+import Transport from '../../transport/transport';
+import { GlobalHotkeyEvents } from '../events/globalHotkey';
+/**
+ * The GlobalHotkey module can register/unregister a global hotkeys.
+ * @namespace
+ */
+export default class GlobalHotkey extends EmitterBase<GlobalHotkeyEvents> {
+    constructor(wire: Transport);
+    /**
+     * Registers a global hotkey with the operating system.
+     * @param { string } hotkey a hotkey string
+     * @param { Function } listener called when the registered hotkey is pressed by the user.
+     * @return {Promise.<void>}
+     * @tutorial GlobalHotkey.register
+     */
+    register(hotkey: string, listener: (...args: any[]) => void): Promise<void>;
+    /**
+     * Unregisters a global hotkey with the operating system.
+     * @param { string } hotkey a hotkey string
+     * @return {Promise.<void>}
+     * @tutorial GlobalHotkey.unregister
+     */
+    unregister(hotkey: string): Promise<void>;
+    /**
+     * Unregisters all global hotkeys for the current application.
+     * @return {Promise.<void>}
+     * @tutorial GlobalHotkey.unregisterAll
+     */
+    unregisterAll(): Promise<void>;
+    /**
+     * Checks if a given hotkey has been registered
+     * @param { string } hotkey a hotkey string
+     * @return {Promise.<boolean>}
+     * @tutorial GlobalHotkey.isRegistered
+     */
+    isRegistered(hotkey: string): Promise<boolean>;
+}

package/src/api/global-hotkey/index.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const base_1 = require("../base");
+/**
+ * The GlobalHotkey module can register/unregister a global hotkeys.
+ * @namespace
+ */
+class GlobalHotkey extends base_1.EmitterBase {
+    constructor(wire) {
+        super(wire, 'global-hotkey');
+    }
+    /**
+     * Registers a global hotkey with the operating system.
+     * @param { string } hotkey a hotkey string
+     * @param { Function } listener called when the registered hotkey is pressed by the user.
+     * @return {Promise.<void>}
+     * @tutorial GlobalHotkey.register
+     */
+    async register(hotkey, listener) {
+        await this.on(hotkey, listener);
+        await this.wire.sendAction('global-hotkey-register', { hotkey });
+        return undefined;
+    }
+    /**
+     * Unregisters a global hotkey with the operating system.
+     * @param { string } hotkey a hotkey string
+     * @return {Promise.<void>}
+     * @tutorial GlobalHotkey.unregister
+     */
+    async unregister(hotkey) {
+        await this.removeAllListeners(hotkey);
+        await this.wire.sendAction('global-hotkey-unregister', { hotkey });
+        return undefined;
+    }
+    /**
+     * Unregisters all global hotkeys for the current application.
+     * @return {Promise.<void>}
+     * @tutorial GlobalHotkey.unregisterAll
+     */
+    async unregisterAll() {
+        await Promise.all(this.eventNames()
+            .filter((name) => !(name === 'registered' || name === 'unregistered'))
+            .map((name) => this.removeAllListeners(name)));
+        await this.wire.sendAction('global-hotkey-unregister-all', {});
+        return undefined;
+    }
+    /**
+     * Checks if a given hotkey has been registered
+     * @param { string } hotkey a hotkey string
+     * @return {Promise.<boolean>}
+     * @tutorial GlobalHotkey.isRegistered
+     */
+    async isRegistered(hotkey) {
+        const { payload: { data } } = await this.wire.sendAction('global-hotkey-is-registered', { hotkey });
+        return data;
+    }
+}
+exports.default = GlobalHotkey;

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

@@ -0,0 +1,26 @@
+import Transport from '../../../transport/transport';
+import ProviderIdentity = OpenFin.ProviderIdentity;
+export declare type ChannelAction = (payload: unknown, id: ProviderIdentity | OpenFin.ClientIdentity) => unknown;
+export declare type ChannelMiddleware = (topic: string, payload: unknown, senderIdentity: ProviderIdentity | OpenFin.ClientIdentity) => unknown;
+export declare type ErrorMiddleware = (topic: string, error: Error, id: ProviderIdentity | OpenFin.ClientIdentity) => unknown;
+export declare class ProtectedItems {
+    providerIdentity: ProviderIdentity;
+    wire: Transport;
+    constructor(providerIdentity: ProviderIdentity, wire: Transport);
+}
+export declare class ChannelBase {
+    protected subscriptions: Map<string, ChannelAction>;
+    private defaultAction?;
+    private preAction?;
+    private postAction?;
+    private errorMiddleware?;
+    private static defaultAction;
+    constructor();
+    protected processAction(topic: string, payload: unknown, senderIdentity: ProviderIdentity | OpenFin.ClientIdentity): Promise<unknown>;
+    beforeAction(func: ChannelMiddleware): void;
+    onError(func: ErrorMiddleware): void;
+    afterAction(func: ChannelMiddleware): void;
+    remove(action: string): void;
+    setDefaultAction(func: ChannelMiddleware): void;
+    register(topic: string, listener: ChannelAction): boolean;
+}

package/src/api/interappbus/channel/channel.js

@@ -0,0 +1,77 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ChannelBase = exports.ProtectedItems = void 0;
+const resultOrPayload = (func) => (topic, payload, senderIdentity) => {
+    const res = func(topic, payload, senderIdentity);
+    return res === undefined ? payload : res;
+};
+class ProtectedItems {
+    constructor(providerIdentity, wire) {
+        this.providerIdentity = providerIdentity;
+        this.wire = wire;
+    }
+}
+exports.ProtectedItems = ProtectedItems;
+class ChannelBase {
+    constructor() {
+        this.subscriptions = new Map();
+    }
+    static defaultAction(topic) {
+        throw new Error(`No action registered at target for ${topic}`);
+    }
+    async processAction(topic, payload, senderIdentity) {
+        try {
+            const mainAction = this.subscriptions.has(topic)
+                ? this.subscriptions.get(topic)
+                : (currentPayload, id) => { var _a; return ((_a = this.defaultAction) !== null && _a !== void 0 ? _a : ChannelBase.defaultAction)(topic, currentPayload, id); };
+            const preActionProcessed = this.preAction ? await this.preAction(topic, payload, senderIdentity) : payload;
+            const actionProcessed = await mainAction(preActionProcessed, senderIdentity);
+            return this.postAction ? await this.postAction(topic, actionProcessed, senderIdentity) : actionProcessed;
+        }
+        catch (e) {
+            if (this.errorMiddleware) {
+                return this.errorMiddleware(topic, e, senderIdentity);
+            }
+            throw e;
+        }
+    }
+    beforeAction(func) {
+        if (this.preAction) {
+            throw new Error('Already registered beforeAction middleware');
+        }
+        this.preAction = resultOrPayload(func);
+    }
+    onError(func) {
+        if (this.errorMiddleware) {
+            throw new Error('Already registered error middleware');
+        }
+        this.errorMiddleware = func;
+    }
+    afterAction(func) {
+        if (this.postAction) {
+            throw new Error('Already registered afterAction middleware');
+        }
+        this.postAction = resultOrPayload(func);
+    }
+    remove(action) {
+        this.subscriptions.delete(action);
+    }
+    setDefaultAction(func) {
+        if (this.defaultAction) {
+            throw new Error('default action can only be set once');
+        }
+        else {
+            this.defaultAction = func;
+        }
+    }
+    register(topic, listener) {
+        if (this.subscriptions.has(topic)) {
+            throw new Error(`Subscription already registered for action: ${topic}. Unsubscribe before adding new subscription`);
+        }
+        else {
+            this.subscriptions.set(topic, listener);
+            return true;
+        }
+    }
+}
+exports.ChannelBase = ChannelBase;