@openfin/core 29.72.17 → 29.73.1

package/src/api/interop/SessionContextGroupClient.js

@@ -1,27 +1,25 @@
 "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 __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), 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 __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
 };
-var _clientPromise;
+var _SessionContextGroupClient_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);
+        _SessionContextGroupClient_clientPromise.set(this, void 0);
         this.id = id;
-        __classPrivateFieldSet(this, _clientPromise, client);
+        __classPrivateFieldSet(this, _SessionContextGroupClient_clientPromise, client, "f");
     }
     /**
      * Sets a context for the session context group.
@@ -33,7 +31,7 @@ class SessionContextGroupClient extends base_1.Base {
         this.wire.sendAction('interop-session-context-group-set-context').catch((e) => {
             // don't expose, analytics-only call
         });
-        const client = await __classPrivateFieldGet(this, _clientPromise);
+        const client = await __classPrivateFieldGet(this, _SessionContextGroupClient_clientPromise, "f");
         return client.dispatch(`sessionContextGroup:setContext-${this.id}`, {
             sessionContextGroupId: this.id,
             context
@@ -43,7 +41,7 @@ class SessionContextGroupClient extends base_1.Base {
         this.wire.sendAction('interop-session-context-group-get-context').catch((e) => {
             // don't expose, analytics-only call
         });
-        const client = await __classPrivateFieldGet(this, _clientPromise);
+        const client = await __classPrivateFieldGet(this, _SessionContextGroupClient_clientPromise, "f");
         return client.dispatch(`sessionContextGroup:getContext-${this.id}`, {
             sessionContextGroupId: this.id,
             type
@@ -56,20 +54,20 @@ class SessionContextGroupClient extends base_1.Base {
         if (typeof contextHandler !== 'function') {
             throw new Error("Non-function argument passed to the first parameter 'handler'. Be aware that the argument order does not match the FDC3 standard.");
         }
-        const client = await __classPrivateFieldGet(this, _clientPromise);
+        const client = await __classPrivateFieldGet(this, _SessionContextGroupClient_clientPromise, "f");
         let handlerId;
         if (contextType) {
-            handlerId = `sessionContextHandler:invoke-${this.id}-${contextType}-${utils_1.generateId()}`;
+            handlerId = `sessionContextHandler:invoke-${this.id}-${contextType}-${(0, utils_1.generateId)()}`;
         }
         else {
             handlerId = `sessionContextHandler:invoke-${this.id}`;
         }
-        client.register(handlerId, utils_1.wrapContextHandler(contextHandler, handlerId));
+        client.register(handlerId, (0, 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);
+        const client = await __classPrivateFieldGet(this, _SessionContextGroupClient_clientPromise, "f");
         return async () => {
             client.remove(handlerId);
             await client.dispatch(`sessionContextGroup:handlerRemoved-${this.id}`, { handlerId });
@@ -78,11 +76,11 @@ class SessionContextGroupClient extends base_1.Base {
     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: ')
+            setContext: (0, utils_1.wrapInTryCatch)(this.setContext.bind(this), 'Failed to set context: '),
+            getCurrentContext: (0, utils_1.wrapInTryCatch)(this.getCurrentContext.bind(this), 'Failed to get context: '),
+            addContextHandler: (0, utils_1.wrapInTryCatch)(this.addContextHandler.bind(this), 'Failed to add context handler: ')
         };
     }
 }
 exports.default = SessionContextGroupClient;
-_clientPromise = new WeakMap();
+_SessionContextGroupClient_clientPromise = new WeakMap();

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,82 @@
+"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) {
+        return 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}-${(0, utils_1.generateId)()}`;
+        }
+        else {
+            handlerId = `contextHandler:invoke-${this.id}-${(0, utils_1.generateId)()}`;
+        }
+        this.client.register(handlerId, (0, 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}-${(0, 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}-${(0, 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}-${(0, 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 listenerUnsubscribers = Array.from(this.listeners.values());
+        const promises = listenerUnsubscribers.map(async (listenerUnsubscriber) => {
+            await listenerUnsubscriber.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-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
@@ -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,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[]>}