@finsemble/finsemble-ui 7.3.0 → 8.0.0-alpha-1

package/clients/Interop/FinsembleDesktopAgent.js

@@ -0,0 +1,813 @@
+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