@openfin/core 33.76.36 → 33.77.1

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

@@ -1,333 +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);
-    });
-}
-/**
- * The Channel API allows an OpenFin application to create a channel as a {@link ChannelProvider ChannelProvider},
- * or connect to a channel as a {@link ChannelClient ChannelClient}.
- * @remarks The "handshake" between the communication partners is
- * simplified when using a channel.  A request to connect to a channel as a client will return a promise that resolves if/when the channel has been created. Both the
- * provider and client can dispatch actions that have been registered on their opposites, and dispatch returns a promise that resolves with a payload from the other
- * communication participant. There can be only one provider per channel, but many clients.  Version `9.61.35.*` or later is required for both communication partners.
- *
- * Asynchronous Methods:
- *  * {@link Channel.create create(channelName, options)}
- *  * {@link Channel.connect connect(channelName, options)}
- *  * {@link Channel.onChannelConnect onChannelConnect(listener)}
- *  * {@link Channel.onChannelDisconnect onChannelDisconnect(listener)}
- */
-class Channel extends base_1.EmitterBase {
-    /**
-     * @internal
-     */
-    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");
-    }
-    /**
-     *
-     * @internal
-     */
-    async getAllChannels() {
-        return this.wire.sendAction('get-all-channels').then(({ payload }) => payload.data);
-    }
-    /**
-     * Listens for channel connections.
-     *
-     * @param listener - callback to execute.
-     *
-     * @example
-     *
-     * ```js
-     * const listener = (channelPayload) => console.log(channelPayload); // see return value below
-     *
-     * fin.InterApplicationBus.Channel.onChannelConnect(listener);
-     *
-     * // example shape
-     * {
-     *     "topic": "channel",
-     *     "type": "connected",
-     *     "uuid": "OpenfinPOC",
-     *     "name": "OpenfinPOC",
-     *     "channelName": "counter",
-     *     "channelId": "OpenfinPOC/OpenfinPOC/counter"
-     * }
-     *
-     * ```
-     */
-    async onChannelConnect(listener) {
-        await this.on('connected', listener);
-    }
-    /**
-     * Listen for channel disconnections.
-     *
-     * @param listener - callback to execute.
-     *
-     * @example
-     *
-     * ```js
-     * const listener = (channelPayload) => console.log(channelPayload); // see return value below
-     *
-     * fin.InterApplicationBus.Channel.onChannelDisconnect(listener);
-     *
-     * // example shape
-     * {
-     *     "topic": "channel",
-     *     "type": "disconnected",
-     *     "uuid": "OpenfinPOC",
-     *     "name": "OpenfinPOC",
-     *     "channelName": "counter",
-     *     "channelId": "OpenfinPOC/OpenfinPOC/counter"
-     * }
-     *
-     * ```
-     */
-    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 */
-    }
-    /**
-     * Connect to a channel. If you wish to send a payload to the provider, add a payload property to the options argument.
-     * EXPERIMENTAL: pass { protocols: ['rtc'] } as options to opt-in to High Throughput Channels.
-     *
-     * @param channelName - Name of the target channel.
-     * @param options - Connection options.
-     * @returns Returns a promise that resolves with an instance of {@link ChannelClient ChannelClient}.
-     *
-     * @remarks The connection request will be routed to the channelProvider if/when the channel is created.  If the connect
-     * request is sent prior to creation, the promise will not resolve or reject until the channel is created by a channelProvider
-     * (whether or not to wait for creation is configurable in the connectOptions).
-     *
-     * The connect call returns a promise that will resolve with a channelClient bus if accepted by the channelProvider, or reject if
-     * the channelProvider throws an error to reject the connection. This bus can communicate with the Provider, but not to other
-     * clients on the channel. Using the bus, the channelClient can register actions and middleware. Channel lifecycle can also be
-     * handled with an onDisconnection listener.
-     *
-     * @example
-     *
-     * ```js
-     * async function makeClient(channelName) {
-     *    // A payload can be sent along with channel connection requests to help with authentication
-     *    const connectPayload = { payload: 'token' };
-     *
-     *    // If the channel has been created this request will be sent to the provider.  If not, the
-     *    // promise will not be resolved or rejected until the channel has been created.
-     *    const clientBus = await fin.InterApplicationBus.Channel.connect(channelName, connectPayload);
-     *
-     *    clientBus.onDisconnection(channelInfo => {
-     *        // handle the channel lifecycle here - we can connect again which will return a promise
-     *        // that will resolve if/when the channel is re-created.
-     *        makeClient(channelInfo.channelName);
-     *    })
-     *
-     *    clientBus.register('topic', (payload, identity) => {
-     *        // register a callback for a topic to which the channel provider can dispatch an action
-     *        console.log('Action dispatched by provider: ', JSON.stringify(identity));
-     *        console.log('Payload sent in dispatch: ', JSON.stringify(payload));
-     *        return {
-     *            echo: payload
-     *        };
-     *    });
-     * }
-     *
-     * makeClient('channelName')
-     * .then(() => console.log('Connected'))
-     * .catch(console.error);
-     * ```
-     */
-    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;
-    }
-    /**
-     * Create a new channel.
-     * You must provide a unique channelName. If a channelName is not provided, or it is not unique, the creation will fail.
-     * EXPERIMENTAL: pass { protocols: ['rtc'] } as options to opt-in to High Throughput Channels.
-     *
-     * @param channelName - Name of the channel to be created.
-     * @param options - Creation options.
-     * @returns Returns a promise that resolves with an instance of {@link ChannelProvider ChannelProvider}.
-     *
-     * @remarks If successful, the create method returns a promise that resolves to an instance of the channelProvider bus. The caller
-     * then becomes the “channel provider” and can use the channelProvider bus to register actions and middleware.
-     *
-     * The caller can also set an onConnection and/or onDisconnection listener that will execute on any new channel
-     * connection/disconnection attempt from a channel client. To reject a connection, simply throw an error in the
-     * onConnection listener.  The default behavior is to accept all new connections.
-     *
-     * A map of client connections is updated automatically on client connection and disconnection and saved in the
-     * [read-only] `connections` property on the channelProvider bus.  The channel will exist until the provider
-     * destroys it or disconnects by closing or destroying the context (navigating or reloading). To setup a channel
-     * as a channelProvider, call `Channel.create` with a unique channel name. A map of client connections is updated
-     * automatically on client connection and disconnection.
-     *
-     * @example
-     *
-     * ```js
-     * (async ()=> {
-     *    // entity creates a channel and becomes the channelProvider
-     *    const providerBus = await fin.InterApplicationBus.Channel.create('channelName');
-     *
-     *    providerBus.onConnection((identity, payload) => {
-     *        // can reject a connection here by throwing an error
-     *        console.log('Client connection request identity: ', JSON.stringify(identity));
-     *        console.log('Client connection request payload: ', JSON.stringify(payload));
-     *    });
-     *
-     *    providerBus.register('topic', (payload, identity) => {
-     *        // register a callback for a 'topic' to which clients can dispatch an action
-     *        console.log('Action dispatched by client: ', JSON.stringify(identity));
-     *        console.log('Payload sent in dispatch: ', JSON.stringify(payload));
-     *        return {
-     *            echo: payload
-     *        };
-     *    });
-     * })();
-     * ```
-     */
-    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' };

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

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

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

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