@openfin/core 29.72.18 → 29.73.2

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

@@ -0,0 +1,224 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PrivateChannelProvider = void 0;
+const InteropBroker_1 = require("../InteropBroker");
+class PrivateChannelProvider {
+    constructor(provider, id) {
+        this.provider = provider;
+        this.id = id;
+        this.clients = new Map();
+        this.registerListeners();
+        this.contextByContextType = new Map();
+        this.lastContext = undefined;
+        this.provider.onConnection((clientIdentity) => this.registerNewClient(clientIdentity));
+        this.provider.onDisconnection((clientIdentity) => this.clients.delete(clientIdentity.endpointId));
+    }
+    getClientState(id) {
+        return this.clients.get(id.endpointId);
+    }
+    registerListeners() {
+        this.provider.register('broadcast', this.broadcast.bind(this));
+        this.provider.register('getCurrentContext', this.getCurrentContext.bind(this));
+        this.provider.register('contextHandlerAdded', this.contextHandlerAdded.bind(this));
+        this.provider.register('contextHandlerRemoved', this.contextHandlerRemoved.bind(this));
+        this.provider.register('nonStandardHandlerRemoved', this.nonStandardHandlerRemoved.bind(this));
+        this.provider.register('onAddContextHandlerAdded', this.onAddContextHandlerAdded.bind(this));
+        this.provider.register('onDisconnectHandlerAdded', this.onDisconnectHandlerAdded.bind(this));
+        this.provider.register('onUnsubscribeHandlerAdded', this.onUnsubscribeHandlerAdded.bind(this));
+        this.provider.register('clientDisconnecting', this.clientDisconnecting.bind(this));
+    }
+    broadcast(payload, broadcasterClientIdentity) {
+        const { context } = payload;
+        const broadcasterClientState = this.getClientState(broadcasterClientIdentity);
+        if (!broadcasterClientState) {
+            throw new Error(`Client with Identity: ${broadcasterClientIdentity.uuid} ${broadcasterClientIdentity.name}, tried to call broadcast, is not connected to this Private Channel`);
+        }
+        const contextIntegrityCheckResult = InteropBroker_1.InteropBroker.checkContextIntegrity(context);
+        if (contextIntegrityCheckResult.isValid === false) {
+            throw new Error(`Failed to broadcast - bad Context. Reason: ${contextIntegrityCheckResult.reason}. Context: ${JSON.stringify(context)}`);
+        }
+        this.contextByContextType.set(context.type, context);
+        this.lastContext = context;
+        Array.from(this.clients.values()).forEach((currClientState) => {
+            const handlerIdsForContextType = currClientState.handlerIdsByContextTypes.get(context.type);
+            if (handlerIdsForContextType) {
+                handlerIdsForContextType.forEach((handlerId) => {
+                    this.provider.dispatch(currClientState.clientIdentity, handlerId, context);
+                });
+            }
+            if (currClientState.globalHandler) {
+                this.provider.dispatch(currClientState.clientIdentity, currClientState.globalHandler, context);
+            }
+        });
+    }
+    getCurrentContext(payload, senderClientIdentity) {
+        const { contextType } = payload;
+        const clientState = this.getClientState(senderClientIdentity);
+        if (!clientState) {
+            throw new Error(`Client with Identity: ${senderClientIdentity.uuid} ${senderClientIdentity.name}, tried to call getCurrentContext, is not connected to this Private Channel`);
+        }
+        if (contextType !== undefined) {
+            const currentContext = this.contextByContextType.get(contextType);
+            if (currentContext)
+                return currentContext;
+            return null;
+        }
+        return this.lastContext ? this.lastContext : null;
+    }
+    contextHandlerAdded(payload, senderClientIdentity) {
+        const { handlerId, contextType } = payload;
+        const senderClientState = this.getClientState(senderClientIdentity);
+        if (!senderClientState) {
+            throw new Error(`Client with Identity: ${senderClientIdentity.uuid} ${senderClientIdentity.name}, tried to call addContextListener, is not connected to this Private Channel`);
+        }
+        if (contextType) {
+            const currentHandlersList = senderClientState.handlerIdsByContextTypes.get(contextType) || [];
+            senderClientState.handlerIdsByContextTypes.set(contextType, [...currentHandlersList, handlerId]);
+            const currContext = this.contextByContextType.get(contextType);
+            if (currContext) {
+                this.provider.dispatch(senderClientIdentity, handlerId, currContext);
+            }
+        }
+        else {
+            senderClientState.globalHandler = handlerId;
+            if (this.lastContext) {
+                this.provider.dispatch(senderClientIdentity, handlerId, this.lastContext);
+            }
+        }
+        Array.from(this.clients.values()).forEach((currClientState) => {
+            if (currClientState.clientIdentity.endpointId !== senderClientIdentity.endpointId &&
+                currClientState.onAddContextListenerHandlerId) {
+                this.provider.dispatch(currClientState.clientIdentity, currClientState.onAddContextListenerHandlerId, contextType);
+            }
+        });
+    }
+    async contextHandlerRemoved(payload, removingClientIdentity) {
+        // MC: Made this removal async to ensure that onUnsubscribe handlers are hit before anything else happens.
+        const { handlerId } = payload;
+        const removingClientState = this.getClientState(removingClientIdentity);
+        if (removingClientState) {
+            let contextType;
+            if (removingClientState.globalHandler === handlerId) {
+                removingClientState.globalHandler = undefined;
+            }
+            else {
+                for (const [currContextType, handlersIds] of removingClientState.handlerIdsByContextTypes) {
+                    const index = handlersIds.indexOf(handlerId);
+                    if (index > -1) {
+                        handlersIds.splice(index, 1);
+                        contextType = currContextType;
+                    }
+                }
+            }
+            const dispatchesToSend = [];
+            const otherClientStates = Array.from(this.clients.values());
+            for (let i = 0; i < otherClientStates.length; i++) {
+                const otherClientState = otherClientStates[i];
+                if (otherClientState.clientIdentity.endpointId !== removingClientIdentity.endpointId &&
+                    otherClientState.onUnsubscribeHandlerId) {
+                    dispatchesToSend.push(this.provider.dispatch(otherClientState.clientIdentity, otherClientState.onUnsubscribeHandlerId, contextType));
+                }
+            }
+            try {
+                await Promise.all(dispatchesToSend);
+            }
+            catch (error) {
+                console.error(`Problem when attempting to dispatch to onUnsubscribeHandlers. Error: ${error} Removing Client: ${handlerId}. uuid: ${removingClientIdentity.uuid}. name: ${removingClientIdentity.name}. endpointId: ${removingClientIdentity.endpointId}`);
+                throw new Error(error);
+            }
+        }
+        else {
+            console.warn(`Trying to remove a handler from a client that isn't mapped. handlerId: ${handlerId}. uuid: ${removingClientIdentity.uuid}. name: ${removingClientIdentity.name}. endpointId: ${removingClientIdentity.endpointId}.`);
+        }
+    }
+    nonStandardHandlerRemoved(payload, id) {
+        const { handlerId } = payload;
+        const clientState = this.getClientState(id);
+        if (clientState) {
+            if (clientState.onDisconnectHandlerId === handlerId) {
+                clientState.onDisconnectHandlerId = undefined;
+            }
+            else if (clientState.onAddContextListenerHandlerId === handlerId) {
+                clientState.onAddContextListenerHandlerId = undefined;
+            }
+            else if (clientState.onUnsubscribeHandlerId === handlerId) {
+                clientState.onUnsubscribeHandlerId = undefined;
+            }
+        }
+        else {
+            console.warn(`Trying to remove a handler from a client that isn't mapped. handlerId: ${handlerId}. clientIdentity: ${id}`);
+        }
+    }
+    onAddContextHandlerAdded(payload, senderClientIdentity) {
+        const clientState = this.getClientState(senderClientIdentity);
+        const { handlerId } = payload;
+        if (!clientState) {
+            throw new Error(`Client with Identity: ${senderClientIdentity.uuid} ${senderClientIdentity.name}, tried to call onAddContextListener, is not connected to this Private Channel`);
+        }
+        clientState.onAddContextListenerHandlerId = handlerId;
+        // FDC3 Spec says that the added listener should fire for all previously-registered addContextListeners from the other client
+        Array.from(this.clients.values()).forEach((otherClientState) => {
+            if (otherClientState.clientIdentity.endpointId !== senderClientIdentity.endpointId) {
+                Array.from(otherClientState.handlerIdsByContextTypes.keys()).forEach((subscribedContextType) => {
+                    this.provider.dispatch(senderClientIdentity, handlerId, subscribedContextType);
+                });
+            }
+        });
+    }
+    onDisconnectHandlerAdded(payload, id) {
+        const clientState = this.getClientState(id);
+        const { handlerId } = payload;
+        if (!clientState) {
+            throw new Error(`Client with Identity: ${id.uuid} ${id.name}, tried to call onDisconnect, is not connected to this Private Channel`);
+        }
+        clientState.onDisconnectHandlerId = handlerId;
+    }
+    onUnsubscribeHandlerAdded(payload, id) {
+        const clientState = this.getClientState(id);
+        const { handlerId } = payload;
+        if (!clientState) {
+            throw new Error(`Client with Identity: ${id.uuid} ${id.name}, tried to call onUnsubscribe, is not connected to this Private Channel`);
+        }
+        clientState.onUnsubscribeHandlerId = handlerId;
+    }
+    async clientDisconnecting(payload, disconnectingClientIdentity) {
+        const disconnectingClientState = this.getClientState(disconnectingClientIdentity);
+        if (!disconnectingClientState) {
+            throw new Error(`Client with Identity: ${disconnectingClientIdentity.uuid} ${disconnectingClientIdentity.name}, tried to call disconnect, is not connected to this Private Channel`);
+        }
+        disconnectingClientState.handlerIdsByContextTypes.clear();
+        this.clients.delete(disconnectingClientIdentity.endpointId);
+        const dispatchesToSend = [];
+        // TODO: call onDisconnect Handler of the other client only.
+        // CURRENTLY, just calling the onDisconnect handler for all the other clients. Once we limit it to just one other client, we can eliminate all the iteration code.
+        const otherClientStates = Array.from(this.clients.values());
+        for (let i = 0; i < otherClientStates.length; i++) {
+            const otherClientState = otherClientStates[i];
+            if (otherClientState.clientIdentity.endpointId !== disconnectingClientIdentity.endpointId &&
+                otherClientState.onDisconnectHandlerId) {
+                dispatchesToSend.push(this.provider.dispatch(otherClientState.clientIdentity, otherClientState.onDisconnectHandlerId));
+            }
+        }
+        try {
+            await Promise.all(dispatchesToSend);
+        }
+        catch (error) {
+            console.error(`Problem when attempting to dispatch to onDisconnectHandlers. Error: ${error} Disconnecting Client: uuid: ${disconnectingClientIdentity.uuid}. name: ${disconnectingClientIdentity.name}. endpointId: ${disconnectingClientIdentity.endpointId}`);
+            throw new Error(error);
+        }
+    }
+    registerNewClient(clientIdentity) {
+        if (!this.clients.has(clientIdentity.endpointId)) {
+            const clientSubscriptionState = {
+                clientIdentity,
+                handlerIdsByContextTypes: new Map(),
+                globalHandler: undefined,
+                onAddContextListenerHandlerId: undefined,
+                onUnsubscribeHandlerId: undefined,
+                onDisconnectHandlerId: undefined
+            };
+            this.clients.set(clientIdentity.endpointId, clientSubscriptionState);
+        }
+    }
+}
+exports.PrivateChannelProvider = PrivateChannelProvider;

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

