@openfin/core 25.68.26

package/src/api/interappbus/channel/protocols/rtc/strategy.js

@@ -0,0 +1,87 @@
+"use strict";
+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 __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 _processAction, _rtcEndpointMap, _connected;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RTCInfo = exports.RTCStrategy = void 0;
+const endpoint_1 = require("./endpoint");
+/*
+This is used to abstract out rtc messaging from the channels implementation using RTCEndpoints.
+*/
+class RTCStrategy {
+    constructor() {
+        _processAction.set(this, null);
+        _rtcEndpointMap.set(this, new Map());
+        _connected.set(this, true);
+        this.send = async (endpointId, action, payload) => {
+            return this.getEndpointById(endpointId).send(action, payload);
+        };
+        this.close = async () => {
+            if (__classPrivateFieldGet(this, _connected)) {
+                __classPrivateFieldGet(this, _rtcEndpointMap).forEach((rtcEndpoint) => rtcEndpoint.close());
+                __classPrivateFieldSet(this, _rtcEndpointMap, new Map());
+            }
+            __classPrivateFieldSet(this, _connected, false);
+        };
+    }
+    onEndpointDisconnect(endpointId, listener) {
+        this.getEndpointById(endpointId).onDisconnect(listener);
+    }
+    receive(listener) {
+        if (__classPrivateFieldGet(this, _processAction)) {
+            throw new Error('You have already set a listener for this RTC Strategy');
+        }
+        __classPrivateFieldSet(this, _processAction, listener);
+        __classPrivateFieldGet(this, _rtcEndpointMap).forEach((rtcEndpoint) => rtcEndpoint.receive(__classPrivateFieldGet(this, _processAction)));
+    }
+    getEndpointById(endpointId) {
+        const endpoint = __classPrivateFieldGet(this, _rtcEndpointMap).get(endpointId);
+        if (!endpoint) {
+            throw new Error(`Client with endpoint id ${endpointId} is not connected`);
+        }
+        return endpoint;
+    }
+    get connected() {
+        return __classPrivateFieldGet(this, _connected);
+    }
+    isEndpointConnected(endpointId) {
+        return __classPrivateFieldGet(this, _rtcEndpointMap).has(endpointId);
+    }
+    addEndpoint(endpointId, payload) {
+        if (!__classPrivateFieldGet(this, _connected)) {
+            console.warn('Adding endpoint to disconnected RTC Strategy');
+            return;
+        }
+        const clientStrat = new endpoint_1.RTCEndpoint(payload.rtc, payload.endpointIdentity);
+        if (__classPrivateFieldGet(this, _processAction)) {
+            clientStrat.receive(__classPrivateFieldGet(this, _processAction));
+        }
+        __classPrivateFieldGet(this, _rtcEndpointMap).set(endpointId, clientStrat);
+    }
+    async closeEndpoint(endpointId) {
+        __classPrivateFieldGet(this, _rtcEndpointMap).delete(endpointId);
+    }
+    isValidEndpointPayload(payload) {
+        const isObject = (x) => {
+            return typeof x === 'object' && x !== null;
+        };
+        return (isObject(payload) &&
+            isObject(payload.endpointIdentity) &&
+            isObject(payload.rtc) &&
+            typeof payload.endpointIdentity.endpointId === 'string');
+    }
+}
+exports.RTCStrategy = RTCStrategy;
+_processAction = new WeakMap(), _rtcEndpointMap = new WeakMap(), _connected = new WeakMap();
+exports.RTCInfo = { version: 1, minimumVersion: 0, type: 'rtc' };

package/src/api/interappbus/channel/protocols/strategy-types.d.ts

