@openfin/core 25.68.26

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

@@ -0,0 +1,84 @@
+"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 __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 _wire, _endpointIdentityMap;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ClassicInfo = exports.ClassicStrategy = void 0;
+/*
+This is used to abstract out ipc messaging from the channels implementation. It is only concerned with sending messages and registration with the MessageReceiver
+*/
+class ClassicStrategy {
+    constructor(wire, messageReceiver, endpointId, // Provider endpointId is channelId
+    providerIdentity) {
+        this.messageReceiver = messageReceiver;
+        this.endpointId = endpointId;
+        this.providerIdentity = providerIdentity;
+        _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());
+        this.send = async (endpointId, action, payload) => {
+            const to = __classPrivateFieldGet(this, _endpointIdentityMap).get(endpointId);
+            if (!to) {
+                throw new Error(`Could not locate routing info for endpoint ${endpointId}`);
+            }
+            // as casting to any because typescript complains. The following is only relevant if this is a locally set endpointId on a ClientIdentity.
+            // We delete these properties to not change backwards compatibility.
+            const cleanId = { ...to };
+            if (cleanId.isLocalEndpointId) {
+                delete cleanId.endpointId;
+            }
+            delete cleanId.isLocalEndpointId;
+            const raw = await __classPrivateFieldGet(this, _wire).sendAction('send-channel-message', {
+                ...cleanId,
+                providerIdentity: this.providerIdentity,
+                action,
+                payload
+            })
+                .catch((reason) => {
+                throw new Error(reason.message);
+            });
+            return raw.payload.data.result;
+        };
+        this.close = async () => {
+            this.messageReceiver.removeEndpoint(this.providerIdentity.channelId, this.endpointId);
+            __classPrivateFieldSet(this, _endpointIdentityMap, new Map());
+        };
+        __classPrivateFieldSet(this, _wire, wire);
+    }
+    onEndpointDisconnect(endpointId, listener) {
+        // Never fires for 'classic'.
+    }
+    receive(listener) {
+        this.messageReceiver.addEndpoint(listener, this.providerIdentity.channelId, this.endpointId);
+    }
+    async closeEndpoint(endpointId) {
+        __classPrivateFieldGet(this, _endpointIdentityMap).delete(endpointId);
+    }
+    isEndpointConnected(endpointId) {
+        return __classPrivateFieldGet(this, _endpointIdentityMap).has(endpointId);
+    }
+    addEndpoint(endpointId, payload) {
+        __classPrivateFieldGet(this, _endpointIdentityMap).set(endpointId, payload.endpointIdentity);
+    }
+    isValidEndpointPayload(payload) {
+        var _a, _b;
+        return (typeof ((_a = payload === null || payload === void 0 ? void 0 : payload.endpointIdentity) === null || _a === void 0 ? void 0 : _a.endpointId) === 'string' ||
+            typeof ((_b = payload === null || payload === void 0 ? void 0 : payload.endpointIdentity) === null || _b === void 0 ? void 0 : _b.channelId) === 'string');
+    }
+}
+exports.ClassicStrategy = ClassicStrategy;
+_wire = new WeakMap(), _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/combined/strategy.d.ts

