@openfin/core 25.68.26

package/src/api/interop/SessionContextGroupClient.js

@@ -0,0 +1,85 @@
+"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;
+Object.defineProperty(exports, "__esModule", { value: true });
+const base_1 = require("../base");
+const utils_1 = require("./utils");
+class SessionContextGroupClient extends base_1.Base {
+    constructor(wire, client, id) {
+        super(wire);
+        _clientPromise.set(this, void 0);
+        this.id = id;
+        __classPrivateFieldSet(this, _clientPromise, client);
+    }
+    /**
+     * Sets a context for the session context group.
+     * @param { Context } context - New context to set.
+     * @return { Promise<void> }
+     * @tutorial interop.setContext
+     */
+    async setContext(context) {
+        this.wire.sendAction('interop-session-context-group-set-context').catch((e) => {
+            // don't expose, analytics-only call
+        });
+        const client = await __classPrivateFieldGet(this, _clientPromise);
+        return client.dispatch(`sessionContextGroup:setContext-${this.id}`, {
+            sessionContextGroupId: this.id,
+            context
+        });
+    }
+    async getCurrentContext(type) {
+        this.wire.sendAction('interop-session-context-group-get-context').catch((e) => {
+            // don't expose, analytics-only call
+        });
+        const client = await __classPrivateFieldGet(this, _clientPromise);
+        return client.dispatch(`sessionContextGroup:getContext-${this.id}`, {
+            sessionContextGroupId: this.id,
+            type
+        });
+    }
+    async addContextHandler(contextHandler, contextType) {
+        this.wire.sendAction('interop-session-context-group-add-handler').catch((e) => {
+            // don't expose, analytics-only call
+        });
+        const client = await __classPrivateFieldGet(this, _clientPromise);
+        let handlerId;
+        if (contextType) {
+            handlerId = `sessionContextHandler:invoke-${this.id}-${contextType}-${utils_1.generateId()}`;
+        }
+        else {
+            handlerId = `sessionContextHandler:invoke-${this.id}`;
+        }
+        client.register(handlerId, utils_1.wrapContextHandler(contextHandler, handlerId));
+        client.dispatch(`sessionContextGroup:handlerAdded-${this.id}`, { handlerId, contextType });
+        return { unsubscribe: await this.createUnsubscribeCb(handlerId) };
+    }
+    async createUnsubscribeCb(handlerId) {
+        const client = await __classPrivateFieldGet(this, _clientPromise);
+        return async () => {
+            client.remove(handlerId);
+            await client.dispatch(`sessionContextGroup:handlerRemoved-${this.id}`, { handlerId });
+        };
+    }
+    getUserInstance() {
+        return {
+            id: this.id,
+            setContext: utils_1.wrapInTryCatch(this.setContext.bind(this), 'Failed to set context: '),
+            getCurrentContext: utils_1.wrapInTryCatch(this.getCurrentContext.bind(this), 'Failed to get context: '),
+            addContextHandler: utils_1.wrapInTryCatch(this.addContextHandler.bind(this), 'Failed to add context handler: ')
+        };
+    }
+}
+exports.default = SessionContextGroupClient;
+_clientPromise = new WeakMap();

package/src/api/interop/fdc3/fdc3-1.2.d.ts

