@openfin/core 29.72.18 → 29.73.1

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

@@ -1,18 +1,16 @@
 "use strict";
-var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, privateMap, value) {
-    if (!privateMap.has(receiver)) {
-        throw new TypeError("attempted to set private field on non-instance");
-    }
-    privateMap.set(receiver, value);
-    return value;
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
 };
-var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, privateMap) {
-    if (!privateMap.has(receiver)) {
-        throw new TypeError("attempted to get private field on non-instance");
-    }
-    return privateMap.get(receiver);
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
 };
-var _wire, _endpointIdentityMap;
+var _ClassicStrategy_wire, _ClassicStrategy_endpointIdentityMap;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ClassicInfo = exports.ClassicStrategy = void 0;
 /*
@@ -24,12 +22,12 @@ class ClassicStrategy {
         this.messageReceiver = messageReceiver;
         this.endpointId = endpointId;
         this.providerIdentity = providerIdentity;
-        _wire.set(this, void 0);
+        _ClassicStrategy_wire.set(this, void 0);
         // Store full endpointIdentity by endpointId of all known endpoints for this strategy instance.
         // (clients will only have 1: the provider, the provider will have all clients)
-        _endpointIdentityMap.set(this, new Map());
+        _ClassicStrategy_endpointIdentityMap.set(this, new Map());
         this.send = async (endpointId, action, payload) => {
-            const to = __classPrivateFieldGet(this, _endpointIdentityMap).get(endpointId);
+            const to = __classPrivateFieldGet(this, _ClassicStrategy_endpointIdentityMap, "f").get(endpointId);
             if (!to) {
                 throw new Error(`Could not locate routing info for endpoint ${endpointId}`);
             }
@@ -40,7 +38,8 @@ class ClassicStrategy {
                 delete cleanId.endpointId;
             }
             delete cleanId.isLocalEndpointId;
-            const raw = await __classPrivateFieldGet(this, _wire).sendAction('send-channel-message', {
+            const raw = await __classPrivateFieldGet(this, _ClassicStrategy_wire, "f")
+                .sendAction('send-channel-message', {
                 ...cleanId,
                 providerIdentity: this.providerIdentity,
                 action,
@@ -53,9 +52,9 @@ class ClassicStrategy {
         };
         this.close = async () => {
             this.messageReceiver.removeEndpoint(this.providerIdentity.channelId, this.endpointId);
-            __classPrivateFieldSet(this, _endpointIdentityMap, new Map());
+            __classPrivateFieldSet(this, _ClassicStrategy_endpointIdentityMap, new Map(), "f");
         };
-        __classPrivateFieldSet(this, _wire, wire);
+        __classPrivateFieldSet(this, _ClassicStrategy_wire, wire, "f");
     }
     onEndpointDisconnect(endpointId, listener) {
         // Never fires for 'classic'.
@@ -64,13 +63,13 @@ class ClassicStrategy {
         this.messageReceiver.addEndpoint(listener, this.providerIdentity.channelId, this.endpointId);
     }
     async closeEndpoint(endpointId) {
-        __classPrivateFieldGet(this, _endpointIdentityMap).delete(endpointId);
+        __classPrivateFieldGet(this, _ClassicStrategy_endpointIdentityMap, "f").delete(endpointId);
     }
     isEndpointConnected(endpointId) {
-        return __classPrivateFieldGet(this, _endpointIdentityMap).has(endpointId);
+        return __classPrivateFieldGet(this, _ClassicStrategy_endpointIdentityMap, "f").has(endpointId);
     }
     addEndpoint(endpointId, payload) {
-        __classPrivateFieldGet(this, _endpointIdentityMap).set(endpointId, payload.endpointIdentity);
+        __classPrivateFieldGet(this, _ClassicStrategy_endpointIdentityMap, "f").set(endpointId, payload.endpointIdentity);
     }
     isValidEndpointPayload(payload) {
         var _a, _b;
@@ -79,6 +78,6 @@ class ClassicStrategy {
     }
 }
 exports.ClassicStrategy = ClassicStrategy;
-_wire = new WeakMap(), _endpointIdentityMap = new WeakMap();
+_ClassicStrategy_wire = new WeakMap(), _ClassicStrategy_endpointIdentityMap = new WeakMap();
 // Arbitrarily starting at 5 to leave the door open to backfilling pre endpointId etc.
 exports.ClassicInfo = { version: 5, minimumVersion: 0, type: 'classic' };

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

@@ -1,19 +1,17 @@
 "use strict";
 /* eslint-disable @typescript-eslint/no-unused-vars */
-var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, privateMap) {
-    if (!privateMap.has(receiver)) {
-        throw new TypeError("attempted to get private field on non-instance");
-    }
-    return privateMap.get(receiver);
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
 };