@@ -0,0 +1,13 @@
+import { MessagingProtocols } from '.';
+import { ClassicStrategy } from './classic/strategy';
+import CombinedStrategy from './combined/strategy';
+import { RTCStrategy } from './rtc/strategy';
+import { ChannelStrategy } from './strategy';
+declare type StrategyMap = {
+    rtc: RTCStrategy;
+    classic: ClassicStrategy;
+};
+export declare type StrategyByProtocol<T extends MessagingProtocols> = StrategyMap[T];
+export declare type PayloadTypeByStrategy<T extends ChannelStrategy<unknown>> = T extends ChannelStrategy<infer U> ? U : never;
+export declare type AnyStrategy = ClassicStrategy | RTCStrategy | CombinedStrategy<PayloadTypeByStrategy<RTCStrategy>, PayloadTypeByStrategy<ClassicStrategy>>;
+export {};

package/src/api/interappbus/channel/protocols/strategy-types.js

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

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

@@ -0,0 +1,15 @@
+import ProviderIdentity = OpenFin.ProviderIdentity;
+export interface ChannelStrategy<T extends unknown> {
+    onEndpointDisconnect(endpointId: string, listener: () => void): void;
+    receive(listener: (action: string, payload: any, identity: any) => Promise<any>): void;
+    send(endpointId: string, action: string, payload: any): Promise<any>;
+    closeEndpoint(endpointId: string): Promise<void>;
+    close(): Promise<void>;
+    isEndpointConnected(endpointId: string): boolean;
+    addEndpoint(endpointId: string, payload: T): void;
+    isValidEndpointPayload(payload: unknown): payload is T;
+}
+export declare type EndpointIdentity = OpenFin.ClientIdentity | ProviderIdentity;
+export declare type EndpointPayload = {
+    endpointIdentity: EndpointIdentity;
+};

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

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

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

@@ -0,0 +1,31 @@
+import { ChannelBase } from './channel';
+import Transport from '../../../transport/transport';
+import { AnyStrategy } from './protocols/strategy-types';
+import ProviderIdentity = OpenFin.ProviderIdentity;
+import ClientIdentity = OpenFin.ClientIdentity;
+export declare type ConnectionListener = (identity: ClientIdentity, connectionMessage?: any) => any;
+export declare type DisconnectionListener = (identity: ClientIdentity) => any;
+export declare class ChannelProvider extends ChannelBase {
+    #private;
+    private static removalMap;
+    private connectListener;
+    private disconnectListener;
+    get connections(): OpenFin.ClientIdentity[];
+    static handleClientDisconnection(channel: ChannelProvider, payload: any): void;
+    static setProviderRemoval(provider: ChannelProvider, remove: Function): void;
+    constructor(providerIdentity: ProviderIdentity, wire: Transport, strategy: AnyStrategy);
+    dispatch(to: OpenFin.ClientIdentity | OpenFin.Identity, action: string, payload?: any): Promise<any>;
+    protected processAction: (action: string, payload: any, senderIdentity: OpenFin.ClientIdentity | OpenFin.ClientIdentityMultiRuntime) => Promise<any>;
+    processConnection(senderId: OpenFin.ClientIdentity, payload: any): Promise<any>;
+    publish(action: string, payload: any): Promise<any>[];
+    onConnection(listener: ConnectionListener): void;
+    onDisconnection(listener: DisconnectionListener): void;
+    destroy(): Promise<void>;
+    private checkForClientConnection;
+    private isClientConnected;
+    private isLegacyClientConnected;
+    private handleMultiRuntimeLegacyClient;
+    private getEndpointIdForOpenFinId;
+    private static clientIdentityIncludesEndpointId;
+    private static clientIsMultiRuntime;
+}

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

