@openfin/core 25.68.26

package/src/shapes/protocol.d.ts

@@ -0,0 +1,178 @@
+import { AuthorizationPayload } from '../transport/transport';
+export interface ProtocolMap extends ProtocolMapBase {
+    'request-external-authorization': {
+        request: any;
+        response: void;
+        specialResponse: AuthorizationPayload;
+    };
+    'application-get-views': {
+        request: OpenFin.ApplicationIdentity;
+        response: OpenFin.Identity[];
+    };
+    'set-jump-list': {
+        request: {
+            config: OpenFin.JumpListCategory[] | null;
+        } & OpenFin.ApplicationIdentity;
+        response: void;
+    };
+    'get-view-window': {
+        request: OpenFin.Identity;
+        response: OpenFin.Identity;
+    };
+    'window-get-views': {
+        request: OpenFin.Identity;
+        response: OpenFin.Identity[];
+    };
+    'hide-view': {
+        request: OpenFin.Identity;
+        response: void;
+    };
+    'launch-manifest': {
+        request: {
+            manifestUrl: string;
+            opts?: OpenFin.RvmLaunchOptions;
+        };
+        response: {
+            manifest: OpenFin.Manifest;
+        };
+    };
+    'get-system-app-configuration': {
+        request: {
+            name: string;
+        };
+        response: any;
+    };
+    'show-popup-menu': {
+        request: OpenFin.Identity & {
+            options: OpenFin.ShowPopupMenuOptions;
+        };
+        response: OpenFin.MenuResult;
+    };
+    'enable-native-window-integration-provider': {
+        request: {
+            permissions: any;
+        };
+        response: OpenFin.NativeWindowIntegrationProviderAuthorization;
+    };
+    'get-permissions': {
+        request: void;
+        response: any;
+    };
+    'set-file-download-location': {
+        request: OpenFin.ApplicationIdentity & {
+            downloadLocation: string;
+        };
+        response: void;
+    };
+    'close-popup-menu': {
+        request: OpenFin.Identity;
+        response: void;
+    };
+    'fdc3-add-context-listener': {
+        request: void;
+        response: void;
+    };
+    'fdc3-broadcast': {
+        request: void;
+        response: void;
+    };
+    'fdc3-get-system-channels': {
+        request: void;
+        response: void;
+    };
+    'fdc3-join-channel': {
+        request: void;
+        response: void;
+    };
+    'fdc3-leave-current-channel': {
+        request: void;
+        response: void;
+    };
+    'interop-connect-sync': {
+        request: void;
+        response: void;
+    };
+    'interop-client-set-context': {
+        request: void;
+        response: void;
+    };
+    'interop-client-add-context-handler': {
+        request: void;
+        response: void;
+    };
+    'interop-client-get-context-groups': {
+        request: void;
+        response: void;
+    };
+    'interop-client-join-context-group': {
+        request: void;
+        response: void;
+    };
+    'interop-client-remove-from-context-group': {
+        request: void;
+        response: void;
+    };
+    'interop-client-get-all-clients-in-context-group': {
+        request: void;
+        response: void;
+    };
+    'interop-client-get-info-for-context-group': {
+        request: void;
+        response: void;
+    };
+    'interop-broker-add-client-to-context-group': {
+        request: void;
+        response: void;
+    };
+    'interop-broker-get-all-clients-in-context-group': {
+        request: void;
+        response: void;
+    };
+    'interop-broker-get-context-groups': {
+        request: void;
+        response: void;
+    };
+    'interop-broker-get-info-for-context-group': {
+        request: void;
+        response: void;
+    };
+    'interop-broker-is-action-authorized': {
+        request: void;
+        response: void;
+    };
+    'interop-broker-is-connection-authorized': {
+        request: void;
+        response: void;
+    };
+    'interop-broker-join-context-group': {
+        request: void;
+        response: void;
+    };
+    'interop-broker-remove-client-from-context-group': {
+        request: void;
+        response: void;
+    };
+    'interop-broker-remove-from-context-group': {
+        request: void;
+        response: void;
+    };
+    'interop-broker-set-context': {
+        request: void;
+        response: void;
+    };
+    'query-permission-for-current-context': {
+        request: {
+            apiName: string;
+            identity: OpenFin.Identity;
+        };
+        response: OpenFin.QueryPermissionResult;
+    };
+}
+interface ProtocolMapBase {
+    [action: string]: {
+        request: any;
+        response: any;
+        specialResponse?: any;
+    };
+}
+export {};

