@openfin/core 25.68.26

package/src/api/interop/InteropClient.js

@@ -0,0 +1,450 @@
+"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 _clientPromise, _sessionContextGroups;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InteropClient = void 0;
+const base_1 = require("../base");
+const SessionContextGroupClient_1 = require("./SessionContextGroupClient");
+const utils_1 = require("./utils");
+/**
+ * @typedef { object } Intent
+ * @summary The combination of an action and a context that is passed to an application for resolution.
+ * @property { string } name Name of the intent.
+ * @property { Context } context Data associated with the intent
+ */
+/**
+ * @typedef { object } Subscription
+ * @summary Object returned when subscribing a handler.
+ * @property { function } unsubscribe Function to unsubscribe the handler.
+ */
+/**
+ * @typedef { function } ContextHandler
+ * @summary Subscription function for addContextHandler.
+ */
+/**
+ * @typedef { function } IntentHandler
+ * @summary Subscription function for registerIntentHandler
+ */
+/**
+ * @typedef { object } ClientIdentity
+ * @summary The Identity for a Channel Client. Includes endpointId to differentiate between different connections for an entity.
+ * @property {string} uuid GUID of an application.
+ * @property {string} name Name of an entity in an application.
+ * @property {string} endpointId Unique differentiator for different Channel connections for an entity.
+ */
+/**
+ * @typedef { object } ContextGroupInfo
+ * @summary Information for a Context Group. Contains metadata for displaying the group properly.
+ * @property {string} id Name of the context group
+ * @property {DisplayMetadata} displayMetadata Metadata for the Context Group. Contains the group's human-readable name, color, and an image, as defined by the Interop Broker.
+ */
+/**
+ * @typedef { object } DisplayMetadata
+ * @summary The display data for a Context Group.
+ * @property {string} name A user-readable name for this context group, e.g: `"Red"`
+ * @property {string} [color] The color that should be associated within this context group when displaying this context group in a UI, e.g: `0xFF0000`.
+ * @property {string} [glyph] A URL of an image that can be used to display this context group
+ */
+/**
+ * @typedef { object } Context
+ * @summary Data passed between entities and applications.
+ * @property {object} [id] An object containing string key-value pairs for the bulk of the data for the context. Differs between context types.
+ * @property {string} [name] User-readable name for the incoming context.
+ * @property {string} type Conserved type for the context (e.g. `instrument` or `country`)
+ */
+/**
+ * @typedef { object } ContextForIntent
+ * @summary Data passed between entities and applications, including an optional metadata.
+ * @property {object} [id] An object containing string key-value pairs for the bulk of the data for the context. Differs between context types.
+ * @property {string} [name] User-readable name for the incoming context.
+ * @property {string} type Conserved type for the context (e.g. `instrument` or `country`)
+ * @property {any} [metadata]
+ */
+/**
+ * @typedef { object } SessionContextGroup
+ * @summary An instance of a SessionContextGroup
+ * @property {string} id The SessionContextGroup's id.
+ * @property {setContext} setContext Sets a context of a certain type
+ * @property {getCurrentContext} getCurrentContext Gets the currently set context of a certain type
+ * @property {addContextHandler} addContextHandler Adds a handler for context change.
+ */
+/**
+ * @typedef {function} setContext
+ * @summary A SessionContextGroup instance method for setting a context in the SessionContextGroup.
+ * @param {Context} context The Context to be set.
+ * @return {Promise<void>}
+ */
+/**
+ * @typedef {function} getCurrentContext
+ * @summary A SessionContextGroup instance method for getting the current context of a certain type.
+ * @param {string} [contextType] The Context Type to get. If not specified the last contextType set would get used.
+ * @return {Promise<Context>}
+ */
+/**
+ * @typedef {function} addContextHandler
+ * @summary A SessionContextGroup instance method for adding a handler for context change.
+ * @param {ContextHandler} contextHandler The callback to be invoked. Is invoked when (a) the context changes or (b) immediately after getting created if the context is already set.
+ * @param {string} [contextType] The context type this handler should listen to. If not specified, a global handler for all context types will get created. Only one global handler is allowed per SessionContextGroup.
+ * @return {Promise<void>}
+ */
+/**
+ * {@link https://developers.openfin.co/of-docs/docs/enable-color-linking **THE INTEROP API IS EXPERIMENTAL. IF YOU WOULD LIKE TO USE IT, PLEASE USE OUR DEFAULT IMPLEMENTATION IN BROWSER**}
+ *
+ * The Interop Client API is broken up into two groups:
+ *
+ * **Content Facing APIs** - For Application Developers putting Views into a Platform Window, who care about Context. These are APIs that send out and receive the Context data that flows between applications. Think of this as the Water in the Interop Pipes.
+ *
+ * **Context Grouping APIs** - For Platform Developers, to add and remove Views to and from Context Groups. These APIs are utilized under-the-hood in Platforms, so they don't need to be used to participate in Interop. These are the APIs that decide which entities the context data flows between. Think of these as the valves or pipes that control the flow of Context Data for Interop.
+ *
+ * ---
+ *
+ * All APIs are available at the `fin.me.interop` namespace.
+ *
+ * ---
+ *
+ * **You only need 2 things to participate in Interop Context Grouping:**
+ * * A Context Handler for incoming context: {@link InteropClient#addContextHandler addContextHandler(handler, contextType?)}
+ * * Call setContext on your context group when you want to share context with other group members: {@link InteropClient#setContext setContext(context)}
+ *
+ * ---
+ *
+ * ##### Constructor
+ * Returned by {@link Interop.connectSync Interop.connectSync}.
+ *
+ * ---
+ *
+ * ##### Interop methods intended for Views
+ *
+ *
+ * **Context Groups API**
+ *  * {@link InteropClient#addContextHandler addContextHandler(handler, contextType?)}
+ *  * {@link InteropClient#setContext setContext(context)}
+ *  * {@link InteropClient#getCurrentContext getCurrentContext(contextType?)}
+ *  * {@link InteropClient#joinSessionContextGroup joinSessionContextGroup(sessionContextGroupId)}
+ *
+ *
+ * **Intents API**
+ *  * {@link InteropClient#fireIntent fireIntent(intent)}
+ *  * {@link InteropClient#registerIntentHandler registerIntentHandler(intentHandler, intentName)}
+ *  * {@link InteropClient#getInfoForIntent getInfoForIntent(infoForIntentOptions)}
+ *  * {@link InteropClient#getInfoForIntentsByContext getInfoForIntentsByContext(context)}
+ *  * {@link InteropClient#fireIntentForContext fireIntentForContext(contextForIntent)}
+ *
+ * ##### Interop methods intended for Windows
+ *  * {@link InteropClient#getContextGroups getContextGroups()}
+ *  * {@link InteropClient#joinContextGroup joinContextGroup(contextGroupId, target?)}
+ *  * {@link InteropClient#removeFromContextGroup removeFromContextGroup(target?)}
+ *  * {@link InteropClient#getInfoForContextGroup getInfoForContextGroup(contextGroupId)}
+ *  * {@link InteropClient#getAllClientsInContextGroup getAllClientsInContextGroup(contextGroupId)}
+ *
+
+ *
+ * @hideconstructor
+ * @class
+ */
+class InteropClient extends base_1.Base {
+    constructor(wire, name, interopConfig) {
+        super(wire);
+        _clientPromise.set(this, void 0);
+        _sessionContextGroups.set(this, void 0);
+        __classPrivateFieldSet(this, _sessionContextGroups, new Map());
+        __classPrivateFieldSet(this, _clientPromise, this.wire.environment.whenReady().then(() => {
+            return this.fin.InterApplicationBus.Channel.connect(`interop-broker-${name}`, {
+                payload: interopConfig
+            });
+        }));
+    }
+    /*
+    Client APIs
+    */
+    /**
+     * Sets a context for the context group of the current entity.
+     * @param { Context } context - New context to set.
+     * @return { Promise<void> }
+     * @tutorial interop.setContext
+     */
+    async setContext(context) {
+        this.wire.sendAction('interop-client-set-context').catch((e) => {
+            // don't expose, analytics-only call
+        });
+        const client = await __classPrivateFieldGet(this, _clientPromise);
+        return client.dispatch('setContext', { context });
+    }
+    /**
+     * Add a context handler for incoming context. If an entity is part of a context group, and then sets its context handler, it will receive all of its declared contexts.
+     * @param { ContextHandler } handler - Handler for incoming context.
+     * @param { string } [contextType] - The type of context you wish to handle.
+     * @return { Promise<Subscription> }
+     * @tutorial interop.addContextHandler
+     */
+    async addContextHandler(handler, contextType) {
+        this.wire.sendAction('interop-client-add-context-handler').catch((e) => {
+            // don't expose, analytics-only call
+        });
+        const client = await __classPrivateFieldGet(this, _clientPromise);
+        let handlerId;
+        if (contextType) {
+            handlerId = `invokeContextHandler-${contextType}-${utils_1.generateId()}`;
+            console.warn(`Warning: By providing a contextType (${contextType}), you are using the experimental addContextHandler. To avoid issues, make sure you are adding your context handlers at the top level in your application.`);
+        }
+        else {
+            handlerId = 'invokeContextHandler';
+        }
+        const wrappedHandler = utils_1.wrapContextHandler(handler, handlerId);
+        client.register(handlerId, wrappedHandler);
+        await client.dispatch('contextHandlerRegistered', { handlerId, contextType });
+        return {
+            unsubscribe: async () => {
+                client.remove(handlerId);
+                await client.dispatch('removeContextHandler', { handlerId });
+            }
+        };
+    }
+    /*
+    Platform Window APIs
+    */
+    /**
+     * Returns the Interop-Broker-defined context groups available for an entity to join.
+     * Used by Platform Windows.
+     * @return { Promise<ContextGroupInfo[]>}
+     * @tutorial interop.getContextGroups
+     */
+    async getContextGroups() {
+        this.wire.sendAction('interop-client-get-context-groups').catch((e) => {
+            // don't expose, analytics-only call
+        });
+        const client = await __classPrivateFieldGet(this, _clientPromise);
+        return client.dispatch('getContextGroups');
+    }
+    /**
+     * Join all Interop Clients at the given identity to context group `contextGroupId`.
+     * If no target is specified, it adds the sender to the context group.
+     * Because multiple Channel connections/Interop Clients can potentially exist at a `uuid`/`name` combo, we currently join all Channel connections/Interop Clients at the given identity to the context group.
+     * If an `endpointId` is provided (which is unlikely, unless the call is coming from an external adapter), then we only join that single connection to the context group.
+     * For all intents and purposes, there will only be 1 connection present in Platform and Browser implmentations, so this point is more-or-less moot.
+     * Used by Platform Windows.
+     * @param { string } contextGroupId - Id of the context group.
+     * @param { Identity } [target] - Identity of the entity you wish to join to a context group.
+     * @return { Promise<void>}
+     * @tutorial interop.joinContextGroup
+     */
+    async joinContextGroup(contextGroupId, target) {
+        this.wire.sendAction('interop-client-join-context-group').catch((e) => {
+            // don't expose, analytics-only call
+        });
+        const client = await __classPrivateFieldGet(this, _clientPromise);
+        if (!contextGroupId) {
+            throw new Error('No contextGroupId specified for joinContextGroup.');
+        }
+        return client.dispatch('joinContextGroup', { contextGroupId, target });
+    }
+    /**
+     * Removes the specified target from a context group.
+     * If no target is specified, it removes the sender from their context group.
+     * Used by Platform Windows.
+     * @param { Identity } [target] - Identity of the entity you wish to join to a context group.
+     * @return { Promise<void>}
+     * @tutorial interop.removeFromContextGroup
+     */
+    async removeFromContextGroup(target) {
+        this.wire.sendAction('interop-client-remove-from-context-group').catch((e) => {
+            // don't expose, analytics-only call
+        });
+        const client = await __classPrivateFieldGet(this, _clientPromise);
+        return client.dispatch('removeFromContextGroup', { target });
+    }
+    /**
+     * Gets all clients for a context group.
+     * Used by Platform Windows.
+     * @param { string } contextGroupId - The id of context group you wish to get clients for.
+     * @return { Promise<ClientIdentity[]>}
+     * @tutorial interop.getAllClientsInContextGroup
+     */
+    async getAllClientsInContextGroup(contextGroupId) {
+        this.wire.sendAction('interop-client-get-all-clients-in-context-group').catch((e) => {
+            // don't expose, analytics-only call
+        });
+        const client = await __classPrivateFieldGet(this, _clientPromise);
+        if (!contextGroupId) {
+            throw new Error('No contextGroupId specified for getAllClientsInContextGroup.');
+        }
+        return client.dispatch('getAllClientsInContextGroup', { contextGroupId });
+    }
+    /**
+     * Gets display info for a context group
+     * Used by Platform Windows.
+     * @param { string } contextGroupId - The id of context group you wish to get display info for.
+     * @return { Promise<ContextGroupInfo>}
+     * @tutorial interop.getInfoForContextGroup
+     */
+    async getInfoForContextGroup(contextGroupId) {
+        this.wire.sendAction('interop-client-get-info-for-context-group').catch((e) => {
+            // don't expose, analytics-only call
+        });
+        const client = await __classPrivateFieldGet(this, _clientPromise);
+        if (!contextGroupId) {
+            throw new Error('No contextGroupId specified for getInfoForContextGroup.');
+        }
+        return client.dispatch('getInfoForContextGroup', { contextGroupId });
+    }
+    /**
+     * Sends an intent to the Interop Broker to resolve.
+     * @param { Intent } intent - The combination of an action and a context that is passed to an application for resolution.
+     * @return { Promise<unknown>}
+     * @tutorial interop.fireIntent
+     * @experimental
+     */
+    async fireIntent(intent) {
+        this.wire.sendAction('interop-client-fire-intent').catch((e) => {
+            // don't expose, this is only for api analytics purposes
+        });
+        const client = await __classPrivateFieldGet(this, _clientPromise);
+        return client.dispatch('fireIntent', intent);
+    }
+    /**
+     * Adds an intent handler for incoming intents. The last intent sent of the name subscribed to will be received.
+     * @param { IntentHandler } handler - Registered function meant to handle a specific intent type.
+     * @param { string } intentName - The name of an intent.
+     * @return { Promise<Subscription> }
+     * @tutorial interop.registerIntentHandler
+     * @experimental
+     */
+    async registerIntentHandler(handler, intentName) {
+        this.wire.sendAction('interop-client-register-intent-handler').catch((e) => {
+            // don't expose, this is only for api analytics purposes
+        });
+        const client = await __classPrivateFieldGet(this, _clientPromise);
+        const handlerId = `intent-handler-${intentName}`;
+        const wrappedHandler = this.wrapIntentHandler(handler, handlerId);
+        try {
+            await client.register(handlerId, wrappedHandler);
+            await client.dispatch('intentHandlerRegistered', { handlerId });
+        }
+        catch (error) {
+            throw new Error('Unable to register intent handler');
+        }
+        return {
+            unsubscribe: async () => {
+                client.remove(handlerId);
+            }
+        };
+    }
+    /**
+     * Gets the last context of the Context Group currently subscribed to. It takes an optional Context Type and returns the
+     * last context of that type.
+     * @param { string } [contextType]
+     * @return { Promise<Context> }
+     * @tutorial interop.getCurrentContext
+     * @experimental
+     */
+    async getCurrentContext(contextType) {
+        this.wire.sendAction('interop-client-get-current-context').catch((e) => {
+            // don't expose, analytics-only call
+        });
+        const client = await __classPrivateFieldGet(this, _clientPromise);
+        return client.dispatch('getCurrentContext', { contextType });
+    }
+    /**
+     * Get information for a particular Intent from the Interop Broker.
+     * @param { InfoForIntentOptions } options
+     * @return { Promise<unknown> }
+     * @tutorial interop.getInfoForIntent
+     * @experimental
+     */
+    async getInfoForIntent(options) {
+        this.wire.sendAction('interop-client-get-info-for-intent').catch((e) => {
+            // don't expose, analytics-only call
+        });
+        const client = await __classPrivateFieldGet(this, _clientPromise);
+        return client.dispatch('getInfoForIntent', options);
+    }
+    /**
+     * Get information from the Interop Broker on all Intents that are meant to handle a particular context.
+     * @param { Context } context
+     * @return { Promise<unknown> }
+     * @tutorial interop.getInfoForIntentsByContext
+     * @experimental
+     */
+    async getInfoForIntentsByContext(context) {
+        this.wire.sendAction('interop-client-get-info-for-intents-by-context').catch((e) => {
+            // don't expose, analytics-only call
+        });
+        const client = await __classPrivateFieldGet(this, _clientPromise);
+        return client.dispatch('getInfoForIntentsByContext', context);
+    }
+    /**
+     * Sends a Context that will be resolved to an Intent by the Interop Broker.
+     * This context accepts a metadata property.
+     * @param { ContextForIntent } context
+     * @return { Promise<unknown> }
+     * @tutorial interop.fireIntentForContext
+     * @experimental
+     */
+    async fireIntentForContext(context) {
+        this.wire.sendAction('interop-client-fire-intent-for-context').catch((e) => {
+            // don't expose, analytics-only call
+        });
+        const client = await __classPrivateFieldGet(this, _clientPromise);
+        return client.dispatch('fireIntentForContext', context);
+    }
+    /**
+     * Join the current entity to session context group `sessionContextGroupId` and return a sessionContextGroup instance.
+     * If the sessionContextGroup doesn't exist, one will get created.
+     * Session Context Groups do not persist between runs and aren't present on snapshots.
+     * @param { string } sessionContextGroupId - Id of the context group.
+     * @return { Promise<SessionContextGroup>}
+     * @tutorial interop.joinSessionContextGroup
+     * @experimental
+     */
+    async joinSessionContextGroup(sessionContextGroupId) {
+        try {
+            const currentSessionContextGroup = __classPrivateFieldGet(this, _sessionContextGroups).get(sessionContextGroupId);
+            if (currentSessionContextGroup) {
+                return currentSessionContextGroup.getUserInstance();
+            }
+            const client = await __classPrivateFieldGet(this, _clientPromise);
+            const { hasConflict } = await client.dispatch('sessionContextGroup:createIfNeeded', {
+                sessionContextGroupId
+            });
+            if (hasConflict) {
+                console.warn(`A (non-session) context group with the name "${sessionContextGroupId}" already exists. If you are trying to join a Context Group, call joinContextGroup instead.`);
+            }
+            const newSessionContextGroup = new SessionContextGroupClient_1.default(this.wire, __classPrivateFieldGet(this, _clientPromise), sessionContextGroupId);
+            __classPrivateFieldGet(this, _sessionContextGroups).set(sessionContextGroupId, newSessionContextGroup);
+            return newSessionContextGroup.getUserInstance();
+        }
+        catch (error) {
+            console.error(`Error thrown trying to create Session Context Group with id "${sessionContextGroupId}": ${error}`);
+            throw error;
+        }
+    }
+    /*
+    Internal Utilties
+    */
+    // eslint-disable-next-line class-methods-use-this
+    wrapIntentHandler(handler, handlerId) {
+        return async (intent) => {
+            try {
+                await handler(intent);
+            }
+            catch (error) {
+                console.error(`Error thrown by handler ${handlerId}: ${error}`);
+                throw error;
+            }
+        };
+    }
+}
+exports.InteropClient = InteropClient;
+_clientPromise = new WeakMap(), _sessionContextGroups = new WeakMap();

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