@@ -204,5 +204,4 @@ export default class Fdc3Module extends Base implements FDC3.DesktopAgent {
     open(app: FDC3.TargetApp, context?: OpenFin.Context): Promise<void>;
     private getCurrentContextGroupInfo;
     private buildChannelObject;
-    private buildAppChannelObject;
 }

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

@@ -329,7 +329,7 @@ class Fdc3Module extends base_1.Base {
             // we do not want to expose this error, just continue if this analytics-only call fails
         });
         const sessionContextGroup = await this.fin.me.interop.joinSessionContextGroup(channelId);
-        return this.buildAppChannelObject(sessionContextGroup);
+        return (0, utils_1.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.
@@ -397,31 +397,5 @@ class Fdc3Module extends base_1.Base {
             }
         };
     }
-    // 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-2.0.d.ts

@@ -102,6 +102,20 @@ import Transport from '../../../transport/transport';
  * @property { string } [version] The version number of the Intents schema being used.
  * @property { Function } getResult {@link getResult Function} that returns a promise that will resolve to either `Context` data returned by the application that resolves the raised intent or a `Channel` established and returned by the app resolving the intent.
  */
+/**
+ * @typedef { object } PrivateChannel
+ * @summary Object representing a private context channel, which is intended to support secure communication between applications, and extends the Channel interface with event handlers which provide information on the connection state of both parties, ensuring that desktop agents do not need to queue or retain messages that are broadcast before a context listener is added and that applications are able to stop broadcasting messages when the other party has disconnected.
+ * @property { string } id Private Channel Id
+ * @property { string } type Channel Type
+ * @property { DisplayMetadata } [displayMetadata]
+ * @property { function } broadcast
+ * @property { function } getCurrentContext
+ * @property { function } addContextListener
+ * @property { function } onAddContextListener
+ * @property { function } onUnsubscribe
+ * @property { function } onDisconnect
+ * @property { function } disconnect
+ */
 /**
  * @class
  * @alias fdc3v2
@@ -229,7 +243,12 @@ export default class Fdc3Module2 extends Base implements FDC3v2.DesktopAgent {
      * @tutorial fdc3.getOrCreateChannel
      */
     getOrCreateChannel(channelId: string): Promise<FDC3.Channel>;
