@openfin/core 33.76.36 → 33.77.1

package/src/api/interop/fdc3/PrivateChannelProvider.js

@@ -1,276 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.PrivateChannelProvider = void 0;
-const InteropBroker_1 = require("../InteropBroker");
-class PrivateChannelProvider {
-    constructor(provider, id) {
-        this.provider = provider;
-        this.id = id;
-        this.clients = new Map();
-        this.registerListeners();
-        this.contextByContextType = new Map();
-        this.lastContext = undefined;
-        this.provider.onConnection((clientIdentity) => this.registerNewClient(clientIdentity));
-        this.provider.onDisconnection(async (clientIdentity) => {
-            const { endpointId } = clientIdentity;
-            if (this.clients.has(endpointId)) {
-                await this.handleClientDisconnecting(clientIdentity);
-            }
-            if ((await this.provider.getAllClientInfo()).length === 0) {
-                this.provider.destroy();
-            }
-        });
-    }
-    getClientState(id) {
-        return this.clients.get(id.endpointId);
-    }
-    registerListeners() {
-        this.provider.register('broadcast', this.broadcast.bind(this));
-        this.provider.register('getCurrentContext', this.getCurrentContext.bind(this));
-        this.provider.register('contextHandlerAdded', this.contextHandlerAdded.bind(this));
-        this.provider.register('contextHandlerRemoved', this.contextHandlerRemoved.bind(this));
-        this.provider.register('nonStandardHandlerRemoved', this.nonStandardHandlerRemoved.bind(this));
-        this.provider.register('onAddContextHandlerAdded', this.onAddContextHandlerAdded.bind(this));
-        this.provider.register('onDisconnectHandlerAdded', this.onDisconnectHandlerAdded.bind(this));
-        this.provider.register('onUnsubscribeHandlerAdded', this.onUnsubscribeHandlerAdded.bind(this));
-        this.provider.register('clientDisconnecting', (payload, clientIdentity) => {
-            this.handleClientDisconnecting(clientIdentity);
-        });
-    }
-    broadcast(payload, broadcasterClientIdentity) {
-        const { context } = payload;
-        const broadcasterClientState = this.getClientState(broadcasterClientIdentity);
-        if (!broadcasterClientState) {
-            throw new Error(`Client with Identity: ${broadcasterClientIdentity.uuid} ${broadcasterClientIdentity.name}, tried to call broadcast, is not connected to this Private Channel`);
-        }
-        const contextIntegrityCheckResult = InteropBroker_1.InteropBroker.checkContextIntegrity(context);
-        if (contextIntegrityCheckResult.isValid === false) {
-            throw new Error(`Failed to broadcast - bad Context. Reason: ${contextIntegrityCheckResult.reason}. Context: ${JSON.stringify(context)}`);
-        }
-        this.contextByContextType.set(context.type, context);
-        this.lastContext = context;
-        Array.from(this.clients.values()).forEach((currClientState) => {
-            const handlerIdsForContextType = currClientState.handlerIdsByContextTypes.get(context.type);
-            if (handlerIdsForContextType) {
-                handlerIdsForContextType.forEach((handlerId) => {
-                    this.provider.dispatch(currClientState.clientIdentity, handlerId, context);
-                });
-            }
-            if (currClientState.globalHandler) {
-                this.provider.dispatch(currClientState.clientIdentity, currClientState.globalHandler, context);
-            }
-        });
-    }
-    getCurrentContext(payload, senderClientIdentity) {
-        const { contextType } = payload;
-        const clientState = this.getClientState(senderClientIdentity);
-        if (!clientState) {
-            throw new Error(`Client with Identity: ${senderClientIdentity.uuid} ${senderClientIdentity.name}, tried to call getCurrentContext, is not connected to this Private Channel`);
-        }
-        if (contextType !== undefined) {
-            const currentContext = this.contextByContextType.get(contextType);
-            if (currentContext)
-                return currentContext;
-            return null;
-        }
-        return this.lastContext ? this.lastContext : null;
-    }
-    contextHandlerAdded(payload, senderClientIdentity) {
-        const { handlerId, contextType } = payload;
-        const senderClientState = this.getClientState(senderClientIdentity);
-        if (!senderClientState) {
-            throw new Error(`Client with Identity: ${senderClientIdentity.uuid} ${senderClientIdentity.name}, tried to call addContextListener, is not connected to this Private Channel`);
-        }
-        if (contextType) {
-            const currentHandlersList = senderClientState.handlerIdsByContextTypes.get(contextType) || [];
-            senderClientState.handlerIdsByContextTypes.set(contextType, [...currentHandlersList, handlerId]);
-        }
-        else {
-            senderClientState.globalHandler = handlerId;
-        }
-        Array.from(this.clients.values()).forEach((currClientState) => {
-            if (currClientState.clientIdentity.endpointId !== senderClientIdentity.endpointId &&
-                currClientState.onAddContextListenerHandlerId) {
-                this.provider.dispatch(currClientState.clientIdentity, currClientState.onAddContextListenerHandlerId, contextType);
-            }
-        });
-    }
-    async contextHandlerRemoved(payload, removingClientIdentity) {
-        // MC: Made this removal async to ensure that onUnsubscribe handlers are hit before anything else happens.
-        const { handlerId } = payload;
-        const removingClientState = this.getClientState(removingClientIdentity);
-        if (removingClientState) {
-            let contextType;
-            if (removingClientState.globalHandler === handlerId) {
-                removingClientState.globalHandler = undefined;
-            }
-            else {
-                for (const [currContextType, handlersIds] of removingClientState.handlerIdsByContextTypes) {
-                    const index = handlersIds.indexOf(handlerId);
-                    if (index > -1) {
-                        handlersIds.splice(index, 1);
-                        contextType = currContextType;
-                    }
-                }
-            }
-            // getting only valid client connections here, it is possible we haven't removed a disconnected client from the map yet
-            // so we need to ensure we don't dispatch to any disconnected client
-            // TODO: Take a look at our client disconnection logic and see if we can handle client disconnection cleanly
-            const clientsToDispatchTo = await this.getConnectedClients();
-            const dispatchPromises = clientsToDispatchTo.map(async (otherClientState) => {
-                const { clientIdentity, clientIdentity: { endpointId }, onUnsubscribeHandlerId } = otherClientState;
-                if (endpointId !== removingClientIdentity.endpointId && onUnsubscribeHandlerId) {
-                    await this.provider.dispatch(clientIdentity, onUnsubscribeHandlerId, contextType);
-                }
-            });
-            try {
-                await Promise.all(dispatchPromises);
-            }
-            catch (error) {
-                console.error(`Problem when attempting to dispatch to onUnsubscribeHandlers. Error: ${error} Removing Client: ${handlerId}. uuid: ${removingClientIdentity.uuid}. name: ${removingClientIdentity.name}. endpointId: ${removingClientIdentity.endpointId}`);
-                throw new Error(error);
-            }
-        }
-        else {
-            console.warn(`Trying to remove a handler from a client that isn't mapped. handlerId: ${handlerId}. uuid: ${removingClientIdentity.uuid}. name: ${removingClientIdentity.name}. endpointId: ${removingClientIdentity.endpointId}.`);
-        }
-    }
-    nonStandardHandlerRemoved(payload, id) {
-        const { handlerId } = payload;
-        const clientState = this.getClientState(id);
-        if (clientState) {
-            if (clientState.onDisconnectHandlerId === handlerId) {
-                clientState.onDisconnectHandlerId = undefined;
-            }
-            else if (clientState.onAddContextListenerHandlerId === handlerId) {
-                clientState.onAddContextListenerHandlerId = undefined;
-            }
-            else if (clientState.onUnsubscribeHandlerId === handlerId) {
-                clientState.onUnsubscribeHandlerId = undefined;
-            }
-        }
-        else {
-            console.warn(`Trying to remove a handler from a client that isn't mapped. handlerId: ${handlerId}. clientIdentity: ${id}`);
-        }
-    }
-    onAddContextHandlerAdded(payload, senderClientIdentity) {
-        const clientState = this.getClientState(senderClientIdentity);
-        const { handlerId } = payload;
-        if (!clientState) {
-            throw new Error(`Client with Identity: ${senderClientIdentity.uuid} ${senderClientIdentity.name}, tried to call onAddContextListener, is not connected to this Private Channel`);
-        }
-        clientState.onAddContextListenerHandlerId = handlerId;
-        // FDC3 Spec says that the added listener should fire for all previously-registered addContextListeners from the other client
-        Array.from(this.clients.values()).forEach((otherClientState) => {
-            if (otherClientState.clientIdentity.endpointId !== senderClientIdentity.endpointId) {
-                Array.from(otherClientState.handlerIdsByContextTypes.keys()).forEach((subscribedContextType) => {
-                    this.provider.dispatch(senderClientIdentity, handlerId, subscribedContextType);
-                });
-            }
-        });
-    }
-    onDisconnectHandlerAdded(payload, id) {
-        const clientState = this.getClientState(id);
-        const { handlerId } = payload;
-        if (!clientState) {
-            throw new Error(`Client with Identity: ${id.uuid} ${id.name}, tried to call onDisconnect, is not connected to this Private Channel`);
-        }
-        clientState.onDisconnectHandlerId = handlerId;
-    }
-    onUnsubscribeHandlerAdded(payload, id) {
-        const clientState = this.getClientState(id);
-        const { handlerId } = payload;
-        if (!clientState) {
-            throw new Error(`Client with Identity: ${id.uuid} ${id.name}, tried to call onUnsubscribe, is not connected to this Private Channel`);
-        }
-        clientState.onUnsubscribeHandlerId = handlerId;
-    }
-    removeClient(disconnectingClientIdentity) {
-        const disconnectingClientState = this.getClientState(disconnectingClientIdentity);
-        if (!disconnectingClientState) {
-            throw new Error(`Client with Identity: ${disconnectingClientIdentity.uuid} ${disconnectingClientIdentity.name}, tried to call disconnect, is not connected to this Private Channel`);
-        }
-        disconnectingClientState.handlerIdsByContextTypes.clear();
-        this.clients.delete(disconnectingClientIdentity.endpointId);
-    }
-    async fireOnDisconnectForOtherClients(disconnectingClientIdentity) {
-        // TODO: call onDisconnect Handler of the other client only.
-        // CURRENTLY, just calling the onDisconnect handler for all the other clients. Once we limit it to just one other client, we can eliminate all the iteration code.
-        const { endpointId } = disconnectingClientIdentity;
-        // getting only valid client connections here, it is possible we haven't removed a disconnected client from the map yet
-        // so we need to ensure we don't dispatch to any disconnected client
-        // TODO: Take a look at our client disconnection logic and see if we can handle client disconnection cleanly
-        const clientsToDispatchTo = await this.getConnectedClients();
-        const dispatchPromises = clientsToDispatchTo.map(async (otherClientState) => {
-            const { clientIdentity: { endpointId: otherClientEndpointId }, onDisconnectHandlerId } = otherClientState;
-            if (otherClientEndpointId !== endpointId && onDisconnectHandlerId) {
-                await this.provider.dispatch(otherClientState.clientIdentity, onDisconnectHandlerId);
-            }
-        });
-        try {
-            await Promise.all(dispatchPromises);
-        }
-        catch (error) {
-            console.error(`Problem when attempting to dispatch to onDisconnectHandlers. Error: ${error} Disconnecting Client: uuid: ${disconnectingClientIdentity.uuid}. name: ${disconnectingClientIdentity.name}. endpointId: ${disconnectingClientIdentity.endpointId}`);
-            throw new Error(error);
-        }
-    }
-    async unsubscribeAll(clientIdentity) {
-        const { endpointId } = clientIdentity;
-        const state = this.clients.get(endpointId);
-        if (state) {
-            const contextTypeHandlerIds = Array.from(state.handlerIdsByContextTypes.values()).flat();
-            const globalHandlerId = state.globalHandler;
-            if (contextTypeHandlerIds.length > 0) {
-                const unsubPromises = contextTypeHandlerIds.map(async (handlerId) => {
-                    return this.contextHandlerRemoved({ handlerId }, clientIdentity);
-                });
-                try {
-                    await Promise.all(unsubPromises);
-                }
-                catch (error) {
-                    console.error(error.message);
-                }
-            }
-            if (globalHandlerId) {
-                try {
-                    await this.contextHandlerRemoved({ handlerId: globalHandlerId }, clientIdentity);
-                }
-                catch (error) {
-                    console.error(error.message);
-                }
-            }
-        }
-    }
-    async handleClientDisconnecting(disconnectingClientIdentity) {
-        await this.unsubscribeAll(disconnectingClientIdentity);
-        this.removeClient(disconnectingClientIdentity);
-        await this.fireOnDisconnectForOtherClients(disconnectingClientIdentity);
-    }
-    registerNewClient(clientIdentity) {
-        if (!this.clients.has(clientIdentity.endpointId)) {
-            const clientSubscriptionState = {
-                clientIdentity,
-                handlerIdsByContextTypes: new Map(),
-                globalHandler: undefined,
-                onAddContextListenerHandlerId: undefined,
-                onUnsubscribeHandlerId: undefined,
-                onDisconnectHandlerId: undefined
-            };
-            this.clients.set(clientIdentity.endpointId, clientSubscriptionState);
-        }
-    }
-    async getConnectedClients() {
-        const allClientInfo = await this.provider.getAllClientInfo();
-        return Array.from(this.clients.values()).filter((clientState) => {
-            const { uuid, name } = clientState.clientIdentity;
-            return allClientInfo.some((clientInfo) => {
-                return name === clientInfo.name && uuid === clientInfo.uuid;
-            });
-        });
-    }
-    static init(channelProvider, id) {
-        return new PrivateChannelProvider(channelProvider, id);
-    }
-}
-exports.PrivateChannelProvider = PrivateChannelProvider;