@@ -0,0 +1,165 @@
+"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);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ChannelProvider = void 0;
+const channel_1 = require("./channel");
+const runtimeVersioning_1 = require("../../../util/runtimeVersioning");
+let ChannelProvider = /** @class */ (() => {
+    var _connections, _protectedObj, _strategy, _removeEndpoint, _close;
+    class ChannelProvider extends channel_1.ChannelBase {
+        constructor(providerIdentity, wire, strategy) {
+            super();
+            _connections.set(this, void 0);
+            _protectedObj.set(this, void 0);
+            _strategy.set(this, void 0);
+            _removeEndpoint.set(this, (identity) => {
+                const remainingConnections = this.connections.filter((clientIdentity) => clientIdentity.endpointId !== identity.endpointId);
+                __classPrivateFieldGet(this, _strategy).closeEndpoint(identity.endpointId);
+                __classPrivateFieldSet(this, _connections, remainingConnections);
+            });
+            // Must be bound.
+            this.processAction = async (action, payload, senderIdentity) => {
+                if (ChannelProvider.clientIsMultiRuntime(senderIdentity) &&
+                    !runtimeVersioning_1.runtimeUuidMeetsMinimumRuntimeVersion(senderIdentity.runtimeUuid, '18.87.56.0')) {
+                    this.handleMultiRuntimeLegacyClient(senderIdentity);
+                }
+                else {
+                    this.checkForClientConnection(senderIdentity);
+                }
+                return super.processAction(action, payload, senderIdentity);
+            };
+            _close.set(this, () => {
+                __classPrivateFieldGet(this, _strategy).close();
+                const remove = ChannelProvider.removalMap.get(this);
+                if (remove) {
+                    remove();
+                }
+            });
+            __classPrivateFieldSet(this, _protectedObj, new channel_1.ProtectedItems(providerIdentity, wire));
+            this.connectListener = () => undefined;
+            this.disconnectListener = () => undefined;
+            __classPrivateFieldSet(this, _connections, []);
+            __classPrivateFieldSet(this, _strategy, strategy);
+            strategy.receive(this.processAction);
+        }
+        get connections() {
+            return [...__classPrivateFieldGet(this, _connections)];
+        }
+        static handleClientDisconnection(channel, payload) {
+            const removeById = channel.connections.find((identity) => identity.endpointId === payload.endpointId);
+            if (removeById) {
+                __classPrivateFieldGet(channel, _removeEndpoint).call(channel, removeById);
+            }
+            else {
+                const multipleRemoves = channel.connections.filter((identity) => {
+                    return identity.uuid === payload.uuid && identity.name === payload.name;
+                });
+                multipleRemoves.forEach(__classPrivateFieldGet(channel, _removeEndpoint));
+            }
+            channel.disconnectListener(payload);
+        }
+        static setProviderRemoval(provider, remove) {
+            ChannelProvider.removalMap.set(provider, remove);
+        }
+        dispatch(to, action, payload) {
+            var _a;
+            const endpointId = (_a = to.endpointId) !== null && _a !== void 0 ? _a : this.getEndpointIdForOpenFinId(to, action);
+            if (endpointId && __classPrivateFieldGet(this, _strategy).isEndpointConnected(endpointId)) {
+                return __classPrivateFieldGet(this, _strategy).send(endpointId, action, payload);
+            }
+            return Promise.reject(new Error(`Client connection with identity uuid: ${to.uuid} / name: ${to.name} / endpointId: ${endpointId} no longer connected.`));
+        }
+        async processConnection(senderId, payload) {
+            __classPrivateFieldGet(this, _connections).push(senderId);
+            return this.connectListener(senderId, payload);
+        }
+        publish(action, payload) {
+            return this.connections.map((to) => __classPrivateFieldGet(this, _strategy).send(to.endpointId, action, payload));
+        }
+        onConnection(listener) {
+            this.connectListener = listener;
+        }
+        onDisconnection(listener) {
+            this.disconnectListener = listener;
+        }
+        async destroy() {
+            const protectedObj = __classPrivateFieldGet(this, _protectedObj);
+            const { channelName } = protectedObj.providerIdentity;
+            __classPrivateFieldSet(this, _connections, []);
+            await protectedObj.wire.sendAction('destroy-channel', { channelName });
+            __classPrivateFieldGet(this, _close).call(this);
+        }
+        checkForClientConnection(clientIdentity) {
+            if (!this.isClientConnected(clientIdentity)) {
+                throw new Error(`This action was sent from a client that is not connected to the provider.
+                    Client Identity: {uuid: ${clientIdentity.uuid}, name: ${clientIdentity.name}, endpointId: ${clientIdentity.endpointId}}`);
+            }
+        }
+        isClientConnected(clientIdentity) {
+            if (ChannelProvider.clientIdentityIncludesEndpointId(clientIdentity)) {
+                return this.connections.some((identity) => {
+                    return (
+                    // Might be redundant to check for uuid and name here after we get an endpointId match, but just in case
+                    identity.endpointId === clientIdentity.endpointId &&
+                        identity.uuid === clientIdentity.uuid &&
+                        identity.name === clientIdentity.name);
+                });
+            }
+            return this.isLegacyClientConnected(clientIdentity);
+        }
+        isLegacyClientConnected(clientIdentity) {
+            return this.connections.some((identity) => {
+                return identity.uuid === clientIdentity.uuid && identity.name === clientIdentity.name;
+            });
+        }
+        handleMultiRuntimeLegacyClient(senderIdentity) {
+            if (!this.isLegacyClientConnected(senderIdentity)) {
+                throw new Error(`This action was sent from a client that is not connected to the provider. Client Identity:
+                    {uuid: ${senderIdentity.uuid}, name: ${senderIdentity.name}, endpointId: ${senderIdentity.endpointId}}`);
+            }
+        }
+        getEndpointIdForOpenFinId(clientIdentity, action) {
+            var _a;
+            const matchingConnections = this.connections.filter((c) => c.name === clientIdentity.name && c.uuid === clientIdentity.uuid);
+            if (matchingConnections.length >= 2) {
+                const protectedObj = __classPrivateFieldGet(this, _protectedObj);
+                const { uuid, name } = clientIdentity;
+                const providerUuid = protectedObj === null || protectedObj === void 0 ? void 0 : protectedObj.providerIdentity.uuid;
+                const providerName = protectedObj === null || protectedObj === void 0 ? void 0 : protectedObj.providerIdentity.name;
+                // eslint-disable-next-line no-console
+                console.warn(`WARNING: Dispatch call may have unintended results. The "to" argument of your dispatch call is missing the
+                "endpointId" parameter. The identity you are dispatching to ({uuid: ${uuid}, name: ${name}})
+                has multiple channelClients for this channel. Your dispatched action: (${action}) from the provider:
+                ({uuid: ${providerUuid}, name: ${providerName}}) will only be processed by the most recently-created client.`);
+            }
+            // Pop to return the most recently created endpointId.
+            return (_a = matchingConnections.pop()) === null || _a === void 0 ? void 0 : _a.endpointId;
+        }
+        // eslint-disable-next-line class-methods-use-this
+        static clientIdentityIncludesEndpointId(subscriptionIdentity) {
+            return subscriptionIdentity.endpointId !== undefined;
+        }
+        // eslint-disable-next-line class-methods-use-this
+        static clientIsMultiRuntime(subscriptionIdentity) {
+            return subscriptionIdentity.runtimeUuid !== undefined;
+        }
+    }
+    _connections = new WeakMap(), _protectedObj = new WeakMap(), _strategy = new WeakMap(), _removeEndpoint = new WeakMap(), _close = new WeakMap();
+    // The following line should be changed following a typescript update.
+    // static #removalMap = new WeakMap<ChannelProvider, Function>();
+    ChannelProvider.removalMap = new WeakMap();
+    return ChannelProvider;
+})();
+exports.ChannelProvider = ChannelProvider;

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

