@openfin/core 33.76.31 → 33.76.38

package/src/api/interop/InteropBroker.js

@@ -1,1085 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.InteropBroker = void 0;
-const base_1 = require("../base");
-const SessionContextGroupBroker_1 = require("./SessionContextGroupBroker");
-const utils_1 = require("./utils");
-const lodash_1 = require("lodash");
-const PrivateChannelProvider_1 = require("./fdc3/PrivateChannelProvider");
-let contextGroups = [
-    {
-        id: 'green',
-        displayMetadata: {
-            color: '#00CC88',
-            name: 'green'
-        }
-    },
-    {
-        id: 'purple',
-        displayMetadata: {
-            color: '#8C61FF',
-            name: 'purple'
-        }
-    },
-    {
-        id: 'orange',
-        displayMetadata: {
-            color: '#FF8C4C',
-            name: 'orange'
-        }
-    },
-    {
-        id: 'red',
-        displayMetadata: {
-            color: '#FF5E60',
-            name: 'red'
-        }
-    },
-    {
-        id: 'pink',
-        displayMetadata: {
-            color: '#FF8FB8',
-            name: 'pink'
-        }
-    },
-    {
-        id: 'yellow',
-        displayMetadata: {
-            color: '#E9FF8F',
-            name: 'yellow'
-        }
-    }
-];
-/**
- * {@link https://developers.openfin.co/of-docs/docs/enable-color-linking}
- *
- * The Interop Broker is responsible for keeping track of the Interop state of the Platform, and for directing messages to the proper locations.
- *
- * ---
- *
- * There are 2 ways to inject custom functionality into the Interop Broker:
- *
- * **1. Configuration**
- *
- * At the moment, you can configure the default context groups for the Interop Broker without having to override it. To do so, include the `interopBrokerConfiguration` `contextGroups` option in your `platform` options in your manifest. This is the preferred method.
- * ```js
- * {
- *      "runtime": {
- *          "arguments": "--v=1 --inspect",
- *          "version": "alpha-v19"
- *      },
- *      "platform": {
- *          "uuid": "platform_customization_local",
- *          "applicationIcon": "https://openfin.github.io/golden-prototype/favicon.ico",
- *          "autoShow": false,
- *          "providerUrl": "http://localhost:5555/provider.html",
- *          "interopBrokerConfiguration": {
- *              "contextGroups": [
- *                  {
- *                      "id": "green",
- *                      "displayMetadata": {
- *                          "color": "#00CC88",
- *                          "name": "green"
- *                      }
- *                  },
- *                  {
- *                      "id": "purple",
- *                      "displayMetadata": {
- *                          "color": "#8C61FF",
- *                          "name": "purple"
- *                      }
- *                  },
- *              ]
- *          }
- *      }
- * }
- * ```
- *
- * By default the Interop Broker logs all actions to the console. You can disable this by using the logging option in `interopBrokerConfiguration`:
- * ```js
- * {
- *      "runtime": {
- *          "arguments": "--v=1 --inspect",
- *          "version": "alpha-v19"
- *      },
- *      "platform": {
- *          "uuid": "platform_customization_local",
- *          "applicationIcon": "https://openfin.github.io/golden-prototype/favicon.ico",
- *          "autoShow": false,
- *          "providerUrl": "http://localhost:5555/provider.html",
- *		    "interopBrokerConfiguration": {
- *       		"logging": {
- *   				"beforeAction": {
- *   					"enabled": false
- *   				},
- *   				"afterAction": {
- *   					"enabled": false
- *   				}
- *   			}
- *		    }
- *      }
- * }
- * ```
- *
- * ---
- * **2. Overriding**
- *
- * Similarly to how [Platform Overriding]{@link https://developers.openfin.co/docs/platform-customization#section-customizing-platform-behavior} works, you can override functions in the Interop Broker in `fin.Platform.init`. An example of that is shown below. Overriding `isConnectionAuthorized` and `isActionAuthorized` will allow you to control allowed connections and allowed actions.
- *
- * However, if there is custom functionality you wish to include in the Interop Broker, please let us know. We would like to provide better configuration options so that you don't have to continually maintain your own override code.
- *
- * ```js
- * fin.Platform.init({
- *     overrideCallback: async (Provider) => {
- *         class Override extends Provider {
- *             async getSnapshot() {
- *                 console.log('before getSnapshot')
- *                 const snapshot = await super.getSnapshot();
- *                 console.log('after getSnapshot')
- *                 return snapshot;
- *             }
- *
- *             async applySnapshot({ snapshot, options }) {
- *                 console.log('before applySnapshot')
- *                 const originalPromise = super.applySnapshot({ snapshot, options });
- *                 console.log('after applySnapshot')
- *
- *                 return originalPromise;
- *             }
- *         };
- *         return new Override();
- *     },
- *     interopOverride: async (InteropBroker) => {
- *         class Override extends InteropBroker {
- *             async joinContextGroup(channelName = 'default', target) {
- *                 console.log('before super joinContextGroup')
- *                 super.joinContextGroup(channelName, target);
- *                 console.log('after super joinContextGroup')
- *             }
- *         }
- *
- *       return new Override();
- *   }
- * });
- * ```
- *
- * ---
- *
- * @hideconstructor
- * @class
- */
-class InteropBroker extends base_1.Base {
-    constructor(wire, getProvider, options) {
-        // Tip from Pierre and Michael from the overrideCheck work: Don't use bound methods for overrideable InteropBroker functions.
-        super(wire);
-        this.getProvider = getProvider;
-        this.interopClients = new Map();
-        this.contextGroupsById = new Map();
-        if (options === null || options === void 0 ? void 0 : options.contextGroups) {
-            contextGroups = options.contextGroups;
-        }
-        if (options === null || options === void 0 ? void 0 : options.logging) {
-            this.logging = options.logging;
-        }
-        this.intentClientMap = new Map();
-        this.lastContextMap = new Map();
-        this.sessionContextGroupMap = new Map();
-        this.setContextGroupMap();
-        this.setupChannelProvider();
-    }
-    static createClosedConstructor(...args) {
-        return class OverrideableBroker extends InteropBroker {
-            constructor(...unused) {
-                if (unused.length) {
-                    const [_ignore1, ignore2, opts] = unused;
-                    if (opts && typeof opts === 'object' && !(0, lodash_1.isEqual)(opts, args[2])) {
-                        // eslint-disable-next-line no-console
-                        console.warn('You have modified the parameters of the InteropOverride constructor. This behavior is deprecated and will be removed in a future version. You can modify these options in your manifest. Please consult our Interop docs for guidance on migrating to the new override scheme.');
-                        super(args[0], args[1], opts);
-                        return;
-                    }
-                    // eslint-disable-next-line no-console
-                    console.warn('You are attempting to pass arguments to the InteropOverride constructor. This is not necessary, and these passed arguments will be ignored. You are likely using an older InteropBroker override scheme. Please consult our Interop docs for guidance on migrating to the new override scheme.');
-                }
-                super(...args);
-            }
-        };
-    }
-    /*
-    Client API
-    */
-    /**
-     * @REMOVED
-     * SetContextOptions interface
-     * @typedef { object } SetContextOptions
-     * @property { Context } {context} - New context to set.
-     */
-    /**
-     * @REMOVED
-     * GetContextOptions interface
-     * @typedef { object } GetContextOptions
-     * @property { string } [contextType] - Context Type
-     */
-    // TODO: extract inline type and do proper comments
-    /**
-     * @REMOVED
-     * JoinContextGroupOptions interface
-     * @typedef { object } JoinContextGroupOptions
-     * @property { string } contextGroupId - Id of the context group.
-     * @property { Identity | ClientIdentity } [target] - Identity of the entity you wish to join to a context group.
-     */
-    /**
-     * @REMOVED
-     * AddClientToContextGroupOptions interface
-     * @typedef { object } AddClientToContextGroupOptions
-     * @property { string } contextGroupId - Name of the context group.
-     */
-    /**
-     * @REMOVED
-     * RemoveFromContextGroupOptions interface
-     * @typedef { object } RemoveFromContextGroupOptions
-     * @property { Identity | ClientIdentity } target - Identity of the entity you wish to join to a context group.
-     */
-    /**
-     * @REMOVED
-     * GetInfoForContextGroupOptions interface
-     * @typedef { object } GetInfoForContextGroupOptions
-     * @property { string } contextGroupId - Name of the context group to get info for.
-     */
-    /**
-     * @REMOVED
-     * GetAllClientsInContextGroupOptions interface
-     * @typedef { object } GetAllClientsInContextGroupOptions
-     * @property { string } contextGroupId - Name of the context group to get info for.
-     */
-    /**
-     * @PORTED
-     * InfoForIntentOptions interface
-     * @typedef { object } InfoForIntentOptions
-     * @property { string } name Name of the intent to get info for.
-     * @property { Context } [context] Optional context.
-     */
-    /**
-     * Sets a context for the context group of the incoming current entity.
-     * @param { SetContextOptions } setContextOptions - New context to set.
-     * @param { ClientIdentity } clientIdentity - Identity of the client sender.
-     * @return { void }
-     */
-    setContext({ context }, clientIdentity) {
-        this.wire.sendAction('interop-broker-set-context').catch((e) => {
-            // don't expose, analytics-only call
-        });
-        const clientState = this.getClientState(clientIdentity);
-        if (clientState && clientState.contextGroupId) {
-            const { contextGroupId } = clientState;
-            if (!this.contextGroupsById.has(contextGroupId)) {
-                // Theoretically not possible.
-                throw new Error(`Client has a context group that isn't in the context group mapping: ${contextGroupId}.`);
-            }
-            const contextIntegrityCheckResult = InteropBroker.checkContextIntegrity(context);
-            if (contextIntegrityCheckResult.isValid === false) {
-                throw new Error(`Failed to set Context - bad Context. Reason: ${contextIntegrityCheckResult.reason}. Context: ${JSON.stringify(context)}`);
-            }
-            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-            const contextGroupState = this.contextGroupsById.get(contextGroupId);
-            const broadcastedContextType = context.type;
-            contextGroupState.set(broadcastedContextType, context);
-            this.lastContextMap.set(contextGroupId, broadcastedContextType);
-            const clientsInSameContextGroup = Array.from(this.interopClients.values()).filter((connectedClient) => connectedClient.contextGroupId === contextGroupId);
-            clientsInSameContextGroup.forEach((client) => {
-                for (const [, handlerInfo] of client.contextHandlers) {
-                    if (InteropBroker.isContextTypeCompatible(broadcastedContextType, handlerInfo.contextType)) {
-                        this.invokeContextHandler(client.clientIdentity, handlerInfo.handlerId, context);
-                    }
-                }
-            });
-        }
-        else if (clientState) {
-            // Client has not joined any context group behavior.
-            throw new Error('You must join a context group before you can set context.');
-        }
-        else {
-            // This shouldn't get hit.
-            throw new Error(`Client with Identity: ${clientIdentity.uuid} ${clientIdentity.name} not in Client State Map`);
-        }
-    }
-    /**
-     * Get current context for a client subscribed to a Context Group.
-     * @param { GetContextOptions } getContextOptions - Options for getting context
-     * @param { ClientIdentity } clientIdentity - Identity of the client sender.
-     * @return { Context }
-     */
-    getCurrentContext(getCurrentContextOptions, clientIdentity) {
-        var _a;
-        this.wire.sendAction('interop-broker-get-current-context').catch((e) => {
-            // don't expose, analytics-only call
-        });
-        const clientState = this.getClientState(clientIdentity);
-        if (!(clientState === null || clientState === void 0 ? void 0 : clientState.contextGroupId)) {
-            throw new Error('You must be a member of a context group to call getCurrentContext');
-        }
-        const { contextGroupId } = clientState;
-        const contextGroupState = this.contextGroupsById.get(contextGroupId);
-        const lastContextType = this.lastContextMap.get(contextGroupId);
-        const contextType = (_a = getCurrentContextOptions === null || getCurrentContextOptions === void 0 ? void 0 : getCurrentContextOptions.contextType) !== null && _a !== void 0 ? _a : lastContextType;
-        return contextGroupState && contextType ? contextGroupState.get(contextType) : undefined;
-    }
-    /*
-    Platform Window APIs
-    */
-    // joinContextGroup and addClientToContextGroup are separate functions here, for easier overrides and separation of concerns.
-    // joinContextGroup checks all connections for matching identities, in case we have multiple connection from an entity.
-    /**
-     * Join all connections at the given identity (or just one if endpointId provided) to context group `contextGroupId`.
-     * If no target is specified, it adds the sender to the context group.
-     * joinContextGroup is responsible for checking connections at the incoming identity. It calls {@link InteropBroker#addClientToContextGroup InteropBroker.addClientToContextGroup} to actually group the client.
-     * Used by Platform Windows.
-     * @return { Promise<void> }
-     * @param { JoinContextGroupOptions } joinContextGroupOptions - Id of the Context Group and identity of the entity to join to the group.
-     * @param { ClientIdentity } senderIdentity - Identity of the client sender.
-     */
-    async joinContextGroup({ contextGroupId, target }, senderIdentity) {
-        this.wire.sendAction('interop-broker-join-context-group').catch((e) => {
-            // don't expose, analytics-only call
-        });
-        if (this.sessionContextGroupMap.has(contextGroupId)) {
-            throw new Error(utils_1.BROKER_ERRORS.joinSessionContextGroupWithJoinContextGroup);
-        }
-        if (target) {
-            // If an endpointId is provided, use that. This will likely be used by external adapters.
-            if (InteropBroker.hasEndpointId(target)) {
-                await this.addClientToContextGroup({ contextGroupId }, target);
-            }
-            // Sanity check here in case a single app has multiple connections
-            try {
-                const allConnections = this.channel.connections.filter((x) => x.uuid === target.uuid && x.name === target.name);
-                if (!allConnections.length) {
-                    throw new Error(`Given Identity ${target.uuid} ${target.name} is not connected to the Interop Broker.`);
-                }
-                if (allConnections.length > 1) {
-                    // Should figure out how we want to handle this situation. In the meantime, just change context group for all connections.
-                    console.warn(`More than one connection found for identity ${target.uuid} ${target.name}`);
-                }
-                const promises = [];
-                for (const connection of allConnections) {
-                    promises.push(this.addClientToContextGroup({ contextGroupId }, connection));
-                }
-                await Promise.all(promises);
-            }
-            catch (error) {
-                throw new Error(error);
-            }
-        }
-        else {
-            // No target provided, add the sender to the context group.
-            await this.addClientToContextGroup({ contextGroupId }, senderIdentity);
-        }
-    }
-    // addClientToContextGroup does the actual addition of the client to the Context Group
-    /**
-     * Helper function for {@link InteropBroker#joinContextGroup InteropBroker.joinContextGroup}. Does the work of actually adding the client to the Context Group.
-     * Used by Platform Windows.
-     * @return { Promise<void> }
-     * @param { AddClientToContextGroupOptions } addClientToContextGroupOptions - Contains the contextGroupId
-     * @param { ClientIdentity } clientIdentity - Identity of the client sender.
-     */
-    async addClientToContextGroup({ contextGroupId }, clientIdentity) {
-        this.wire.sendAction('interop-broker-add-client-to-context-group').catch((e) => {
-            // don't expose, analytics-only call
-        });
-        const clientSubscriptionState = this.getClientState(clientIdentity);
-        if (!clientSubscriptionState) {
-            throw new Error(`Client with Identity: ${clientIdentity.uuid} ${clientIdentity.name} not in Client State Map`);
-        }
-        if (!this.getContextGroups().find((contextGroupInfo) => contextGroupInfo.id === contextGroupId)) {
-            throw new Error(`Attempting to join a context group that does not exist: ${contextGroupId}. You may only join existing context groups.`);
-        }
-        const oldContextGroupId = clientSubscriptionState.contextGroupId;
-        if (oldContextGroupId !== contextGroupId) {
-            clientSubscriptionState.contextGroupId = contextGroupId;
-            await this.setCurrentContextGroupInClientOptions(clientIdentity, contextGroupId);
-            const contextGroupMap = this.contextGroupsById.get(contextGroupId);
-            for (const [, handlerInfo] of clientSubscriptionState.contextHandlers) {
-                const { contextType, handlerId } = handlerInfo;
-                if (contextType === undefined) {
-                    // Send this single handler all of the context, because it accepts all.
-                    contextGroupMap.forEach((context, _) => {
-                        this.invokeContextHandler(clientIdentity, handlerId, context);
-                    });
-                }
-                else if (contextGroupMap.has(contextType)) {
-                    const contextForType = contextGroupMap.get(contextType);
-                    if (contextForType) {
-                        this.invokeContextHandler(clientIdentity, handlerId, contextForType);
-                    }
-                }
-            }
-        }
-    }
-    // Removes the target from its context group. Similar structure to joinContextGroup.
-    /**
-     * Removes the specified target from a context group.
-     * If no target is specified, it removes the sender from their context group.
-     * removeFromContextGroup is responsible for checking connections at the incoming identity. It calls {@link InteropBroker#removeClientFromContextGroup InteropBroker.removeClientFromContextGroup} to actually ungroup the client.
-     * Used by Platform Windows.
-     * @return { Promise<void> }
-     * @param { RemoveFromContextGroupOptions } removeFromContextGroupOptions - Contains the target identity to remove.
-     * @param { ClientIdentity } senderIdentity - Identity of the client sender.
-     */
-    async removeFromContextGroup({ target }, senderIdentity) {
-        this.wire.sendAction('interop-broker-remove-from-context-group').catch((e) => {
-            // don't expose, analytics-only call
-        });
-        if (target) {
-            // If an endpointId is provided, use that. This will likely be used by external adapters.
-            if (InteropBroker.hasEndpointId(target)) {
-                await this.removeClientFromContextGroup(target);
-            }
-            try {
-                // Sanity check here in case a single app has multiple connections
-                const allConnections = this.channel.connections.filter((x) => x.uuid === target.uuid && x.name === target.name);
-                if (!allConnections.length) {
-                    throw new Error(`No connection found for given Identity ${target.uuid} ${target.name}`);
-                }
-                if (allConnections.length > 1) {
-                    console.warn(`More than one connection found for identity ${target.uuid} ${target.name}`);
-                }
-                const promises = [];
-                for (const connection of allConnections) {
-                    promises.push(this.removeClientFromContextGroup(connection));
-                }
-                await Promise.all(promises);
-            }
-            catch (error) {
-                throw new Error(error);
-            }
-        }
-        else {
-            // No target provided, remove the sender from the context group.
-            await this.removeClientFromContextGroup(senderIdentity);
-        }
-    }
-    // removeClientFromContextGroup does the actual remove of the client from the Context Group
-    /**
-     * Helper function for {@link InteropBroker#removeFromContextGroup InteropBroker.removeFromContextGroup}. Does the work of actually removing the client from the Context Group.
-     * Used by Platform Windows.
-     * @return { Promise<void> }
-     * @property { ClientIdentity } clientIdentity - Identity of the client sender.
-     */
-    async removeClientFromContextGroup(clientIdentity) {
-        this.wire.sendAction('interop-broker-remove-client-from-context-group').catch((e) => {
-            // don't expose, analytics-only call
-        });
-        const clientState = this.getClientState(clientIdentity);
-        if (clientState) {
-            clientState.contextGroupId = undefined;
-        }
-        await this.setCurrentContextGroupInClientOptions(clientIdentity, null);
-    }
-    // Used by platform windows to know what client groups the provider has declared. Also used internally to access context groups. Overrideable so that the platform developer can modify it.
-    /**
-     * Returns the Interop-Broker-defined context groups available for an entity to join. Because this function is used in the rest of the Interop Broker to fetch the Context Groups, overriding this allows you to customize the Context Groups for the Interop Broker. However, we recommend customizing the context groups through configuration instead.
-     * Used by Platform Windows.
-     * @return { Promise<ContextGroupInfo[]>}
-     */
-    // eslint-disable-next-line class-methods-use-this
-    getContextGroups() {
-        this.wire.sendAction('interop-broker-get-context-groups').catch((e) => {
-            // don't expose, analytics-only call
-        });
-        // Create copy for immutability
-        return contextGroups.map((contextGroup) => {
-            return { ...contextGroup };
-        });
-    }
-    // Used to by platform windows to get display metadata for a context group.
-    /**
-     * Gets display info for a context group
-     * Used by Platform Windows.
-     * @param { GetInfoForContextGroupOptions } getInfoForContextGroupOptions - Contains contextGroupId, the context group you wish to get display info for.
-     * @return { Promise<ContextGroupInfo>}
-     */
-    getInfoForContextGroup({ contextGroupId }) {
-        this.wire.sendAction('interop-broker-get-info-for-context-group').catch((e) => {
-            // don't expose, analytics-only call
-        });
-        return this.getContextGroups().find((contextGroup) => contextGroup.id === contextGroupId);
-    }
-    // Used by platform windows to get all clients for a context group.
-    /**
-     * Gets all clients for a context group.
-     * Used by Platform Windows.
-     * @param { GetAllClientsInContextGroupOptions } getAllClientsInContextGroupOptions - Contains contextGroupId, the context group you wish to get clients for.
-     * @return { Promise<ClientIdentity[]>}
-     */
-    getAllClientsInContextGroup({ contextGroupId }) {
-        this.wire.sendAction('interop-broker-get-all-clients-in-context-group').catch((e) => {
-            // don't expose, analytics-only call
-        });
-        const clientsInContextGroup = Array.from(this.interopClients.values())
-            .filter((connectedClient) => connectedClient.contextGroupId === contextGroupId)
-            .map((subscriptionState) => {
-            return subscriptionState.clientIdentity;
-        });
-        return clientsInContextGroup;
-    }
-    /**
-     * Responsible for launching of applications that can handle a given intent, and delegation of intents to those applications.
-     * Must be overridden.
-     * @param { Intent } intent The combination of an action and a context that is passed to an application for resolution.
-     * @param { ClientIdentity }  clientIdentity Identity of the Client making the request.
-     * @return { Promise<unknown> }
-     * @tutorial interop.handleFiredIntent
-     */
-    // eslint-disable-next-line class-methods-use-this
-    async handleFiredIntent(intent, clientIdentity) {
-        const warning = (0, utils_1.generateOverrideWarning)('fdc3.raiseIntent', 'InteropBroker.handleFiredIntent', clientIdentity, 'interopClient.fireIntent');
-        console.warn(warning);
-        throw new Error(utils_1.BROKER_ERRORS.fireIntent);
-    }
-    /**
-     * Should be called in {@link InteropBroker#handleFiredIntent InteropBroker.handleFiredIntent}.
-     * While handleFiredIntent is responsible for launching applications, setIntentTarget is used to tell the InteropBroker which application should receive the intent when it is ready.
-     * @param { Intent } intent The combination of an action and a context that is passed to an application for resolution.
-     * @param { Identity } target - Identity of the target that will handle the intent.
-     * @return { Promise<void> }
-     */
-    async setIntentTarget(intent, target) {
-        this.wire.sendAction('interop-broker-set-intent-target').catch((e) => {
-            // don't expose, this is only for api analytics purposes
-        });
-        const targetInfo = this.intentClientMap.get(target.name);
-        const handlerId = `intent-handler-${intent.name}`;
-        if (!targetInfo) {
-            this.intentClientMap.set(target.name, new Map());
-            const newHandlerInfoMap = this.intentClientMap.get(target.name);
-            if (newHandlerInfoMap) {
-                newHandlerInfoMap.set(handlerId, { isReady: false, pendingIntents: [intent] });
-            }
-        }
-        else {
-            const handlerInfo = targetInfo.get(handlerId);
-            if (!handlerInfo) {
-                targetInfo.set(handlerId, { isReady: false, pendingIntents: [intent] });
-            }
-            else {
-                handlerInfo.pendingIntents.push(intent);
-                if (handlerInfo.clientIdentity && handlerInfo.isReady) {
-                    const { clientIdentity, pendingIntents } = handlerInfo;
-                    try {
-                        const intentToSend = pendingIntents[pendingIntents.length - 1];
-                        await this.invokeIntentHandler(clientIdentity, handlerId, intentToSend);
-                        handlerInfo.pendingIntents = [];
-                    }
-                    catch (error) {
-                        console.error(`Error invoking intent handler for client ${clientIdentity.uuid}/${clientIdentity.name}/${clientIdentity.endpointId}`);
-                        handlerInfo.isReady = false;
-                    }
-                }
-            }
-        }
-    }
-    /**
-     * Responsible for returning information on a particular Intent.
-     * Must be overridden.
-     * @param { InfoForIntentOptions } options
-     * @param { ClientIdentity }  clientIdentity Identity of the Client making the request.
-     * @return { Promise<unknown> }
-     * @tutorial interop.handleInfoForIntent
-     */
-    // eslint-disable-next-line class-methods-use-this
-    async handleInfoForIntent(options, clientIdentity) {
-        const warning = (0, utils_1.generateOverrideWarning)('fdc3.findIntent', 'InteropBroker.handleInfoForIntent', clientIdentity, 'interopClient.getInfoForIntent');
-        console.warn(warning);
-        throw new Error(utils_1.BROKER_ERRORS.getInfoForIntent);
-    }
-    /**
-     * Responsible for returning information on which Intents are meant to handle a specific Context.
-     * Must be overridden.
-     * @param { Context } context Data passed between entities and applications.
-     * @param { ClientIdentity } clientIdentity Identity of the Client making the request.
-     * @return { Promise<unknown> }
-     * @tutorial interop.handleInfoForIntentsByContext
-     */
-    // eslint-disable-next-line class-methods-use-this
-    async handleInfoForIntentsByContext(context, clientIdentity) {
-        const warning = (0, utils_1.generateOverrideWarning)('fdc3.findIntentsByContext', 'InteropBroker.handleInfoForIntentsByContext', clientIdentity, 'interopClient.getInfoForIntentsByContext');
-        console.warn(warning);
-        throw new Error(utils_1.BROKER_ERRORS.getInfoForIntentsByContext);
-    }
-    /**
-     * Responsible for resolving an Intent based on a specific Context.
-     * Must be overridden.
-     * @param { ContextForIntent } contextForIntent Data passed between entities and applications.
-     * @param { ClientIdentity }  clientIdentity Identity of the Client making the request.
-     * @return { Promise<unknown> }
-     * @tutorial interop.handleFiredIntentForContext
-     */
-    // eslint-disable-next-line class-methods-use-this
-    async handleFiredIntentForContext(contextForIntent, clientIdentity) {
-        const warning = (0, utils_1.generateOverrideWarning)('fdc3.raiseIntentForContext', 'InteropBroker.handleFiredIntentForContext', clientIdentity, 'interopClient.fireIntentForContext');
-        console.warn(warning);
-        throw new Error(utils_1.BROKER_ERRORS.fireIntentForContext);
-    }
-    /**
-     * Provides the identity of any Interop Client that disconnects from the Interop Broker. It is meant to be overriden.
-     * @param clientIdentity
-     * @return { Promise<void> }
-     * @tutorial interop.clientDisconnected
-     */
-    // eslint-disable-next-line class-methods-use-this
-    async clientDisconnected(clientIdentity) {
-        // This function is called in channel.onDisconnection.
-        // It is meant to be overridden to inform when an Interop Client has been disconnected.
-    }
-    /**
-     * Responsible for resolving an fdc3.open call.
-     * Must be overridden.
-     * @param { Fdc3OpenOptions } fdc3OpenOptions fdc3.open options
-     * @param { ClientIdentity } clientIdentity Identity of the Client making the request.
-     */
-    // eslint-disable-next-line class-methods-use-this
-    async fdc3HandleOpen({ app, context }, clientIdentity) {
-        const warning = (0, utils_1.generateOverrideWarning)('fdc3.open', 'InteropBroker.fdc3HandleOpen', clientIdentity);
-        console.warn(warning);
-        throw new Error(utils_1.BROKER_ERRORS.fdc3Open);
-    }
-    /**
-     * Responsible for resolving the fdc3.findInstances call.
-     * Must be overridden
-     * @param { AppIdentifier(2) }  app AppIdentifier that was passed to fdc3.findInstances
-     * @param { ClientIdentity } clientIdentity Identity of the Client making the request.
-     */
-    // eslint-disable-next-line class-methods-use-this
-    async fdc3HandleFindInstances(app, clientIdentity) {
-        const warning = (0, utils_1.generateOverrideWarning)('fdc3.open', 'InteropBroker.fdc3HandleFindInstances', clientIdentity);
-        console.warn(warning);
-        throw new Error(utils_1.BROKER_ERRORS.fdc3FindInstances);
-    }
-    /**
-     * Responsible for resolving the fdc3.getAppMetadata call.
-     * Must be overridden
-     * @param { AppIdentifier(2) } app AppIdentifier that was passed to fdc3.getAppMetadata
-     * @param { ClientIdentity } clientIdentity Identity of the Client making the request.
-     */
-    // eslint-disable-next-line class-methods-use-this
-    async fdc3HandleGetAppMetadata(app, clientIdentity) {
-        const warning = (0, utils_1.generateOverrideWarning)('fdc3.getAppMetadata', 'InteropBroker.fdc3HandleGetAppMetadata', clientIdentity);
-        console.warn(warning);
-        throw new Error(utils_1.BROKER_ERRORS.fdc3GetAppMetadata);
-    }
-    /**
-     * This function is called by the Interop Broker whenever a Context handler would fire.
-     * For FDC3 2.0 you would need to override this function and add the contextMetadata as
-     * part of the Context object. Then would you need to call
-     * super.invokeContextHandler passing it this new Context object along with the clientIdentity and handlerId
-     * @param { ClientIdentity } clientIdentity
-     * @param { string } handlerId
-     * @param { Context } context
-     * @returns { Promise<void> }
-     * @tutorial interopBroker.invokeContextHandler
-     */
-    async invokeContextHandler(clientIdentity, handlerId, context) {
-        const provider = await this.getProvider();
-        try {
-            await provider.dispatch(clientIdentity, handlerId, context);
-        }
-        catch (error) {
-            console.error(`Error invoking context handler ${handlerId} for context type ${context.type} in client ${clientIdentity.uuid}/${clientIdentity.name}/${clientIdentity.endpointId}`, error);
-        }
-    }
-    /**
-     * This function is called by the Interop Broker whenever an Intent handler would fire.
-     * For FDC3 2.0 you would need to override this function and add the contextMetadata as
-     * part of the Context object inside the Intent object. Then would you need to call
-     * super.invokeIntentHandler passing it this new Intent object along with the clientIdentity and handlerId
-     * @param { ClientIdentity } ClientIdentity
-     * @param { string } handlerId
-     * @param { Context } context
-     * @returns { Promise<void> }
-     * @tutorial interopBroker.invokeIntentHandler
-     */
-    async invokeIntentHandler(clientIdentity, handlerId, intent) {
-        const provider = await this.getProvider();
-        await provider.dispatch(clientIdentity, handlerId, intent);
-    }
-    /**
-     * Responsible for resolving fdc3.getInfo for FDC3 2.0
-     * Would need to return the optionalFeatures and appMetadata for the {@link ImplementationMetadata ImplementationMetadata}.
-     * Must be overridden.
-     * @param clientIdentity
-     * @returns { Promise<ImplementationMetadata(2)> }
-     */
-    // eslint-disable-next-line class-methods-use-this
-    async fdc3HandleGetInfo(payload, clientIdentity) {
-        const { fdc3Version } = payload;
-        return {
-            fdc3Version,
-            provider: 'OpenFin',
-            providerVersion: await this.fin.System.getVersion(),
-            optionalFeatures: {
-                OriginatingAppMetadata: false,
-                UserChannelMembershipAPIs: true
-            },
-            appMetadata: {
-                appId: '',
-                instanceId: ''
-            }
-        };
-    }
-    /**
-     * Returns an array of info for each Interop Client connected to the Interop Broker.
-     *
-     * FDC3 2.0: Use the endpointId in the ClientInfo as the instanceId when generating
-     * an AppIdentifier.
-     * @return { Promise<Array<ClientInfo>> }
-     * @tutorial interop.getAllClientInfo
-     */
-    async getAllClientInfo() {
-        const provider = await this.getProvider();
-        return provider.getAllClientInfo();
-    }
-    /*
-    Snapshot APIs
-    */
-    // Used to save interop broker state in snapshots
-    decorateSnapshot(snapshot) {
-        return { ...snapshot, interopSnapshotDetails: { contextGroupStates: this.getContextGroupStates() } };
-    }
-    // Used to restore interop broker state in snapshots.
-    applySnapshot(snapshot, options) {
-        var _a;
-        const contextGroupStates = (_a = snapshot === null || snapshot === void 0 ? void 0 : snapshot.interopSnapshotDetails) === null || _a === void 0 ? void 0 : _a.contextGroupStates;
-        if (contextGroupStates) {
-            if (!(options === null || options === void 0 ? void 0 : options.closeExistingWindows)) {
-                this.updateExistingClients(contextGroupStates);
-            }
-            this.rehydrateContextGroupStates(contextGroupStates);
-        }
-    }
-    updateExistingClients(contextGroupStates) {
-        const clients = this.interopClients;
-        clients.forEach((subState) => {
-            const { clientIdentity, contextGroupId, contextHandlers } = subState;
-            if (contextGroupId) {
-                const groupContexts = contextGroupStates[contextGroupId];
-                for (const [, context] of Object.entries(groupContexts)) {
-                    contextHandlers.forEach((contextHandler) => {
-                        const { handlerId, contextType } = contextHandler;
-                        if (InteropBroker.isContextTypeCompatible(context.type, contextType)) {
-                            this.invokeContextHandler(clientIdentity, handlerId, context);
-                        }
-                    });
-                }
-            }
-        });
-    }
-    // Used to store context group state in snapshots
-    getContextGroupStates() {
-        return InteropBroker.toObject(this.contextGroupsById);
-    }
-    // Used to rehydrate the context state from a snapshot
-    rehydrateContextGroupStates(incomingContextGroupStates) {
-        const contextGroupStates = Object.entries(incomingContextGroupStates);
-        for (const [contextGroupId, contexts] of contextGroupStates) {
-            const contextObjects = Object.entries(contexts);
-            for (const [contextType, context] of contextObjects) {
-                if (this.contextGroupsById.has(contextGroupId)) {
-                    const currentContextGroupState = this.contextGroupsById.get(contextGroupId);
-                    currentContextGroupState.set(contextType, context);
-                }
-                else {
-                    // This logic will change when dynamic context group creation comes in.
-                    console.warn(`Attempting to set a context group that isn't in the context group mapping. Skipping context group rehydration for: ${contextGroupId}`);
-                }
-            }
-        }
-    }
-    /*
-    Internal Context Handler APIs
-    */
-    // Used to give context to a client that has registered their context handler
-    contextHandlerRegistered({ contextType, handlerId }, clientIdentity) {
-        const handlerInfo = { contextType, handlerId };
-        const clientState = this.getClientState(clientIdentity);
-        clientState === null || clientState === void 0 ? void 0 : clientState.contextHandlers.set(handlerId, handlerInfo);
-        if (clientState && clientState.contextGroupId) {
-            const { contextGroupId } = clientState;
-            const contextGroupMap = this.contextGroupsById.get(contextGroupId);
-            if (contextType === undefined) {
-                // Send this single handler all of the context, because it accepts all.
-                contextGroupMap.forEach((context, _) => {
-                    this.invokeContextHandler(clientIdentity, handlerId, context);
-                });
-            }
-            else if (contextGroupMap.has(contextType)) {
-                const contextForType = contextGroupMap.get(contextType);
-                if (contextForType) {
-                    this.invokeContextHandler(clientIdentity, handlerId, contextForType);
-                }
-            }
-        }
-    }
-    // eslint-disable-next-line class-methods-use-this
-    async intentHandlerRegistered(payload, clientIdentity) {
-        const { handlerId } = payload;
-        const clientIntentInfo = this.intentClientMap.get(clientIdentity.name);
-        const handlerInfo = clientIntentInfo === null || clientIntentInfo === void 0 ? void 0 : clientIntentInfo.get(handlerId);
-        if (!clientIntentInfo) {
-            this.intentClientMap.set(clientIdentity.name, new Map());
-            const newHandlerInfoMap = this.intentClientMap.get(clientIdentity.name);
-            if (newHandlerInfoMap) {
-                newHandlerInfoMap.set(handlerId, { isReady: true, pendingIntents: [], clientIdentity });
-            }
-        }
-        else if (!handlerInfo) {
-            clientIntentInfo.set(handlerId, { isReady: true, pendingIntents: [], clientIdentity });
-        }
-        else {
-            const { pendingIntents } = handlerInfo;
-            handlerInfo.clientIdentity = clientIdentity;
-            handlerInfo.isReady = true;
-            try {
-                if (pendingIntents.length > 0) {
-                    const intentToSend = pendingIntents[pendingIntents.length - 1];
-                    await this.invokeIntentHandler(clientIdentity, handlerId, intentToSend);
-                    handlerInfo.pendingIntents = [];
-                }
-            }
-            catch (error) {
-                console.error(`Error invoking intent handler: ${handlerId} for client ${clientIdentity.uuid}/${clientIdentity.name}/${clientIdentity.endpointId}`);
-            }
-        }
-    }
-    // Used to remove a context handler for a client
-    removeContextHandler({ handlerId }, clientIdentity) {
-        const clientState = this.getClientState(clientIdentity);
-        if (clientState) {
-            clientState.contextHandlers.delete(handlerId);
-        }
-    }
-    handleJoinSessionContextGroup({ sessionContextGroupId }, clientIdentity) {
-        try {
-            if (!sessionContextGroupId) {
-                throw new Error('Failed to join session context group: must specify group id.');
-            }
-            const sessionContextGroup = this.sessionContextGroupMap.get(sessionContextGroupId);
-            if (sessionContextGroup) {
-                sessionContextGroup.registerNewClient(clientIdentity);
-            }
-            else {
-                const newSessionContextGroupBroker = new SessionContextGroupBroker_1.default(this.channel, sessionContextGroupId);
-                newSessionContextGroupBroker.registerNewClient(clientIdentity);
-                this.sessionContextGroupMap.set(sessionContextGroupId, newSessionContextGroupBroker);
-            }
-            return { hasConflict: this.contextGroupsById.has(sessionContextGroupId) };
-        }
-        catch (error) {
-            throw new Error(error);
-        }
-    }
-    /*
-    Internal Utilties
-    */
-    // Getter for interop info for a client.
-    getClientState(id) {
-        return this.interopClients.get(id.endpointId);
-    }
-    // Util for getContextGroupStates. Serializes the contextGroupStates object so we can store it.
-    static toObject(map) {
-        const objectFromMap = Object.fromEntries(map);
-        const newObject = {};
-        Object.entries(objectFromMap).forEach(([contextGroupId, contextMap]) => {
-            const newContextObject = Object.fromEntries(contextMap);
-            newObject[contextGroupId] = newContextObject;
-        });
-        return newObject;
-    }
-    static checkContextIntegrity(context) {
-        if (!context) {
-            return { isValid: false, reason: 'No context supplied' };
-        }
-        if (typeof context !== 'object') {
-            return { isValid: false, reason: 'Context must be an Object' };
-        }
-        if (!context.type) {
-            return { isValid: false, reason: 'Context must have a type property' };
-        }
-        if (context.id && typeof context.id !== 'object') {
-            return {
-                isValid: false,
-                reason: 'Context id must be an Object populated with key-value identifiers (if set)'
-            };
-        }
-        if (context.id) {
-            const { id } = context;
-            const keys = Object.keys(id);
-            let foundBadIdentifier = false;
-            if (!keys.length) {
-                return { isValid: false, reason: 'Context id must have at least one key-value identifier' };
-            }
-            keys.forEach((key) => {
-                if (typeof key !== 'string' || typeof id[key] !== 'string') {
-                    foundBadIdentifier = true;
-                }
-            });
-            if (foundBadIdentifier) {
-                return { isValid: false, reason: 'Context id key-value identifiers must be of type string' };
-            }
-        }
-        if (context.name && typeof context.name !== 'string') {
-            return { isValid: false, reason: 'Context name must be of string type (if set)' };
-        }
-        return { isValid: true };
-    }
-    // Util to check a client identity.
-    static hasEndpointId(target) {
-        return target.endpointId !== undefined;
-    }
-    // Util to check if we should send a context to a handler.
-    static isContextTypeCompatible(contextType, registeredContextType) {
-        return typeof registeredContextType === 'undefined' || contextType === registeredContextType;
-    }
-    // Setup function for state mapping
-    setContextGroupMap() {
-        // This way, if a user overrides this.getContextGroups, it's reflected in the contextGroupMapping.
-        for (const contextGroupInfo of this.getContextGroups()) {
-            this.contextGroupsById.set(contextGroupInfo.id, new Map());
-        }
-    }
-    async setCurrentContextGroupInClientOptions(clientIdentity, contextGroupId) {
-        const entityInfo = await this.fin.System.getEntityInfo(clientIdentity.uuid, clientIdentity.name);
-        let entity;
-        if (entityInfo.entityType === 'view') {
-            entity = await this.fin.View.wrap(clientIdentity);
-        }
-        else if (entityInfo.entityType === 'window') {
-            entity = await this.fin.Window.wrap(clientIdentity);
-        }
-        if (entity) {
-            await entity.updateOptions({
-                interop: {
-                    currentContextGroup: contextGroupId
-                }
-            });
-        }
-        else {
-            console.warn(`Setting Current Context Group: Entity with identity ${clientIdentity.uuid}, ${clientIdentity.name} is not a window or view. It is a ${entityInfo.entityType} instead.`);
-        }
-    }
-    async setupChannelProvider() {
-        try {
-            const channel = await this.getProvider();
-            this.channel = channel;
-            this.wireChannel(channel);
-        }
-        catch (error) {
-            throw new Error(`Error setting up Interop Broker Channel Provider: ${error}`);
-        }
-    }
-    // Setup Channel Connection Logic
-    wireChannel(channel) {
-        channel.onConnection(async (clientIdentity, payload) => {
-            if (!(await this.isConnectionAuthorized(clientIdentity, payload))) {
-                throw new Error(`Connection not authorized for ${clientIdentity.uuid}, ${clientIdentity.name}`);
-            }
-            if (!clientIdentity.endpointId) {
-                throw new Error('Version too old to be compatible with Interop. Please upgrade your runtime to a more recent version.');
-            }
-            const clientSubscriptionState = {
-                contextGroupId: undefined,
-                contextHandlers: new Map(),
-                clientIdentity
-            };
-            // Only allow the client to join a contextGroup that actually exists.
-            if ((payload === null || payload === void 0 ? void 0 : payload.currentContextGroup) && this.contextGroupsById.has(payload.currentContextGroup)) {
-                clientSubscriptionState.contextGroupId = payload === null || payload === void 0 ? void 0 : payload.currentContextGroup;
-            }
-            this.interopClients.set(clientIdentity.endpointId, clientSubscriptionState);
-        });
-        channel.onDisconnection((clientIdentity) => {
-            this.interopClients.delete(clientIdentity.endpointId);
-            const targetInfo = this.intentClientMap.get(clientIdentity.name);
-            if (targetInfo && clientIdentity.uuid === this.fin.me.uuid) {
-                targetInfo.forEach((handler) => {
-                    handler.isReady = false;
-                });
-            }
-            this.sessionContextGroupMap.forEach((sessionContextGroup) => {
-                sessionContextGroup.onDisconnection(clientIdentity);
-            });
-            this.clientDisconnected(clientIdentity);
-        });
-        channel.beforeAction(async (action, payload, clientIdentity) => {
-            var _a, _b;
-            if (!(await this.isActionAuthorized(action, payload, clientIdentity))) {
-                throw new Error(`Action (${action}) not authorized for ${clientIdentity.uuid}, ${clientIdentity.name}`);
-            }
-            if ((_b = (_a = this.logging) === null || _a === void 0 ? void 0 : _a.beforeAction) === null || _b === void 0 ? void 0 : _b.enabled) {
-                console.log(action, payload, clientIdentity);
-            }
-        });
-        channel.afterAction((action, payload, clientIdentity) => {
-            var _a, _b;
-            if ((_b = (_a = this.logging) === null || _a === void 0 ? void 0 : _a.afterAction) === null || _b === void 0 ? void 0 : _b.enabled) {
-                console.log(action, payload, clientIdentity);
-            }
-        });
-        // Client functions
-        channel.register('setContext', this.setContext.bind(this));
-        channel.register('fireIntent', this.handleFiredIntent.bind(this));
-        channel.register('getCurrentContext', this.getCurrentContext.bind(this));
-        channel.register('getInfoForIntent', this.handleInfoForIntent.bind(this));
-        channel.register('getInfoForIntentsByContext', this.handleInfoForIntentsByContext.bind(this));
-        channel.register('fireIntentForContext', this.handleFiredIntentForContext.bind(this));
-        // Platform window functions
-        channel.register('getContextGroups', this.getContextGroups.bind(this));
-        channel.register('joinContextGroup', this.joinContextGroup.bind(this));
-        channel.register('removeFromContextGroup', this.removeFromContextGroup.bind(this));
-        channel.register('getAllClientsInContextGroup', this.getAllClientsInContextGroup.bind(this));
-        channel.register('getInfoForContextGroup', this.getInfoForContextGroup.bind(this));
-        // Internal methods
-        channel.register('contextHandlerRegistered', this.contextHandlerRegistered.bind(this));
-        channel.register('intentHandlerRegistered', this.intentHandlerRegistered.bind(this));
-        channel.register('removeContextHandler', this.removeContextHandler.bind(this));
-        channel.register('sessionContextGroup:createIfNeeded', this.handleJoinSessionContextGroup.bind(this));
-        // fdc3 only methods
-        channel.register('fdc3Open', this.fdc3HandleOpen.bind(this));
-        channel.register('fdc3v2FindIntentsByContext', this.handleInfoForIntentsByContext.bind(this));
-        channel.register('fdc3FindInstances', this.fdc3HandleFindInstances.bind(this));
-        channel.register('fdc3GetAppMetadata', this.fdc3HandleGetAppMetadata.bind(this));
-        channel.register('fdc3v2GetInfo', async (payload, clientIdentity) => {
-            return this.fdc3HandleGetInfo.bind(this)(payload, clientIdentity);
-        });
-        channel.register('createPrivateChannelProvider', async (payload) => {
-            const { channelId } = payload;
-            const channelProvider = await this.fin.InterApplicationBus.Channel.create(channelId);
-            PrivateChannelProvider_1.PrivateChannelProvider.init(channelProvider, channelId);
-        });
-    }
-    /**
-     * Can be used to completely prevent a connection. Return false to prevent connections. Allows all connections by default.
-     * @param _id the identity tryinc to connect
-     * @param _connectionPayload optional payload to use in custom implementations, will be undefined by default
-     */
-    isConnectionAuthorized(_id, _connectionPayload) {
-        this.wire.sendAction('interop-broker-is-connection-authorized').catch((e) => {
-            // don't expose, analytics-only call
-        });
-        return Promise.resolve(true);
-    }
-    /**
-     * Called before every action to check if this entity should be allowed to take the action.
-     * Return false to prevent the action
-     * @param _action the string action to authorize in camel case
-     * @param _payload the data being sent for this action
-     * @param _identity the connection attempting to dispatch this action
-     */
-    isActionAuthorized(_action, _payload, _identity) {
-        this.wire.sendAction('interop-broker-is-action-authorized').catch((e) => {
-            // don't expose, analytics-only call
-        });
-        return Promise.resolve(true);
-    }
-}
-exports.InteropBroker = InteropBroker;