package/src/shapes/protocol.js

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

package/src/transport/fin_store.d.ts

@@ -0,0 +1,4 @@
+import Fin from '../api/fin';
+import Transport from './transport';
+export declare function registerFin(wire: Transport, fin: Fin): void;
+export declare function getFin(wire: Transport): Fin;

package/src/transport/fin_store.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getFin = exports.registerFin = void 0;
+const finMap = new WeakMap();
+function registerFin(wire, fin) {
+    finMap.set(wire, fin);
+}
+exports.registerFin = registerFin;
+function getFin(wire) {
+    const fin = finMap.get(wire);
+    if (!fin) {
+        throw new Error('Could not locate fin api for given transport');
+    }
+    return fin;
+}
+exports.getFin = getFin;

package/src/transport/transport-errors.d.ts

@@ -0,0 +1,17 @@
+export declare class DisconnectedError extends Error {
+    constructor(readyState: number);
+    readyState: number;
+}
+export declare class UnexpectedActionError extends Error {
+}
+export declare class DuplicateCorrelationError extends Error {
+}
+export declare class NoAckError extends Error {
+}
+export declare class NotImplementedError extends Error {
+}
+export declare class NotSupportedError extends Error {
+}
+export declare class RuntimeError extends Error {
+    constructor(data: any);
+}

package/src/transport/transport-errors.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RuntimeError = exports.NotSupportedError = exports.NotImplementedError = exports.NoAckError = exports.DuplicateCorrelationError = exports.UnexpectedActionError = exports.DisconnectedError = void 0;
+/* eslint-disable max-classes-per-file */
+const wire_1 = require("./wire");
+class DisconnectedError extends Error {
+    constructor(readyState) {
+        super(`Expected websocket state OPEN but found ${wire_1.READY_STATE[readyState]}`);
+        this.readyState = readyState;
+    }
+}
+exports.DisconnectedError = DisconnectedError;
+class UnexpectedActionError extends Error {
+}
+exports.UnexpectedActionError = UnexpectedActionError;
+class DuplicateCorrelationError extends Error {
+}
+exports.DuplicateCorrelationError = DuplicateCorrelationError;
+class NoAckError extends Error {
+}
+exports.NoAckError = NoAckError;
+class NotImplementedError extends Error {
+}
+exports.NotImplementedError = NotImplementedError;
+class NotSupportedError extends Error {
+}
+exports.NotSupportedError = NotSupportedError;
+class RuntimeError extends Error {
+    constructor(data) {
+        const payload = data.payload || data;
+        const { reason, error } = payload;
+        super(reason);
+        this.name = 'RuntimeError';
+        if (error === null || error === void 0 ? void 0 : error.stack) {
+            this.stack = error.stack;
+        }
+    }
+}
+exports.RuntimeError = RuntimeError;

package/src/transport/transport.d.ts

