@openfin/core 25.68.30 → 25.70.2

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

@@ -1,87 +1,87 @@
-"use strict";
-var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, privateMap) {
-    if (!privateMap.has(receiver)) {
-        throw new TypeError("attempted to get private field on non-instance");
-    }
-    return privateMap.get(receiver);
-};
-var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, privateMap, value) {
-    if (!privateMap.has(receiver)) {
-        throw new TypeError("attempted to set private field on non-instance");
-    }
-    privateMap.set(receiver, value);
-    return value;
-};
-var _processAction, _rtcEndpointMap, _connected;
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.RTCInfo = exports.RTCStrategy = void 0;
-const endpoint_1 = require("./endpoint");
-/*
-This is used to abstract out rtc messaging from the channels implementation using RTCEndpoints.
-*/
-class RTCStrategy {
-    constructor() {
-        _processAction.set(this, null);
-        _rtcEndpointMap.set(this, new Map());
-        _connected.set(this, true);
-        this.send = async (endpointId, action, payload) => {
-            return this.getEndpointById(endpointId).send(action, payload);
-        };
-        this.close = async () => {
-            if (__classPrivateFieldGet(this, _connected)) {
-                __classPrivateFieldGet(this, _rtcEndpointMap).forEach((rtcEndpoint) => rtcEndpoint.close());
-                __classPrivateFieldSet(this, _rtcEndpointMap, new Map());
-            }
-            __classPrivateFieldSet(this, _connected, false);
-        };
-    }
-    onEndpointDisconnect(endpointId, listener) {
-        this.getEndpointById(endpointId).onDisconnect(listener);
-    }
-    receive(listener) {
-        if (__classPrivateFieldGet(this, _processAction)) {
-            throw new Error('You have already set a listener for this RTC Strategy');
-        }
-        __classPrivateFieldSet(this, _processAction, listener);
-        __classPrivateFieldGet(this, _rtcEndpointMap).forEach((rtcEndpoint) => rtcEndpoint.receive(__classPrivateFieldGet(this, _processAction)));
-    }
-    getEndpointById(endpointId) {
-        const endpoint = __classPrivateFieldGet(this, _rtcEndpointMap).get(endpointId);
-        if (!endpoint) {
-            throw new Error(`Client with endpoint id ${endpointId} is not connected`);
-        }
-        return endpoint;
-    }
-    get connected() {
-        return __classPrivateFieldGet(this, _connected);
-    }
-    isEndpointConnected(endpointId) {
-        return __classPrivateFieldGet(this, _rtcEndpointMap).has(endpointId);
-    }
-    addEndpoint(endpointId, payload) {
-        if (!__classPrivateFieldGet(this, _connected)) {
-            console.warn('Adding endpoint to disconnected RTC Strategy');
-            return;
-        }
-        const clientStrat = new endpoint_1.RTCEndpoint(payload.rtc, payload.endpointIdentity);
-        if (__classPrivateFieldGet(this, _processAction)) {
-            clientStrat.receive(__classPrivateFieldGet(this, _processAction));
-        }
-        __classPrivateFieldGet(this, _rtcEndpointMap).set(endpointId, clientStrat);
-    }
-    async closeEndpoint(endpointId) {
-        __classPrivateFieldGet(this, _rtcEndpointMap).delete(endpointId);
-    }
-    isValidEndpointPayload(payload) {
-        const isObject = (x) => {
-            return typeof x === 'object' && x !== null;
-        };
-        return (isObject(payload) &&
-            isObject(payload.endpointIdentity) &&
-            isObject(payload.rtc) &&
-            typeof payload.endpointIdentity.endpointId === 'string');
-    }
-}
-exports.RTCStrategy = RTCStrategy;
-_processAction = new WeakMap(), _rtcEndpointMap = new WeakMap(), _connected = new WeakMap();
-exports.RTCInfo = { version: 1, minimumVersion: 0, type: 'rtc' };
+"use strict";
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, privateMap) {
+    if (!privateMap.has(receiver)) {
+        throw new TypeError("attempted to get private field on non-instance");
+    }
+    return privateMap.get(receiver);
+};
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, privateMap, value) {
+    if (!privateMap.has(receiver)) {
+        throw new TypeError("attempted to set private field on non-instance");
+    }
+    privateMap.set(receiver, value);
+    return value;
+};
+var _processAction, _rtcEndpointMap, _connected;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RTCInfo = exports.RTCStrategy = void 0;
+const endpoint_1 = require("./endpoint");
+/*
+This is used to abstract out rtc messaging from the channels implementation using RTCEndpoints.
+*/
+class RTCStrategy {
+    constructor() {
+        _processAction.set(this, null);
+        _rtcEndpointMap.set(this, new Map());
+        _connected.set(this, true);
+        this.send = async (endpointId, action, payload) => {
+            return this.getEndpointById(endpointId).send(action, payload);
+        };
+        this.close = async () => {
+            if (__classPrivateFieldGet(this, _connected)) {
+                __classPrivateFieldGet(this, _rtcEndpointMap).forEach((rtcEndpoint) => rtcEndpoint.close());
+                __classPrivateFieldSet(this, _rtcEndpointMap, new Map());
+            }
+            __classPrivateFieldSet(this, _connected, false);
+        };
+    }
+    onEndpointDisconnect(endpointId, listener) {
+        this.getEndpointById(endpointId).onDisconnect(listener);
+    }
+    receive(listener) {
+        if (__classPrivateFieldGet(this, _processAction)) {
+            throw new Error('You have already set a listener for this RTC Strategy');
+        }
+        __classPrivateFieldSet(this, _processAction, listener);
+        __classPrivateFieldGet(this, _rtcEndpointMap).forEach((rtcEndpoint) => rtcEndpoint.receive(__classPrivateFieldGet(this, _processAction)));
+    }
+    getEndpointById(endpointId) {
+        const endpoint = __classPrivateFieldGet(this, _rtcEndpointMap).get(endpointId);
+        if (!endpoint) {
+            throw new Error(`Client with endpoint id ${endpointId} is not connected`);
+        }
+        return endpoint;
+    }
+    get connected() {
+        return __classPrivateFieldGet(this, _connected);
+    }
+    isEndpointConnected(endpointId) {
+        return __classPrivateFieldGet(this, _rtcEndpointMap).has(endpointId);
+    }
+    addEndpoint(endpointId, payload) {
+        if (!__classPrivateFieldGet(this, _connected)) {
+            console.warn('Adding endpoint to disconnected RTC Strategy');
+            return;
+        }
+        const clientStrat = new endpoint_1.RTCEndpoint(payload.rtc, payload.endpointIdentity);
+        if (__classPrivateFieldGet(this, _processAction)) {
+            clientStrat.receive(__classPrivateFieldGet(this, _processAction));
+        }
+        __classPrivateFieldGet(this, _rtcEndpointMap).set(endpointId, clientStrat);
+    }
+    async closeEndpoint(endpointId) {
+        __classPrivateFieldGet(this, _rtcEndpointMap).delete(endpointId);
+    }
+    isValidEndpointPayload(payload) {
+        const isObject = (x) => {
+            return typeof x === 'object' && x !== null;
+        };
+        return (isObject(payload) &&
+            isObject(payload.endpointIdentity) &&
+            isObject(payload.rtc) &&
+            typeof payload.endpointIdentity.endpointId === 'string');
+    }
+}
+exports.RTCStrategy = RTCStrategy;
+_processAction = new WeakMap(), _rtcEndpointMap = new WeakMap(), _connected = new WeakMap();
+exports.RTCInfo = { version: 1, minimumVersion: 0, type: 'rtc' };

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

