@openfin/core 33.76.36 → 33.77.1

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

@@ -1,29 +0,0 @@
-import type * as OpenFin from '../../../OpenFin';
-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 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

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

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

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