@@ -0,0 +1,57 @@
+/// <reference types="node" />
+import { EventEmitter } from 'events';
+import { Wire, WireConstructor, READY_STATE, ExistingConnectConfig, InternalConnectConfig } from './wire';
+import { Environment } from '../environment/environment';
+import { RuntimeEvent } from '../api/events/base';
+import EventAggregator from '../api/events/eventAggregator';
+import { EntityTypeHelpers } from '../api/me';
+import { EntityType } from '../shapes/EntityType';
+import { ProtocolMap } from '../shapes/protocol';
+export declare type MessageHandler = (data: any) => boolean;
+declare class Transport<MeType extends EntityType = EntityType> extends EventEmitter {
+    #private;
+    protected wireListeners: Map<number, {
+        resolve: Function;
+        reject: Function;
+    }>;
+    protected uncorrelatedListener: Function;
+    me: OpenFin.EntityInfo & EntityTypeHelpers<MeType>;
+    environment: Environment;
+    topicRefMap: Map<string, number>;
+    sendRaw: Wire['send'];
+    eventAggregator: EventAggregator;
+    protected messageHandlers: MessageHandler[];
+    constructor(WireType: WireConstructor, environment: Environment, config: OpenFin.Identity);
+    connectSync: () => void;
+    getPort: () => string;
+    shutdown(): Promise<void>;
+    connect(config: InternalConnectConfig): Promise<string | void>;
+    connectByPort(config: ExistingConnectConfig): Promise<string>;
+    READY_STATE: typeof READY_STATE;
+    sendAction<T extends keyof ProtocolMap = string>(action: T, payload?: ProtocolMap[T]['request'], uncorrelated?: boolean): Promise<Message<{
+        data: ProtocolMap[T]['response'];
+    } & ProtocolMap[T]['specialResponse']>>;
+    ferryAction(origData: any): Promise<Message<any>>;
+    registerMessageHandler(handler: MessageHandler): void;
+    protected addWireListener(id: number, resolve: Function, reject: Function, uncorrelated: boolean): void;
+    protected onmessage(data: Message<Payload>): void;
+    protected handleMessage(data: Message<Payload>): boolean;
+}
+export default Transport;
+export interface Message<T> {
+    action: string;
+    payload: T;
+    correlationId?: number;
+}
+export interface EventMessage extends Message<RuntimeEvent> {
+    action: 'process-desktop-event';
+    payload: RuntimeEvent;
+}
+export interface Payload {
+    success: boolean;
+    data: any;
+}
+export interface AuthorizationPayload {
+    token: string;
+    file: string;
+}

package/src/transport/transport.js

