@openfin/core 25.68.26

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

@@ -0,0 +1,22 @@
+import { ChannelBase } from './channel';
+import Transport from '../../../transport/transport';
+import { AnyStrategy } from './protocols/strategy-types';
+import ProviderIdentity = OpenFin.ProviderIdentity;
+declare type DisconnectionListener = (providerIdentity: ProviderIdentity) => any;
+interface RoutingInfo extends ProviderIdentity {
+    endpointId: string;
+}
+export default class ChannelClient extends ChannelBase {
+    #private;
+    private disconnectListener;
+    private endpointId;
+    static closeChannelByEndpointId(id: string): void;
+    static handleProviderDisconnect(channel: ChannelClient, eventPayload: ProviderIdentity): void;
+    constructor(routingInfo: RoutingInfo, wire: Transport, strategy: AnyStrategy);
+    protected processAction: (action: string, payload: any, senderIdentity: ProviderIdentity | OpenFin.ClientIdentity) => Promise<any>;
+    get providerIdentity(): ProviderIdentity;
+    dispatch(action: string, payload?: any): Promise<any>;
+    onDisconnection(listener: DisconnectionListener): void;
+    disconnect(): Promise<void>;
+}
+export {};

package/src/api/interappbus/channel/client.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 _protectedObj, _strategy, _close;
+Object.defineProperty(exports, "__esModule", { value: true });
+const channel_1 = require("./channel");
+const channelClientsByEndpointId = new Map();
+class ChannelClient extends channel_1.ChannelBase {
+    constructor(routingInfo, wire, strategy) {
+        super();
+        _protectedObj.set(this, void 0);
+        _strategy.set(this, void 0);
+        // needs to be bound;
+        this.processAction = (action, payload, senderIdentity) => super.processAction(action, payload, senderIdentity);
+        _close.set(this, () => {
+            channelClientsByEndpointId.delete(this.endpointId);
+            __classPrivateFieldGet(this, _strategy).close();
+        });
+        __classPrivateFieldSet(this, _protectedObj, new channel_1.ProtectedItems(routingInfo, wire));
+        this.disconnectListener = () => undefined;
+        this.endpointId = routingInfo.endpointId;
+        __classPrivateFieldSet(this, _strategy, strategy);
+        channelClientsByEndpointId.set(this.endpointId, this);
+        strategy.receive(this.processAction);
+    }
+    static closeChannelByEndpointId(id) {
+        const channel = channelClientsByEndpointId.get(id);
+        if (channel) {
+            __classPrivateFieldGet(channel, _close).call(channel);
+        }
+    }
+    // closes the channel and invokes the disconnect listener if an event payload is passed.
+    static handleProviderDisconnect(channel, eventPayload) {
+        channel.disconnectListener(eventPayload);
+        __classPrivateFieldGet(channel, _close).call(channel);
+    }
+    get providerIdentity() {
+        const protectedObj = __classPrivateFieldGet(this, _protectedObj);
+        return protectedObj.providerIdentity;
+    }
+    async dispatch(action, payload) {
+        if (__classPrivateFieldGet(this, _strategy).isEndpointConnected(this.providerIdentity.channelId)) {
+            return __classPrivateFieldGet(this, _strategy).send(this.providerIdentity.channelId, action, payload);
+        }
+        throw new Error('The client you are trying to dispatch from is disconnected from the target provider.');
+    }
+    onDisconnection(listener) {
+        this.disconnectListener = (payload) => {
+            try {
+                listener(payload);
+            }
+            catch (err) {
+                throw new Error(`Error while calling the onDisconnection callback: ${err.message}`);
+            }
+            finally {
+                this.disconnectListener = () => undefined;
+            }
+        };
+    }
+    async disconnect() {
+        const protectedObj = __classPrivateFieldGet(this, _protectedObj);
+        const { channelName, uuid, name } = protectedObj.providerIdentity;
+        await protectedObj.wire.sendAction('disconnect-from-channel', {
+            channelName,
+            uuid,
+            name,
+            endpointId: this.endpointId
+        });
+        __classPrivateFieldGet(this, _close).call(this);
+    }
+}
+exports.default = ChannelClient;
+_protectedObj = new WeakMap(), _strategy = new WeakMap(), _close = new WeakMap();

package/src/api/interappbus/channel/connection-manager.d.ts