@@ -0,0 +1,20 @@
+import { ChannelStrategy } from '../strategy';
+declare type OverlapsOnlyIfMatching<T, U> = {
+    [K in Extract<keyof T, keyof U>]: U[K] extends T[K] ? U[K] : T[K] extends U[K] ? T[K] : never;
+};
+declare type OnlyIfCompatible<A, B, D = OverlapsOnlyIfMatching<A, B>> = D extends Record<any, never> ? keyof D extends never ? A | B : never : A | B;
+export default class CombinedStrategy<A, B> implements ChannelStrategy<OnlyIfCompatible<A, B>> {
+    private primary;
+    private secondary;
+    static combine<A, B>(a: ChannelStrategy<A>, b: ChannelStrategy<B>): OnlyIfCompatible<A, B> extends never ? never : CombinedStrategy<A, B>;
+    private constructor();
+    onEndpointDisconnect(endpointId: string, listener: () => void): void;
+    isValidEndpointPayload(payload: unknown): payload is OnlyIfCompatible<A, B>;
+    closeEndpoint(endpointId: string): Promise<void>;
+    isEndpointConnected(endpoint: string): boolean;
+    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>;
+    close(): Promise<void>;
+}
+export {};

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

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class CombinedStrategy {
+    // eslint-disable-next-line no-useless-constructor
+    constructor(primary, secondary) {
+        this.primary = primary;
+        this.secondary = secondary;
+    }
+    // Making this a static method because the constructor can't be typed.
+    // Otherwise it will error when calling addEndpoint but I'd rather the whole instance be typed as never.
+    static combine(a, b) {
+        return new CombinedStrategy(a, b);
+    }
+    onEndpointDisconnect(endpointId, listener) {
+        this.primary.onEndpointDisconnect(endpointId, () => {
+            if (!this.secondary.isEndpointConnected(endpointId)) {
+                listener();
+            }
+        });
+        this.secondary.onEndpointDisconnect(endpointId, () => {
+            if (!this.primary.isEndpointConnected(endpointId)) {
+                listener();
+            }
+        });
+    }
+    isValidEndpointPayload(payload) {
+        return this.primary.isValidEndpointPayload(payload) || this.secondary.isValidEndpointPayload(payload);
+    }
+    async closeEndpoint(endpointId) {
+        await this.primary.closeEndpoint(endpointId);
+        await this.secondary.closeEndpoint(endpointId);
+    }
+    isEndpointConnected(endpoint) {
+        return this.primary.isEndpointConnected(endpoint) || this.secondary.isEndpointConnected(endpoint);
+    }
+    async addEndpoint(endpoint, payload) {
+        if (this.primary.isValidEndpointPayload(payload)) {
+            await this.primary.addEndpoint(endpoint, payload);
+        }
+        if (this.secondary.isValidEndpointPayload(payload)) {
+            await this.secondary.addEndpoint(endpoint, payload);
+        }
+    }
+    receive(listener) {
+        this.primary.receive(listener);
+        this.secondary.receive(listener);
+    }
+    send(endpointId, action, payload) {
+        if (this.primary.isEndpointConnected(endpointId)) {
+            return this.primary.send(endpointId, action, payload);
+        }
+        return this.secondary.send(endpointId, action, payload);
+    }
+    async close() {
+        await Promise.all([this.primary.close(), this.secondary.close()]);
+    }
+}
+exports.default = CombinedStrategy;

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

@@ -0,0 +1,44 @@
+export interface ProtocolPacketBase {
+    version: number;
+    minimumVersion?: number;
+    type: string;
+    payload?: any;
+}
+export interface ClassicProtocolOffer extends ProtocolPacketBase {
+    type: 'classic';
+}
+export interface RTCProtocolOffer extends ProtocolPacketBase {
+    type: 'rtc';
+    payload: {
+        offer: RTCSessionDescriptionInit;
+        rtcConnectionId: string;
+    };
+}
+export declare type ProtocolOffer = ClassicProtocolOffer | RTCProtocolOffer;
+export declare type MessagingProtocols = ProtocolOffer['type'];
+export declare type LocalSupportedProtocol = {
+    type: MessagingProtocols;
+    minimumVersion: number;
+    version: number;
+};
+export interface ExternalClientOffer {
+    maxProtocols: number;
+    supportedProtocols: ProtocolPacketBase[];
+}
+export interface ClientOffer {
+    supportedProtocols: ProtocolOffer[];
+    maxProtocols: number;
+}
+export interface ClassicProtocolAnswer extends ProtocolPacketBase {
+    type: 'classic';
+}
+export interface RTCProtocolAnswer extends ProtocolPacketBase {
+    type: 'rtc';
+    payload: {
+        answer: RTCSessionDescriptionInit;
+    };
+}
+export declare type ProtocolAnswer = ClassicProtocolAnswer | RTCProtocolAnswer;
+export interface ClientAnswer {
+    supportedProtocols: ProtocolAnswer[];
+}

