@openfin/core 25.68.30 → 25.70.2

package/src/api/interappbus/channel/connection-manager.js

@@ -1,244 +1,244 @@
-"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 _messageReceiver, _rtcConnectionManager;
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ConnectionManager = void 0;
-const exhaustive_1 = require("../../../util/exhaustive");
-const base_1 = require("../../base");
-const strategy_1 = require("./protocols/classic/strategy");
-const strategy_2 = require("./protocols/rtc/strategy");
-const ice_manager_1 = require("./protocols/rtc/ice-manager");
-const provider_1 = require("./provider");
-const message_receiver_1 = require("./protocols/classic/message-receiver");
-const protocol_manager_1 = require("./protocols/protocol-manager");
-const strategy_3 = require("./protocols/combined/strategy");
-class ConnectionManager extends base_1.Base {
-    constructor(wire) {
-        super(wire);
-        _messageReceiver.set(this, void 0);
-        _rtcConnectionManager.set(this, void 0);
-        this.removeChannelFromProviderMap = (channelId) => {
-            this.providerMap.delete(channelId);
-        };
-        this.onmessage = (msg) => {
-            if (msg.action === 'process-channel-connection') {
-                this.processChannelConnection(msg);
-                return true;
-            }
-            return false;
-        };
-        this.providerMap = new Map();
-        this.protocolManager = new protocol_manager_1.ProtocolManager(this.isNodeEnvironment() ? ['classic'] : ['rtc', 'classic']);
-        __classPrivateFieldSet(this, _messageReceiver, new message_receiver_1.MessageReceiver(wire));
-        __classPrivateFieldSet(this, _rtcConnectionManager, new ice_manager_1.RTCICEManager(wire));
-        wire.registerMessageHandler(this.onmessage.bind(this));
-    }
-    static getProtocolOptionsFromStrings(protocols) {
-        return protocols.map(protocol => {
-            switch (protocol) {
-                case 'rtc':
-                    return strategy_2.RTCInfo;
-                case 'classic':
-                    return strategy_1.ClassicInfo;
-                default:
-                    return exhaustive_1.exhaustiveCheck(protocol, ['rtc', 'classic']);
-            }
-        });
-    }
-    createProvider(options, providerIdentity) {
-        const opts = Object.assign(this.wire.environment.getDefaultChannelOptions().create, options || {});
-        const protocols = this.protocolManager.getProviderProtocols(opts === null || opts === void 0 ? void 0 : opts.protocols);
-        const createSingleStrategy = (stratType) => {
-            switch (stratType) {
-                case 'rtc':
-                    return new strategy_2.RTCStrategy();
-                case 'classic':
-                    return new strategy_1.ClassicStrategy(this.wire, __classPrivateFieldGet(this, _messageReceiver), 
-                    // Providers do not have an endpointId, use channelId as endpointId in the strategy.
-                    providerIdentity.channelId, providerIdentity);
-                default:
-                    return exhaustive_1.exhaustiveCheck(stratType, ['rtc', 'classic']);
-            }
-        };
-        const strategies = protocols.map(createSingleStrategy);
-        let strategy;
-        if (strategies.length === 2) {
-            const [a, b] = strategies;
-            strategy = strategy_3.default.combine(a, b);
-        }
-        else if (strategies.length === 1) {
-            [strategy] = strategies;
-        }
-        else {
-            // Should be impossible.
-            throw new Error('failed to combine strategies');
-        }
-        const channel = new provider_1.ChannelProvider(providerIdentity, this.wire, strategy);
-        const key = providerIdentity.channelId;
-        this.providerMap.set(key, { provider: channel, strategy, supportedProtocols: ConnectionManager.getProtocolOptionsFromStrings(protocols) });
-        provider_1.ChannelProvider.setProviderRemoval(channel, this.removeChannelFromProviderMap.bind(this));
-        return channel;
-    }
-    async createClientOffer(options) {
-        const protocols = this.protocolManager.getClientProtocols(options === null || options === void 0 ? void 0 : options.protocols);
-        let rtcPacket;
-        const supportedProtocols = await Promise.all(protocols.map(async (type) => {
-            switch (type) {
-                case 'rtc': {
-                    const { rtcClient, channels, offer, rtcConnectionId, channelsOpened } = await __classPrivateFieldGet(this, _rtcConnectionManager).startClientOffer();
-                    rtcPacket = { rtcClient, channels, channelsOpened };
-                    return {
-                        type: 'rtc',
-                        version: strategy_2.RTCInfo.version,
-                        payload: { offer, rtcConnectionId }
-                    };
-                }
-                case 'classic':
-                    return { type: 'classic', version: strategy_1.ClassicInfo.version };
-                default:
-                    return exhaustive_1.exhaustiveCheck(type, ['rtc', 'classic']);
-            }
-        }));
-        return {
-            offer: {
-                supportedProtocols,
-                maxProtocols: 2
-            },
-            rtc: rtcPacket
-        };
-    }
-    async createClientStrategy(rtcPacket, routingInfo) {
-        var _a;
-        if (!routingInfo.endpointId) {
-            routingInfo.endpointId = this.wire.environment.getNextMessageId();
-            // For New Clients connecting to Old Providers. To prevent multi-dispatching and publishing, we delete previously-connected
-            // clients that are in the same context as the newly-connected client.
-            __classPrivateFieldGet(this, _messageReceiver).checkForPreviousClientConnection(routingInfo.channelId);
-        }
-        const answer = (_a = routingInfo.answer) !== null && _a !== void 0 ? _a : {
-            supportedProtocols: [{ type: 'classic', version: 1 }]
-        };
-        const createStrategyFromAnswer = async (protocol) => {
-            if (protocol.type === 'rtc' && rtcPacket) {
-                await __classPrivateFieldGet(this, _rtcConnectionManager).finishClientOffer(rtcPacket.rtcClient, protocol.payload.answer, rtcPacket.channelsOpened);
-                return new strategy_2.RTCStrategy();
-            }
-            if (protocol.type === 'classic') {
-                return new strategy_1.ClassicStrategy(this.wire, __classPrivateFieldGet(this, _messageReceiver), routingInfo.endpointId, routingInfo);
-            }
-            return null;
-        };
-        const allProtocols = (await Promise.all(answer.supportedProtocols.map(createStrategyFromAnswer))).filter((x) => x !== null);
-        // Clean up logic if provider didn't support rtc.
-        if (rtcPacket && !allProtocols.some((x) => x instanceof strategy_2.RTCStrategy)) {
-            if (rtcPacket) {
-                rtcPacket.rtcClient.close();
-            }
-        }
-        let strategy;
-        if (allProtocols.length >= 2) {
-            strategy = strategy_3.default.combine(allProtocols[0], allProtocols[1]);
-        }
-        else if (allProtocols.length) {
-            [strategy] = allProtocols;
-        }
-        else {
-            // Should be impossible.
-            throw new Error('No compatible protocols');
-        }
-        // as casting rtcPacket because we won't have an rtcStrategy if rtcPacket is undefined;
-        const endpointPayload = { endpointIdentity: routingInfo, rtc: rtcPacket };
-        strategy.addEndpoint(routingInfo.channelId, endpointPayload);
-        return strategy;
-    }
-    async processChannelConnection(msg) {
-        const { clientIdentity, providerIdentity, ackToSender, payload, offer: clientOffer } = msg.payload;
-        if (!clientIdentity.endpointId) {
-            // Should be polyfilled by core but not in cases of node connecting to an old runtime.
-            clientIdentity.endpointId = this.wire.environment.getNextMessageId();
-            clientIdentity.isLocalEndpointId = true;
-        }
-        else {
-            clientIdentity.isLocalEndpointId = false;
-        }
-        const key = providerIdentity.channelId;
-        const bus = this.providerMap.get(key);
-        if (!bus) {
-            ackToSender.payload.success = false;
-            ackToSender.payload.reason = `Channel "${providerIdentity.channelName}" has been destroyed.`;
-            return this.wire.sendRaw(ackToSender);
-        }
-        const { provider, strategy, supportedProtocols } = bus;
-        try {
-            if (!(provider instanceof provider_1.ChannelProvider)) {
-                throw Error('Cannot connect to a channel client');
-            }
-            const offer = clientOffer !== null && clientOffer !== void 0 ? clientOffer : {
-                supportedProtocols: [{ type: 'classic', version: 1 }],
-                maxProtocols: 1
-            };
-            const overlappingProtocols = this.protocolManager.getCompatibleProtocols(supportedProtocols, offer);
-            if (!overlappingProtocols.length) {
-                throw new Error('This provider does not support any of the offered protocols.');
-            }
-            const res = await provider.processConnection(clientIdentity, payload);
-            ackToSender.payload.payload = ackToSender.payload.payload || {};
-            // Loop through all supported protocols and accumulate them into the answer
-            // addEndpoint is tricky but we need to wait for channel resolution before adding the endpoint.
-            let clientAnswer = {
-                supportedProtocols: [],
-                endpointPayloadPromise: Promise.resolve({ endpointIdentity: clientIdentity })
-            };
-            clientAnswer = await overlappingProtocols.reduce(async (accumP, protocolToUse) => {
-                const answer = await accumP;
-                if (protocolToUse.type === 'rtc') {
-                    const { answer: rtcAnswer, rtcClient, channels } = await __classPrivateFieldGet(this, _rtcConnectionManager).createProviderAnswer(protocolToUse.payload.rtcConnectionId, protocolToUse.payload.offer);
-                    answer.supportedProtocols.push({
-                        type: 'rtc',
-                        version: strategy_2.RTCInfo.version,
-                        payload: {
-                            answer: rtcAnswer
-                        }
-                    });
-                    answer.endpointPayloadPromise = answer.endpointPayloadPromise.then((endpointPayload) => channels.then((resolvedChannels) => {
-                        return {
-                            ...endpointPayload,
-                            rtc: {
-                                rtcClient,
-                                channels: resolvedChannels
-                            }
-                        };
-                    }));
-                }
-                else {
-                    answer.supportedProtocols.push({ type: 'classic', version: strategy_1.ClassicInfo.version });
-                }
-                return answer;
-            }, Promise.resolve(clientAnswer));
-            // Need to as cast here.
-            clientAnswer.endpointPayloadPromise.then((endpointPayload) => strategy.addEndpoint(clientIdentity.endpointId, endpointPayload));
-            ackToSender.payload.payload.result = res;
-            ackToSender.payload.payload.answer = clientAnswer;
-            return this.wire.sendRaw(ackToSender);
-        }
-        catch (e) {
-            ackToSender.payload.success = false;
-            ackToSender.payload.reason = e.message;
-            return this.wire.sendRaw(ackToSender);
-        }
-    }
-}
-exports.ConnectionManager = ConnectionManager;
-_messageReceiver = new WeakMap(), _rtcConnectionManager = new WeakMap();
+"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 _messageReceiver, _rtcConnectionManager;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConnectionManager = void 0;
+const exhaustive_1 = require("../../../util/exhaustive");
+const base_1 = require("../../base");
+const strategy_1 = require("./protocols/classic/strategy");
+const strategy_2 = require("./protocols/rtc/strategy");
+const ice_manager_1 = require("./protocols/rtc/ice-manager");
+const provider_1 = require("./provider");
+const message_receiver_1 = require("./protocols/classic/message-receiver");
+const protocol_manager_1 = require("./protocols/protocol-manager");
+const strategy_3 = require("./protocols/combined/strategy");
+class ConnectionManager extends base_1.Base {
+    constructor(wire) {
+        super(wire);
+        _messageReceiver.set(this, void 0);
+        _rtcConnectionManager.set(this, void 0);
+        this.removeChannelFromProviderMap = (channelId) => {
+            this.providerMap.delete(channelId);
+        };
+        this.onmessage = (msg) => {
+            if (msg.action === 'process-channel-connection') {
+                this.processChannelConnection(msg);
+                return true;
+            }
+            return false;
+        };
+        this.providerMap = new Map();
+        this.protocolManager = new protocol_manager_1.ProtocolManager(this.isNodeEnvironment() ? ['classic'] : ['rtc', 'classic']);
+        __classPrivateFieldSet(this, _messageReceiver, new message_receiver_1.MessageReceiver(wire));
+        __classPrivateFieldSet(this, _rtcConnectionManager, new ice_manager_1.RTCICEManager(wire));
+        wire.registerMessageHandler(this.onmessage.bind(this));
+    }
+    static getProtocolOptionsFromStrings(protocols) {
+        return protocols.map(protocol => {
+            switch (protocol) {
+                case 'rtc':
+                    return strategy_2.RTCInfo;
+                case 'classic':
+                    return strategy_1.ClassicInfo;
+                default:
+                    return exhaustive_1.exhaustiveCheck(protocol, ['rtc', 'classic']);
+            }
+        });
+    }
+    createProvider(options, providerIdentity) {
+        const opts = Object.assign(this.wire.environment.getDefaultChannelOptions().create, options || {});
+        const protocols = this.protocolManager.getProviderProtocols(opts === null || opts === void 0 ? void 0 : opts.protocols);
+        const createSingleStrategy = (stratType) => {
+            switch (stratType) {
+                case 'rtc':
+                    return new strategy_2.RTCStrategy();
+                case 'classic':
+                    return new strategy_1.ClassicStrategy(this.wire, __classPrivateFieldGet(this, _messageReceiver), 
+                    // Providers do not have an endpointId, use channelId as endpointId in the strategy.
+                    providerIdentity.channelId, providerIdentity);
+                default:
+                    return exhaustive_1.exhaustiveCheck(stratType, ['rtc', 'classic']);
+            }
+        };
+        const strategies = protocols.map(createSingleStrategy);
+        let strategy;
+        if (strategies.length === 2) {
+            const [a, b] = strategies;
+            strategy = strategy_3.default.combine(a, b);
+        }
+        else if (strategies.length === 1) {
+            [strategy] = strategies;
+        }
+        else {
+            // Should be impossible.
+            throw new Error('failed to combine strategies');
+        }
+        const channel = new provider_1.ChannelProvider(providerIdentity, this.wire, strategy);
+        const key = providerIdentity.channelId;
+        this.providerMap.set(key, { provider: channel, strategy, supportedProtocols: ConnectionManager.getProtocolOptionsFromStrings(protocols) });
+        provider_1.ChannelProvider.setProviderRemoval(channel, this.removeChannelFromProviderMap.bind(this));
+        return channel;
+    }
+    async createClientOffer(options) {
+        const protocols = this.protocolManager.getClientProtocols(options === null || options === void 0 ? void 0 : options.protocols);
+        let rtcPacket;
+        const supportedProtocols = await Promise.all(protocols.map(async (type) => {
+            switch (type) {
+                case 'rtc': {
+                    const { rtcClient, channels, offer, rtcConnectionId, channelsOpened } = await __classPrivateFieldGet(this, _rtcConnectionManager).startClientOffer();
+                    rtcPacket = { rtcClient, channels, channelsOpened };
+                    return {
+                        type: 'rtc',
+                        version: strategy_2.RTCInfo.version,
+                        payload: { offer, rtcConnectionId }
+                    };
+                }
+                case 'classic':
+                    return { type: 'classic', version: strategy_1.ClassicInfo.version };
+                default:
+                    return exhaustive_1.exhaustiveCheck(type, ['rtc', 'classic']);
+            }
+        }));
+        return {
+            offer: {
+                supportedProtocols,
+                maxProtocols: 2
+            },
+            rtc: rtcPacket
+        };
+    }
+    async createClientStrategy(rtcPacket, routingInfo) {
+        var _a;
+        if (!routingInfo.endpointId) {
+            routingInfo.endpointId = this.wire.environment.getNextMessageId();
+            // For New Clients connecting to Old Providers. To prevent multi-dispatching and publishing, we delete previously-connected
+            // clients that are in the same context as the newly-connected client.
+            __classPrivateFieldGet(this, _messageReceiver).checkForPreviousClientConnection(routingInfo.channelId);
+        }
+        const answer = (_a = routingInfo.answer) !== null && _a !== void 0 ? _a : {
+            supportedProtocols: [{ type: 'classic', version: 1 }]
+        };
+        const createStrategyFromAnswer = async (protocol) => {
+            if (protocol.type === 'rtc' && rtcPacket) {
+                await __classPrivateFieldGet(this, _rtcConnectionManager).finishClientOffer(rtcPacket.rtcClient, protocol.payload.answer, rtcPacket.channelsOpened);
+                return new strategy_2.RTCStrategy();
+            }
+            if (protocol.type === 'classic') {
+                return new strategy_1.ClassicStrategy(this.wire, __classPrivateFieldGet(this, _messageReceiver), routingInfo.endpointId, routingInfo);
+            }
+            return null;
+        };
+        const allProtocols = (await Promise.all(answer.supportedProtocols.map(createStrategyFromAnswer))).filter((x) => x !== null);
+        // Clean up logic if provider didn't support rtc.
+        if (rtcPacket && !allProtocols.some((x) => x instanceof strategy_2.RTCStrategy)) {
+            if (rtcPacket) {
+                rtcPacket.rtcClient.close();
+            }
+        }
+        let strategy;
+        if (allProtocols.length >= 2) {
+            strategy = strategy_3.default.combine(allProtocols[0], allProtocols[1]);
+        }
+        else if (allProtocols.length) {
+            [strategy] = allProtocols;
+        }
+        else {
+            // Should be impossible.
+            throw new Error('No compatible protocols');
+        }
+        // as casting rtcPacket because we won't have an rtcStrategy if rtcPacket is undefined;
+        const endpointPayload = { endpointIdentity: routingInfo, rtc: rtcPacket };
+        strategy.addEndpoint(routingInfo.channelId, endpointPayload);
+        return strategy;
+    }
+    async processChannelConnection(msg) {
+        const { clientIdentity, providerIdentity, ackToSender, payload, offer: clientOffer } = msg.payload;
+        if (!clientIdentity.endpointId) {
+            // Should be polyfilled by core but not in cases of node connecting to an old runtime.
+            clientIdentity.endpointId = this.wire.environment.getNextMessageId();
+            clientIdentity.isLocalEndpointId = true;
+        }
+        else {
+            clientIdentity.isLocalEndpointId = false;
+        }
+        const key = providerIdentity.channelId;
+        const bus = this.providerMap.get(key);
+        if (!bus) {
+            ackToSender.payload.success = false;
+            ackToSender.payload.reason = `Channel "${providerIdentity.channelName}" has been destroyed.`;
+            return this.wire.sendRaw(ackToSender);
+        }
+        const { provider, strategy, supportedProtocols } = bus;
+        try {
+            if (!(provider instanceof provider_1.ChannelProvider)) {
+                throw Error('Cannot connect to a channel client');
+            }
+            const offer = clientOffer !== null && clientOffer !== void 0 ? clientOffer : {
+                supportedProtocols: [{ type: 'classic', version: 1 }],
+                maxProtocols: 1
+            };
+            const overlappingProtocols = this.protocolManager.getCompatibleProtocols(supportedProtocols, offer);
+            if (!overlappingProtocols.length) {
+                throw new Error('This provider does not support any of the offered protocols.');
+            }
+            const res = await provider.processConnection(clientIdentity, payload);
+            ackToSender.payload.payload = ackToSender.payload.payload || {};
+            // Loop through all supported protocols and accumulate them into the answer
+            // addEndpoint is tricky but we need to wait for channel resolution before adding the endpoint.
+            let clientAnswer = {
+                supportedProtocols: [],
+                endpointPayloadPromise: Promise.resolve({ endpointIdentity: clientIdentity })
+            };
+            clientAnswer = await overlappingProtocols.reduce(async (accumP, protocolToUse) => {
+                const answer = await accumP;
+                if (protocolToUse.type === 'rtc') {
+                    const { answer: rtcAnswer, rtcClient, channels } = await __classPrivateFieldGet(this, _rtcConnectionManager).createProviderAnswer(protocolToUse.payload.rtcConnectionId, protocolToUse.payload.offer);
+                    answer.supportedProtocols.push({
+                        type: 'rtc',
+                        version: strategy_2.RTCInfo.version,
+                        payload: {
+                            answer: rtcAnswer
+                        }
+                    });
+                    answer.endpointPayloadPromise = answer.endpointPayloadPromise.then((endpointPayload) => channels.then((resolvedChannels) => {
+                        return {
+                            ...endpointPayload,
+                            rtc: {
+                                rtcClient,
+                                channels: resolvedChannels
+                            }
+                        };
+                    }));
+                }
+                else {
+                    answer.supportedProtocols.push({ type: 'classic', version: strategy_1.ClassicInfo.version });
+                }
+                return answer;
+            }, Promise.resolve(clientAnswer));
+            // Need to as cast here.
+            clientAnswer.endpointPayloadPromise.then((endpointPayload) => strategy.addEndpoint(clientIdentity.endpointId, endpointPayload));
+            ackToSender.payload.payload.result = res;
+            ackToSender.payload.payload.answer = clientAnswer;
+            return this.wire.sendRaw(ackToSender);
+        }
+        catch (e) {
+            ackToSender.payload.success = false;
+            ackToSender.payload.reason = e.message;
+            return this.wire.sendRaw(ackToSender);
+        }
+    }
+}
+exports.ConnectionManager = ConnectionManager;
+_messageReceiver = new WeakMap(), _rtcConnectionManager = new WeakMap();

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

