@openfin/core 33.76.31 → 33.76.38

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

@@ -1,246 +0,0 @@
-"use strict";
-var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
-    if (kind === "m") throw new TypeError("Private method is not writable");
-    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
-    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
-    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
-};
-var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
-    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
-    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
-    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
-};
-var _ConnectionManager_messageReceiver, _ConnectionManager_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 {
-    static getProtocolOptionsFromStrings(protocols) {
-        return protocols.map((protocol) => {
-            switch (protocol) {
-                case 'rtc':
-                    return strategy_2.RTCInfo;
-                case 'classic':
-                    return strategy_1.ClassicInfo;
-                default:
-                    return (0, exhaustive_1.exhaustiveCheck)(protocol, ['rtc', 'classic']);
-            }
-        });
-    }
-    constructor(wire) {
-        super(wire);
-        _ConnectionManager_messageReceiver.set(this, void 0);
-        _ConnectionManager_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, _ConnectionManager_messageReceiver, new message_receiver_1.MessageReceiver(wire), "f");
-        __classPrivateFieldSet(this, _ConnectionManager_rtcConnectionManager, new ice_manager_1.RTCICEManager(wire), "f");
-        wire.registerMessageHandler(this.onmessage.bind(this));
-    }
-    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, _ConnectionManager_messageReceiver, "f"), 
-                    // Providers do not have an endpointId, use channelId as endpointId in the strategy.
-                    providerIdentity.channelId, providerIdentity);
-                default:
-                    return (0, 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, _ConnectionManager_rtcConnectionManager, "f").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 (0, 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, _ConnectionManager_messageReceiver, "f").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, _ConnectionManager_rtcConnectionManager, "f").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, _ConnectionManager_messageReceiver, "f"), 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, _ConnectionManager_rtcConnectionManager, "f").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;
-_ConnectionManager_messageReceiver = new WeakMap(), _ConnectionManager_rtcConnectionManager = new WeakMap();

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

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

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