@@ -0,0 +1,195 @@
+"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 _wire;
+Object.defineProperty(exports, "__esModule", { value: true });
+const events_1 = require("events");
+const wire_1 = require("./wire");
+const transport_errors_1 = require("./transport-errors");
+const eventAggregator_1 = require("../api/events/eventAggregator");
+const me_1 = require("../api/me");
+class Transport extends events_1.EventEmitter {
+    constructor(WireType, environment, config) {
+        super();
+        this.wireListeners = new Map();
+        this.topicRefMap = new Map();
+        this.eventAggregator = new eventAggregator_1.default();
+        this.messageHandlers = [this.eventAggregator.dispatchEvent];
+        _wire.set(this, void 0);
+        this.connectSync = () => {
+            const wire = __classPrivateFieldGet(this, _wire);
+            wire.connectSync();
+        };
+        // This function is only used in our tests.
+        this.getPort = () => {
+            if (this.environment.constructor.name !== 'NodeEnvironment') {
+                throw new transport_errors_1.NotImplementedError('Not Implemented');
+            }
+            const wire = __classPrivateFieldGet(this, _wire);
+            return wire.wire.url.split(':').slice(-1)[0];
+        };
+        /* `READY_STATE` is an instance var set by `constructor` to reference the `WebTransportSocket.READY_STATE` enum.
+         * This is syntactic sugar that makes the enum accessible through the `wire` property of the various `fin` singletons.
+         * For example, `fin.system.wire.READY_STATE` is a shortcut to `fin.system.wire.wire.constructor.READY_STATE`.
+         * However it is accessed, the enum is useful for interrogating the state of the web socket on send failure.
+         * The `err.readyState` value is passed to the `reject` handler of the promise returned by either of
+         * `sendAction` or `ferryAction`, and hence all the API methods in the various `fin` singletons that call them.
+         * The enum can be used in two distinct ways by the `reject` handler (using `fin.System.getVersion` by way of example):
+         * 1. State name by state value:
+         * fin.system.getVersion().catch(err => { console.log('State:', fin.system.wire.READY_STATE[err.readyState]); });
+         * 2. State value by state name:
+         * fin.system.getVersion().catch(err => { console.log('Closed:', err.readyState === fin.system.wire.READY_STATE.CLOSED); });
+         * Note that `reject` is called when and only when `readyState` is not `OPEN`.
+         */
+        this.READY_STATE = wire_1.READY_STATE;
+        __classPrivateFieldSet(this, _wire, new WireType(this.onmessage.bind(this)));
+        this.environment = environment;
+        this.sendRaw = __classPrivateFieldGet(this, _wire).send.bind(__classPrivateFieldGet(this, _wire));
+        this.registerMessageHandler(this.handleMessage.bind(this));
+        __classPrivateFieldGet(this, _wire).on('disconnected', () => {
+            for (const [, { reject }] of this.wireListeners) {
+                reject('Remote connection has closed');
+            }
+            this.wireListeners.clear();
+            this.emit('disconnected');
+        });
+        const { uuid, name } = config;
+        const entityType = this.environment.getCurrentEntityType();
+        this.me = me_1.getBaseMe(entityType, uuid, name);
+    }
+    shutdown() {
+        const wire = __classPrivateFieldGet(this, _wire);
+        return wire.shutdown();
+    }
+    async connect(config) {
+        if (wire_1.isExistingConnectConfig(config)) {
+            return this.connectByPort(config);
+        }
+        if (wire_1.isNewConnectConfig(config)) {
+            const port = await this.environment.retrievePort(config);
+            return this.connectByPort({ ...config, address: `ws://localhost:${port}` });
+        }
+        return undefined;
+    }
+    async connectByPort(config) {
+        const { address, uuid } = config;
+        const reqAuthPayload = { ...config, type: 'file-token' };
+        const wire = __classPrivateFieldGet(this, _wire);
+        await wire.connect(address);
+        const requestExtAuthRet = await this.sendAction('request-external-authorization', {
+            uuid,
+            type: 'file-token'
+        }, true);
+        if (requestExtAuthRet.action !== 'external-authorization-response') {
+            throw new transport_errors_1.UnexpectedActionError(requestExtAuthRet.action);
+        }
+        const { token } = requestExtAuthRet.payload;
+        await this.environment.writeToken(requestExtAuthRet.payload.file, requestExtAuthRet.payload.token);
+        const requestAuthRet = await this.sendAction('request-authorization', reqAuthPayload, true);
+        if (requestAuthRet.action !== 'authorization-response') {
+            throw new transport_errors_1.UnexpectedActionError(requestAuthRet.action);
+        }
+        else if (requestAuthRet.payload.success !== true) {
+            throw new transport_errors_1.RuntimeError(requestAuthRet.payload);
+        }
+        else {
+            return token;
+        }
+    }
+    sendAction(action, payload = {}, uncorrelated = false
+    // specialResponse type is only used for 'requestAuthorization'
+    ) {
+        return new Promise((resolve, reject) => {
+            const id = this.environment.getNextMessageId();
+            const msg = {
+                action,
+                payload,
+                messageId: id
+            };
+            const wire = __classPrivateFieldGet(this, _wire);
+            this.addWireListener(id, resolve, reject, uncorrelated);
+            return wire.send(msg).catch(reject);
+        });
+    }
+    ferryAction(origData) {
+        return new Promise((resolve, reject) => {
+            const id = this.environment.getNextMessageId();
+            origData.messageId = id;
+            const resolver = (data) => {
+                resolve(data.payload);
+            };
+            const wire = __classPrivateFieldGet(this, _wire);
+            return wire
+                .send(origData)
+                .then(() => this.addWireListener(id, resolver, reject, false))
+                .catch(reject);
+        });
+    }
+    registerMessageHandler(handler) {
+        this.messageHandlers.push(handler);
+    }
+    addWireListener(id, resolve, reject, uncorrelated) {
+        if (uncorrelated) {
+            this.uncorrelatedListener = resolve;
+        }
+        else if (this.wireListeners.has(id)) {
+            reject(new transport_errors_1.DuplicateCorrelationError(String(id)));
+        }
+        else {
+            this.wireListeners.set(id, { resolve, reject });
+        }
+        // Timeout and reject()?
+    }
+    // This method executes message handlers until the _one_ that handles the message (returns truthy) has run
+    onmessage(data) {
+        for (const h of this.messageHandlers) {
+            h.call(null, data);
+        }
+    }
+    handleMessage(data) {
+        const id = data.correlationId || NaN;
+        if (!('correlationId' in data)) {
+            if (this.uncorrelatedListener) {
+                this.uncorrelatedListener.call(null, data);
+            }
+            this.uncorrelatedListener = () => {
+                // empty block
+            };
+        }
+        else if (!this.wireListeners.has(id)) {
+            return false;
+        }
+        else {
+            // We just checked for existence above
+            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+            const { resolve, reject } = this.wireListeners.get(id);
+            if (data.action !== 'ack') {
+                reject(new transport_errors_1.NoAckError(data.action));
+            }
+            else if (!('payload' in data)) {
+                reject(new transport_errors_1.RuntimeError(data));
+            }
+            else if (!data.payload.success) {
+                reject(new transport_errors_1.RuntimeError(data.payload));
+            }
+            else {
+                resolve.call(null, data);
+            }
+            this.wireListeners.delete(id);
+        }
+        return true;
+    }
+}
+_wire = new WeakMap();
+exports.default = Transport;