@@ -0,0 +1,187 @@
+import { Base } from '../../base';
+/**
+ * @typedef { object } Listener
+ * @summary Listener object returned by addContextListener and addIntentListener
+ * @property {function} unsubscribe function for addContextListener and addIntentListener.
+ */
+/**
+ * @typedef { object } Channel
+ * @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.
+ * @property {string} type Defaults to system.
+ * @property {function} broadcast Broadcasts a context for the channel.
+ * @property {function} addContextListener Add a context handler for incoming context.
+ * @property {function} getCurrentContext Gets the current context for the channel.
+ */
+/**
+ * @typedef  { object } AppMetadata
+ * @summary App metadata is provided by the FDC3 App Directory.
+ * @property {string} name
+ * @property {string} [appId]
+ * @property {string} [version]
+ * @property {string} [title]
+ * @property {string} [tooltip]
+ * @property {string} [description]
+ * @property {Array<string>} [icons]
+ * @property {Array<string>} [images]
+ */
+/**
+ * @typedef { string | AppMetadata } TargetApp
+ * @summary Some operations can identify an app just by its name, or pass full app metadata.
+ */
+/**
+ * @typedef { object } IntentResolution
+ * @summary IntentResolution provides a standard format for data returned upon resolving an Intent.
+ * @property { TargetApp } source identifier for the Application resolving the Intent (null if the Intent could not be resolved)
+ * @property { string } [data] Return data structure - if one is provided for the given Intent.
+ * @property { string } version The version number of the Intents schema being used
+ */
+/**
+ * @typedef { object } AppIntent
+ * @summary An interface that represents the binding of an intent to apps.
+ * @property { Intent } intent
+ * @property { Array<AppMetadata> } apps
+ */
+/**
+ * @typedef { object } ImplementationMetadata
+ * @summary An interface that represents FDC3 implementation meta data.
+ * @property { string } fdc3Version The FDC3 version
+ * @property { string } provider The provider uuid with prepend 'openfin'
+ * @property { string } [providerVersion] The provider runtime version
+ */
+/**
+ * The FDC3 Client Library provides a set APIs to be used for FDC3 compliance,
+ * while using our Interop API under the hood. In order to use this set of APIs
+ * you will need to set up your own {@link InteropBroker InteropBroker} or use a Platform application, which does the setup for you. Refer to our documentation on
+ * our {@link https://developers.openfin.co/of-docs/docs/enable-color-linking Interop API}.
+ *
+ * We currently support APIs based on FDC3 1.2. To enable the FDC3 APIs in a {@link Window Window} or {@link View View}, add the fdc3InteropApi
+ * property to its options:
+ *
+ * ```js
+ * {
+ *     autoShow: false,
+ *     saveWindowState: true,
+ *     url: 'https://openfin.co',
+ *     fdc3InteropApi: '1.2'
+ * }
+ * ```
+ *
+ * If using a {@link Platform Platform } application, you can set this property in defaultWindowOptions and defaultViewOptions.
+ *
+ * @class
+ * @alias Fdc3
+ * @hideconstructor
+ */
+export default class Fdc3Module extends Base implements FDC3.DesktopAgent {
+    /**
+     * 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. If you wish to listen for all incoming contexts, pass `null` for the contextType argument.
+     * @param { string | null } contextType - The type of context you wish to handle.
+     * @param { ContextHandler } handler - Handler for incoming context.
+     * @returns { Listener }
+     * @tutorial fdc3.addContextListener
+     * @static
+     */
+    addContextListener(contextType: string | null, handler: OpenFin.ContextHandler): FDC3.Listener & Promise<FDC3.Listener>;
+    /**
+     * Broadcasts a context for the channel of the current entity.
+     * @param { Context } context - New context to set.
+     * @returns { Promise<void> }
+     * @tutorial fdc3.broadcast
+     * @static
+     */
+    broadcast(context: OpenFin.Context): Promise<void>;
+    /**
+     * Returns the Interop-Broker-defined context groups available for an entity to join.
+     * @returns { Promise<Channel[]>}
+     * @tutorial fdc3.getSystemChannels
+     * @static
+     */
+    getSystemChannels(): Promise<OpenFin.ContextGroupInfo[]>;
+    /**
+     * 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 implementations, so this point is more-or-less moot.
+     * @param { string } channelId - Id of the context group.
+     * @returns { Promise<void> }
+     * @tutorial fdc3.joinChannel
+     * @static
+     */
+    joinChannel(channelId: string): Promise<void>;
+    /**
+     * Removes the specified target from a context group.
+     * If no target is specified, it removes the sender from their context group.
+     * @returns { Promise<void> }
+     * @tutorial fdc3.leaveCurrentChannel
+     * @static
+     */
+    leaveCurrentChannel(): Promise<void>;
+    /**
+     * Adds a listener for incoming Intents.
+     * @param { string } intent - Name of the Intent
+     * @param { IntentHandler } handler - Handler for incoming Intent
+     * @returns { Listener }
+     * @tutorial fdc3.addIntentListener
+     * @static
+     */
+    addIntentListener(intent: string, handler: OpenFin.ContextHandler): FDC3.Listener & Promise<FDC3.Listener>;
+    /**
+     * Raises a specific intent.
+     * @param { string } intent Name of the Intent.
+     * @param { Context } context Context associated with the Intent.
+     * @param { TargetApp }  app App that will resolve the Intent. This is added as metadata to the Intent. Can be accessed by the app provider in {@link InteropBroker#handleFiredIntent InteropBroker.handleFiredIntent}.
+     * @returns { IntentResolution }
+     * @tutorial fdc3.raiseIntent
+     * @static
+     */
+    raiseIntent(intent: string, context: OpenFin.Context, app?: FDC3.TargetApp): Promise<FDC3.IntentResolution>;
+    /**
+     * Returns the Channel that the entity is subscribed to. Returns null if not joined to a channel.
+     * @returns { Channel | null }
+     * @tutorial fdc3.getCurrentChannel
+     */
+    getCurrentChannel(): Promise<FDC3.Channel | null>;
+    /**
+     * Find out more information about a particular intent by passing its name, and optionally its context.
+     * @param { string } intent Name of the Intent
+     * @param { Context } [context]
+     * @return { Promise<AppIntent> }
+     * @tutorial fdc3.findIntent
+     */
+    findIntent(intent: string, context?: OpenFin.Context): Promise<FDC3.AppIntent>;
+    /**
+     * Find all the available intents for a particular context.
+     * @param { Context } context
+     * @return { Promise<Array<AppIntent>> }
+     * @tutorial fdc3.findIntentsByContext
+     */
+    findIntentsByContext(context: OpenFin.Context): Promise<Array<FDC3.AppIntent>>;
+    /**
+     * Finds and raises an intent against a target app based purely on context data.
+     * @param { Context } context
+     * @param { TargetApp } [app]
+     * @return { Promise<IntentResolution> }
+     * @tutorial fdc3.raiseIntentForContext
+     */
+    raiseIntentForContext(context: OpenFin.Context, app?: FDC3.TargetApp): Promise<FDC3.IntentResolution>;
+    /**
+     * Returns a Channel object for the specified channel, creating it as an App Channel if it does not exist.
+     * @param channelId
+     * @returns { Promise<Channel> }
+     * @tutorial fdc3.getOrCreateChannel
+     */
+    getOrCreateChannel(channelId: string): Promise<FDC3.Channel>;
+    /**
+     * Returns metadata relating to the FDC3 object and its provider, including the supported version of the FDC3 specification and the name of the provider of the implementation.
+     * @return { Promise<ImplementationMetadata> }
+     * @tutorial fdc3.getInfo
+     */
+    getInfo(): FDC3.ImplementationMetadata;
+    open(): void;
+    private getCurrentContextGroupInfo;
+    private buildChannelObject;
+    private buildAppChannelObject;
+}