@@ -1,169 +0,0 @@
-"use strict";
-var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
-    if (kind === "m") throw new TypeError("Private method is not writable");
-    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
-    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
-    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
-};
-var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
-    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
-    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
-    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
-};
-var _Channel_connectionManager, _Channel_internalEmitter, _Channel_readyToConnect;
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Channel = void 0;
-/* eslint-disable no-console */
-const events_1 = require("events");
-const lazy_1 = require("../../../util/lazy");
-const base_1 = require("../../base");
-const client_1 = require("./client");
-const connection_manager_1 = require("./connection-manager");
-const provider_1 = require("./provider");
-function retryDelay(count) {
-    const interval = 500; // base delay
-    const steps = 10; // How many retries to do before incrementing the delay
-    const base = 2; // How much to multiply the previous delay by
-    const max = 30000; // max delay
-    const step = Math.floor(count / steps);
-    const delay = Math.min(max, interval * base ** step);
-    return new Promise(resolve => {
-        setTimeout(() => {
-            resolve(false);
-        }, delay);
-    });
-}
-class Channel extends base_1.EmitterBase {
-    constructor(wire) {
-        super(wire, 'channel');
-        _Channel_connectionManager.set(this, void 0);
-        _Channel_internalEmitter.set(this, new events_1.EventEmitter());
-        // OpenFin API has not been injected at construction time, *must* wait for API to be ready.
-        _Channel_readyToConnect.set(this, new lazy_1.AsyncRetryableLazy(async () => {
-            await Promise.all([
-                this.on('disconnected', (eventPayload) => {
-                    client_1.default.handleProviderDisconnect(eventPayload);
-                }),
-                this.on('connected', (...args) => {
-                    __classPrivateFieldGet(this, _Channel_internalEmitter, "f").emit('connected', ...args);
-                })
-            ]).catch(() => new Error('error setting up channel connection listeners'));
-        }));
-        __classPrivateFieldSet(this, _Channel_connectionManager, new connection_manager_1.ConnectionManager(wire), "f");
-    }
-    async getAllChannels() {
-        return this.wire.sendAction('get-all-channels').then(({ payload }) => payload.data);
-    }
-    async onChannelConnect(listener) {
-        await this.on('connected', listener);
-    }
-    async onChannelDisconnect(listener) {
-        await this.on('disconnected', listener);
-    }
-    async safeConnect(channelName, shouldWait, connectPayload) {
-        const retryInfo = { count: 0 };
-        /* eslint-disable no-await-in-loop, no-constant-condition */
-        do {
-            // setup a listener and a connected promise to await in case we connect before the channel is ready
-            let connectedListener = () => undefined;
-            const connectedPromise = new Promise((resolve) => {
-                connectedListener = (payload) => {
-                    if (channelName === payload.channelName) {
-                        resolve(true);
-                    }
-                };
-                __classPrivateFieldGet(this, _Channel_internalEmitter, "f").on('connected', connectedListener);
-            });
-            try {
-                if (retryInfo.count > 0) {
-                    // Wait before retrying
-                    // Delay returns false connectedPromise returns true so we can know if a retry is due to connected event
-                    retryInfo.gotConnectedEvent = await Promise.race([retryDelay(retryInfo.count), connectedPromise]);
-                    const result = await this.wire.sendAction('connect-to-channel', { ...connectPayload, retryInfo });
-                    // log only if there was a retry
-                    console.log(`Successfully connected to channelName: ${channelName}`);
-                    return result.payload.data;
-                }
-                // Send retryInfo to the core for debug log inclusion
-                const sentMessagePromise = this.wire.sendAction('connect-to-channel', connectPayload);
-                // Save messageId from the first connection attempt
-                retryInfo.originalMessageId = sentMessagePromise.messageId;
-                const result = await sentMessagePromise;
-                return result.payload.data;
-            }
-            catch (error) {
-                if (!error.message.includes('internal-nack')) {
-                    // Not an internal nack, break the loop
-                    throw error;
-                }
-                if (shouldWait && retryInfo.count === 0) {
-                    // start waiting on the next iteration, warn the user
-                    console.warn(`No channel found for channelName: ${channelName}. Waiting for connection...`);
-                }
-            }
-            finally {
-                retryInfo.count += 1;
-                // in case of other errors, remove our listener
-                __classPrivateFieldGet(this, _Channel_internalEmitter, "f").removeListener('connected', connectedListener);
-            }
-        } while (shouldWait); // If we're waiting we retry the above loop
-        // Should wait was false, no channel was found.
-        throw new Error(`No channel found for channelName: ${channelName}.`);
-        /* eslint-enable no-await-in-loop, no-constant-condition */
-    }
-    async connect(channelName, options = {}) {
-        // Make sure we don't connect before listeners are set up
-        // This also errors if we're not in OpenFin, ensuring we don't run unnecessary code
-        await __classPrivateFieldGet(this, _Channel_readyToConnect, "f").getValue();
-        if (!channelName || typeof channelName !== 'string') {
-            throw new Error('Please provide a channelName string to connect to a channel.');
-        }
-        const opts = { wait: true, ...this.wire.environment.getDefaultChannelOptions().connect, ...options };
-        const { offer, rtc: rtcPacket } = await __classPrivateFieldGet(this, _Channel_connectionManager, "f").createClientOffer(opts);
-        let connectionUrl;
-        if (this.fin.me.isFrame || this.fin.me.isView || this.fin.me.isWindow) {
-            connectionUrl = (await this.fin.me.getInfo()).url;
-        }
-        const connectPayload = {
-            channelName,
-            ...opts,
-            offer,
-            connectionUrl
-        };
-        const routingInfo = await this.safeConnect(channelName, opts.wait, connectPayload);
-        const strategy = await __classPrivateFieldGet(this, _Channel_connectionManager, "f").createClientStrategy(rtcPacket, routingInfo);
-        const channel = new client_1.default(routingInfo, this.wire, strategy);
-        // It is the client's responsibility to handle endpoint disconnection to the provider.
-        // If the endpoint dies, the client will force a disconnection through the core.
-        // The provider does not care about endpoint disconnection.
-        strategy.onEndpointDisconnect(routingInfo.channelId, async () => {
-            try {
-                await channel.sendDisconnectAction();
-            }
-            catch (error) {
-                console.warn(`Something went wrong during disconnect for client with uuid: ${routingInfo.uuid} / name: ${routingInfo.name} / endpointId: ${routingInfo.endpointId}.`);
-            }
-            finally {
-                client_1.default.handleProviderDisconnect(routingInfo);
-            }
-        });
-        return channel;
-    }
-    async create(channelName, options) {
-        if (!channelName) {
-            throw new Error('Please provide a channelName to create a channel');
-        }
-        const { payload: { data: providerIdentity } } = await this.wire.sendAction('create-channel', { channelName });
-        const channel = __classPrivateFieldGet(this, _Channel_connectionManager, "f").createProvider(options, providerIdentity);
-        // TODO: fix typing (internal)
-        // @ts-expect-error
-        this.on('client-disconnected', (eventPayload) => {
-            if (eventPayload.channelName === channelName) {
-                provider_1.ChannelProvider.handleClientDisconnection(channel, eventPayload);
-            }
-        });
-        return channel;
-    }
-}
-exports.Channel = Channel;
-_Channel_connectionManager = new WeakMap(), _Channel_internalEmitter = new WeakMap(), _Channel_readyToConnect = new WeakMap();

package/src/api/interappbus/channel/protocols/classic/message-receiver.d.ts

