@openfin/core 33.76.36 → 33.77.1

package/src/api/interop/SessionContextGroupBroker.d.ts

@@ -1,27 +0,0 @@
-import type * as OpenFin from '../../OpenFin';
-import type { ChannelProvider } from '../interappbus/channel/provider';
-export default class SessionContextGroupBroker {
-    id: string;
-    private contextGroupMap;
-    private provider;
-    private clients;
-    private lastContext;
-    constructor(provider: ChannelProvider, id: string);
-    registerListeners(): void;
-    getCurrentContext(payload: {
-        type?: string;
-    }): OpenFin.Context | undefined;
-    setContext(payload: {
-        context: OpenFin.Context;
-    }, clientIdentity: OpenFin.ClientIdentity): void;
-    private getClientState;
-    handlerAdded(payload: {
-        handlerId: string;
-        contextType?: string;
-    }, clientIdentity: OpenFin.ClientIdentity): Promise<void>;
-    handlerRemoved(payload: {
-        handlerId: string;
-    }, clientIdentity: OpenFin.ClientIdentity): void;
-    registerNewClient(clientIdentity: OpenFin.ClientIdentity): void;
-    onDisconnection(clientIdentity: OpenFin.ClientIdentity): void;
-}

package/src/api/interop/SessionContextGroupBroker.js

@@ -1,108 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const _1 = require(".");
-class SessionContextGroupBroker {
-    constructor(provider, id) {
-        this.provider = provider;
-        this.id = id;
-        this.lastContext = undefined;
-        this.contextGroupMap = new Map();
-        this.clients = new Map();
-        this.registerListeners();
-    }
-    registerListeners() {
-        this.provider.register(`sessionContextGroup:getContext-${this.id}`, this.getCurrentContext.bind(this));
-        this.provider.register(`sessionContextGroup:setContext-${this.id}`, this.setContext.bind(this));
-        this.provider.register(`sessionContextGroup:handlerAdded-${this.id}`, this.handlerAdded.bind(this));
-        this.provider.register(`sessionContextGroup:handlerRemoved-${this.id}`, this.handlerRemoved.bind(this));
-    }
-    getCurrentContext(payload) {
-        return payload.type ? this.contextGroupMap.get(payload.type) : this.lastContext;
-    }
-    setContext(payload, clientIdentity) {
-        const { context } = payload;
-        const contextIntegrityCheckResult = _1.InteropBroker.checkContextIntegrity(context);
-        if (contextIntegrityCheckResult.isValid === false) {
-            throw new Error(`Failed to set Context - bad Context. Reason: ${contextIntegrityCheckResult.reason}. Context: ${JSON.stringify(context)}`);
-        }
-        const clientState = this.getClientState(clientIdentity);
-        if (!clientState) {
-            // This shouldn't get hit.
-            throw new Error(`Client with Identity: ${clientIdentity.uuid} ${clientIdentity.name} not in Session Client State Map`);
-        }
-        // set the context
-        this.contextGroupMap.set(context.type, context);
-        this.lastContext = context;
-        const clientSubscriptionStates = Array.from(this.clients.values());
-        clientSubscriptionStates.forEach((client) => {
-            var _a;
-            // eslint-disable-next-line no-unused-expressions
-            (_a = client.contextHandlers.get(context.type)) === null || _a === void 0 ? void 0 : _a.forEach((handlerId) => {
-                this.provider.dispatch(client.clientIdentity, handlerId, context);
-            });
-            if (client.globalHandler) {
-                this.provider.dispatch(client.clientIdentity, client.globalHandler, context);
-            }
-        });
-    }
-    getClientState(id) {
-        return this.clients.get(id.endpointId);
-    }
-    async handlerAdded(payload, clientIdentity) {
-        const { handlerId, contextType } = payload;
-        const clientSubscriptionState = this.getClientState(clientIdentity);
-        if (!clientSubscriptionState) {
-            throw new Error(`Client with Identity: ${clientIdentity.uuid} ${clientIdentity.name} not in Client State Map`);
-        }
-        if (contextType) {
-            const currentHandlerList = clientSubscriptionState.contextHandlers.get(contextType) || [];
-            clientSubscriptionState.contextHandlers.set(contextType, [...currentHandlerList, handlerId]);
-            const currentContext = this.contextGroupMap.get(contextType);
-            if (currentContext) {
-                await this.provider.dispatch(clientIdentity, handlerId, currentContext);
-            }
-        }
-        else {
-            clientSubscriptionState.globalHandler = handlerId;
-            const globalDispatchPromises = [...this.contextGroupMap.keys()].map(async (currentContextType) => {
-                const currentContext = this.contextGroupMap.get(currentContextType);
-                if (currentContext) {
-                    await this.provider.dispatch(clientIdentity, handlerId, currentContext);
-                }
-            });
-            await Promise.all(globalDispatchPromises);
-        }
-    }
-    handlerRemoved(payload, clientIdentity) {
-        const { handlerId } = payload;
-        const client = this.clients.get(clientIdentity.endpointId);
-        if (client) {
-            Array.from(client.contextHandlers).forEach(([, handlers]) => {
-                const index = handlers.indexOf(handlerId);
-                if (index > -1) {
-                    handlers.splice(index, 1);
-                }
-            });
-            if (client.globalHandler === handlerId) {
-                client.globalHandler = undefined;
-            }
-        }
-        else {
-            console.warn(`Trying to remove a handler from a client that isn't mapped. handlerId: ${handlerId}. clientIdentity: ${clientIdentity}`);
-        }
-    }
-    registerNewClient(clientIdentity) {
-        if (!this.clients.has(clientIdentity.endpointId)) {
-            const clientSubscriptionState = {
-                contextHandlers: new Map(),
-                clientIdentity,
-                globalHandler: undefined
-            };
-            this.clients.set(clientIdentity.endpointId, clientSubscriptionState);
-        }
-    }
-    onDisconnection(clientIdentity) {
-        this.clients.delete(clientIdentity.endpointId);
-    }
-}
-exports.default = SessionContextGroupBroker;

