@finsemble/finsemble-ui 8.0.2 → 8.1.0-beta.2

package/platform/services/window/StackedWindowManager/stackedWindowManager.js

@@ -0,0 +1,1641 @@
+/*!
+ * Copyright 2017 - 2020 by ChartIQ, Inc.
+ * All rights reserved.
+ */
+// This file contains the service to manage all stacked windows.
+// The common/window/stackedWindow wrapper contains the primary interface. Also, common/StackedWindowManager contains interface to createStackedWindow used by Launcher.
+import { RouterClient } from "../../../../clients/routerClient";
+import { Logger } from "../../../../clients/logger";
+import { FinsembleWindowInternal } from "../WindowAbstractions/FinsembleWindowInternal";
+import { ConfigUtilInstance as ConfigUtil } from "../../../../common/configUtil";
+import * as constants from "../../../../common/constants";
+import { GroupPoolSingleton, MonitorPoolSingleton } from "../Common/Pools/PoolSingletons";
+import { BaseWindow } from "../WindowAbstractions/BaseWindow";
+import { each as asyncEach } from "async";
+import _throttle from "lodash/throttle";
+import BoxMath from "../Docking/boxMath";
+import { getMonitorByBounds } from "../../../../common/Monitors";
+/**
+ * Constructor for stackedWindow record -- this is what's saved in the store
+ *
+ * @param {any} stackedWindowIdentifier
+ * @memberof StackedWindowManager
+ * @private
+ */
+class WindowRecord {
+    constructor(stackedWindowIdentifier) {
+        this.identifier = stackedWindowIdentifier;
+        this.childWindowIdentifiers = [];
+        this.visibleWindowIdentifier = null;
+        this.bounds = null;
+    }
+}
+export class StackedWindowManager {
+    constructor(params) {
+        this.params = params; // keeps any params that ware passed in
+        this.childWindow = {}; // holds the wrapper for each child window
+        this.storeCache = {}; // maintains a local cache by window name of what what this service keeps in the global store; stays in sync because only this service writes to store
+        this.stackedWindowListeners = {}; // saves handles for listeners so can be removed (indexed by stacked window name)
+        this.stackedWindowWrappers = {}; // each stacked window has a wrapper so can invoke saveWindowOptions() to save workspace state
+        this.eventHandlerFunction = {}; // holds event handlers functions (needed to remove listeners)
+        this.childNameToSID = {}; // mapping from child window name to it parent stackedWindowIdentifier
+        /**
+         * The following events (and these only) should be propagated from the children to the stack.
+         */
+        this.childEventsToHandle = [
+            "maximized",
+            "minimized",
+            "restored",
+            "shown",
+            "hidden",
+            "focused",
+            "broughtToFront",
+            "setBounds",
+            "alwaysOnTop",
+            "setOpacity",
+            "bounds-change-request",
+            "bounds-change-end",
+            "bounds-changed",
+            "system-bounds-changed",
+        ];
+        this.bindAllFunctions();
+        window.StackedWindowManager = this;
+    }
+    initialize(finsembleConfig, callback = Function.prototype) {
+        // addReadyTimeout default should be larger than the router failover time (i.e. when failover goes to cross-domain) -- default fail over time adds up to 6 seconds
+        this.addReadyTimeout = ConfigUtil.getDefault(finsembleConfig, "finsembleConfig.stackedWindow.addReadyTimeout", 6500);
+        Logger.system.debug(`"StackedWindowManager addReadyTimeout ${this.addReadyTimeout}`);
+        this.setupStackedWindowServiceListeners();
+        this.listenForWorkspaceChanges();
+        callback();
+    }
+    bindAllFunctions() {
+        const self = this;
+        for (const name of Object.getOwnPropertyNames(Object.getPrototypeOf(self))) {
+            const method = self[name];
+            // skip constructor
+            if (!(method instanceof Function) || method === StackedWindowManager)
+                continue;
+            self[name] = self[name].bind(self);
+        }
+    }
+    // When the workspace is changed, we need to create a new queue. Without that, the system will wait until the old queue is complete (when it times out...).
+    listenForWorkspaceChanges() {
+        // RouterClient.addListener("WorkspaceService.switch", this.onWorkspaceChanging);
+    }
+    // /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+    // "Hidden" External Interfaces
+    // 		RouterClient.publish(`Finsemble.parentChange.${windowIdentifier.windowName}`, { type: "Added", stackedWindowIdentifier });
+    // 		RouterClient.publish(`Finsemble.parentChange.${windowIdentifier.windowName}`, { type: "Remove", stackedWindowIdentifier });
+    //
+    // /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+    // /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+    // Utility Functions
+    // /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+    /**
+     * Return true if the specified window in specified stack is showing
+     *
+     * @param {any} params
+     * @returns
+     * @memberof StackedWindowManager
+     * @private
+     */
+    isShowing(params) {
+        const { stackedWindowIdentifier, windowIdentifier } = params;
+        const thisStackRecord = this.storeCache[stackedWindowIdentifier.windowName];
+        //
+        return (windowIdentifier &&
+            thisStackRecord.visibleWindowIdentifier &&
+            windowIdentifier.windowName === thisStackRecord.visibleWindowIdentifier.windowName); // returns true if window is visible in stack
+    }
+    /**
+     * Return true if the specified window name is in the specified stack
+     *
+     * @param {any} params
+     * @returns
+     * @memberof StackedWindowManager
+     * @private
+     */
+    ifWindowInStack(params) {
+        const { thisStackRecord, windowName } = params;
+        let result = false;
+        for (let i = 0; i < thisStackRecord.childWindowIdentifiers.length; i++) {
+            if (thisStackRecord.childWindowIdentifiers[i].name === windowName) {
+                result = true;
+            }
+        }
+        return result; // true if the specified window name is in the stack
+    }
+    /**
+     * Return true if the params indication the wrap operation was invoked directly on the window, as opposed to directly on the childWindow
+     *
+     * @param {any} params
+     * @returns
+     * @memberof StackedWindowManager
+     * @private
+     */
+    operatingDirectlyOnStackedWindow(params) {
+        let result;
+        let { stackedWindowIdentifier, windowIdentifier } = params;
+        stackedWindowIdentifier = stackedWindowIdentifier || {};
+        if (!windowIdentifier || stackedWindowIdentifier.windowName === windowIdentifier.windowName) {
+            result = true; // must be a stacked window
+        }
+        else {
+            result = false; // must be operating on a child of a stacked window
+        }
+        return result;
+    }
+    /**
+     * Return current monitor for the given window bounds
+     * @param windowBounds
+     * @returns
+     * @private
+     */
+    getMonitor(windowBounds) {
+        var _a;
+        const overlaps = [];
+        for (const monitor of MonitorPoolSingleton.iterator()) {
+            const overlap = BoxMath.getOverlap(windowBounds, ((_a = monitor.rawMonitor) === null || _a === void 0 ? void 0 : _a.monitorRect) || monitor.availableRect);
+            overlaps.push({
+                monitor,
+                overlap,
+            });
+        }
+        // Gets the monitor with the greatest overlap. The reduce function pulls the proper object with the greats overlap value. We return the monitor property of that object.
+        return overlaps.reduce((prev, current) => (prev.overlap > current.overlap ? prev : current)).monitor;
+    }
+    /**
+     * Update child windows options on restore event
+     * @param stackWindow the parent stacked window
+     * @param restoredBounds the bounds after restoring
+     * @private
+     */
+    restoreChildren(stackWindow, restoredBounds) {
+        stackWindow.childWindowIdentifiers.forEach((childIdentifier) => {
+            const childWindow = this.childWindow[childIdentifier.windowName];
+            if (childWindow) {
+                childWindow.ignoreSystemRestore = false;
+                if (childWindow.windowState !== constants.WINDOWSTATE.NORMAL) {
+                    childWindow._restore({ invokedByParent: true });
+                }
+                childWindow._setBounds({ bounds: restoredBounds, invokedByParent: true });
+                if (childWindow.name !== stackWindow.visibleWindowIdentifier.windowName) {
+                    childWindow._hide({ invokedByParent: true });
+                }
+            }
+        });
+    }
+    /**
+     * Update child windows options on maximize event
+     * @param stackWindow the parent stacked window
+     * @private
+     */
+    maximizeChildren(stackWindow) {
+        const monitor = getMonitorByBounds(stackWindow.bounds);
+        stackWindow.childWindowIdentifiers.forEach((childIdentifier) => {
+            const childWindow = this.childWindow[childIdentifier.windowName];
+            if (childWindow) {
+                /**
+                 * Work around for a bug in which a switching tabs is triggering a system restore that would restore the window to its original size.
+                 * The ignoreSystemRestore flag is added before childWrapper._show to indicate that we are in a maximized state and *only* switching
+                 * tabs and therefore we do not want to restore the window.
+                 */
+                childWindow.ignoreSystemRestore = true;
+                if (childWindow.windowState !== constants.WINDOWSTATE.MAXIMIZED) {
+                    childWindow._maximize({ invokedByParent: true });
+                }
+                childWindow._setBounds({ bounds: monitor.availableRect, invokedByParent: true });
+                if (childWindow.name !== stackWindow.visibleWindowIdentifier.windowName) {
+                    childWindow._hide({ invokedByParent: true });
+                }
+            }
+        });
+    }
+    // ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+    // Setup router listeners to handing incoming service requests and events from child windows
+    // ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+    eventChannelName(stackedWindowName, channelTopic) {
+        return `StackedWindow-${stackedWindowName}-${channelTopic}`;
+    }
+    setupInterfaceListener(methodName, methodFunction) {
+        RouterClient.addResponder(`StackedWindow.${methodName}`, (err, queryMessage) => {
+            if (err) {
+                Logger.system.error(`StackedWindow.${methodName} addResponder failed: ${err}`);
+            }
+            else {
+                if (queryMessage === null || queryMessage === void 0 ? void 0 : queryMessage.data.windowIdentifier) {
+                    // Ensure that the WI has matching windowName and name (in case a client sends the wrong one).
+                    if (queryMessage.data.windowIdentifier.windowName) {
+                        queryMessage.data.windowIdentifier.name = queryMessage.data.windowIdentifier.windowName;
+                    }
+                    else if (queryMessage.data.windowIdentifier.name) {
+                        queryMessage.data.windowIdentifier.windowName = queryMessage.data.windowIdentifier.name;
+                    }
+                }
+                const callback = (error, response) => {
+                    queryMessage === null || queryMessage === void 0 ? void 0 : queryMessage.sendQueryResponse(error, response);
+                };
+                methodFunction(queryMessage === null || queryMessage === void 0 ? void 0 : queryMessage.data, callback);
+            }
+        });
+    }
+    setupStackedWindowServiceListeners() {
+        // window wrapper entry points
+        this.setupInterfaceListener("minimize", this.minimize);
+        this.setupInterfaceListener("maximize", this.maximize);
+        this.setupInterfaceListener("restore", this.restore);
+        this.setupInterfaceListener("focus", this.focus);
+        this.setupInterfaceListener("bringToFront", this.bringToFront);
+        this.setupInterfaceListener("saveWindowOptions", this.saveWindowStateToStore);
+        this.setupInterfaceListener("setBounds", this.setBounds);
+        this.setupInterfaceListener("getBounds", this.getBounds);
+        this.setupInterfaceListener("getBoundsFromSystem", this.getBoundsFromSystem);
+        this.setupInterfaceListener("startMove", this.startMove);
+        this.setupInterfaceListener("stopMove", this.stopMove);
+        // this.setupInterfaceListener("updateOptions", this.updateOptions);
+        this.setupInterfaceListener("hide", this.hide);
+        this.setupInterfaceListener("show", this.show);
+        this.setupInterfaceListener("close", this.close);
+        this.setupInterfaceListener("reorder", this.reorder);
+        this.setupInterfaceListener("alwaysOnTop", this.setAlwaysOnTop);
+        // this.setupInterfaceListener("setOpacity", this.setOpacity);
+        RouterClient.addResponder("StackedWindow.setOpacity", (err, queryMessage) => {
+            if (err) {
+                Logger.system.error(`StackedWindow.setOpacity addResponder failed: ${err}`);
+            }
+            else {
+                this.setOpacity(queryMessage === null || queryMessage === void 0 ? void 0 : queryMessage.data, (setOpacityError, response) => {
+                    queryMessage === null || queryMessage === void 0 ? void 0 : queryMessage.sendQueryResponse(setOpacityError, response);
+                });
+            }
+        });
+        RouterClient.addResponder("StackedWindow.updateOptions", (err, queryMessage) => {
+            if (err) {
+                Logger.system.error(`StackedWindow.updateOptions addResponder failed: ${err}`);
+            }
+            else {
+                this.updateOptions(queryMessage === null || queryMessage === void 0 ? void 0 : queryMessage.data, (updateOptionsError, response) => {
+                    queryMessage === null || queryMessage === void 0 ? void 0 : queryMessage.sendQueryResponse(updateOptionsError, response);
+                });
+            }
+        });
+    }
+    async visibleChildEventHandler(stackedWindowName, stackWrap, event) {
+        const stackedWindowIdentifier = {
+            windowName: stackedWindowName,
+            name: stackedWindowName,
+            windowType: "StackedWindow",
+        };
+        const thisStackRecord = this.storeCache[stackedWindowName];
+        // Sometimes removal of visible Child events never happens. Not sure why. Under normal circumstances, this is not an issue because you generally don't get here
+        // However in the case of evergreen components, this prevents the evergreen component from moving when launched in another workspace.
+        // So cleanup listeners if we somehow managed to get here and the stack doesn't exist.
+        if (!this.storeCache[stackedWindowName]) {
+            const { wrap: childWrap } = await BaseWindow.getInstance({ name: event.source });
+            this.removeChildEventListener(stackedWindowName, event.source, childWrap);
+            return;
+        }
+        switch (event.event) {
+            case "bounds-change-end":
+                this.saveWindowOptions({ closing: false }, stackedWindowIdentifier);
+                stackWrap.eventManager.trigger(event.event, event.data);
+                Logger.system.verbose("StackedWindowManager transmitting event", event.event, this.eventChannelName(stackedWindowName, event.event), event);
+                break;
+            case "restored":
+                stackWrap.windowState = constants.WINDOWSTATE.NORMAL;
+                this.restoreChildren(thisStackRecord, event.data.bounds);
+                break;
+            case "maximized":
+                stackWrap.windowState = constants.WINDOWSTATE.MAXIMIZED;
+                this.maximizeChildren(thisStackRecord);
+                break;
+            case "alwaysOnTop": {
+                let alwaysOnTopValue = event.data.alwaysOnTop;
+                if (alwaysOnTopValue === undefined) {
+                    const eventWindowName = event.data.windowName;
+                    const activeChildWindow = this.childWindow[eventWindowName];
+                    alwaysOnTopValue = !activeChildWindow.getParent().alwaysOnTop; // gets the parent alwaysOnTop value and toggles it
+                }
+                await this.setAlwaysOnTop({
+                    stackedWindowIdentifier,
+                    alwaysOnTop: alwaysOnTopValue,
+                });
+                break;
+            }
+            default:
+                stackWrap.eventManager.trigger(event.event, event.data);
+                Logger.system.verbose("StackedWindowManager transmitting event", event.eventName, this.eventChannelName(stackedWindowName, event.event), event);
+                break;
+        }
+    }
+    addChildEventListener(stackedWindowName, childName, childWrapper) {
+        Logger.system.debug("StackedWindowManagerService.addChildEventListener", stackedWindowName, childName);
+        FinsembleWindowInternal.getInstance({ name: stackedWindowName }, (err, stackWrap) => {
+            for (let i = 0; i < this.childEventsToHandle.length; i++) {
+                const eventName = this.childEventsToHandle[i];
+                let eventHandler = (eventObject) => {
+                    this.visibleChildEventHandler(stackedWindowName, stackWrap, eventObject);
+                };
+                if (eventName === "bounds-change-request") {
+                    eventHandler = _throttle(eventHandler, 10);
+                }
+                if (!this.eventHandlerFunction[stackedWindowName])
+                    this.eventHandlerFunction[stackedWindowName] = {};
+                if (this.eventHandlerFunction[stackedWindowName][eventName]) {
+                    Logger.system.warn("Avoiding Registering the same Listener Twice.");
+                }
+                else {
+                    Logger.system.debug("StackedWindowManager addChildEventListener", eventName, childName);
+                    this.eventHandlerFunction[stackedWindowName][eventName] = eventHandler;
+                    childWrapper.addEventListener(eventName, eventHandler);
+                }
+            }
+        });
+    }
+    removeChildEventListener(stackedWindowName, childName, childWrapper) {
+        Logger.system.debug("StackedWindowManager.removeChildEventListener", stackedWindowName, childName);
+        // We may try to remove listeners before adding them. If so, don't error out.
+        if (!this.eventHandlerFunction[stackedWindowName])
+            this.eventHandlerFunction[stackedWindowName] = {};
+        for (let i = 0; i < this.childEventsToHandle.length; i++) {
+            const eventName = this.childEventsToHandle[i];
+            const handler = this.eventHandlerFunction[stackedWindowName][eventName];
+            if (handler) {
+                childWrapper.removeEventListener(eventName, handler);
+                delete this.eventHandlerFunction[stackedWindowName][eventName];
+            }
+            else {
+                Logger.system.debug("StackedWindowManager.removeChildEventListener before the listener was added.");
+            }
+        }
+    }
+    // ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+    // The next section of functions are oriented to managing Stacked Windows throughout the system.
+    // ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+    // returns true if all the groupWindows are in the array of child windows
+    groupWindowsContainedInStacked(groupWindows, childWindows) {
+        let matchCount = 0;
+        let groupWindowCount = 0;
+        let groupWindow;
+        for (groupWindow in groupWindows) {
+            groupWindowCount++; // count the number of group windows
+            if (groupWindows.hasOwnProperty(groupWindow)) {
+                for (const childWindow of childWindows) {
+                    if (groupWindow === childWindow.name) {
+                        matchCount++; // count the matches found in child windows
+                    }
+                }
+            }
+        }
+        return groupWindowCount === matchCount; // return true if all group windows found in child windows
+    }
+    // when a new child window is added to the stack, this function determines if the stacked window should join any of the children groups
+    joinGroups(groups, stackedWindowIdentifier) {
+        const thisStackRecord = this.storeCache[stackedWindowIdentifier.windowName];
+        if (!thisStackRecord) {
+            Logger.system.error("stackedWindowManager.joinGroups unidentified stacked window", stackedWindowIdentifier);
+        }
+        else if (groups) {
+            for (const group of groups) {
+                const oneGroup = GroupPoolSingleton.get(group);
+                if (!this.groupWindowsContainedInStacked(oneGroup.windows, thisStackRecord.childWindowIdentifiers)) {
+                    // if the group exists outside the stacked window, then join the group
+                    RouterClient.transmit("DockingService.joinGroup", {
+                        groupName: group,
+                        name: stackedWindowIdentifier.windowName,
+                    });
+                }
+            }
+        }
+    }
+    getGroups(windowIdentifier) {
+        const promiseResolver = async (resolve) => {
+            RouterClient.query("DockingService.getGroupsForWindow", { name: windowIdentifier.name }, (err, response) => {
+                resolve(response.data);
+            });
+        };
+        return new Promise(promiseResolver);
+    }
+    /**
+     * Creates a new StackedWindow, returning its stackWindowIdentifier in the callback. Optionally initializes stack with a set of child windows.
+     *
+     * Invoked by Launcher Service when spawning a stacked window (e.g. LauncherClient.spawn()).
+     *
+     * @param {object} params Parameters
+     * @param {array=} params.windowIdentifiers array of windowIdentifiers to add to stack on creation.
+     * @param {boolean=} params.new if true then stacked window being defined for first time with no persistent state
+     * @param {function=} callback function(err, stackedWindowIdentifier)
+     * @memberof StackedWindowManager
+     * @private
+     */
+    async createStackedWindow(params, callback = null) {
+        var _a, _b;
+        Logger.system.debug("StackedWindowManager.createStackedWindow", params);
+        if (params.customData)
+            params.customData.manifest = {};
+        const stackedWindowIdentifier = {
+            windowType: "StackedWindow",
+            windowName: params.windowName || params.name,
+        };
+        let thisStackRecord;
+        let subscribeID = null;
+        // TABBING TBD: need to finish before callback -- async
+        // if (true || params.new) { // being created for the first time (not from workspace with persistent state)
+        thisStackRecord = new WindowRecord(stackedWindowIdentifier); // blank initial record
+        Object.assign(thisStackRecord, params); // merge windowDescriptor into stackRecord
+        thisStackRecord.registeredWithDockingManager = false;
+        const windowIdentifiers = thisStackRecord.childWindowIdentifiers && thisStackRecord.childWindowIdentifiers.length
+            ? thisStackRecord.childWindowIdentifiers
+            : (_b = (_a = thisStackRecord.customData) === null || _a === void 0 ? void 0 : _a.spawnData) === null || _b === void 0 ? void 0 : _b.windowIdentifiers;
+        thisStackRecord.childWindowIdentifiers = [];
+        // below commented out because don't want to save until complete state
+        // this.saveStore(stackedWindowIdentifier); // go ahead and save initial information before waiting on children
+        const wrapReadyCallback = async (err, response) => {
+            if (response.data && response.data.state === "open") {
+                RouterClient.unsubscribe(subscribeID); // no longer need subscription
+                for (let i = 0; i < windowIdentifiers.length; i++) {
+                    const p = Object.assign({}, params);
+                    p.windowIdentifier = windowIdentifiers[i];
+                    if (i === 0) {
+                        p.inheritGroups = true;
+                    }
+                    await this.addWindow(p);
+                }
+                // if not a newStack (i.e. spawned by workspace) the register here after children are added; otherwise for new stacks must dynamically register in addWindow.  TBD: need better model here
+                if (!params.newStack) {
+                    await this.registerWithDockingManager({
+                        windowIdentifier: stackedWindowIdentifier,
+                    });
+                }
+                Logger.system.debug("StackedWindowManager.createStackedWindow all available windows added");
+                const isVisible = thisStackRecord.visibleWindowIdentifier &&
+                    thisStackRecord.childWindowIdentifiers.length &&
+                    !this.ifWindowInStack({
+                        thisStackRecord,
+                        windowName: thisStackRecord.visibleWindowIdentifier.windowName,
+                    });
+                // if there is a visible window but the corresponding child window never became ready (for any reason) then set a new visible window
+                if (isVisible) {
+                    Logger.system.error("StackedWindowManager.createStackedWindow resetting visible window to first child since previous visible window couldn't be added");
+                    this.setVisibleWindow({
+                        stackedWindowIdentifier,
+                        windowIdentifier: thisStackRecord.childWindowIdentifiers[0],
+                    }); // make the first window visible by default
+                }
+                if (!thisStackRecord.childWindowIdentifiers.length) {
+                    // TBD: this should essentially mean the stacked-window creation failed, but this has side-effect so just put out error for now. Revisit on cleanup.  But tested and roughly handled okay.
+                    Logger.system.error("StackedWindowManager.createStackedWindow: no children became ready");
+                }
+                // send notification to LauncherClient that the window has been created (otherwise LauncherClient hangs)
+                RouterClient.publish(`Finsemble.${stackedWindowIdentifier.windowName}.componentReady`, {
+                    name: stackedWindowIdentifier.windowName,
+                });
+                // note the LauncherService will add to the workspace after spawn completes (spawn is the main client of this function)
+                await this.saveWindowOptions({ closing: false }, stackedWindowIdentifier); // save again now children added
+                this.setVisibleWindow({
+                    stackedWindowIdentifier,
+                    windowIdentifier: thisStackRecord.visibleWindowIdentifier,
+                });
+            }
+        };
+        Logger.system.debug("StackedWindowManager.createStackedWindow NewRecord", thisStackRecord);
+        this.storeCache[stackedWindowIdentifier.windowName] = thisStackRecord; // cache the stacked window data
+        if (windowIdentifiers) {
+            // if a list of initial windows provides, then now add them as children
+            params.noSave = true; // input to addWindow -- don't save in add because will do it once here after all added
+            params.stackedWindowIdentifier = stackedWindowIdentifier;
+            // wait for the wrap to be available before adding windows.
+            const wrapReadyChannel = `Finsemble.${stackedWindowIdentifier.windowName}.wrapReady`;
+            subscribeID = RouterClient.subscribe(wrapReadyChannel, wrapReadyCallback);
+            callback === null || callback === void 0 ? void 0 : callback(null, stackedWindowIdentifier);
+        }
+    }
+    /**
+     * Private utility function to sleep/wait for a specified time before accepting the returned promise.
+     * @private
+     */
+    sleep(milliseconds) {
+        return new Promise((resolve) => setTimeout(() => {
+            resolve("Timeout");
+        }, milliseconds));
+    }
+    waitForWrapReady(windowName) {
+        const channel = `Finsemble.${windowName}.wrapReady`;
+        return new Promise((resolve) => {
+            const subscribeID = RouterClient.subscribe(channel, async (err, response) => {
+                var _a, _b;
+                RouterClient.unsubscribe(subscribeID);
+                const available = ((_a = response.data) === null || _a === void 0 ? void 0 : _a.name) === windowName && ((_b = response.data) === null || _b === void 0 ? void 0 : _b.state) === "open";
+                if (!available) {
+                    Logger.system.debug("StackedWindowManager.addWindow waiting", windowName);
+                    return;
+                }
+                resolve(null);
+            });
+        });
+    }
+    /**
+     * 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 Parameters
+     * @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 {boolean=} params.ignorePreviousState if true then ignore the previous state of the window being added (with in another stack and registered with docking handled elsewhere)
+     * @param {boolean=} params.noVisibility if true don't automatically set visibility when first window added to the stack (needed for ordered startup)
+     * @param {function=} callback function(err)
+     * @memberof StackedWindowManager
+     * @private
+     */
+    async addWindow(params) {
+        Logger.system.debug("StackedWindowManager.addWindow", params);
+        const { windowName } = params.windowIdentifier;
+        // this handles when a window being added never reaches the ready state -- set timer to catch these cases and reject on timeout
+        const err = await Promise.race([this.sleep(this.addReadyTimeout), this.waitForWrapReady(windowName)]);
+        if (err) {
+            const error = `StackedWindowManager.addWindow() child ${params.windowIdentifier.windowName} never became ready`;
+            Logger.system.error(error);
+            return { err: error };
+        }
+        Logger.system.debug("StackedWindowManager.addWindow() continuing", params.windowIdentifier.windowName);
+        const { stackedWindowIdentifier, windowIdentifier, noSave } = params;
+        const thisStackRecord = this.storeCache[stackedWindowIdentifier.windowName];
+        if (!thisStackRecord) {
+            const error = "StackedWindowManager.addWindow() unknown stackedWindowIdentifier";
+            Logger.system.error(error);
+            return { err: error };
+        }
+        // position to add the window
+        const { position = thisStackRecord.childWindowIdentifiers.length } = params;
+        thisStackRecord.childWindowIdentifiers.splice(position, 0, windowIdentifier); // add to the child array
+        this.childNameToSID[windowIdentifier.windowName] = stackedWindowIdentifier; // add mapping to parent stackedWindowIdentifier
+        const { data: wrappedWindow } = await FinsembleWindowInternal.getInstanceStandardized(windowIdentifier);
+        if (!wrappedWindow) {
+            const error = `StackedWindowManager.addWindow() Cannot get wrap for ${windowName}`;
+            Logger.system.error(error);
+            return { err: error };
+        }
+        this.childWindow[windowIdentifier.windowName] = wrappedWindow; // save the wrapper for quick use
+        // save alwaysOnTop state so that when the window leaves the stack, its original alwaysOnTop state is restored
+        if (typeof windowIdentifier.alwaysOnTop !== "boolean")
+            windowIdentifier.alwaysOnTop = wrappedWindow._isAlwaysOnTop();
+        // if stacked window doesn't have a visible window, then make this window being added the visible window
+        if (!thisStackRecord.visibleWindowIdentifier) {
+            const { err: err2, data: bounds } = await wrappedWindow._getBounds({}, () => { });
+            if (err2 || !bounds) {
+                const error = `StackedWindowManager.addWindow() no bounds received ${err2}`;
+                Logger.system.error(error);
+                return { err: error };
+            }
+            // get the window bounds and save as the stackedWindow bounds
+            Logger.system.debug("StackedWindowManager.addWindow() got bounds", windowIdentifier, bounds);
+            this.mergeBounds(thisStackRecord, bounds);
+            thisStackRecord.bounds = bounds;
+            Object.assign(thisStackRecord, bounds);
+            this.setVisibleWindow({
+                stackedWindowIdentifier,
+                windowIdentifier,
+                noSave: params.noSave,
+                isAddingChildren: true,
+            });
+            // if stacked window has a predefined visibleWindow and it matches the window being added, then set this window to the visible window
+        }
+        else if (thisStackRecord.visibleWindowIdentifier &&
+            thisStackRecord.visibleWindowIdentifier.windowName === windowIdentifier.windowName) {
+            this.setVisibleWindow({
+                stackedWindowIdentifier,
+                windowIdentifier,
+                noSave: params.noSave,
+                isAddingChildren: true,
+            });
+            // if stacked window has a predefined visibleWindow and it does not match the window being added, then hide this window
+        }
+        else {
+            Logger.system.debug("StackedWindowManager.addWindow hiding window", windowIdentifier);
+            // hide the window being added and set it bounds
+            wrappedWindow._hide({ invokedByParent: true }, () => {
+                Logger.system.debug("StackedWindowManager.addWindow setting bounds", windowIdentifier, thisStackRecord.bounds);
+                wrappedWindow._setBounds({
+                    bounds: thisStackRecord.bounds,
+                    invokedByParent: true,
+                });
+            });
+        }
+        // If the stack is maximized and we're adding a window to it,
+        // call to maximize the window
+        const { wrap: stackedWrapper } = await BaseWindow.getInstance(stackedWindowIdentifier);
+        const childWindow = this.childWindow[windowIdentifier.windowName];
+        if (stackedWrapper.windowState === constants.WINDOWSTATE.MAXIMIZED) {
+            childWindow._maximize();
+        }
+        else if (stackedWrapper.windowState === constants.WINDOWSTATE.NORMAL) {
+            childWindow._restore();
+        }
+        if (!params.noRemove) {
+            // if higher level (e.g. presentation components) isn't handling the previous state of the window
+            // handling the previous state of the window being added
+            const { parentWindow } = wrappedWindow;
+            if (parentWindow && parentWindow.name != thisStackRecord.name) {
+                // if the window being added was already in a stackedWindow, remove it from that stacked window (the window is already unregistered with docking)
+                Logger.system.debug("StackedWindowManager.addWindow removing from previous parentWindow", parentWindow.identifier);
+                // if adding a window to this stack that needs to be removed from another stack,
+                // then when removing don't automatically make the window visible; instead use normally visibility settings in new stacked window
+                await this.removeWindow({
+                    stackedWindowIdentifier: parentWindow.identifier,
+                    windowIdentifier,
+                    noVisible: true,
+                    noDocking: true,
+                });
+            }
+            else {
+                // else window is standalone and registered with docking, so deregister with docking (since only stacked window is registered)
+                Logger.system.debug("StackedWindowManager.addWindow unregistering from docking (case 1)", windowIdentifier);
+                if (params.inheritGroups && params.newStack) {
+                    await this.registerWithDockingManager({
+                        windowIdentifier: stackedWindowIdentifier,
+                    });
+                    const groups = await this.getGroups(windowIdentifier);
+                    this.joinGroups(groups, stackedWindowIdentifier);
+                }
+                this.deregisterWithDockingManager({ windowIdentifier }); // docking manager manage the parentWindow stacked window (not the individual children)
+            }
+        }
+        if (!noSave) {
+            await this.saveWindowOptions({ closing: false }, stackedWindowIdentifier); // update the cache and the global store
+        }
+        // Notify interested listeners (e.g. BaseWindow wrappers for added window) that window was added to the stack
+        Logger.system.debug("StackedWindowManager publish parent notification", windowIdentifier.windowName);
+        RouterClient.publish(`Finsemble.parentChange.${windowIdentifier.windowName}`, {
+            type: "Added",
+            stackedWindowIdentifier,
+        });
+        // Publish Exists event right after the Added event because windows use this event type to track parent state.
+        RouterClient.publish(`Finsemble.parentChange.${windowIdentifier.windowName}`, {
+            type: "Exists",
+            stackedWindowIdentifier,
+        });
+        await this.makeStackAlwaysOnTopIfNeeded({
+            stackedWindowIdentifier,
+        });
+        return {};
+    }
+    /**
+     * This will make a stack always on top if any child is always on top.
+     */
+    async makeStackAlwaysOnTopIfNeeded(params) {
+        const thisStackRecord = this.storeCache[params.stackedWindowIdentifier.windowName];
+        const alwaysOnTop = thisStackRecord.childWindowIdentifiers.some(({ windowName }) => this.childWindow[windowName]._isAlwaysOnTop());
+        if (alwaysOnTop) {
+            await this.setAlwaysOnTop({
+                stackedWindowIdentifier: params.stackedWindowIdentifier,
+                alwaysOnTop: alwaysOnTop,
+            });
+        }
+    }
+    triggerEvent(params, cb) {
+        FinsembleWindowInternal.getInstance({ stackedWindowManager: this, name: params.windowIdentifier.windowName }, (_err, wrap) => {
+            wrap.eventManager.trigger(params.event);
+            cb();
+        });
+    }
+    /**
+     * Closes and deletes a stacked window. If specified (see params) then children will be closed; otherwise children will be signals they are removed from the stacked window.
+     *
+     * @param {object} params Parameters
+     * @param {object} params.stackedWindowIdentifier stacked window to operate on
+     * @param {object=} params.closeChildren if true then also close all children
+     * @param {object=} params.removeFromWorkspace if then remove stacked window and child windows from the workspace
+     * @param {boolean=} params.waitChildClose if true then wait for child wrapper to close before returned (needed for cleanly switching workspaces)
+     * @param {boolean=} params.noDocking if true then do not register removed window with docking (the workspace is unaffected)
+     * @param {any} callback
+     * @memberof StackedWindowManager
+     */
+    closeStackedWindow(params, callback = Function.prototype) {
+        Logger.system.debug("StackedWindowManager.closeStackedWindow", params.stackedWindowIdentifier.windowName, params);
+        const promiseResolver = async (resolve) => {
+            let { stackedWindowIdentifier, removeFromWorkspace, closeChildren } = params;
+            if (!closeChildren && closeChildren !== false) {
+                closeChildren = removeFromWorkspace;
+            }
+            const thisStackRecord = this.storeCache[stackedWindowIdentifier.windowName];
+            Logger.system.debug("StackedWindowManager.closeStackedWindow saveStore done", params.stackedWindowIdentifier.windowName);
+            if (!thisStackRecord) {
+                const err = "StackedWindowManager.closeStackedWindow: no stacked record";
+                Logger.system.error(err, params);
+                resolve({ err });
+                callback(err);
+            }
+            else {
+                // clear the pubsub state for the stacked window -- must set to empty (to match LaucherClient check)
+                RouterClient.publish(`Finsemble.${stackedWindowIdentifier.windowName}.componentReady`, {});
+                if (removeFromWorkspace) {
+                    if (closeChildren) {
+                        while (thisStackRecord.childWindowIdentifiers.length > 0) {
+                            // the currently visible window is closed one at a time to support orderly close, which might require UI interaction
+                            await this.deleteWindow({
+                                noCloseStack: true,
+                                waitChildClose: params.waitChildClose,
+                                stackedWindowIdentifier,
+                                windowIdentifier: thisStackRecord.visibleWindowIdentifier,
+                                removeFromWorkspace,
+                                fromSystem: params.fromSystem,
+                            });
+                        }
+                    }
+                    else {
+                        while (thisStackRecord.childWindowIdentifiers.length > 0) {
+                            await this.removeWindow({
+                                noCloseStack: true,
+                                waitChildClose: params.waitChildClose,
+                                stackedWindowIdentifier,
+                                windowIdentifier: thisStackRecord.visibleWindowIdentifier,
+                            });
+                        }
+                    }
+                    this.deregisterWithDockingManager({
+                        windowIdentifier: stackedWindowIdentifier,
+                        removeFromWorkspace,
+                    });
+                    delete this.storeCache[stackedWindowIdentifier.windowName]; // remove stacked window from cache
+                    resolve();
+                    callback();
+                }
+                else {
+                    // clear the pubsub parent state for each child window (if not done, children will for some cases incorrectly have a parent specified);
+                    // note removeWindow() will also clear this parent state, but this path doesn't invoke removeWindow
+                    for (let i = 0; i < thisStackRecord.childWindowIdentifiers.length; i++) {
+                        const childName = thisStackRecord.childWindowIdentifiers[i].name;
+                        Logger.system.debug("StackedWindowManager.closeStackedWindow cleaning up parent state for child", childName);
+                        RouterClient.publish(`Finsemble.parentChange.${childName}`, {});
+                    }
+                    // essentially shouldn't have to do anything else but cleanup local state -- workspace is closing children individually
+                    if (thisStackRecord.visibleWindowIdentifier) {
+                        const visibleChildWrapper = this.childWindow[thisStackRecord.visibleWindowIdentifier.windowName];
+                        this.removeChildEventListener(stackedWindowIdentifier.windowName, thisStackRecord.visibleWindowIdentifier.windowName, visibleChildWrapper);
+                    }
+                    delete this.storeCache[stackedWindowIdentifier.windowName]; // remove stacked window from cache
+                    resolve();
+                    callback();
+                }
+            }
+        };
+        return new Promise(promiseResolver);
+    }
+    waitForWindowClosed(windowName) {
+        return new Promise((resolve) => {
+            const subscribeID = RouterClient.subscribe(`Finsemble.${windowName}.wrapReady`, (subscribeError, response) => {
+                const { data } = response;
+                const windowWasClosed = data.name === windowName && data.state === "closed";
+                if (!windowWasClosed) {
+                    Logger.system.debug("StackedWindowManager.removeWindow waiting", windowName);
+                }
+                else {
+                    Logger.system.debug("StackedWindowManager.removeWindow continuing", windowName);
+                    RouterClient.unsubscribe(subscribeID);
+                    resolve(subscribeError);
+                }
+            });
+        });
+    }
+    removeWindowFromCache(stackName, windowName) {
+        let stack = this.storeCache[stackName];
+        if (stack) {
+            for (let i = 0; i < stack.childWindowIdentifiers.length; i++) {
+                const item = stack.childWindowIdentifiers[i];
+                if (item.windowName === windowName) {
+                    stack.childWindowIdentifiers.splice(i, 1);
+                    return { wasAlwaysOnTop: item.alwaysOnTop, stack };
+                }
+            }
+        }
+        return { wasAlwaysOnTop: false, stack };
+    }
+    async closeStack(stackedWindowIdentifier) {
+        let stack = this.storeCache[stackedWindowIdentifier.windowName];
+        const lastChild = stack.childWindowIdentifiers[0];
+        const { err: getGroupsForWindowError, response } = await RouterClient.query("DockingService.getGroupsForWindow", {
+            name: stack.name,
+        });
+        await this.registerWithDockingManager({ windowIdentifier: lastChild });
+        const groups = response.data;
+        if (groups) {
+            for (const group of groups) {
+                RouterClient.transmit("DockingService.joinGroup", {
+                    groupName: group,
+                    name: lastChild.windowName,
+                });
+            }
+        }
+        const innerChildWrapper = this.childWindow[lastChild.windowName];
+        innerChildWrapper._show({ invokedByParent: true });
+        const { wrap } = await BaseWindow.getInstance(stackedWindowIdentifier);
+        // for now must call close on public wrapper to have wrapper cleanup happen correctly
+        Logger.system.debug("StackedWindowManager.removeWindowparent invoking public close", stackedWindowIdentifier, getGroupsForWindowError);
+        const { err } = await wrap.close({
+            closeChildren: false,
+            stackedWindowIdentifier,
+            removeFromWorkspace: true,
+            invokedByParent: true,
+            force: false,
+        });
+        return err;
+    }
+    /**
+     * 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 Parameters
+     * @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 {boolean=} params.noVisible if true then do not make window visible when removing it
+     * @param {boolean=} params.waitChildClose if true then wait for child wrapper to close before returned (needed for cleanly switching workspaces)
+     * @param {boolean=false} params.closeWindow
+     * @param {boolean=false} params.noCloseStack  if true don't close the stack window when only one child
+     * @param {function=} callback function(err)
+     * @memberof StackedWindowManager
+     * @returns promise
+     * @private
+     */
+    async removeWindow(params, callback = Function.prototype) {
+        var _a;
+        const { noVisible, noCloseStack, stackedWindowIdentifier, windowIdentifier, noDocking } = params;
+        const { wasAlwaysOnTop, stack: thisStackRecord } = this.removeWindowFromCache(stackedWindowIdentifier.windowName, windowIdentifier.windowName);
+        Logger.system.debug("StackedWindowManager.removeWindow", params, thisStackRecord);
+        if (!thisStackRecord) {
+            const error = "StackedWindowManager.removeWindow unknown stackedWindowIdentifier";
+            Logger.system.warn(error, params);
+            callback(error);
+            return { err: error };
+        }
+        const childWrapper = this.childWindow[windowIdentifier.windowName];
+        childWrapper._alwaysOnTop({ alwaysOnTop: wasAlwaysOnTop });
+        childWrapper.clearParent(); // remove parent setting from child being remove
+        delete this.childNameToSID[windowIdentifier.windowName]; // remove child's mapping to parent stackedWindowIdentifier
+        if (((_a = thisStackRecord.visibleWindowIdentifier) === null || _a === void 0 ? void 0 : _a.windowName) === windowIdentifier.windowName) {
+            this.removeChildEventListener(thisStackRecord.identifier.windowName, windowIdentifier.windowName, childWrapper);
+            thisStackRecord.visibleWindowIdentifier = null;
+        }
+        // unless specified otherwise, register the remove window with docking
+        if (!noDocking) {
+            Logger.system.debug("StackedWindowManager.removeWindow registering with docking", stackedWindowIdentifier, windowIdentifier);
+            this.registerWithDockingManager({ windowIdentifier });
+        }
+        // go ahead and set visibility even if closing in order to finish this set of stackedWindow updates
+        if (thisStackRecord.childWindowIdentifiers.length && !thisStackRecord.visibleWindowIdentifier) {
+            this.setVisibleWindow({
+                stackedWindowIdentifier,
+                windowIdentifier: thisStackRecord.childWindowIdentifiers[0], // make the first window visible by default
+            });
+        }
+        // unless specified otherwise, show the window being removed from the stacked window (it might not be visible)
+        if (!noVisible) {
+            childWrapper._show({ invokedByParent: true });
+        }
+        await this.saveWindowOptions({ closing: false }, params.stackedWindowIdentifier);
+        // Notify interested listeners (e.g. BaseWindow wrappers of the removed window) that window was removed from the stack
+        Logger.system.debug("StackedWindowManager.removeWindow parent notification", windowIdentifier.windowName);
+        RouterClient.publish(`Finsemble.parentChange.${windowIdentifier.windowName}`, {
+            type: "Removed",
+            stackedWindowIdentifier,
+        });
+        RouterClient.publish(`Finsemble.parentChange.${windowIdentifier.windowName}`, {});
+        childWrapper._restore();
+        // if only one child window then the stack is empty and can be unregistered.
+        // Pull child out, and close stackedWindow;
+        // compare for <= 1 since might be concurrently removing multiple windows from stack for crashed components (i.e. this function is not fully reentrant yet)
+        if (!noCloseStack && thisStackRecord.childWindowIdentifiers.length <= 1) {
+            Logger.system.debug("StackedWindowManager.removeWindowparent closing stacked window", stackedWindowIdentifier);
+            const closeError = await this.closeStack(stackedWindowIdentifier);
+            // @early-exit. If you uncomment this return statement, the callback will be invoked twice. That causes errors and looks bad
+            // save the child value first because sometimes it's removed from the stackRecord before the query returns, but it still needs to be unregistered
+            callback(closeError);
+            return { err: closeError };
+        }
+        Logger.system.debug("StackedWindowManager.removeWindowparent NOT closing stacked window", noCloseStack, thisStackRecord);
+        let err = null;
+        if (params.waitChildClose) {
+            const error = await this.waitForWindowClosed(params.windowIdentifier.windowName);
+            if (error)
+                err = error.toString();
+        }
+        callback(err);
+        return { err };
+    }
+    /**
+     * 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 Parameters
+    .* @param {object} params.stackedWindowIdentifier stacked window to operate on
+     * @param {object} params.windowIdentifier window to delete
+     * @param {function=} callback function(err)
+     * @memberof StackedWindowManager
+     * @private
+     */
+    deleteWindow(params, callback = Function.prototype) {
+        const promiseResolver = async (resolve) => {
+            Logger.system.debug("StackedWindowManager.deleteWindow", params);
+            if (params.removeFromWorkspace === false) {
+                callback();
+                resolve();
+            }
+            else {
+                params.noDocking = true;
+                await this.removeWindow(params);
+                const { wrap } = await BaseWindow.getInstance(params.windowIdentifier);
+                wrap.close({
+                    /*
+                     * If the close event is sent from the system (i.e. user is closing a stacked window from the taskbar), tell the wrapper to not show the error
+                     * when attempting to close that window (because the window is already closed from the system).
+                     * For now we're still calling this function even if it's a system close because we need some way to close a slacked window from the
+                     * taskbar. We can also change the event name we pass into "this.setupSystemListener" in case of a system close in the WebWindowWrapper file from
+                     * 'closed' to 'system-closed' so we don't have to close twice. But we decided it's a big change and we should go with a less risky approach in this bug fixing PR.
+                     */
+                    suppressError: params.fromSystem,
+                    invokedByParent: true,
+                    force: false,
+                    removeFromWorkspace: true,
+                }, (err) => {
+                    callback(err);
+                    resolve({ err });
+                });
+            }
+        };
+        return new Promise(promiseResolver);
+    }
+    getPreviouslyVisibleWindow(visibleWindowName, stackedWindowName) {
+        if (!visibleWindowName)
+            return null;
+        const previouslyVisibleWindow = this.childWindow[visibleWindowName]; // will use below to hide previous after setting next
+        if (previouslyVisibleWindow) {
+            this.removeChildEventListener(stackedWindowName, visibleWindowName, previouslyVisibleWindow);
+        }
+        return previouslyVisibleWindow;
+    }
+    /**
+     * Sets the visible window within the stack.  The previously visible window in stack will be automatically hidden.
+     *
+     * @param {object} params Parameters
+     * @param {object} params.stackedWindowIdentifier stacked window to operate on
+     * @param {object} params.windowIdentifier
+     * @param {object} params.force if force is true then reset visible even if it is already marked as visible in store (this is for startup)
+     * @param {function=} callback function(err)
+     * @memberof StackedWindowManager
+     * @private
+     */
+    async setVisibleWindow(params, cb) {
+        var _a;
+        Logger.system.debug("StackedWindowManager.setVisibleWindow", params);
+        const { stackedWindowIdentifier, windowIdentifier } = params;
+        const thisStackRecord = this.storeCache[stackedWindowIdentifier.windowName];
+        let err = null;
+        if (!thisStackRecord) {
+            err = "StackedWindowManager.setVisibleWindow unknown stackedWindowIdentifier";
+            Logger.system.warn(err, params);
+            cb === null || cb === void 0 ? void 0 : cb(err);
+            return;
+        }
+        let previouslyVisibleWindow = this.getPreviouslyVisibleWindow((_a = thisStackRecord.visibleWindowIdentifier) === null || _a === void 0 ? void 0 : _a.windowName, stackedWindowIdentifier.windowName);
+        thisStackRecord.visibleWindowIdentifier = windowIdentifier;
+        const savedBounds = thisStackRecord.bounds;
+        if (!previouslyVisibleWindow || (previouslyVisibleWindow === null || previouslyVisibleWindow === void 0 ? void 0 : previouslyVisibleWindow.windowState) !== constants.WINDOWSTATE.MAXIMIZED) {
+            // set bounds on new visible window
+            this.childWindow[windowIdentifier.windowName]._setBounds({
+                bounds: thisStackRecord.bounds,
+                invokedByParent: true,
+            });
+        }
+        const childWrapper = this.childWindow[windowIdentifier.windowName];
+        childWrapper.disableFrame();
+        this.addChildEventListener(stackedWindowIdentifier.windowName, thisStackRecord.visibleWindowIdentifier.windowName, childWrapper);
+        Logger.system.debug("StackedWindowManager.setVisibleWindow showing", windowIdentifier);
+        const notMinMax = childWrapper.windowOptions.windowState !== constants.WINDOWSTATE.MINIMIZED_WAS_NORMAL && !params.isAddingChildren;
+        /* Workaround for an electron bug where calling show on a aero-snapped window restores the window to it's position prior to being aero-snapped.
+        We can't prevent the window from moving, so after we show the child window we set it's bounds back to it's former position.
+        aeroMode is used to track selecting a window from the preview after snapping. It needs to be set to false in this case as the aero-snap action has already completed.
+
+        This workaround, has the side effect of removing aero-snapped state from the window. However, since only the visible window when the stack was snapped was considered aero-snapped by the OS,
+        the stack already did not respond to subsequent aero-snap commands if another tab was in focus.
+        */
+        if (notMinMax)
+            window.aeroMode = false;
+        await childWrapper._show({
+            invokedByParent: true,
+        });
+        // currently we'll handle a persisted MINIMIZED_WAS_NORMAL state in the stacked window, but not the MINIMIZED_WAS_MAXIMIZED (refactoring window management will address this)
+        if (notMinMax) {
+            if (childWrapper.windowState !== constants.WINDOWSTATE.MAXIMIZED) {
+                childWrapper._setBounds({
+                    bounds: savedBounds,
+                    invokedByParent: true,
+                });
+            }
+            childWrapper._focus({ invokedByParent: true });
+            Logger.system.debug("StackedWindowManager.setVisibleWindow shown", windowIdentifier);
+            // Doing it this way so that the window in the back is visible when the one in the front hides. This reduces the flickering effect of switching tabs.
+            if ((previouslyVisibleWindow === null || previouslyVisibleWindow === void 0 ? void 0 : previouslyVisibleWindow.windowName) !== childWrapper.windowName) {
+                Logger.system.debug("StackedWindowManager.setVisibleWindow hiding previous", previouslyVisibleWindow);
+                previouslyVisibleWindow === null || previouslyVisibleWindow === void 0 ? void 0 : previouslyVisibleWindow._hide({ invokedByParent: true }, () => {
+                    // sometimes (once every 5 tab switches or so) the window gets into a bad state where it is hidden as far as the system is concerned
+                    // but it is actually visible but cannot be interacted with. so call hide a second time to fix and really really hide.
+                    previouslyVisibleWindow === null || previouslyVisibleWindow === void 0 ? void 0 : previouslyVisibleWindow._hide({ invokedByParent: true });
+                });
+            }
+        }
+        // make sure the window is in front (use case: adding tab to window that isn't in front)
+        childWrapper._bringToFront({ invokedByParent: true });
+        if (!params.noSave) {
+            this.saveWindowOptions({ closing: false }, params.stackedWindowIdentifier);
+        }
+        cb === null || cb === void 0 ? void 0 : cb(err);
+    }
+    // temporary code to workaround tabbing/tiling problem that reshows window when tabs are reordered
+    hideInactiveChildren(thisStackRecord) {
+        Logger.system.debug("StackedWindowManager.hideInactiveChildren");
+        thisStackRecord.childWindowIdentifiers.forEach((identifier) => {
+            // only rehide if not the the visible window
+            if (thisStackRecord.visibleWindowIdentifier &&
+                identifier.windowName !== thisStackRecord.visibleWindowIdentifier.windowName) {
+                const wrap = this.childWindow[identifier.windowName];
+                wrap._hide({ invokedByParent: true });
+            }
+        });
+    }
+    /**
+     * Reorders the stack, but odes not affect visibility
+     *
+     * @param {object} params Parameters
+     * @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 StackedWindowManager
+     * @private
+     */
+    reorder(params, callback = Function.prototype) {
+        Logger.system.debug("StackedWindowManager.reorder", params);
+        const { stackedWindowIdentifier, windowIdentifiers } = params;
+        // TBD: verify list of identifiers are the same and if not generate error
+        const thisStackRecord = this.storeCache[stackedWindowIdentifier.windowName];
+        let err = null;
+        if (thisStackRecord) {
+            thisStackRecord.childWindowIdentifiers = windowIdentifiers;
+            this.hideInactiveChildren(thisStackRecord); // this is to sidestep a bug in docking/tiling that reshows a moved tab
+            this.saveWindowOptions({ closing: false }, stackedWindowIdentifier);
+        }
+        else {
+            err = "StackedWindowManager.reorder unknown stackedWindowIdentifier";
+            Logger.system.warn(err, params);
+        }
+        if (callback)
+            callback(err);
+    }
+    // ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+    // The next section of functions support stacked-window primitives throughout the system.
+    // ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+    // stacked window minimize (invoked remotely through stacked window wrapper)
+    minimize(params, callback = Function.prototype) {
+        Logger.system.debug("StackedWindowManager.minimize", params);
+        // if operating on StackedWindow then operation should apply to the visible window
+        if (this.operatingDirectlyOnStackedWindow(params)) {
+            const thisStackRecord = this.storeCache[params.stackedWindowIdentifier.windowName];
+            if (thisStackRecord) {
+                params.windowIdentifier = thisStackRecord.visibleWindowIdentifier;
+            }
+            else {
+                Logger.system.warn("ignoring command because StackedWindow undefined (probably okay due to its recent close)", params);
+                return callback("undefined window");
+            }
+        }
+        if (this.isShowing(params)) {
+            const visibleWindow = this.childWindow[params.windowIdentifier.windowName];
+            params.invokedByParent = true; // prevents wrapper function from recalling parent (causing a loop)
+            visibleWindow === null || visibleWindow === void 0 ? void 0 : visibleWindow._minimize(params); // invoke function on active window's wrapper
+        }
+        else {
+            Logger.system.error(`StackedWindowManager Warning: minimize received for hidden window ${params.windowIdentifier.windowName}`);
+        }
+        callback(null);
+    }
+    // stacked window maximize (invoked remotely through stacked window wrapper)
+    maximize(params, callback = Function.prototype) {
+        Logger.system.debug("StackedWindowManager.maximize", params);
+        const thisStackRecord = this.storeCache[params.stackedWindowIdentifier.windowName];
+        const visibleWindowWrap = this.childWindow[thisStackRecord.visibleWindowIdentifier.windowName];
+        if (visibleWindowWrap)
+            visibleWindowWrap._maximize();
+        callback();
+    }
+    // stacked window restore (invoked remotely through stacked window wrapper)
+    restore(params, callback = Function.prototype) {
+        Logger.system.debug("StackedWindowManager.restore", params);
+        const thisStackRecord = this.storeCache[params.stackedWindowIdentifier.windowName];
+        const visibleWindowWrap = this.childWindow[thisStackRecord.visibleWindowIdentifier.windowName];
+        if (visibleWindowWrap.windowState === undefined)
+            visibleWindowWrap.windowState = params.windowState;
+        if (visibleWindowWrap)
+            visibleWindowWrap._restore();
+        return callback();
+    }
+    // stacked window focus (invoked remotely through stacked window wrapper)
+    focus(params, callback = Function.prototype) {
+        Logger.system.debug("StackedWindowManager.focus", params);
+        // if operating on StackedWindow then operation should apply to the visible window
+        if (this.operatingDirectlyOnStackedWindow(params)) {
+            const thisStackRecord = this.storeCache[params.stackedWindowIdentifier.windowName];
+            if (thisStackRecord) {
+                params.windowIdentifier = thisStackRecord.visibleWindowIdentifier;
+            }
+            else {
+                Logger.system.warn("ignoring command because StackedWindow undefined (probably okay due to its recent close)", params);
+                return callback("undefined window");
+            }
+        }
+        if (this.isShowing(params)) {
+            const visibleWindow = this.childWindow[params.windowIdentifier.windowName];
+            params.invokedByParent = true; // prevents wrapper function from recalling parent (causing a loop)
+            visibleWindow === null || visibleWindow === void 0 ? void 0 : visibleWindow._focus(params); // invoke function on active window's wrapper
+        }
+        else {
+            Logger.system.error(`StackedWindowManager Warning: focus received for hidden window ${params.windowIdentifier.windowName}`);
+        }
+        callback(null);
+    }
+    // stacked window bringToFront (invoked remotely through stacked window wrapper)
+    bringToFront(params, callback = Function.prototype) {
+        var _a;
+        params = params || {};
+        Logger.system.debug("StackedWindowManager.bringToFront", params);
+        // if operating on StackedWindow then operation should apply to the visible window
+        if (this.operatingDirectlyOnStackedWindow(params)) {
+            const thisStackRecord = this.storeCache[params.stackedWindowIdentifier.windowName];
+            if (thisStackRecord) {
+                params.windowIdentifier = thisStackRecord.visibleWindowIdentifier;
+            }
+            else {
+                Logger.system.warn("ignoring command because StackedWindow undefined (probably okay due to its recent close)", params);
+                return callback("undefined window");
+            }
+        }
+        if (this.isShowing(params)) {
+            const visibleWindow = this.childWindow[params.windowIdentifier.windowName];
+            params.invokedByParent = true; // prevents wrapper function from recalling parent (causing a loop)
+            visibleWindow === null || visibleWindow === void 0 ? void 0 : visibleWindow._bringToFront(params); // invoke function on active window's wrapper
+        }
+        else {
+            Logger.system.error(`StackedWindowManager Warning: bringToFront received for hidden window ${(_a = params.stackedWindowIdentifier) === null || _a === void 0 ? void 0 : _a.windowName}`);
+        }
+        callback(null);
+    }
+    saveWindowStateToStore(params, callback = Function.prototype) {
+        this.saveWindowOptions({ closing: false }, params.stackedWindowIdentifier, callback);
+    }
+    mergeBounds(stackRecord, bounds) {
+        bounds.right = bounds.left + bounds.width;
+        const newBounds = {
+            left: bounds.left,
+            right: bounds.right,
+            width: bounds.width,
+            top: bounds.top,
+            bottom: bounds.top + bounds.height,
+            height: bounds.height,
+        };
+        const defaultBounds = {
+            defaultLeft: bounds.left,
+            defaultWidth: bounds.width,
+            defaultTop: bounds.top,
+            defaultHeight: bounds.height,
+        };
+        Object.assign(stackRecord, newBounds);
+        Object.assign(stackRecord, defaultBounds);
+        stackRecord.bounds = newBounds;
+    }
+    // stacked window setBounds (invoked remotely through stacked window wrapper)
+    setBounds(params, callback = Function.prototype) {
+        Logger.system.debug("StackedWindowManager.setBounds", params);
+        let err = null;
+        const thisStackRecord = this.storeCache[params.stackedWindowIdentifier.windowName];
+        if (!thisStackRecord) {
+            Logger.system.warn("ignoring command because StackedWindow undefined (probably okay due to its recent close)", params);
+            err = "undefined window";
+        }
+        else {
+            // if operating on StackedWindow then operation should apply to the visible window
+            if (this.operatingDirectlyOnStackedWindow(params)) {
+                params.windowIdentifier = thisStackRecord.visibleWindowIdentifier;
+            }
+            if (this.isShowing(params)) {
+                const visibleWindow = this.childWindow[params.windowIdentifier.windowName];
+                this.mergeBounds(thisStackRecord, params.bounds);
+                params.invokedByParent = true; // prevents wrapper function from recalling parent (causing a loop)
+                visibleWindow === null || visibleWindow === void 0 ? void 0 : visibleWindow._setBounds(params); // invoke function on active window's wrapper
+            }
+            else if (params.windowIdentifier) {
+                Logger.system.warn(`StackedWindowManager Warning: setBounds received for hidden window ${params.windowIdentifier}`);
+            }
+        }
+        callback(err);
+    }
+    // stacked window getBoundsFromSystem (invoked remotely through stacked window wrapper)
+    getBoundsFromSystem(params, callback = Function.prototype) {
+        Logger.system.debug("StackedWindowManager.getBoundsFromSystem", params);
+        const thisStackRecord = this.storeCache[params.stackedWindowIdentifier.windowName];
+        // if operating on StackedWindow then operation should apply to the visible window
+        if (this.operatingDirectlyOnStackedWindow(params)) {
+            if (thisStackRecord) {
+                params.windowIdentifier = thisStackRecord.visibleWindowIdentifier;
+            }
+            else {
+                Logger.system.warn("ignoring command because StackedWindow undefined (probably okay due to its recent close)", params);
+                return callback("undefined window");
+            }
+        }
+        if (this.isShowing(params)) {
+            const visibleWindow = this.childWindow[params.windowIdentifier.windowName];
+            if (!visibleWindow) {
+                const err = `stackedWindowManager: cannot find child window ${params.windowIdentifier.windowName}`;
+                Logger.system.error(err);
+                callback(err);
+                return;
+            }
+            params.invokedByParent = true; // prevents wrapper function from recalling parent (causing a loop)
+            visibleWindow === null || visibleWindow === void 0 ? void 0 : visibleWindow._getBoundsFromSystem(params, (err, bounds) => {
+                // invoke function on active window's wrapper
+                const _bounds = err ? thisStackRecord.bounds : bounds;
+                callback(err, _bounds);
+            });
+        }
+        else if (!this.operatingDirectlyOnStackedWindow(params)) {
+            Logger.system.error(`StackedWindowManager Warning: getBoundsFromSystem received for hidden window ${params.windowIdentifier.windowName}`);
+            callback("getBounds on hidden window");
+        }
+    }
+    // stacked window getBounds (invoked remotely through stacked window wrapper)
+    getBounds(params, callback = Function.prototype) {
+        params = params || {};
+        Logger.system.debug("StackedWindowManager.getBounds", params);
+        let thisStackRecord = null;
+        // if operating on StackedWindow then operation should apply to the visible window
+        if (this.operatingDirectlyOnStackedWindow(params)) {
+            thisStackRecord = this.storeCache[params.stackedWindowIdentifier.windowName];
+            if (thisStackRecord) {
+                params.windowIdentifier = thisStackRecord.visibleWindowIdentifier;
+                Logger.system.debug("StackedWindowManager.getBounds", params, thisStackRecord);
+            }
+            else {
+                Logger.system.warn("ignoring command because StackedWindow undefined (probably okay due to its recent close)", params);
+                callback("undefined window");
+                return;
+            }
+        }
+        if (thisStackRecord && thisStackRecord.bounds) {
+            callback(null, thisStackRecord.bounds);
+        }
+        else if (!thisStackRecord.visibleWindowIdentifier) {
+            // since no visible window use empty bounds; this is to handle an intermittent error that sometimes occurred when creating a stack
+            const emptyBounds = {
+                left: 0,
+                right: 0,
+                width: 10,
+                top: 0,
+                bottom: 0,
+                height: 10,
+            };
+            callback(null, emptyBounds);
+        }
+        else if (this.isShowing(params)) {
+            const visibleWindow = this.childWindow[params.windowIdentifier.windowName];
+            if (!visibleWindow) {
+                const err = `stackedWindowManager: cannot find child window ${params.windowIdentifier.windowName}`;
+                Logger.system.error(err);
+                callback(err);
+                return;
+            }
+            params.invokedByParent = true; // prevents wrapper function from recalling parent (causing a loop)
+            visibleWindow === null || visibleWindow === void 0 ? void 0 : visibleWindow._getBounds(params, (err, bounds) => {
+                // invoke function on active window's wrapper
+                const _bounds = err ? this.storeCache[params.stackedWindowIdentifier.windowName].bounds : bounds;
+                callback(err, _bounds);
+            });
+        }
+        else if (!this.operatingDirectlyOnStackedWindow(params)) {
+            Logger.system.error(`StackedWindowManager Warning: getBounds received for hidden window ${params.windowIdentifier.windowName}`);
+            callback("getBounds on hidden window");
+        }
+        callback("something went wrong");
+    }
+    // stacked window updateOptions (invoked remotely through stacked window wrapper)
+    updateOptions(params, callback = Function.prototype) {
+        Logger.system.debug("StackedWindowManager.updateOptions", params);
+        let err = null;
+        // TABBING TBD: put in a getter function for the stacked records to provide common error checking.  Docking might invoke for non-existent stacked window
+        const thisStackRecord = this.storeCache[params.stackedWindowIdentifier.windowName];
+        if (thisStackRecord) {
+            // if operating on StackedWindow then operation should apply to the visible window
+            if (this.operatingDirectlyOnStackedWindow(params)) {
+                params.windowIdentifier = thisStackRecord.visibleWindowIdentifier;
+            }
+            if (this.isShowing(params)) {
+                const visibleWindow = this.childWindow[params.windowIdentifier.windowName];
+                params.invokedByParent = true; // prevents wrapper function from recalling parent (causing a loop)
+                visibleWindow === null || visibleWindow === void 0 ? void 0 : visibleWindow._updateOptions(params); // invoke function on active window's wrapper
+                // if (visibleWindow) { // update options is invoked during docking registration while stacked window is being created, so may not have visible window
+                // 	visibleWindow._updateOptions(params); // invoke function on active window's wrapper
+                // }
+            }
+            else {
+                Logger.system.error(`StackedWindowManager.updateOptions Warning: updateOptions received for hidden window ${params.windowIdentifier.windowName}`);
+            }
+        }
+        else {
+            // else must be an outdated request from a closed stacked window
+            Logger.system.warn("ignoring command because StackedWindow undefined (probably okay due to its recent close)", params);
+            err = "undefined window";
+        }
+        callback(err);
+    }
+    // stacked window hide (invoked remotely through stacked window wrapper)
+    hide(params, callback = Function.prototype) {
+        Logger.system.debug("StackedWindowManager.hide", params);
+        // if operating on StackedWindow then operation should apply to the visible window
+        if (this.operatingDirectlyOnStackedWindow(params)) {
+            const thisStackRecord = this.storeCache[params.stackedWindowIdentifier.windowName];
+            if (thisStackRecord) {
+                params.windowIdentifier = thisStackRecord.visibleWindowIdentifier;
+                thisStackRecord.isVisible = false;
+            }
+            else {
+                Logger.system.warn("ignoring command because StackedWindow undefined (probably okay due to its recent close)", params);
+                return callback("undefined window");
+            }
+        }
+        if (this.isShowing(params)) {
+            const visibleWindow = this.childWindow[params.windowIdentifier.windowName];
+            params.invokedByParent = true; // prevents wrapper function from recalling parent (causing a loop)
+            visibleWindow === null || visibleWindow === void 0 ? void 0 : visibleWindow._hide(params); // invoke function on active window's wrapper
+        }
+        else {
+            Logger.system.error(`StackedWindowManager Warning: hide received for hidden window ${params.windowIdentifier.windowName}`);
+        }
+        callback(null);
+    }
+    // stacked window show (invoked remotely through stacked window wrapper)
+    show(params, callback = Function.prototype) {
+        Logger.system.debug("StackedWindowManager.show", params);
+        // if operating on StackedWindow then operation should apply to the visible window
+        if (this.operatingDirectlyOnStackedWindow(params)) {
+            const thisStackRecord = this.storeCache[params.stackedWindowIdentifier.windowName];
+            if (thisStackRecord) {
+                params.windowIdentifier = thisStackRecord.visibleWindowIdentifier;
+                thisStackRecord.isVisible = true;
+            }
+            else {
+                Logger.system.warn("ignoring command because StackedWindow undefined (probably okay due to its recent close)", params);
+                return callback("undefined window");
+            }
+        }
+        if (this.isShowing(params)) {
+            const visibleWindow = this.childWindow[params.windowIdentifier.windowName];
+            params.invokedByParent = true; // prevents wrapper function from recalling parent (causing a loop)
+            visibleWindow === null || visibleWindow === void 0 ? void 0 : visibleWindow._show(params); // invoke function on active window's wrapper
+        }
+        else {
+            Logger.system.error(`StackedWindowManager Warning: show received for hidden window ${params.windowIdentifier.windowName}`);
+        }
+        callback(null);
+    }
+    // this stacked window close applies to an individual child window (see closeStackedWindow for closing the complete stackedWindow)
+    close(params, callback = Function.prototype) {
+        Logger.system.debug("StackedWindowManager.close", params);
+        // if operating on StackedWindow then operation should apply to the visible window
+        if (params.removeFromWorkspace || this.operatingDirectlyOnStackedWindow(params)) {
+            this.closeStackedWindow(params, callback);
+        }
+        else {
+            this.deleteWindow(params, callback);
+        }
+    }
+    /**
+     * whether the stack itself is visible or not
+     * @param params
+     * @param callback
+     */
+    isStackShowing(params, callback = Function.prototype) {
+        const thisStackRecord = this.storeCache[params.stackedWindowIdentifier.windowName];
+        if (thisStackRecord.isVisible === false) {
+            callback(null, false);
+            return;
+        }
+        callback(null, true);
+    }
+    /**
+     * set Stack to be always on top. Makes all children of the stack always on top and triggers the alwaysOnTop event for the stack
+     */
+    setAlwaysOnTop(params, callback = Function.prototype) {
+        const setAlwaysOnTopPromiseResolver = (resolve) => {
+            Logger.system.debug("StackedWindowManager.setAlwaysOnTop", params);
+            const thisStackRecord = this.storeCache[params.stackedWindowIdentifier.windowName];
+            // if operating on StackedWindow then operation should apply to the visible window
+            if (this.operatingDirectlyOnStackedWindow(params) && !thisStackRecord) {
+                Logger.system.warn("ignoring command because StackedWindow undefined (probably okay due to its recent close)", params);
+                resolve();
+                return callback("undefined window");
+            }
+            params.invokedByParent = true; // prevents wrapper function from recalling parent (causing a loop)
+            for (const childWindowIdentifier of thisStackRecord.childWindowIdentifiers) {
+                const childWindow = this.childWindow[childWindowIdentifier.windowName];
+                childWindow._alwaysOnTop(params);
+            }
+            FinsembleWindowInternal.getInstance({ name: thisStackRecord.name }, (err, stackedWindow) => {
+                if (stackedWindow.alwaysOnTop !== params.alwaysOnTop) {
+                    stackedWindow.alwaysOnTop = params.alwaysOnTop;
+                    stackedWindow.eventManager.trigger("alwaysOnTop", {
+                        alwaysOnTop: params.alwaysOnTop,
+                    });
+                    Logger.system.verbose("StackedWindowManager transmitting event", "alwaysOnTop", this.eventChannelName(thisStackRecord.name, "alwaysOnTop"), event);
+                }
+                callback(null);
+                resolve();
+            });
+        };
+        return new Promise(setAlwaysOnTopPromiseResolver);
+    }
+    // stacked window setOpacity (invoked remotely through stacked window wrapper)
+    setOpacity(params, callback = Function.prototype) {
+        let err = null;
+        Logger.system.debug("StackedWindowManager.setOpacity", params);
+        const thisStackRecord = this.storeCache[params.stackedWindowIdentifier.windowName];
+        if (thisStackRecord) {
+            // if operating on StackedWindow then operation should apply to the visible window
+            if (this.operatingDirectlyOnStackedWindow(params)) {
+                if (!thisStackRecord.visibleWindowIdentifier)
+                    return; // there's no window to set opacity on.
+                params.windowIdentifier = thisStackRecord.visibleWindowIdentifier;
+            }
+            if (this.isShowing(params)) {
+                const visibleWindow = this.childWindow[params.windowIdentifier.windowName];
+                params.invokedByParent = true; // prevents wrapper function from recalling parent (causing a loop)
+                visibleWindow === null || visibleWindow === void 0 ? void 0 : visibleWindow._setOpacity(params); // invoke function on active window's wrapper
+            }
+            else {
+                Logger.system.error(`StackedWindowManager Warning: setOpacity received for hidden window ${params.windowIdentifier.windowName}`);
+            }
+        }
+        else {
+            Logger.system.warn("ignoring command because StackedWindow undefined (probably okay due to its recent close)", params);
+            err = "undefined window";
+        }
+        callback(err);
+    }
+    // ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+    // General functions support workspace and docking
+    // TABBING TBD: NEED GENERAL PARAMETERIZED VERSIONS OF THE FUNCTIONS BELOW PULLED OUT OF THE WINDOW CLIENT AND PUT IN COMMON TO SHARE
+    // ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+    // placeholder for workspace integration
+    async saveWindowOptions(params, stackedWindowIdentifier, maincallback = Function.prototype) {
+        Logger.system.debug("StackedWindowManager.setComponentState", stackedWindowIdentifier);
+        const thisStackRecord = this.storeCache[stackedWindowIdentifier.windowName];
+        if (!thisStackRecord)
+            return maincallback("stack record not found");
+        const { wrap: stackedWindow } = await FinsembleWindowInternal.getInstance({
+            name: stackedWindowIdentifier.windowName,
+        });
+        stackedWindow.saveCompleteWindowState(thisStackRecord, () => {
+            var _a;
+            const saveChildBounds = (childIdentifier, done) => {
+                Logger.system.debug("StackedWindowManager.saveWindowOptions saveCompleteWindowState child", childIdentifier.windowName);
+                const { bounds } = thisStackRecord;
+                bounds.persistBounds = true;
+                const wrap = this.childWindow[childIdentifier.windowName];
+                if (wrap) {
+                    wrap._setBounds({ bounds, invokedByParent: true }, done);
+                }
+                else {
+                    FinsembleWindowInternal.getInstance({ name: childIdentifier.windowName }, (err, wrappedWindow) => {
+                        wrappedWindow._setBounds({ bounds, invokedByParent: true }, done);
+                    });
+                }
+            };
+            Logger.system.debug("StackedWindowManager.saveWindowOptions saveCompleteWindowState start", (_a = stackedWindow.identifier) === null || _a === void 0 ? void 0 : _a.windowName, thisStackRecord);
+            if (!params.closing) {
+                asyncEach(thisStackRecord.childWindowIdentifiers, saveChildBounds, () => {
+                    Logger.system.debug("StackedWindowManager.saveWindowOptions saveCompleteWindowState done");
+                    RouterClient.publish(`Finsemble.StackedWindow.${stackedWindowIdentifier.windowName}`, thisStackRecord);
+                    maincallback();
+                });
+            }
+            else {
+                Logger.system.debug("StackedWindowManager.saveWindowOptions saveCompleteWindowState skipped");
+                RouterClient.publish(`Finsemble.StackedWindow.${stackedWindowIdentifier.windowName}`, thisStackRecord);
+                maincallback();
+            }
+        });
+    }
+    /**
+     * Register a window with docking. It transmits a message to the LauncherService, which registers it as a dockable window.
+     *
+     * @param {object} params Parameters
+     * @param {string} params.windowIdentifier the window to register (may be stacked window or child window)
+     * @private
+     */
+    registerWithDockingManager(params, cb = Function.prototype) {
+        const promiseResolver = (resolve) => {
+            Logger.system.debug("StackedWindowManager.registerWithDockingManager", params);
+            const { windowName } = params.windowIdentifier;
+            params.windowIdentifier.name = windowName;
+            // In the case when we have an existing window, we should use it's options. Otherwise the default options will be applied.
+            const wrap = this.childWindow[windowName];
+            const queryParams = wrap
+                ? {
+                    name: windowName,
+                    uuid: params.windowIdentifier.uuid,
+                    windowType: params.windowIdentifier.windowType,
+                    options: {
+                        // dockingOptions
+                        options: wrap.dockingOptions,
+                        snapping: wrap.snapping,
+                        tiling: wrap.tiling,
+                        tabbing: wrap.tabbing,
+                        allowAutoArrange: wrap.allowAutoArrange,
+                        canMinimize: wrap.canMinimize,
+                        canMaximize: wrap.canMaximize,
+                    },
+                }
+                : Object.assign(params.windowIdentifier, params.windowType);
+            RouterClient.query("DockingService.registerWindow", queryParams, () => {
+                Logger.system.debug("StackedWindowManager Docking Registration complete.", params);
+                resolve();
+                if (cb) {
+                    cb();
+                }
+            });
+        };
+        return new Promise(promiseResolver);
+    }
+    /**
+     * Unregister a window with docking.
+     *
+     * @param {object} params Parameters
+     * @param {boolean} params.removeFromWorkspace true to remove from workspace
+     * @param {string} params.windowIdentifier window to unregister
+     * @private
+     */
+    deregisterWithDockingManager(params) {
+        Logger.system.debug("StackedWindowManager.deregisterWithDockingManager", params);
+        RouterClient.transmit("DockingService.deregisterWindow", {
+            name: params.windowIdentifier.windowName,
+            userInitiated: params.removeFromWorkspace,
+        });
+    }
+    startMove(params, callback = Function.prototype) {
+        // stacked window setBounds (invoked remotely through stacked window wrapper)
+        Logger.system.debug("StackedWindowManager.startMove", params);
+        let err = null;
+        const thisStackRecord = this.storeCache[params.stackedWindowIdentifier.windowName];
+        if (!thisStackRecord) {
+            Logger.system.warn("ignoring command because StackedWindow undefined (probably okay due to its recent close)", params);
+            err = "undefined window";
+        }
+        else {
+            // if operating on StackedWindow then operation should apply to the visible window
+            if (this.operatingDirectlyOnStackedWindow(params)) {
+                params.windowIdentifier = thisStackRecord.visibleWindowIdentifier;
+            }
+            if (this.isShowing(params)) {
+                const visibleWindow = this.childWindow[params.windowIdentifier.windowName];
+                visibleWindow === null || visibleWindow === void 0 ? void 0 : visibleWindow.startMove(); // invoke function on active window's wrapper
+            }
+            else {
+                Logger.system.error(`StackedWindowManager Warning: startMove received for hidden window ${params.windowIdentifier}`);
+            }
+        }
+        callback(err);
+    }
+    stopMove(params, callback = Function.prototype) {
+        // stacked window setBounds (invoked remotely through stacked window wrapper)
+        Logger.system.debug("StackedWindowManager.stopMove", params);
+        let err = null;
+        const thisStackRecord = this.storeCache[params.stackedWindowIdentifier.windowName];
+        if (!thisStackRecord) {
+            Logger.system.warn("ignoring command because StackedWindow undefined (probably okay due to its recent close)", params);
+            err = "undefined window";
+        }
+        else {
+            // if operating on StackedWindow then operation should apply to the visible window
+            if (this.operatingDirectlyOnStackedWindow(params)) {
+                params.windowIdentifier = thisStackRecord.visibleWindowIdentifier;
+            }
+            if (this.isShowing(params)) {
+                const visibleWindow = this.childWindow[params.windowIdentifier.windowName];
+                visibleWindow === null || visibleWindow === void 0 ? void 0 : visibleWindow.stopMove(); // invoke function on active window's wrapper
+            }
+            else {
+                Logger.system.error(`StackedWindowManager Warning: stopMove received for hidden window ${params.windowIdentifier}`);
+            }
+        }
+        callback(err);
+    }
+}
+const serviceInstance = new StackedWindowManager({});
+export default serviceInstance;
+//# sourceMappingURL=stackedWindowManager.js.map