@@ -1,13 +1,13 @@
-import { MessagingProtocols } from '.';
-import { ClassicStrategy } from './classic/strategy';
-import CombinedStrategy from './combined/strategy';
-import { RTCStrategy } from './rtc/strategy';
-import { ChannelStrategy } from './strategy';
-declare 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 {};
+import { MessagingProtocols } from '.';
+import { ClassicStrategy } from './classic/strategy';
+import CombinedStrategy from './combined/strategy';
+import { RTCStrategy } from './rtc/strategy';
+import { ChannelStrategy } from './strategy';
+declare 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 {};

package/src/api/interappbus/channel/protocols/strategy-types.js

@@ -1,2 +1,2 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -1,15 +1,15 @@
-import 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;
-    send(endpointId: string, action: string, payload: any): Promise<any>;
-    closeEndpoint(endpointId: string): Promise<void>;
-    close(): Promise<void>;
-    isEndpointConnected(endpointId: string): boolean;
-    addEndpoint(endpointId: string, payload: T): void;
-    isValidEndpointPayload(payload: unknown): payload is T;
-}
-export declare type EndpointIdentity = OpenFin.ClientIdentity | ProviderIdentity;
-export declare type EndpointPayload = {
-    endpointIdentity: EndpointIdentity;
-};
+import 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;
+    send(endpointId: string, action: string, payload: any): Promise<any>;
+    closeEndpoint(endpointId: string): Promise<void>;
+    close(): Promise<void>;
+    isEndpointConnected(endpointId: string): boolean;
+    addEndpoint(endpointId: string, payload: T): void;
+    isValidEndpointPayload(payload: unknown): payload is T;
+}
+export declare type EndpointIdentity = OpenFin.ClientIdentity | ProviderIdentity;
+export declare type EndpointPayload = {
+    endpointIdentity: EndpointIdentity;
+};

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