package/src/api/interop/SessionContextGroupClient.d.ts

@@ -1,21 +0,0 @@
-import type * as OpenFin from '../../OpenFin';
-import { Transport } from '../../transport/transport';
-import { Base } from '../base';
-export default class SessionContextGroupClient extends Base {
-    #private;
-    id: string;
-    constructor(wire: Transport, client: Promise<OpenFin.ChannelClient>, id: string);
-    /**
-     * Sets a context for the session context group.
-     * @param context - New context to set.
-     *
-     * @tutorial interop.setContext
-     */
-    setContext(context: OpenFin.Context): Promise<void>;
-    getCurrentContext(type?: string): Promise<OpenFin.Context>;
-    addContextHandler(contextHandler: OpenFin.ContextHandler, contextType?: string): Promise<{
-        unsubscribe: () => void;
-    }>;
-    private createUnsubscribeCb;
-    getUserInstance(): OpenFin.SessionContextGroup;
-}

package/src/api/interop/SessionContextGroupClient.js

@@ -1,86 +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 _SessionContextGroupClient_clientPromise;
-Object.defineProperty(exports, "__esModule", { value: true });
-const base_1 = require("../base");
-const utils_1 = require("./utils");
-class SessionContextGroupClient extends base_1.Base {
-    constructor(wire, client, id) {
-        super(wire);
-        _SessionContextGroupClient_clientPromise.set(this, void 0);
-        this.id = id;
-        __classPrivateFieldSet(this, _SessionContextGroupClient_clientPromise, client, "f");
-    }
-    /**
-     * Sets a context for the session context group.
-     * @param context - New context to set.
-     *
-     * @tutorial interop.setContext
-     */
-    async setContext(context) {
-        this.wire.sendAction('interop-session-context-group-set-context').catch((e) => {
-            // don't expose, analytics-only call
-        });
-        const client = await __classPrivateFieldGet(this, _SessionContextGroupClient_clientPromise, "f");
-        return client.dispatch(`sessionContextGroup:setContext-${this.id}`, {
-            sessionContextGroupId: this.id,
-            context
-        });
-    }
-    async getCurrentContext(type) {
-        this.wire.sendAction('interop-session-context-group-get-context').catch((e) => {
-            // don't expose, analytics-only call
-        });
-        const client = await __classPrivateFieldGet(this, _SessionContextGroupClient_clientPromise, "f");
-        return client.dispatch(`sessionContextGroup:getContext-${this.id}`, {
-            sessionContextGroupId: this.id,
-            type
-        });
-    }
-    async addContextHandler(contextHandler, contextType) {
-        this.wire.sendAction('interop-session-context-group-add-handler').catch((e) => {
-            // don't expose, analytics-only call
-        });
-        if (typeof contextHandler !== 'function') {
-            throw new Error("Non-function argument passed to the first parameter 'handler'. Be aware that the argument order does not match the FDC3 standard.");
-        }
-        const client = await __classPrivateFieldGet(this, _SessionContextGroupClient_clientPromise, "f");
-        let handlerId;
-        if (contextType) {
-            handlerId = `sessionContextHandler:invoke-${this.id}-${contextType}-${(0, utils_1.generateId)()}`;
-        }
-        else {
-            handlerId = `sessionContextHandler:invoke-${this.id}`;
-        }
-        client.register(handlerId, (0, utils_1.wrapContextHandler)(contextHandler, handlerId));
-        await client.dispatch(`sessionContextGroup:handlerAdded-${this.id}`, { handlerId, contextType });
-        return { unsubscribe: await this.createUnsubscribeCb(handlerId) };
-    }
-    async createUnsubscribeCb(handlerId) {
-        const client = await __classPrivateFieldGet(this, _SessionContextGroupClient_clientPromise, "f");
-        return async () => {
-            client.remove(handlerId);
-            await client.dispatch(`sessionContextGroup:handlerRemoved-${this.id}`, { handlerId });
-        };
-    }
-    getUserInstance() {
-        return {
-            id: this.id,
-            setContext: (0, utils_1.wrapInTryCatch)(this.setContext.bind(this), 'Failed to set context: '),
-            getCurrentContext: (0, utils_1.wrapInTryCatch)(this.getCurrentContext.bind(this), 'Failed to get context: '),
-            addContextHandler: (0, utils_1.wrapInTryCatch)(this.addContextHandler.bind(this), 'Failed to add context handler: ')
-        };
-    }
-}
-exports.default = SessionContextGroupClient;
-_SessionContextGroupClient_clientPromise = new WeakMap();

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