@@ -1,23 +1,22 @@
-import ChannelClient from './client';
-import { ChannelProvider } from './provider';
-import { EmitterBase } from '../../base';
-import Transport from '../../../transport/transport';
-import { ChannelEvents } from '../../events/channel';
-import ProviderIdentity = OpenFin.ProviderIdentity;
-import Identity = OpenFin.Identity;
-import Message = OpenFin.Message;
-export interface ChannelMessage extends Message<any> {
-    senderIdentity: Identity;
-    ackToSender: any;
-    providerIdentity: ProviderIdentity;
-    connectAction: boolean;
-}
-export declare class Channel extends EmitterBase<ChannelEvents> {
-    #private;
-    constructor(wire: Transport);
-    getAllChannels(): Promise<ProviderIdentity[]>;
-    onChannelConnect(listener: (...args: any[]) => void): Promise<void>;
-    onChannelDisconnect(listener: (...args: any[]) => void): Promise<void>;
-    connect(channelName: string, options?: OpenFin.ChannelConnectOptions): Promise<ChannelClient>;
-    create(channelName: string, options?: OpenFin.ChannelCreateOptions): Promise<ChannelProvider>;
-}
+import ChannelClient from './client';
+import { ChannelProvider } from './provider';
+import { EmitterBase } from '../../base';
+import Transport, { Message } from '../../../transport/transport';
+import { ChannelEvents } from '../../events/channel';
+import ProviderIdentity = OpenFin.ProviderIdentity;
+import Identity = OpenFin.Identity;
+export interface ChannelMessage extends Message<any> {
+    senderIdentity: Identity;
+    ackToSender: any;
+    providerIdentity: ProviderIdentity;
+    connectAction: boolean;
+}
+export declare class Channel extends EmitterBase<ChannelEvents> {
+    #private;
+    constructor(wire: Transport);
+    getAllChannels(): Promise<ProviderIdentity[]>;
+    onChannelConnect(listener: (...args: any[]) => void): Promise<void>;
+    onChannelDisconnect(listener: (...args: any[]) => void): Promise<void>;
+    connect(channelName: string, options?: OpenFin.ChannelConnectOptions): Promise<ChannelClient>;
+    create(channelName: string, options?: OpenFin.ChannelCreateOptions): Promise<ChannelProvider>;
+}