@openfin/core 25.68.30 → 25.70.2

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

@@ -1,135 +1,135 @@
-"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 __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, privateMap, value) {
-    if (!privateMap.has(receiver)) {
-        throw new TypeError("attempted to set private field on non-instance");
-    }
-    privateMap.set(receiver, value);
-    return value;
-};
-var _processAction, _disconnectListener;
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.RTCEndpoint = void 0;
-const errors_1 = require("../../../../../util/errors");
-/*
-This handles sending RTC messages between RTC connections over the request and response data channels.
-*/
-class RTCEndpoint {
-    constructor(rtc, endpointIdentity) {
-        this.rtc = rtc;
-        this.endpointIdentity = endpointIdentity;
-        this.responseMap = new Map();
-        _processAction.set(this, null);
-        _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);
-                }
-            }
-        };
-        this.send = async (action, payload) => {
-            const messageId = `message-${Math.random()}`;
-            const promise = new Promise((resolve, reject) => {
-                this.responseMap.set(messageId, { resolve, reject });
-            });
-            this.rtc.channels.request.send(JSON.stringify({ action, payload, messageId }));
-            return promise;
-        };
-        this.close = () => {
-            this.responseMap.forEach((response) => response.reject('Connection has closed.'));
-            this.responseMap = new Map();
-            this.rtc.channels.request.close();
-            this.rtc.channels.response.close();
-            this.rtc.rtcClient.close();
-        };
-        this.rtc.channels.response.addEventListener('message', (e) => {
-            var _a;
-            const { messageId, payload, success, error } = JSON.parse(e.data);
-            const { resolve, reject } = (_a = this.responseMap.get(messageId)) !== null && _a !== void 0 ? _a : {};
-            if (resolve && reject) {
-                this.responseMap.delete(messageId);
-                if (success) {
-                    resolve(payload);
-                }
-                else {
-                    reject(error);
-                }
-            }
-            else {
-                console.log('Could not find id in responseMap.');
-                console.log(e);
-            }
-        });
-        this.rtc.channels.request.addEventListener('message', async (e) => {
-            const { messageId, action, payload } = JSON.parse(e.data);
-            if (__classPrivateFieldGet(this, _processAction)) {
-                try {
-                    const res = await __classPrivateFieldGet(this, _processAction).call(this, action, payload, endpointIdentity);
-                    this.rtc.channels.response.send(JSON.stringify({
-                        messageId,
-                        payload: res,
-                        success: true
-                    }));
-                }
-                catch (error) {
-                    // Check if RTCDataChannel is open before sending, error gets swallowed here in the case where
-                    // client dispatched then closed or disconnected before the dispatch resolves.
-                    if (this.rtc.channels.response.readyState === 'open') {
-                        this.rtc.channels.response.send(JSON.stringify({
-                            messageId,
-                            error: errors_1.errorToPOJO(error),
-                            success: false
-                        }));
-                    }
-                }
-                // Check if RTCDataChannel is open for same reason as catch block above.
-            }
-            else if (this.rtc.channels.response.readyState === 'open') {
-                this.rtc.channels.response.send(JSON.stringify({
-                    messageId,
-                    success: false,
-                    error: 'Connection not ready.'
-                }));
-            }
-        });
-        this.rtc.rtcClient.addEventListener('connectionstatechange', this.connectionStateChangeHandler);
-        // Disconnect if data channels close unexpectedly, e.g. can happen due to message size > ~255kB (RTCPeerConnection.sctp.maxMessageSizeLimit: 262144)
-        Object.values(this.rtc.channels).forEach((datachannel) => {
-            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);
-                }
-            };
-        });
-    }
-    onDisconnect(listener) {
-        if (!__classPrivateFieldGet(this, _disconnectListener)) {
-            __classPrivateFieldSet(this, _disconnectListener, listener);
-        }
-        else {
-            throw new Error('RTCEndpoint disconnectListener cannot be set twice.');
-        }
-    }
-    receive(listener) {
-        if (__classPrivateFieldGet(this, _processAction)) {
-            throw new Error('You have already set a listener for this RTC Endpoint.');
-        }
-        __classPrivateFieldSet(this, _processAction, listener);
-    }
-    get connected() {
-        return this.rtc.rtcClient.connectionState === 'connected';
-    }
-}
-exports.RTCEndpoint = RTCEndpoint;
-_processAction = new WeakMap(), _disconnectListener = new WeakMap();
+"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 __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, privateMap, value) {
+    if (!privateMap.has(receiver)) {
+        throw new TypeError("attempted to set private field on non-instance");
+    }
+    privateMap.set(receiver, value);
+    return value;
+};
+var _processAction, _disconnectListener;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RTCEndpoint = void 0;
+const errors_1 = require("../../../../../util/errors");
+/*
+This handles sending RTC messages between RTC connections over the request and response data channels.
+*/
+class RTCEndpoint {
+    constructor(rtc, endpointIdentity) {
+        this.rtc = rtc;
+        this.endpointIdentity = endpointIdentity;
+        this.responseMap = new Map();
+        _processAction.set(this, null);
+        _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);
+                }
+            }
+        };
+        this.send = async (action, payload) => {
+            const messageId = `message-${Math.random()}`;
+            const promise = new Promise((resolve, reject) => {
+                this.responseMap.set(messageId, { resolve, reject });
+            });
+            this.rtc.channels.request.send(JSON.stringify({ action, payload, messageId }));
+            return promise;
+        };
+        this.close = () => {
+            this.responseMap.forEach((response) => response.reject('Connection has closed.'));
+            this.responseMap = new Map();
+            this.rtc.channels.request.close();
+            this.rtc.channels.response.close();
+            this.rtc.rtcClient.close();
+        };
+        this.rtc.channels.response.addEventListener('message', (e) => {
+            var _a;
+            const { messageId, payload, success, error } = JSON.parse(e.data);
+            const { resolve, reject } = (_a = this.responseMap.get(messageId)) !== null && _a !== void 0 ? _a : {};
+            if (resolve && reject) {
+                this.responseMap.delete(messageId);
+                if (success) {
+                    resolve(payload);
+                }
+                else {
+                    reject(error);
+                }
+            }
+            else {
+                console.log('Could not find id in responseMap.');
+                console.log(e);
+            }
+        });
+        this.rtc.channels.request.addEventListener('message', async (e) => {
+            const { messageId, action, payload } = JSON.parse(e.data);
+            if (__classPrivateFieldGet(this, _processAction)) {
+                try {
+                    const res = await __classPrivateFieldGet(this, _processAction).call(this, action, payload, endpointIdentity);
+                    this.rtc.channels.response.send(JSON.stringify({
+                        messageId,
+                        payload: res,
+                        success: true
+                    }));
+                }
+                catch (error) {
+                    // Check if RTCDataChannel is open before sending, error gets swallowed here in the case where
+                    // client dispatched then closed or disconnected before the dispatch resolves.
+                    if (this.rtc.channels.response.readyState === 'open') {
+                        this.rtc.channels.response.send(JSON.stringify({
+                            messageId,
+                            error: errors_1.errorToPOJO(error),
+                            success: false
+                        }));
+                    }
+                }
+                // Check if RTCDataChannel is open for same reason as catch block above.
+            }
+            else if (this.rtc.channels.response.readyState === 'open') {
+                this.rtc.channels.response.send(JSON.stringify({
+                    messageId,
+                    success: false,
+                    error: 'Connection not ready.'
+                }));
+            }
+        });
+        this.rtc.rtcClient.addEventListener('connectionstatechange', this.connectionStateChangeHandler);
+        // Disconnect if data channels close unexpectedly, e.g. can happen due to message size > ~255kB (RTCPeerConnection.sctp.maxMessageSizeLimit: 262144)
+        Object.values(this.rtc.channels).forEach((datachannel) => {
+            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);
+                }
+            };
+        });
+    }
+    onDisconnect(listener) {
+        if (!__classPrivateFieldGet(this, _disconnectListener)) {
+            __classPrivateFieldSet(this, _disconnectListener, listener);
+        }
+        else {
+            throw new Error('RTCEndpoint disconnectListener cannot be set twice.');
+        }
+    }
+    receive(listener) {
+        if (__classPrivateFieldGet(this, _processAction)) {
+            throw new Error('You have already set a listener for this RTC Endpoint.');
+        }
+        __classPrivateFieldSet(this, _processAction, listener);
+    }
+    get connected() {
+        return this.rtc.rtcClient.connectionState === 'connected';
+    }
+}
+exports.RTCEndpoint = RTCEndpoint;
+_processAction = new WeakMap(), _disconnectListener = new WeakMap();

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