@@ -1,13 +0,0 @@
-import { Transport } from '../../../../../transport/transport';
-import { Base } from '../../../../base';
-import { ChannelBase } from '../../channel';
-export declare class MessageReceiver extends Base {
-    private endpointMap;
-    private latestEndpointIdByChannelId;
-    constructor(wire: Transport);
-    private processChannelMessage;
-    private onmessage;
-    addEndpoint(handler: ChannelBase['processAction'], channelId: string, endpointId: string): void;
-    removeEndpoint(channelId: string, endpointId: string): void;
-    checkForPreviousClientConnection(channelId: string): void;
-}

package/src/api/interappbus/channel/protocols/classic/message-receiver.js

@@ -1,73 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.MessageReceiver = void 0;
-const client_1 = require("../../client");
-const base_1 = require("../../../../base");
-/*
-This is a singleton (per fin object) tasked with routing messages coming off the ipc to the correct endpoint.
-It needs to be a singleton because there can only be one per wire. It tracks both clients and providers' processAction passed in via the strategy.
-If functionality is not about receiving messages, it does not belong here.
-*/
-class MessageReceiver extends base_1.Base {
-    constructor(wire) {
-        super(wire);
-        this.onmessage = (msg) => {
-            if (msg.action === 'process-channel-message') {
-                this.processChannelMessage(msg);
-                return true;
-            }
-            return false;
-        };
-        this.endpointMap = new Map();
-        this.latestEndpointIdByChannelId = new Map();
-        wire.registerMessageHandler(this.onmessage.bind(this));
-    }
-    async processChannelMessage(msg) {
-        var _a, _b;
-        const { senderIdentity, providerIdentity, action, ackToSender, payload, intendedTargetIdentity } = msg.payload;
-        const key = (_b = (_a = intendedTargetIdentity.channelId) !== null && _a !== void 0 ? _a : intendedTargetIdentity.endpointId) !== null && _b !== void 0 ? _b : this.latestEndpointIdByChannelId.get(providerIdentity.channelId); // No endpointId was passed, make best attempt
-        const handler = this.endpointMap.get(key);
-        if (!handler) {
-            ackToSender.payload.success = false;
-            ackToSender.payload.reason = `Client connection with identity uuid: ${this.wire.me.uuid} / name: ${this.wire.me.name} / endpointId: ${key} no longer connected.`;
-            return this.wire.sendRaw(ackToSender);
-        }
-        try {
-            const res = await handler(action, payload, senderIdentity);
-            ackToSender.payload.payload = ackToSender.payload.payload || {};
-            ackToSender.payload.payload.result = res;
-            return this.wire.sendRaw(ackToSender);
-        }
-        catch (e) {
-            ackToSender.payload.success = false;
-            ackToSender.payload.reason = e.message;
-            return this.wire.sendRaw(ackToSender);
-        }
-    }
-    addEndpoint(handler, channelId, endpointId) {
-        this.endpointMap.set(endpointId, handler);
-        // Providers have the same endpointId and channelId.
-        // This is only used when clients are receiving messages from providers, so we shouldn't save provider endpointId here.
-        if (channelId !== endpointId) {
-            this.latestEndpointIdByChannelId.set(channelId, endpointId);
-        }
-    }
-    removeEndpoint(channelId, endpointId) {
-        this.endpointMap.delete(endpointId);
-        if (this.latestEndpointIdByChannelId.get(channelId) === endpointId) {
-            this.latestEndpointIdByChannelId.delete(channelId);
-        }
-    }
-    checkForPreviousClientConnection(channelId) {
-        const endpointIdFromPreviousConnection = this.latestEndpointIdByChannelId.get(channelId);
-        if (endpointIdFromPreviousConnection) {
-            // Not convinced by this way of doing things, but pushing up for now.
-            client_1.default.closeChannelByEndpointId(endpointIdFromPreviousConnection);
-            // eslint-disable-next-line no-console
-            console.warn('You have created a second connection to an older provider. First connection has been removed from the clientMap');
-            // eslint-disable-next-line no-console
-            console.warn('If the provider calls publish(), you may receive multiple messages.');
-        }
-    }
-}
-exports.MessageReceiver = MessageReceiver;

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

@@ -1,24 +0,0 @@
-import type * as OpenFin from '../../../../../OpenFin';
-import { Transport } from '../../../../../transport/transport';
-import { MessageReceiver } from './message-receiver';
-import { ChannelStrategy, EndpointPayload } from '../strategy';
-import { LocalSupportedProtocol } from '..';
-type ProviderIdentity = OpenFin.ProviderIdentity;
-export declare class ClassicStrategy implements ChannelStrategy<EndpointPayload> {
-    #private;
-    private messageReceiver;
-    private endpointId;
-    private providerIdentity;
-    constructor(wire: Transport, messageReceiver: MessageReceiver, endpointId: string, // Provider endpointId is channelId
-    providerIdentity: ProviderIdentity);
-    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>;
-    closeEndpoint(endpointId: string): Promise<void>;
-    isEndpointConnected(endpointId: string): boolean;
-    addEndpoint(endpointId: string, payload: EndpointPayload): void;
-    isValidEndpointPayload(payload: any): payload is EndpointPayload;
-}
-export declare const ClassicInfo: LocalSupportedProtocol;
-export {};

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

