@openfin/core 29.72.17 → 30.73.1

package/OpenFin.d.ts

@@ -250,13 +250,13 @@ declare namespace OpenFin {
 
     export type WindowOptions = MutableWindowOptions & ConstWindowOptions;
 
-    export type ViewVisibilityOption = { 
+    export type ViewVisibilityOption = {
         enabled?: boolean;
-    }
+    };
 
-    export type ShowViewOnWindowResizeOptions =  ViewVisibilityOption & {
+    export type ShowViewOnWindowResizeOptions = ViewVisibilityOption & {
         paintIntervalMs?: number;
-    }
+    };
 
     export type ViewVisibilityOptions = {
         showViewsOnWindowResize?: ShowViewOnWindowResizeOptions;
@@ -1427,6 +1427,7 @@ declare namespace OpenFin {
     export type IntentMetadata<TargetType = any> = {
         target?: TargetType;
         resultType?: string;
+        intentResolutionResultId?: string;
     };
 
     export type IntentHandler = (intent: OpenFin.Intent) => void;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@openfin/core",
-    "version": "29.72.17",
+    "version": "30.73.1",
     "license": "Apache-2.0",
     "main": "./src/mock.js",
     "types": "./src/mock.d.ts",

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

@@ -0,0 +1,17 @@
+declare type HandlerId = string;
+export declare class PrivateChannelClient {
+    id: string;
+    client: OpenFin.ChannelClient;
+    listeners: Map<HandlerId, FDC3v2.Listener>;
+    constructor(client: OpenFin.ChannelClient, id: string);
+    broadcast(context: OpenFin.Context): Promise<void>;
+    getCurrentContext(contextType?: string): Promise<OpenFin.Context | null>;
+    addContextListener(contextType: string | null, handler: OpenFin.ContextHandler): Promise<FDC3v2.Listener>;
+    private createNonStandardUnsubscribeCb;
+    private createContextUnsubscribeCb;
+    onAddContextListener(handler: (contextType?: string) => void): FDC3v2.Listener;
+    onDisconnect(handler: () => void): FDC3v2.Listener;
+    onUnsubscribe(handler: (contextType?: string) => void): FDC3v2.Listener;
+    disconnect(): Promise<void>;
+}
+export {};

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

@@ -0,0 +1,84 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PrivateChannelClient = void 0;
+const utils_1 = require("../utils");
+class PrivateChannelClient {
+    constructor(client, id) {
+        this.id = id;
+        this.client = client;
+        this.listeners = new Map();
+    }
+    async broadcast(context) {
+        this.client.dispatch('broadcast', { context });
+    }
+    async getCurrentContext(contextType) {
+        return this.client.dispatch('getCurrentContext', { contextType });
+    }
+    async addContextListener(contextType, handler) {
+        if (typeof handler !== 'function') {
+            throw new Error("Non-function argument passed to the second parameter 'handler'. Be aware that the argument order does not match the FDC3 standard.");
+        }
+        let handlerId;
+        if (contextType) {
+            handlerId = `contextHandler:invoke-${this.id}-${contextType}-${utils_1.generateId()}`;
+        }
+        else {
+            handlerId = `contextHandler:invoke-${this.id}-${utils_1.generateId()}`;
+        }
+        this.client.register(handlerId, utils_1.wrapContextHandler(handler, handlerId));
+        const listener = { unsubscribe: await this.createContextUnsubscribeCb(handlerId) };
+        this.listeners.set(handlerId, listener);
+        await this.client.dispatch(`contextHandlerAdded`, { handlerId, contextType });
+        return listener;
+    }
+    createNonStandardUnsubscribeCb(handlerId) {
+        return async () => {
+            this.client.remove(handlerId);
+            this.listeners.delete(handlerId);
+            await this.client.dispatch('nonStandardHandlerRemoved', { handlerId });
+        };
+    }
+    createContextUnsubscribeCb(handlerId) {
+        return async () => {
+            this.client.remove(handlerId);
+            this.listeners.delete(handlerId);
+            await this.client.dispatch('contextHandlerRemoved', { handlerId });
+        };
+    }
+    onAddContextListener(handler) {
+        const handlerId = `onContextHandlerAdded:invoke-${this.id}-${utils_1.generateId()}`;
+        this.client.register(handlerId, handler);
+        const listener = { unsubscribe: this.createNonStandardUnsubscribeCb(handlerId) };
+        this.listeners.set(handlerId, listener);
+        this.client.dispatch(`onAddContextHandlerAdded`, { handlerId });
+        return listener;
+    }
+    onDisconnect(handler) {
+        const handlerId = `onDisconnect:invoke-${this.id}-${utils_1.generateId()}`;
+        this.client.register(handlerId, handler);
+        const listener = { unsubscribe: this.createNonStandardUnsubscribeCb(handlerId) };
+        this.listeners.set(handlerId, listener);
+        this.client.dispatch(`onDisconnectHandlerAdded`, { handlerId });
+        return listener;
+    }
+    onUnsubscribe(handler) {
+        const handlerId = `onUnsubscribe:invoke-${this.id}-${utils_1.generateId()}`;
+        this.client.register(handlerId, handler);
+        const listener = { unsubscribe: this.createNonStandardUnsubscribeCb(handlerId) };
+        this.listeners.set(handlerId, listener);
+        this.client.dispatch(`onUnsubscribeHandlerAdded`, { handlerId });
+        return listener;
+    }
+    async disconnect() {
+        const promises = [];
+        const listenerUnsubscribers = Array.from(this.listeners.values());
+        for (let i = 0; i < listenerUnsubscribers.length; i++) {
+            const listener = listenerUnsubscribers[i];
+            promises.push(listener.unsubscribe());
+        }
+        await Promise.all(promises);
+        await this.client.dispatch('clientDisconnecting');
+        await this.client.disconnect();
+    }
+}
+exports.PrivateChannelClient = PrivateChannelClient;

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

@@ -0,0 +1,40 @@
+import { ChannelProvider } from '../../interappbus/channel/provider';
+declare type HandlerId = string;
+export declare class PrivateChannelProvider {
+    id: string;
+    private provider;
+    private clients;
+    private contextByContextType;
+    private lastContext;
+    constructor(provider: ChannelProvider, id: string);
+    private getClientState;
+    registerListeners(): void;
+    broadcast(payload: {
+        context: OpenFin.Context;
+    }, broadcasterClientIdentity: OpenFin.ClientIdentity): void;
+    getCurrentContext(payload: {
+        contextType?: string;
+    }, senderClientIdentity: OpenFin.ClientIdentity): OpenFin.Context | null;
+    contextHandlerAdded(payload: {
+        handlerId: HandlerId;
+        contextType?: string;
+    }, senderClientIdentity: OpenFin.ClientIdentity): void;
+    contextHandlerRemoved(payload: {
+        handlerId: HandlerId;
+    }, removingClientIdentity: OpenFin.ClientIdentity): Promise<void>;
+    nonStandardHandlerRemoved(payload: {
+        handlerId: HandlerId;
+    }, id: OpenFin.ClientIdentity): void;
+    onAddContextHandlerAdded(payload: {
+        handlerId: HandlerId;
+    }, senderClientIdentity: OpenFin.ClientIdentity): void;
+    onDisconnectHandlerAdded(payload: {
+        handlerId: HandlerId;
+    }, id: OpenFin.ClientIdentity): void;
+    onUnsubscribeHandlerAdded(payload: {
+        handlerId: HandlerId;
+    }, id: OpenFin.ClientIdentity): void;
+    clientDisconnecting(payload: {}, disconnectingClientIdentity: OpenFin.ClientIdentity): Promise<void>;
+    registerNewClient(clientIdentity: OpenFin.ClientIdentity): void;
+}
+export {};

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-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
@@ -203,7 +217,7 @@ export default class Fdc3Module2 extends Base implements FDC3v2.DesktopAgent {
      * @param { Context } context Context associated with the Intent
      * @param { AppIdentifier | TargetApp } [app]
      * @returns { Promise<IntentResolution(2)> }
-     * @tutorial fdc3.raiseIntent
+     * @tutorial fdc3v2.raiseIntent
      */
     raiseIntent(intent: string, context: OpenFin.Context, app?: FDC3v2.AppIdentifier | FDC3.TargetApp): Promise<FDC3v2.IntentResolution>;
     /**
@@ -211,7 +225,7 @@ export default class Fdc3Module2 extends Base implements FDC3v2.DesktopAgent {
      * @param { Context } context Context associated with the Intent
      * @param { AppIdentifier | TargetApp } [app]
      * @returns { Promise<IntentResolution(2)> }
-     * @tutorial fdc3.raiseIntentForContext
+     * @tutorial fdc3v2.raiseIntentForContext
      */
     raiseIntentForContext(context: OpenFin.Context, app?: FDC3v2.AppIdentifier | FDC3.TargetApp): Promise<FDC3v2.IntentResolution>;
     /**
@@ -229,7 +243,14 @@ 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>;
+    connectPrivateChannel(channelId: string): Promise<FDC3v2.PrivateChannel>;
+    private buildPrivateChannelObject;
     /**
      * 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

@@ -3,7 +3,10 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const base_1 = require("../../base");
 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.
@@ -106,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
@@ -281,20 +298,39 @@ class Fdc3Module2 extends base_1.Base {
      * @param { Context } context Context associated with the Intent
      * @param { AppIdentifier | TargetApp } [app]
      * @returns { Promise<IntentResolution(2)> }
-     * @tutorial fdc3.raiseIntent
+     * @tutorial fdc3v2.raiseIntent
      */
     async raiseIntent(intent, context, app) {
-        return this.fdc3Module.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
+        });
+        try {
+            return utils_2.getIntentResolution(this.fin.me.interop, context, app, intent);
+        }
+        catch (error) {
+            const errorToThrow = error.message === utils_1.BROKER_ERRORS.fireIntent ? 'ResolverUnavailable' : error;
+            throw new Error(errorToThrow);
+        }
     }
     /**
      * Finds and raises an intent against apps registered with the desktop agent based purely on the type of the context data.
      * @param { Context } context Context associated with the Intent
      * @param { AppIdentifier | TargetApp } [app]
      * @returns { Promise<IntentResolution(2)> }
-     * @tutorial fdc3.raiseIntentForContext
+     * @tutorial fdc3v2.raiseIntentForContext
      */
     async raiseIntentForContext(context, app) {
-        return this.fdc3Module.raiseIntentForContext(context, app);
+        // TODO: We have to do the same thing we do for raiseIntent here as well.
+        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 utils_2.getIntentResolution(this.fin.me.interop, context, app);
+        }
+        catch (error) {
+            const errorToThrow = error.message === utils_1.BROKER_ERRORS.fireIntent ? 'ResolverUnavailable' : error;
+            throw new Error(errorToThrow);
+        }
     }
     /**
      * Adds a listener for incoming intents.
@@ -307,13 +343,33 @@ class Fdc3Module2 extends base_1.Base {
         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
         });
+        if (typeof intent !== 'string') {
+            throw new Error('First argument must be an Intent name');
+        }
         // The FDC3 Intenter handler only expects the context and contextMetadata to be passed to the handler,
         // so we wrap it here and only pass those paramaters.
-        const contextHandler = (raisedIntent) => {
-            const { context } = raisedIntent;
-            const { contextMetadata, ...rest } = context;
-            const args = contextMetadata ? [{ ...rest }, contextMetadata] : [context, null];
-            handler(...args);
+        const contextHandler = async (raisedIntent) => {
+            const { context, metadata: intentMetadata } = raisedIntent;
+            const { contextMetadata, metadata, ...rest } = context;
+            let intentResult;
+            try {
+                const newContext = metadata ? { metadata, ...rest } : { ...rest };
+                intentResult = await handler(newContext, contextMetadata);
+            }
+            catch (error) {
+                intentResult = error;
+            }
+            const intentResolutionResultId = (intentMetadata === null || intentMetadata === void 0 ? void 0 : intentMetadata.intentResolutionResultId) || (metadata === null || metadata === void 0 ? void 0 : metadata.intentResolutionResultId);
+            if (intentResolutionResultId) {
+                // Send whatever the result is.
+                fin.InterApplicationBus.publish(intentResolutionResultId, intentResult);
+            }
+            if (intentResult instanceof Error) {
+                throw new Error(intentResult.message);
+            }
+            else {
+                return intentResult;
+            }
         };
         return this.fin.me.interop.registerIntentHandler(contextHandler, intent, { fdc3Version: '2.0' });
     }
@@ -326,9 +382,80 @@ 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 = 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 this.buildPrivateChannelObject(newPrivateChannelClient);
+    }
+    // TODO: need to remove this method and not expose it. Added temporarily for the purposes of testing.
+    // eslint-disable-next-line class-methods-use-this
+    async connectPrivateChannel(channelId) {
+        try {
+            const channelClient = await fin.InterApplicationBus.Channel.connect(channelId);
+            const privateChannelClient = new PrivateChannelClient_1.PrivateChannelClient(channelClient, channelId);
+            return this.buildPrivateChannelObject(privateChannelClient);
+        }
+        catch (error) {
+            throw new Error(`Private Channel with id: ${channelId} doesn't exist`);
+        }
+    }
+    // eslint-disable-next-line class-methods-use-this
+    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);
+            }
+        };
     }
     /**
      * Retrieves a list of the User Channels available for the app to join.

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

@@ -1,3 +1,14 @@
 export declare class UnsupportedChannelApiError extends Error {
     constructor(apiName: string);
 }
+export declare enum ResultError {
+    /** Returned if the `IntentHandler` exited without returning a Promise or that
+     *  Promise was not resolved with a Context or Channel object.
+     */
+    NoResultReturned = "NoResultReturned",
+    /** Returned if the `IntentHandler` function processing the raised intent
+     *  throws an error or rejects the Promise it returned.
+     */
+    IntentHandlerRejected = "IntentHandlerRejected"
+}
+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,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.UnsupportedChannelApiError = void 0;
+exports.getIntentResolution = exports.ResultError = exports.UnsupportedChannelApiError = void 0;
+const utils_1 = require("../utils");
 class UnsupportedChannelApiError extends Error {
     constructor(apiName) {
         super(apiName);
@@ -8,3 +9,55 @@ class UnsupportedChannelApiError extends Error {
     }
 }
 exports.UnsupportedChannelApiError = UnsupportedChannelApiError;
+var ResultError;
+(function (ResultError) {
+    /** Returned if the `IntentHandler` exited without returning a Promise or that
+     *  Promise was not resolved with a Context or Channel object.
+     */
+    ResultError["NoResultReturned"] = "NoResultReturned";
+    /** Returned if the `IntentHandler` function processing the raised intent
+     *  throws an error or rejects the Promise it returned.
+     */
+    ResultError["IntentHandlerRejected"] = "IntentHandlerRejected";
+})(ResultError = exports.ResultError || (exports.ResultError = {}));
+exports.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();
+    // Promise we'll use in getResult
+    const getResultPromise = new Promise((resolve) => {
+        fin.InterApplicationBus.subscribe({ uuid: '*' }, guid, (intentResult) => {
+            resolve(intentResult);
+        });
+    });
+    // Adding the intentResolutionResultId to the intentObj. Because fireIntent only accepts a single arg, we have to slap it in here.
+    const metadata = app ? { target: app, intentResolutionResultId: guid } : { intentResolutionResultId: guid };
+    const intentObj = intent ? { name: intent, context, metadata } : { ...context, metadata };
+    // Set up the getResult call.
+    const getResult = async () => {
+        const intentResult = await getResultPromise;
+        if (!intentResult) {
+            throw new Error(ResultError.NoResultReturned);
+        }
+        if (intentResult instanceof Error) {
+            throw new Error(ResultError.IntentHandlerRejected);
+        }
+        return intentResult;
+    };
+    // Finally fire the intent.
+    const intentResolutionInfoFromBroker = intent
+        ? await interopModule.fireIntent(intentObj)
+        : await interopModule.fireIntentForContext(intentObj);
+    if (typeof intentResolutionInfoFromBroker !== 'object') {
+        return {
+            source: {
+                appId: '',
+                instanceId: ''
+            },
+            intent: '',
+            version: '2.0',
+            getResult
+        };
+    }
+    return { ...intentResolutionInfoFromBroker, getResult };
+};

package/src/api/interop/utils.js

@@ -45,7 +45,7 @@ exports.BROKER_ERRORS = {
 exports.wrapIntentHandler = (handler, handlerId) => {
     return async (intent) => {
         try {
-            await handler(intent);
+            return handler(intent);
         }
         catch (error) {
             console.error(`Error thrown by handler ${handlerId}: ${error}`);