@openfin/core 25.68.30 → 25.70.2

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

@@ -1,121 +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();
+"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

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

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

@@ -1,84 +1,84 @@
-"use strict";
-var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, privateMap, value) {
-    if (!privateMap.has(receiver)) {
-        throw new TypeError("attempted to set private field on non-instance");
-    }
-    privateMap.set(receiver, value);
-    return value;
-};
-var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, privateMap) {
-    if (!privateMap.has(receiver)) {
-        throw new TypeError("attempted to get private field on non-instance");
-    }
-    return privateMap.get(receiver);
-};
-var _wire, _endpointIdentityMap;
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ClassicInfo = exports.ClassicStrategy = void 0;
-/*
-This is used to abstract out ipc messaging from the channels implementation. It is only concerned with sending messages and registration with the MessageReceiver
-*/
-class ClassicStrategy {
-    constructor(wire, messageReceiver, endpointId, // Provider endpointId is channelId
-    providerIdentity) {
-        this.messageReceiver = messageReceiver;
-        this.endpointId = endpointId;
-        this.providerIdentity = providerIdentity;
-        _wire.set(this, void 0);
-        // Store full endpointIdentity by endpointId of all known endpoints for this strategy instance.
-        // (clients will only have 1: the provider, the provider will have all clients)
-        _endpointIdentityMap.set(this, new Map());
-        this.send = async (endpointId, action, payload) => {
-            const to = __classPrivateFieldGet(this, _endpointIdentityMap).get(endpointId);
-            if (!to) {
-                throw new Error(`Could not locate routing info for endpoint ${endpointId}`);
-            }
-            // as casting to any because typescript complains. The following is only relevant if this is a locally set endpointId on a ClientIdentity.
-            // We delete these properties to not change backwards compatibility.
-            const cleanId = { ...to };
-            if (cleanId.isLocalEndpointId) {
-                delete cleanId.endpointId;
-            }
-            delete cleanId.isLocalEndpointId;
-            const raw = await __classPrivateFieldGet(this, _wire).sendAction('send-channel-message', {
-                ...cleanId,
-                providerIdentity: this.providerIdentity,
-                action,
-                payload
-            })
-                .catch((reason) => {
-                throw new Error(reason.message);
-            });
-            return raw.payload.data.result;
-        };
-        this.close = async () => {
-            this.messageReceiver.removeEndpoint(this.providerIdentity.channelId, this.endpointId);
-            __classPrivateFieldSet(this, _endpointIdentityMap, new Map());
-        };
-        __classPrivateFieldSet(this, _wire, wire);
-    }
-    onEndpointDisconnect(endpointId, listener) {
-        // Never fires for 'classic'.
-    }
-    receive(listener) {
-        this.messageReceiver.addEndpoint(listener, this.providerIdentity.channelId, this.endpointId);
-    }
-    async closeEndpoint(endpointId) {
-        __classPrivateFieldGet(this, _endpointIdentityMap).delete(endpointId);
-    }
-    isEndpointConnected(endpointId) {
-        return __classPrivateFieldGet(this, _endpointIdentityMap).has(endpointId);
-    }
-    addEndpoint(endpointId, payload) {
-        __classPrivateFieldGet(this, _endpointIdentityMap).set(endpointId, payload.endpointIdentity);
-    }
-    isValidEndpointPayload(payload) {
-        var _a, _b;
-        return (typeof ((_a = payload === null || payload === void 0 ? void 0 : payload.endpointIdentity) === null || _a === void 0 ? void 0 : _a.endpointId) === 'string' ||
-            typeof ((_b = payload === null || payload === void 0 ? void 0 : payload.endpointIdentity) === null || _b === void 0 ? void 0 : _b.channelId) === 'string');
-    }
-}
-exports.ClassicStrategy = ClassicStrategy;
-_wire = new WeakMap(), _endpointIdentityMap = new WeakMap();
-// Arbitrarily starting at 5 to leave the door open to backfilling pre endpointId etc.
-exports.ClassicInfo = { version: 5, minimumVersion: 0, type: 'classic' };
+"use strict";
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, privateMap, value) {
+    if (!privateMap.has(receiver)) {
+        throw new TypeError("attempted to set private field on non-instance");
+    }
+    privateMap.set(receiver, value);
+    return value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, privateMap) {
+    if (!privateMap.has(receiver)) {
+        throw new TypeError("attempted to get private field on non-instance");
+    }
+    return privateMap.get(receiver);
+};
+var _wire, _endpointIdentityMap;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ClassicInfo = exports.ClassicStrategy = void 0;
+/*
+This is used to abstract out ipc messaging from the channels implementation. It is only concerned with sending messages and registration with the MessageReceiver
+*/
+class ClassicStrategy {
+    constructor(wire, messageReceiver, endpointId, // Provider endpointId is channelId
+    providerIdentity) {
+        this.messageReceiver = messageReceiver;
+        this.endpointId = endpointId;
+        this.providerIdentity = providerIdentity;
+        _wire.set(this, void 0);
+        // Store full endpointIdentity by endpointId of all known endpoints for this strategy instance.
+        // (clients will only have 1: the provider, the provider will have all clients)
+        _endpointIdentityMap.set(this, new Map());
+        this.send = async (endpointId, action, payload) => {
+            const to = __classPrivateFieldGet(this, _endpointIdentityMap).get(endpointId);
+            if (!to) {
+                throw new Error(`Could not locate routing info for endpoint ${endpointId}`);
+            }
+            // as casting to any because typescript complains. The following is only relevant if this is a locally set endpointId on a ClientIdentity.
+            // We delete these properties to not change backwards compatibility.
+            const cleanId = { ...to };
+            if (cleanId.isLocalEndpointId) {
+                delete cleanId.endpointId;
+            }
+            delete cleanId.isLocalEndpointId;
+            const raw = await __classPrivateFieldGet(this, _wire).sendAction('send-channel-message', {
+                ...cleanId,
+                providerIdentity: this.providerIdentity,
+                action,
+                payload
+            })
+                .catch((reason) => {
+                throw new Error(reason.message);
+            });
+            return raw.payload.data.result;
+        };
+        this.close = async () => {
+            this.messageReceiver.removeEndpoint(this.providerIdentity.channelId, this.endpointId);
+            __classPrivateFieldSet(this, _endpointIdentityMap, new Map());
+        };
+        __classPrivateFieldSet(this, _wire, wire);
+    }
+    onEndpointDisconnect(endpointId, listener) {
+        // Never fires for 'classic'.
+    }
+    receive(listener) {
+        this.messageReceiver.addEndpoint(listener, this.providerIdentity.channelId, this.endpointId);
+    }
+    async closeEndpoint(endpointId) {
+        __classPrivateFieldGet(this, _endpointIdentityMap).delete(endpointId);
+    }
+    isEndpointConnected(endpointId) {
+        return __classPrivateFieldGet(this, _endpointIdentityMap).has(endpointId);
+    }
+    addEndpoint(endpointId, payload) {
+        __classPrivateFieldGet(this, _endpointIdentityMap).set(endpointId, payload.endpointIdentity);
+    }
+    isValidEndpointPayload(payload) {
+        var _a, _b;
+        return (typeof ((_a = payload === null || payload === void 0 ? void 0 : payload.endpointIdentity) === null || _a === void 0 ? void 0 : _a.endpointId) === 'string' ||
+            typeof ((_b = payload === null || payload === void 0 ? void 0 : payload.endpointIdentity) === null || _b === void 0 ? void 0 : _b.channelId) === 'string');
+    }
+}
+exports.ClassicStrategy = ClassicStrategy;
+_wire = new WeakMap(), _endpointIdentityMap = new WeakMap();
+// Arbitrarily starting at 5 to leave the door open to backfilling pre endpointId etc.
+exports.ClassicInfo = { version: 5, minimumVersion: 0, type: 'classic' };