@@ -1,20 +0,0 @@
-import type * as OpenFin from '../../../OpenFin';
-import type { Listener, Context, ContextHandler } from './shapes/fdc3v2';
-type HandlerId = string;
-export declare class PrivateChannelClient {
-    id: string;
-    client: OpenFin.ChannelClient;
-    listeners: Map<HandlerId, Listener>;
-    constructor(client: OpenFin.ChannelClient, id: string);
-    broadcast(context: Context): Promise<void>;
-    getCurrentContext(contextType?: string): Promise<Context | null>;
-    addContextListener(contextType: string | null, handler: ContextHandler): Promise<Listener>;
-    private createNonStandardUnsubscribeCb;
-    private createContextUnsubscribeCb;
-    onAddContextListener(handler: (contextType?: string) => void): Listener;
-    onDisconnect(handler: () => void): Listener;
-    onUnsubscribe(handler: (contextType?: string) => void): Listener;
-    cleanUpAllSubs(): Promise<void>;
-    disconnect(): Promise<void>;
-}
-export {};

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

@@ -1,90 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.PrivateChannelClient = void 0;
-const utils_1 = require("../utils");
-class PrivateChannelClient {
-    constructor(client, id) {
-        this.id = id;
-        this.client = client;
-        this.listeners = new Map();
-    }
-    async broadcast(context) {
-        return this.client.dispatch('broadcast', { context });
-    }
-    async getCurrentContext(contextType) {
-        return this.client.dispatch('getCurrentContext', { contextType });
-    }
-    async addContextListener(contextType, handler) {
-        if (typeof handler !== 'function') {
-            throw new Error("Non-function argument passed to the second parameter 'handler'. Be aware that the argument order does not match the FDC3 standard.");
-        }
-        let handlerId;
-        if (contextType) {
-            handlerId = `contextHandler:invoke-${this.id}-${contextType}-${(0, utils_1.generateId)()}`;
-        }
-        else {
-            handlerId = `contextHandler:invoke-${this.id}-${(0, utils_1.generateId)()}`;
-        }
-        this.client.register(handlerId, (0, utils_1.wrapContextHandler)(handler, handlerId));
-        const listener = { unsubscribe: await this.createContextUnsubscribeCb(handlerId) };
-        this.listeners.set(handlerId, listener);
-        await this.client.dispatch(`contextHandlerAdded`, { handlerId, contextType });
-        return listener;
-    }
-    createNonStandardUnsubscribeCb(handlerId) {
-        return async () => {
-            this.client.remove(handlerId);
-            this.listeners.delete(handlerId);
-            await this.client.dispatch('nonStandardHandlerRemoved', { handlerId });
-        };
-    }
-    createContextUnsubscribeCb(handlerId) {
-        return async () => {
-            this.client.remove(handlerId);
-            this.listeners.delete(handlerId);
-            await this.client.dispatch('contextHandlerRemoved', { handlerId });
-        };
-    }
-    onAddContextListener(handler) {
-        const handlerId = `onContextHandlerAdded:invoke-${this.id}-${(0, utils_1.generateId)()}`;
-        this.client.register(handlerId, handler);
-        const listener = { unsubscribe: this.createNonStandardUnsubscribeCb(handlerId) };
-        this.listeners.set(handlerId, listener);
-        this.client.dispatch(`onAddContextHandlerAdded`, { handlerId });
-        return listener;
-    }
-    onDisconnect(handler) {
-        const handlerId = `onDisconnect:invoke-${this.id}-${(0, utils_1.generateId)()}`;
-        this.client.register(handlerId, handler);
-        const listener = { unsubscribe: this.createNonStandardUnsubscribeCb(handlerId) };
-        this.listeners.set(handlerId, listener);
-        this.client.dispatch(`onDisconnectHandlerAdded`, { handlerId });
-        return listener;
-    }
-    onUnsubscribe(handler) {
-        const handlerId = `onUnsubscribe:invoke-${this.id}-${(0, utils_1.generateId)()}`;
-        this.client.register(handlerId, handler);
-        const listener = { unsubscribe: this.createNonStandardUnsubscribeCb(handlerId) };
-        this.listeners.set(handlerId, listener);
-        this.client.dispatch(`onUnsubscribeHandlerAdded`, { handlerId });
-        return listener;
-    }
-    async cleanUpAllSubs() {
-        const listenerUnsubscribers = Array.from(this.listeners.keys());
-        listenerUnsubscribers.forEach((handlerId) => {
-            this.client.remove(handlerId);
-            this.listeners.delete(handlerId);
-        });
-    }
-    async disconnect() {
-        try {
-            await this.client.dispatch('clientDisconnecting');
-            await this.cleanUpAllSubs();
-            await this.client.disconnect();
-        }
-        catch (error) {
-            throw new Error(error.message);
-        }
-    }
-}
-exports.PrivateChannelClient = PrivateChannelClient;

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