-    createPrivateChannel(): Promise<FDC3v2.PrivateChannel | void>;
+    /**
+     * Returns a Channel with an auto-generated identity that is intended for private communication between applications. Primarily used to create channels that will be returned to other applications via an IntentResolution for a raised intent.
+     * @returns { Promise<PrivateChannel> }
+     * @tutorial fdc3v2.createPrivateChannel
+     */
+    createPrivateChannel(): Promise<FDC3v2.PrivateChannel>;
     /**
      * Retrieves a list of the User Channels available for the app to join.
      * @returns { Promise<Channel[]>}

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

@@ -5,6 +5,8 @@ const utils_1 = require("../utils");
 const InteropClient_1 = require("../InteropClient");
 const utils_2 = require("./utils");
 const fdc3_1_2_1 = require("./fdc3-1.2");
+const PrivateChannelClient_1 = require("./PrivateChannelClient");
+const PrivateChannelProvider_1 = require("./PrivateChannelProvider");
 /**
  * @typedef { object } AppIdentifier
  * @summary Identifies an application, or instance of an application, and is used to target FDC3 API calls at specific applications.
@@ -107,6 +109,20 @@ const fdc3_1_2_1 = require("./fdc3-1.2");
  * @property { string } [version] The version number of the Intents schema being used.
  * @property { Function } getResult {@link getResult Function} that returns a promise that will resolve to either `Context` data returned by the application that resolves the raised intent or a `Channel` established and returned by the app resolving the intent.
  */