@@ -0,0 +1,85 @@
+/// <reference types="node" />
+import { EventEmitter } from 'events';
+import { Base } from '../base';
+import Transport, { Message } from '../../transport/transport';
+import { Channel } from './channel/index';
+/**
+ * A messaging bus that allows for pub/sub messaging between different applications.
+ * @namespace
+ */
+export default class InterApplicationBus extends Base {
+    Channel: Channel;
+    events: {
+        subscriberAdded: string;
+        subscriberRemoved: string;
+    };
+    private refCounter;
+    protected emitter: EventEmitter;
+    on: any;
+    removeAllListeners: any;
+    constructor(wire: Transport);
+    /**
+     * Publishes a message to all applications running on OpenFin Runtime that
+     * are subscribed to the specified topic.
+     * @param { string } topic The topic on which the message is sent
+     * @param { any } message The message to be published. Can be either a primitive
+     * data type (string, number, or boolean) or composite data type (object, array)
+     * that is composed of other primitive or composite data types
+     * @return {Promise.<void>}
+     * @tutorial InterApplicationBus.publish
+     */
+    publish(topic: string, message: any): Promise<void>;
+    /**
+     * Sends a message to a specific application on a specific topic.
+     * @param { Identity } destination The identity of the application to which the message is sent
+     * @param { string } topic The topic on which the message is sent
+     * @param { any } message The message to be sent. Can be either a primitive data
+     * type (string, number, or boolean) or composite data type (object, array) that
+     * is composed of other primitive or composite data types
+     * @return {Promise.<void>}
+     * @tutorial InterApplicationBus.send
+     */
+    send(destination: {
+        uuid: string;
+        name?: string;
+    }, topic: string, message: any): Promise<void>;
+    /**
+     * Subscribes to messages from the specified application on the specified topic.
+     * @param { Identity } source This object is described in the Identity in the typedef
+     * @param { string } topic The topic on which the message is sent
+     * @param { function } listener A function that is called when a message has
+     * been received. It is passed the message, uuid and name of the sending application.
+     * The message can be either a primitive data type (string, number, or boolean) or
+     * composite data type (object, array) that is composed of other primitive or composite
+     * data types
+     * @return {Promise.<void>}
+     * @tutorial InterApplicationBus.subscribe
+     */
+    subscribe(source: {
+        uuid: string;
+        name?: string;
+    }, topic: string, listener: any): Promise<void>;
+    /**
+     * Unsubscribes to messages from the specified application on the specified topic.
+     * @param { Identity } source This object is described in the Identity in the typedef
+     * @param { string } topic The topic on which the message is sent
+     * @param { function } listener A callback previously registered with subscribe()
+     * @return {Promise.<void>}
+     * @tutorial InterApplicationBus.unsubscribe
+     */
+    unsubscribe(source: {
+        uuid: string;
+        name?: string;
+    }, topic: string, listener: any): Promise<void>;
+    private processMessage;
+    private emitSubscriverEvent;
+    protected createSubscriptionKey(uuid: string, name: string, topic: string): string;
+    protected onmessage(message: Message<InterAppPayload>): boolean;
+}
+export declare class InterAppPayload {
+    sourceUuid: string;
+    sourceWindowName: string;
+    topic: string;
+    destinationUuid?: string;
+    message?: any;
+}

