@openfin/core 30.73.6 → 30.73.7

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,15 +53,30 @@ class Channel extends base_1.EmitterBase {
             this.on('connected', listener);
         });
         try {
-            const { offer, rtc: rtcPacket } = await __classPrivateFieldGet(this, _connectionManager).createClientOffer(opts);
-            const res = await this.wire.sendAction('connect-to-channel', { channelName, ...opts, offer });
+            const { offer, rtc: rtcPacket } = await __classPrivateFieldGet(this, _Channel_connectionManager, "f").createClientOffer(opts);
+            let connectionUrl;
+            const entityType = this.wire.environment.getCurrentEntityType();
+            if (entityType === 'iframe') {
+                // @ts-expect-error
+                // TODO: type this correctly (frame types are broken)
+                const frame = (await this.fin.me.getInfo()).url;
+            }
+            else if (entityType === 'window' || entityType === 'view') {
+                connectionUrl = (await this.fin.me.getInfo()).url;
+            }
+            const res = await this.wire.sendAction('connect-to-channel', {
+                channelName,
+                ...opts,
+                offer,
+                connectionUrl
+            });
             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.
             if (resolver) {
                 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 +119,9 @@ 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);
+        // TODO: fix typing (internal)
+        // @ts-expect-error
         this.on('client-disconnected', (eventPayload) => {
             if (eventPayload.channelName === channelName) {
                 provider_1.ChannelProvider.handleClientDisconnection(channel, eventPayload);
@@ -116,4 +131,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.d.ts

@@ -1,8 +1,9 @@
+import type * as OpenFin from '../../../../../OpenFin';
 import Transport from '../../../../../transport/transport';
 import { MessageReceiver } from './message-receiver';
 import { ChannelStrategy, EndpointPayload } from '../strategy';
 import { LocalSupportedProtocol } from '..';
-import ProviderIdentity = OpenFin.ProviderIdentity;
+declare type ProviderIdentity = OpenFin.ProviderIdentity;
 export declare class ClassicStrategy implements ChannelStrategy<EndpointPayload> {
     #private;
     private messageReceiver;
@@ -20,3 +21,4 @@ export declare class ClassicStrategy implements ChannelStrategy<EndpointPayload>
     isValidEndpointPayload(payload: any): payload is EndpointPayload;
 }
 export declare const ClassicInfo: LocalSupportedProtocol;
+export {};

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

@@ -15,6 +15,9 @@ export interface RTCProtocolOffer extends ProtocolPacketBase {
     };
 }
 export declare type ProtocolOffer = ClassicProtocolOffer | RTCProtocolOffer;
+/**
+ * Protocol values for determining channel messaging strategy.
+ */
 export declare type MessagingProtocols = ProtocolOffer['type'];
 export declare type LocalSupportedProtocol = {
     type: MessagingProtocols;

package/src/api/interappbus/channel/protocols/protocol-manager.d.ts

@@ -1,4 +1,4 @@
-import { MessagingProtocols, ExternalClientOffer, ProtocolOffer, LocalSupportedProtocol } from '.';
+import { ExternalClientOffer, LocalSupportedProtocol, MessagingProtocols, ProtocolOffer } from '.';
 export declare class ProtocolManager {
     private ProtocolsInPreferenceOrder;
     DefaultClientProtocols: ['classic'];

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

@@ -1,4 +1,5 @@
-import ProviderIdentity = OpenFin.ProviderIdentity;
+import type * as OpenFin from '../../../../../OpenFin';
+declare type ProviderIdentity = OpenFin.ProviderIdentity;
 export interface RTCEndpointChannels {
     request: RTCDataChannel;
     response: RTCDataChannel;
@@ -21,3 +22,4 @@ export declare class RTCEndpoint {
     close: () => void;
     get connected(): boolean;
 }
+export {};

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

@@ -1,21 +1,19 @@
 "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;
+/* eslint-disable @typescript-eslint/no-unused-vars */
 const errors_1 = require("../../../../../util/errors");
 /*
 This handles sending RTC messages between RTC connections over the request and response data channels.
@@ -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/ice-manager.js

@@ -1,5 +1,4 @@
 "use strict";
-/* eslint-disable class-methods-use-this */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.RTCICEManager = void 0;
 const base_1 = require("../../../../base");

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

@@ -1,7 +1,8 @@
+import type * as OpenFin from '../../../../../OpenFin';
 import { ChannelStrategy } from '../strategy';
 import { RTCPacket } from './endpoint';
 import { LocalSupportedProtocol } from '..';
-import ProviderIdentity = OpenFin.ProviderIdentity;
+declare type ProviderIdentity = OpenFin.ProviderIdentity;
 export interface RTCStrategyEndpointPayload {
     endpointIdentity: OpenFin.ClientIdentity | ProviderIdentity;
     rtc: RTCPacket;
@@ -20,3 +21,4 @@ export declare class RTCStrategy implements ChannelStrategy<RTCStrategyEndpointP
     isValidEndpointPayload(payload: any): payload is RTCStrategyEndpointPayload;
 }
 export declare const RTCInfo: LocalSupportedProtocol;
+export {};

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/protocols/strategy.d.ts

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

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

@@ -1,26 +1,29 @@
+import type * as OpenFin from '../../../OpenFin';
 import { ChannelBase } from './channel';
 import Transport from '../../../transport/transport';
 import { AnyStrategy } from './protocols/strategy-types';
-import ProviderIdentity = OpenFin.ProviderIdentity;
-import ClientIdentity = OpenFin.ClientIdentity;
+declare type ProviderIdentity = OpenFin.ProviderIdentity;
+declare type ClientIdentity = OpenFin.ClientIdentity;
 export declare type ConnectionListener = (identity: ClientIdentity, connectionMessage?: any) => Promise<any> | any;
 export declare type DisconnectionListener = (identity: ClientIdentity) => any;
+declare type ClientConnectionPayload = OpenFin.ClientIdentity & OpenFin.ClientInfo;
 export declare class ChannelProvider extends ChannelBase {
     #private;
     private static removalMap;
     private connectListener;
     private disconnectListener;
-    get connections(): OpenFin.ClientIdentity[];
+    get connections(): ClientConnectionPayload[];
     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>;
+    processConnection(senderId: ClientConnectionPayload, payload: any): Promise<any>;
     publish(action: string, payload: any): Promise<any>[];
     onConnection(listener: ConnectionListener): void;
     onDisconnection(listener: DisconnectionListener): void;
     destroy(): Promise<void>;
+    getAllClientInfo(): Promise<Array<OpenFin.ClientInfo>>;
     private checkForClientConnection;
     private isClientConnected;
     private isLegacyClientConnected;
@@ -29,3 +32,4 @@ export declare class ChannelProvider extends ChannelBase {
     private static clientIdentityIncludesEndpointId;
     private static clientIsMultiRuntime;
 }
+export {};