@openfin/core 25.68.26

package/src/api/interop/Factory.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const base_1 = require("../base");
+const InteropBroker_1 = require("./InteropBroker");
+const InteropClient_1 = require("./InteropClient");
+const defaultOverride = (Class, ...args) => new Class(...args);
+/**
+ * @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
+ */
+class InteropModule extends base_1.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
+     */
+    async init(name, override = defaultOverride) {
+        this.wire.sendAction('interop-init').catch((e) => {
+            // don't expose, analytics-only call
+        });
+        const provider = await this.fin.InterApplicationBus.Channel.create(`interop-broker-${name}`);
+        // Allows for manifest-level configuration, without having to override. (e.g. specifying custom context groups)
+        const options = await this.fin.Application.getCurrentSync().getInfo();
+        return override(InteropBroker_1.InteropBroker, this.wire, provider, options.initialOptions.interopBrokerConfiguration || {});
+    }
+    /**
+     * 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, interopConfig) {
+        this.wire.sendAction('interop-connect-sync').catch((e) => {
+            // don't expose, analytics-only call
+        });
+        return new InteropClient_1.InteropClient(this.wire, name, interopConfig);
+    }
+}
+exports.default = InteropModule;

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

@@ -0,0 +1,363 @@
+import { Base } from '../base';
+import type Transport from '../../transport/transport';
+import Identity = OpenFin.Identity;
+/**
+ * {@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 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"
+ *                      }
+ *                  },
+ *              ]
+ *          }
+ *      }
+ * }
+ * ```
+ *
+ * ---
+ * **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, provider, options, ...args) => {
+ *         class Override extends InteropBroker {
+ *             async joinContextGroup(channelName = 'default', target) {
+ *                 console.log('before super joinContextGroup')
+ *                 super.joinContextGroup(channelName, target);
+ *                 console.log('after super joinContextGroup')
+ *             }
+ *         }
+ *
+ *         options.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'
+ *                 }
+ *             }
+ *         ];
+ *       return new Override(provider, options, ...args);
+ *   }
+ * });
+ * ```
+ *
+ * ---
+ *
+ * @hideconstructor
+ * @class
+ */
+export declare class InteropBroker extends Base {
+    private channel;
+    private interopClients;
+    private contextGroupsById;
+    private intentClientMap;
+    private lastContextMap;
+    private sessionContextGroupMap;
+    constructor(wire: Transport, channel: OpenFin.ChannelProvider, options?: any);
+    /**
+     * SetContextOptions interface
+     * @typedef { object } SetContextOptions
+     * @property { Context } {context} - New context to set.
+     */
+    /**
+     * GetContextOptions interface
+     * @typedef { object } GetContextOptions
+     * @property { string } [contextType] - Context Type
+     */
+    /**
+     * 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.
+     */
+    /**
+     * AddClientToContextGroupOptions interface
+     * @typedef { object } AddClientToContextGroupOptions
+     * @property { string } contextGroupId - Name of the context group.
+     */
+    /**
+     * RemoveFromContextGroupOptions interface
+     * @typedef { object } RemoveFromContextGroupOptions
+     * @property { Identity | ClientIdentity } target - Identity of the entity you wish to join to a context group.
+     */
+    /**
+     * GetInfoForContextGroupOptions interface
+     * @typedef { object } GetInfoForContextGroupOptions
+     * @property { string } contextGroupId - Name of the context group to get info for.
+     */
+    /**
+     * GetAllClientsInContextGroupOptions interface
+     * @typedef { object } GetAllClientsInContextGroupOptions
+     * @property { string } contextGroupId - Name of the context group to get info for.
+     */
+    /**
+     * 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 }
+     * @experimental
+     */
+    setContext({ context }: {
+        context: OpenFin.Context;
+    }, clientIdentity: OpenFin.ClientIdentity): void;
+    /**
+     * 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: {
+        contextType: string;
+    }, clientIdentity: OpenFin.ClientIdentity): OpenFin.Context | undefined;
+    /**
+     * 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.
+     * @experimental
+     */
+    joinContextGroup({ contextGroupId, target }: {
+        contextGroupId: string;
+        target?: OpenFin.ClientIdentity | OpenFin.Identity;
+    }, senderIdentity: OpenFin.ClientIdentity): Promise<void>;
+    /**
+     * 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.
+     * @experimental
+     */
+    addClientToContextGroup({ contextGroupId }: {
+        contextGroupId: string;
+    }, clientIdentity: OpenFin.ClientIdentity): Promise<void>;
+    /**
+     * 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.
+     * @experimental
+     */
+    removeFromContextGroup({ target }: {
+        target: OpenFin.Identity;
+    }, senderIdentity: OpenFin.ClientIdentity): Promise<void>;
+    /**
+     * 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.
+     * @experimental
+     */
+    removeClientFromContextGroup(clientIdentity: OpenFin.ClientIdentity): Promise<void>;
+    /**
+     * 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[]>}
+     * @experimental
+     */
+    getContextGroups(): Readonly<OpenFin.ContextGroupInfo[]>;
+    /**
+     * 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>}
+     * @experimental
+     */
+    getInfoForContextGroup({ contextGroupId }: {
+        contextGroupId: string;
+    }): OpenFin.ContextGroupInfo | undefined;
+    /**
+     * 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[]>}
+     * @experimental
+     */
+    getAllClientsInContextGroup({ contextGroupId }: {
+        contextGroupId: string;
+    }): OpenFin.ClientIdentity[];
+    /**
+     * 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
+     * @experimental
+     */
+    handleFiredIntent(intent: OpenFin.Intent, clientIdentity: OpenFin.ClientIdentity): Promise<unknown>;
+    /**
+     * 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> }
+     * @experimental
+     */
+    setIntentTarget(intent: OpenFin.Intent, target: OpenFin.Identity): Promise<void>;
+    /**
+     * 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
+     * @experimental
+     */
+    handleInfoForIntent(options: OpenFin.InfoForIntentOptions, clientIdentity: OpenFin.ClientIdentity): Promise<unknown>;
+    /**
+     * 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
+     * @experimental
+     */
+    handleInfoForIntentsByContext(context: OpenFin.Context, clientIdentity: OpenFin.ClientIdentity): Promise<unknown>;
+    /**
+     * 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
+     * @experimental
+     */
+    handleFiredIntentForContext(contextForIntent: OpenFin.ContextForIntent, clientIdentity: OpenFin.ClientIdentity): Promise<unknown>;
+    decorateSnapshot(snapshot: OpenFin.Snapshot): OpenFin.Snapshot;
+    applySnapshot(snapshot: OpenFin.Snapshot, options: OpenFin.ApplySnapshotOptions): void;
+    updateExistingClients(contextGroupStates: OpenFin.ContextGroupStates): void;
+    getContextGroupStates(): OpenFin.ContextGroupStates;
+    rehydrateContextGroupStates(incomingContextGroupStates: OpenFin.ContextGroupStates): void;
+    contextHandlerRegistered({ contextType, handlerId }: {
+        contextType: string | undefined;
+        handlerId: string;
+    }, clientIdentity: OpenFin.ClientIdentity): void;
+    intentHandlerRegistered(payload: any, clientIdentity: OpenFin.ClientIdentity): Promise<void>;
+    protected invokeContextHandler(clientIdentity: OpenFin.ClientIdentity, handlerId: string, context: OpenFin.Context): void;
+    removeContextHandler({ handlerId }: {
+        handlerId: string;
+    }, clientIdentity: OpenFin.ClientIdentity): void;
+    handleJoinSessionContextGroup({ sessionContextGroupId }: {
+        sessionContextGroupId: string;
+    }, clientIdentity: OpenFin.ClientIdentity): {
+        hasConflict: boolean;
+    };
+    private getClientState;
+    private static toObject;
+    static checkContextIntegrity(context: OpenFin.Context): {
+        isValid: true;
+    } | {
+        isValid: false;
+        reason: string;
+    };
+    private static hasEndpointId;
+    static isContextTypeCompatible(contextType: string, registeredContextType: string | undefined): boolean;
+    private setContextGroupMap;
+    private static setCurrentContextGroupInClientOptions;
+    private wireChannel;
+    /**
+     * 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: Identity, _connectionPayload?: any): Promise<boolean>;
+    /**
+     * 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: string, _payload: any, _identity: OpenFin.ClientIdentity): Promise<boolean>;
+}