package/src/api/interappbus/index.js

@@ -0,0 +1,175 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InterAppPayload = void 0;
+const events_1 = require("events");
+const base_1 = require("../base");
+const ref_counter_1 = require("../../util/ref-counter");
+const index_1 = require("./channel/index");
+const validate_1 = require("../../util/validate");
+/**
+ * A messaging bus that allows for pub/sub messaging between different applications.
+ * @namespace
+ */
+class InterApplicationBus extends base_1.Base {
+    constructor(wire) {
+        super(wire);
+        this.events = {
+            subscriberAdded: 'subscriber-added',
+            subscriberRemoved: 'subscriber-removed'
+        };
+        this.refCounter = new ref_counter_1.default();
+        this.Channel = new index_1.Channel(wire);
+        this.emitter = new events_1.EventEmitter();
+        wire.registerMessageHandler(this.onmessage.bind(this));
+        this.on = this.emitter.on.bind(this.emitter);
+        this.removeAllListeners = this.emitter.removeAllListeners.bind(this.emitter);
+    }
+    /**
+     * Publishes a message to all applications running on OpenFin Runtime that
+     * are subscribed to the specified topic.
+     * @param { string } topic The topic on which the message is sent
+     * @param { any } message The message to be published. Can be either a primitive
+     * data type (string, number, or boolean) or composite data type (object, array)
+     * that is composed of other primitive or composite data types
+     * @return {Promise.<void>}
+     * @tutorial InterApplicationBus.publish
+     */
+    publish(topic, message) {
+        return this.wire
+            .sendAction('publish-message', {
+            topic,
+            message,
+            sourceWindowName: this.me.name
+        })
+            .then(() => undefined);
+    }
+    /**
+     * Sends a message to a specific application on a specific topic.
+     * @param { Identity } destination The identity of the application to which the message is sent
+     * @param { string } topic The topic on which the message is sent
+     * @param { any } message The message to be sent. Can be either a primitive data
+     * type (string, number, or boolean) or composite data type (object, array) that
+     * is composed of other primitive or composite data types
+     * @return {Promise.<void>}
+     * @tutorial InterApplicationBus.send
+     */
+    async send(destination, topic, message) {
+        const errorMsg = validate_1.validateIdentity(destination);
+        if (errorMsg) {
+            throw new Error(errorMsg);
+        }
+        await this.wire.sendAction('send-message', {
+            destinationUuid: destination.uuid,
+            destinationWindowName: destination.name,
+            topic,
+            message,
+            sourceWindowName: this.me.name
+        });
+    }
+    /**
+     * Subscribes to messages from the specified application on the specified topic.
+     * @param { Identity } source This object is described in the Identity in the typedef
+     * @param { string } topic The topic on which the message is sent
+     * @param { function } listener A function that is called when a message has
+     * been received. It is passed the message, uuid and name of the sending application.
+     * The message can be either a primitive data type (string, number, or boolean) or
+     * composite data type (object, array) that is composed of other primitive or composite
+     * data types
+     * @return {Promise.<void>}
+     * @tutorial InterApplicationBus.subscribe
+     */
+    subscribe(source, topic, listener) {
+        const subKey = this.createSubscriptionKey(source.uuid, source.name || '*', topic);
+        const sendSubscription = () => {
+            return this.wire.sendAction('subscribe', {
+                sourceUuid: source.uuid,
+                sourceWindowName: source.name || '*',
+                topic,
+                destinationWindowName: this.me.name
+            });
+        };
+        const alreadySubscribed = () => {
+            return Promise.resolve();
+        };
+        this.emitter.on(subKey, listener);
+        return this.refCounter.actOnFirst(subKey, sendSubscription, alreadySubscribed);
+    }
+    /**
+     * Unsubscribes to messages from the specified application on the specified topic.
+     * @param { Identity } source This object is described in the Identity in the typedef
+     * @param { string } topic The topic on which the message is sent
+     * @param { function } listener A callback previously registered with subscribe()
+     * @return {Promise.<void>}
+     * @tutorial InterApplicationBus.unsubscribe
+     */
+    unsubscribe(source, topic, listener) {
+        const sourceWindowName = source.name || '*';
+        const subKey = this.createSubscriptionKey(source.uuid, sourceWindowName, topic);
+        const sendUnsubscription = () => {
+            return this.wire.sendAction('unsubscribe', {
+                sourceUuid: source.uuid,
+                sourceWindowName,
+                topic,
+                destinationWindowName: this.me.name
+            });
+        };
+        const dontSendUnsubscription = () => {
+            return new Promise((r) => r).then(() => undefined);
+        };
+        this.emitter.removeListener(subKey, listener);
+        return this.refCounter.actOnLast(subKey, sendUnsubscription, dontSendUnsubscription);
+    }
+    processMessage(message) {
+        const { payload: { message: payloadMessage, sourceWindowName, sourceUuid, topic } } = message;
+        const keys = [
+            this.createSubscriptionKey(sourceUuid, sourceWindowName, topic),
+            this.createSubscriptionKey(sourceUuid, '*', topic),
+            this.createSubscriptionKey('*', '*', topic)
+        ];
+        const idOfSender = { uuid: sourceUuid, name: sourceWindowName };
+        keys.forEach((key) => {
+            this.emitter.emit(key, payloadMessage, idOfSender);
+        });
+    }
+    emitSubscriverEvent(type, message) {
+        const { payload: { targetName: name, uuid, topic } } = message;
+        const payload = { name, uuid, topic };
+        this.emitter.emit(type, payload);
+    }
+    // eslint-disable-next-line class-methods-use-this
+    createSubscriptionKey(uuid, name, topic) {
+        const n = name || '*';
+        if (!(uuid && n && topic)) {
+            throw new Error('Missing uuid, name, or topic string');
+        }
+        return createKey(uuid, n, topic);
+    }
+    onmessage(message) {
+        const { action } = message;
+        switch (action) {
+            case 'process-message':
+                this.processMessage(message);
+                break;
+            case this.events.subscriberAdded:
+                this.emitSubscriverEvent(this.events.subscriberAdded, message);
+                break;
+            case this.events.subscriberRemoved:
+                this.emitSubscriverEvent(this.events.subscriberRemoved, message);
+                break;
+            default:
+                break;
+        }
+        return true;
+    }
+}
+exports.default = InterApplicationBus;
+class InterAppPayload {
+}
+exports.InterAppPayload = InterAppPayload;
+function createKey(...toHash) {
+    return toHash
+        .map((item) => {
+        return Buffer.from(`${item}`).toString('base64');
+    })
+        .join('/');
+}

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