package/src/api/interop/fdc3/fdc3-1.2.js

@@ -0,0 +1,385 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const base_1 = require("../../base");
+const utils_1 = require("./utils");
+const utils_2 = require("../utils");
+/**
+ * @typedef { object } Listener
+ * @summary Listener object returned by addContextListener and addIntentListener
+ * @property {function} unsubscribe function for addContextListener and addIntentListener.
+ */
+/**
+ * @typedef { object } Channel
+ * @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.
+ * @property {string} type Defaults to system.
+ * @property {function} broadcast Broadcasts a context for the channel.
+ * @property {function} addContextListener Add a context handler for incoming context.
+ * @property {function} getCurrentContext Gets the current context for the channel.
+ */
+/**
+ * @typedef  { object } AppMetadata
+ * @summary App metadata is provided by the FDC3 App Directory.
+ * @property {string} name
+ * @property {string} [appId]
+ * @property {string} [version]
+ * @property {string} [title]
+ * @property {string} [tooltip]
+ * @property {string} [description]
+ * @property {Array<string>} [icons]
+ * @property {Array<string>} [images]
+ */
+/**
+ * @typedef { string | AppMetadata } TargetApp
+ * @summary Some operations can identify an app just by its name, or pass full app metadata.
+ */
+/**
+ * @typedef { object } IntentResolution
+ * @summary IntentResolution provides a standard format for data returned upon resolving an Intent.
+ * @property { TargetApp } source identifier for the Application resolving the Intent (null if the Intent could not be resolved)
+ * @property { string } [data] Return data structure - if one is provided for the given Intent.
+ * @property { string } version The version number of the Intents schema being used
+ */
+/**
+ * @typedef { object } AppIntent
+ * @summary An interface that represents the binding of an intent to apps.
+ * @property { Intent } intent
+ * @property { Array<AppMetadata> } apps
+ */
+/**
+ * @typedef { object } ImplementationMetadata
+ * @summary An interface that represents FDC3 implementation meta data.
+ * @property { string } fdc3Version The FDC3 version
+ * @property { string } provider The provider uuid with prepend 'openfin'
+ * @property { string } [providerVersion] The provider runtime version
+ */
+/**
+ * The FDC3 Client Library provides a set APIs to be used for FDC3 compliance,
+ * while using our Interop API under the hood. In order to use this set of APIs
+ * you will need to set up your own {@link InteropBroker InteropBroker} or use a Platform application, which does the setup for you. Refer to our documentation on
+ * our {@link https://developers.openfin.co/of-docs/docs/enable-color-linking Interop API}.
+ *
+ * We currently support APIs based on FDC3 1.2. To enable the FDC3 APIs in a {@link Window Window} or {@link View View}, add the fdc3InteropApi
+ * property to its options:
+ *
+ * ```js
+ * {
+ *     autoShow: false,
+ *     saveWindowState: true,
+ *     url: 'https://openfin.co',
+ *     fdc3InteropApi: '1.2'
+ * }
+ * ```
+ *
+ * If using a {@link Platform Platform } application, you can set this property in defaultWindowOptions and defaultViewOptions.
+ *
+ * @class
+ * @alias Fdc3
+ * @hideconstructor
+ */
+class Fdc3Module extends base_1.Base {
+    /**
+     * 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. If you wish to listen for all incoming contexts, pass `null` for the contextType argument.
+     * @param { string | null } contextType - The type of context you wish to handle.
+     * @param { ContextHandler } handler - Handler for incoming context.
+     * @returns { Listener }
+     * @tutorial fdc3.addContextListener
+     * @static
+     */
+    addContextListener(contextType, handler) {
+        this.wire.sendAction('fdc3-add-context-listener').catch((e) => {
+            // we do not want to expose this error, just continue if this analytics-only call fails
+        });
+        let listener;
+        if (typeof contextType === 'function') {
+            console.warn('addContextListener(handler) has been deprecated. Please use addContextListener(null, handler)');
+            listener = window.fin.me.interop.addContextHandler(contextType);
+        }
+        else {
+            listener = window.fin.me.interop.addContextHandler(handler, contextType === null ? undefined : contextType);
+        }
+        return {
+            ...listener,
+            unsubscribe: () => listener.then((l) => l.unsubscribe())
+        };
+    }
+    /**
+     * Broadcasts a context for the channel of the current entity.
+     * @param { Context } context - New context to set.
+     * @returns { Promise<void> }
+     * @tutorial fdc3.broadcast
+     * @static
+     */
+    async broadcast(context) {
+        this.wire.sendAction('fdc3-broadcast').catch((e) => {
+            // we do not want to expose this error, just continue if this analytics-only call fails
+        });
+        window.fin.me.interop.setContext(context);
+    }
+    /**
+     * Returns the Interop-Broker-defined context groups available for an entity to join.
+     * @returns { Promise<Channel[]>}
+     * @tutorial fdc3.getSystemChannels
+     * @static
+     */
+    async getSystemChannels() {
+        this.wire.sendAction('fdc3-get-system-channels').catch((e) => {
+            // we do not want to expose this error, just continue if this analytics-only call fails
+        });
+        const channels = await window.fin.me.interop.getContextGroups();
+        const unsupportedChannelApis = {
+            addContextListener: () => {
+                throw new utils_1.UnsupportedChannelApiError('Channel.addContextListener');
+            },
+            broadcast: () => {
+                throw new utils_1.UnsupportedChannelApiError('Channel.broadcast');
+            },
+            getCurrentChannel: () => {
+                throw new utils_1.UnsupportedChannelApiError('Channel.getCurrentChannel');
+            }
+        };
+        // fdc3 implementation of getSystemChannels returns on array of channels, have to decorate over
+        // this so people know that these APIs are not supported
+        return channels.map((channel) => {
+            return { ...channel, type: 'system', ...unsupportedChannelApis };
+        });
+    }
+    /**
+     * 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 implementations, so this point is more-or-less moot.
+     * @param { string } channelId - Id of the context group.
+     * @returns { Promise<void> }
+     * @tutorial fdc3.joinChannel
+     * @static
+     */
+    async joinChannel(channelId) {
+        this.wire.sendAction('fdc3-join-channel').catch((e) => {
+            // we do not want to expose this error, just continue if this analytics-only call fails
+        });
+        window.fin.me.interop.joinContextGroup(channelId);
+    }
+    /**
+     * Removes the specified target from a context group.
+     * If no target is specified, it removes the sender from their context group.
+     * @returns { Promise<void> }
+     * @tutorial fdc3.leaveCurrentChannel
+     * @static
+     */
+    async leaveCurrentChannel() {
+        this.wire.sendAction('fdc3-leave-current-channel').catch((e) => {
+            // we do not want to expose this error, just continue if this analytics-only call fails
+        });
+        window.fin.me.interop.removeFromContextGroup();
+    }
+    /**
+     * Adds a listener for incoming Intents.
+     * @param { string } intent - Name of the Intent
+     * @param { IntentHandler } handler - Handler for incoming Intent
+     * @returns { Listener }
+     * @tutorial fdc3.addIntentListener
+     * @static
+     */
+    addIntentListener(intent, handler) {
+        this.wire.sendAction('fdc3-add-intent-listener').catch((e) => {
+            // we do not want to expose this error, just continue if this analytics-only call fails
+        });
+        const contextHandler = (raisedIntent) => {
+            handler(raisedIntent.context);
+        };
+        const listener = window.fin.me.interop.registerIntentHandler(contextHandler, intent);
+        return {
+            ...listener,
+            unsubscribe: () => listener.then((l) => l.unsubscribe())
+        };
+    }
+    /**
+     * Raises a specific intent.
+     * @param { string } intent Name of the Intent.
+     * @param { Context } context Context associated with the Intent.
+     * @param { TargetApp }  app App that will resolve the Intent. This is added as metadata to the Intent. Can be accessed by the app provider in {@link InteropBroker#handleFiredIntent InteropBroker.handleFiredIntent}.
+     * @returns { IntentResolution }
+     * @tutorial fdc3.raiseIntent
+     * @static
+     */
+    async raiseIntent(intent, context, app) {
+        this.wire.sendAction('fdc3-raise-intent').catch((e) => {
+            // we do not want to expose this error, just continue if this analytics-only call fails
+        });
+        const intentObj = app
+            ? { name: intent, context, metadata: { target: app } }
+            : { name: intent, context };
+        try {
+            return await window.fin.me.interop.fireIntent(intentObj);
+        }
+        catch (error) {
+            const errorToThrow = error.message === utils_2.BROKER_ERRORS.fireIntent ? 'ResolverUnavailable' : error;
+            throw new Error(errorToThrow);
+        }
+    }
+    /**
+     * Returns the Channel that the entity is subscribed to. Returns null if not joined to a channel.
+     * @returns { Channel | null }
+     * @tutorial fdc3.getCurrentChannel
+     */
+    async getCurrentChannel() {
+        this.wire.sendAction('fdc3-get-current-channel').catch((e) => {
+            // we do not want to expose this error, just continue if this analytics-only call fails
+        });
+        const currentContextGroupInfo = await this.getCurrentContextGroupInfo();
+        if (!currentContextGroupInfo) {
+            return null;
+        }
+        return this.buildChannelObject(currentContextGroupInfo);
+    }
+    /**
+     * Find out more information about a particular intent by passing its name, and optionally its context.
+     * @param { string } intent Name of the Intent
+     * @param { Context } [context]
+     * @return { Promise<AppIntent> }
+     * @tutorial fdc3.findIntent
+     */
+    async findIntent(intent, context) {
+        this.wire.sendAction('fdc3-find-intent').catch((e) => {
+            // we do not want to expose this error, just continue if this analytics-only call fails
+        });
+        try {
+            return await window.fin.me.interop.getInfoForIntent({ name: intent, context });
+        }
+        catch (error) {
+            const errorToThrow = error.message === utils_2.BROKER_ERRORS.getInfoForIntent ? 'ResolverUnavailable' : error;
+            throw new Error(errorToThrow);
+        }
+    }
+    /**
+     * Find all the available intents for a particular context.
+     * @param { Context } context
+     * @return { Promise<Array<AppIntent>> }
+     * @tutorial fdc3.findIntentsByContext
+     */
+    async findIntentsByContext(context) {
+        this.wire.sendAction('fdc3-find-intents-by-context').catch((e) => {
+            // we do not want to expose this error, just continue if this analytics-only call fails
+        });
+        try {
+            return await window.fin.me.interop.getInfoForIntentsByContext(context);
+        }
+        catch (error) {
+            const errorToThrow = error.message === utils_2.BROKER_ERRORS.getInfoForIntentsByContext ? 'ResolverUnavailable' : error;
+            throw new Error(errorToThrow);
+        }
+    }
+    /**
+     * Finds and raises an intent against a target app based purely on context data.
+     * @param { Context } context
+     * @param { TargetApp } [app]
+     * @return { Promise<IntentResolution> }
+     * @tutorial fdc3.raiseIntentForContext
+     */
+    async raiseIntentForContext(context, app) {
+        this.wire.sendAction('fdc3-raise-intent-for-context').catch((e) => {
+            // we do not want to expose this error, just continue if this analytics-only call fails
+        });
+        try {
+            return await window.fin.me.interop.fireIntentForContext({ ...context, metadata: { target: app } });
+        }
+        catch (error) {
+            const errorToThrow = error.message === utils_2.BROKER_ERRORS.fireIntentForContext ? 'ResolverUnavailable' : error;
+            throw new Error(errorToThrow);
+        }
+    }
+    /**
+     * Returns a Channel object for the specified channel, creating it as an App Channel if it does not exist.
+     * @param channelId
+     * @returns { Promise<Channel> }
+     * @tutorial fdc3.getOrCreateChannel
+     */
+    async getOrCreateChannel(channelId) {
+        this.wire.sendAction('fdc3-get-or-create-channel').catch((e) => {
+            // we do not want to expose this error, just continue if this analytics-only call fails
+        });
+        const sessionContextGroup = await window.fin.me.interop.joinSessionContextGroup(channelId);
+        return this.buildAppChannelObject(sessionContextGroup);
+    }
+    /**
+     * Returns metadata relating to the FDC3 object and its provider, including the supported version of the FDC3 specification and the name of the provider of the implementation.
+     * @return { Promise<ImplementationMetadata> }
+     * @tutorial fdc3.getInfo
+     */
+    getInfo() {
+        this.wire.sendAction('fdc3-get-info').catch((e) => {
+            // we do not want to expose this error, just continue if this analytics-only call fails
+        });
+        // @ts-expect-error
+        const { uuid, fdc3InteropApi } = fin.__internal_.initialOptions;
+        // @ts-expect-error
+        const runtimeVersion = fin.desktop.getVersion();
+        return {
+            fdc3Version: fdc3InteropApi,
+            provider: `openfin-${uuid}`,
+            providerVersion: runtimeVersion
+        };
+    }
+    // eslint-disable-next-line class-methods-use-this
+    open() {
+        throw new utils_1.UnsupportedError('open');
+    }
+    // utils
+    // eslint-disable-next-line class-methods-use-this
+    async getCurrentContextGroupInfo() {
+        const contextGroups = await window.fin.me.interop.getContextGroups();
+        const clientsInCtxGroupsPromise = contextGroups.map(async (ctxGroup) => {
+            return window.fin.me.interop.getAllClientsInContextGroup(ctxGroup.id);
+        });
+        const clientsInCtxGroups = await Promise.all(clientsInCtxGroupsPromise);
+        const clientIdx = clientsInCtxGroups.findIndex((clientIdentityArr) => {
+            return clientIdentityArr.some((clientIdentity) => {
+                const { uuid, name } = clientIdentity;
+                return window.fin.me.identity.uuid === uuid && window.fin.me.identity.name === name;
+            });
+        });
+        return contextGroups[clientIdx];
+    }
+    async buildChannelObject(currentContextGroupInfo) {
+        return {
+            ...currentContextGroupInfo,
+            type: 'system',
+            addContextListener: this.addContextListener.bind(this),
+            broadcast: this.broadcast.bind(this),
+            getCurrentContext: async (contextType) => {
+                const context = await window.fin.me.interop.getCurrentContext(contextType);
+                return context === undefined ? null : context;
+            }
+        };
+    }
+    // eslint-disable-next-line class-methods-use-this
+    buildAppChannelObject(sessionContextGroup) {
+        return {
+            id: sessionContextGroup.id,
+            type: 'app',
+            broadcast: sessionContextGroup.setContext,
+            getCurrentContext: async (contextType) => {
+                const context = await sessionContextGroup.getCurrentContext(contextType);
+                return context === undefined ? null : context;
+            },
+            addContextListener: (contextType, handler) => {
+                let listener;
+                if (typeof contextType === 'function') {
+                    console.warn('addContextListener(handler) has been deprecated. Please use addContextListener(null, handler)');
+                    listener = sessionContextGroup.addContextHandler(contextType);
+                }
+                else {
+                    listener = sessionContextGroup.addContextHandler(handler, contextType === null ? undefined : contextType);
+                }
+                return {
+                    ...listener,
+                    unsubscribe: () => listener.then((l) => l.unsubscribe())
+                };
+            }
+        };
+    }
+}
+exports.default = Fdc3Module;

package/src/api/interop/fdc3/fdc3.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerFdc3Shim = exports.versionMap = void 0;
+const fdc3_1_2_1 = require("./fdc3-1.2");
+exports.versionMap = {
+    '1.2': fdc3_1_2_1.default
+};
+function registerFdc3Shim(version, transport) {
+    if (Object.keys(exports.versionMap).includes(version)) {
+        const Api = exports.versionMap[version];
+        window.fdc3 = new Api(transport);
+    }
+    else {
+        console.error(`FDC3 API version ${version} is not supported`);
+    }
+}
+exports.registerFdc3Shim = registerFdc3Shim;

package/src/api/interop/fdc3/utils.d.ts

@@ -0,0 +1,6 @@
+export declare class UnsupportedError extends Error {
+    constructor(apiName: string);
+}
+export declare class UnsupportedChannelApiError extends Error {
+    constructor(apiName: string);
+}