@@ -0,0 +1,28 @@
+import { ChannelMessage } from '.';
+import Transport from '../../../transport/transport';
+import { Base } from '../../base';
+import { ClientOffer, LocalSupportedProtocol } from './protocols/index';
+import { RTCPacket } from './protocols/rtc/endpoint';
+import { ChannelProvider } from './provider';
+import { AnyStrategy } from './protocols/strategy-types';
+export declare type ProviderEntry = {
+    provider: ChannelProvider;
+    strategy: AnyStrategy;
+    supportedProtocols: LocalSupportedProtocol[];
+};
+export declare class ConnectionManager extends Base {
+    #private;
+    private protocolManager;
+    private providerMap;
+    private static getProtocolOptionsFromStrings;
+    constructor(wire: Transport);
+    createProvider(options: OpenFin.ChannelCreateOptions | undefined, providerIdentity: any): ChannelProvider;
+    createClientOffer(options?: OpenFin.ChannelConnectOptions): Promise<{
+        offer: ClientOffer;
+        rtc?: RTCPacket;
+    }>;
+    createClientStrategy(rtcPacket: RTCPacket | undefined, routingInfo: any): Promise<AnyStrategy>;
+    removeChannelFromProviderMap: (channelId: string) => void;
+    onmessage: (msg: ChannelMessage) => boolean;
+    private processChannelConnection;
+}

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

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

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

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

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

@@ -0,0 +1,121 @@
+"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 _connectionManager;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Channel = void 0;
+/* eslint-disable no-console */
+const client_1 = require("./client");
+const provider_1 = require("./provider");
+const base_1 = require("../../base");
+const connection_manager_1 = require("./connection-manager");
+// eslint-disable-next-line @typescript-eslint/no-empty-function
+const noop = () => { };
+class Channel extends base_1.EmitterBase {
+    constructor(wire) {
+        super(wire, 'channel');
+        _connectionManager.set(this, void 0);
+        __classPrivateFieldSet(this, _connectionManager, new connection_manager_1.ConnectionManager(wire));
+    }
+    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 connect(channelName, options) {
+        if (!channelName || typeof channelName !== 'string') {
+            throw new Error('Please provide a channelName string to connect to a channel.');
+        }
+        const opts = Object.assign(this.wire.environment.getDefaultChannelOptions().connect, options || {});
+        let resolver = noop;
+        let listener = noop;
+        const waitResponse = new Promise((resolve) => {
+            resolver = resolve;
+            listener = (payload) => {
+                if (channelName === payload.channelName) {
+                    this.removeListener('connected', listener);
+                    this.connect(channelName, opts).then((response) => {
+                        resolve(response);
+                    });
+                }
+            };
+            this.on('connected', listener);
+        });
+        try {
+            const { offer, rtc: rtcPacket } = await __classPrivateFieldGet(this, _connectionManager).createClientOffer(opts);
+            const res = await this.wire.sendAction('connect-to-channel', { channelName, ...opts, offer });
+            const { payload: { data: routingInfo } } = res;
+            // If there isn't a matching channel, the above sendAction call will error out and go to catch, skipping the logic below.
+            if (resolver) {
+                resolver();
+            }
+            this.removeListener('connected', listener);
+            const strategy = await __classPrivateFieldGet(this, _connectionManager).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.disconnect();
+                }
+                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(channel, routingInfo);
+                }
+            });
+            this.on('disconnected', (eventPayload) => {
+                if (eventPayload.channelName === channelName) {
+                    client_1.default.handleProviderDisconnect(channel, eventPayload);
+                }
+            });
+            return channel;
+        }
+        catch (e) {
+            const shouldWait = { wait: true, ...opts }.wait;
+            const internalNackMessage = 'internal-nack';
+            if (shouldWait && e.message && e.message.includes(internalNackMessage)) {
+                console.warn(`Channel not found for channelName: ${channelName}, waiting for channel connection.`);
+                return waitResponse;
+            }
+            if (e.message === internalNackMessage) {
+                throw new Error(`No channel found for channelName: ${channelName}`);
+            }
+            else {
+                throw new Error(e);
+            }
+        }
+    }
+    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, _connectionManager).createProvider(options, providerIdentity);
+        this.on('client-disconnected', (eventPayload) => {
+            if (eventPayload.channelName === channelName) {
+                provider_1.ChannelProvider.handleClientDisconnection(channel, eventPayload);
+            }
+        });
+        return channel;
+    }
+}
+exports.Channel = Channel;
+_connectionManager = new WeakMap();

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

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

@@ -0,0 +1,73 @@
+"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

@@ -0,0 +1,22 @@
+import Transport from '../../../../../transport/transport';
+import { MessageReceiver } from './message-receiver';
+import { ChannelStrategy, EndpointPayload } from '../strategy';
+import { LocalSupportedProtocol } from '..';
+import 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;