@openfin/core 27.71.21 → 27.71.23

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@openfin/core",
-    "version": "27.71.21",
+    "version": "27.71.23",
     "license": "Apache-2.0",
     "main": "./src/mock.js",
     "types": "./src/mock.d.ts",

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

@@ -15,6 +15,7 @@ export default class ChannelClient extends ChannelBase {
     constructor(routingInfo: RoutingInfo, wire: Transport, strategy: AnyStrategy);
     protected processAction: (action: string, payload: any, senderIdentity: ProviderIdentity | OpenFin.ClientIdentity) => Promise<any>;
     get providerIdentity(): ProviderIdentity;
+    getRTCConnection(): RTCPeerConnection;
     dispatch(action: string, payload?: any): Promise<any>;
     onDisconnection(listener: DisconnectionListener): void;
     disconnect(): Promise<void>;

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

@@ -49,6 +49,9 @@ class ChannelClient extends channel_1.ChannelBase {
         const protectedObj = __classPrivateFieldGet(this, _protectedObj);
         return protectedObj.providerIdentity;
     }
+    getRTCConnection() {
+        return __classPrivateFieldGet(this, _strategy).getRTCConnection(this.providerIdentity.channelId);
+    }
     async dispatch(action, payload) {
         if (__classPrivateFieldGet(this, _strategy).isEndpointConnected(this.providerIdentity.channelId)) {
             return __classPrivateFieldGet(this, _strategy).send(this.providerIdentity.channelId, action, payload);

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

@@ -10,6 +10,7 @@ export declare class ClassicStrategy implements ChannelStrategy<EndpointPayload>
     private providerIdentity;
     constructor(wire: Transport, messageReceiver: MessageReceiver, endpointId: string, // Provider endpointId is channelId
     providerIdentity: ProviderIdentity);
+    getRTCConnection(endpointId: string): RTCPeerConnection;
     onEndpointDisconnect(endpointId: string, listener: () => void): void;
     receive(listener: (action: string, payload: any, identity: OpenFin.ClientIdentity | OpenFin.ClientIdentityMultiRuntime | ProviderIdentity) => Promise<any>): void;
     send: (endpointId: string, action: string, payload: any) => Promise<any>;

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

@@ -57,6 +57,9 @@ class ClassicStrategy {
         };
         __classPrivateFieldSet(this, _wire, wire);
     }
+    getRTCConnection(endpointId) {
+        throw new Error("Not implemented");
+    }
     onEndpointDisconnect(endpointId, listener) {
         // Never fires for 'classic'.
     }

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

@@ -15,6 +15,7 @@ export default class CombinedStrategy<A, B> implements ChannelStrategy<OnlyIfCom
     addEndpoint(endpoint: string, payload: OnlyIfCompatible<A, B>): Promise<void>;
     receive(listener: (action: string, payload: any, identity: any) => Promise<any>): void;
     send(endpointId: string, action: string, payload: any): Promise<any>;
+    getRTCConnection(endpointId: string): RTCPeerConnection;
     close(): Promise<void>;
 }
 export {};

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

@@ -51,6 +51,18 @@ class CombinedStrategy {
         }
         return this.secondary.send(endpointId, action, payload);
     }
+    getRTCConnection(endpointId) {
+        let connection;
+        try {
+            if (this.primary.isEndpointConnected(endpointId)) {
+                connection = this.primary.getRTCConnection(endpointId);
+            }
+        }
+        catch (error) {
+            console.log("error getting rtcpeer from primary");
+        }
+        return connection !== null && connection !== void 0 ? connection : this.secondary.getRTCConnection(endpointId);
+    }
     async close() {
         await Promise.all([this.primary.close(), this.secondary.close()]);
     }

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

@@ -20,4 +20,5 @@ export declare class RTCEndpoint {
     send: (action: string, payload: any) => Promise<any>;
     close: () => void;
     get connected(): boolean;
+    get peerConnection(): RTCPeerConnection;
 }

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

@@ -130,6 +130,9 @@ class RTCEndpoint {
     get connected() {
         return this.rtc.rtcClient.connectionState === 'connected';
     }
+    get peerConnection() {
+        return this.rtc.rtcClient;
+    }
 }
 exports.RTCEndpoint = RTCEndpoint;
 _processAction = new WeakMap(), _disconnectListener = new WeakMap();

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

@@ -9,6 +9,7 @@ export interface RTCStrategyEndpointPayload {
 export declare class RTCStrategy implements ChannelStrategy<RTCStrategyEndpointPayload> {
     #private;
     onEndpointDisconnect(endpointId: string, listener: () => void): void;
+    getRTCConnection(endpointId: string): RTCPeerConnection;
     receive(listener: (action: string, payload: any, identity: OpenFin.ClientIdentity | OpenFin.ClientIdentityMultiRuntime | ProviderIdentity) => Promise<any>): void;
     send: (endpointId: string, action: string, payload: any) => Promise<any>;
     close: () => Promise<void>;

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

@@ -38,6 +38,13 @@ class RTCStrategy {
     onEndpointDisconnect(endpointId, listener) {
         this.getEndpointById(endpointId).onDisconnect(listener);
     }
+    getRTCConnection(endpointId) {
+        const endpoint = __classPrivateFieldGet(this, _rtcEndpointMap).get(endpointId);
+        if (!endpoint) {
+            throw new Error('Could not find WebRTC connection');
+        }
+        return endpoint.peerConnection;
+    }
     receive(listener) {
         if (__classPrivateFieldGet(this, _processAction)) {
             throw new Error('You have already set a listener for this RTC Strategy');

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

@@ -8,6 +8,7 @@ export interface ChannelStrategy<T extends unknown> {
     isEndpointConnected(endpointId: string): boolean;
     addEndpoint(endpointId: string, payload: T): void;
     isValidEndpointPayload(payload: unknown): payload is T;
+    getRTCConnection(endpointId: string): RTCPeerConnection;
 }
 export declare type EndpointIdentity = OpenFin.ClientIdentity | ProviderIdentity;
 export declare type EndpointPayload = {

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

@@ -13,6 +13,7 @@ export declare class ChannelProvider extends ChannelBase {
     get connections(): OpenFin.ClientIdentity[];
     static handleClientDisconnection(channel: ChannelProvider, payload: any): void;
     static setProviderRemoval(provider: ChannelProvider, remove: Function): void;
+    getRTCPeerConnection(endpointId: string): RTCPeerConnection;
     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>;

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

@@ -73,6 +73,9 @@ let ChannelProvider = /** @class */ (() => {
         static setProviderRemoval(provider, remove) {
             ChannelProvider.removalMap.set(provider, remove);
         }
+        getRTCPeerConnection(endpointId) {
+            return __classPrivateFieldGet(this, _strategy).getRTCConnection(endpointId);
+        }
         dispatch(to, action, payload) {
             var _a;
             const endpointId = (_a = to.endpointId) !== null && _a !== void 0 ? _a : this.getEndpointIdForOpenFinId(to, action);