package/src/api/interappbus/channel/protocols/index.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -0,0 +1,10 @@
+import { MessagingProtocols, ExternalClientOffer, ProtocolOffer, LocalSupportedProtocol } from '.';
+export declare class ProtocolManager {
+    private ProtocolsInPreferenceOrder;
+    DefaultClientProtocols: ['classic'];
+    DefaultProviderProtocols: ['classic'];
+    constructor(ProtocolsInPreferenceOrder: MessagingProtocols[]);
+    getClientProtocols: (protocols?: string[]) => MessagingProtocols[];
+    getProviderProtocols: (protocols?: string[]) => ['rtc'] | ['rtc', 'classic'] | ['classic'];
+    getCompatibleProtocols: (providerProtocols: LocalSupportedProtocol[], clientOffer: ExternalClientOffer) => ProtocolOffer[];
+}

package/src/api/interappbus/channel/protocols/protocol-manager.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProtocolManager = void 0;
+/*
+This should be agnostic of any actual openfin code to be unit testable.
+Dependencies on the actual srategies should be handled in ConnectionManager
+*/
+class ProtocolManager {
+    // eslint-disable-next-line no-useless-constructor
+    constructor(ProtocolsInPreferenceOrder) {
+        this.ProtocolsInPreferenceOrder = ProtocolsInPreferenceOrder;
+        this.DefaultClientProtocols = ['classic'];
+        this.DefaultProviderProtocols = ['classic'];
+        this.getClientProtocols = (protocols) => {
+            const supported = protocols
+                ? this.ProtocolsInPreferenceOrder.filter((x) => protocols.includes(x))
+                : this.DefaultClientProtocols;
+            if (!supported.length) {
+                throw new Error(`No valid protocols were passed in. Accepted values are: ${this.ProtocolsInPreferenceOrder.join(', ')}.`);
+            }
+            return supported;
+        };
+        this.getProviderProtocols = (protocols) => {
+            const supported = protocols
+                ? this.ProtocolsInPreferenceOrder.filter((x) => protocols.includes(x))
+                : this.DefaultProviderProtocols;
+            if (!supported.length) {
+                throw new Error(`No valid protocols were passed in. Accepted values are: ${this.ProtocolsInPreferenceOrder.join(', ')}.`);
+            }
+            return supported;
+        };
+        this.getCompatibleProtocols = (providerProtocols, clientOffer) => {
+            const supported = clientOffer.supportedProtocols.filter((clientProtocol) => providerProtocols.some((providerProtocol) => {
+                var _a;
+                return providerProtocol.type === clientProtocol.type &&
+                    clientProtocol.version >= providerProtocol.minimumVersion &&
+                    providerProtocol.version >= ((_a = clientProtocol.minimumVersion) !== null && _a !== void 0 ? _a : 0);
+            }));
+            return supported.slice(0, clientOffer.maxProtocols);
+        };
+    }
+}
+exports.ProtocolManager = ProtocolManager;

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

@@ -0,0 +1,23 @@
+import ProviderIdentity = OpenFin.ProviderIdentity;
+export interface RTCEndpointChannels {
+    request: RTCDataChannel;
+    response: RTCDataChannel;
+}
+export interface RTCPacket {
+    rtcClient: RTCPeerConnection;
+    channels: RTCEndpointChannels;
+    channelsOpened: Promise<void>;
+}
+export declare class RTCEndpoint {
+    #private;
+    private rtc;
+    private endpointIdentity;
+    private responseMap;
+    constructor(rtc: RTCPacket, endpointIdentity: OpenFin.ClientIdentity | ProviderIdentity);
+    private connectionStateChangeHandler;
+    onDisconnect(listener: () => void): void;
+    receive(listener: (action: string, payload: any, identity: OpenFin.ClientIdentity | ProviderIdentity) => Promise<any>): void;
+    send: (action: string, payload: any) => Promise<any>;
+    close: () => void;
+    get connected(): boolean;
+}

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

@@ -0,0 +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();

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

@@ -0,0 +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>;
+    }>;
+}

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

@@ -0,0 +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;

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

@@ -0,0 +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;