@finsemble/finsemble-ui 8.3.0-beta.8 → 8.3.1

package/platform/services/window/WindowAbstractions/stackedWindowWrapper.js

@@ -1,680 +0,0 @@
-import { RouterClient } from "../../../../clients/routerClient";
-import { Logger } from "../../../../clients/logger";
-import * as util from "../../../../common/util";
-import { BaseWindow } from "./BaseWindow";
-import { WINDOWSTATE } from "../../../../common/constants";
-import StackedWindowManager from "../StackedWindowManager/stackedWindowManager";
-class StackedWindow extends BaseWindow {
-    constructor(params) {
-        super(params);
-        this.params = params;
-        this.windowState = WINDOWSTATE.NORMAL;
-        this._listeners = {};
-        this.bindAllFunctions();
-        this.addListeners();
-    }
-    removeListeners() {
-        Logger.system.debug("removeListeners not implemented");
-    }
-    _setResizable() {
-        Logger.system.error("_setResizable not implemented");
-    }
-    addListeners() {
-        this.addEventListener("minimized", () => {
-            // we set the new windowState based on whether the current windowState is maximized or normal.
-            // if it is not either of those things, that means it is already in a minimized state, so we don't do anything.
-            if (this.windowState === WINDOWSTATE.MAXIMIZED) {
-                this.windowState = WINDOWSTATE.MINIMIZED_WAS_MAXIMIZED;
-                this.windowOptions.windowState = WINDOWSTATE.MINIMIZED_WAS_MAXIMIZED;
-            }
-            else if (this.windowState === WINDOWSTATE.NORMAL) {
-                this.windowState = WINDOWSTATE.MINIMIZED_WAS_NORMAL;
-                this.windowOptions.windowState = WINDOWSTATE.MINIMIZED_WAS_NORMAL;
-            }
-            else {
-                Logger.system.warn("Invalid window state received listening to window minimize", this.windowState);
-            }
-        });
-        this.addEventListener("restored", () => {
-            this.windowState = WINDOWSTATE.NORMAL;
-            this.windowOptions.windowState = WINDOWSTATE.NORMAL;
-        });
-        this.addEventListener("maximized", () => {
-            this.windowState = WINDOWSTATE.MAXIMIZED;
-            this.windowOptions.windowState = WINDOWSTATE.MAXIMIZED;
-        });
-    }
-    _addEventListener(params, handler = Function.prototype) {
-        const { eventName } = params;
-        this.addEventListener(eventName, handler);
-    }
-    addEventListener(event, handler = Function.prototype) {
-        super.addEventListener(event, handler);
-        // ..need to add a listener on the child window...
-    }
-    _removeEventListener(params, handler = Function.prototype) {
-        const { eventName } = params;
-        this.removeEventListener(eventName, handler);
-    }
-    removeEventListener(event, handler = Function.prototype) {
-        super.removeEventListener(event, handler);
-        // ..need to add a listener on the child window...
-    }
-    eventChannelName(channelTopic) {
-        return `StackedWindow-${this.name}-${channelTopic}`;
-    }
-    bindAllFunctions() {
-        const self = this;
-        for (const name of Object.getOwnPropertyNames(Object.getPrototypeOf(self))) {
-            if (self[name] instanceof Function) {
-                self[name] = self[name].bind(self); // only bind function properties
-            }
-        }
-    }
-    // wrapper function to listen to bounds changing, but need a better/generalized solution
-    listenForBoundsChanging() {
-        const eventHandler = (err, message) => {
-            Logger.system.debug("StackedWindow incoming transmit", this.eventChannelName("bounds-change-request"), message.data);
-            // bounds changing will come in from the child window. We need to overwrite the name so that docking thinks it's the stack being moved, not the child.
-            message.data.name = this.name;
-            this.eventManager.trigger("bounds-change-request", message.data);
-        };
-        RouterClient.addListener(this.eventChannelName("bounds-change-request"), eventHandler);
-    }
-    // ////////////////////////////////////////////////////////////////////////////////////////////////////
-    // Housekeeping function for private window methods
-    // ////////////////////////////////////////////////////////////////////////////////////////////////////
-    /**
-     * Handles common housekeeping checks and modifications on params at the beginning of each private window function
-     *
-     * @param {string} methodName method name (e.g. "minimize", "maximize")
-     * @param {object} params
-     * @memberof StackedWindow
-     * @private
-     */
-    _privatePreface(methodName, params) {
-        if (!params || typeof params === "function") {
-            // if function then assume callback was passed in with no params
-            params = {};
-        }
-        const fullParams = util.clone(params); // clone so params from calling function won't be modified (and cause other problems)
-        fullParams.stackedWindowIdentifier = {
-            windowName: this.identifier.windowName,
-            windowType: this.identifier.windowType,
-        }; // add this window's identifier
-        Logger.system.debug(`StackedWindow.${methodName} _privatePreface`, fullParams);
-        const eventBlackList = ["_saveWindowOptions", "_setBounds"];
-        if (eventBlackList.includes(methodName)) {
-            // if method in event blacklist, then set parameter to skip sending event
-            fullParams.doNotTransmitEvent = true;
-        }
-        return fullParams;
-    }
-    // ////////////////////////////////////////////////////////////////////////////////////////////////////
-    // Private window functions, fulfilled through requests to "super" and Stacked Window Manager Module
-    // ////////////////////////////////////////////////////////////////////////////////////////////////////
-    _minimize(params, callback = Function.prototype) {
-        const promiseResolver = (resolve) => {
-            callback = typeof params === "function" ? params : callback; // if callback is the only argument
-            params = this._privatePreface("_minimize", params);
-            super._minimize(params, (err, response) => {
-                if (!err && response.shouldContinue) {
-                    StackedWindowManager.minimize(params, (minimizeErr, minimizeResponse) => {
-                        callback(minimizeErr, minimizeResponse);
-                        resolve({ minimizeErr, data: minimizeResponse });
-                    });
-                }
-                else {
-                    callback(err, response);
-                    resolve({ err, data: response });
-                }
-            });
-        };
-        return new Promise(promiseResolver);
-    }
-    _maximize(params, callback = Function.prototype) {
-        callback = typeof params === "function" ? params : callback; // if callback is the only argument
-        if (this.windowState === WINDOWSTATE.MAXIMIZED) {
-            callback();
-            return Promise.resolve();
-        }
-        const promiseResolver = (resolve) => {
-            params = this._privatePreface("_maximize", params);
-            StackedWindowManager.maximize({
-                stackedWindowIdentifier: Object.assign({}, this.identifier),
-                windowIdentifier: this.identifier,
-                invokedByParent: false,
-            }, (maximizeErr, maximizeResponse) => {
-                this.windowState = WINDOWSTATE.MAXIMIZED;
-                this.eventManager.trigger("maximized");
-                callback(maximizeErr, maximizeResponse);
-                resolve({ maximizeErr, data: maximizeResponse });
-            });
-        };
-        return new Promise(promiseResolver);
-    }
-    async _restore(params, cb) {
-        if (this.windowState === WINDOWSTATE.MINIMIZED_WAS_MAXIMIZED) {
-            await this._maximize(params);
-            cb === null || cb === void 0 ? void 0 : cb(null, { shouldContinue: true });
-            return { data: { shouldContinue: true } };
-        }
-        const promiseResolver = (resolve) => {
-            params = this._privatePreface("_restore", params);
-            StackedWindowManager.restore({
-                stackedWindowIdentifier: Object.assign({}, this.identifier),
-                windowIdentifier: this.identifier,
-                invokedByParent: false,
-                windowState: this.windowState,
-                checkMinimize: false,
-            }, (restoreErr, restoreResponse) => {
-                Logger.system.debug("StackedWindowManager.restore callback", restoreErr, restoreResponse);
-                this.windowState = WINDOWSTATE.NORMAL;
-                this.eventManager.trigger("restored");
-                cb === null || cb === void 0 ? void 0 : cb(restoreErr, restoreResponse);
-                resolve({ restoreErr, data: restoreResponse });
-            });
-        };
-        return new Promise(promiseResolver);
-    }
-    _focus(params, callback = Function.prototype) {
-        const promiseResolver = (resolve) => {
-            callback = typeof params === "function" ? params : callback; // if callback is the only argument
-            params = this._privatePreface("_focus", params);
-            super._focus(params, (err, response) => {
-                if (!err && response.shouldContinue) {
-                    StackedWindowManager.focus(params, (focusErr, focusResponse) => {
-                        Logger.system.debug("StackedWindowManager.focus callback", focusErr, focusResponse);
-                        callback(focusErr, focusResponse);
-                        resolve({ focusErr, data: focusResponse });
-                    });
-                }
-                else {
-                    callback(err, response);
-                    resolve({ err, data: response });
-                }
-            });
-        };
-        return new Promise(promiseResolver);
-    }
-    _bringToFront(params, callback = Function.prototype) {
-        const promiseResolver = (resolve) => {
-            callback = typeof params === "function" ? params : callback; // if callback is the only argument
-            params = this._privatePreface("_bringToFront", params);
-            super._bringToFront(params, (err, response) => {
-                if (!err && response.shouldContinue) {
-                    StackedWindowManager.bringToFront(params, (bringToFrontErr, bringToFrontResponse) => {
-                        Logger.system.debug("StackedWindowManager.bringToFront callback", bringToFrontErr, bringToFrontResponse);
-                        callback(bringToFrontErr, bringToFrontResponse);
-                        resolve({ bringToFrontErr, data: bringToFrontResponse });
-                    });
-                }
-                else {
-                    callback(err, response);
-                    resolve({ err, data: response });
-                }
-            });
-        };
-        return new Promise(promiseResolver);
-    }
-    _saveWindowOptions(params, callback = Function.prototype) {
-        const promiseResolver = (resolve) => {
-            callback = typeof params === "function" ? params : callback; // if callback is the only argument
-            params = this._privatePreface("_saveWindowOptions", params);
-            super._saveWindowOptions(params, (err, response) => {
-                if (!err && response.shouldContinue) {
-                    StackedWindowManager.saveWindowOptions({ closing: false }, this, (saveWindowOptionsErr, saveWindowOptionsResponse) => {
-                        Logger.system.debug("StackedWindowManager.saveWindowOptions callback", saveWindowOptionsErr, saveWindowOptionsResponse);
-                        callback(saveWindowOptionsErr, saveWindowOptionsResponse);
-                        resolve({
-                            saveWindowOptionsErr,
-                            data: saveWindowOptionsResponse,
-                        });
-                    });
-                }
-                else {
-                    callback(err, response);
-                    resolve({ err, data: response });
-                }
-            });
-        };
-        return new Promise(promiseResolver);
-    }
-    _setBounds(params, callback = Function.prototype) {
-        const promiseResolver = (resolve) => {
-            callback = typeof params === "function" ? params : callback; // if callback is the only argument
-            params = this._privatePreface("_setBounds", params);
-            super._setBounds(params, (err, response) => {
-                if (!err && response.shouldContinue) {
-                    StackedWindowManager.setBounds(params, (setBoundsErr, setBoundsResponse) => {
-                        Logger.system.debug("StackedWindowManager.setBounds callback", setBoundsErr, setBoundsResponse);
-                        callback(setBoundsErr, setBoundsResponse);
-                        resolve({ setBoundsErr, data: setBoundsResponse });
-                    });
-                }
-                else {
-                    callback(err, response);
-                    resolve({ err, data: response });
-                }
-            });
-        };
-        return new Promise(promiseResolver);
-    }
-    _getBoundsFromSystem(params, callback = Function.prototype) {
-        const promiseResolver = (resolve) => {
-            callback = typeof params === "function" ? params : callback; // if callback is the only argument
-            params = this._privatePreface("_getBoundsFromSystem", params);
-            super._getBoundsFromSystem(params, (err, response) => {
-                if (!err && response.shouldContinue) {
-                    StackedWindowManager.getBoundsFromSystem(params, (innerErr, innerResponse) => {
-                        Logger.system.debug("StackedWindowManager.getBoundsFromSystem callback", innerErr, innerResponse);
-                        callback(innerErr, innerResponse);
-                        resolve({ innerErr, data: innerResponse });
-                    });
-                }
-                else {
-                    callback(err, response);
-                    resolve({ err, data: response });
-                }
-            });
-        };
-        return new Promise(promiseResolver);
-    }
-    _getBounds(params, cb) {
-        const promiseResolver = (resolve) => {
-            cb = typeof params === "function" ? params : cb; // if callback is the only argument
-            params = this._privatePreface("_getBounds", params);
-            super._getBounds(params, (err, response) => {
-                if (!err && response.shouldContinue) {
-                    StackedWindowManager.getBounds(params, (setBoundsErr, setBoundsResponse) => {
-                        Logger.system.debug("StackedWindowManager.getBounds callback", setBoundsErr, setBoundsResponse);
-                        cb === null || cb === void 0 ? void 0 : cb(setBoundsErr, setBoundsResponse);
-                        resolve({ setBoundsErr, data: setBoundsResponse });
-                    });
-                }
-                else {
-                    cb === null || cb === void 0 ? void 0 : cb(err, response);
-                    resolve({ err, data: response });
-                }
-            });
-        };
-        return new Promise(promiseResolver);
-    }
-    /**
-     * Is Window Visible?
-     * @param {*} params Currently unused
-     * @param {*} callback returns true in response if showing, false otherwise
-     */
-    _isShowing(params, callback = Function.prototype) {
-        const promiseResolver = (resolve) => {
-            callback = typeof params === "function" ? params : callback; // if callback is the only argument
-            params = this._privatePreface("_isShowing", params);
-            super._isShowing(params, (err, response) => {
-                if (!err && response.shouldContinue) {
-                    StackedWindowManager.isStackShowing(params, (isShowingErr, isShowingResponse) => {
-                        Logger.system.debug("StackedWindowManager.getBounds callback", isShowingErr, isShowingResponse);
-                        callback(isShowingErr, isShowingResponse);
-                        resolve({ isShowingErr, data: isShowingResponse });
-                    });
-                }
-                else {
-                    callback(err, response);
-                    resolve({ err, data: response });
-                }
-            });
-        };
-        return new Promise(promiseResolver);
-    }
-    _updateOptions(params, callback = Function.prototype) {
-        const promiseResolver = (resolve) => {
-            callback = typeof params === "function" ? params : callback; // if callback is the only argument
-            params = this._privatePreface("_updateOptions", params);
-            super._updateOptions(params, (err, response) => {
-                if (!err && response.shouldContinue) {
-                    StackedWindowManager.updateOptions(params, (updateOptionsErr, updateOptionsResponse) => {
-                        Logger.system.debug("StackedWindowManager.updateOptions callback", updateOptionsErr, updateOptionsResponse);
-                        callback(updateOptionsErr, updateOptionsResponse);
-                        resolve({ updateOptionsErr, data: updateOptionsResponse });
-                    });
-                }
-                else {
-                    callback(err, response);
-                    resolve({ err, data: response });
-                }
-            });
-        };
-        return new Promise(promiseResolver);
-    }
-    _hide(params, callback = Function.prototype) {
-        const promiseResolver = (resolve) => {
-            callback = typeof params === "function" ? params : callback; // if callback is the only argument
-            params = this._privatePreface("_hide", params);
-            super._hide(params, (err, response) => {
-                if (!err && response.shouldContinue) {
-                    StackedWindowManager.hide(params, (hideErr, hideResponse) => {
-                        Logger.system.debug("StackedWindowManager.hide callback", hideErr, hideResponse);
-                        callback(hideErr, hideResponse);
-                        resolve({ hideErr, data: hideResponse });
-                    });
-                }
-                else {
-                    callback(err, response);
-                    resolve({ err, data: response });
-                }
-            });
-        };
-        return new Promise(promiseResolver);
-    }
-    async _show(params, cb) {
-        const fullParams = this._privatePreface("_show", params);
-        const { err, data } = await super._show(fullParams);
-        if (!err && (data === null || data === void 0 ? void 0 : data.shouldContinue)) {
-            const { err: showErr, data: showResponse } = await StackedWindowManager.show(fullParams);
-            Logger.system.debug("StackedWindowManager.show callback", showErr, showResponse);
-            cb === null || cb === void 0 ? void 0 : cb(showErr, showResponse);
-            return { err: showErr, data: showResponse };
-        }
-        else {
-            cb === null || cb === void 0 ? void 0 : cb(err, data);
-            return { err, data };
-        }
-    }
-    _showAt(params, callback = Function.prototype) {
-        const promiseResolver = (resolve) => {
-            callback = typeof params === "function" ? params : callback; // if callback is the only argument
-            params = this._privatePreface("_showAt", params);
-            super._showAt(params, (err, response) => {
-                callback(err, response);
-                resolve({ err, data: response });
-            });
-        };
-        return new Promise(promiseResolver);
-    }
-    _close(params = {}, cb) {
-        return new Promise((resolve) => {
-            cb = typeof params === "function" ? params : cb; // if callback is the only argument
-            params = this._privatePreface("_close", params);
-            super._close(params, (err, response) => {
-                if (!err && (response === null || response === void 0 ? void 0 : response.shouldContinue)) {
-                    StackedWindowManager.close(params, (closeErr, closeResponse = {}) => {
-                        Logger.system.debug("StackedWindowManager.close callback", closeErr, closeResponse);
-                        cb === null || cb === void 0 ? void 0 : cb(closeErr, {
-                            shouldContinue: closeResponse.shouldContinue || false,
-                        });
-                        resolve({
-                            err: closeErr,
-                            data: { shouldContinue: closeResponse.shouldContinue || false },
-                        });
-                    });
-                }
-                else {
-                    cb === null || cb === void 0 ? void 0 : cb(err, { shouldContinue: false });
-                    resolve({ err, data: { shouldContinue: false } });
-                }
-            });
-        });
-    }
-    _alwaysOnTop(params, callback = Function.prototype) {
-        const promiseResolver = (resolve) => {
-            callback = typeof params === "function" ? params : callback; // if callback is the only argument
-            params = this._privatePreface("_alwaysOnTop", params);
-            super._alwaysOnTop(params, (err, response) => {
-                if (!err && response.shouldContinue) {
-                    StackedWindowManager.setAlwaysOnTop(params, (alwaysOnTopErr, alwaysOnTopResponse) => {
-                        Logger.system.debug("StackedWindowManager.alwaysOnTop callback", alwaysOnTopErr, alwaysOnTopResponse);
-                        callback(alwaysOnTopErr, alwaysOnTopResponse);
-                        resolve({ alwaysOnTopErr, data: alwaysOnTopResponse });
-                    });
-                }
-                else {
-                    callback(err, response);
-                    resolve({ err, data: response });
-                }
-            });
-        };
-        return new Promise(promiseResolver);
-    }
-    /**
-     *
-     * Returns true if the window is always on top. False otherwise.
-     *
-     * Disable eslint below because params is undefined, but we don't want to refactor the other calls to expect the 1st param to equal the callback.
-     */
-    _isAlwaysOnTop(params = {}, callback = Function.prototype) {
-        // eslint-disable-line
-        this.alwaysOnTop = Boolean(this.alwaysOnTop);
-        callback(null, this.alwaysOnTop);
-        return this.alwaysOnTop;
-    }
-    _setOpacity(params, callback = Function.prototype) {
-        const promiseResolver = (resolve) => {
-            callback = typeof params === "function" ? params : callback; // if callback is the only argument
-            params = this._privatePreface("_setOpacity", params);
-            super._setOpacity(params, (err, response) => {
-                if (!err && response.shouldContinue) {
-                    StackedWindowManager.setOpacity(params, (setOpacityErr, setOpacityResponse) => {
-                        Logger.system.debug("StackedWindowManager.setOpacity callback", setOpacityErr, setOpacityResponse);
-                        callback(setOpacityErr, setOpacityResponse);
-                        resolve({ setOpacityErr, data: setOpacityResponse });
-                    });
-                }
-                else {
-                    callback(err, response);
-                    resolve({ err, data: response });
-                }
-            });
-        };
-        return new Promise(promiseResolver);
-    }
-    // //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-    // //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-    // CLEANUP NOTE:
-    //
-    // WHEN NEW TABBING INTERFACE IS PROVIDED TO PRESENTATION COMPONENTS, THEN ALL THE BELOW FUNCTIONS WILL BE REMOVED - THEY BECOME INTERNAL TO WINDOW SERVICE
-    //
-    // //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-    // ////////////////////////////////////////////////////////////////////////////////////////////////////
-    // Housekeeping function for window management methods
-    // ////////////////////////////////////////////////////////////////////////////////////////////////////
-    /**
-     * Handles common housekeeping checks and modifications on params at the beginning of each private window-management function
-     *
-     * @param {string} methodName method name (e.g. "minimize", "maximize")
-     * @param {object} params
-     * @memberof StackedWindow
-     * @private
-     */
-    _privateManagementPreface(methodName, params) {
-        if (typeof params === "function") {
-            Logger.system.error("StackedWindowWrapper.wrapPreface bad params", params);
-        }
-        params = params || {};
-        params.stackedWindowIdentifier = {
-            windowName: this.identifier.windowName,
-            windowType: this.identifier.windowType,
-        }; // add this window's identifier
-        Logger.system.debug(`StackedWindow.${methodName}  _privateManagementPreface`, params);
-        return params;
-    }
-    /**
-     * Temporary function until more cleanup done. Handles common housekeeping checks and modifications on params at the beginning of each private window-management function
-     *
-     * @param {string} methodName method name (e.g. "minimize", "maximize")
-     * @param {object} params
-     * @memberof StackedWindow
-     * @private
-     */
-    _newPrivateManagementPreface(methodName, params) {
-        if (typeof params === "function") {
-            Logger.system.error("StackedWindowWrapper.wrapPreface bad params", params);
-        }
-        params = params || {};
-        params.stackedWindowIdentifier = {
-            windowName: this.identifier.windowName,
-            windowType: this.identifier.windowType,
-        }; // add this window's identifier
-        Logger.system.debug(`StackedWindow.${methodName}  _newPrivateManagementPreface`, params);
-        return params;
-    }
-    // //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-    // Below are the stackedWindow management functions (again fulfilled through requests to the Stacked Window Manager
-    // //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-    // temporarily need to support both private and public management function -- later only window service will invoke (i.e. no public interfaces)
-    _removeWindow(params, callback = Function.prototype) {
-        const promiseResolver = (resolve) => {
-            callback = typeof params === "function" ? params : callback; // if callback is the only argument
-            params = this._newPrivateManagementPreface("_removeWindow", params);
-            StackedWindowManager.removeWindow(params, (err, response) => {
-                Logger.system.debug("StackedWindowManager.removeWindow callback", err, response);
-                callback(err, response);
-                resolve({ err, data: response });
-            });
-        };
-        return new Promise(promiseResolver);
-    }
-    /**
-     * Adds window as a child to a stacked window.  Adds to the top of the stack, or if specified to a specific location in the stack;
-     *
-     * @param {object=} params
-     * @param {object} params.stackedWindowIdentifier stacked window to operate on stacked window to operate on
-     * @param {object} params.windowIdentifier window to add
-     * @param {number=} params.position the location in the stack to push the window.  Location 0 is the bottom of the stack. Defaults to the top of stack.
-     * @param {boolean=} params.noSave if true then don't save the store after updating it (will be saved by caller)
-     * @param {function=} callback function(err)
-     * @memberof StackedWindow
-     */
-    addWindow(params, callback = Function.prototype) {
-        params = this._privateManagementPreface("addWindow", params);
-        const promiseResolver = (resolve) => {
-            RouterClient.query("StackedWindow.addWindow", params, (err, queryResponseMessage) => {
-                Logger.system.debug("StackedWindow.addWindow callback", err, queryResponseMessage);
-                callback(err, queryResponseMessage.data);
-                resolve({ err, data: queryResponseMessage.data });
-            });
-        };
-        return new Promise(promiseResolver);
-    }
-    /**
-     * Removes a child window from a stacked window.  If removed window was visible, then the bottom child window (position 0) in stack will be made visible.
-     *
-     * @param {object} params
-.	 * @param {object} params.stackedWindowIdentifier stacked window to operate on
-     * @param {object} params.windowIdentifier window to remove
-     * @param {boolean=} params.noDocking if true then do not register removed window with docking (the workspace is unaffected)
-     * @param {function=} callback function(err)
-     * @memberof StackedWindow
-     */
-    removeWindow(params, callback = Function.prototype) {
-        params = this._privateManagementPreface("removeWindow", params);
-        const promiseResolver = (resolve) => {
-            RouterClient.query("StackedWindow.removeWindow", params, (err, queryResponseMessage) => {
-                Logger.system.debug("StackedWindow.removeWindow callback", err, queryResponseMessage);
-                callback(err, queryResponseMessage.data);
-                resolve({ err, data: queryResponseMessage.data });
-            });
-        };
-        return new Promise(promiseResolver);
-    }
-    /**
-     * Removes a window from the stack then closes it.  If removed window was visible, then the bottom child window (position 0) in stack will be made visible.
-     *
-     * @param {object} params
-.	 * @param {object} params.stackedWindowIdentifier stacked window to operate on
-     * @param {object} params.windowIdentifier window to delete
-     * @param {function=} callback function(err)
-     * @memberof StackedWindow
-     */
-    deleteWindow(params, callback = Function.prototype) {
-        params = this._privateManagementPreface("deleteWindow", params);
-        const promiseResolver = (resolve) => {
-            RouterClient.query("StackedWindow.deleteWindow", params, (err, queryResponseMessage) => {
-                Logger.system.debug("StackedWindow.deleteWindow callback", err, queryResponseMessage);
-                callback(err, queryResponseMessage.data);
-                resolve({ err, data: queryResponseMessage.data });
-            });
-        };
-        return new Promise(promiseResolver);
-    }
-    /**
-     * Sets the visible window within the stack.  The previously visible window in stack will be automatically hidden.
-     *
-     * @param {object} params
-.	 * @param {object} params.stackedWindowIdentifier stacked window to operate on
-     * @param {object} params.windowIdentifier
-     * @param {function=} callback function(err)
-     * @memberof StackedWindow
-     */
-    setVisibleWindow(params, callback = Function.prototype) {
-        params = this._privateManagementPreface("setVisibleWindow", params);
-        const promiseResolver = (resolve) => {
-            RouterClient.query("StackedWindow.setVisibleWindow", params, (err, queryResponseMessage) => {
-                Logger.system.debug("StackedWindow.setVisibleWindow callback", err, queryResponseMessage);
-                callback(err, queryResponseMessage.data);
-                resolve({ err, data: queryResponseMessage.data });
-            });
-        };
-        return new Promise(promiseResolver);
-    }
-    /**
-     * Reorders the stack, but odes not affect visibility
-     *
-     * @param {object} params
-.	 * @param {object} params.stackedWindowIdentifier stacked window to operate on
-     * @param {array} params.windowIdentifiers array of windowIdentifiers which provides the new order
-     * @param {function=} callback function(err)
-     * @memberof StackedWindow
-     */
-    reorder(params, callback = Function.prototype) {
-        params = this._privateManagementPreface("reorder", params);
-        const promiseResolver = (resolve) => {
-            RouterClient.query("StackedWindow.reorder", params, (err, queryResponseMessage) => {
-                Logger.system.debug("StackedWindow.reorder callback", err, queryResponseMessage);
-                callback(err, queryResponseMessage.data);
-                resolve({ err, data: queryResponseMessage.data });
-            });
-        };
-        return new Promise(promiseResolver);
-    }
-    /**
-     * Reorders the stack, but odes not affect visibility
-     *
-     * @param {object} params
-.	 * @param {object} params.stackedWindowIdentifier stacked window to operate on
-     * @param {array} params.windowIdentifiers array of windowIdentifiers which provides the new order
-     * @param {function=} callback function(err)
-     * @memberof StackedWindow
-     */
-    stopMove(params = {}, callback = Function.prototype) {
-        params = this._privateManagementPreface("stopMove", params);
-        const promiseResolver = (resolve) => {
-            RouterClient.query("StackedWindow.stopMove", params, (err, queryResponseMessage) => {
-                Logger.system.debug("StackedWindow.stopMove callback", err, queryResponseMessage);
-                callback(err, queryResponseMessage.data);
-                resolve({ err, data: queryResponseMessage.data });
-            });
-        };
-        return new Promise(promiseResolver);
-    }
-    /**
- * Reorders the stack, but odes not affect visibility
- *
-     * @param {object} params
-.	 * @param {object} params.stackedWindowIdentifier stacked window to operate on
- * @param {array} params.windowIdentifiers array of windowIdentifiers which provides the new order
- * @param {function=} callback function(err)
- * @memberof StackedWindow
- */
-    startMove(params = {}, callback = Function.prototype) {
-        params = this._privateManagementPreface("startMove", params);
-        const promiseResolver = (resolve) => {
-            RouterClient.query("StackedWindow.startMove", params, (err, queryResponseMessage) => {
-                Logger.system.debug("StackedWindow.startMove callback", err, queryResponseMessage);
-                callback(err, queryResponseMessage.data);
-                resolve({ err, data: queryResponseMessage.data });
-            });
-        };
-        return new Promise(promiseResolver);
-    }
-}
-export default StackedWindow;
-//# sourceMappingURL=stackedWindowWrapper.js.map