@@ -1,2 +1,2 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -1,31 +1,31 @@
-import { ChannelBase } from './channel';
-import Transport from '../../../transport/transport';
-import { AnyStrategy } from './protocols/strategy-types';
-import ProviderIdentity = OpenFin.ProviderIdentity;
-import ClientIdentity = OpenFin.ClientIdentity;
-export declare type ConnectionListener = (identity: ClientIdentity, connectionMessage?: any) => any;
-export declare type DisconnectionListener = (identity: ClientIdentity) => any;
-export declare class ChannelProvider extends ChannelBase {
-    #private;
-    private static removalMap;
-    private connectListener;
-    private disconnectListener;
-    get connections(): OpenFin.ClientIdentity[];
-    static handleClientDisconnection(channel: ChannelProvider, payload: any): void;
-    static setProviderRemoval(provider: ChannelProvider, remove: Function): void;
-    constructor(providerIdentity: ProviderIdentity, wire: Transport, strategy: AnyStrategy);
-    dispatch(to: OpenFin.ClientIdentity | OpenFin.Identity, action: string, payload?: any): Promise<any>;
-    protected processAction: (action: string, payload: any, senderIdentity: OpenFin.ClientIdentity | OpenFin.ClientIdentityMultiRuntime) => Promise<any>;
-    processConnection(senderId: OpenFin.ClientIdentity, payload: any): Promise<any>;
-    publish(action: string, payload: any): Promise<any>[];
-    onConnection(listener: ConnectionListener): void;
-    onDisconnection(listener: DisconnectionListener): void;
-    destroy(): Promise<void>;
-    private checkForClientConnection;
-    private isClientConnected;
-    private isLegacyClientConnected;
-    private handleMultiRuntimeLegacyClient;
-    private getEndpointIdForOpenFinId;
-    private static clientIdentityIncludesEndpointId;
-    private static clientIsMultiRuntime;
-}
+import { ChannelBase } from './channel';
+import Transport from '../../../transport/transport';
+import { AnyStrategy } from './protocols/strategy-types';
+import ProviderIdentity = OpenFin.ProviderIdentity;
+import ClientIdentity = OpenFin.ClientIdentity;
+export declare type ConnectionListener = (identity: ClientIdentity, connectionMessage?: any) => any;
+export declare type DisconnectionListener = (identity: ClientIdentity) => any;
+export declare class ChannelProvider extends ChannelBase {
+    #private;
+    private static removalMap;
+    private connectListener;
+    private disconnectListener;
+    get connections(): OpenFin.ClientIdentity[];
+    static handleClientDisconnection(channel: ChannelProvider, payload: any): void;
+    static setProviderRemoval(provider: ChannelProvider, remove: Function): void;
+    constructor(providerIdentity: ProviderIdentity, wire: Transport, strategy: AnyStrategy);
+    dispatch(to: OpenFin.ClientIdentity | OpenFin.Identity, action: string, payload?: any): Promise<any>;
+    protected processAction: (action: string, payload: any, senderIdentity: OpenFin.ClientIdentity | OpenFin.ClientIdentityMultiRuntime) => Promise<any>;
+    processConnection(senderId: OpenFin.ClientIdentity, payload: any): Promise<any>;
+    publish(action: string, payload: any): Promise<any>[];
+    onConnection(listener: ConnectionListener): void;
+    onDisconnection(listener: DisconnectionListener): void;
+    destroy(): Promise<void>;
+    private checkForClientConnection;
+    private isClientConnected;
+    private isLegacyClientConnected;
+    private handleMultiRuntimeLegacyClient;
+    private getEndpointIdForOpenFinId;
+    private static clientIdentityIncludesEndpointId;
+    private static clientIsMultiRuntime;
+}

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