package/src/api/interop/fdc3/documentationStub.d.ts

@@ -1,14 +0,0 @@
-/**
- * Prior to the move to TypeDoc, OpenFin maintained a copy of the FDC3 documentation under this namespace.  To avoid
- * duplication, these types have been removed from the OpenFin documentation.
- *
- * These types can be found in the official FDC3 documentation at https://fdc3.finos.org/docs/api/ref/Types.
- *
- * @packageDocumentation
- */
-/**
- * @hidden
- *
- * Export required to allow import into typedoc entry point.
- */
-export declare const placeholder = "placeholder";

package/src/api/interop/fdc3/documentationStub.js

@@ -1,17 +0,0 @@
-"use strict";
-/**
- * Prior to the move to TypeDoc, OpenFin maintained a copy of the FDC3 documentation under this namespace.  To avoid
- * duplication, these types have been removed from the OpenFin documentation.
- *
- * These types can be found in the official FDC3 documentation at https://fdc3.finos.org/docs/api/ref/Types.
- *
- * @packageDocumentation
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.placeholder = void 0;
-/**
- * @hidden
- *
- * Export required to allow import into typedoc entry point.
- */
-exports.placeholder = 'placeholder';

package/src/api/interop/fdc3/fdc3-1.2.d.ts

@@ -1,205 +0,0 @@
-import type * as FDC3v1 from './shapes/fdc3v1';
-import { Base } from '../../base';
-/**
- * @typedef { object } Listener
- * @summary Listener object returned by addContextListener and addIntentListener
- * @property {function} unsubscribe function for addContextListener and addIntentListener.
- */
-/**
- * @typedef { object } Channel
- * @summary Information for a Context Group. Contains metadata for displaying the group properly.
- * @property {string} id Name of the context group
- * @property {DisplayMetadata} displayMetadata Metadata for the Context Group. Contains the group's human-readable name, color, and an image, as defined by the Interop Broker.
- * @property {string} type Defaults to system.
- * @property {function} broadcast Broadcasts a context for the channel.
- * @property {function} addContextListener Add a context handler for incoming context.
- * @property {function} getCurrentContext Gets the current context for the channel.
- */
-/**
- * @typedef  { object } AppMetadata
- * @summary App metadata is provided by the FDC3 App Directory.
- * @property {string} name
- * @property {string} [appId]
- * @property {string} [version]
- * @property {string} [title]
- * @property {string} [tooltip]
- * @property {string} [description]
- * @property {Array<string>} [icons]
- * @property {Array<string>} [images]
- */
-/**
- * @typedef { string | AppMetadata } TargetApp
- * @summary Some operations can identify an app just by its name, or pass full app metadata.
- */
-/**
- * @typedef { object } IntentResolution
- * @summary IntentResolution provides a standard format for data returned upon resolving an Intent.
- * @property { TargetApp } source identifier for the Application resolving the Intent (null if the Intent could not be resolved)
- * @property { string } [data] Return data structure - if one is provided for the given Intent.
- * @property { string } version The version number of the Intents schema being used
- */
-/**
- * @typedef { object } AppIntent
- * @summary An interface that represents the binding of an intent to apps.
- * @property { Intent } intent
- * @property { Array<AppMetadata> } apps
- */
-/**
- * @typedef { object } ImplementationMetadata
- * @summary An interface that represents FDC3 implementation meta data.
- * @property { string } fdc3Version The FDC3 version
- * @property { string } provider The provider uuid with prepend 'openfin'
- * @property { string } [providerVersion] The provider runtime version
- */
-/**
- * @version 1.2
- * The FDC3 Client Library provides a set APIs to be used for FDC3 compliance,
- * while using our Interop API under the hood. In order to use this set of APIs
- * you will need to set up your own {@link InteropBroker InteropBroker} or use a Platform application, which does the setup for you. Refer to our documentation on
- * our {@link https://developers.openfin.co/of-docs/docs/enable-color-linking Interop API}.
- *
- * To enable the FDC3 APIs in a {@link Window Window} or {@link View View}, add the fdc3InteropApi
- * property to its options:
- *
- * ```js
- * {
- *     autoShow: false,
- *     saveWindowState: true,
- *     url: 'https://openfin.co',
- *     fdc3InteropApi: '1.2'
- * }
- * ```
- *
- * If using a {@link Platform Platform } application, you can set this property in defaultWindowOptions and defaultViewOptions.
- *
- * In order to ensure that the FDC3 Api is ready before use, you can use the 'fdc3Ready' event fired on the DOM Window object:
- *
- * ```js
- * function fdc3Action() {
- *     // Make some fdc3 API calls here
- * }
- *
- * if (window.fdc3) {
- *    fdc3Action();
- * } else {
- *    window.addEventListener('fdc3Ready', fdc3Action);
- * }
- * ```
- */
-export default class Fdc3Module extends Base implements FDC3v1.DesktopAgent {
-    /**
-     * Add a context handler for incoming context. If an entity is part of a context group, and then sets its context handler, it will receive all of its declared contexts. If you wish to listen for all incoming contexts, pass `null` for the contextType argument.
-     * @param contextType - The type of context you wish to handle.
-     * @param handler - Handler for incoming context.
-     *
-     * @tutorial fdc3.addContextListener
-     * @static
-     */
-    addContextListener(contextType: string | null, handler: FDC3v1.ContextHandler): FDC3v1.Listener & Promise<FDC3v1.Listener>;
-    /**
-     * Broadcasts a context for the channel of the current entity.
-     * @param context - New context to set.
-     *
-     * @tutorial fdc3.broadcast
-     * @static
-     */
-    broadcast(context: FDC3v1.Context): Promise<void>;
-    /**
-     * Returns the Interop-Broker-defined context groups available for an entity to join.
-     *
-     * @tutorial fdc3.getSystemChannels
-     * @static
-     */
-    getSystemChannels(): Promise<FDC3v1.SystemChannel[]>;
-    /**
-     * Join all Interop Clients at the given identity to context group `contextGroupId`.
-     * If no target is specified, it adds the sender to the context group.
-     * Because multiple Channel connections/Interop Clients can potentially exist at a `uuid`/`name` combo, we currently join all Channel connections/Interop Clients at the given identity to the context group.
-     * If an `endpointId` is provided (which is unlikely, unless the call is coming from an external adapter), then we only join that single connection to the context group.
-     * For all intents and purposes, there will only be 1 connection present in Platform and Browser implementations, so this point is more-or-less moot.
-     * @param channelId - Id of the context group.
-     *
-     * @tutorial fdc3.joinChannel
-     * @static
-     */
-    joinChannel(channelId: string): Promise<void>;
-    /**
-     * Removes the specified target from a context group.
-     * If no target is specified, it removes the sender from their context group.
-     *
-     * @tutorial fdc3.leaveCurrentChannel
-     * @static
-     */
-    leaveCurrentChannel(): Promise<void>;
-    /**
-     * Adds a listener for incoming Intents.
-     * @param intent - Name of the Intent
-     * @param handler - Handler for incoming Intent
-     *
-     * @tutorial fdc3.addIntentListener
-     * @static
-     */
-    addIntentListener(intent: string, handler: FDC3v1.ContextHandler): FDC3v1.Listener & Promise<FDC3v1.Listener>;
-    /**
-     * Raises a specific intent.
-     * @param intent Name of the Intent.
-     * @param context Context associated with the Intent.
-     * @param  app App that will resolve the Intent. This is added as metadata to the Intent. Can be accessed by the app provider in {@link InteropBroker#handleFiredIntent InteropBroker.handleFiredIntent}.
-     *
-     * @tutorial fdc3.raiseIntent
-     * @static
-     */
-    raiseIntent(intent: string, context: FDC3v1.Context, app?: FDC3v1.TargetApp): Promise<FDC3v1.IntentResolution>;
-    /**
-     * Returns the Channel that the entity is subscribed to. Returns null if not joined to a channel.
-     *
-     * @tutorial fdc3.getCurrentChannel
-     */
-    getCurrentChannel(): Promise<FDC3v1.Channel | null>;
-    /**
-     * Find out more information about a particular intent by passing its name, and optionally its context.
-     * @param intent Name of the Intent
-     * @param context
-     *
-     * @tutorial fdc3.findIntent
-     */
-    findIntent(intent: string, context?: FDC3v1.Context): Promise<FDC3v1.AppIntent>;
-    /**
-     * Find all the available intents for a particular context.
-     * @param context
-     *
-     * @tutorial fdc3.findIntentsByContext
-     */
-    findIntentsByContext(context: FDC3v1.Context): Promise<Array<FDC3v1.AppIntent>>;
-    /**
-     * Finds and raises an intent against a target app based purely on context data.
-     * @param context
-     * @param app
-     *
-     * @tutorial fdc3.raiseIntentForContext
-     */
-    raiseIntentForContext(context: FDC3v1.Context, app?: FDC3v1.TargetApp): Promise<FDC3v1.IntentResolution>;
-    /**
-     * Returns a Channel object for the specified channel, creating it as an App Channel if it does not exist.
-     * @param channelId
-     *
-     * @tutorial fdc3.getOrCreateChannel
-     */
-    getOrCreateChannel(channelId: string): Promise<FDC3v1.Channel>;
-    /**
-     * Returns metadata relating to the FDC3 object and its provider, including the supported version of the FDC3 specification and the name of the provider of the implementation.
-     *
-     * @tutorial fdc3.getInfo
-     */
-    getInfo(): FDC3v1.ImplementationMetadata;
-    /**
-     * Launches an app with target information, which can either be a string or an AppMetadata object.
-     * @param app
-     * @param context
-     *
-     * @tutorial fdc3.open
-     */
-    open(app: FDC3v1.TargetApp, context?: FDC3v1.Context): Promise<void>;
-    private getCurrentContextGroupInfo;
-    private buildChannelObject;
-}