@@ -0,0 +1,37 @@
+import { Base } from '../base';
+import { InteropBroker } from './InteropBroker';
+import { InteropClient } from './InteropClient';
+/**
+ * @typedef { object } InteropConfig
+ * @summary Information relevant to the Interop Broker.
+ * @property {string} [currentContextGroup] Context Group for the client. (green, yellow, red, etc.)
+ * @property {string} [providerId] When provided, automatically connects the client to the specified provider uuid
+ */
+/**
+ * Manages creation of Interop Brokers and Interop Clients. These APIs are called under-the-hood in Platforms.
+ * @namespace
+ * @alias Interop
+ */
+export default class InteropModule extends Base {
+    /**
+     * Initializes an Interop Broker. This is called under-the-hood for Platforms.
+     * @param { string } name - Name of the Interop Broker.
+     * @param { OverrideCallback<InteropBroker> } [override] - A callback function that can be used to extend or replace default Interop Broker behavior.
+     * @return {Promise.<InteropBroker>}
+     * @tutorial Interop.init
+     * @experimental
+     * @static
+     */
+    init(name: string, override?: OpenFin.OverrideCallback<InteropBroker>): Promise<InteropBroker>;
+    /**
+     * Connects a client to an Interop broker. This is called under-the-hood for Views in a Platform.
+     * @param { string } name - The name of the Interop Broker to connect to. For Platforms, this will default to the uuid of the Platform.
+     * @param { InteropConfig } [interopConfig] - Information relevant to the Interop Broker. Typically a declaration of
+     * what context(s) the entity wants to subscribe to, and the current Context Group of the entity.
+     * @return {InteropClient}
+     * @tutorial Interop.connectSync
+     * @experimental
+     * @static
+     */
+    connectSync(name: string, interopConfig: OpenFin.InteropConfig): InteropClient;
+}