package/src/transport/wire.d.ts

@@ -0,0 +1,76 @@
+/// <reference types="node" />
+import { EventEmitter } from 'events';
+export interface Wire extends EventEmitter {
+    connect(address: string): Promise<any>;
+    connectSync(): any;
+    send(data: any): Promise<any>;
+    shutdown(): Promise<void>;
+}
+export interface WireConstructor {
+    new (onmessage: (data: any) => void): Wire;
+}
+export interface RuntimeConfig {
+    version: string;
+    fallbackVersion?: string;
+    securityRealm?: string;
+    verboseLogging?: boolean;
+    arguments?: string;
+    rvmDir?: string;
+}
+export interface ServiceConfig {
+    name: string;
+    manifestUrl: string;
+}
+export interface BaseConfig {
+    uuid?: string;
+    address?: string;
+    name?: string;
+    nonPersistent?: boolean;
+    runtimeClient?: boolean;
+    licenseKey?: string;
+    client?: any;
+    manifestUrl?: string;
+    startupApp?: any;
+    lrsUrl?: string;
+    assetsUrl?: string;
+    devToolsPort?: number;
+    installerUI?: boolean;
+    runtime?: RuntimeConfig;
+    services?: ServiceConfig[];
+    appAssets?: [{
+        src: string;
+        alias: string;
+        target: string;
+        version: string;
+        args: string;
+    }];
+    customItems?: [any];
+    timeout?: number;
+}
+export interface ConfigWithUuid extends BaseConfig {
+    uuid: string;
+}
+export interface ExistingConnectConfig extends ConfigWithUuid {
+    address: string;
+}
+export interface ConfigWithRuntime extends BaseConfig {
+    runtime: RuntimeConfig;
+}
+export interface ExternalConfig extends BaseConfig {
+    manifestUrl: string;
+}
+export declare type NewConnectConfig = ConfigWithUuid & ConfigWithRuntime;
+export declare type PortDiscoveryConfig = (ExternalConfig & ConfigWithRuntime) | NewConnectConfig;
+export declare type ConnectConfig = ExistingConnectConfig | NewConnectConfig | ExternalConfig;
+export declare type InternalConnectConfig = ExistingConnectConfig | NewConnectConfig;
+export declare function isExternalConfig(config: ConnectConfig): config is ExternalConfig;
+export declare function isExistingConnectConfig(config: any): config is ExistingConnectConfig;
+export declare function isNewConnectConfig(config: any): config is NewConnectConfig;
+export declare function isPortDiscoveryConfig(config: any): config is PortDiscoveryConfig;
+export declare function isInternalConnectConfig(config: any): config is InternalConnectConfig;
+export declare enum READY_STATE {
+    CONNECTING = 0,
+    OPEN = 1,
+    CLOSING = 2,
+    CLOSED = 3
+}