-var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, privateMap, value) {
-    if (!privateMap.has(receiver)) {
-        throw new TypeError("attempted to set private field on non-instance");
-    }
-    privateMap.set(receiver, value);
-    return value;
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
 };
-var _processAction, _disconnectListener;
+var _RTCEndpoint_processAction, _RTCEndpoint_disconnectListener;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.RTCEndpoint = void 0;
 const errors_1 = require("../../../../../util/errors");
@@ -25,14 +23,14 @@ class RTCEndpoint {
         this.rtc = rtc;
         this.endpointIdentity = endpointIdentity;
         this.responseMap = new Map();
-        _processAction.set(this, null);
-        _disconnectListener.set(this, void 0);
+        _RTCEndpoint_processAction.set(this, null);
+        _RTCEndpoint_disconnectListener.set(this, void 0);
         this.connectionStateChangeHandler = (event) => {
             if (this.rtc.rtcClient.connectionState !== 'connected') {
                 this.rtc.rtcClient.removeEventListener('connectionstatechange', this.connectionStateChangeHandler);
                 this.close();
-                if (__classPrivateFieldGet(this, _disconnectListener)) {
-                    __classPrivateFieldGet(this, _disconnectListener).call(this);
+                if (__classPrivateFieldGet(this, _RTCEndpoint_disconnectListener, "f")) {
+                    __classPrivateFieldGet(this, _RTCEndpoint_disconnectListener, "f").call(this);
                 }
             }
         };
@@ -71,9 +69,9 @@ class RTCEndpoint {
         });
         this.rtc.channels.request.addEventListener('message', async (e) => {
             const { messageId, action, payload } = JSON.parse(e.data);
-            if (__classPrivateFieldGet(this, _processAction)) {
+            if (__classPrivateFieldGet(this, _RTCEndpoint_processAction, "f")) {
                 try {
-                    const res = await __classPrivateFieldGet(this, _processAction).call(this, action, payload, endpointIdentity);
+                    const res = await __classPrivateFieldGet(this, _RTCEndpoint_processAction, "f").call(this, action, payload, endpointIdentity);
                     this.rtc.channels.response.send(JSON.stringify({
                         messageId,
                         payload: res,
@@ -86,7 +84,7 @@ class RTCEndpoint {
                     if (this.rtc.channels.response.readyState === 'open') {
                         this.rtc.channels.response.send(JSON.stringify({
                             messageId,
-                            error: errors_1.errorToPOJO(error),
+                            error: (0, errors_1.errorToPOJO)(error),
                             success: false
                         }));
                     }
@@ -107,29 +105,29 @@ class RTCEndpoint {
             datachannel.onclose = (e) => {
                 [...this.responseMap.values()].forEach((promise) => promise.reject(new Error('RTCDataChannel closed unexpectedly, this is most commonly caused by message size. Note: RTC Channels have a message size limit of ~255kB.')));
                 this.close();
-                if (__classPrivateFieldGet(this, _disconnectListener)) {
-                    __classPrivateFieldGet(this, _disconnectListener).call(this);
+                if (__classPrivateFieldGet(this, _RTCEndpoint_disconnectListener, "f")) {
+                    __classPrivateFieldGet(this, _RTCEndpoint_disconnectListener, "f").call(this);
                 }
             };
         });
     }
     onDisconnect(listener) {
-        if (!__classPrivateFieldGet(this, _disconnectListener)) {
-            __classPrivateFieldSet(this, _disconnectListener, listener);
+        if (!__classPrivateFieldGet(this, _RTCEndpoint_disconnectListener, "f")) {
+            __classPrivateFieldSet(this, _RTCEndpoint_disconnectListener, listener, "f");
         }
         else {
             throw new Error('RTCEndpoint disconnectListener cannot be set twice.');
         }
     }
     receive(listener) {
-        if (__classPrivateFieldGet(this, _processAction)) {
+        if (__classPrivateFieldGet(this, _RTCEndpoint_processAction, "f")) {
             throw new Error('You have already set a listener for this RTC Endpoint.');
         }
-        __classPrivateFieldSet(this, _processAction, listener);
+        __classPrivateFieldSet(this, _RTCEndpoint_processAction, listener, "f");
     }
     get connected() {
         return this.rtc.rtcClient.connectionState === 'connected';
     }
 }
 exports.RTCEndpoint = RTCEndpoint;
-_processAction = new WeakMap(), _disconnectListener = new WeakMap();
+_RTCEndpoint_processAction = new WeakMap(), _RTCEndpoint_disconnectListener = new WeakMap();

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

@@ -1,18 +1,16 @@
 "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 __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, privateMap, value) {
-    if (!privateMap.has(receiver)) {
-        throw new TypeError("attempted to set private field on non-instance");
-    }
-    privateMap.set(receiver, value);
-    return value;
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
 };
-var _processAction, _rtcEndpointMap, _connected;
+var _RTCStrategy_processAction, _RTCStrategy_rtcEndpointMap, _RTCStrategy_connected;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.RTCInfo = exports.RTCStrategy = void 0;
 const endpoint_1 = require("./endpoint");
@@ -21,56 +19,56 @@ This is used to abstract out rtc messaging from the channels implementation usin
 */
 class RTCStrategy {
     constructor() {
-        _processAction.set(this, null);
-        _rtcEndpointMap.set(this, new Map());
-        _connected.set(this, true);
+        _RTCStrategy_processAction.set(this, null);
+        _RTCStrategy_rtcEndpointMap.set(this, new Map());
+        _RTCStrategy_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());
+            if (__classPrivateFieldGet(this, _RTCStrategy_connected, "f")) {
+                __classPrivateFieldGet(this, _RTCStrategy_rtcEndpointMap, "f").forEach((rtcEndpoint) => rtcEndpoint.close());
+                __classPrivateFieldSet(this, _RTCStrategy_rtcEndpointMap, new Map(), "f");
             }
-            __classPrivateFieldSet(this, _connected, false);
+            __classPrivateFieldSet(this, _RTCStrategy_connected, false, "f");
         };
     }
     onEndpointDisconnect(endpointId, listener) {
         this.getEndpointById(endpointId).onDisconnect(listener);
     }
     receive(listener) {
-        if (__classPrivateFieldGet(this, _processAction)) {
+        if (__classPrivateFieldGet(this, _RTCStrategy_processAction, "f")) {
             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)));
+        __classPrivateFieldSet(this, _RTCStrategy_processAction, listener, "f");
+        __classPrivateFieldGet(this, _RTCStrategy_rtcEndpointMap, "f").forEach((rtcEndpoint) => rtcEndpoint.receive(__classPrivateFieldGet(this, _RTCStrategy_processAction, "f")));
     }
     getEndpointById(endpointId) {
-        const endpoint = __classPrivateFieldGet(this, _rtcEndpointMap).get(endpointId);
+        const endpoint = __classPrivateFieldGet(this, _RTCStrategy_rtcEndpointMap, "f").get(endpointId);
         if (!endpoint) {
             throw new Error(`Client with endpoint id ${endpointId} is not connected`);
         }
         return endpoint;
     }
     get connected() {
-        return __classPrivateFieldGet(this, _connected);
+        return __classPrivateFieldGet(this, _RTCStrategy_connected, "f");
     }
     isEndpointConnected(endpointId) {
-        return __classPrivateFieldGet(this, _rtcEndpointMap).has(endpointId);
+        return __classPrivateFieldGet(this, _RTCStrategy_rtcEndpointMap, "f").has(endpointId);
     }
     addEndpoint(endpointId, payload) {
-        if (!__classPrivateFieldGet(this, _connected)) {
+        if (!__classPrivateFieldGet(this, _RTCStrategy_connected, "f")) {
             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));
+        if (__classPrivateFieldGet(this, _RTCStrategy_processAction, "f")) {
+            clientStrat.receive(__classPrivateFieldGet(this, _RTCStrategy_processAction, "f"));
         }
-        __classPrivateFieldGet(this, _rtcEndpointMap).set(endpointId, clientStrat);
+        __classPrivateFieldGet(this, _RTCStrategy_rtcEndpointMap, "f").set(endpointId, clientStrat);
     }
     async closeEndpoint(endpointId) {
-        __classPrivateFieldGet(this, _rtcEndpointMap).delete(endpointId);
+        __classPrivateFieldGet(this, _RTCStrategy_rtcEndpointMap, "f").delete(endpointId);
     }
     isValidEndpointPayload(payload) {
         const isObject = (x) => {
@@ -83,5 +81,5 @@ class RTCStrategy {
     }
 }
 exports.RTCStrategy = RTCStrategy;
-_processAction = new WeakMap(), _rtcEndpointMap = new WeakMap(), _connected = new WeakMap();
+_RTCStrategy_processAction = new WeakMap(), _RTCStrategy_rtcEndpointMap = new WeakMap(), _RTCStrategy_connected = new WeakMap();
 exports.RTCInfo = { version: 1, minimumVersion: 0, type: 'rtc' };

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

@@ -1,165 +1,160 @@
 "use strict";
-var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, privateMap, value) {
-    if (!privateMap.has(receiver)) {
-        throw new TypeError("attempted to set private field on non-instance");
-    }
-    privateMap.set(receiver, value);
-    return value;
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
 };
-var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, privateMap) {
-    if (!privateMap.has(receiver)) {
-        throw new TypeError("attempted to get private field on non-instance");
-    }
-    return privateMap.get(receiver);
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
 };
+var _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");
-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);
+class ChannelProvider extends channel_1.ChannelBase {
+    constructor(providerIdentity, wire, strategy) {
+        super();
+        _ChannelProvider_connections.set(this, void 0);
+        _ChannelProvider_protectedObj.set(this, void 0);
+        _ChannelProvider_strategy.set(this, void 0);
+        _ChannelProvider_removeEndpoint.set(this, (identity) => {
+            const remainingConnections = this.connections.filter((clientIdentity) => clientIdentity.endpointId !== identity.endpointId);
+            __classPrivateFieldGet(this, _ChannelProvider_strategy, "f").closeEndpoint(identity.endpointId);
+            __classPrivateFieldSet(this, _ChannelProvider_connections, remainingConnections, "f");
+        });
+        // Must be bound.
+        this.processAction = async (action, payload, senderIdentity) => {
+            if (ChannelProvider.clientIsMultiRuntime(senderIdentity) &&
+                !(0, runtimeVersioning_1.runtimeUuidMeetsMinimumRuntimeVersion)(senderIdentity.runtimeUuid, '18.87.56.0')) {
+                this.handleMultiRuntimeLegacyClient(senderIdentity);
             }
             else {
-                const multipleRemoves = channel.connections.filter((identity) => {
-                    return identity.uuid === payload.uuid && identity.name === payload.name;
-                });
-                multipleRemoves.forEach(__classPrivateFieldGet(channel, _removeEndpoint));
+                this.checkForClientConnection(senderIdentity);
             }
-            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 super.processAction(action, payload, senderIdentity);
+        };
+        _ChannelProvider_close.set(this, () => {
+            __classPrivateFieldGet(this, _ChannelProvider_strategy, "f").close();
+            const remove = ChannelProvider.removalMap.get(this);
+            if (remove) {
+                remove();
             }
-            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;
+        });
+        __classPrivateFieldSet(this, _ChannelProvider_protectedObj, new channel_1.ProtectedItems(providerIdentity, wire), "f");
+        this.connectListener = () => undefined;
+        this.disconnectListener = () => undefined;
+        __classPrivateFieldSet(this, _ChannelProvider_connections, [], "f");
+        __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"));
         }
-        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);
+        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, _ChannelProvider_strategy, "f").isEndpointConnected(endpointId)) {
+            return __classPrivateFieldGet(this, _ChannelProvider_strategy, "f").send(endpointId, action, payload);
         }
-        checkForClientConnection(clientIdentity) {
-            if (!this.isClientConnected(clientIdentity)) {
-                throw new Error(`This action was sent from a client that is not connected to the provider.
+        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, _ChannelProvider_connections, "f").push(senderId);
+        return this.connectListener(senderId, payload);
+    }
+    publish(action, payload) {
+        return this.connections.map((to) => __classPrivateFieldGet(this, _ChannelProvider_strategy, "f").send(to.endpointId, action, payload));
+    }
+    onConnection(listener) {
+        this.connectListener = listener;
+    }
+    onDisconnection(listener) {
+        this.disconnectListener = listener;
+    }
+    async destroy() {
+        const protectedObj = __classPrivateFieldGet(this, _ChannelProvider_protectedObj, "f");
+        const { channelName } = protectedObj.providerIdentity;
+        __classPrivateFieldSet(this, _ChannelProvider_connections, [], "f");
+        await protectedObj.wire.sendAction('destroy-channel', { channelName });
+        __classPrivateFieldGet(this, _ChannelProvider_close, "f").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) {
+    }
+    isClientConnected(clientIdentity) {
+        if (ChannelProvider.clientIdentityIncludesEndpointId(clientIdentity)) {
             return this.connections.some((identity) => {
-                return identity.uuid === clientIdentity.uuid && identity.name === clientIdentity.name;
+                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);
             });
         }
-        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:
+        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
-                console.warn(`WARNING: Dispatch call may have unintended results. The "to" argument of your dispatch call is missing the
+    }
+    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, _ChannelProvider_protectedObj, "f");
+            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;
         }
+        // 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;
+_ChannelProvider_connections = new WeakMap(), _ChannelProvider_protectedObj = new WeakMap(), _ChannelProvider_strategy = new WeakMap(), _ChannelProvider_removeEndpoint = new WeakMap(), _ChannelProvider_close = new WeakMap();
+// The following line should be changed following a typescript update.
+// static #removalMap = new WeakMap<ChannelProvider, Function>();
+ChannelProvider.removalMap = new WeakMap();

package/src/api/interappbus/index.js

@@ -54,7 +54,7 @@ class InterApplicationBus extends base_1.Base {
      * @tutorial InterApplicationBus.send
      */
     async send(destination, topic, message) {
-        const errorMsg = validate_1.validateIdentity(destination);
+        const errorMsg = (0, validate_1.validateIdentity)(destination);
         if (errorMsg) {
             throw new Error(errorMsg);
         }