@finsemble/finsemble-ui 1.0.0-beta-3 → 1.0.0-beta-6

package/clients/Interop/FinsembleDesktopAgent.js

@@ -1,813 +0,0 @@
-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 __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 _HeartbeatMonitor_declareDead, _HeartbeatMonitor_timeoutHandle, _HeartbeatMonitor_disconnectHandlers, _ChannelProxy_desktopAgent, _FinsembleDesktopAgent_connected, _FinsembleDesktopAgent_heartbeatMonitor, _FinsembleDesktopAgent_startHasBeenCalled, _FinsembleDesktopAgent_uuid, _FinsembleDesktopAgent_clientChannel, _FinsembleDesktopAgent_intentHandlers, _FinsembleDesktopAgent_contextHandlers, _FinsembleDesktopAgent_queue, _FinsembleDesktopAgent_routerClient, _FinsembleDesktopAgent_startup, _FinsembleDesktopAgent_FSBLVersion;
-import uuidv4 from "uuid-random";
-import { OpenError, ResolveError, } from "@finos/fdc3";
-import Logger from "../logger";
-import ConfigClient from "../configClient";
-import SystemManagerClient from "../../common/systemManagerClient";
-import { Globals } from "../../common/Globals";
-import { SERVER_CHANNEL } from "./types";
-import { mmAdd, mmRemove, errorAsString, } from "./types";
-const Uninitialized = "";
-/**
- * Heartbeats are used by the InteropService to detect dead fdc3 client connections. A connection
- * can die if a window crashes or is terminated. Heartbeats are also currently the only way to detect
- * that freestanding apps have closed, even gracefully.
- */
-class HeartbeatMonitor {
-    constructor() {
-        // If Finsemble sleeps (power saving mode) then heartbeats will slow to once per minute (this is a browser thing)
-        // So we only declare an app dead if a heartbeat isn't received for two minutes, even though normally we should
-        // expect to receive one every 10 seconds. Hopefully in the future we will have more reliable, router disconnection
-        // capabilities based on underlying transports such as WebSocket.
-        _HeartbeatMonitor_declareDead.set(this, 2 * 60 * 1000);
-        _HeartbeatMonitor_timeoutHandle.set(this, null);
-        // Contains onDisconnect()'s registered handlers
-        _HeartbeatMonitor_disconnectHandlers.set(this, []);
-    }
-    start() {
-        this.registerHeartbeat();
-    }
-    registerHeartbeat() {
-        // Got a heartbeat, so clear our death timer
-        clearTimeout(__classPrivateFieldGet(this, _HeartbeatMonitor_timeoutHandle, "f"));
-        Logger.system.debug(`FinsembleDesktopAgent: heartbeat received`);
-        // And start a new one
-        __classPrivateFieldSet(this, _HeartbeatMonitor_timeoutHandle, setTimeout(() => {
-            Logger.system.warn(`FinsembleDesktopAgent: No heartbeat received within ${__classPrivateFieldGet(this, _HeartbeatMonitor_declareDead, "f")}  milliseconds`);
-            this.notifyDisconnect();
-        }, __classPrivateFieldGet(this, _HeartbeatMonitor_declareDead, "f")), "f");
-    }
-    notifyDisconnect() {
-        console.warn("fdc3 has lost connectivity to the interop service. You may need to restart this app.");
-        __classPrivateFieldGet(this, _HeartbeatMonitor_disconnectHandlers, "f").forEach((handler) => {
-            handler(`No heartbeat received from interop service within ${__classPrivateFieldGet(this, _HeartbeatMonitor_declareDead, "f")}  milliseconds`);
-        });
-    }
-    onDisconnect(cb) {
-        __classPrivateFieldSet(this, _HeartbeatMonitor_disconnectHandlers, __classPrivateFieldGet(this, _HeartbeatMonitor_disconnectHandlers, "f").concat(cb), "f");
-    }
-    stop() {
-        clearTimeout(__classPrivateFieldGet(this, _HeartbeatMonitor_timeoutHandle, "f"));
-    }
-}
-_HeartbeatMonitor_declareDead = new WeakMap(), _HeartbeatMonitor_timeoutHandle = new WeakMap(), _HeartbeatMonitor_disconnectHandlers = new WeakMap();
-/**
- * Implements FDC3's Channel interface. All actual transmissions still occur through the desktop agent via private functions.
- */
-class ChannelProxy {
-    constructor(desktopAgent, id, type = "app") {
-        _ChannelProxy_desktopAgent.set(this, void 0);
-        __classPrivateFieldSet(this, _ChannelProxy_desktopAgent, desktopAgent, "f");
-        this.id = id;
-        this.type = type;
-    }
-    /**
-     * Broadcasts the given context on this channel. This is equivalent to joining the channel and then calling the
-     * top-level FDC3 `broadcast` function.
-     *
-     * Note that this function can be used without first joining the channel, allowing applications to broadcast on
-     * channels that they aren't a member of.
-     *
-     * `Error` with a string from the `ChannelError` enumeration.
-     */
-    broadcast(context) {
-        if (!context) {
-            throw new Error("Invalid arguments. The required context parameter is missing.");
-        }
-        __classPrivateFieldGet(this, _ChannelProxy_desktopAgent, "f").channelBroadcast(this.id, context);
-    }
-    /**
-     * Returns the last context that was broadcast on this channel. All channels initially have no context, until a
-     * context is broadcast on the channel. If there is not yet any context on the channel, this method
-     * will return `null`.
-     *
-     * The context of a channel will be captured regardless of how the context is broadcasted on this channel - whether
-     * using the top-level FDC3 `broadcast` function, or using the channel-level {@link broadcast} function on this
-     * object.
-     *
-     * Optionally a {@link contextType} can be provided, in which case the current context of the matching type will
-     * be returned (if any). Desktop agent implementations may decide to record contexts by type, in which case it will
-     * be possible to get the most recent context of the type specified, but this is not guaranteed.
-     *
-     * `Error` with a string from the `ChannelError` enumeration.
-     */
-    getCurrentContext(contextType) {
-        return __classPrivateFieldGet(this, _ChannelProxy_desktopAgent, "f").channelGetCurrentContext(this.id, contextType);
-    }
-    /**
-     * Adds a listener for incoming contexts whenever a broadcast happens on this channel.
-     */
-    addContextListener(contextTypeOrHandler, handler) {
-        if (contextTypeOrHandler === undefined) {
-            throw new Error("Invalid arguments. The contextTypeOrHandler parameter shouldn't be undefined.");
-        }
-        if (typeof contextTypeOrHandler !== "function" && !handler) {
-            throw new Error("Invalid arguments. The required handler parameter is missing.");
-        }
-        return __classPrivateFieldGet(this, _ChannelProxy_desktopAgent, "f").channelAddContextListener(this.id, contextTypeOrHandler, handler);
-    }
-}
-_ChannelProxy_desktopAgent = new WeakMap();
-/**
- * See https://stackoverflow.com/questions/45847399/friend-class-in-typescript for implementation of "friend" class
- */
-export class FinsembleDesktopAgent {
-    constructor({ routerClient, startup }) {
-        _FinsembleDesktopAgent_connected.set(this, false);
-        _FinsembleDesktopAgent_heartbeatMonitor.set(this, new HeartbeatMonitor());
-        // A lock that prevents start() from running multiple times
-        _FinsembleDesktopAgent_startHasBeenCalled.set(this, false);
-        // uuid is set in connect(), when startup.onReady
-        _FinsembleDesktopAgent_uuid.set(this, "");
-        _FinsembleDesktopAgent_clientChannel.set(this, `FSBL.FDC3.Client.${uuidv4()}`);
-        _FinsembleDesktopAgent_intentHandlers.set(this, {});
-        _FinsembleDesktopAgent_contextHandlers.set(this, {});
-        // Stores fdc3 calls that are received before a connection is established with the interop service
-        // Once a connection is established then the queue is released.
-        _FinsembleDesktopAgent_queue.set(this, []);
-        _FinsembleDesktopAgent_routerClient.set(this, void 0);
-        _FinsembleDesktopAgent_startup.set(this, void 0);
-        _FinsembleDesktopAgent_FSBLVersion.set(this, Uninitialized);
-        __classPrivateFieldSet(this, _FinsembleDesktopAgent_routerClient, routerClient, "f");
-        __classPrivateFieldSet(this, _FinsembleDesktopAgent_startup, startup, "f");
-        this.cacheFSBLVersion();
-        // Per 1.2 spec, dispatch this event as soon as the global fdc3 object exists and is ready to accept API calls.
-        // We should not wait until start() because in some circumstances, start() is not called *until* an API call is made.
-        // Skip this if the global Event class is undefined (if running in Node.js such as a unit test). Note: also needed to confirm window.dispatchEvent was available, perhaps because of latest Node version.
-        if (Globals.Event && Globals.dispatchEvent) {
-            const event = new Globals.Event("fdc3Ready");
-            Globals.dispatchEvent(event);
-        }
-    }
-    // Cache FSBL version for use by fdc3.getInfo.
-    async cacheFSBLVersion() {
-        // Since setFSBLVersion is async, there is a timing gap until FDC3 2.0 supports async getInfo(). However, the default for #FSBLVersion covers the gap for now.
-        // It's possible to close this gap now by not dispatching "fdc3Ready" until FSBLVersion is set, but doing that properly requires a change to the fdc3 preload and
-        // then breaks existing apps that don't wait as defined in 1.2 spec.
-        if (__classPrivateFieldGet(this, _FinsembleDesktopAgent_FSBLVersion, "f") == Uninitialized) {
-            __classPrivateFieldSet(this, _FinsembleDesktopAgent_FSBLVersion, "6.6.0", "f");
-        }
-        const { err, data: FSBLVersion } = await ConfigClient.getValue({ field: "finsemble.system.FSBLVersion" });
-        if (!err) {
-            __classPrivateFieldSet(this, _FinsembleDesktopAgent_FSBLVersion, FSBLVersion, "f");
-        }
-    }
-    fdc3Error(msg) {
-        return new Error(msg);
-    }
-    meta() {
-        return {
-            uuid: __classPrivateFieldGet(this, _FinsembleDesktopAgent_uuid, "f"),
-            href: window.document ? document.location.href : "",
-        };
-    }
-    handleHeartbeat() {
-        __classPrivateFieldGet(this, _FinsembleDesktopAgent_heartbeatMonitor, "f").registerHeartbeat();
-    }
-    triggerContextListeners(message) {
-        var _a, _b;
-        const { context } = message.payload;
-        let handlers;
-        // The targetSubscriberId field is set only when contexts are from an autoBroadcast. During autoBroadcast, one context is received for a specific
-        // subscriber (for addContextListener), or multiple contexts may be received in rapid fire (for joinChannel with existing subscribers).
-        // For all cases only the handler identified by targetSubscriberId is triggered.
-        //
-        // The need for targetSubscriberId is due to a channel having multiple listeners (based on context), with each of these context listeners potentially
-        // having multiple handlers. Without targetSubscriberId, autoBroadcast would go to all listeners, which isn't correct (ambiguity causes duplicate triggering).
-        //
-        // For a specific example, if the app adds a second global listener for any context (i.e. "*") then only that one new listener should trigger
-        // when the corresponding autoBroadcast message arrives with the latest context; targetSubscriberId ensures this by uniquely identifying
-        // the listener and it corresponding handler.
-        if (message.meta.targetSubscriberId) {
-            let targetHandlerSet;
-            // Find the subscriber's handler and save in targetHandlerSet. (Alternatively, could have created a direct mapping, but reusing the existing data structure.)
-            // This code can be converted to flatMap now that we have ES2020 support.
-            Object.values(__classPrivateFieldGet(this, _FinsembleDesktopAgent_contextHandlers, "f")).every((handlersByType) => {
-                targetHandlerSet = handlersByType.find((handlerSet) => handlerSet.targetSubscriberId === message.meta.targetSubscriberId);
-                return targetHandlerSet === undefined;
-            });
-            // there is only one handler for the autoBroadcast path, but next section of code expects an array for the general case.
-            handlers = targetHandlerSet ? [targetHandlerSet] : [];
-        }
-        else {
-            // get all registered handlers, for this context type or global handlers
-            handlers = ((_a = __classPrivateFieldGet(this, _FinsembleDesktopAgent_contextHandlers, "f")[context === null || context === void 0 ? void 0 : context.type]) !== null && _a !== void 0 ? _a : []).concat((_b = __classPrivateFieldGet(this, _FinsembleDesktopAgent_contextHandlers, "f")["*"]) !== null && _b !== void 0 ? _b : []);
-        }
-        handlers.forEach(({ handler, channel }) => {
-            // If broadcast channel matches our handler's channel, or
-            // If broadcast is global and we have a generic handler
-            if (message.meta.channel === channel || (!message.meta.channel && !channel)) {
-                Logger.system.debug(`FDC3 Client: triggerContextListeners for all on ${channel !== null && channel !== void 0 ? channel : "default"} channel`, message.type, message);
-                // invoke the addContextListener handler
-                handler(context);
-            }
-            else {
-                Logger.system.debug(`FDC3 Client: triggerContextListeners skipped for all on ${channel !== null && channel !== void 0 ? channel : "default"} channel`, message.type, message);
-            }
-        });
-    }
-    triggerIntentListeners(message) {
-        const { intent, context } = message.payload;
-        const handlers = __classPrivateFieldGet(this, _FinsembleDesktopAgent_intentHandlers, "f")[intent];
-        const functionArray = handlers ? handlers : [];
-        if (context)
-            functionArray.forEach((func) => func(context));
-    }
-    handleIncoming(message) {
-        Logger.system.debug("FDC3 Client: handleIncoming", message.type, message);
-        switch (message.type) {
-            case "broadcast":
-                this.triggerContextListeners(message);
-                break;
-            case "intent":
-                this.triggerIntentListeners(message);
-                break;
-            case "heartbeat":
-                this.handleHeartbeat();
-                break;
-            default:
-                break;
-        }
-    }
-    /**
-     * Releases the queue, sending API calls to the interop service that had been deferred until a connection
-     * was established.
-     */
-    releaseQueue() {
-        /**
-         * When messages were queued, the uuid would not have been available (uuid is based on windowName
-         * which is only available after startup.onReady). Now that we're releasing the queue, update
-         * the uuid in any queued messages before sending them out.
-         */
-        const updateUUID = (message) => {
-            var _a;
-            if (((_a = message === null || message === void 0 ? void 0 : message.meta) === null || _a === void 0 ? void 0 : _a.uuid) !== undefined) {
-                message.meta.uuid = __classPrivateFieldGet(this, _FinsembleDesktopAgent_uuid, "f");
-            }
-            return message;
-        };
-        __classPrivateFieldGet(this, _FinsembleDesktopAgent_queue, "f").forEach(async (entry) => {
-            const { message, handler, resolve } = entry;
-            const { err, receiveMessage } = await this.exchange(updateUUID(message), handler);
-            resolve({ err, receiveMessage });
-        });
-        __classPrivateFieldSet(this, _FinsembleDesktopAgent_queue, [], "f");
-    }
-    /**
-     * This is the central point for exchanging data with the interop service. Even though some FDC3
-     * calls such as broadcast() are one way, we always perform a query/response with the server, at
-     * least getting an empty response to know that it was handled.
-     */
-    exchange(message, handler = () => { }) {
-        return new Promise(async (resolve) => {
-            if (__classPrivateFieldGet(this, _FinsembleDesktopAgent_connected, "f")) {
-                const { err, response } = await __classPrivateFieldGet(this, _FinsembleDesktopAgent_routerClient, "f").query(SERVER_CHANNEL, message, handler);
-                const receiveMessage = response === null || response === void 0 ? void 0 : response.data;
-                resolve({ err, receiveMessage });
-            }
-            else {
-                __classPrivateFieldGet(this, _FinsembleDesktopAgent_queue, "f").push({ message, handler, resolve });
-                this.start();
-            }
-        });
-    }
-    /**
-     * Performs the handshake to the interop service and starts hearbeats.
-     * @internal
-     */
-    async connect() {
-        var _a;
-        /**
-         * StartupData contains the AuthenticationToken necessary to connect to the interop service. When an app
-         * is spawned by Finsemble, the AuthenticationToken is automatically created by the launcher. When an app
-         * is freestanding, the AuthenticationToken is generated when a developer calls FSBLJSAdapter.startApp with a
-         * digital signing key. If an app can't be authenticated then Startup ensures that an anonymous
-         * AuthenticationToken exists (type "unauthenticated").
-         */
-        const startupData = __classPrivateFieldGet(this, _FinsembleDesktopAgent_startup, "f").getStartupData();
-        const { windowName = "Unknown window", authenticationToken } = startupData;
-        Logger.system.log(`fdc3.connect StartupData for ${windowName}`, startupData);
-        __classPrivateFieldSet(this, _FinsembleDesktopAgent_uuid, `fdc3-${(_a = authenticationToken === null || authenticationToken === void 0 ? void 0 : authenticationToken.meta) === null || _a === void 0 ? void 0 : _a.name}-${uuidv4()}`, "f");
-        const registerClient = {
-            type: "register",
-            meta: this.meta(),
-            payload: {
-                // It would be better if the server assigned the client channel name. We could then protect against clashes.
-                clientChannel: __classPrivateFieldGet(this, _FinsembleDesktopAgent_clientChannel, "f"),
-                // Ideally the server gets/verifies the windowName from the router
-                windowName,
-                // Required by InteropService to authenticate this client (preventing spoofing)
-                authenticationToken,
-            },
-        };
-        /**
-         * We need to ensure that the SERVER_CHANNEL responder has been added to the router. This happens
-         * at the kernel stage when the InteropService is starting up. Therefore we need to wait until the
-         * kernel stage is complete (i.e. InteropService is up and running) before we can query the SERVER_CHANNEL.
-         *
-         * Freestanding apps will periodically try to register with Interop if they are started prior to Finsemble
-         * coming up which would cause interop registration request being fired before the responder was added to the router.
-         *
-         * This waitForBootStage works, even though Finsemble might not be up, for two reasons:
-         * 	1) the underlying router subscribe in waitForBootStage will be queued by the routerClient until the router is up
-         * 	2) the underlying pubsub topic relies on a default pubSub responder in the router service, so it will immediately
-         * 		be available when the router is available.
-         */
-        SystemManagerClient.waitForBootStage("kernel", "stageCompleted", (error) => {
-            if (error) {
-                Logger.system.error("connect error waitingForBootStage", error);
-            }
-            else {
-                __classPrivateFieldGet(this, _FinsembleDesktopAgent_routerClient, "f").query(SERVER_CHANNEL, registerClient, (err) => {
-                    if (err) {
-                        Logger.system.error("connect error", err);
-                    }
-                    else {
-                        __classPrivateFieldGet(this, _FinsembleDesktopAgent_routerClient, "f").addResponder(__classPrivateFieldGet(this, _FinsembleDesktopAgent_clientChannel, "f"), (err2, request) => {
-                            if (err2 || !request) {
-                                const errorString = errorAsString(err2 !== null && err2 !== void 0 ? err2 : "No request received on responder");
-                                Logger.system.error(`FinsembleDesktopAgent can't listen on channel ${__classPrivateFieldGet(this, _FinsembleDesktopAgent_clientChannel, "f")} : ${errorString}`);
-                                // channel isn't available, uh oh
-                            }
-                            else {
-                                if (request.data)
-                                    this.handleIncoming(request.data);
-                                request.sendQueryResponse(null);
-                            }
-                        });
-                        __classPrivateFieldSet(this, _FinsembleDesktopAgent_connected, true, "f");
-                        Logger.system.log(`FDC3 client connected for window ${windowName}`);
-                        this.releaseQueue();
-                        // The heartbeat monitor shouldn't start until now that we've successfully connected to the interop service
-                        __classPrivateFieldGet(this, _FinsembleDesktopAgent_heartbeatMonitor, "f").start();
-                    }
-                });
-            }
-        });
-    }
-    /**
-     * Connect to the interop service. This method can be safely called multiple times. It will only
-     * establish a single connection.
-     * This function is called by FSBLDesktop and FSBLFreestanding.
-     * @internal
-     */
-    async start() {
-        // We only need to register with the FSBL event handlers once. Prevents connecting multiple times.
-        if (__classPrivateFieldGet(this, _FinsembleDesktopAgent_startHasBeenCalled, "f"))
-            return;
-        __classPrivateFieldSet(this, _FinsembleDesktopAgent_startHasBeenCalled, true, "f");
-        await __classPrivateFieldGet(this, _FinsembleDesktopAgent_startup, "f").onReady();
-        // The connect method performs the handshake and starts the heartbeats.
-        // **We do not want to await** it since any calling function would stall, until a connection is established. In this
-        // instance this is a "fire and forget" action and any connections issues will be highlighted by other API calls.
-        this.connect();
-    }
-    /**
-     * Stops the client and puts it back into queuing state. The client
-     * can be restarted by calling connect().
-     * @internal
-     */
-    async stop() {
-        __classPrivateFieldGet(this, _FinsembleDesktopAgent_heartbeatMonitor, "f").stop();
-        const unregisterClient = {
-            type: "unregister",
-            meta: this.meta(),
-        };
-        await this.exchange(unregisterClient);
-        __classPrivateFieldSet(this, _FinsembleDesktopAgent_startHasBeenCalled, false, "f");
-        __classPrivateFieldGet(this, _FinsembleDesktopAgent_routerClient, "f").removeResponder(__classPrivateFieldGet(this, _FinsembleDesktopAgent_clientChannel, "f"));
-        __classPrivateFieldSet(this, _FinsembleDesktopAgent_connected, false, "f");
-    }
-    /**
-     * Registers handlers which will be called if the client is disconnected from Finsemble. This is only useful when
-     * running in freestanding apps that might continue running after Finsemble has been terminated. Users should be
-     * prompted to restart their freestanding app when a disconnect is received.
-     *
-     * @param cb Handler function.
-     * @experimental This method is not part of the FDC3 standard and may be replaced in the future with alternative mechanisms.
-     */
-    onDisconnect(cb) {
-        __classPrivateFieldGet(this, _FinsembleDesktopAgent_heartbeatMonitor, "f").onDisconnect(cb);
-    }
-    /** @internal */
-    async channelGetCurrentContext(channel, contextType) {
-        const message = {
-            type: "currentContextRequest",
-            meta: Object.assign(Object.assign({}, this.meta()), { channel }),
-            payload: {
-                contextType,
-            },
-        };
-        const { err, receiveMessage } = await this.exchange(message);
-        if (err)
-            return null;
-        return (receiveMessage === null || receiveMessage === void 0 ? void 0 : receiveMessage.type) === "currentContext" ? receiveMessage.payload.context : null;
-    }
-    /**
-     * Publishes context to other apps on the desktop.
-     * Calling broadcast at the DesktopAgent scope will push the context to whatever Channel the app is joined to.
-     * If the app is not currently joined to a channel, calling fdc3.broadcast will have no effect.
-     * Apps can still directly broadcast and listen to context on any channel via the methods on the Channel class.
-     * @param context
-     */
-    broadcast(context) {
-        if (!context) {
-            throw new Error("Invalid arguments. The required context parameter is missing.");
-        }
-        const message = {
-            type: "broadcast",
-            meta: this.meta(),
-            payload: {
-                context,
-            },
-        };
-        this.exchange(message);
-    }
-    /** @internal */
-    channelBroadcast(channel, context) {
-        const message = {
-            type: "broadcast",
-            meta: Object.assign(Object.assign({}, this.meta()), { channel }),
-            payload: {
-                context,
-            },
-        };
-        this.exchange(message);
-    }
-    /**
-     * Retrieves a list of the System channels available for the app to join.
-     * This should include the 'global' channel.
-     */
-    async getSystemChannels() {
-        var _a;
-        const message = {
-            type: "systemChannelRequest",
-            meta: this.meta(),
-        };
-        const { err, receiveMessage } = await this.exchange(message);
-        if (err)
-            return [];
-        const channelNames = (receiveMessage === null || receiveMessage === void 0 ? void 0 : receiveMessage.type) === "systemChannels" ? (_a = receiveMessage === null || receiveMessage === void 0 ? void 0 : receiveMessage.payload) === null || _a === void 0 ? void 0 : _a.channels : [];
-        return channelNames.map((name) => new ChannelProxy(this, name, "system"));
-    }
-    /**
-     * Launches/links to an app by name.
-     * If a Context object is passed in, this object will be provided to the opened application via a contextListener.
-     * The Context argument is functionally equivalent to opening the target app with no context and broadcasting the context directly to it.
-     * If opening errors, it returns an Error with a string from the OpenError enumeration.
-     *
-     * @param target
-     * @param context
-     */
-    async open(target, context) {
-        if (!target) {
-            throw new Error("Invalid arguments. The required target parameter is missing.");
-        }
-        const message = {
-            type: "open",
-            meta: this.meta(),
-            payload: {
-                target,
-                context,
-            },
-        };
-        const { err, receiveMessage } = await this.exchange(message);
-        const interopOpenResponse = receiveMessage;
-        if (err) {
-            throw this.fdc3Error(OpenError.ResolverUnavailable);
-        }
-        else if (interopOpenResponse.payload.error) {
-            throw this.fdc3Error(interopOpenResponse.payload.error);
-        }
-    }
-    /**
-     * Find out more information about a particular intent by passing its name, and optionally its context.
-     *
-     * findIntent is effectively granting programmatic access to the Desktop Agent's resolver.
-     * A promise resolving to the intent, its metadata and metadata about the apps that registered it is returned.
-     * This can be used to raise the intent against a specific app.
-     *
-     * If the resolution fails, the promise will return an `Error` with a string from the `ResolveError` enumeration.
-     *
-     * @param intent
-     * @param context
-     */
-    async findIntent(intent, context) {
-        if (!intent) {
-            throw new Error("Invalid arguments. The required intent parameter is missing.");
-        }
-        const message = {
-            type: "findIntent",
-            meta: this.meta(),
-            payload: {
-                intent,
-                context,
-            },
-        };
-        const { err, receiveMessage } = await this.exchange(message);
-        const interopFindIntentResponse = receiveMessage;
-        if (err) {
-            throw this.fdc3Error(ResolveError.ResolverUnavailable);
-        }
-        else if (interopFindIntentResponse.payload.error) {
-            throw this.fdc3Error(interopFindIntentResponse.payload.error);
-        }
-        else if (!interopFindIntentResponse.payload.appIntent) {
-            throw this.fdc3Error("Invalid response returned from InteropService for findIntent. No appIntent and no error.");
-        }
-        return interopFindIntentResponse.payload.appIntent;
-    }
-    /**
-     * Find all the available intents for a particular context.
-     *
-     * findIntents is effectively granting programmatic access to the Desktop Agent's resolver.
-     * A promise resolving to all the intents, their metadata and metadata about the apps that registered it is returned,
-     * based on the context types the intents have registered.
-     *
-     * If the resolution fails, the promise will return an `Error` with a string from the `ResolveError` enumeration.
-     * @param context
-     */
-    async findIntentsByContext(context) {
-        if (!context) {
-            throw new Error("Invalid arguments. The required context parameter is missing.");
-        }
-        // The context parameter was made optional to support a query for all intents. This is consistent with findIntent, however it is not consistent with FDC3 spec plus.
-        // a mechanism is still needed to query for contexts. A better solution is to add two new InteropAdmin methods; e.g. getIntents() and getContexts().
-        const message = {
-            type: "findIntentsByContext",
-            meta: this.meta(),
-            payload: {
-                context,
-            },
-        };
-        const { receiveMessage } = await this.exchange(message);
-        const interopIntentsList = receiveMessage;
-        if (interopIntentsList.payload.error) {
-            throw this.fdc3Error(interopIntentsList.payload.error);
-        }
-        return interopIntentsList.payload.intents || [];
-    }
-    /**
-     * Raises an intent to the desktop agent to resolve.
-     * @param intent
-     * @param context
-     * @param target
-     */
-    async raiseIntent(intent, context, target) {
-        if (!intent) {
-            throw new Error("Invalid arguments. The required intent parameter is missing.");
-        }
-        if (!context) {
-            throw new Error("Invalid arguments. The required context parameter is missing.");
-        }
-        const message = {
-            type: "raiseIntent",
-            meta: this.meta(),
-            payload: {
-                intent,
-                context,
-                target,
-            },
-        };
-        const { err, receiveMessage } = await this.exchange(message);
-        const interopIntentResolution = receiveMessage;
-        if (err) {
-            throw this.fdc3Error(ResolveError.ResolverUnavailable);
-        }
-        else if (interopIntentResolution.payload.error) {
-            throw this.fdc3Error(interopIntentResolution.payload.error);
-        }
-        else if (!interopIntentResolution.payload.data) {
-            throw this.fdc3Error("Invalid response returned from InteropService for raiseIntent. No data.");
-        }
-        return interopIntentResolution.payload.data;
-    }
-    /**
-     * Finds and raises an intent against a target app based purely on context data.
-     *
-     * raiseIntentForContext is essentially a raiseIntent without a specific intent specified, hence the same "raiseIntent" Interop message is used.
-     *
-     * @param context
-     * @param target
-     */
-    async raiseIntentForContext(context, target) {
-        if (!context) {
-            throw new Error("Invalid arguments. The required context parameter is missing.");
-        }
-        const message = {
-            type: "raiseIntent",
-            meta: this.meta(),
-            payload: {
-                context,
-                target,
-            },
-        };
-        const { err, receiveMessage } = await this.exchange(message);
-        const interopRaiseIntentResponse = receiveMessage;
-        if (err) {
-            throw this.fdc3Error(ResolveError.ResolverUnavailable);
-        }
-        else if (interopRaiseIntentResponse.payload.error) {
-            throw this.fdc3Error(interopRaiseIntentResponse.payload.error);
-        }
-        else if (!interopRaiseIntentResponse.payload.data) {
-            throw this.fdc3Error("Invalid response returned from InteropService for raiseIntentForContext. No data.");
-        }
-        return interopRaiseIntentResponse.payload.data;
-    }
-    /**
-     * Adds a listener for incoming Intents from the Agent.
-     * @param intent
-     * @param handler
-     */
-    addIntentListener(intent, handler) {
-        if (!handler) {
-            throw new Error("Invalid arguments. The required intent parameter is missing.");
-        }
-        if (!handler) {
-            throw new Error("Invalid arguments. The required handler parameter is missing.");
-        }
-        __classPrivateFieldGet(this, _FinsembleDesktopAgent_intentHandlers, "f")[intent] = mmAdd(__classPrivateFieldGet(this, _FinsembleDesktopAgent_intentHandlers, "f"), intent, handler);
-        const message = {
-            type: "subscribeIntent",
-            meta: this.meta(),
-            payload: {
-                intent,
-            },
-        };
-        this.exchange(message); // don't wait for response
-        return {
-            unsubscribe: () => {
-                const unsubscribeMessage = {
-                    type: "unsubscribeIntent",
-                    meta: this.meta(),
-                    payload: {
-                        intent,
-                    },
-                };
-                this.exchange(unsubscribeMessage); // don't wait for response
-                __classPrivateFieldGet(this, _FinsembleDesktopAgent_intentHandlers, "f")[intent] = mmRemove(__classPrivateFieldGet(this, _FinsembleDesktopAgent_intentHandlers, "f"), intent, handler);
-            },
-        };
-    }
-    /** @internal */
-    channelAddContextListener(channel, contextTypeOrHandler, handler) {
-        // Derives a definitive contextType and handler from the varargs
-        // Possibilities: addContextListener(handler) - deprecated 1.1, addContextListener(null, handler), addContextListener(contextType, handler)
-        const contextTypeOrWildCard = contextTypeOrHandler ? contextTypeOrHandler : "*";
-        const contextType = handler ? contextTypeOrWildCard : "*";
-        if (!handler)
-            handler = contextTypeOrHandler;
-        // A unique targetSubscriberId must be passed in InteropSubscribeContext; the InteropService can direct messages to this specific listener by returning the targetSubscriberId in a broadcast message,
-        const targetSubscriberId = `subscriberId.${Date.now()}_${Math.random()}`;
-        // Bind targetSubscriberId to the specific handler and save in map
-        const handlerSet = { handler, channel, targetSubscriberId };
-        __classPrivateFieldGet(this, _FinsembleDesktopAgent_contextHandlers, "f")[contextType] = mmAdd(__classPrivateFieldGet(this, _FinsembleDesktopAgent_contextHandlers, "f"), contextType, handlerSet);
-        let message = {
-            type: "subscribeContext",
-            meta: Object.assign(Object.assign({}, this.meta()), { targetSubscriberId }),
-            payload: {
-                contextType,
-            },
-        };
-        if (channel)
-            message.meta.channel = channel;
-        this.exchange(message); // Don't wait for response
-        return {
-            unsubscribe: () => {
-                let unsubscribeMessage = {
-                    type: "unsubscribeContext",
-                    meta: this.meta(),
-                    payload: {
-                        contextType,
-                    },
-                };
-                if (channel)
-                    unsubscribeMessage.meta.channel = channel;
-                __classPrivateFieldGet(this, _FinsembleDesktopAgent_contextHandlers, "f")[contextType] = mmRemove(__classPrivateFieldGet(this, _FinsembleDesktopAgent_contextHandlers, "f"), contextType, handlerSet);
-                this.exchange(unsubscribeMessage); // Don't wait for response
-            },
-        };
-    }
-    /**
-     * Adds a listener for incoming context broadcast from the Desktop Agent.
-     * If the consumer is only interested in a context of a particular type, they can use the relevant overload that allows the type to be specified.
-     * @param contextTypeOrHandler
-     * @param handler
-     */
-    addContextListener(contextTypeOrHandler, handler) {
-        if (contextTypeOrHandler === undefined) {
-            throw new Error("Invalid arguments. The contextTypeOrHandler parameter shouldn't be undefined.");
-        }
-        if (typeof contextTypeOrHandler !== "function" && !handler) {
-            throw new Error("Invalid arguments. The required handler parameter is missing.");
-        }
-        return this.channelAddContextListener(null, contextTypeOrHandler, handler);
-    }
-    /**
-     * Joins the app to the specified channel.
-     * If an app is joined to a channel, all fdc3.broadcast calls will go to the channel, and all listeners assigned via fdc3.addContextListener will listen on the channel.
-     * An app can only be joined to one channel at a time.
-     * Rejects with error if the channel is unavailable or the join request is denied.
-     * Error with a string from the ChannelError enumeration.
-     * @param channelId
-     */
-    async joinChannel(channelId) {
-        if (!channelId) {
-            throw new Error("Invalid arguments. The required channelId parameter is missing.");
-        }
-        const message = {
-            type: "joinChannels",
-            meta: this.meta(),
-            payload: {
-                channels: [channelId],
-            },
-        };
-        await this.exchange(message);
-    }
-    /**
-     * Returns a Channel object for the specified channel, creating it (as an App channel) - if it does not exist.
-     * Error with a string from the ChannelError enumeration if channel could not be created or access was denied.
-     * @param channelId
-     */
-    async getOrCreateChannel(channelId) {
-        if (!channelId) {
-            throw new Error("Invalid arguments. The required channelId parameter is missing.");
-        }
-        return new ChannelProxy(this, channelId);
-    }
-    /**
-     * FDC3 2.0 pre-release
-     *
-     * Get all joined channels
-     *
-     * Known race condition: getCurrentChannels() can return an empty string if it is called before the InteropService's linker module
-     * has completed initializing the app. This can occur if fdc3.getCurrentChannels() is the very first call that an app makes. To work around
-     * this issue, use the interop.autoConnect config flag. A future version of the InteropService will hold off on completed registrations
-     * until submodules have finished their work.
-     */
-    async getCurrentChannels() {
-        const message = {
-            type: "getCurrentChannels",
-            meta: this.meta(),
-        };
-        const { err, receiveMessage } = await this.exchange(message);
-        const interopGetCurrentChannelsResponse = receiveMessage;
-        if (err) {
-            throw this.fdc3Error(err);
-        }
-        else if (interopGetCurrentChannelsResponse.payload.error) {
-            throw this.fdc3Error(interopGetCurrentChannelsResponse.payload.error);
-        }
-        else if (!interopGetCurrentChannelsResponse.payload.data) {
-            throw this.fdc3Error("Invalid response returned from InteropService for getCurrentChannels. No data.");
-        }
-        return interopGetCurrentChannelsResponse.payload.data.map((entry) => new ChannelProxy(this, entry.channel, "system"));
-    }
-    /**
-     * Returns the Channel object for the current channel membership.
-     * Returns null if the app is not joined to a channel.
-     */
-    async getCurrentChannel() {
-        const channels = await this.getCurrentChannels();
-        return channels && channels.length ? channels[0] : null;
-    }
-    /**
-     * Removes the app from any channel membership.
-     * Context broadcast and listening through the top-level fdc3.broadcast and fdc3.addContextListener will be in a no-op when the app is not on a channel.
-     */
-    async leaveCurrentChannel() {
-        const message = {
-            type: "leaveChannels",
-            meta: this.meta(),
-            payload: {},
-        };
-        await this.exchange(message);
-    }
-    /**
-     * Retrieves information about the FDC3 Desktop Agent implementation, such as
-     * the implemented version of the FDC3 specification and the name of the implementation
-     * provider.
-     */
-    getInfo() {
-        return {
-            fdc3Version: "1.2",
-            provider: "Finsemble",
-            // This data is added at build time by webpack EnvironmentPlugin
-            providerVersion: __classPrivateFieldGet(this, _FinsembleDesktopAgent_FSBLVersion, "f"),
-        };
-    }
-}
-_FinsembleDesktopAgent_connected = new WeakMap(), _FinsembleDesktopAgent_heartbeatMonitor = new WeakMap(), _FinsembleDesktopAgent_startHasBeenCalled = new WeakMap(), _FinsembleDesktopAgent_uuid = new WeakMap(), _FinsembleDesktopAgent_clientChannel = new WeakMap(), _FinsembleDesktopAgent_intentHandlers = new WeakMap(), _FinsembleDesktopAgent_contextHandlers = new WeakMap(), _FinsembleDesktopAgent_queue = new WeakMap(), _FinsembleDesktopAgent_routerClient = new WeakMap(), _FinsembleDesktopAgent_startup = new WeakMap(), _FinsembleDesktopAgent_FSBLVersion = new WeakMap();
-//# sourceMappingURL=FinsembleDesktopAgent.js.map