@@ -1,55 +0,0 @@
-import type * as OpenFin from '../../../OpenFin';
-type ChannelProvider = OpenFin.ChannelProvider;
-type HandlerId = string;
-type ContextType = string;
-interface PrivateChannelClientState {
-    clientIdentity: OpenFin.ClientIdentity;
-    handlerIdsByContextTypes: Map<ContextType, HandlerId[]>;
-    globalHandler: HandlerId | undefined;
-    onAddContextListenerHandlerId: HandlerId | undefined;
-    onUnsubscribeHandlerId: HandlerId | undefined;
-    onDisconnectHandlerId: HandlerId | undefined;
-}
-export declare class PrivateChannelProvider {
-    id: string;
-    private provider;
-    private clients;
-    private contextByContextType;
-    private lastContext;
-    constructor(provider: ChannelProvider, id: string);
-    private getClientState;
-    registerListeners(): void;
-    broadcast(payload: {
-        context: OpenFin.Context;
-    }, broadcasterClientIdentity: OpenFin.ClientIdentity): void;
-    getCurrentContext(payload: {
-        contextType?: string;
-    }, senderClientIdentity: OpenFin.ClientIdentity): OpenFin.Context | null;
-    contextHandlerAdded(payload: {
-        handlerId: HandlerId;
-        contextType?: string;
-    }, senderClientIdentity: OpenFin.ClientIdentity): void;
-    contextHandlerRemoved(payload: {
-        handlerId: HandlerId;
-    }, removingClientIdentity: OpenFin.ClientIdentity): Promise<void>;
-    nonStandardHandlerRemoved(payload: {
-        handlerId: HandlerId;
-    }, id: OpenFin.ClientIdentity): void;
-    onAddContextHandlerAdded(payload: {
-        handlerId: HandlerId;
-    }, senderClientIdentity: OpenFin.ClientIdentity): void;
-    onDisconnectHandlerAdded(payload: {
-        handlerId: HandlerId;
-    }, id: OpenFin.ClientIdentity): void;
-    onUnsubscribeHandlerAdded(payload: {
-        handlerId: HandlerId;
-    }, id: OpenFin.ClientIdentity): void;
-    removeClient(disconnectingClientIdentity: OpenFin.ClientIdentity): void;
-    fireOnDisconnectForOtherClients(disconnectingClientIdentity: OpenFin.ClientIdentity): Promise<void>;
-    unsubscribeAll(clientIdentity: OpenFin.ClientIdentity): Promise<void>;
-    handleClientDisconnecting(disconnectingClientIdentity: OpenFin.ClientIdentity): Promise<void>;
-    registerNewClient(clientIdentity: OpenFin.ClientIdentity): void;
-    getConnectedClients(): Promise<PrivateChannelClientState[]>;
-    static init(channelProvider: OpenFin.ChannelProvider, id: string): PrivateChannelProvider;
-}
-export {};