@openfin/core 31.74.6 → 31.74.8

package/src/api/events/window.d.ts

@@ -1,6 +1,6 @@
 import type * as OpenFin from '../../OpenFin';
 import { NamedEvent, PropagatedEvent } from './base';
-import { PropagatedViewEvent } from './view';
+import { BaseViewEvent, PropagatedViewEvent, AttachedEvent as ViewAttachedEvent } from './view';
 import { NonPropagatedWebContentsEvent, WillPropagateWebContentsEvent } from './webcontents';
 export type AlertRequestedEvent = NamedEvent & {
     type: 'alert-requested';
@@ -84,11 +84,9 @@ export type WillMoveOrResizeEvent = NamedEvent & {
 export type PerformanceReportEvent = Performance & NamedEvent & {
     type: 'performance-report';
 };
-export type ViewDetachedEvent = NamedEvent & {
+export type ViewDetachedEvent = NamedEvent & BaseViewEvent & {
     type: 'view-detached';
     previousTarget: OpenFin.Identity;
-    target: OpenFin.Identity;
-    viewIdentity: OpenFin.Identity;
 };
 export type InputEvent = {
     inputType: 'keyUp' | 'keyDown';
@@ -101,6 +99,18 @@ export type InputEvent = {
     repeat: boolean;
     command?: string;
 };
+export type LayoutInitializedEvent = NamedEvent & {
+    type: 'layout-initialized';
+    ofViews: (OpenFin.Identity & {
+        entityType: 'view';
+    })[];
+};
+export type LayoutReadyEvent = NamedEvent & {
+    type: 'layout-ready';
+    views: (OpenFin.Identity & {
+        success: boolean;
+    })[];
+};
 /**
  * A Window event that does not propagate to (republish on) parent topics.
  */
@@ -141,12 +151,6 @@ export type WindowHotkeyEvent = InputEvent & NamedEvent & {
 export type WindowInitializedEvent = NamedEvent & {
     type: 'initialized';
 };
-export type LayoutInitializedEvent = NamedEvent & {
-    type: 'layout-initialized';
-};
-export type LayoutReadyEvent = NamedEvent & {
-    type: 'layout-ready';
-};
 export type MaximizedEvent = NamedEvent & {
     type: 'maximized';
 };
@@ -180,13 +184,17 @@ export type WillMoveEvent = WillMoveOrResizeEvent & {
 export type WillResizeEvent = WillMoveOrResizeEvent & {
     type: 'will-resize';
 };
+/**
+ * A propagated view event that is re-propagated from window.
+ */
+export type PropagatedViewAttachedEvent = PropagatedEvent<'view', ViewAttachedEvent>;
 /**
  * A Window event that does propagate to (republish on) parent topics.
  */
-export type WillPropagateWindowEvent = WillPropagateWebContentsEvent | PropagatedViewEvent | ViewDetachedEvent | AuthRequestedEvent | BeginUserBoundsChangingEvent | BoundsChangedEvent | BoundsChangingEvent | WindowCloseRequestedEvent | WindowClosedEvent | WindowClosingEvent | DisabledMovementBoundsChangedEvent | DisabledMovementBoundsChangingEvent | EmbeddedEvent | EndUserBoundsChangingEvent | ExternalProcessExitedEvent | ExternalProcessStartedEvent | HiddenEvent | WindowHotkeyEvent | WindowInitializedEvent | LayoutInitializedEvent | LayoutReadyEvent | MaximizedEvent | MinimizedEvent | WindowOptionsChangedEvent | PerformanceReportEvent | PreloadScriptsStateChangedEvent | PreloadScriptsStateChangingEvent | ReloadedEvent | WindowRestoredEvent | WindowShowRequestedEvent | WindowShownEvent | UserMovementDisabledEvent | UserMovementEnabledEvent | WillMoveEvent | WillRedirectEvent | WillResizeEvent;
+export type WillPropagateWindowEvent = WillPropagateWebContentsEvent | PropagatedViewAttachedEvent | ViewDetachedEvent | AuthRequestedEvent | BeginUserBoundsChangingEvent | BoundsChangedEvent | BoundsChangingEvent | WindowCloseRequestedEvent | WindowClosedEvent | WindowClosingEvent | DisabledMovementBoundsChangedEvent | DisabledMovementBoundsChangingEvent | EmbeddedEvent | EndUserBoundsChangingEvent | ExternalProcessExitedEvent | ExternalProcessStartedEvent | HiddenEvent | WindowHotkeyEvent | WindowInitializedEvent | LayoutInitializedEvent | LayoutReadyEvent | MaximizedEvent | MinimizedEvent | WindowOptionsChangedEvent | PerformanceReportEvent | PreloadScriptsStateChangedEvent | PreloadScriptsStateChangingEvent | ReloadedEvent | WindowRestoredEvent | WindowShowRequestedEvent | WindowShownEvent | UserMovementDisabledEvent | UserMovementEnabledEvent | WillMoveEvent | WillRedirectEvent | WillResizeEvent;
 export type WindowEvent = {
     topic: 'window';
-} & (WillPropagateWindowEvent | NonPropagatedWindowEvent);
+} & (WillPropagateWindowEvent | NonPropagatedWindowEvent | PropagatedViewEvent);
 export type WindowEventType = WindowEvent['type'];
-export type PropagatedWindowEvent = PropagatedEvent<'window', WillPropagateWindowEvent>;
+export type PropagatedWindowEvent = PropagatedEvent<'window', Exclude<WillPropagateWindowEvent, WindowCloseRequestedEvent>>;
 export type PropagatedWindowEventType = PropagatedWindowEvent['type'];

package/src/api/interappbus/channel/index.js

@@ -62,7 +62,7 @@ class Channel extends base_1.EmitterBase {
             if (entityType === 'iframe') {
                 // @ts-expect-error
                 // TODO: type this correctly (frame types are broken)
-                const frame = (await this.fin.me.getInfo()).url;
+                connectionUrl = (await this.fin.me.getInfo()).url;
             }
             else if (entityType === 'window' || entityType === 'view') {
                 connectionUrl = (await this.fin.me.getInfo()).url;

package/src/api/interappbus/channel/protocols/classic/strategy.js

@@ -10,7 +10,7 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
     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 _ClassicStrategy_wire, _ClassicStrategy_endpointIdentityMap;
+var _ClassicStrategy_wire, _ClassicStrategy_endpointIdentityMap, _ClassicStrategy_pendingMessagesByEndpointId;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ClassicInfo = exports.ClassicStrategy = void 0;
 /*
@@ -26,7 +26,11 @@ class ClassicStrategy {
         // Store full endpointIdentity by endpointId of all known endpoints for this strategy instance.
         // (clients will only have 1: the provider, the provider will have all clients)
         _ClassicStrategy_endpointIdentityMap.set(this, new Map());
+        // Store a set of cancellable promises to be able to reject them when client
+        // connection problems occur
+        _ClassicStrategy_pendingMessagesByEndpointId.set(this, new Map);
         this.send = async (endpointId, action, payload) => {
+            var _a;
             const to = __classPrivateFieldGet(this, _ClassicStrategy_endpointIdentityMap, "f").get(endpointId);
             if (!to) {
                 throw new Error(`Could not locate routing info for endpoint ${endpointId}`);
@@ -38,20 +42,27 @@ class ClassicStrategy {
                 delete cleanId.endpointId;
             }
             delete cleanId.isLocalEndpointId;
-            const raw = await __classPrivateFieldGet(this, _ClassicStrategy_wire, "f")
+            // grab the promise before awaiting it to save in our pending messages map
+            const p = __classPrivateFieldGet(this, _ClassicStrategy_wire, "f")
                 .sendAction('send-channel-message', {
                 ...cleanId,
                 providerIdentity: this.providerIdentity,
                 action,
                 payload
-            })
-                .catch((reason) => {
-                throw new Error(reason.message);
+            });
+            (_a = __classPrivateFieldGet(this, _ClassicStrategy_pendingMessagesByEndpointId, "f").get(endpointId)) === null || _a === void 0 ? void 0 : _a.add(p);
+            const raw = await p.catch((error) => {
+                throw new Error(error.message);
+            }).finally(() => {
+                var _a;
+                // clean up the pending promise
+                (_a = __classPrivateFieldGet(this, _ClassicStrategy_pendingMessagesByEndpointId, "f").get(endpointId)) === null || _a === void 0 ? void 0 : _a.delete(p);
             });
             return raw.payload.data.result;
         };
         this.close = async () => {
             this.messageReceiver.removeEndpoint(this.providerIdentity.channelId, this.endpointId);
+            [...__classPrivateFieldGet(this, _ClassicStrategy_endpointIdentityMap, "f").keys()].forEach((id) => this.closeEndpoint(id));
             __classPrivateFieldSet(this, _ClassicStrategy_endpointIdentityMap, new Map(), "f");
         };
         __classPrivateFieldSet(this, _ClassicStrategy_wire, wire, "f");
@@ -63,13 +74,20 @@ class ClassicStrategy {
         this.messageReceiver.addEndpoint(listener, this.providerIdentity.channelId, this.endpointId);
     }
     async closeEndpoint(endpointId) {
+        const id = __classPrivateFieldGet(this, _ClassicStrategy_endpointIdentityMap, "f").get(endpointId);
         __classPrivateFieldGet(this, _ClassicStrategy_endpointIdentityMap, "f").delete(endpointId);
+        const pendingSet = __classPrivateFieldGet(this, _ClassicStrategy_pendingMessagesByEndpointId, "f").get(endpointId);
+        pendingSet === null || pendingSet === void 0 ? void 0 : pendingSet.forEach((p) => {
+            const errorMsg = `Channel connection with identity uuid: ${id === null || id === void 0 ? void 0 : id.uuid} / name: ${id === null || id === void 0 ? void 0 : id.name} / endpointId: ${endpointId} no longer connected.`;
+            p.cancel(new Error(errorMsg));
+        });
     }
     isEndpointConnected(endpointId) {
         return __classPrivateFieldGet(this, _ClassicStrategy_endpointIdentityMap, "f").has(endpointId);
     }
     addEndpoint(endpointId, payload) {
         __classPrivateFieldGet(this, _ClassicStrategy_endpointIdentityMap, "f").set(endpointId, payload.endpointIdentity);
+        __classPrivateFieldGet(this, _ClassicStrategy_pendingMessagesByEndpointId, "f").set(endpointId, new Set());
     }
     isValidEndpointPayload(payload) {
         var _a, _b;
@@ -78,6 +96,6 @@ class ClassicStrategy {
     }
 }
 exports.ClassicStrategy = ClassicStrategy;
-_ClassicStrategy_wire = new WeakMap(), _ClassicStrategy_endpointIdentityMap = new WeakMap();
+_ClassicStrategy_wire = new WeakMap(), _ClassicStrategy_endpointIdentityMap = new WeakMap(), _ClassicStrategy_pendingMessagesByEndpointId = new WeakMap();
 // Arbitrarily starting at 5 to leave the door open to backfilling pre endpointId etc.
 exports.ClassicInfo = { version: 5, minimumVersion: 0, type: 'classic' };

package/src/api/interappbus/index.js

@@ -17,7 +17,7 @@ class InterApplicationBus extends base_1.Base {
             subscriberAdded: 'subscriber-added',
             subscriberRemoved: 'subscriber-removed'
         };
-        this.refCounter = new ref_counter_1.default();
+        this.refCounter = new ref_counter_1.RefCounter();
         this.Channel = new index_1.Channel(wire);
         this.emitter = new events_1.EventEmitter();
         wire.registerMessageHandler(this.onmessage.bind(this));

package/src/api/interop/InteropBroker.js

@@ -5,6 +5,7 @@ const base_1 = require("../base");
 const SessionContextGroupBroker_1 = require("./SessionContextGroupBroker");
 const utils_1 = require("./utils");
 const lodash_1 = require("lodash");
+const PrivateChannelProvider_1 = require("./fdc3/PrivateChannelProvider");
 let contextGroups = [
     {
         id: 'green',
@@ -1009,8 +1010,6 @@ class InteropBroker extends base_1.Base {
             });
             this.clientDisconnected(clientIdentity);
         });
-        // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-        // @ts-ignore
         channel.beforeAction(async (action, payload, clientIdentity) => {
             var _a, _b;
             if (!(await this.isActionAuthorized(action, payload, clientIdentity))) {
@@ -1052,6 +1051,11 @@ class InteropBroker extends base_1.Base {
         channel.register('fdc3v2GetInfo', async (payload, clientIdentity) => {
             return this.fdc3HandleGetInfo.bind(this)(payload, clientIdentity);
         });
+        channel.register('createPrivateChannelProvider', async (payload) => {
+            const { channelId } = payload;
+            const channelProvider = await this.fin.InterApplicationBus.Channel.create(channelId);
+            PrivateChannelProvider_1.PrivateChannelProvider.init(channelProvider, channelId);
+        });
     }
     /**
      * Can be used to completely prevent a connection. Return false to prevent connections. Allows all connections by default.

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

@@ -14,6 +14,7 @@ export declare class PrivateChannelClient {
     onAddContextListener(handler: (contextType?: string) => void): Listener;
     onDisconnect(handler: () => void): Listener;
     onUnsubscribe(handler: (contextType?: string) => void): Listener;
+    cleanUpAllSubs(): Promise<void>;
     disconnect(): Promise<void>;
 }
 export {};

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

@@ -69,14 +69,22 @@ class PrivateChannelClient {
         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();
+    async cleanUpAllSubs() {
+        const listenerUnsubscribers = Array.from(this.listeners.keys());
+        listenerUnsubscribers.forEach((handlerId) => {
+            this.client.remove(handlerId);
+            this.listeners.delete(handlerId);
         });
-        await Promise.all(promises);
-        await this.client.dispatch('clientDisconnecting');
-        await this.client.disconnect();
+    }
+    async disconnect() {
+        try {
+            await this.client.dispatch('clientDisconnecting');
+            await this.cleanUpAllSubs();
+            await this.client.disconnect();
+        }
+        catch (error) {
+            throw new Error(error.message);
+        }
     }
 }
 exports.PrivateChannelClient = PrivateChannelClient;

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

@@ -1,6 +1,15 @@
 import type * as OpenFin from '../../../OpenFin';
-import { ChannelProvider } from '../../interappbus/channel/provider';
+type ChannelProvider = OpenFin.ChannelProvider;
 type HandlerId = string;
+type ContextType = string;
+interface PrivateChannelClientState {
+    clientIdentity: OpenFin.ClientIdentity;
+    handlerIdsByContextTypes: Map<ContextType, HandlerId[]>;
+    globalHandler: HandlerId | undefined;
+    onAddContextListenerHandlerId: HandlerId | undefined;
+    onUnsubscribeHandlerId: HandlerId | undefined;
+    onDisconnectHandlerId: HandlerId | undefined;
+}
 export declare class PrivateChannelProvider {
     id: string;
     private provider;
@@ -35,7 +44,12 @@ export declare class PrivateChannelProvider {
     onUnsubscribeHandlerAdded(payload: {
         handlerId: HandlerId;
     }, id: OpenFin.ClientIdentity): void;
-    clientDisconnecting(payload: {}, disconnectingClientIdentity: OpenFin.ClientIdentity): Promise<void>;
+    removeClient(disconnectingClientIdentity: OpenFin.ClientIdentity): void;
+    fireOnDisconnectForOtherClients(disconnectingClientIdentity: OpenFin.ClientIdentity): Promise<void>;
+    unsubscribeAll(clientIdentity: OpenFin.ClientIdentity): Promise<void>;
+    handleClientDisconnecting(disconnectingClientIdentity: OpenFin.ClientIdentity): Promise<void>;
     registerNewClient(clientIdentity: OpenFin.ClientIdentity): void;
+    getConnectedClients(): Promise<PrivateChannelClientState[]>;
+    static init(channelProvider: OpenFin.ChannelProvider, id: string): PrivateChannelProvider;
 }
 export {};

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

@@ -11,7 +11,15 @@ class PrivateChannelProvider {
         this.contextByContextType = new Map();
         this.lastContext = undefined;
         this.provider.onConnection((clientIdentity) => this.registerNewClient(clientIdentity));
-        this.provider.onDisconnection((clientIdentity) => this.clients.delete(clientIdentity.endpointId));
+        this.provider.onDisconnection(async (clientIdentity) => {
+            const { endpointId } = clientIdentity;
+            if (this.clients.has(endpointId)) {
+                await this.handleClientDisconnecting(clientIdentity);
+            }
+            if ((await this.provider.getAllClientInfo()).length === 0) {
+                this.provider.destroy();
+            }
+        });
     }
     getClientState(id) {
         return this.clients.get(id.endpointId);
@@ -25,7 +33,9 @@ class PrivateChannelProvider {
         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));
+        this.provider.register('clientDisconnecting', (payload, clientIdentity) => {
+            this.handleClientDisconnecting(clientIdentity);
+        });
     }
     broadcast(payload, broadcasterClientIdentity) {
         const { context } = payload;
@@ -74,16 +84,9 @@ class PrivateChannelProvider {
         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 &&
@@ -110,17 +113,18 @@ class PrivateChannelProvider {
                     }
                 }
             }
-            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));
+            // getting only valid client connections here, it is possible we haven't removed a disconnected client from the map yet
+            // so we need to ensure we don't dispatch to any disconnected client
+            // TODO: Take a look at our client disconnection logic and see if we can handle client disconnection cleanly
+            const clientsToDispatchTo = await this.getConnectedClients();
+            const dispatchPromises = clientsToDispatchTo.map(async (otherClientState) => {
+                const { clientIdentity, clientIdentity: { endpointId }, onUnsubscribeHandlerId } = otherClientState;
+                if (endpointId !== removingClientIdentity.endpointId && onUnsubscribeHandlerId) {
+                    await this.provider.dispatch(clientIdentity, onUnsubscribeHandlerId, contextType);
                 }
-            }
+            });
             try {
-                await Promise.all(dispatchesToSend);
+                await Promise.all(dispatchPromises);
             }
             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}`);
@@ -181,32 +185,68 @@ class PrivateChannelProvider {
         }
         clientState.onUnsubscribeHandlerId = handlerId;
     }
-    async clientDisconnecting(payload, disconnectingClientIdentity) {
+    removeClient(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 = [];
+    }
+    async fireOnDisconnectForOtherClients(disconnectingClientIdentity) {
         // 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));
+        const { endpointId } = disconnectingClientIdentity;
+        // getting only valid client connections here, it is possible we haven't removed a disconnected client from the map yet
+        // so we need to ensure we don't dispatch to any disconnected client
+        // TODO: Take a look at our client disconnection logic and see if we can handle client disconnection cleanly
+        const clientsToDispatchTo = await this.getConnectedClients();
+        const dispatchPromises = clientsToDispatchTo.map(async (otherClientState) => {
+            const { clientIdentity: { endpointId: otherClientEndpointId }, onDisconnectHandlerId } = otherClientState;
+            if (otherClientEndpointId !== endpointId && onDisconnectHandlerId) {
+                await this.provider.dispatch(otherClientState.clientIdentity, onDisconnectHandlerId);
             }
-        }
+        });
         try {
-            await Promise.all(dispatchesToSend);
+            await Promise.all(dispatchPromises);
         }
         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);
         }
     }
+    async unsubscribeAll(clientIdentity) {
+        const { endpointId } = clientIdentity;
+        const state = this.clients.get(endpointId);
+        if (state) {
+            const contextTypeHandlerIds = Array.from(state.handlerIdsByContextTypes.values()).flat();
+            const globalHandlerId = state.globalHandler;
+            if (contextTypeHandlerIds.length > 0) {
+                const unsubPromises = contextTypeHandlerIds.map(async (handlerId) => {
+                    return this.contextHandlerRemoved({ handlerId }, clientIdentity);
+                });
+                try {
+                    await Promise.all(unsubPromises);
+                }
+                catch (error) {
+                    console.error(error.message);
+                }
+            }
+            if (globalHandlerId) {
+                try {
+                    await this.contextHandlerRemoved({ handlerId: globalHandlerId }, clientIdentity);
+                }
+                catch (error) {
+                    console.error(error.message);
+                }
+            }
+        }
+    }
+    async handleClientDisconnecting(disconnectingClientIdentity) {
+        await this.unsubscribeAll(disconnectingClientIdentity);
+        this.removeClient(disconnectingClientIdentity);
+        await this.fireOnDisconnectForOtherClients(disconnectingClientIdentity);
+    }
     registerNewClient(clientIdentity) {
         if (!this.clients.has(clientIdentity.endpointId)) {
             const clientSubscriptionState = {
@@ -220,5 +260,17 @@ class PrivateChannelProvider {
             this.clients.set(clientIdentity.endpointId, clientSubscriptionState);
         }
     }
+    async getConnectedClients() {
+        const allClientInfo = await this.provider.getAllClientInfo();
+        return Array.from(this.clients.values()).filter((clientState) => {
+            const { uuid, name } = clientState.clientIdentity;
+            return allClientInfo.some((clientInfo) => {
+                return name === clientInfo.name && uuid === clientInfo.uuid;
+            });
+        });
+    }
+    static init(channelProvider, id) {
+        return new PrivateChannelProvider(channelProvider, id);
+    }
 }
 exports.PrivateChannelProvider = PrivateChannelProvider;

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

@@ -4,6 +4,7 @@ const base_1 = require("../../base");
 const utils_1 = require("./utils");
 const utils_2 = require("../utils");
 const InteropClient_1 = require("../InteropClient");
+const lodash_1 = require("lodash");
 /**
  * @typedef { object } Listener
  * @summary Listener object returned by addContextListener and addIntentListener
@@ -169,11 +170,15 @@ class Fdc3Module extends base_1.Base {
         }
         catch (error) {
             if (error.message === utils_2.BROKER_ERRORS.joinSessionContextGroupWithJoinContextGroup) {
-                throw new Error('The Channel you have tried to join is an App Channel. Custom Channels can only be defined by the Interop Broker through code or manifest configuration. Please use getOrCreateChannel.');
+                console.error('The Channel you have tried to join is an App Channel. Custom Channels can only be defined by the Interop Broker through code or manifest configuration. Please use getOrCreateChannel.');
             }
             else {
-                throw new Error(error.message);
+                console.error(error.message);
             }
+            if (error.message.startsWith('Attempting to join a context group that does not exist')) {
+                throw new Error(utils_1.ChannelError.NoChannelFound);
+            }
+            throw new Error(utils_1.ChannelError.AccessDenied);
         }
     }
     /**
@@ -317,8 +322,19 @@ class Fdc3Module extends base_1.Base {
         this.wire.sendAction('fdc3-get-or-create-channel').catch((e) => {
             // we do not want to expose this error, just continue if this analytics-only call fails
         });
-        const sessionContextGroup = await this.fin.me.interop.joinSessionContextGroup(channelId);
-        return (0, utils_1.buildAppChannelObject)(sessionContextGroup);
+        const systemChannels = await this.getSystemChannels();
+        const userChannel = systemChannels.find((channel) => channel.id === channelId);
+        if (userChannel) {
+            return { ...userChannel, type: 'system', ...(0, utils_1.getUnsupportedChannelApis)() };
+        }
+        try {
+            const sessionContextGroup = await this.fin.me.interop.joinSessionContextGroup(channelId);
+            return (0, utils_1.buildAppChannelObject)(sessionContextGroup);
+        }
+        catch (error) {
+            console.error(error.message);
+            throw new Error(utils_1.ChannelError.CreationFailed);
+        }
     }
     /**
      * 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.
@@ -378,7 +394,39 @@ class Fdc3Module extends base_1.Base {
         return {
             ...currentContextGroupInfo,
             type: 'system',
-            addContextListener: this.addContextListener.bind(this),
+            addContextListener: (contextType, handler) => {
+                let realHandler;
+                let realType;
+                if (typeof contextType === 'function') {
+                    console.warn('addContextListener(handler) has been deprecated. Please use addContextListener(null, handler)');
+                    realHandler = contextType;
+                }
+                else {
+                    realHandler = handler;
+                    if (typeof contextType === 'string') {
+                        realType = contextType;
+                    }
+                }
+                const listener = (async () => {
+                    let first = true;
+                    const currentContext = await this.fin.me.interop.getCurrentContext(realType);
+                    const wrappedHandler = (context, contextMetadata) => {
+                        if (first) {
+                            first = false;
+                            if ((0, lodash_1.isEqual)(currentContext, context)) {
+                                return;
+                            }
+                        }
+                        // eslint-disable-next-line consistent-return
+                        return realHandler(context, contextMetadata);
+                    };
+                    return this.fin.me.interop.addContextHandler(wrappedHandler, realType);
+                })();
+                return {
+                    ...listener,
+                    unsubscribe: () => listener.then((l) => l.unsubscribe())
+                };
+            },
             broadcast: this.broadcast.bind(this),
             getCurrentContext: async (contextType) => {
                 const context = await this.fin.me.interop.getCurrentContext(contextType);

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

@@ -171,14 +171,14 @@ export default class Fdc3Module2 extends Base implements FDC3v2.DesktopAgent {
      * Find all the available instances for a particular application.
      * @param { AppIdentifier } app
      * @returns { Promise<Array<AppIdentifier>> }
-     * @tutorial findInstances
+     * @tutorial fdc3v2.findInstances
      */
     findInstances(app: FDC3v2.AppIdentifier): Promise<Array<FDC3v2.AppIdentifier>>;
     /**
      * Retrieves the AppMetadata for an AppIdentifier, which provides additional metadata (such as icons, a title and description) from the App Directory record for the application, that may be used for display purposes.
      * @param { AppIdentifier } app
      * @returns { Promise<AppMetadata(2)> }
-     * @tutorial getAppMetadata
+     * @tutorial fdc3v2.getAppMetadata
      */
     getAppMetadata(app: FDC3v2.AppIdentifier): Promise<FDC3v2.AppMetadata>;
     /**
@@ -210,7 +210,7 @@ export default class Fdc3Module2 extends Base implements FDC3v2.DesktopAgent {
      * @param { Context } context
      * @param { string } [resultType] The type of result returned for any intent specified during resolution.
      * @returns { Promise<Array<AppIntent(2)>> }
-     * @tutorial findIntentsByContext
+     * @tutorial fdc3v2.findIntentsByContext
      */
     findIntentsByContext(context: FDC3v2.Context, resultType?: string): Promise<Array<FDC3v2.AppIntent>>;
     /**
@@ -219,7 +219,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 raiseIntent
+     * @tutorial fdc3v2.raiseIntent
      */
     raiseIntent(intent: string, context: FDC3v2.Context, app?: FDC3v2.AppIdentifier | FDC3v1.TargetApp): Promise<FDC3v2.IntentResolution>;
     /**
@@ -227,7 +227,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 raiseIntentForContext
+     * @tutorial fdc3v2.raiseIntentForContext
      */
     raiseIntentForContext(context: FDC3v2.Context, app?: FDC3v2.AppIdentifier | FDC3v1.TargetApp): Promise<FDC3v2.IntentResolution>;
     /**
@@ -244,17 +244,17 @@ export default class Fdc3Module2 extends Base implements FDC3v2.DesktopAgent {
      * @returns { Promise<Channel> }
      * @tutorial fdc3.getOrCreateChannel
      */
-    getOrCreateChannel(channelId: string): Promise<FDC3v1.Channel>;
+    getOrCreateChannel(channelId: string): Promise<FDC3v2.Channel>;
     /**
      * 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 createPrivateChannel
+     * @tutorial fdc3v2.createPrivateChannel
      */
     createPrivateChannel(): Promise<FDC3v2.PrivateChannel>;
     /**
      * Retrieves a list of the User Channels available for the app to join.
      * @returns { Promise<Channel[]>}
-     * @tutorial getUserChannels
+     * @tutorial fdc3v2.getUserChannels
      */
     getUserChannels(): Promise<Array<FDC3v1.SystemChannel>>;
     /**
@@ -268,7 +268,7 @@ export default class Fdc3Module2 extends Base implements FDC3v2.DesktopAgent {
      * Join an app to a specified User channel.
      * @param { string } channelId Channel name
      * @returns { Promise<void> }
-     * @tutorial joinUserChannel
+     * @tutorial fdc3v2.joinUserChannel
      */
     joinUserChannel(channelId: string): Promise<void>;
     /**
@@ -282,6 +282,7 @@ export default class Fdc3Module2 extends Base implements FDC3v2.DesktopAgent {
     /**
      * Returns the Channel object for the current User channel membership
      * @returns { Promise<FDC3.Channel | null> }
+     * @tutorial fdc3.getCurrentChannel
      */
     getCurrentChannel(): Promise<FDC3v2.Channel | null>;
     /**
@@ -294,7 +295,7 @@ export default class Fdc3Module2 extends Base implements FDC3v2.DesktopAgent {
      * Retrieves information about the FDC3 implementation, including the supported version of the FDC3 specification, the name of the provider of the implementation, its own version number, details of whether optional API features are implemented and the metadata of the calling application according to the desktop agent.
      * fdc3HandleGetInfo must be overridden in the InteropBroker so that the ImplementationMetadata will have the appMetadata info.
      * @returns { Promise<ImplementationMetadata(2)> }
-     * @tutorial getInfo
+     * @tutorial fdc3v2.getInfo
      */
     getInfo(): Promise<FDC3v2.ImplementationMetadata>;
 }