+/**
+ * @typedef { object } PrivateChannel
+ * @summary Object representing a private context channel, which is intended to support secure communication between applications, and extends the Channel interface with event handlers which provide information on the connection state of both parties, ensuring that desktop agents do not need to queue or retain messages that are broadcast before a context listener is added and that applications are able to stop broadcasting messages when the other party has disconnected.
+ * @property { string } id Private Channel Id
+ * @property { string } type Channel Type
+ * @property { DisplayMetadata } [displayMetadata]
+ * @property { function } broadcast
+ * @property { function } getCurrentContext
+ * @property { function } addContextListener
+ * @property { function } onAddContextListener
+ * @property { function } onUnsubscribe
+ * @property { function } onDisconnect
+ * @property { function } disconnect
+ */
 /**
  * @class
  * @alias fdc3v2
@@ -289,7 +305,7 @@ class Fdc3Module2 extends base_1.Base {
             // we do not want to expose this error, just continue if this analytics-only call fails
         });
         try {
-            return utils_2.getIntentResolution(this.fin.me.interop, context, app, intent);
+            return (0, utils_2.getIntentResolution)(this.fin.me.interop, context, app, intent);
         }
         catch (error) {
             const errorToThrow = error.message === utils_1.BROKER_ERRORS.fireIntent ? 'ResolverUnavailable' : error;
@@ -309,7 +325,7 @@ class Fdc3Module2 extends base_1.Base {
             // we do not want to expose this error, just continue if this analytics-only call fails
         });
         try {
-            return utils_2.getIntentResolution(this.fin.me.interop, context, app);
+            return (0, utils_2.getIntentResolution)(this.fin.me.interop, context, app);
         }
         catch (error) {
             const errorToThrow = error.message === utils_1.BROKER_ERRORS.fireIntent ? 'ResolverUnavailable' : error;
@@ -366,9 +382,18 @@ class Fdc3Module2 extends base_1.Base {
     async getOrCreateChannel(channelId) {
         return this.fdc3Module.getOrCreateChannel(channelId);
     }
-    // eslint-disable-next-line class-methods-use-this
+    /**
+     * Returns a Channel with an auto-generated identity that is intended for private communication between applications. Primarily used to create channels that will be returned to other applications via an IntentResolution for a raised intent.
+     * @returns { Promise<PrivateChannel> }
+     * @tutorial fdc3v2.createPrivateChannel
+     */
     async createPrivateChannel() {
-        // private channels will be implemented in another PR
+        const channelId = (0, utils_1.generateId)();
+        const channelProvider = await this.fin.InterApplicationBus.Channel.create(channelId);
+        const newPrivateChannelProvider = new PrivateChannelProvider_1.PrivateChannelProvider(channelProvider, channelId);
+        const channelClient = await this.fin.InterApplicationBus.Channel.connect(channelId);
+        const newPrivateChannelClient = new PrivateChannelClient_1.PrivateChannelClient(channelClient, channelId);
+        return (0, utils_2.buildPrivateChannelObject)(newPrivateChannelClient);
     }
     /**
      * Retrieves a list of the User Channels available for the app to join.

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

@@ -1,3 +1,4 @@
+import { PrivateChannelClient } from './PrivateChannelClient';
 export declare class UnsupportedChannelApiError extends Error {
     constructor(apiName: string);
 }
@@ -11,4 +12,7 @@ export declare enum ResultError {
      */
     IntentHandlerRejected = "IntentHandlerRejected"
 }