@@ -1,101 +0,0 @@
-"use strict";
-var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
-    if (kind === "m") throw new TypeError("Private method is not writable");
-    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
-    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
-    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
-};
-var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
-    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
-    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
-    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
-};
-var _ClassicStrategy_wire, _ClassicStrategy_endpointIdentityMap, _ClassicStrategy_pendingMessagesByEndpointId;
-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;
-        _ClassicStrategy_wire.set(this, void 0);
-        // Store full endpointIdentity by endpointId of all known endpoints for this strategy instance.
-        // (clients will only have 1: the provider, the provider will have all clients)
-        _ClassicStrategy_endpointIdentityMap.set(this, new Map());
-        // Store a set of cancellable promises to be able to reject them when client
-        // connection problems occur
-        _ClassicStrategy_pendingMessagesByEndpointId.set(this, new Map);
-        this.send = async (endpointId, action, payload) => {
-            var _a;
-            const to = __classPrivateFieldGet(this, _ClassicStrategy_endpointIdentityMap, "f").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;
-            // grab the promise before awaiting it to save in our pending messages map
-            const p = __classPrivateFieldGet(this, _ClassicStrategy_wire, "f")
-                .sendAction('send-channel-message', {
-                ...cleanId,
-                providerIdentity: this.providerIdentity,
-                action,
-                payload
-            });
-            (_a = __classPrivateFieldGet(this, _ClassicStrategy_pendingMessagesByEndpointId, "f").get(endpointId)) === null || _a === void 0 ? void 0 : _a.add(p);
-            const raw = await p.catch((error) => {
-                throw new Error(error.message);
-            }).finally(() => {
-                var _a;
-                // clean up the pending promise
-                (_a = __classPrivateFieldGet(this, _ClassicStrategy_pendingMessagesByEndpointId, "f").get(endpointId)) === null || _a === void 0 ? void 0 : _a.delete(p);
-            });
-            return raw.payload.data.result;
-        };
-        this.close = async () => {
-            this.messageReceiver.removeEndpoint(this.providerIdentity.channelId, this.endpointId);
-            [...__classPrivateFieldGet(this, _ClassicStrategy_endpointIdentityMap, "f").keys()].forEach((id) => this.closeEndpoint(id));
-            __classPrivateFieldSet(this, _ClassicStrategy_endpointIdentityMap, new Map(), "f");
-        };
-        __classPrivateFieldSet(this, _ClassicStrategy_wire, wire, "f");
-    }
-    onEndpointDisconnect(endpointId, listener) {
-        // Never fires for 'classic'.
-    }
-    receive(listener) {
-        this.messageReceiver.addEndpoint(listener, this.providerIdentity.channelId, this.endpointId);
-    }
-    async closeEndpoint(endpointId) {
-        const id = __classPrivateFieldGet(this, _ClassicStrategy_endpointIdentityMap, "f").get(endpointId);
-        __classPrivateFieldGet(this, _ClassicStrategy_endpointIdentityMap, "f").delete(endpointId);
-        const pendingSet = __classPrivateFieldGet(this, _ClassicStrategy_pendingMessagesByEndpointId, "f").get(endpointId);
-        pendingSet === null || pendingSet === void 0 ? void 0 : pendingSet.forEach((p) => {
-            const errorMsg = `Channel connection with identity uuid: ${id === null || id === void 0 ? void 0 : id.uuid} / name: ${id === null || id === void 0 ? void 0 : id.name} / endpointId: ${endpointId} no longer connected.`;
-            p.cancel(new Error(errorMsg));
-        });
-    }
-    isEndpointConnected(endpointId) {
-        return __classPrivateFieldGet(this, _ClassicStrategy_endpointIdentityMap, "f").has(endpointId);
-    }
-    addEndpoint(endpointId, payload) {
-        __classPrivateFieldGet(this, _ClassicStrategy_endpointIdentityMap, "f").set(endpointId, payload.endpointIdentity);
-        __classPrivateFieldGet(this, _ClassicStrategy_pendingMessagesByEndpointId, "f").set(endpointId, new Set());
-    }
-    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;
-_ClassicStrategy_wire = new WeakMap(), _ClassicStrategy_endpointIdentityMap = new WeakMap(), _ClassicStrategy_pendingMessagesByEndpointId = new WeakMap();
-// Arbitrarily starting at 5 to leave the door open to backfilling pre endpointId etc.
-exports.ClassicInfo = { version: 5, minimumVersion: 0, type: 'classic' };