@@ -1,30 +1,30 @@
-import Transport from '../../../../../transport/transport';
-import { EmitterBase } from '../../../../base';
-import { RTCEndpointChannels } from './endpoint';
-export declare class RTCICEManager extends EmitterBase<any> {
-    constructor(wire: Transport);
-    static createDataChannelPromise(label: string, rtcClient: RTCPeerConnection): Promise<RTCDataChannel>;
-    ensureChannelOpened: (channel: RTCDataChannel) => Promise<void>;
-    listenForProviderIce(rtcConnectionId: string, listener: any): Promise<void>;
-    raiseProviderIce(rtcConnectionId: string, payload: any): Promise<void>;
-    listenForClientIce(rtcConnectionId: string, listener: any): Promise<void>;
-    raiseClientIce(rtcConnectionId: string, payload: any): Promise<void>;
-    private cleanupIceListeners;
-    private createClientEventName;
-    private createProviderEventName;
-    private createRouteString;
-    private createRtcPeer;
-    startClientOffer(): Promise<{
-        rtcClient: RTCPeerConnection;
-        offer: RTCSessionDescriptionInit;
-        channels: RTCEndpointChannels;
-        rtcConnectionId: string;
-        channelsOpened: Promise<void>;
-    }>;
-    finishClientOffer(rtcClient: RTCPeerConnection, answer: RTCSessionDescriptionInit, providerReady: Promise<void>): Promise<boolean>;
-    createProviderAnswer(rtcConnectionId: string, offer: RTCSessionDescriptionInit): Promise<{
-        rtcClient: RTCPeerConnection;
-        answer: RTCSessionDescriptionInit;
-        channels: Promise<RTCEndpointChannels>;
-    }>;
-}
+import Transport from '../../../../../transport/transport';
+import { EmitterBase } from '../../../../base';
+import { RTCEndpointChannels } from './endpoint';
+export declare class RTCICEManager extends EmitterBase<any> {
+    constructor(wire: Transport);
+    static createDataChannelPromise(label: string, rtcClient: RTCPeerConnection): Promise<RTCDataChannel>;
+    ensureChannelOpened: (channel: RTCDataChannel) => Promise<void>;
+    listenForProviderIce(rtcConnectionId: string, listener: any): Promise<void>;
+    raiseProviderIce(rtcConnectionId: string, payload: any): Promise<void>;
+    listenForClientIce(rtcConnectionId: string, listener: any): Promise<void>;
+    raiseClientIce(rtcConnectionId: string, payload: any): Promise<void>;
+    private cleanupIceListeners;
+    private createClientEventName;
+    private createProviderEventName;
+    private createRouteString;
+    private createRtcPeer;
+    startClientOffer(): Promise<{
+        rtcClient: RTCPeerConnection;
+        offer: RTCSessionDescriptionInit;
+        channels: RTCEndpointChannels;
+        rtcConnectionId: string;
+        channelsOpened: Promise<void>;
+    }>;
+    finishClientOffer(rtcClient: RTCPeerConnection, answer: RTCSessionDescriptionInit, providerReady: Promise<void>): Promise<boolean>;
+    createProviderAnswer(rtcConnectionId: string, offer: RTCSessionDescriptionInit): Promise<{
+        rtcClient: RTCPeerConnection;
+        answer: RTCSessionDescriptionInit;
+        channels: Promise<RTCEndpointChannels>;
+    }>;
+}