+export declare const buildPrivateChannelObject: (privateChannelClient: PrivateChannelClient) => FDC3v2.PrivateChannel;
+export declare const buildAppChannelObject: (sessionContextGroup: OpenFin.SessionContextGroup) => FDC3.Channel;
+export declare const connectPrivateChannel: (channelId: string) => Promise<FDC3v2.PrivateChannel>;
 export declare const getIntentResolution: (interopModule: OpenFin.InteropClient, context: OpenFin.Context, app?: FDC3v2.AppIdentifier | FDC3.TargetApp, intent?: string) => Promise<FDC3v2.IntentResolution>;

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

@@ -1,7 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getIntentResolution = exports.ResultError = exports.UnsupportedChannelApiError = void 0;
+exports.getIntentResolution = exports.connectPrivateChannel = exports.buildAppChannelObject = exports.buildPrivateChannelObject = exports.ResultError = exports.UnsupportedChannelApiError = void 0;
 const utils_1 = require("../utils");
+const PrivateChannelClient_1 = require("./PrivateChannelClient");
 class UnsupportedChannelApiError extends Error {
     constructor(apiName) {
         super(apiName);
@@ -20,10 +21,97 @@ var ResultError;
      */
     ResultError["IntentHandlerRejected"] = "IntentHandlerRejected";
 })(ResultError = exports.ResultError || (exports.ResultError = {}));
