@openfin/core 33.76.31 → 33.76.38

package/src/api/interop/SessionContextGroupClient.js

@@ -1,86 +0,0 @@
-"use strict";
-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 _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);
-        _SessionContextGroupClient_clientPromise.set(this, void 0);
-        this.id = id;
-        __classPrivateFieldSet(this, _SessionContextGroupClient_clientPromise, client, "f");
-    }
-    /**
-     * Sets a context for the session context group.
-     * @param { Context } context - New context to set.
-     * @return { Promise<void> }
-     * @tutorial interop.setContext
-     */
-    async setContext(context) {
-        this.wire.sendAction('interop-session-context-group-set-context').catch((e) => {
-            // don't expose, analytics-only call
-        });
-        const client = await __classPrivateFieldGet(this, _SessionContextGroupClient_clientPromise, "f");
-        return client.dispatch(`sessionContextGroup:setContext-${this.id}`, {
-            sessionContextGroupId: this.id,
-            context
-        });
-    }
-    async getCurrentContext(type) {
-        this.wire.sendAction('interop-session-context-group-get-context').catch((e) => {
-            // don't expose, analytics-only call
-        });
-        const client = await __classPrivateFieldGet(this, _SessionContextGroupClient_clientPromise, "f");
-        return client.dispatch(`sessionContextGroup:getContext-${this.id}`, {
-            sessionContextGroupId: this.id,
-            type
-        });
-    }
-    async addContextHandler(contextHandler, contextType) {
-        this.wire.sendAction('interop-session-context-group-add-handler').catch((e) => {
-            // don't expose, analytics-only call
-        });
-        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, _SessionContextGroupClient_clientPromise, "f");
-        let handlerId;
-        if (contextType) {
-            handlerId = `sessionContextHandler:invoke-${this.id}-${contextType}-${(0, utils_1.generateId)()}`;
-        }
-        else {
-            handlerId = `sessionContextHandler:invoke-${this.id}`;
-        }
-        client.register(handlerId, (0, utils_1.wrapContextHandler)(contextHandler, handlerId));
-        await client.dispatch(`sessionContextGroup:handlerAdded-${this.id}`, { handlerId, contextType });
-        return { unsubscribe: await this.createUnsubscribeCb(handlerId) };
-    }
-    async createUnsubscribeCb(handlerId) {
-        const client = await __classPrivateFieldGet(this, _SessionContextGroupClient_clientPromise, "f");
-        return async () => {
-            client.remove(handlerId);
-            await client.dispatch(`sessionContextGroup:handlerRemoved-${this.id}`, { handlerId });
-        };
-    }
-    getUserInstance() {
-        return {
-            id: this.id,
-            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;
-_SessionContextGroupClient_clientPromise = new WeakMap();

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

@@ -1,20 +0,0 @@
-import type * as OpenFin from '../../../OpenFin';
-import type { Listener, Context, ContextHandler } from './shapes/fdc3v2';
-type HandlerId = string;
-export declare class PrivateChannelClient {
-    id: string;
-    client: OpenFin.ChannelClient;
-    listeners: Map<HandlerId, Listener>;
-    constructor(client: OpenFin.ChannelClient, id: string);
-    broadcast(context: Context): Promise<void>;
-    getCurrentContext(contextType?: string): Promise<Context | null>;
-    addContextListener(contextType: string | null, handler: ContextHandler): Promise<Listener>;
-    private createNonStandardUnsubscribeCb;
-    private createContextUnsubscribeCb;
-    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

@@ -1,90 +0,0 @@
-"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 cleanUpAllSubs() {
-        const listenerUnsubscribers = Array.from(this.listeners.keys());
-        listenerUnsubscribers.forEach((handlerId) => {
-            this.client.remove(handlerId);
-            this.listeners.delete(handlerId);
-        });
-    }
-    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,55 +0,0 @@
-import type * as OpenFin from '../../../OpenFin';
-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;
-    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;
-    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

@@ -1,276 +0,0 @@
-"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(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);
-    }
-    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', (payload, clientIdentity) => {
-            this.handleClientDisconnecting(clientIdentity);
-        });
-    }
-    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]);
-        }
-        else {
-            senderClientState.globalHandler = handlerId;
-        }
-        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;
-                    }
-                }
-            }
-            // 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(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}`);
-                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;
-    }
-    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);
-    }
-    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 { 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(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 = {
-                clientIdentity,
-                handlerIdsByContextTypes: new Map(),
-                globalHandler: undefined,
-                onAddContextListenerHandlerId: undefined,
-                onUnsubscribeHandlerId: undefined,
-                onDisconnectHandlerId: undefined
-            };
-            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;