@@ -1,165 +1,165 @@
-"use strict";
-var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, privateMap, value) {
-    if (!privateMap.has(receiver)) {
-        throw new TypeError("attempted to set private field on non-instance");
-    }
-    privateMap.set(receiver, value);
-    return value;
-};
-var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, privateMap) {
-    if (!privateMap.has(receiver)) {
-        throw new TypeError("attempted to get private field on non-instance");
-    }
-    return privateMap.get(receiver);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ChannelProvider = void 0;
-const channel_1 = require("./channel");
-const runtimeVersioning_1 = require("../../../util/runtimeVersioning");
-let ChannelProvider = /** @class */ (() => {
-    var _connections, _protectedObj, _strategy, _removeEndpoint, _close;
-    class ChannelProvider extends channel_1.ChannelBase {
-        constructor(providerIdentity, wire, strategy) {
-            super();
-            _connections.set(this, void 0);
-            _protectedObj.set(this, void 0);
-            _strategy.set(this, void 0);
-            _removeEndpoint.set(this, (identity) => {
-                const remainingConnections = this.connections.filter((clientIdentity) => clientIdentity.endpointId !== identity.endpointId);
-                __classPrivateFieldGet(this, _strategy).closeEndpoint(identity.endpointId);
-                __classPrivateFieldSet(this, _connections, remainingConnections);
-            });
-            // Must be bound.
-            this.processAction = async (action, payload, senderIdentity) => {
-                if (ChannelProvider.clientIsMultiRuntime(senderIdentity) &&
-                    !runtimeVersioning_1.runtimeUuidMeetsMinimumRuntimeVersion(senderIdentity.runtimeUuid, '18.87.56.0')) {
-                    this.handleMultiRuntimeLegacyClient(senderIdentity);
-                }
-                else {
-                    this.checkForClientConnection(senderIdentity);
-                }
-                return super.processAction(action, payload, senderIdentity);
-            };
-            _close.set(this, () => {
-                __classPrivateFieldGet(this, _strategy).close();
-                const remove = ChannelProvider.removalMap.get(this);
-                if (remove) {
-                    remove();
-                }
-            });
-            __classPrivateFieldSet(this, _protectedObj, new channel_1.ProtectedItems(providerIdentity, wire));
-            this.connectListener = () => undefined;
-            this.disconnectListener = () => undefined;
-            __classPrivateFieldSet(this, _connections, []);
-            __classPrivateFieldSet(this, _strategy, strategy);
-            strategy.receive(this.processAction);
-        }
-        get connections() {
-            return [...__classPrivateFieldGet(this, _connections)];
-        }
-        static handleClientDisconnection(channel, payload) {
-            const removeById = channel.connections.find((identity) => identity.endpointId === payload.endpointId);
-            if (removeById) {
-                __classPrivateFieldGet(channel, _removeEndpoint).call(channel, removeById);
-            }
-            else {
-                const multipleRemoves = channel.connections.filter((identity) => {
-                    return identity.uuid === payload.uuid && identity.name === payload.name;
-                });
-                multipleRemoves.forEach(__classPrivateFieldGet(channel, _removeEndpoint));
-            }
-            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);
-            if (endpointId && __classPrivateFieldGet(this, _strategy).isEndpointConnected(endpointId)) {
-                return __classPrivateFieldGet(this, _strategy).send(endpointId, action, payload);
-            }
-            return Promise.reject(new Error(`Client connection with identity uuid: ${to.uuid} / name: ${to.name} / endpointId: ${endpointId} no longer connected.`));
-        }
-        async processConnection(senderId, payload) {
-            __classPrivateFieldGet(this, _connections).push(senderId);
-            return this.connectListener(senderId, payload);
-        }
-        publish(action, payload) {
-            return this.connections.map((to) => __classPrivateFieldGet(this, _strategy).send(to.endpointId, action, payload));
-        }
-        onConnection(listener) {
-            this.connectListener = listener;
-        }
-        onDisconnection(listener) {
-            this.disconnectListener = listener;
-        }
-        async destroy() {
-            const protectedObj = __classPrivateFieldGet(this, _protectedObj);
-            const { channelName } = protectedObj.providerIdentity;
-            __classPrivateFieldSet(this, _connections, []);
-            await protectedObj.wire.sendAction('destroy-channel', { channelName });
-            __classPrivateFieldGet(this, _close).call(this);
-        }
-        checkForClientConnection(clientIdentity) {
-            if (!this.isClientConnected(clientIdentity)) {
+"use strict";
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, privateMap, value) {
+    if (!privateMap.has(receiver)) {
+        throw new TypeError("attempted to set private field on non-instance");
+    }
+    privateMap.set(receiver, value);
+    return value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, privateMap) {
+    if (!privateMap.has(receiver)) {
+        throw new TypeError("attempted to get private field on non-instance");
+    }
+    return privateMap.get(receiver);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ChannelProvider = void 0;
+const channel_1 = require("./channel");
+const runtimeVersioning_1 = require("../../../util/runtimeVersioning");
+let ChannelProvider = /** @class */ (() => {
+    var _connections, _protectedObj, _strategy, _removeEndpoint, _close;
+    class ChannelProvider extends channel_1.ChannelBase {
+        constructor(providerIdentity, wire, strategy) {
+            super();
+            _connections.set(this, void 0);
+            _protectedObj.set(this, void 0);
+            _strategy.set(this, void 0);
+            _removeEndpoint.set(this, (identity) => {
+                const remainingConnections = this.connections.filter((clientIdentity) => clientIdentity.endpointId !== identity.endpointId);
+                __classPrivateFieldGet(this, _strategy).closeEndpoint(identity.endpointId);
+                __classPrivateFieldSet(this, _connections, remainingConnections);
+            });
+            // Must be bound.
+            this.processAction = async (action, payload, senderIdentity) => {
+                if (ChannelProvider.clientIsMultiRuntime(senderIdentity) &&
+                    !runtimeVersioning_1.runtimeUuidMeetsMinimumRuntimeVersion(senderIdentity.runtimeUuid, '18.87.56.0')) {
+                    this.handleMultiRuntimeLegacyClient(senderIdentity);
+                }
+                else {
+                    this.checkForClientConnection(senderIdentity);
+                }
+                return super.processAction(action, payload, senderIdentity);
+            };
+            _close.set(this, () => {
+                __classPrivateFieldGet(this, _strategy).close();
+                const remove = ChannelProvider.removalMap.get(this);
+                if (remove) {
+                    remove();
+                }
+            });
+            __classPrivateFieldSet(this, _protectedObj, new channel_1.ProtectedItems(providerIdentity, wire));
+            this.connectListener = () => undefined;
+            this.disconnectListener = () => undefined;
+            __classPrivateFieldSet(this, _connections, []);
+            __classPrivateFieldSet(this, _strategy, strategy);
+            strategy.receive(this.processAction);
+        }
+        get connections() {
+            return [...__classPrivateFieldGet(this, _connections)];
+        }
+        static handleClientDisconnection(channel, payload) {
+            const removeById = channel.connections.find((identity) => identity.endpointId === payload.endpointId);
+            if (removeById) {
+                __classPrivateFieldGet(channel, _removeEndpoint).call(channel, removeById);
+            }
+            else {
+                const multipleRemoves = channel.connections.filter((identity) => {
+                    return identity.uuid === payload.uuid && identity.name === payload.name;
+                });
+                multipleRemoves.forEach(__classPrivateFieldGet(channel, _removeEndpoint));
+            }
+            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);
+            if (endpointId && __classPrivateFieldGet(this, _strategy).isEndpointConnected(endpointId)) {
+                return __classPrivateFieldGet(this, _strategy).send(endpointId, action, payload);
+            }
+            return Promise.reject(new Error(`Client connection with identity uuid: ${to.uuid} / name: ${to.name} / endpointId: ${endpointId} no longer connected.`));
+        }
+        async processConnection(senderId, payload) {
+            __classPrivateFieldGet(this, _connections).push(senderId);
+            return this.connectListener(senderId, payload);
+        }
+        publish(action, payload) {
+            return this.connections.map((to) => __classPrivateFieldGet(this, _strategy).send(to.endpointId, action, payload));
+        }
+        onConnection(listener) {
+            this.connectListener = listener;
+        }
+        onDisconnection(listener) {
+            this.disconnectListener = listener;
+        }
+        async destroy() {
+            const protectedObj = __classPrivateFieldGet(this, _protectedObj);
+            const { channelName } = protectedObj.providerIdentity;
+            __classPrivateFieldSet(this, _connections, []);
+            await protectedObj.wire.sendAction('destroy-channel', { channelName });
+            __classPrivateFieldGet(this, _close).call(this);
+        }
+        checkForClientConnection(clientIdentity) {
+            if (!this.isClientConnected(clientIdentity)) {
                 throw new Error(`This action was sent from a client that is not connected to the provider.
-                    Client Identity: {uuid: ${clientIdentity.uuid}, name: ${clientIdentity.name}, endpointId: ${clientIdentity.endpointId}}`);
-            }
-        }
-        isClientConnected(clientIdentity) {
-            if (ChannelProvider.clientIdentityIncludesEndpointId(clientIdentity)) {
-                return this.connections.some((identity) => {
-                    return (
-                    // Might be redundant to check for uuid and name here after we get an endpointId match, but just in case
-                    identity.endpointId === clientIdentity.endpointId &&
-                        identity.uuid === clientIdentity.uuid &&
-                        identity.name === clientIdentity.name);
-                });
-            }
-            return this.isLegacyClientConnected(clientIdentity);
-        }
-        isLegacyClientConnected(clientIdentity) {
-            return this.connections.some((identity) => {
-                return identity.uuid === clientIdentity.uuid && identity.name === clientIdentity.name;
-            });
-        }
-        handleMultiRuntimeLegacyClient(senderIdentity) {
-            if (!this.isLegacyClientConnected(senderIdentity)) {
+                    Client Identity: {uuid: ${clientIdentity.uuid}, name: ${clientIdentity.name}, endpointId: ${clientIdentity.endpointId}}`);
+            }
+        }
+        isClientConnected(clientIdentity) {
+            if (ChannelProvider.clientIdentityIncludesEndpointId(clientIdentity)) {
+                return this.connections.some((identity) => {
+                    return (
+                    // Might be redundant to check for uuid and name here after we get an endpointId match, but just in case
+                    identity.endpointId === clientIdentity.endpointId &&
+                        identity.uuid === clientIdentity.uuid &&
+                        identity.name === clientIdentity.name);
+                });
+            }
+            return this.isLegacyClientConnected(clientIdentity);
+        }
+        isLegacyClientConnected(clientIdentity) {
+            return this.connections.some((identity) => {
+                return identity.uuid === clientIdentity.uuid && identity.name === clientIdentity.name;
+            });
+        }
+        handleMultiRuntimeLegacyClient(senderIdentity) {
+            if (!this.isLegacyClientConnected(senderIdentity)) {
                 throw new Error(`This action was sent from a client that is not connected to the provider. Client Identity:
-                    {uuid: ${senderIdentity.uuid}, name: ${senderIdentity.name}, endpointId: ${senderIdentity.endpointId}}`);
-            }
-        }
-        getEndpointIdForOpenFinId(clientIdentity, action) {
-            var _a;
-            const matchingConnections = this.connections.filter((c) => c.name === clientIdentity.name && c.uuid === clientIdentity.uuid);
-            if (matchingConnections.length >= 2) {
-                const protectedObj = __classPrivateFieldGet(this, _protectedObj);
-                const { uuid, name } = clientIdentity;
-                const providerUuid = protectedObj === null || protectedObj === void 0 ? void 0 : protectedObj.providerIdentity.uuid;
-                const providerName = protectedObj === null || protectedObj === void 0 ? void 0 : protectedObj.providerIdentity.name;
-                // eslint-disable-next-line no-console
+                    {uuid: ${senderIdentity.uuid}, name: ${senderIdentity.name}, endpointId: ${senderIdentity.endpointId}}`);
+            }
+        }
+        getEndpointIdForOpenFinId(clientIdentity, action) {
+            var _a;
+            const matchingConnections = this.connections.filter((c) => c.name === clientIdentity.name && c.uuid === clientIdentity.uuid);
+            if (matchingConnections.length >= 2) {
+                const protectedObj = __classPrivateFieldGet(this, _protectedObj);
+                const { uuid, name } = clientIdentity;
+                const providerUuid = protectedObj === null || protectedObj === void 0 ? void 0 : protectedObj.providerIdentity.uuid;
+                const providerName = protectedObj === null || protectedObj === void 0 ? void 0 : protectedObj.providerIdentity.name;
+                // eslint-disable-next-line no-console
                 console.warn(`WARNING: Dispatch call may have unintended results. The "to" argument of your dispatch call is missing the
                 "endpointId" parameter. The identity you are dispatching to ({uuid: ${uuid}, name: ${name}})
                 has multiple channelClients for this channel. Your dispatched action: (${action}) from the provider:
-                ({uuid: ${providerUuid}, name: ${providerName}}) will only be processed by the most recently-created client.`);
-            }
-            // Pop to return the most recently created endpointId.
-            return (_a = matchingConnections.pop()) === null || _a === void 0 ? void 0 : _a.endpointId;
-        }
-        // eslint-disable-next-line class-methods-use-this
-        static clientIdentityIncludesEndpointId(subscriptionIdentity) {
-            return subscriptionIdentity.endpointId !== undefined;
-        }
-        // eslint-disable-next-line class-methods-use-this
-        static clientIsMultiRuntime(subscriptionIdentity) {
-            return subscriptionIdentity.runtimeUuid !== undefined;
-        }
-    }
-    _connections = new WeakMap(), _protectedObj = new WeakMap(), _strategy = new WeakMap(), _removeEndpoint = new WeakMap(), _close = new WeakMap();
-    // The following line should be changed following a typescript update.
-    // static #removalMap = new WeakMap<ChannelProvider, Function>();
-    ChannelProvider.removalMap = new WeakMap();
-    return ChannelProvider;
-})();
-exports.ChannelProvider = ChannelProvider;
+                ({uuid: ${providerUuid}, name: ${providerName}}) will only be processed by the most recently-created client.`);
+            }
+            // Pop to return the most recently created endpointId.
+            return (_a = matchingConnections.pop()) === null || _a === void 0 ? void 0 : _a.endpointId;
+        }
+        // eslint-disable-next-line class-methods-use-this
+        static clientIdentityIncludesEndpointId(subscriptionIdentity) {
+            return subscriptionIdentity.endpointId !== undefined;
+        }
+        // eslint-disable-next-line class-methods-use-this
+        static clientIsMultiRuntime(subscriptionIdentity) {
+            return subscriptionIdentity.runtimeUuid !== undefined;
+        }
+    }
+    _connections = new WeakMap(), _protectedObj = new WeakMap(), _strategy = new WeakMap(), _removeEndpoint = new WeakMap(), _close = new WeakMap();
+    // The following line should be changed following a typescript update.
+    // static #removalMap = new WeakMap<ChannelProvider, Function>();
+    ChannelProvider.removalMap = new WeakMap();
+    return ChannelProvider;
+})();
+exports.ChannelProvider = ChannelProvider;