@openfin/core 29.72.17 → 29.73.1

package/src/api/interappbus/channel/index.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 _connectionManager;
+var _Channel_connectionManager;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Channel = void 0;
 /* eslint-disable no-console */
@@ -25,8 +23,8 @@ const noop = () => { };
 class Channel extends base_1.EmitterBase {
     constructor(wire) {
         super(wire, 'channel');
-        _connectionManager.set(this, void 0);
-        __classPrivateFieldSet(this, _connectionManager, new connection_manager_1.ConnectionManager(wire));
+        _Channel_connectionManager.set(this, void 0);
+        __classPrivateFieldSet(this, _Channel_connectionManager, new connection_manager_1.ConnectionManager(wire), "f");
     }
     async getAllChannels() {
         return this.wire.sendAction('get-all-channels').then(({ payload }) => payload.data);
@@ -55,7 +53,7 @@ class Channel extends base_1.EmitterBase {
             this.on('connected', listener);
         });
         try {
-            const { offer, rtc: rtcPacket } = await __classPrivateFieldGet(this, _connectionManager).createClientOffer(opts);
+            const { offer, rtc: rtcPacket } = await __classPrivateFieldGet(this, _Channel_connectionManager, "f").createClientOffer(opts);
             const res = await this.wire.sendAction('connect-to-channel', { channelName, ...opts, offer });
             const { payload: { data: routingInfo } } = res;
             // If there isn't a matching channel, the above sendAction call will error out and go to catch, skipping the logic below.
@@ -63,7 +61,7 @@ class Channel extends base_1.EmitterBase {
                 resolver();
             }
             this.removeListener('connected', listener);
-            const strategy = await __classPrivateFieldGet(this, _connectionManager).createClientStrategy(rtcPacket, routingInfo);
+            const strategy = await __classPrivateFieldGet(this, _Channel_connectionManager, "f").createClientStrategy(rtcPacket, routingInfo);
             const channel = new client_1.default(routingInfo, this.wire, strategy);
             // It is the client's responsibility to handle endpoint disconnection to the provider.
             // If the endpoint dies, the client will force a disconnection through the core.
@@ -106,7 +104,7 @@ class Channel extends base_1.EmitterBase {
             throw new Error('Please provide a channelName to create a channel');
         }
         const { payload: { data: providerIdentity } } = await this.wire.sendAction('create-channel', { channelName });
-        const channel = __classPrivateFieldGet(this, _connectionManager).createProvider(options, providerIdentity);
+        const channel = __classPrivateFieldGet(this, _Channel_connectionManager, "f").createProvider(options, providerIdentity);
         this.on('client-disconnected', (eventPayload) => {
             if (eventPayload.channelName === channelName) {
                 provider_1.ChannelProvider.handleClientDisconnection(channel, eventPayload);
@@ -116,4 +114,4 @@ class Channel extends base_1.EmitterBase {
     }
 }
 exports.Channel = Channel;
-_connectionManager = new WeakMap();
+_Channel_connectionManager = new WeakMap();

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' };