package/src/transport/wire.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.READY_STATE = exports.isInternalConnectConfig = exports.isPortDiscoveryConfig = exports.isNewConnectConfig = exports.isExistingConnectConfig = exports.isExternalConfig = void 0;
+function isExternalConfig(config) {
+    if (typeof config.manifestUrl === 'string') {
+        return true;
+    }
+    return false;
+}
+exports.isExternalConfig = isExternalConfig;
+function isExistingConnectConfig(config) {
+    return hasUuid(config) && typeof config.address === 'string';
+}
+exports.isExistingConnectConfig = isExistingConnectConfig;
+function hasUuid(config) {
+    return typeof config.uuid === 'string';
+}
+function hasRuntimeVersion(config) {
+    return config.runtime && typeof config.runtime.version === 'string';
+}
+function isNewConnectConfig(config) {
+    return hasUuid(config) && hasRuntimeVersion(config);
+}
+exports.isNewConnectConfig = isNewConnectConfig;
+function isPortDiscoveryConfig(config) {
+    return (isExternalConfig(config) && hasRuntimeVersion(config)) || isNewConnectConfig(config);
+}
+exports.isPortDiscoveryConfig = isPortDiscoveryConfig;
+function isInternalConnectConfig(config) {
+    return isExistingConnectConfig(config) || isNewConnectConfig(config);
+}
+exports.isInternalConnectConfig = isInternalConnectConfig;
+var READY_STATE;
+(function (READY_STATE) {
+    READY_STATE[READY_STATE["CONNECTING"] = 0] = "CONNECTING";
+    READY_STATE[READY_STATE["OPEN"] = 1] = "OPEN";
+    READY_STATE[READY_STATE["CLOSING"] = 2] = "CLOSING";
+    READY_STATE[READY_STATE["CLOSED"] = 3] = "CLOSED"; // The connection is closed.
+})(READY_STATE = exports.READY_STATE || (exports.READY_STATE = {}));

package/src/util/asyncFilter.d.ts

@@ -0,0 +1 @@
+export declare function asyncFilter<T>(values: T[], callback: (value: T) => Promise<boolean>): Promise<T[]>;

package/src/util/asyncFilter.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.asyncFilter = void 0;
+async function asyncFilter(values, callback) {
+    return Promise.all(values.map(callback)).then((results) => values.filter((_, i) => results[i]));
+}
+exports.asyncFilter = asyncFilter;

package/src/util/errors.d.ts

@@ -0,0 +1,9 @@
+export interface ErrorPlainObject {
+    stack: string;
+    message: string;
+    toString(): string;
+}
+/**
+ * This function converts JS errors into plain objects
+ */
+export declare function errorToPOJO(error: Error): ErrorPlainObject;

package/src/util/errors.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.errorToPOJO = void 0;
+/**
+ * This function converts JS errors into plain objects
+ */
+function errorToPOJO(error) {
+    return {
+        stack: error.stack,
+        message: error.message,
+        toString: error.toString
+    };
+}
+exports.errorToPOJO = errorToPOJO;

package/src/util/exhaustive.d.ts

@@ -0,0 +1 @@
+export declare function exhaustiveCheck(value: string, allowed?: string[]): never;

package/src/util/exhaustive.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.exhaustiveCheck = void 0;
+function exhaustiveCheck(value, allowed) {
+    throw new Error(`Unsupported value: ${value}${allowed ? `\n Supported values are: ${allowed.join('')}` : ''}`);
+}
+exports.exhaustiveCheck = exhaustiveCheck;