package/src/api/interappbus/channel/protocols/rtc/ice-manager.js

@@ -1,131 +1,131 @@
-"use strict";
-/* eslint-disable class-methods-use-this */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.RTCICEManager = void 0;
-const base_1 = require("../../../../base");
-/*
-Singleton that facilitates Offer and Answer exchange required for establishing RTC connections.
-*/
-class RTCICEManager extends base_1.EmitterBase {
-    constructor(wire) {
-        super(wire, 'channel');
-        this.ensureChannelOpened = (channel) => {
-            return new Promise((resolve, reject) => {
-                if (channel.readyState === 'open') {
-                    resolve();
-                }
-                else if (channel.readyState === 'connecting') {
-                    const listener = () => {
-                        channel.removeEventListener('open', listener);
-                        resolve();
-                    };
-                    channel.addEventListener('open', listener);
-                }
-                else {
-                    reject(new Error('This Channel has already closed'));
-                }
-            });
-        };
-    }
-    static createDataChannelPromise(label, rtcClient) {
-        let resolver;
-        const promise = new Promise((resolve) => {
-            resolver = resolve;
-        });
-        const listener = (e) => {
-            const openListener = () => {
-                e.channel.removeEventListener('open', openListener);
-                resolver(e.channel);
-            };
-            if (e.channel.label === label) {
-                e.channel.addEventListener('open', openListener);
-                rtcClient.removeEventListener('datachannel', listener);
-            }
-        };
-        rtcClient.addEventListener('datachannel', listener);
-        return promise;
-    }
-    async listenForProviderIce(rtcConnectionId, listener) {
-        await this.on(this.createProviderEventName(rtcConnectionId), listener, { timestamp: Date.now() });
-    }
-    async raiseProviderIce(rtcConnectionId, payload) {
-        await this.wire.environment.raiseEvent(this.createRouteString(this.createProviderEventName(rtcConnectionId)), payload);
-    }
-    async listenForClientIce(rtcConnectionId, listener) {
-        await this.on(this.createClientEventName(rtcConnectionId), listener, { timestamp: Date.now() });
-    }
-    async raiseClientIce(rtcConnectionId, payload) {
-        await this.wire.environment.raiseEvent(this.createRouteString(this.createClientEventName(rtcConnectionId)), payload);
-    }
-    cleanupIceListeners(rtcConnectionId) {
-        this.removeAllListeners(this.createClientEventName(rtcConnectionId));
-        this.removeAllListeners(this.createProviderEventName(rtcConnectionId));
-    }
-    createClientEventName(rtcConnectionId) {
-        return `ice-client-${rtcConnectionId}`;
-    }
-    createProviderEventName(rtcConnectionId) {
-        return `ice-provider-${rtcConnectionId}`;
-    }
-    createRouteString(name) {
-        return `channel/${name}`;
-    }
-    createRtcPeer() {
-        return this.wire.environment.getRtcPeer();
-    }
-    async startClientOffer() {
-        // TODO replace with real guid.
-        const rtcConnectionId = Math.random().toString();
-        const rtcClient = this.createRtcPeer();
-        rtcClient.addEventListener('icecandidate', async (e) => {
-            var _a;
-            if (e.candidate) {
-                await this.raiseClientIce(rtcConnectionId, { candidate: (_a = e.candidate) === null || _a === void 0 ? void 0 : _a.toJSON() });
-            }
-        });
-        await this.listenForProviderIce(rtcConnectionId, async (payload) => {
-            await rtcClient.addIceCandidate(payload.candidate);
-        });
-        const channels = {
-            request: rtcClient.createDataChannel('request'),
-            response: rtcClient.createDataChannel('response')
-        };
-        const offer = await rtcClient.createOffer();
-        await rtcClient.setLocalDescription(offer);
-        const channelsOpened = Promise.all([channels.request, channels.response].map(this.ensureChannelOpened)).then(() => undefined);
-        return { rtcClient, channels, offer, rtcConnectionId, channelsOpened };
-    }
-    async finishClientOffer(rtcClient, answer, providerReady) {
-        await rtcClient.setRemoteDescription(answer);
-        await providerReady;
-        return true;
-    }
-    async createProviderAnswer(rtcConnectionId, offer) {
-        const rtcClient = this.createRtcPeer();
-        const requestChannelPromise = RTCICEManager.createDataChannelPromise('request', rtcClient);
-        const responseChannelPromise = RTCICEManager.createDataChannelPromise('response', rtcClient);
-        rtcClient.addEventListener('icecandidate', async (e) => {
-            var _a;
-            if (e.candidate) {
-                await this.raiseProviderIce(rtcConnectionId, { candidate: (_a = e.candidate) === null || _a === void 0 ? void 0 : _a.toJSON() });
-            }
-        });
-        await this.listenForClientIce(rtcConnectionId, async (payload) => {
-            await rtcClient.addIceCandidate(payload.candidate);
-        });
-        await rtcClient.setRemoteDescription(offer);
-        const answer = await rtcClient.createAnswer();
-        await rtcClient.setLocalDescription(answer);
-        const channels = Promise.all([requestChannelPromise, responseChannelPromise]).then(([request, response]) => {
-            // Clean up ice events.
-            this.cleanupIceListeners(rtcConnectionId);
-            return { request, response };
-        });
-        return {
-            rtcClient,
-            answer,
-            channels
-        };
-    }
-}
-exports.RTCICEManager = RTCICEManager;
+"use strict";
+/* eslint-disable class-methods-use-this */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RTCICEManager = void 0;
+const base_1 = require("../../../../base");
+/*
+Singleton that facilitates Offer and Answer exchange required for establishing RTC connections.
+*/
+class RTCICEManager extends base_1.EmitterBase {
+    constructor(wire) {
+        super(wire, 'channel');
+        this.ensureChannelOpened = (channel) => {
+            return new Promise((resolve, reject) => {
+                if (channel.readyState === 'open') {
+                    resolve();
+                }
+                else if (channel.readyState === 'connecting') {
+                    const listener = () => {
+                        channel.removeEventListener('open', listener);
+                        resolve();
+                    };
+                    channel.addEventListener('open', listener);
+                }
+                else {
+                    reject(new Error('This Channel has already closed'));
+                }
+            });
+        };
+    }
+    static createDataChannelPromise(label, rtcClient) {
+        let resolver;
+        const promise = new Promise((resolve) => {
+            resolver = resolve;
+        });
+        const listener = (e) => {
+            const openListener = () => {
+                e.channel.removeEventListener('open', openListener);
+                resolver(e.channel);
+            };
+            if (e.channel.label === label) {
+                e.channel.addEventListener('open', openListener);
+                rtcClient.removeEventListener('datachannel', listener);
+            }
+        };
+        rtcClient.addEventListener('datachannel', listener);
+        return promise;
+    }
+    async listenForProviderIce(rtcConnectionId, listener) {
+        await this.on(this.createProviderEventName(rtcConnectionId), listener, { timestamp: Date.now() });
+    }
+    async raiseProviderIce(rtcConnectionId, payload) {
+        await this.wire.environment.raiseEvent(this.createRouteString(this.createProviderEventName(rtcConnectionId)), payload);
+    }
+    async listenForClientIce(rtcConnectionId, listener) {
+        await this.on(this.createClientEventName(rtcConnectionId), listener, { timestamp: Date.now() });
+    }
+    async raiseClientIce(rtcConnectionId, payload) {
+        await this.wire.environment.raiseEvent(this.createRouteString(this.createClientEventName(rtcConnectionId)), payload);
+    }
+    cleanupIceListeners(rtcConnectionId) {
+        this.removeAllListeners(this.createClientEventName(rtcConnectionId));
+        this.removeAllListeners(this.createProviderEventName(rtcConnectionId));
+    }
+    createClientEventName(rtcConnectionId) {
+        return `ice-client-${rtcConnectionId}`;
+    }
+    createProviderEventName(rtcConnectionId) {
+        return `ice-provider-${rtcConnectionId}`;
+    }
+    createRouteString(name) {
+        return `channel/${name}`;
+    }
+    createRtcPeer() {
+        return this.wire.environment.getRtcPeer();
+    }
+    async startClientOffer() {
+        // TODO replace with real guid.
+        const rtcConnectionId = Math.random().toString();
+        const rtcClient = this.createRtcPeer();
+        rtcClient.addEventListener('icecandidate', async (e) => {
+            var _a;
+            if (e.candidate) {
+                await this.raiseClientIce(rtcConnectionId, { candidate: (_a = e.candidate) === null || _a === void 0 ? void 0 : _a.toJSON() });
+            }
+        });
+        await this.listenForProviderIce(rtcConnectionId, async (payload) => {
+            await rtcClient.addIceCandidate(payload.candidate);
+        });
+        const channels = {
+            request: rtcClient.createDataChannel('request'),
+            response: rtcClient.createDataChannel('response')
+        };
+        const offer = await rtcClient.createOffer();
+        await rtcClient.setLocalDescription(offer);
+        const channelsOpened = Promise.all([channels.request, channels.response].map(this.ensureChannelOpened)).then(() => undefined);
+        return { rtcClient, channels, offer, rtcConnectionId, channelsOpened };
+    }
+    async finishClientOffer(rtcClient, answer, providerReady) {
+        await rtcClient.setRemoteDescription(answer);
+        await providerReady;
+        return true;
+    }
+    async createProviderAnswer(rtcConnectionId, offer) {
+        const rtcClient = this.createRtcPeer();
+        const requestChannelPromise = RTCICEManager.createDataChannelPromise('request', rtcClient);
+        const responseChannelPromise = RTCICEManager.createDataChannelPromise('response', rtcClient);
+        rtcClient.addEventListener('icecandidate', async (e) => {
+            var _a;
+            if (e.candidate) {
+                await this.raiseProviderIce(rtcConnectionId, { candidate: (_a = e.candidate) === null || _a === void 0 ? void 0 : _a.toJSON() });
+            }
+        });
+        await this.listenForClientIce(rtcConnectionId, async (payload) => {
+            await rtcClient.addIceCandidate(payload.candidate);
+        });
+        await rtcClient.setRemoteDescription(offer);
+        const answer = await rtcClient.createAnswer();
+        await rtcClient.setLocalDescription(answer);
+        const channels = Promise.all([requestChannelPromise, responseChannelPromise]).then(([request, response]) => {
+            // Clean up ice events.
+            this.cleanupIceListeners(rtcConnectionId);
+            return { request, response };
+        });
+        return {
+            rtcClient,
+            answer,
+            channels
+        };
+    }
+}
+exports.RTCICEManager = RTCICEManager;

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