@@ -0,0 +1,26 @@
+import type { ChannelProvider } from '../interappbus/channel/provider';
+export default class SessionContextGroupBroker {
+    id: string;
+    private contextGroupMap;
+    private provider;
+    private clients;
+    private lastContext;
+    constructor(provider: ChannelProvider, id: string);
+    registerListeners(): void;
+    getCurrentContext(payload: {
+        type?: string;
+    }): OpenFin.Context | undefined;
+    setContext(payload: {
+        context: OpenFin.Context;
+    }, clientIdentity: OpenFin.ClientIdentity): void;
+    private getClientState;
+    handlerAdded(payload: {
+        handlerId: string;
+        contextType?: string;
+    }, clientIdentity: OpenFin.ClientIdentity): void;
+    handlerRemoved(payload: {
+        handlerId: string;
+    }, clientIdentity: OpenFin.ClientIdentity): void;
+    registerNewClient(clientIdentity: OpenFin.ClientIdentity): void;
+    onDisconnection(clientIdentity: OpenFin.ClientIdentity): void;
+}

package/src/api/interop/SessionContextGroupBroker.js

@@ -0,0 +1,107 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const _1 = require(".");
+class SessionContextGroupBroker {
+    constructor(provider, id) {
+        this.provider = provider;
+        this.id = id;
+        this.lastContext = undefined;
+        this.contextGroupMap = new Map();
+        this.clients = new Map();
+        this.registerListeners();
+    }
+    registerListeners() {
+        this.provider.register(`sessionContextGroup:getContext-${this.id}`, this.getCurrentContext.bind(this));
+        this.provider.register(`sessionContextGroup:setContext-${this.id}`, this.setContext.bind(this));
+        this.provider.register(`sessionContextGroup:handlerAdded-${this.id}`, this.handlerAdded.bind(this));
+        this.provider.register(`sessionContextGroup:handlerRemoved-${this.id}`, this.handlerRemoved.bind(this));
+    }
+    getCurrentContext(payload) {
+        return payload.type ? this.contextGroupMap.get(payload.type) : this.lastContext;
+    }
+    setContext(payload, clientIdentity) {
+        const { context } = payload;
+        const contextIntegrityCheckResult = _1.InteropBroker.checkContextIntegrity(context);
+        if (contextIntegrityCheckResult.isValid === false) {
+            throw new Error(`Failed to set Context - bad Context. Reason: ${contextIntegrityCheckResult.reason}. Context: ${JSON.stringify(context)}`);
+        }
+        const clientState = this.getClientState(clientIdentity);
+        if (!clientState) {
+            // This shouldn't get hit.
+            throw new Error(`Client with Identity: ${clientIdentity.uuid} ${clientIdentity.name} not in Session Client State Map`);
+        }
+        // set the context
+        this.contextGroupMap.set(context.type, context);
+        this.lastContext = context;
+        const clientSubscriptionStates = Array.from(this.clients.values());
+        clientSubscriptionStates.forEach((client) => {
+            var _a;
+            // eslint-disable-next-line no-unused-expressions
+            (_a = client.contextHandlers.get(context.type)) === null || _a === void 0 ? void 0 : _a.forEach((handlerId) => {
+                this.provider.dispatch(client.clientIdentity, handlerId, context);
+            });
+            if (client.globalHandler) {
+                this.provider.dispatch(client.clientIdentity, client.globalHandler, context);
+            }
+        });
+    }
+    getClientState(id) {
+        return this.clients.get(id.endpointId);
+    }
+    handlerAdded(payload, clientIdentity) {
+        const { handlerId, contextType } = payload;
+        const clientSubscriptionState = this.getClientState(clientIdentity);
+        if (!clientSubscriptionState) {
+            throw new Error(`Client with Identity: ${clientIdentity.uuid} ${clientIdentity.name} not in Client State Map`);
+        }
+        if (contextType) {
+            const currentHandlerList = clientSubscriptionState.contextHandlers.get(contextType) || [];
+            clientSubscriptionState.contextHandlers.set(contextType, [...currentHandlerList, handlerId]);
+            const currentContext = this.contextGroupMap.get(contextType);
+            if (currentContext) {
+                this.provider.dispatch(clientIdentity, handlerId, currentContext);
+            }
+        }
+        else {
+            clientSubscriptionState.globalHandler = handlerId;
+            [...this.contextGroupMap.keys()].forEach((currentContextType) => {
+                const currentContext = this.contextGroupMap.get(currentContextType);
+                if (currentContext) {
+                    this.provider.dispatch(clientIdentity, handlerId, currentContext);
+                }
+            });
+        }
+    }
+    handlerRemoved(payload, clientIdentity) {
+        const { handlerId } = payload;
+        const client = this.clients.get(clientIdentity.endpointId);
+        if (client) {
+            Array.from(client.contextHandlers).forEach(([, handlers]) => {
+                const index = handlers.indexOf(handlerId);
+                if (index > -1) {
+                    handlers.splice(index, 1);
+                }
+            });
+            if (client.globalHandler === handlerId) {
+                client.globalHandler = undefined;
+            }
+        }
+        else {
+            console.warn(`Trying to remove a handler from a client that isn't mapped. handlerId: ${handlerId}. clientIdentity: ${clientIdentity}`);
+        }
+    }
+    registerNewClient(clientIdentity) {
+        if (!this.clients.has(clientIdentity.endpointId)) {
+            const clientSubscriptionState = {
+                contextHandlers: new Map(),
+                clientIdentity,
+                globalHandler: undefined
+            };
+            this.clients.set(clientIdentity.endpointId, clientSubscriptionState);
+        }
+    }
+    onDisconnection(clientIdentity) {
+        this.clients.delete(clientIdentity.endpointId);
+    }
+}
+exports.default = SessionContextGroupBroker;

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

@@ -0,0 +1,20 @@
+import Transport from '../../transport/transport';
+import { Base } from '../base';
+export default class SessionContextGroupClient extends Base {
+    #private;
+    id: string;
+    constructor(wire: Transport, client: Promise<OpenFin.ChannelClient>, id: string);
+    /**
+     * Sets a context for the session context group.
+     * @param { Context } context - New context to set.
+     * @return { Promise<void> }
+     * @tutorial interop.setContext
+     */
+    setContext(context: OpenFin.Context): Promise<void>;
+    getCurrentContext(type?: string): Promise<OpenFin.Context>;
+    addContextHandler(contextHandler: OpenFin.ContextHandler, contextType?: string): Promise<{
+        unsubscribe: () => void;
+    }>;
+    private createUnsubscribeCb;
+    getUserInstance(): OpenFin.SessionContextGroup;
+}