@openfin/core 31.74.1 → 31.74.2

package/src/api/interappbus/channel/connection-manager.js

@@ -23,6 +23,18 @@ const message_receiver_1 = require("./protocols/classic/message-receiver");
 const protocol_manager_1 = require("./protocols/protocol-manager");
 const strategy_3 = require("./protocols/combined/strategy");
 class ConnectionManager extends base_1.Base {
+    static getProtocolOptionsFromStrings(protocols) {
+        return protocols.map((protocol) => {
+            switch (protocol) {
+                case 'rtc':
+                    return strategy_2.RTCInfo;
+                case 'classic':
+                    return strategy_1.ClassicInfo;
+                default:
+                    return (0, exhaustive_1.exhaustiveCheck)(protocol, ['rtc', 'classic']);
+            }
+        });
+    }
     constructor(wire) {
         super(wire);
         _ConnectionManager_messageReceiver.set(this, void 0);
@@ -43,18 +55,6 @@ class ConnectionManager extends base_1.Base {
         __classPrivateFieldSet(this, _ConnectionManager_rtcConnectionManager, new ice_manager_1.RTCICEManager(wire), "f");
         wire.registerMessageHandler(this.onmessage.bind(this));
     }
-    static getProtocolOptionsFromStrings(protocols) {
-        return protocols.map((protocol) => {
-            switch (protocol) {
-                case 'rtc':
-                    return strategy_2.RTCInfo;
-                case 'classic':
-                    return strategy_1.ClassicInfo;
-                default:
-                    return (0, exhaustive_1.exhaustiveCheck)(protocol, ['rtc', 'classic']);
-            }
-        });
-    }
     createProvider(options, providerIdentity) {
         const opts = Object.assign(this.wire.environment.getDefaultChannelOptions().create, options || {});
         const protocols = this.protocolManager.getProviderProtocols(opts === null || opts === void 0 ? void 0 : opts.protocols);

package/src/api/interappbus/channel/index.d.ts

@@ -4,8 +4,8 @@ import { ChannelProvider } from './provider';
 import { EmitterBase } from '../../base';
 import { Transport, Message } from '../../../transport/transport';
 import { ChannelEvent } from '../../events/channel';
-declare type ProviderIdentity = OpenFin.ProviderIdentity;
-declare type Identity = OpenFin.Identity;
+type ProviderIdentity = OpenFin.ProviderIdentity;
+type Identity = OpenFin.Identity;
 export interface ChannelMessage extends Message<any> {
     senderIdentity: Identity;
     ackToSender: any;

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.d.ts

@@ -3,7 +3,7 @@ import { Transport } from '../../../../../transport/transport';
 import { MessageReceiver } from './message-receiver';
 import { ChannelStrategy, EndpointPayload } from '../strategy';
 import { LocalSupportedProtocol } from '..';
-declare type ProviderIdentity = OpenFin.ProviderIdentity;
+type ProviderIdentity = OpenFin.ProviderIdentity;
 export declare class ClassicStrategy implements ChannelStrategy<EndpointPayload> {
     #private;
     private messageReceiver;

package/src/api/interappbus/channel/protocols/combined/strategy.d.ts

@@ -1,8 +1,8 @@
 import { ChannelStrategy } from '../strategy';
-declare type OverlapsOnlyIfMatching<T, U> = {
+type OverlapsOnlyIfMatching<T, U> = {
     [K in Extract<keyof T, keyof U>]: U[K] extends T[K] ? U[K] : T[K] extends U[K] ? T[K] : never;
 };
-declare type OnlyIfCompatible<A, B, D = OverlapsOnlyIfMatching<A, B>> = D extends Record<any, never> ? keyof D extends never ? A | B : never : A | B;
+type OnlyIfCompatible<A, B, D = OverlapsOnlyIfMatching<A, B>> = D extends Record<any, never> ? keyof D extends never ? A | B : never : A | B;
 export default class CombinedStrategy<A, B> implements ChannelStrategy<OnlyIfCompatible<A, B>> {
     private primary;
     private secondary;

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

@@ -1,16 +1,16 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 class CombinedStrategy {
-    // eslint-disable-next-line no-useless-constructor
-    constructor(primary, secondary) {
-        this.primary = primary;
-        this.secondary = secondary;
-    }
     // Making this a static method because the constructor can't be typed.
     // Otherwise it will error when calling addEndpoint but I'd rather the whole instance be typed as never.
     static combine(a, b) {
         return new CombinedStrategy(a, b);
     }
+    // eslint-disable-next-line no-useless-constructor
+    constructor(primary, secondary) {
+        this.primary = primary;
+        this.secondary = secondary;
+    }
     onEndpointDisconnect(endpointId, listener) {
         this.primary.onEndpointDisconnect(endpointId, () => {
             if (!this.secondary.isEndpointConnected(endpointId)) {

package/src/api/interappbus/channel/protocols/index.d.ts

@@ -14,12 +14,12 @@ export interface RTCProtocolOffer extends ProtocolPacketBase {
         rtcConnectionId: string;
     };
 }
-export declare type ProtocolOffer = ClassicProtocolOffer | RTCProtocolOffer;
+export type ProtocolOffer = ClassicProtocolOffer | RTCProtocolOffer;
 /**
  * Protocol values for determining channel messaging strategy.
  */
-export declare type MessagingProtocols = ProtocolOffer['type'];
-export declare type LocalSupportedProtocol = {
+export type MessagingProtocols = ProtocolOffer['type'];
+export type LocalSupportedProtocol = {
     type: MessagingProtocols;
     minimumVersion: number;
     version: number;
@@ -41,7 +41,7 @@ export interface RTCProtocolAnswer extends ProtocolPacketBase {
         answer: RTCSessionDescriptionInit;
     };
 }
-export declare type ProtocolAnswer = ClassicProtocolAnswer | RTCProtocolAnswer;
+export type ProtocolAnswer = ClassicProtocolAnswer | RTCProtocolAnswer;
 export interface ClientAnswer {
     supportedProtocols: ProtocolAnswer[];
 }

package/src/api/interappbus/channel/protocols/rtc/endpoint.d.ts

@@ -1,5 +1,5 @@
 import type * as OpenFin from '../../../../../OpenFin';
-declare type ProviderIdentity = OpenFin.ProviderIdentity;
+type ProviderIdentity = OpenFin.ProviderIdentity;
 export interface RTCEndpointChannels {
     request: RTCDataChannel;
     response: RTCDataChannel;

package/src/api/interappbus/channel/protocols/rtc/strategy.d.ts

@@ -2,7 +2,7 @@ import type * as OpenFin from '../../../../../OpenFin';
 import { ChannelStrategy } from '../strategy';
 import { RTCPacket } from './endpoint';
 import { LocalSupportedProtocol } from '..';
-declare type ProviderIdentity = OpenFin.ProviderIdentity;
+type ProviderIdentity = OpenFin.ProviderIdentity;
 export interface RTCStrategyEndpointPayload {
     endpointIdentity: OpenFin.ClientIdentity | ProviderIdentity;
     rtc: RTCPacket;

package/src/api/interappbus/channel/protocols/strategy-types.d.ts

@@ -3,11 +3,11 @@ import { ClassicStrategy } from './classic/strategy';
 import CombinedStrategy from './combined/strategy';
 import { RTCStrategy } from './rtc/strategy';
 import { ChannelStrategy } from './strategy';
-declare type StrategyMap = {
+type StrategyMap = {
     rtc: RTCStrategy;
     classic: ClassicStrategy;
 };
-export declare type StrategyByProtocol<T extends MessagingProtocols> = StrategyMap[T];
-export declare type PayloadTypeByStrategy<T extends ChannelStrategy<unknown>> = T extends ChannelStrategy<infer U> ? U : never;
-export declare type AnyStrategy = ClassicStrategy | RTCStrategy | CombinedStrategy<PayloadTypeByStrategy<RTCStrategy>, PayloadTypeByStrategy<ClassicStrategy>>;
+export type StrategyByProtocol<T extends MessagingProtocols> = StrategyMap[T];
+export type PayloadTypeByStrategy<T extends ChannelStrategy<unknown>> = T extends ChannelStrategy<infer U> ? U : never;
+export type AnyStrategy = ClassicStrategy | RTCStrategy | CombinedStrategy<PayloadTypeByStrategy<RTCStrategy>, PayloadTypeByStrategy<ClassicStrategy>>;
 export {};

package/src/api/interappbus/channel/protocols/strategy.d.ts

@@ -1,5 +1,5 @@
 import type * as OpenFin from '../../../../OpenFin';
-declare type ProviderIdentity = OpenFin.ProviderIdentity;
+type ProviderIdentity = OpenFin.ProviderIdentity;
 export interface ChannelStrategy<T extends unknown> {
     onEndpointDisconnect(endpointId: string, listener: () => void): void;
     receive(listener: (action: string, payload: any, identity: any) => Promise<any>): void;
@@ -10,8 +10,8 @@ export interface ChannelStrategy<T extends unknown> {
     addEndpoint(endpointId: string, payload: T): void;
     isValidEndpointPayload(payload: unknown): payload is T;
 }
-export declare type EndpointIdentity = OpenFin.ClientIdentity | ProviderIdentity;
-export declare type EndpointPayload = {
+export type EndpointIdentity = OpenFin.ClientIdentity | ProviderIdentity;
+export type EndpointPayload = {
     endpointIdentity: EndpointIdentity;
 };
 export {};

package/src/api/interappbus/channel/provider.d.ts

@@ -2,11 +2,11 @@ import type * as OpenFin from '../../../OpenFin';
 import { ChannelBase } from './channel';
 import { Transport } from '../../../transport/transport';
 import { AnyStrategy } from './protocols/strategy-types';
-declare type ProviderIdentity = OpenFin.ProviderIdentity;
-declare type ClientIdentity = OpenFin.ClientIdentity;
-export declare type ConnectionListener = (identity: ClientIdentity, connectionMessage?: any) => Promise<any> | any;
-export declare type DisconnectionListener = (identity: ClientIdentity) => any;
-declare type ClientConnectionPayload = OpenFin.ClientIdentity & OpenFin.ClientInfo;
+type ProviderIdentity = OpenFin.ProviderIdentity;
+type ClientIdentity = OpenFin.ClientIdentity;
+export type ConnectionListener = (identity: ClientIdentity, connectionMessage?: any) => Promise<any> | any;
+export type DisconnectionListener = (identity: ClientIdentity) => any;
+type ClientConnectionPayload = OpenFin.ClientIdentity & OpenFin.ClientInfo;
 export declare class ChannelProvider extends ChannelBase {
     #private;
     private static removalMap;

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

@@ -1,21 +1,40 @@
 "use strict";
+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 __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, 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 _ChannelProvider_connections, _ChannelProvider_protectedObj, _ChannelProvider_strategy, _ChannelProvider_removeEndpoint, _ChannelProvider_close;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ChannelProvider = void 0;
 const channel_1 = require("./channel");
 const runtimeVersioning_1 = require("../../../util/runtimeVersioning");
 class ChannelProvider extends channel_1.ChannelBase {
+    get connections() {
+        return [...__classPrivateFieldGet(this, _ChannelProvider_connections, "f")];
+    }
+    static handleClientDisconnection(channel, payload) {
+        const removeById = channel.connections.find((identity) => identity.endpointId === payload.endpointId);
+        if (removeById) {
+            __classPrivateFieldGet(channel, _ChannelProvider_removeEndpoint, "f").call(channel, removeById);
+        }
+        else {
+            const multipleRemoves = channel.connections.filter((identity) => {
+                return identity.uuid === payload.uuid && identity.name === payload.name;
+            });
+            multipleRemoves.forEach(__classPrivateFieldGet(channel, _ChannelProvider_removeEndpoint, "f"));
+        }
+        channel.disconnectListener(payload);
+    }
+    static setProviderRemoval(provider, remove) {
+        ChannelProvider.removalMap.set(provider, remove);
+    }
     constructor(providerIdentity, wire, strategy) {
         super();
         _ChannelProvider_connections.set(this, void 0);
@@ -51,25 +70,6 @@ class ChannelProvider extends channel_1.ChannelBase {
         __classPrivateFieldSet(this, _ChannelProvider_strategy, strategy, "f");
         strategy.receive(this.processAction);
     }
-    get connections() {
-        return [...__classPrivateFieldGet(this, _ChannelProvider_connections, "f")];
-    }
-    static handleClientDisconnection(channel, payload) {
-        const removeById = channel.connections.find((identity) => identity.endpointId === payload.endpointId);
-        if (removeById) {
-            __classPrivateFieldGet(channel, _ChannelProvider_removeEndpoint, "f").call(channel, removeById);
-        }
-        else {
-            const multipleRemoves = channel.connections.filter((identity) => {
-                return identity.uuid === payload.uuid && identity.name === payload.name;
-            });
-            multipleRemoves.forEach(__classPrivateFieldGet(channel, _ChannelProvider_removeEndpoint, "f"));
-        }
-        channel.disconnectListener(payload);
-    }
-    static setProviderRemoval(provider, remove) {
-        ChannelProvider.removalMap.set(provider, remove);
-    }
     dispatch(to, action, payload) {
         var _a;
         const endpointId = (_a = to.endpointId) !== null && _a !== void 0 ? _a : this.getEndpointIdForOpenFinId(to, action);

package/src/api/interop/InteropBroker.d.ts

@@ -3,7 +3,7 @@ import { AppIdentifier } from './fdc3/shapes/fdc3v2';
 import type * as OpenFin from '../../OpenFin';
 import { Base } from '../base';
 import type { Transport } from '../../transport/transport';
-declare type Identity = OpenFin.Identity;
+type Identity = OpenFin.Identity;
 /**
  * {@link https://developers.openfin.co/of-docs/docs/enable-color-linking}
  *

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

@@ -1,6 +1,6 @@
 import type * as OpenFin from '../../../OpenFin';
 import type { Listener, Context, ContextHandler } from './shapes/fdc3v2';
-declare type HandlerId = string;
+type HandlerId = string;
 export declare class PrivateChannelClient {
     id: string;
     client: OpenFin.ChannelClient;
@@ -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';
-declare type HandlerId = string;
+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;
@@ -110,17 +120,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 +192,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 +267,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

@@ -169,11 +169,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 +321,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.