-exports.getIntentResolution = async (interopModule, context, app, intent) => {
+const buildPrivateChannelObject = (privateChannelClient) => {
+    let clientDisconnected = false;
+    const checkIfClientDisconnected = () => {
+        if (clientDisconnected) {
+            throw new Error('Private Channel Client has been disconnected from the Private Channel');
+        }
+    };
+    return {
+        id: privateChannelClient.id,
+        type: 'private',
+        broadcast: async (context) => {
+            checkIfClientDisconnected();
+            return privateChannelClient.broadcast(context);
+        },
+        getCurrentContext: async (contextType) => {
+            checkIfClientDisconnected();
+            return privateChannelClient.getCurrentContext(contextType);
+        },
+        addContextListener: async (contextType, handler) => {
+            checkIfClientDisconnected();
+            let handlerInUse = handler;
+            let contextTypeInUse = contextType;
+            if (typeof contextType === 'function') {
+                console.warn('addContextListener(handler) has been deprecated. Please use addContextListener(null, handler)');
+                handlerInUse = contextType;
+                contextTypeInUse = null;
+            }
+            const listener = privateChannelClient.addContextListener(contextTypeInUse, handlerInUse);
+            return listener;
+        },
+        onAddContextListener: (handler) => {
+            checkIfClientDisconnected();
+            return privateChannelClient.onAddContextListener(handler);
+        },
+        disconnect: async () => {
+            checkIfClientDisconnected();
+            clientDisconnected = true;
+            return privateChannelClient.disconnect();
+        },
+        onDisconnect: (handler) => {
+            checkIfClientDisconnected();
+            return privateChannelClient.onDisconnect(handler);
+        },
+        onUnsubscribe: (handler) => {
+            checkIfClientDisconnected();
+            return privateChannelClient.onUnsubscribe(handler);
+        }
+    };
+};
+exports.buildPrivateChannelObject = buildPrivateChannelObject;
+const 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.buildAppChannelObject = buildAppChannelObject;
+const connectPrivateChannel = async (channelId) => {
+    try {
+        const channelClient = await fin.InterApplicationBus.Channel.connect(channelId);
+        const privateChannelClient = new PrivateChannelClient_1.PrivateChannelClient(channelClient, channelId);
+        return (0, exports.buildPrivateChannelObject)(privateChannelClient);
+    }
+    catch (error) {
+        throw new Error(`Private Channel with id: ${channelId} doesn't exist`);
+    }
+};
+exports.connectPrivateChannel = connectPrivateChannel;
+const getIntentResolution = async (interopModule, context, app, intent) => {
     // Generate an ID to make a session context group with. We will pass that ID to the Broker.
     // The broker will then setContext on that session context group later with our Intent Result,
-    const guid = utils_1.generateId();
+    const guid = (0, utils_1.generateId)();
     // Promise we'll use in getResult
     const getResultPromise = new Promise((resolve) => {
         fin.InterApplicationBus.subscribe({ uuid: '*' }, guid, (intentResult) => {
@@ -35,13 +123,32 @@ exports.getIntentResolution = async (interopModule, context, app, intent) => {
     const intentObj = intent ? { name: intent, context, metadata } : { ...context, metadata };
     // Set up the getResult call.
     const getResult = async () => {
-        const intentResult = await getResultPromise;
+        let intentResult = await getResultPromise;
         if (!intentResult) {
             throw new Error(ResultError.NoResultReturned);
         }
         if (intentResult instanceof Error) {
             throw new Error(ResultError.IntentHandlerRejected);
         }
+        if (typeof intentResult === 'object') {
+            const { id, type } = intentResult;
+            if (type && id && typeof id === 'string') {
+                switch (type) {
+                    case 'private': {
+                        intentResult = await (0, exports.connectPrivateChannel)(id);
+                        break;
+                    }
+                    case 'app': {
+                        const sessionContextGroup = await interopModule.joinSessionContextGroup(id);
+                        intentResult = (0, exports.buildAppChannelObject)(sessionContextGroup);
+                        break;
+                    }
+                    default: {
+                        break;
+                    }
+                }
+            }
+        }
         return intentResult;
     };
     // Finally fire the intent.
@@ -61,3 +168,4 @@ exports.getIntentResolution = async (interopModule, context, app, intent) => {
     }
     return { ...intentResolutionInfoFromBroker, getResult };
 };
+exports.getIntentResolution = getIntentResolution;

package/src/api/interop/index.js

@@ -1,14 +1,18 @@
 "use strict";
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
-    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
 }) : (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
     o[k2] = m[k];
 }));
 var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !exports.hasOwnProperty(p)) __createBinding(exports, m, p);
-}
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 const Factory_1 = require("./Factory");
 exports.default = Factory_1.default;

package/src/api/interop/utils.js