@@ -1,22 +1,22 @@
-import { ChannelStrategy } from '../strategy';
-import { RTCPacket } from './endpoint';
-import { LocalSupportedProtocol } from '..';
-import ProviderIdentity = OpenFin.ProviderIdentity;
-export interface RTCStrategyEndpointPayload {
-    endpointIdentity: OpenFin.ClientIdentity | ProviderIdentity;
-    rtc: RTCPacket;
-}
-export declare class RTCStrategy implements ChannelStrategy<RTCStrategyEndpointPayload> {
-    #private;
-    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>;
-    close: () => Promise<void>;
-    private getEndpointById;
-    get connected(): boolean;
-    isEndpointConnected(endpointId: string): boolean;
-    addEndpoint(endpointId: string, payload: RTCStrategyEndpointPayload): void;
-    closeEndpoint(endpointId: string): Promise<void>;
-    isValidEndpointPayload(payload: any): payload is RTCStrategyEndpointPayload;
-}
-export declare const RTCInfo: LocalSupportedProtocol;
+import { ChannelStrategy } from '../strategy';
+import { RTCPacket } from './endpoint';
+import { LocalSupportedProtocol } from '..';
+import ProviderIdentity = OpenFin.ProviderIdentity;
+export interface RTCStrategyEndpointPayload {
+    endpointIdentity: OpenFin.ClientIdentity | ProviderIdentity;
+    rtc: RTCPacket;
+}
+export declare class RTCStrategy implements ChannelStrategy<RTCStrategyEndpointPayload> {
+    #private;
+    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>;
+    close: () => Promise<void>;
+    private getEndpointById;
+    get connected(): boolean;
+    isEndpointConnected(endpointId: string): boolean;
+    addEndpoint(endpointId: string, payload: RTCStrategyEndpointPayload): void;
+    closeEndpoint(endpointId: string): Promise<void>;
+    isValidEndpointPayload(payload: any): payload is RTCStrategyEndpointPayload;
+}
+export declare const RTCInfo: LocalSupportedProtocol;