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

package/clients/dialogManagerClient.js

@@ -1,691 +0,0 @@
-/*!
- * Copyright 2017 - 2020 by ChartIQ, Inc.
- * All rights reserved.
- */
-/**
- * The Dialog Manager Client simplifies interacting with dialog windows by spawning them and getting data back from them.
- * In this context, a dialog window is simply a child window spawned to interact with the user, such as a confirmation dialog.
- * Functions are provided here for both the parent-window side and the dialog/child-window side.
- *
- *`FSBL.Clients.DialogManager` is always pre-initialized with one instance of the Dialog Manager in the Finsemble Library (making it essentially, a singleton when referenced in the same window). This means when developing Finsemble components, you directly access the Dialog Manager without using the constructor (e.g., `FSBL.Clients.DialogManager.spawnDialog(...);`). **The constructor is not exposed to components.**
- *
- * @module DialogManagerClient
- */
-import { LauncherClient } from "./launcherClient";
-import { DistributedStoreClient } from "./distributedStoreClient";
-import { FinsembleWindow } from "../common/FinsembleWindow";
-import { Logger } from "./logger";
-import { System } from "../common/system";
-import { getMyWindowIdentifier } from "../common/util";
-import { RouterClient } from "./routerClient";
-import { Globals } from "../common/Globals";
-import { singleton } from "../common/Singleton";
-import SystemManagerClient from "../common/systemManagerClient";
-import { nameMap as legacyUINameMap } from "../deprecated/legacyUIComponentNames";
-import { series as asyncSeries } from "async";
-import uuidv4 from "uuid-random";
-export class DialogManagerClientController {
-    constructor() {
-        this.initialized = false;
-        /**
-         * Can be used to set a specific timeout
-         */
-        this.userInputTimeout = null;
-        /**
-         * A global store used to track which windows are registered as dialogs and their state.
-         * Dialogs are put in the "available" pool when they are available for use. They are put
-         * in the "open" pool when they are in use.
-         */
-        this.DialogStore = null;
-        /**
-         * Will be set to true if the current window is a dialog
-         */
-        this.isDialog = false;
-        /**
-         * Contains a unique channel name that a dialog can use to communicate back to
-         * its originating window. The channel is created by the originating window as
-         * a query responder.
-         */
-        this.RESPONDER_CHANNEL = null;
-        /**
-         * Used to send a message back to whoever opened this dialog
-         */
-        this.openerMessage = null;
-        /**
-         * Same as FEAGlobals.finsembleWindow
-         */
-        this.finsembleWindow = null;
-        /**
-         * Will be set with the spawn data, which contains the input params and responseChannel
-         */
-        this.spawnData = {};
-    }
-    /**
-     * Checks to see whether the window is a dialog, setting this.isDialog to true or false
-     * @param {cb} cb The callback to be invoked after the method completes successfully.
-     */
-    async checkIfWindowIsDialog(cb) {
-        var _a, _b, _c, _d, _e, _f;
-        if (Globals.finsembleWindow) {
-            const { err, data: options } = await Globals.finsembleWindow.getOptions();
-            this.spawnData = (_b = (_a = options === null || options === void 0 ? void 0 : options.customData) === null || _a === void 0 ? void 0 : _a.spawnData) !== null && _b !== void 0 ? _b : {};
-            this.isDialog = (_f = (_e = (_d = (_c = options === null || options === void 0 ? void 0 : options.customData) === null || _c === void 0 ? void 0 : _c.foreign) === null || _d === void 0 ? void 0 : _d.clients) === null || _e === void 0 ? void 0 : _e.dialogManager) === null || _f === void 0 ? void 0 : _f.isDialog;
-            cb === null || cb === void 0 ? void 0 : cb(err);
-        }
-        else {
-            this.isDialog = false;
-            cb === null || cb === void 0 ? void 0 : cb("Freestanding apps cannot be dialogs");
-        }
-    }
-    /**
-     * Registers the window as a dialog with the global store. If the component is incapable of being used as a dialog (this is set in the component's config), the callback is immediately invoked.
-     *
-     * **Note:** This method checks whether the calling window is a dialog.
-     * @param {function} callback The callback to be invoked after the method completes successfully.
-     */
-    async registerWithStore(cb) {
-        var _a;
-        if (this.isDialog) {
-            const myWindowIdentifier = await getMyWindowIdentifier();
-            this.RESPONDER_CHANNEL = `Dialog.${myWindowIdentifier.windowName}.Show`;
-            await ((_a = this.DialogStore) === null || _a === void 0 ? void 0 : _a.setValue({
-                field: `dialogs.available.${myWindowIdentifier.windowName}`,
-                value: myWindowIdentifier,
-            }));
-        }
-        cb === null || cb === void 0 ? void 0 : cb();
-    }
-    /**
-     * Establishes a connection to the distributed store that is used
-     * by all dialogs. This function may be called many times but will
-     * only initialize one time.
-     */
-    initializeOnce() {
-        return new Promise(async (resolve) => {
-            // Only initialize once
-            if (this.initialized) {
-                resolve();
-                return;
-            }
-            this.initialized = true;
-            await SystemManagerClient.waitForStartup("windowService");
-            await this.checkIfWindowIsDialog();
-            asyncSeries([
-                this.createStore.bind(this),
-                this.registerWithStore.bind(this),
-                this.getFinsembleWindow.bind(this),
-                (done) => {
-                    done();
-                },
-            ], () => {
-                resolve();
-            });
-        });
-    }
-    /**
-     * Creates the global store if it doesn't exist.
-     * @param {function} callback
-     */
-    async createStore(cb) {
-        const defaults = {
-            dialogs: {
-                opened: {},
-                available: {},
-            },
-        };
-        const { err, data } = await DistributedStoreClient.createStore({
-            store: "DialogStore",
-            values: defaults,
-            global: true,
-        });
-        if (err || !data) {
-            Logger.error(`DialogManagerClient could not create store "DialogStore"`, err);
-        }
-        else {
-            this.DialogStore = data;
-        }
-        cb === null || cb === void 0 ? void 0 : cb();
-    }
-    /**
-     */
-    async getFinsembleWindow(cb) {
-        // this.finsembleWindow must only be initialized in actual dialogs. Otherwise it causes side effects in services.
-        if (this.isDialog) {
-            const { wrap } = await FinsembleWindow.getInstance({ name: System.Window.getCurrent().name });
-            this.finsembleWindow = wrap;
-        }
-        cb === null || cb === void 0 ? void 0 : cb();
-    }
-    async getAvailableDialog(type, cb) {
-        if (!this.DialogStore) {
-            const error = `DialogMangerClient.getAvailableDialogs() store not yet initialized}`;
-            Logger.system.error(error);
-            cb === null || cb === void 0 ? void 0 : cb(null);
-            return null;
-        }
-        const { err, data: availableDialogs } = await this.DialogStore.getGlobalValue("dialogs.available");
-        if (err) {
-            const error = `DialogMangerClient.getAvailableDialogs() store error ${err}`;
-            Logger.system.error(error);
-            cb === null || cb === void 0 ? void 0 : cb(null);
-            return null;
-        }
-        for (const dialogName in availableDialogs) {
-            const dialog = availableDialogs[dialogName];
-            if (dialog.componentType === type) {
-                cb === null || cb === void 0 ? void 0 : cb(dialog);
-                return dialog;
-            }
-        }
-        cb === null || cb === void 0 ? void 0 : cb(null);
-        return null;
-    }
-    /**
-     * State management - just moves an opened dialog back to the "available" pool.
-     * @param {object} identifier window identifier of the dialog.
-     */
-    async moveDialogFromOpenedToAvailable(identifier) {
-        var _a, _b;
-        if (!this.DialogStore) {
-            const error = `DialogMangerClient.moveDialogFromOpenedToAvailable() store not yet initialized}`;
-            Logger.system.error(error);
-            return error;
-        }
-        const { err, data: dialogs } = await this.DialogStore.getGlobalValue("dialogs");
-        if (err || !dialogs) {
-            const error = `DialogManagerClient.moveDialogFromOpenedToAvailable() no "dialogs" object returned from store`;
-            Logger.system.error(error);
-            return error;
-        }
-        const openedDialogs = dialogs.opened;
-        const availableDialogs = dialogs.available;
-        delete openedDialogs[identifier.windowName];
-        availableDialogs[identifier.windowName] = identifier;
-        (_a = this.DialogStore) === null || _a === void 0 ? void 0 : _a.setValue({
-            field: "dialogs.opened",
-            value: openedDialogs,
-        });
-        (_b = this.DialogStore) === null || _b === void 0 ? void 0 : _b.setValue({
-            field: "dialogs.available",
-            value: availableDialogs,
-        });
-        return null;
-    }
-    /**
-     * State management - just moves an available dialog out of the "available" pool.
-     * @param {object} identifier window identifier of the dialog.
-     */
-    async moveDialogFromAvailableToOpened(identifier) {
-        var _a, _b;
-        if (!this.DialogStore) {
-            const error = `DialogMangerClient.moveDialogFromAvailableToOpened() store not yet initialized}`;
-            Logger.system.error(error);
-            return error;
-        }
-        const { err, data: dialogs } = await this.DialogStore.getGlobalValue("dialogs");
-        if (err || !dialogs) {
-            const error = `DialogManagerClient.moveDialogFromAvailableToOpened no "dialogs" object returned from store`;
-            Logger.system.error(error);
-            return error;
-        }
-        const availableDialogs = dialogs.available;
-        const openedDialogs = dialogs.opened;
-        delete availableDialogs[identifier.windowName];
-        openedDialogs[identifier.windowName] = identifier;
-        (_a = this.DialogStore) === null || _a === void 0 ? void 0 : _a.setValue({
-            field: "dialogs.available",
-            value: availableDialogs,
-        });
-        (_b = this.DialogStore) === null || _b === void 0 ? void 0 : _b.setValue({
-            field: "dialogs.opened",
-            value: openedDialogs,
-        });
-        return null;
-    }
-}
-const getControllerInstance = async () => {
-    const controller = singleton("DialogManagerClient", DialogManagerClientController);
-    await controller.initializeOnce();
-    return controller;
-};
-/**
- * Generates a string for the "onReady" for a given channel.
- * @param {object} identifier
- */
-const generateDialogReadyChannel = (identifier) => {
-    const concat = identifier.windowName;
-    return `Dialog.${concat}.ready`;
-};
-// ///////////////////////////////////////////
-// Functions relating to the modal scrim
-// ///////////////////////////////////////////
-/**
- * Registers this window as a modal that can be used by the dialog manager. This will set
- * the window as a "scrim" – taking up the entire size of the monitor and being invisible or lightly opaque.
- *
- * Sometimes, clicking anywhere on this window will dismiss the modal.
- */
-export const registerModal = async () => {
-    var _a, _b;
-    const controller = await getControllerInstance();
-    const info = await System.getMonitorInfo();
-    const { virtualScreen } = info;
-    (_a = controller.finsembleWindow) === null || _a === void 0 ? void 0 : _a.setBounds({
-        bounds: Object.assign(Object.assign({}, virtualScreen), { width: virtualScreen.right - virtualScreen.left, height: virtualScreen.bottom - virtualScreen.top }),
-    });
-    const myWindowIdentifier = await getMyWindowIdentifier();
-    (_b = controller.DialogStore) === null || _b === void 0 ? void 0 : _b.setValue({
-        field: "modalIdentifier",
-        value: myWindowIdentifier,
-    });
-    return null;
-};
-/**
- * Shows a semi-transparent black modal behind the dialog.
- * @param {function} cb The callback to be invoked after the method completes successfully.
- */
-export const showModal = async (cb) => {
-    const controller = await getControllerInstance();
-    if (!controller.DialogStore) {
-        const error = `DialogMangerClient.showModal() store not yet initialized}`;
-        Logger.system.error(error);
-        cb === null || cb === void 0 ? void 0 : cb(error);
-        return error;
-    }
-    const { err, data: identifier } = await controller.DialogStore.getGlobalValue("modalIdentifier");
-    if (err || !identifier) {
-        // If null is passed back, this likely means the window is not ready yet.
-        // We only need to proceed if the window exists and identifier is not null
-        const error = `DialogManagerClient.showModal() error from store: ${err}`;
-        Logger.system.debug(error);
-        cb === null || cb === void 0 ? void 0 : cb(error);
-        return error;
-    }
-    const { wrap: modal } = await FinsembleWindow.getInstance({
-        uuid: identifier.uuid,
-        name: identifier.windowName,
-    });
-    modal.updateOptions({
-        options: {
-            opacity: 0.4,
-        },
-    }, () => {
-        modal.show(() => {
-            modal.bringToFront(() => {
-                var _a;
-                (_a = controller.finsembleWindow) === null || _a === void 0 ? void 0 : _a.focus(() => {
-                    var _a;
-                    (_a = controller.finsembleWindow) === null || _a === void 0 ? void 0 : _a.bringToFront();
-                    if (cb && typeof cb === "function") {
-                        cb();
-                    }
-                });
-            });
-        });
-    });
-    return null;
-};
-/**
- * Hides the dialog's modal.
- */
-export const hideModal = async () => {
-    const controller = await getControllerInstance();
-    if (!controller.DialogStore) {
-        const error = `DialogMangerClient.hideModal() store not yet initialized}`;
-        Logger.system.error(error);
-        return error;
-    }
-    const { err, data: identifier } = await controller.DialogStore.getGlobalValue("modalIdentifier");
-    if (err || !identifier) {
-        // If null is passed back, this likely means the window is not ready yet.
-        // We only need to proceed if the window exists and identifier is not null
-        const error = `DialogManagerClient.hideModal() error from store: ${err}`;
-        Logger.system.debug(error);
-        return error;
-    }
-    const { wrap: modal } = await FinsembleWindow.getInstance({
-        uuid: identifier.uuid,
-        name: identifier.windowName,
-    });
-    modal.hide();
-    return null;
-};
-// ///////////////////////////////////////////
-// Client Side Functions (Calling a Dialog Window)
-// ///////////////////////////////////////////
-/**
- * Function to initialize and open a dialog. Internally used.
- *
- * @param {object} identifier The window identifier of the dialog.
- * @param {object} options Any data to send to the dialog for its initialization.
- * @param {function} onUserInput Callback to be invoked after the user interacts with the dialog.
- */
-const sendQueryToDialog = async (identifier, options, onUserInput) => {
-    const warn = (timeout) => {
-        console.warn(`No response from dialog ${identifier.windowName} after ${timeout / 1000} seconds. Check to make sure your dialog is sending back data.`);
-    };
-    const controller = await getControllerInstance();
-    controller.moveDialogFromAvailableToOpened(identifier);
-    const queryChannel = `Dialog.${identifier.windowName}.Show`;
-    const listenerChannel = generateDialogReadyChannel(identifier);
-    let warningTimeout;
-    const unsubscribe = RouterClient.addListener(listenerChannel, async (err, response) => {
-        warningTimeout = setTimeout(warn.bind(null, response.data.userInputTimeout), response.data.userInputTimeout);
-        const { err: launchError, data } = await LauncherClient.showWindow(identifier, {
-            monitor: options.monitor || "mine",
-            left: "center",
-            top: "center",
-        });
-        if (launchError || !data) {
-            const error = `DialogManagerClient.sendQueryToDialog error showing window ${identifier.windowName} ${launchError}`;
-            Logger.system.error(error);
-            warn(error);
-            return;
-        }
-        const { name } = data.finWindow;
-        FinsembleWindow.getInstance({ name }, (getFinsembleWindowInstanceErr, wrap) => {
-            wrap.bringToFront();
-            wrap.focus();
-        });
-        unsubscribe();
-    });
-    const { err, response } = await RouterClient.query(queryChannel, options);
-    clearTimeout(warningTimeout);
-    controller.moveDialogFromOpenedToAvailable(identifier);
-    onUserInput(err, response.data);
-};
-/**
- * Spawns an app or url in "dialog mode". The app's window will not be dockable.
- * The app does not need to be explicitly coded as a dialog.
- *
- * Parameters passed as `params.inputParams` can be retrieved in the dialog window by
- * calling `FSBL.Clients.DialogManager.getParametersFromInDialog()`.
- *
- * ```javascript
- * FSBL.Clients.DialogManager.spawnDialog(
- * {
- * 	name: "dialogTemplate",
- * 	height:300,
- * 	width:400,
- * 	url:"http://localhost/components/system/dialogs/dialog1.html"
- * },
- * {
- * 	someData: 12345
- * },
- * (error, responseParameters) => {
- *	if (!error) {
- * 		console.log(">>>> spawnDialog response: " + JSON.stringify(responseParameters));
- *	}
- * });
- * ```
- * @param {object} params Parameters. Same as <a href="/docs/reference/typedocs/modules/LauncherClient#spawn">LauncherClient.spawn()</a> with the following exceptions.
- * @param {string} params.url URL of dialog to launch
- * @param {string} [params.name] - The name of the dialog
- * @param {number|string} params.x - Same as <a href="/docs/reference/typedocs/modules/LauncherClient#spawn">LauncherClient.spawn()</a> except defaults to "center".
- * @param {number | string} [params.y="center"] - Same as <a href="/docs/reference/typedocs/modules/LauncherClient#spawn">LauncherClient.spawn()</a> except defaults to "center".
- * @param {object} inputParams Object or any data type needed by your dialog.
- * @param {function} dialogResponseCallback called when response received back from dialog window (typically on dialog completion). `responseParameters` is defined by the dialog.
- * @param {function} cb Returns response from <a href="/docs/reference/typedocs/modules/LauncherClient#spawn">LauncherClient.spawn()</a>
- */
-export const spawnDialog = async (params, inputParams, dialogResponseCallback, cb) => {
-    const responseChannel = `DialogChannel-${uuidv4()}`;
-    params.data = { inputParams, responseChannel };
-    // Dialogs default to center
-    if (!params.left && params.left !== 0 && !params.right && params.right !== 0) {
-        params.left = "center";
-    }
-    if (!params.top && params.top !== 0 && !params.bottom && params.bottom !== 0) {
-        params.top = "center";
-    }
-    const unsubscribe = RouterClient.addListener(responseChannel, (err, response) => {
-        dialogResponseCallback(err, response.data);
-        unsubscribe();
-    });
-    const { error: err, response: data } = await LauncherClient.spawn("dialogTemplate", params);
-    if (err) {
-        Logger.system.error("DialogMangerClient.spawnDialog error spawning", err);
-        dialogResponseCallback(err, data);
-    }
-    cb === null || cb === void 0 ? void 0 : cb(err, data);
-    return { err, data };
-};
-/**
- * Opens an existing dialog that is registered under the requested type.
- * If no dialog is found then one will be spawned (with the options passed as the second parameter).
- *
- * Resolves to an error string if the dialog could not be opened, or null if it was successfully opened.
- *
- * @param {string} type Component type to open. The <code>type</code> must be a key in the finsemble.components configuration object.
- * If "yesNo" or "singleInput" are provided (legacy component names) then these will be converted to "YesNoDialog" and "SingleInputDialog"
- * (current component names).
- * @param {object} options Options to pass into the opened window.
- * @param {function} onUserInput Callback to be invoked when the user interacts with the dialog.
- */
-export const open = async (type, options, onUserInput) => {
-    var _a;
-    /**
-     * Replaces legacy UI Component names with their updated name. Existing customer code may reference prior names
-     * such as "yesNo" or "singleInput". This code will replace those calls with "YesNoDialog" and "SingleInputDialog".
-     * See comment in ../../deprecated/legacyUIComponentNames.ts for more information.
-     */
-    type = (_a = legacyUINameMap[type]) !== null && _a !== void 0 ? _a : type;
-    /** Attempts to open the dialog. If no dialog is yet registered then it resolves to false */
-    const openDialog = () => new Promise(async (resolve) => {
-        const controller = await getControllerInstance();
-        controller.getAvailableDialog(type, (dialogIdentifier) => {
-            if (dialogIdentifier) {
-                sendQueryToDialog(dialogIdentifier, options, onUserInput);
-                resolve(true);
-            }
-            else {
-                resolve(false);
-            }
-        });
-    });
-    // Attempt to open the dialog. This will work if the dialog is open and properly registered.
-    const opened = await openDialog();
-    if (opened)
-        return null;
-    const spawnOptionsForDialogs = {
-        options: {
-            customData: {
-                foreign: {
-                    clients: {
-                        dialogManager: {
-                            isDialog: true,
-                        },
-                    },
-                },
-            },
-        },
-    };
-    const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
-    // Otherwise, launch the dialog and then wait for it to register. Since registration is an asynchronous activity
-    // we are forced to poll.
-    const { error } = await LauncherClient.spawn(type, spawnOptionsForDialogs);
-    if (error) {
-        const errorMessage = `DialogManagerClient.open launching dialog "${type}" error ${error}`;
-        Logger.system.error(errorMessage);
-        return errorMessage;
-    }
-    else {
-        // The dialog was successfully launched, now we poll for up to 30 seconds waiting for it to register
-        const timeout = 30000;
-        for (let i = 0; i < 15; i++) {
-            if (await openDialog())
-                return null;
-            else
-                await sleep(timeout / 15);
-        }
-        const errorMessage = `DialogManagerClient.open error opening dialog "${type}. The dialog launched but didn't register within ${timeout} ms`;
-        Logger.system.error(errorMessage);
-        return errorMessage;
-    }
-};
-// ///////////////////////////////////////////
-// Server Side Functions (Becoming a Dialog Window)
-// ///////////////////////////////////////////
-// Currently unused internally
-/**
- * Called from within a dialog window to get the `inputParams` passed by the originating window when
- * it called `spawnDialog()`.
- *
- * ```javascript
- * var dialogData = await FSBL.Clients.DialogManager.getParametersFromInDialog();
- * ```
- */
-export const getParametersFromInDialog = async () => {
-    // For legacy reasons, this function wasn't async and so there's a possibility that spawnData might
-    // not be set yet, but unlikely given how the API is used
-    const controller = await getControllerInstance();
-    const { inputParams } = controller.spawnData;
-    Logger.system.debug(`DialogManagerClient:getParametersFromInDialog: ${JSON.stringify(inputParams)}`);
-    return inputParams;
-};
-// Currently unused internally
-/**
- * Called within a dialog to pass a response back to the originating window.
- * This will invoke the originating window's callback function that it passed to `spawnDialog()`.
- *
- * ```javascript
- * FSBL.Clients.DialogManager.respondAndExitFromInDialog({ choice: response });
- * ```
- * @param {object} responseParameters Data to be returned to the originating window's callback
- */
-export const respondAndExitFromInDialog = async (responseParameters) => {
-    // For legacy reasons, this function wasn't async and so there's a possibility that spawnData might
-    // not be set yet, but unlikely given how the API is used
-    const controller = await getControllerInstance();
-    Logger.system.debug(`DialogManagerClient:respondAndExitFromInDialog: ${JSON.stringify(responseParameters)}`);
-    const { responseChannel } = controller.spawnData;
-    RouterClient.transmit(responseChannel, responseParameters);
-};
-/**
- * Must be called by the dialog window when it is ready to be displayed.
- */
-export const showDialog = async () => {
-    var _a;
-    const controller = await getControllerInstance();
-    const myWindowIdentifier = await getMyWindowIdentifier();
-    const listenerChannel = generateDialogReadyChannel(myWindowIdentifier);
-    // tells the dialog manager in the opening window that the dialog is ready to be shown.
-    RouterClient.transmit(listenerChannel, {
-        userInputTimeout: (_a = controller.userInputTimeout) !== null && _a !== void 0 ? _a : 10000,
-    });
-};
-/**
- * Dialog windows *must* run this method so that results can be sent back to
- * originating windows. This method must *only* be run once in any given dialog window.
- *
- * ```javascript
- * FSBL.Clients.DialogManager.registerDialogCallback((err, request) => {
- *    if(err) return;
- *    console.log("Originating window sent", request.data);
- *    request.sendQueryResponse("your response");
- *    FSBL.System.Window.getCurrent().hide();
- * });
- *
- * ```
- *
- * @param {function} callback Callback that is invoked when the originating window
- * connects. Data passed by the originating window can be found in the `data` member of the
- * second parameter to the callback.
- */
-export const registerDialogCallback = async (cb) => {
-    const controller = await getControllerInstance();
-    if (controller.RESPONDER_CHANNEL) {
-        RouterClient.addResponder(controller.RESPONDER_CHANNEL, (err, message) => {
-            // Keep a local copy of the inquiry so that `respondToOpener()` can be
-            // called asynchronously to respond
-            if (message)
-                controller.openerMessage = message;
-            cb === null || cb === void 0 ? void 0 : cb(err, message);
-        });
-    }
-};
-/**
- * Dialogs may call this to respond to the originating window (instead of responding
- * directly to callbacks from `registerDialogCallback()`). The main advantage of using
- * this method is that it automatically hides the dialog.
- *
- * The modal scrim will automatically be hidden unless `data` is an object with
- * member `hideModalOnClose` set to `false`.
- *
- * @param {any} data Data to be passed back to the originating window.
- */
-export const respondToOpener = async (data) => {
-    var _a, _b;
-    const controller = await getControllerInstance();
-    Logger.system.info("DialogManagerClient:RespondToOpener:", data);
-    (_a = controller.openerMessage) === null || _a === void 0 ? void 0 : _a.sendQueryResponse(null, data);
-    if ((data === null || data === void 0 ? void 0 : data.hideModalOnClose) !== false) {
-        hideModal();
-    }
-    (_b = controller.finsembleWindow) === null || _b === void 0 ? void 0 : _b.hide();
-    controller.openerMessage = null;
-};
-/**
- * @ignore
- */
-export const DialogManagerClient = {
-    /**
-     * Used to set a timeout. This will be refactored.
-     */
-    set userInputTimeout(timeout) {
-        const controller = singleton("DialogManagerClient", DialogManagerClientController);
-        controller.userInputTimeout = timeout;
-    },
-    /**
-     * Used to check response from dialog. This will be refactored.
-     */
-    get openerMessage() {
-        const controller = singleton("DialogManagerClient", DialogManagerClientController);
-        return controller.openerMessage;
-    },
-    /**
-     * For backward compatibility
-     * @private
-     * @deprecated
-     */
-    initialize: () => {
-        Logger.system.deprecated("It is no longer necessary to call DialogManager.initialize()");
-    },
-    /**
-     * For backward compatibility
-     * @private
-     * @deprecated
-     */
-    onReady: (cb) => {
-        Logger.system.deprecated("It is no longer necessary to call DialogManager.onReady()");
-        cb === null || cb === void 0 ? void 0 : cb();
-    },
-    createStore: (cb) => {
-        Logger.system.deprecated("DialogManager.createStore() is an internal function. It has been deprecated and will be removed in a future release.");
-        const controller = singleton("DialogManagerClient", DialogManagerClientController);
-        return controller.createStore(cb);
-    },
-    getAvailableDialog: (type, cb) => {
-        Logger.system.deprecated("DialogManager.getAvailableDialog() is an internal function. It has been deprecated and will be removed in a future release.");
-        const controller = singleton("DialogManagerClient", DialogManagerClientController);
-        return controller.getAvailableDialog(type, cb);
-    },
-    sendQueryToDialog: (identifier, options, onUserInput) => {
-        Logger.system.deprecated("DialogManager.sendQueryToDialog() is an internal function. It has been deprecated and will be removed in a future release.");
-        return sendQueryToDialog(identifier, options, onUserInput);
-    },
-    open,
-    spawnDialog,
-    registerDialogCallback,
-    getParametersFromInDialog,
-    respondAndExitFromInDialog,
-    showDialog,
-    registerModal,
-    showModal,
-    hideModal,
-    respondToOpener,
-};
-/**
- * @ignore
- */
-export default DialogManagerClient;
-//# sourceMappingURL=dialogManagerClient.js.map