@@ -1,8 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.wrapIntentHandler = exports.BROKER_ERRORS = exports.generateOverrideWarning = exports.generateOverrideError = exports.wrapContextHandler = exports.wrapInTryCatch = exports.generateId = void 0;
-exports.generateId = () => `${Math.random()}${Date.now()}`;
-exports.wrapInTryCatch = (f, prefix) => (...args) => {
+const generateId = () => `${Math.random()}${Date.now()}`;
+exports.generateId = generateId;
+const wrapInTryCatch = (f, prefix) => (...args) => {
     try {
         return f(...args);
     }
@@ -10,7 +11,8 @@ exports.wrapInTryCatch = (f, prefix) => (...args) => {
         throw new Error((prefix || '') + e);
     }
 };
-exports.wrapContextHandler = (handler, handlerId) => {
+exports.wrapInTryCatch = wrapInTryCatch;
+const wrapContextHandler = (handler, handlerId) => {
     return async (context) => {
         try {
             await handler(context);
@@ -21,28 +23,31 @@ exports.wrapContextHandler = (handler, handlerId) => {
         }
     };
 };
-exports.generateOverrideError = (clientApi, brokerApi) => {
+exports.wrapContextHandler = wrapContextHandler;
+const generateOverrideError = (clientApi, brokerApi) => {
     return `You have tried to to use ${clientApi} but ${brokerApi} has not been overridden in the Interop Broker. Please override this function. Refer to our documentation for more info.`;
 };
-exports.generateOverrideWarning = (fdc3ClientApi, brokerApi, identity, interopClientApi) => {
+exports.generateOverrideError = generateOverrideError;
+const generateOverrideWarning = (fdc3ClientApi, brokerApi, identity, interopClientApi) => {
     const { uuid, name } = identity;
     const message = interopClientApi
         ? `Entity with identity: ${uuid}/${name} has called ${interopClientApi} or ${fdc3ClientApi} but ${brokerApi} has not been overridden.`
         : `Entity with identity: ${uuid}/${name} has called ${fdc3ClientApi} but ${brokerApi} has not been overridden.`;
     return message;
 };
+exports.generateOverrideWarning = generateOverrideWarning;
 exports.BROKER_ERRORS = {
-    fireIntent: exports.generateOverrideError('fireIntent', 'handleFiredIntent'),
-    fireIntentForContext: exports.generateOverrideError('fireIntentForContext', 'handleFiredIntentForContext'),
-    getInfoForIntent: exports.generateOverrideError('getInfoForIntent', 'handleInfoForIntent'),
-    getInfoForIntentsByContext: exports.generateOverrideError('getInfoForIntentsByContext', 'handleInfoForIntentsByContext'),
+    fireIntent: (0, exports.generateOverrideError)('fireIntent', 'handleFiredIntent'),
+    fireIntentForContext: (0, exports.generateOverrideError)('fireIntentForContext', 'handleFiredIntentForContext'),
+    getInfoForIntent: (0, exports.generateOverrideError)('getInfoForIntent', 'handleInfoForIntent'),
+    getInfoForIntentsByContext: (0, exports.generateOverrideError)('getInfoForIntentsByContext', 'handleInfoForIntentsByContext'),
     joinSessionContextGroupWithJoinContextGroup: 'The Context Group you have tried to join is a Session Context Group. Custom Context Groups can only be defined by the Interop Broker through code or manifest configuration. Please use joinSessionContextGroup.',
-    fdc3Open: exports.generateOverrideError('fdc3.open', 'fdc3HandleOpen'),
-    fdc3FindInstances: exports.generateOverrideError('fdc3.findInstances', 'fdc3HandleFindInstances'),
-    fdc3GetAppMetadata: exports.generateOverrideError('fdc3.getAppMetadata', 'fdc3HandleGetAppMetadata'),
-    fdc3GetInfo: exports.generateOverrideError('fdc3.getInfo', 'fdc3HandleGetInfo')
+    fdc3Open: (0, exports.generateOverrideError)('fdc3.open', 'fdc3HandleOpen'),
+    fdc3FindInstances: (0, exports.generateOverrideError)('fdc3.findInstances', 'fdc3HandleFindInstances'),
+    fdc3GetAppMetadata: (0, exports.generateOverrideError)('fdc3.getAppMetadata', 'fdc3HandleGetAppMetadata'),
+    fdc3GetInfo: (0, exports.generateOverrideError)('fdc3.getInfo', 'fdc3HandleGetInfo')
 };
-exports.wrapIntentHandler = (handler, handlerId) => {
+const wrapIntentHandler = (handler, handlerId) => {
     return async (intent) => {
         try {
             return handler(intent);
@@ -53,3 +58,4 @@ exports.wrapIntentHandler = (handler, handlerId) => {
         }
     };
 };
+exports.wrapIntentHandler = wrapIntentHandler;