@finsemble/finsemble-ui 8.3.0 → 8.3.1

package/platform/services/window/Docking/dockingMain.js

@@ -1,2541 +0,0 @@
-import { isEqualIgnoringArrayOrder } from "../../../../common/util";
-import * as util from "../../../../common/util";
-import DockingCalculator from "./dockingCalculator";
-import { FinsembleWindowInternal } from "../WindowAbstractions/FinsembleWindowInternal";
-import { BaseWindow } from "../WindowAbstractions/BaseWindow";
-import AutoArrange from "../MultiWindowFeatures/autoArrange";
-import { System } from "../../../../common/system";
-import DockableWindow from "./dockableWindow";
-import BoxMath from "./boxMath";
-import { RouterClient } from "../../../../clients/routerClient";
-import LauncherClient from "../../../../clients/launcherClient";
-import ConfigClient from "../../../../clients/configClient";
-import { Logger } from "../../../../clients/logger";
-import * as constants from "../../../../common/constants";
-import { deriveWindowPosition, splitWindowMoves } from "./monitorUpdateHandler";
-import SystemManagerClient from "../../../../common/systemManagerClient";
-import { WINDOWSTATE } from "../../../../common/constants";
-import { getAllMonitors, adjustBoundsToBeOnMonitor, onMonitorsChanged } from "../../../../common/Monitors";
-import { DockingPoolSingleton, MonitorPoolSingleton } from "../Common/Pools/PoolSingletons";
-import { DockableMonitor } from "./dockableMonitor";
-import uuidv4 from "uuid-random";
-Logger.start();
-const DockingMain_AUTO_ARRANGE_CHANNEL = "DockingService.AutoArrangeStatus";
-let serviceConfig = {};
-let groupData = {};
-const { APPLICATION_STATE_CHANNEL } = constants;
-// Paste this into a toolbar's console.
-// [1,2,3,4,5].forEach(num => FSBL.Clients.LauncherClient.spawn("Welcome Component", {name: "window" + num, addToWorkspace: true}))
-const clone = function (obj) {
-    // This has been tested a good amount. Previous to this commit we were using a mix of deepmerge and JSON.parse(JSON.stringify()).
-    // Trying lodash/deepclone made my tests take 2-3s.
-    // JSON.parse everywhere made them take ~ 1s.
-    // Using JSON.parse on arrays and deep merge on objects makes them take 7-900ms.
-    if (Array.isArray(obj)) {
-        return obj.slice();
-    }
-    try {
-        return JSON.parse(JSON.stringify(obj));
-    }
-    catch (e) {
-        Logger.system.error("clone error", e);
-        return e;
-    }
-};
-const CALCULATOR = {
-    addWindow: Function.prototype,
-    removeWindow: Function.prototype,
-    getBoundsOfGroupWindows: Function.prototype,
-    cleanupSharedEdges: Function.prototype,
-};
-/**
- * Takes any Bounds type that may or may not have all fields filled in (e.g. right or width)
- * and returns a CompleteBounds with all fields computed.
- *
- * At least left & right, or left & width, or right & width must be provided or the calculation will be zero
- * At least top & bottom, or top & height, or bottom & height must be provided or the calculation will be zero
- */
-const completeBounds = (source) => {
-    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m;
-    const left = (_a = source.left) !== null && _a !== void 0 ? _a : ((_b = source.right) !== null && _b !== void 0 ? _b : 0) - ((_c = source.width) !== null && _c !== void 0 ? _c : 0);
-    const right = (_d = source.right) !== null && _d !== void 0 ? _d : left + ((_e = source.width) !== null && _e !== void 0 ? _e : 0);
-    const width = (_f = source.width) !== null && _f !== void 0 ? _f : right - left;
-    const top = (_g = source.top) !== null && _g !== void 0 ? _g : ((_h = source.bottom) !== null && _h !== void 0 ? _h : 0) - ((_j = source.height) !== null && _j !== void 0 ? _j : 0);
-    const bottom = (_k = source.bottom) !== null && _k !== void 0 ? _k : top + ((_l = source.height) !== null && _l !== void 0 ? _l : 0);
-    const height = (_m = source.height) !== null && _m !== void 0 ? _m : bottom - top;
-    return {
-        left,
-        right,
-        top,
-        bottom,
-        width,
-        height,
-    };
-};
-/**
- * Shows the scrim occupying half the of the group or window bounds specified in bounds on the side specified by edge.
- *
- * @param {any} edge
- * @param {any} bounds
- * @returns
- */
-const scrimShower = (edge, bounds) => {
-    const maskBounds = Object.assign({}, bounds);
-    const newWindowBounds = Object.assign({}, bounds);
-    switch (edge) {
-        case "full": // This is for swapping
-            break;
-        case "top":
-            maskBounds.height = Math.round(bounds.height / 2);
-            maskBounds.bottom = maskBounds.top + maskBounds.height;
-            newWindowBounds.top = maskBounds.bottom;
-            newWindowBounds.height = bounds.height - maskBounds.height;
-            // Recalculate so it isn't affected by rounding errors.
-            newWindowBounds.bottom = newWindowBounds.top + newWindowBounds.height;
-            break;
-        case "left":
-            maskBounds.width = Math.round(bounds.width / 2);
-            maskBounds.right = maskBounds.left + maskBounds.width;
-            newWindowBounds.left = maskBounds.right;
-            newWindowBounds.width = bounds.width - maskBounds.width;
-            // Recalculate so it isn't affected by rounding errors.
-            newWindowBounds.right = newWindowBounds.left + newWindowBounds.width;
-            break;
-        case "bottom":
-            maskBounds.height = Math.round(bounds.height / 2);
-            maskBounds.top = maskBounds.bottom - maskBounds.height;
-            newWindowBounds.bottom = maskBounds.top;
-            newWindowBounds.height = bounds.height - maskBounds.height;
-            // Recalculate so it isn't affected by rounding errors.
-            newWindowBounds.top = newWindowBounds.bottom - newWindowBounds.height;
-            break;
-        case "right":
-            maskBounds.width = Math.round(bounds.width / 2);
-            maskBounds.left = maskBounds.left + maskBounds.width;
-            newWindowBounds.right = maskBounds.left;
-            newWindowBounds.width = bounds.width - maskBounds.width;
-            // Recalculate so it isn't affected by rounding errors.
-            newWindowBounds.left = newWindowBounds.right - newWindowBounds.width;
-            break;
-        default:
-            break;
-    }
-    return {
-        maskBounds,
-        newWindowBounds,
-    };
-};
-class DockingMain extends DockingCalculator {
-    constructor(params, monitorsInstance) {
-        super(monitorsInstance);
-        // for reverting autoArrange
-        this.cachedPositions = {};
-        this.registrationPending = {};
-        this.deregistrationPending = {};
-        this.activeWorkspace = { name: "", guid: "" };
-        this.isWindows = true;
-        this.applicationState = "";
-        // We're doing this for hole-filling. need to remove the window so that while we're resizing windows, they're unphased by the windows that are resizing.
-        CALCULATOR.addWindow = super.addWindowInternal.bind(this);
-        CALCULATOR.removeWindow = super.removeWindowInternal.bind(this);
-        CALCULATOR.getBoundsOfGroupWindows = super.getBoundsOfGroupWindows.bind(this);
-        CALCULATOR.cleanupSharedEdges = super.cleanupSharedEdges.bind(this);
-        this.AutoArrange = new AutoArrange({
-            DockingCalculator: this,
-        });
-        // For disabling tabbing or tiling
-        this.tabbingEnabled = typeof params.tabbingEnabled !== undefined ? params.tabbingEnabled : false;
-        this.tilingEnabled = typeof params.tilingEnabled !== undefined ? params.tilingEnabled : false;
-        // Determined by services config. Set when docking is constructed.
-        this.enableWindowsAeroSnap = false;
-        // Default height and width for a dockableComponent. This comes from the main config with
-        // docking options. These defaults are different from launchers defaults for a given window
-        this.defaultHeight = params.defaultHeight;
-        this.defaultWidth = params.defaultWidth;
-        onMonitorsChanged(this.monitorsChanged.bind(this));
-        this.bindAllFunctions();
-    }
-    bindAllFunctions() {
-        const self = this;
-        for (const name of Object.getOwnPropertyNames(Object.getPrototypeOf(self))) {
-            if (self[name] instanceof Function) {
-                self[name] = self[name].bind(self); // only bind function properties
-            }
-        }
-    }
-    defaultDockingOptions(options, MIN_HEIGHT, MIN_WIDTH) {
-        var _a;
-        let defaultOptions = {};
-        // If no options, start with an empty object so that all the lines below don't cause catastrophic failures.
-        if (!options)
-            options = {};
-        const checkForTaskbarOptions = options.hasOwnProperty("options");
-        defaultOptions.dockable = options.dockable || false;
-        defaultOptions.ephemeral = options.ephemeral;
-        defaultOptions.undockedParams = {
-            width: options.width,
-            height: options.height,
-        };
-        defaultOptions.dockedParams = {
-            width: options.dockedWidth ? options.dockedWidth : options.width,
-            height: options.dockedHeight ? options.dockedHeight : options.height,
-        };
-        if (!defaultOptions.dockable) {
-            defaultOptions.startsDocked = false;
-        }
-        else {
-            defaultOptions.startsDocked = options.docked || "top";
-        }
-        defaultOptions.overwriteDockedOptions = options.overwriteStartDocked || false;
-        // If snapping is true, we don't want to ignoreSnappingRequests and vice versa
-        defaultOptions.ignoreSnappingRequests = typeof options.snapping === "undefined" ? false : !options.snapping;
-        defaultOptions.showTaskbarIcon = checkForTaskbarOptions ? (_a = options.options) === null || _a === void 0 ? void 0 : _a.showTaskbarIcon : true;
-        defaultOptions.minHeight = options.minHeight || MIN_HEIGHT;
-        defaultOptions.maxHeight = options.maxHeight || Infinity;
-        defaultOptions.minWidth = options.minWidth || MIN_WIDTH;
-        defaultOptions.maxWidth = options.maxWidth || Infinity;
-        defaultOptions.claimSpace = {
-            enabled: false,
-        };
-        return defaultOptions;
-    }
-    windowServiceChannelName(channelTopic) {
-        return `WindowService-Request-${channelTopic}`;
-    }
-    /**
-     * Function that sets wether tabbing or tiling is disabled for this instance of DockingMain
-     *
-     * @param {object} serviceConfig The service config
-     */
-    setTilingOrTabbingEnabled(setTilingOrTabbingEnabledArg) {
-        let tabbing = true;
-        let tiling = true;
-        if (setTilingOrTabbingEnabledArg.hasOwnProperty("tabbing") &&
-            setTilingOrTabbingEnabledArg.tabbing.hasOwnProperty("enabled")) {
-            Logger.system.debug(`Setting tabbing prop based on config state: ${setTilingOrTabbingEnabledArg.tabbing.enabled}`);
-            tabbing = setTilingOrTabbingEnabledArg.tabbing.enabled;
-        }
-        if (setTilingOrTabbingEnabledArg.hasOwnProperty("tiling") &&
-            setTilingOrTabbingEnabledArg.tiling.hasOwnProperty("enabled")) {
-            Logger.system.debug(`Setting tiling prop based on config state: ${setTilingOrTabbingEnabledArg.tiling.enabled}`);
-            tiling = setTilingOrTabbingEnabledArg.tiling.enabled;
-        }
-        this.tabbingEnabled = tabbing;
-        this.tilingEnabled = tiling;
-    }
-    /**
-     * Function that runs after a window has completed a move action
-     *
-     * @param {object} win The window object
-     * @param {boolean} triggeredByAutoArrange True if the move was triggered by auto arrange. If the move was triggered by auto arrange, we don't want to delete cached window positions.
-     */
-    onMoveComplete(win, triggeredByAutoArrange) {
-        // If an autoarrangeable window is moved, and the move isn't triggered by auto arrange, we want to wipe the status
-        if (!triggeredByAutoArrange) {
-            this.resetAutoArrangeForAWindowsMonitor(win);
-        }
-        const movedWin = this.getWindow(win.name);
-        let groupChanged = this.tellWindowOrGroupToSaveLocation(movedWin);
-        if (groupChanged) {
-            this.updateGroupData();
-        }
-    }
-    updateGroupData() {
-        const changed = this._updateGroupData();
-        Logger.system.debug("Publishing Group Update: DockingCalc.updateGroupData", changed ? "changed" : "not changed");
-        if (changed) {
-            this.publishGroupUpdate();
-        }
-    }
-    /**
-     * Handler for incoming docking deregistration request for specified window.
-     * Invoked both by addListener("DockingService.registerWindow") and addListener("DockingService.deregisterWindow").
-     * @private
-     */
-    deregisterWindow(self, err, response) {
-        const windowName = response.data.name;
-        // if a registration pending for window, then can't deregister yet, so save deregister request here and process it when registration is complete
-        if (self.registrationPending[windowName]) {
-            const deregisterArgs = { err, response }; // save original args to use when later unregistering
-            self.deregistrationPending[windowName] = deregisterArgs;
-            Logger.system.info("deregisterWindow: creating pending deregistration", windowName);
-        }
-        else {
-            // no registration pending so continue with deregistration
-            const registeredWindows = self.getWindowNames();
-            Logger.system.info("Trying to deregisterWindow", windowName);
-            if (!registeredWindows.includes(windowName)) {
-                Logger.system.debug("Window tried to deregister, but never registered", windowName);
-                return;
-            }
-            let win = self.getWindow(windowName);
-            self.AutoArrange.reconcileStackDeletionWithAutoArrangedWindows(win);
-            if (response.data.removeFromWorkspace) {
-                const bounds = win.getBounds();
-                const movableGroup = self.getMovableGroup(windowName);
-                const immobileGroup = self.getImmobileGroup(windowName);
-                const fillHoleInGroup = self.shouldFillHolesInGroups(movableGroup);
-                self.removeWindowFromAllGroups(win);
-                self.wipeSnapRelationships(windowName);
-                self.removeWindow(windowName);
-                if (movableGroup && fillHoleInGroup) {
-                    Logger.system.debug("docking.deregisterWindow", windowName, movableGroup, fillHoleInGroup);
-                    console.debug("docking.deregisterWindow", windowName, movableGroup, fillHoleInGroup);
-                    this.fillHoles(movableGroup, bounds);
-                }
-                else {
-                    Logger.system.debug("docking.deregisterWindow fix option", windowName, movableGroup, fillHoleInGroup);
-                    console.debug("docking.deregisterWindow fix option", windowName, movableGroup, fillHoleInGroup);
-                    [movableGroup, immobileGroup].forEach((grp) => grp && self.fixGroupMembership(grp));
-                }
-                if (immobileGroup) {
-                    immobileGroup.updateBounds();
-                }
-            }
-            else {
-                // We're not removing the window from the workspace (i.e. deregisterWindow gets triggered by workspace reload or switching workspaces)
-                // in which case we can skip rebuilding group relationships and just remove the window.
-                self.removeWindow(windowName);
-            }
-            // will handle any group updates that need to be sent.
-            if (self.onMoveComplete && response.data.userInitiated === true) {
-                self.onMoveComplete(win);
-            }
-            delete self.deregistrationPending[windowName];
-            Logger.system.info("deregisterWindow: complete", windowName);
-            Logger.system.debug("Docking: Registered Windows", Object.keys(self.getWindows()));
-        }
-    }
-    /**
-     * Given a window name, reset the auto arrange status for the monitor that window is on
-     * @param {object | string} window A window name or docking window object
-     */
-    resetAutoArrangeForAWindowsMonitor(window) {
-        let win;
-        if (typeof window === "string" || window.hasOwnProperty("name")) {
-            // If window is a string or has a name property we can use it to get the window
-            const name = window.hasOwnProperty("name") ? window.name : window;
-            win = this.getWindow(name);
-            // Window might have already deregistered. Check to see if a window was returned
-            if (!win) {
-                // If the window wasn't found return
-                return;
-            }
-        }
-        const { monitor } = win;
-        if (!monitor) {
-            // If the monitor for the given window can't be found the auto arrange status reset will not succeed; return
-            return;
-        }
-        /*
-            12/11/19 JC - Previously, this was unthought of, but when a window is closed the auto arrange status should be wiped.
-            Otherwise you end up with a case where you can auto arrange some windows, close a window in that arrangement, and
-            now your auto arrange status is still true but clicking auto arrange will re-arrange, not restore, the remaining windows.
-        */
-        if (this.AutoArrange.isArranged[monitor.name] && win.win.allowAutoArrange !== false) {
-            this.AutoArrange.isArranged[monitor.name] = false;
-            delete this.cachedPositions[monitor.name][win.name];
-            this.cachedPositions[monitor.name] = {};
-            this.sendAutoArrangeStatusUpdate();
-        }
-    }
-    /**
-     *  Helper function that determines whether a group should fill holes left by windows that leave it.
-     * @params {dockableGroup} grp The group for which to fill holes (or not).
-     */
-    shouldFillHolesInGroups(grp) {
-        let fillHoleInGroup = this.groupMode.fillHolesOnUndock;
-        if (fillHoleInGroup) {
-            fillHoleInGroup = grp && grp.isARectangle();
-        }
-        return fillHoleInGroup;
-    }
-    /**
-     * When a window no longer delegates its movement to us (it closes or unregisters for some reason), we need to make sure we don't leave strange, disconnected groups out there.
-     * If you imagine [A][B][C], and B is closed, this code will make sure that A & C don't remain grouped.
-     * @param {*} grp
-     */
-    fixGroupMembership(grp) {
-        this.buildSnapRelationshipsForGroup(grp);
-        const windowsThatWereInGroup = grp.getWindowNames();
-        const wasMovable = grp.isMovable;
-        // 2nd param says 'Don't worry, we will reform this group. Don't go changing
-        // taskbar icons willy nilly.
-        this.removeGroup(grp.name, true);
-        for (const name of windowsThatWereInGroup) {
-            let group;
-            if (wasMovable) {
-                group = this.getMovableGroup(name);
-            }
-            else {
-                group = this.getImmobileGroup(name);
-            }
-            // Prevent exponential group formation by not calling formGroup is the window is already in a group.
-            if (!group) {
-                this.formGroup(name, {
-                    isMovable: wasMovable,
-                    whitelist: windowsThatWereInGroup,
-                });
-            }
-        }
-    }
-    // If a window closes uncleanly, we will clean up docking.
-    onWindowClosed(err, response) {
-        if (response.data.name.indexOf("StackedWindow") === -1) {
-            this.resetAutoArrangeForAWindowsMonitor(response.data.name);
-        }
-        this.deregisterWindow(this, null, response);
-        this.updateGroupData();
-    }
-    /**
-     * Creates router endpoints for all of our client APIs. Add servers or listeners for requests coming from your clients.
-     * @private
-     */
-    createRouterEndpoints() {
-        RouterClient.subscribe(constants.WORKSPACE.UPDATE_PUBSUB, (err, response) => {
-            if (response.data.reason === "workspace:load:dataRetrieved" ||
-                response.data.reason === "workspace:load:finished" ||
-                response.data.reason === "rename") {
-                this.handleWorkspaceUpdate(err, response);
-            }
-        });
-        RouterClient.addListener("DockingService.showAtMousePosition", (err, response) => {
-            this.dockingReady || Logger.system.error("Docking API invoked before ready", response);
-            const windowIdentifier = response.data;
-            const win = this.getWindow(windowIdentifier.windowName);
-            System.getMousePosition((getMousePositionErr, position) => {
-                var _a, _b, _c, _d, _e, _f;
-                // Here we generate a fake event to move the window where we want it to go. This will cause docking to go through its typical event loop, undock the window, and everything else the user expects.
-                const bounds = win.getBounds();
-                if (!win.win.isDocked) {
-                    bounds.top = ((_a = position === null || position === void 0 ? void 0 : position.top) !== null && _a !== void 0 ? _a : 0) - ((_b = bounds.height) !== null && _b !== void 0 ? _b : 0) + 10;
-                    // center the window over the mouse position. Feels better.
-                    bounds.left = ((_c = position === null || position === void 0 ? void 0 : position.left) !== null && _c !== void 0 ? _c : 0) - ((_d = bounds.width) !== null && _d !== void 0 ? _d : 0) / 2;
-                    bounds.right = bounds.left + ((_e = bounds.width) !== null && _e !== void 0 ? _e : 0);
-                    bounds.bottom = bounds.top + ((_f = bounds.height) !== null && _f !== void 0 ? _f : 0);
-                }
-                win.setBounds(bounds, () => {
-                    win.show();
-                    this.tellWindowOrGroupToSaveLocation(win);
-                });
-            });
-        });
-        const addWindow = async (windowWrap, message, data) => {
-            try {
-                await this.addWindow(windowWrap);
-                const { data: isShowing } = await windowWrap._isShowing({});
-                // failure point, add window failed.
-                message.sendQueryResponse(null, {
-                    status: "finished",
-                });
-                let dockableWin = this.getWindow(windowWrap.name);
-                // Not sure how this is possible but defensive programming against a bug seen in the field - https://support.chartiq.com/a/tickets/11962
-                if (!dockableWin) {
-                    await this.addWindow(windowWrap);
-                    dockableWin = this.getWindow(windowWrap.name);
-                    if (!dockableWin) {
-                        Logger.system.error("addWindow failed to add Window to docking or window was removed immediately after adding.", windowWrap.name);
-                        return;
-                    }
-                }
-                const isDockable = dockableWin.isDockableComponent || windowWrap.windowState === WINDOWSTATE.NORMAL;
-                // windows are temporarily hidden when minimized, maximize, autoShow === false
-                if (isShowing === false && isDockable) {
-                    dockableWin.isHidden = true;
-                }
-                else {
-                    dockableWin.isHidden = false;
-                }
-                // group windows whether they are showing or not
-                this.checkIfWindowIsInGroup(data.name);
-                Logger.system.info("registerWindow: registration complete", data.name);
-                Logger.system.debug("Docking: Registered Windows", Object.keys(this.getWindows()));
-                // registration complete so can clear marker for pending registration; deregistrationWindow looks for this same marker
-                delete this.registrationPending[data.name];
-                // if there is a deregister pending for the window (see deregisterWindow) can now process it since registration is complete
-                if (this.deregistrationPending[data.name]) {
-                    const deregisterArgs = this.deregistrationPending[data.name]; // get the original deregister arguments
-                    this.deregisterWindow(this, deregisterArgs.err, deregisterArgs.response); // process the pending deregister
-                    delete this.deregistrationPending[data.name]; // pending deregistration has been processed so delete
-                    Logger.system.info("deregisterWindow: pending deregistration processed", data.name);
-                }
-                this.AutoArrange.reconcileStackCreationWithAutoArrangedWindows(data);
-            }
-            catch (_a) {
-                /* failed to add */
-            }
-        };
-        // Handler for incoming docking registration request for specified window.
-        RouterClient.addResponder("DockingService.registerWindow", async (err, message) => {
-            var _a, _b;
-            this.dockingReady || Logger.system.error("Docking API invoked before ready", message);
-            if (err || !message) {
-                Logger.system.error("DockingService.registerWindow error", err);
-                return;
-            }
-            const { data } = message;
-            // For the sake of assimilation
-            data.options = Object.assign(data.options || {}, (_b = (_a = data.windowMsg) === null || _a === void 0 ? void 0 : _a.options) !== null && _b !== void 0 ? _b : {});
-            /*
-            If the window has already registered with docking, deregister and then reregister.
-            Sometimes this happens while reloading a workspace where a timing gap causes the same window to reregister before the previous instance is deregistered.
-
-            Second parameter is set to false to prevent a logger warning (we expect *not* to find the window)
-            */
-            if (this.getWindow(data.name, false)) {
-                this.deregisterWindow(this, null, message);
-            }
-            Logger.system.info("registerWindow: starting registration", data.name);
-            this.registrationPending[data.name] = true; // mark pending registration (needed to handle deregisterWindow because register is async, leaving a timing gap)
-            if (!data.windowType)
-                data.windowType = "WebWindow";
-            const { err: getInstanceErr, data: wrap } = await BaseWindow.getInstanceStandardized(data);
-            if (getInstanceErr || !wrap) {
-                Logger.system.error("Docking: registerWindow. addWindow err", message.data.name, getInstanceErr);
-                return;
-            }
-            if (message.data.options && message.data.options.canGroup === false) {
-                this.addToGroupBlacklist(data.name);
-            }
-            const windowWrap = wrap;
-            Logger.system.info("Docking: registerWindow. addWindow", message.data.name, message.data);
-            const dockingOptions = this.defaultDockingOptions(data.options, this.MINIMUM_HEIGHT, this.MINIMUM_WIDTH);
-            windowWrap.dockingOptions = dockingOptions;
-            if (data.options) {
-                windowWrap.snapping = data.options.snapping;
-                windowWrap.tiling = data.options.tiling;
-                windowWrap.tabbing = data.options.tabbing;
-                windowWrap.allowAutoArrange = data.options.allowAutoArrange;
-                if (windowWrap.setMinimizeAbility) {
-                    const canWindowMinimize = data.options.canMinimize !== false;
-                    windowWrap.setMinimizeAbility(canWindowMinimize);
-                }
-                if (windowWrap.setMaximizeAbility) {
-                    const canWindowMaximize = data.options.canMaximize !== false;
-                    windowWrap.setMaximizeAbility(canWindowMaximize);
-                }
-            }
-            windowWrap.enableWindowsAeroSnap = this.enableWindowsAeroSnap;
-            await addWindow(windowWrap, message, data);
-        });
-        /**
-         * Not sure we'll need this any more since we have the wrappers. Leaving in until we can clarify.
-         */
-        RouterClient.addPubSubResponder(/WindowMove.*/, {});
-        // Here we set the initial state of the two group topics (WORKSPACE_GROUP_UPDATE is the old/legacy one)
-        RouterClient.publish(constants.DOCKING.GROUP_UPDATE, this.buildGroupUpdate());
-        RouterClient.publish(constants.DOCKING.WORKSPACE_GROUP_UPDATE, this.buildWorkspaceGroupUpdate());
-        /**
-         * When groupMode changes in a toolbar (or any component), it uses PubSub to publish a state change.
-         */
-        RouterClient.addPubSubResponder("DockingService.groupMode", {});
-        RouterClient.subscribe("WindowMoved", () => {
-            // this.onMouseUp();
-        });
-        RouterClient.subscribe("monitorInfo", (monitorInfoErr, response) => {
-            this.updateMonitorInfo(response.data);
-        });
-        RouterClient.addResponder("DockingService.getGroupMode", (err, message) => {
-            this.dockingReady || Logger.system.error("Docking API invoked before ready", message);
-            if (!err && message)
-                message.sendQueryResponse(null, this.getGroupMode());
-        });
-        RouterClient.addResponder("DockingService.getBounds", (err, message) => {
-            this.dockingReady || Logger.system.error("Docking API invoked before ready", message);
-            if (!err && message)
-                this.getBounds(message.data, (getBoundsErr, bounds) => {
-                    message.sendQueryResponse(getBoundsErr, bounds);
-                });
-        });
-        RouterClient.addListener("DockingService.toggleGroupMode", (toggleGroupModeErr, message) => {
-            this.dockingReady || Logger.system.error("Docking API invoked before ready", message);
-            const groupMode = this.getGroupMode();
-            groupMode.enabled = !groupMode.enabled;
-            this.setGroupMode(groupMode);
-        });
-        RouterClient.addListener("DockingService.updateWindowLocation", (err, message) => {
-            this.dockingReady || Logger.system.error("Docking API invoked before ready", message);
-            const updateWindow = this.getWindow(message.data.windowName, false);
-            // we get updates for _every_ window when their location changes via launcherClient.showWindow. Even if they aren't registered with docking. This if statement prevents errors from showing up in the logger.
-            if (updateWindow) {
-                updateWindow.setBounds(message.data.location);
-            }
-        });
-        RouterClient.addListener("DockingService.hyperfocusGroup", (err, message) => {
-            Logger.system.deprecated("hyperFocus is deprecated as of version 4.0.0. This functionality may be removed in a future release");
-            this.dockingReady || Logger.system.error("Docking API invoked before ready", message);
-            this.hyperFocus(message.data);
-        });
-        /**
-         * Auto-arrange doesn't throw disable-frame-bounds-changed events, since it uses `setBounds` under the hood. So this will just go through the windows and update their positions.
-         */
-        RouterClient.addListener("DockingService.updateWindowPositions", (err, response) => {
-            this.dockingReady || Logger.system.error("Docking API invoked before ready", response);
-            this.updateWindowPositions();
-        });
-        RouterClient.addListener("DockingService.formGroup", (err, response) => {
-            this.dockingReady || Logger.system.error("Docking API invoked before ready", response);
-            const groupWindowNames = this.formGroup(response.data.windowName, { isMovable: true });
-            this.updateGroupData();
-            this._maybeAddLaunchGroupComponentData(response.data.windowName, groupWindowNames);
-            // Logger.system.debug("Publishing Group Update: FormGroup");
-        });
-        /**
-         * Called from the launcherClient after `spawn` is invoked. Will group two or more windows.
-         */
-        RouterClient.addResponder("DockingService.groupWindows", (err, message) => {
-            this.dockingReady || Logger.system.error("Docking API invoked before ready", message);
-            if (!err && message)
-                this.groupWindows(message.data, (groupWindowsErr) => {
-                    this.updateGroupData();
-                    // Logger.system.debug("Publishing Group Update: GroupWindows");
-                    message.sendQueryResponse(groupWindowsErr, {
-                        groupWindowsErr,
-                        status: groupWindowsErr ? "failed" : "success",
-                    });
-                });
-        });
-        RouterClient.addResponder("DockingService.leaveGroup", (err, response) => {
-            this.dockingReady || Logger.system.error("Docking API invoked before ready", response);
-            if (err || !response) {
-                Logger.system.error("DockingService.leaveGroup error", err);
-                return;
-            }
-            const windowName = response.data.name;
-            const leavingWindow = this.getWindow(windowName, false);
-            if (!leavingWindow) {
-                response.sendQueryResponse("Window is not registered with docking", null);
-                return;
-            }
-            const movableGroup = this.getMovableGroup(windowName);
-            const immovableGroup = this.getImmobileGroup(windowName);
-            if (!movableGroup) {
-                response.sendQueryResponse("Window is not in a moveable group", null);
-                return;
-            }
-            let fillHoleInGroup = false;
-            const hole = leavingWindow.getBounds();
-            if (this.groupMode.undockDisbandsEntireGroup) {
-                this.removeGroup(movableGroup.name);
-            }
-            else {
-                fillHoleInGroup = movableGroup.isARectangle();
-                const newBounds = leavingWindow.getBounds();
-                newBounds.left = newBounds.left + 15;
-                newBounds.right = newBounds.right + 15;
-                newBounds.bottom = newBounds.bottom + 15;
-                newBounds.top = newBounds.top + 15;
-                leavingWindow.setBounds(newBounds);
-                // removeWindowFromGroup(response.data, movableGroup.name);
-                this.removeWindowFromAllGroups(leavingWindow);
-                // Because ejecting the window was causing complications when filling holes.
-                CALCULATOR.removeWindow(leavingWindow.name, false);
-            }
-            this.wipeSnapRelationships(leavingWindow.name);
-            if (fillHoleInGroup) {
-                // group gets reconstituted in the removeWIndowFromGroup function. So get the reference to the new group.
-                this.fillHoles(movableGroup, hole);
-            }
-            else {
-                [movableGroup, immovableGroup].forEach((grp) => {
-                    if (grp) {
-                        this.fixGroupMembership(grp);
-                    }
-                });
-            }
-            if (!this.groupMode.undockDisbandsEntireGroup) {
-                Logger.system.debug("LeaveGroup, adding window back to docking.", leavingWindow.name);
-                CALCULATOR.addWindow(leavingWindow.name, leavingWindow);
-            }
-            this.recalculateSnaps();
-            const groups = this.getGroups();
-            const groupList = {};
-            for (const group in groups) {
-                groupList[group] = groups[group].getWindowNames();
-            }
-            this.updateGroupData();
-            this._removeLaunchGroupComponentDataFromLeavingWindow(leavingWindow);
-            leavingWindow.bringToFront();
-            response.sendQueryResponse(null, groupList);
-        });
-        RouterClient.addResponder("DockingService.getWindowsInGroup", (err, response) => {
-            if (err || !response) {
-                Logger.system.error("DockingService.getWindowsInGroup error", err);
-                return;
-            }
-            const grp = this.getGroup(response.data.groupName);
-            if (err)
-                return response.sendQueryResponse(err, null);
-            const error = null;
-            let windowList = [];
-            if (!grp) {
-                err = "Group not found.";
-            }
-            else {
-                windowList = grp.getWindowNames();
-            }
-            response.sendQueryResponse(error, windowList);
-        });
-        RouterClient.addResponder("DockingService.getGroupObjectsForWindow", (err, response) => {
-            if (err || !response) {
-                Logger.system.error("DockingService.getGroupObjectsForWindow error", err);
-                return;
-            }
-            const win = this.getWindow(response.data.name || response.data.windowName);
-            if (win) {
-                const responseObject = win.groupNames.map((groupName) => {
-                    const grp = this.getGroup(groupName);
-                    return {
-                        name: groupName,
-                        isMovable: grp.isMovable,
-                    };
-                });
-                return response.sendQueryResponse(null, responseObject);
-            }
-            response.sendQueryResponse("window not found");
-        });
-        RouterClient.addResponder("DockingService.getGroupsForWindow", (err, response) => {
-            if (err || !response) {
-                Logger.system.error("DockingService.getGroupsForWindow error", err);
-                return;
-            }
-            const win = this.getWindow(response.data.name || response.data.windowName);
-            if (win) {
-                return response.sendQueryResponse(null, win.getGroupNames());
-            }
-            response.sendQueryResponse("window not found");
-        });
-        // LauncherGroups calling reveal all does not handle special docking-only cases such as
-        // grouped windows/stacked windows/etc
-        RouterClient.addResponder("DockingService.restoreDockableWindows", (err, response) => {
-            if (err || !response) {
-                Logger.system.error("DockingService.restoreDockableWindows error", err);
-                return;
-            }
-            let windows = response.data.windowNames;
-            // Loop through the window names and retrieve their docking counterpart if applicable
-            windows.map((win) => {
-                var _a;
-                const w = this.getWindow(win);
-                if (w) {
-                    // Take care of any stacked windows
-                    if (w.name.includes("StackedWindow")) {
-                        w.win.oldState.childWindowIdentifiers.map((childWin) => {
-                            const nameToFind = childWin.name || childWin.windowName;
-                            const index = windows.findIndex((name) => name === nameToFind);
-                            windows.splice(index, 1);
-                        });
-                        w.win._restore({});
-                    }
-                    // Take care of any groups this window is a part of
-                    (_a = w.groupNames) === null || _a === void 0 ? void 0 : _a.forEach((groupName) => {
-                        const g = this.getGroup(groupName);
-                        if (g.isMovable) {
-                            const windowNamesInGroup = Object.keys(g.windows);
-                            g.restoreAll(() => {
-                                // After the group is restored, remove the windows in the group from the list
-                                // of windows that still need to be restored
-                                windowNamesInGroup.forEach((windowName) => {
-                                    const index = windows.findIndex((name) => name === windowName);
-                                    windows.splice(index, 1);
-                                });
-                            });
-                        }
-                    });
-                }
-            });
-            return response.sendQueryResponse(null, windows);
-        });
-        RouterClient.addListener("DockingService.joinGroup", (err, response) => {
-            this.addWindowToGroup({
-                groupName: response.data.groupName,
-                win: this.getWindow(response.data.name),
-            });
-            this.updateGroupData();
-        });
-        RouterClient.addListener("DockingService.checkAndFixGroups", (err, response) => {
-            this.checkAndFixGroupPosition(response.data.name);
-        });
-        RouterClient.addListener(constants.DOCKING.REQUEST_PUBLISH, () => {
-            this.publishGroupUpdate();
-        });
-        /**
-         * PassThrough
-         */
-        RouterClient.addListener("DockingService.deregisterWindow", (err, response) => {
-            this.dockingReady || Logger.system.error("Docking API invoked before ready");
-            this.deregisterWindow(this, err, response);
-        });
-        RouterClient.addResponder("DockingService.maximizeWindow", (err, message) => {
-            this.dockingReady || Logger.system.error("Docking API invoked before ready", message);
-            if (err || !message) {
-                Logger.system.error("DockingService.maximizeWindow error", err);
-                return;
-            }
-            this.maximizeWindow(message.data, (bounds) => {
-                this.sendQueryResponse(message, bounds);
-            });
-        });
-        RouterClient.addResponder("DockingService.restoreFromMaximize", (err, message) => {
-            this.dockingReady || Logger.system.error("Docking API invoked before ready", message);
-            if (err || !message) {
-                Logger.system.error("DockingService.restoreFromMaximize error", err);
-                return;
-            }
-            if (this.getWindow(message.data.name)) {
-                this.restoreFromMaximize(message.data, () => {
-                    this.sendQueryResponse(message, null);
-                });
-            }
-            else {
-                message.sendQueryResponse("Window not registered with the DockingMain.", null);
-            }
-        });
-        RouterClient.addListener("DockingService.constituteGroups", () => {
-            this.dockingReady || Logger.system.error("Docking API invoked before ready");
-            this.constituteGroups();
-        });
-        RouterClient.addResponder("DockingService.autoArrange", async (err, message) => {
-            var _a;
-            this.dockingReady || Logger.system.error("Docking API invoked before ready", message);
-            if (err || !message) {
-                Logger.system.error("DockingService.autoArrange error", err);
-                return;
-            }
-            let dimensions = null;
-            if (message.data.windowIdentifier) {
-                const monitorInfo = await LauncherClient.getMonitorInfo({
-                    windowIdentifier: message.data.windowIdentifier,
-                });
-                dimensions = this.prepMonitorDimensions((_a = monitorInfo.data) === null || _a === void 0 ? void 0 : _a.name);
-            }
-            else if (message.data.monitorDimensions.name) {
-                dimensions = this.prepMonitorDimensions(message.data.monitorDimensions.name);
-            }
-            if (!dimensions) {
-                message.sendQueryResponse(new Error("No window or monitor supplied to autoArrange"), null);
-                return;
-            }
-            await this.AutoArrange.arrange(dimensions);
-            this.updateGroupData();
-            message.sendQueryResponse(null, "success");
-        });
-        RouterClient.addPubSubResponder(DockingMain_AUTO_ARRANGE_CHANNEL, {});
-        /* Tabbing and Tiling */
-        RouterClient.addListener("DockingService.startTilingOrTabbing", (err, message) => {
-            this.dockingReady || Logger.system.error("Docking API invoked before ready", message);
-            this.startTilingOrTabbing(err, message);
-        });
-        RouterClient.addResponder("DockingService.stopTilingOrTabbing", (err, message) => {
-            this.dockingReady || Logger.system.error("Docking API invoked before ready", message);
-            if (err || !message) {
-                Logger.system.error("DockingService.stopTilingOrTabbing error", err);
-                return;
-            }
-            this.stopTilingOrTabbing(err, message, () => {
-                message.sendQueryResponse(null, true);
-            });
-        });
-        RouterClient.addListener("DockingService.identifierForTilingOrTabbing", (err, message) => {
-            this.dockingReady || Logger.system.error("Docking API invoked before ready", message);
-            this.identifierForTilingOrTabbing(err, message);
-        });
-        RouterClient.addListener("DockingService.cancelTilingOrTabbing", (_, message) => {
-            this.dockingReady || Logger.system.error("Docking API invoked before ready", message);
-            this.cancelTilingOrTabbing();
-        });
-        /* End Tabbing and Tiling */
-        RouterClient.subscribe(APPLICATION_STATE_CHANNEL, (err, response) => {
-            this.applicationState = response.data.state;
-        });
-        RouterClient.addListener("DockingService.wipeAutoArrange", (err, message) => {
-            this.resetAutoArrangeForAWindowsMonitor(message.data.win);
-        });
-        // Monitor information is now managed by docking (for simplicity of claiming/unclaiming space). This is just to get the information when it changes. getMonitorInfoAll in the launcher comes here now.
-        RouterClient.addResponder("DockingService.getMonitorsFromDocking", (err, message) => {
-            this.dockingReady || Logger.system.error("Docking API invoked before ready", message);
-            if (err || !message) {
-                Logger.system.error("DockingService.getMonitorsFromDocking error", err);
-                return;
-            }
-            const monitors = this.getRawMonitors();
-            message.sendQueryResponse(null, { monitors });
-        });
-    }
-    /**
-     * Check if new group is a launchGroup component, i.e. there's a window with launchGroupComponentData in its windowDescriptor.
-     * If the groups is a launchGroup component then add the launchGroupCompoenentData to the new member of the group.
-     *
-     * Note: We break early as we only want to find the first component to have a launchGroupComponentData.
-     *
-     * @param {string} windowNameToAddToGroup The window name to add to the group
-     * @param {Array<string>} groupWindowNames All window names in the group
-     */
-    _maybeAddLaunchGroupComponentData(windowNameToAddToGroup, groupWindowNames) {
-        for (const windowName of groupWindowNames) {
-            if (windowName !== windowNameToAddToGroup) {
-                const groupWindow = this.getWindow(windowName);
-                if (groupWindow.win.windowDescriptor.launchGroupComponentData) {
-                    const newGroupWindow = this.getWindow(windowNameToAddToGroup);
-                    newGroupWindow.win.windowDescriptor.launchGroupComponentData =
-                        groupWindow.win.windowDescriptor.launchGroupComponentData;
-                    break;
-                }
-            }
-        }
-    }
-    /**
-     * Invoked when a window leaves a group. Checks if we have launchGroupComponentData to remove and
-     * removes it. Does nothing otherwise.
-     *
-     * @param {wrap} leavingWindow The window leaving the group.
-     */
-    _removeLaunchGroupComponentDataFromLeavingWindow(leavingWindow) {
-        var _a, _b;
-        if ((_b = (_a = leavingWindow.win) === null || _a === void 0 ? void 0 : _a.windowDescriptor) === null || _b === void 0 ? void 0 : _b.launchGroupComponentData) {
-            delete leavingWindow.win.windowDescriptor.launchGroupComponentData;
-        }
-    }
-    // this is the old/legacy group update that is currently preserved for legacy reasons.  It does not have guid.
-    buildWorkspaceGroupUpdate() {
-        return {
-            groupName: "Docking",
-            groupData,
-            workspaceName: this.activeWorkspace.name,
-        };
-    }
-    // this is the current group update that has everything in the old one plus guid.
-    buildGroupUpdate() {
-        return Object.assign({ guid: this.activeWorkspace.guid }, this.buildWorkspaceGroupUpdate());
-    }
-    sendQueryResponse(message, data) {
-        message.sendQueryResponse(null, data);
-    }
-    prepMonitorDimensions(monitorName) {
-        const serviceMonitors = this.getMonitors();
-        const monitors = Object.keys(serviceMonitors).map((mon) => serviceMonitors[mon]);
-        let monitor;
-        for (let i = 0; i < monitors.length; i++) {
-            const mon = monitors[i];
-            if (mon.name === monitorName) {
-                monitor = mon;
-                break;
-            }
-        }
-        if (monitor) {
-            return {
-                left: monitor.availableRect.left,
-                right: monitor.availableRect.right,
-                top: monitor.availableRect.top,
-                bottom: monitor.availableRect.bottom,
-                name: monitor.name,
-                height: monitor.availableRect.height,
-                width: monitor.availableRect.width,
-            };
-        }
-        return null;
-    }
-    /**
-     * Called when monitors' state changes. Either a monitor has been added/removed or rearranged.
-     * When a change occurs query the system for the new window position and update the bounds.
-     * Groups need special treatment to ensure that they stay together.
-     * The toolbar is also a special case because it needs to stay the same size and keep it's docking state
-     * @param {object} monitors An object containing each monitor with monitor name as keys
-     */
-    async monitorsChanged(eventData) {
-        const rawMonitors = eventData.monitors;
-        Logger.system.debug("Monitors-changed: monitors-changed event received. Monitors from the event:", rawMonitors);
-        const adjustedBoundsPromiseList = [];
-        const dockedWindowBoundsPromiseList = [];
-        const windowNames = this.getWindowNames();
-        // hide a groupMask if monitor has been changed, because position of the mask related to monitor dimensions
-        this.hideGroupMask();
-        // After building the current list of monitors, update the monitor status.
-        // This must be called before requesting the updated window bounds from assimilation
-        this.updateMonitorInfo(rawMonitors);
-        // Request the updated information in the format required for assimilation
-        const formattedMonitorInfo = await new Promise((resolve) => {
-            System.getMonitorInfo(resolve);
-        });
-        if (this.isWindows) {
-            const { err } = await RouterClient.query("Assimilation.setMonitorInfo", formattedMonitorInfo);
-            if (err) {
-                Logger.system.error("Error sending MonitorInfo to Assimilation", err);
-            }
-        }
-        windowNames.forEach((windowName) => {
-            const win = this.getWindow(windowName);
-            if (win.win.isDocked) {
-                // If this is a docked window that has been moved by the OS it will not be claiming space correctly
-                // on the new monitor and needs to be redocked
-                dockedWindowBoundsPromiseList.push(deriveWindowPosition({ win, movableGroup: null, monitorsInstance: this.monitorsInstance }));
-            }
-            else if (win.isDockableComponent) {
-                this.handleUndockedWindow(win);
-            }
-        });
-        const dockedWindows = await Promise.all(dockedWindowBoundsPromiseList);
-        dockedWindows.forEach((boundsObject) => {
-            if (boundsObject)
-                this.handleDockedWindow(boundsObject);
-        });
-        // Iterate through all the windows and get their bounds. If their bounds have changed they will be used to update the window position.
-        windowNames.forEach((windowName) => {
-            const win = this.getWindow(windowName);
-            // The OS doesn't move minimized windows. They need to be handled on restore
-            if (win.win.windowState === constants.WINDOWSTATE.MINIMIZED_WAS_MAXIMIZED ||
-                win.win.windowState === constants.WINDOWSTATE.MINIMIZED_WAS_NORMAL)
-                return;
-            // Batch the resulting bounds for windows in a group. Groups bounds need to be sent all at once and windows can take different amounts of time to get their updated bounds
-            const movableGroup = this.getMovableGroup(win.name);
-            adjustedBoundsPromiseList.push(deriveWindowPosition({ win, movableGroup, monitorsInstance: this.monitorsInstance }));
-        });
-        // Wait for updated bounds for all windows before performing any move actions
-        let adjustedBoundsList = [];
-        try {
-            adjustedBoundsList = await Promise.all(adjustedBoundsPromiseList);
-        }
-        catch (adjustedBoundsListErr) {
-            Logger.system.error("Error rearranging windows on monitor change", adjustedBoundsListErr);
-        }
-        // Split the returned list by type into moved windows in a group and all other non-docked windows that should move
-        const { groupMoves, nonGroupMoves } = splitWindowMoves(adjustedBoundsList);
-        const groupNames = Object.keys(groupMoves);
-        // Use the updated bounds for each window in the group to choose where to move the group
-        groupNames.forEach((groupName) => {
-            const group = this.getGroup(groupName);
-            group.performDeferredSystemMove(this, groupMoves[groupName]);
-        });
-        // For windows not in a group, update their bounds
-        nonGroupMoves.forEach((move) => {
-            const win = this.getWindow(move.name);
-            let { bounds } = move;
-            if (win.win.windowState === constants.WINDOWSTATE.MAXIMIZED) {
-                const monitor = this.getUpdatedOrNewMonitor(win);
-                if (monitor)
-                    win.monitor = monitor;
-            }
-            win.setBounds(bounds);
-            win.win.stopMove();
-        });
-        // Handles a bug where the OS doesn't repaint all windows after logging back into a machine after a remote
-        // desktop session. Show all windows that Finsemble isn't hiding.
-        windowNames.forEach((name) => {
-            const win = this.getWindow(name);
-            // Furthermore, we do not want to call show on minimized windows or they will restore whenever a monitor change occurs
-            const functionExists = typeof win.win.isShowing === "function";
-            if (functionExists &&
-                win.win.windowState !== constants.WINDOWSTATE.MINIMIZED_WAS_MAXIMIZED &&
-                win.win.windowState !== constants.WINDOWSTATE.MINIMIZED_WAS_NORMAL &&
-                win.win.windowState !== constants.WINDOWSTATE.MAXIMIZED) {
-                win.win._isShowing({}, (isShowingErr, isShowing) => {
-                    // undocked toolbar jumps and moves to mouse on startup without both these checks
-                    if (isShowing && !win.isHidden) {
-                        win.show();
-                    }
-                });
-            }
-        });
-    }
-    /**
-     * Handles the docked toolbar after a monitor change occurs.
-     * Make sure it remains docked at the correct location and size
-     * @param {} win - window that is docked, usually the toolbar
-     */
-    async handleDockedWindow(boundsObject) {
-        /* Algorithm
-         if(!justundocked & !justdocked) { // monitor has changed and we have done nothing yet, so undock
-             undock
-             justundocked = true
-         }
-         else if (justundocked & !justdocked) { // this is the monitor change caused by undocking, dock now
-             justundocked = false
-             dock
-             justdocked = true
-         } else if (justdocked) { // this is the monitor change caused by docking
-             justdocked = false
-             setBounds // we need to call this second setbounds because the window automatically gets pushed out of claimed space
-         }
-         return
-        */
-        var _a, _b, _c;
-        const win = this.getWindow(boundsObject.name);
-        let newMonitor = this.getUpdatedOrNewMonitor(win);
-        if (!newMonitor) {
-            return;
-        }
-        win.monitor = newMonitor;
-        if (!win.justUndocked && !win.justDocked && !win.isHidden) {
-            win.justUndocked = true;
-            if (newMonitor && newMonitor.undockWindowFromMonitor) {
-                newMonitor.undockWindowFromMonitor(win, true);
-                // sometimes undocking will not trigger a monitor change, in this case, we will dock after 2 seconds
-                this.recallToDock = setTimeout(() => {
-                    this.handleDockedWindow(boundsObject);
-                }, 2000);
-            }
-            else {
-                this.handleDockedWindow(boundsObject);
-            }
-        }
-        else if (win.justUndocked && !win.justDocked) {
-            clearTimeout(this.recallToDock);
-            win.justUndocked = false;
-            if (!Object.keys(newMonitor).length) {
-                newMonitor = this.getMonitorForWindow(win);
-                win.monitor = newMonitor;
-            }
-            newMonitor.dockWindowToMonitor(win, win, ((_a = win.undockedPosition) === null || _a === void 0 ? void 0 : _a.width) || this.defaultWidth, ((_b = win.undockedPosition) === null || _b === void 0 ? void 0 : _b.height) || this.defaultHeight);
-        }
-        else if (win.justDocked) {
-            win.justDocked = false;
-            // Get the window's snapped edge based on its docked position
-            const keys = Object.keys(win.monitorDockablePositions);
-            const snappedEdge = (_c = keys.find((key) => win.monitorDockablePositions[key] === win.dockedPosition)) === null || _c === void 0 ? void 0 : _c.toLowerCase();
-            // Values the window needs to dock properly.
-            win.dockedHeight = win.height;
-            win.snappedEdge = snappedEdge !== null && snappedEdge !== void 0 ? snappedEdge : "undefined";
-            const newBounds = win.getBounds();
-            win.setBounds(newBounds, () => {
-                if (this.isWindows && this.claimSpace) {
-                    win.win._setOpacity({ opacity: 1 });
-                }
-            });
-        }
-    }
-    /**
-     * Handles the undocked window after a monitor change occurs.
-     *
-     * @param {} win - window that is undocked, usually the toolbar
-     */
-    handleUndockedWindow(window) {
-        // updates the window state to notify that undocking has finished
-        window.justUndocked = false;
-    }
-    /**
-     * Checks if a monitor still exists
-     * Used for adjusting window location after a monitor change were we want to prioritize the current monitor
-     */
-    getUpdatedWindowMonitorIfItExists(dockableMonitor) {
-        const currentDockableMonitors = this.getMonitors();
-        for (const key of Object.keys(currentDockableMonitors)) {
-            const currentDockableMonitor = currentDockableMonitors[key];
-            if (dockableMonitor.rawMonitor &&
-                currentDockableMonitor.rawMonitor.deviceId === dockableMonitor.rawMonitor.deviceId) {
-                return currentDockableMonitor;
-            }
-        }
-    }
-    /**
-     * Returns the updated monitor for a window or a new monitor
-     * if the current one for the window no longer exists.
-     * @param {FinsembleWindow} win Finsemble window
-     */
-    getUpdatedOrNewMonitor(win) {
-        const monitor = this.getUpdatedWindowMonitorIfItExists(win.monitor);
-        if (monitor) {
-            Logger.system.verbose(`Monitors-changed: The current monitor for the ${win.name} still exists.`);
-            return monitor;
-        }
-        // Chooses the monitor that the window shares the most bounds with. If there is a tie or the window is not on any monitor the last monitor in the array will be chosen
-        const newMonitor = this.getMonitorForWindow(win);
-        Logger.system.verbose(`Monitors-changed: window ${win.name}'s current monitor no longer present, new monitor is ${newMonitor}`);
-        return Object.values(this.getMonitors()).find((dockingMon) => dockingMon.rawMonitor.deviceId === newMonitor.rawMonitor.deviceId);
-    }
-    /**
-     * Loops through DockableMonitor(s) and compares against a system monitor passed in.
-     *
-     * @param {*} mon A monitor representation
-     * @returns A dockable monitor which contains the same deviceId as the monitor passed in
-     */
-    getDockingMonitorFromSystemMonitor(mon) {
-        let resultingMonitor;
-        const idToCheck = mon.rawMonitor ? mon.rawMonitor.deviceId : mon.deviceId;
-        const dockingMonitors = this.getMonitors();
-        // Update the window's reference to the monitor that it is on. The new reference has updated rects that reflect the change that came from the system.
-        for (let i = 0; i < Object.keys(dockingMonitors).length; i++) {
-            const dockingMon = dockingMonitors[Object.keys(dockingMonitors)[i]];
-            if (dockingMon.rawMonitor.deviceId === idToCheck) {
-                resultingMonitor = dockingMon;
-                break;
-            }
-        }
-        return resultingMonitor;
-    }
-    /**
-     * Updates monitor info with claim space changes (usually triggered by docking/undocking toolbar or adding/removing monitors)
-     * @param {*} monitorUpdate The new monitor information
-     * @param {boolean} isDockableWindowAction If this action is triggered by a dockable window, we don't want to wipe out auto arrange status
-     */
-    updateMonitorInfo(monitorUpdate, isDockableWindowAction) {
-        const self = this;
-        const monitors = self.getMonitors();
-        if (!isDockableWindowAction) {
-            Object.values(monitors).forEach((monitor) => {
-                this.AutoArrange.isArranged[monitor.name] = false;
-            });
-            self.sendAutoArrangeStatusUpdate();
-        }
-        self.removeAllMonitors();
-        monitorUpdate.forEach((monitor) => {
-            self.addMonitor({
-                name: monitor.name,
-                left: monitor.availableRect.left,
-                top: monitor.availableRect.top,
-                right: monitor.availableRect.right,
-                bottom: monitor.availableRect.bottom,
-                _monitor: monitor,
-            }, isDockableWindowAction);
-        });
-        Logger.system.debug("MONITOR: Docking.monitorUpdate", monitorUpdate);
-        self.setBufferSize(serviceConfig.BUFFER_SIZE);
-    }
-    /**
-     * This function will maximize a window.
-     * @param {object} params
-     * @param {object} params.windowIdentifier
-     * @param {string} params.name
-     */
-    maximizeWindow(params, cb) {
-        const win = this.getWindow(params.name);
-        if (win.win.windowState === constants.WINDOWSTATE.MAXIMIZED) {
-            cb();
-            return;
-        }
-        // When a maximized window is minimized then restored, we want to ensure any windows that were minimized
-        // along side this window (grouped) will be restored.
-        if (win.win.windowState === constants.WINDOWSTATE.MINIMIZED_WAS_MAXIMIZED) {
-            win.groupNames.forEach((groupName) => {
-                const grp = this.getGroup(groupName);
-                if (grp.isMovable) {
-                    grp.restoreAll();
-                }
-            });
-        }
-        win.win.windowOptions.windowState = win.win.windowState;
-        win.win.saveCompleteWindowState(win.win.windowOptions);
-        win.bringToFront();
-        this.resetAutoArrangeForAWindowsMonitor(win);
-        if (cb)
-            cb();
-    }
-    /**
-     * This function will restore a maximized window.
-     * @param {object} params
-     * @param {string} params.name
-     */
-    async restoreFromMaximize(params, cb = Function.prototype) {
-        var _a, _b, _c, _d;
-        const win = this.getWindow(params.name);
-        win.win.windowState = constants.WINDOWSTATE.NORMAL;
-        let b = win.win.cachedBounds && Object.keys(win.win.cachedBounds).length ? win.win.cachedBounds : win.getBounds();
-        let bounds = {
-            left: b.left,
-            right: (_a = b.right) !== null && _a !== void 0 ? _a : 0,
-            top: b.top,
-            bottom: (_b = b.bottom) !== null && _b !== void 0 ? _b : 0,
-            width: (_c = b.width) !== null && _c !== void 0 ? _c : 0,
-            height: (_d = b.height) !== null && _d !== void 0 ? _d : 0,
-        };
-        // Only changes the window position if there has been a monitor change. We don't want the window to restore off monitor
-        let adjustedBounds = adjustBoundsToBeOnMonitor(this.monitorsInstance, bounds);
-        win.win.startMove();
-        win.setBounds(adjustedBounds, () => {
-            // The folllow seems to be a NOP.  WHould be win.win.cachedBounds?  Plus why clear it?
-            // win.cachedBounds = {};
-            win.win.stopMove();
-            /**
-             * The second setBounds below this giant comment block is because of a strange sequencing problem in electron.
-             * When you double click on the titlebar of a component, the OS maximizes the window. We capture the event,
-             * and then tell it to setBounds right below the toolbar.
-             * When we call set bounds, it appears that windows is moving the window afterwards. My hypothesis is that by
-             * calling setBounds, we're triggering the OS's restore behavior (when you move a window that's maximized, it
-             * restores itself).
-             *
-             * The data below shows the sequencing problem. The logs come from FEA. 'Windows moved' logs come from the
-             * Win32 API throwing 'move' events, which effectively means 'Hey, the OS completed drawing the window at
-             * these bounds. 'Setting bounds for' are logs from the MainWindow calling setBounds on the Electron
-             * BrowserWindow
-             *
-             * **The next line is the first event we get from the OS upon double clicking the window.**
-             * Windows moved window Welcome Component-2-1861-Finsemble { x: -8, y: -8, width: 2576, height: 1416 }
-             * **This is us setting bounds in reaction to the OS's maximize event.**
-             * Setting bounds for  Welcome Component-2-1861-Finsemble { height: 1361, width: 2560, x: 0, y: 39 }
-             * **This is windows' recognition that we've moved the window to the proper place.**
-             * Windows moved window Welcome Component-2-1861-Finsemble { x: 0, y: 39, width: 2560, height: 1361 }
-             * **This is the unexplained window move from windows**
-             * Windows moved window Welcome Component-2-1861-Finsemble { x: 0, y: 56, width: 2560, height: 1361 }
-             * **This is the 2nd set bounds below**
-             * Setting bounds for  Welcome Component-2-1861-Finsemble { height: 1361, width: 2560, x: 0, y: 39 }
-             * **This is windows' confirmation that we moved the window**
-             * Windows moved window Welcome Component-2-1861-Finsemble { x: 0, y: 39, width: 2560, height: 1361 }
-             *
-             */
-            win.setBounds(adjustedBounds);
-            if (cb) {
-                cb();
-            }
-        });
-    }
-    onWindowShown(event) {
-        const dockableWindow = this.getWindow(event.source);
-        // need to set show state in dockable window, but cannot call show() or it will cause an infinite loop
-        if (dockableWindow) {
-            dockableWindow.setShown();
-        }
-    }
-    // if a window is docked, and gets hidden, undock it.
-    // NOTE: ******** This never fires since underlying bug for "hidden" *******
-    onWindowHidden(event) {
-        const dockableWindow = this.getWindow(event.source);
-        // need to set hide state in dockable window, but cannot call hide() or it will cause an infinite loop
-        if (dockableWindow) {
-            dockableWindow.setHidden();
-        }
-    }
-    onWindowClosedHandler(event) {
-        const responseData = {
-            name: event.source,
-            removeFromWorkspace: event.data.removeFromWorkspace,
-        };
-        // When closing a window, call to undock.
-        // dockableWindow will take care of determining
-        // if the toolbars internal state should change
-        const dockableWindow = this.getWindow(event.source);
-        if (dockableWindow)
-            dockableWindow.undock(true);
-        if (this.applicationState !== "closing") {
-            this.onWindowClosed(null, { data: responseData });
-        }
-    }
-    /**
-     * Function that's called after a window is moved.
-     */
-    /**
-     * Registers a window with the DockingCalculator.
-     * @param  {dockableWindow} win
-     * @return {Promise}
-     */
-    addWindow(win) {
-        // cannot add closing/closed windows to docking.
-        if (["closing", "closed"].includes(win.wrapState))
-            return Promise.reject();
-        const self = this;
-        const calcAddWindow = super.addWindowInternal.bind(this);
-        // If a window reloads, it may try to add itself to the dockingCalc twice.
-        // 2nd param doesn't throw error if we can't find the window.
-        if (this.getWindow(win.name, false)) {
-            Logger.system.debug("Docking:addWindow reload immediate resolve");
-            return Promise.resolve(self.getWindow(win.name));
-        }
-        return new Promise((resolve) => {
-            win._getBounds({}, (err, bounds) => {
-                // If addWindow is called multiple times in quick succession, check to see if it's been added before going through this entire process again. This was happening when tiling from a tabbed group.
-                if (self.getWindow(win.name, false)) {
-                    return Promise.resolve(self.getWindow(win.name));
-                }
-                if (!bounds) {
-                    Promise.reject(err);
-                    return Logger.system.error("No bounds returned from wrap.getBounds", win.name, err);
-                }
-                const dockableWindow = DockableWindow.factory(win, bounds, self);
-                Logger.system.debug("Docking:calling addWindow on the calculator", win.name, bounds);
-                dockableWindow.win.addEventListener("minimized", self.setWindowMinimized);
-                dockableWindow.win.addEventListener("maximized", self.setWindowMaximized);
-                dockableWindow.win.addEventListener("focused", self.setWindowFocused);
-                dockableWindow.win.addEventListener("shown", self.bringGroupToFront);
-                dockableWindow.win.addEventListener("hidden", self.onWindowHidden);
-                dockableWindow.win.addEventListener("shown", self.onWindowShown);
-                /**
-                 * We have to wrap `self.onWindowClosedHandler` in an
-                 * error function or it doesn't work. We haven't investigated this extensively.
-                 * We do know however that the method is in fact bound in `self.bindAllFunctions()`,
-                 * and that `this` in fact an instance of `DockingMain`.
-                 *
-                 */
-                dockableWindow.closeEventListener = (e) => {
-                    self.onWindowClosedHandler(e);
-                };
-                dockableWindow.win.addEventListener("closed", dockableWindow.closeEventListener);
-                calcAddWindow(win.name, dockableWindow);
-                resolve(dockableWindow);
-            });
-        });
-    }
-    /**
-     * @private
-     * @param {string} windowname
-     */
-    fixAllGroups(windowName) {
-        const movableGroup = this.getMovableGroup(windowName);
-        const immobileGroup = this.getImmobileGroup(windowName);
-        [movableGroup, immobileGroup].forEach((grp) => grp && this.fixGroupMembership(grp));
-    }
-    setWindowMinimized(event) {
-        const dockableWindow = this.getWindow(event.source);
-        if (!dockableWindow) {
-            return Logger.system.warn("SetWindowMinimized called on window not registered for movement.", event.source);
-        }
-        let groupFound = false;
-        // If Window is in group, minimize the group
-        dockableWindow.groupNames.forEach((groupName) => {
-            const grp = this.getGroup(groupName);
-            if (grp.isMovable) {
-                groupFound = true;
-                grp.minimizeAll();
-            }
-        });
-        // make sure window is not already joined to a group
-        if (!groupFound) {
-            this.fixAllGroups(event.source);
-            this.removeWindowFromAllGroups(dockableWindow);
-            this.updateGroupData();
-            this.resetAutoArrangeForAWindowsMonitor(dockableWindow);
-        }
-    }
-    setWindowMaximized(event) {
-        const dockableWindow = this.getWindow(event.source);
-        if (!dockableWindow) {
-            return Logger.system.warn("setWindowMaximized called on window not registered for movement.", event.source);
-        }
-        const groupFound = dockableWindow.groupNames.find((groupName) => {
-            const grp = this.getGroup(groupName);
-            return grp.isMovable;
-        });
-        // make sure window is not already joined to a group
-        if (!groupFound) {
-            this.fixAllGroups(event.source);
-            this.removeWindowFromAllGroups(dockableWindow);
-            this.updateGroupData();
-            this.resetAutoArrangeForAWindowsMonitor(dockableWindow);
-        }
-    }
-    setWindowFocused(event) {
-        const self = this;
-        // Don't log an error because the window may not exist in our object pool if it's part of a stack
-        const dockableWindow = self.getWindow(event.source, false);
-        if (!dockableWindow)
-            return;
-        setTimeout(() => {
-            if (dockableWindow.win.windowState !== constants.WINDOWSTATE.NORMAL)
-                return;
-            // win.removeEventListener is async. When reloading a workspace, the window is closed, and un-registers with docking.
-            // We remove the event listeners from windows for focus, shown, etc.
-            // Then we re-spawn the same windows with the same uuid/name. Underneath the hood, Electron has yet to remove those event listeners.
-            // The new windows get focused, and get into this event handler.
-            // If we don't make the check below, the DockingCalculator throws errors saying "Hey this window hasn't registered with me yet."
-            if (self.getWindowNames().includes(event.source)) {
-                self.bringGroupToFront(event);
-            }
-        }, 100);
-    }
-    bringGroupToFront(event) {
-        const dockableWindow = this.getWindow(event.source);
-        if (!dockableWindow)
-            return;
-        dockableWindow.groupNames.forEach((groupName) => {
-            const grp = this.getGroup(groupName);
-            if (grp.isMovable) {
-                grp.bringToFront({ restoreWindows: false }); // No need to restore windows since they are by default already un-minimized. Doing so can cause infinite loops with stackedWindows [Terry].
-            }
-        });
-    }
-    hyperFocus(params) {
-        const dockableWindow = this.getWindow(params.windowName);
-        dockableWindow.groupNames.forEach((groupName) => {
-            const grp = this.getGroup(groupName);
-            if (grp.isMovable) {
-                LauncherClient.hyperFocus({ windowList: grp.getWindowNames() });
-            }
-        });
-    }
-    async initiateGroupMaskCreation() {
-        const setDockingMoveMask = async () => {
-            const { wrap: groupMask } = await FinsembleWindowInternal.getInstance({
-                name: "DockingGroupMask",
-                waitForReady: true,
-            });
-            groupMask._getBounds({}, (err, bounds) => {
-                const mask = DockableWindow.factory(groupMask, bounds, this);
-                mask.canGroup = false;
-                this.groupMask = mask;
-            });
-        };
-        // when component is started, it's workspace client will try to access the workspace service, so wait until workspace is up before creating this mask
-        await SystemManagerClient.waitForStartup("workspaceService");
-        // Show Docking Move Mask
-        LauncherClient.showWindow({ componentType: "DockingGroupMask" }, {
-            name: "DockingGroupMask",
-            spawnIfNotFound: true,
-            options: {
-                autoShow: false,
-            },
-        }, setDockingMoveMask);
-    }
-    removeWindow(windowName) {
-        const dockableWindow = this.getWindow(windowName);
-        dockableWindow.win.removeEventListener("minimized", this.setWindowMinimized);
-        dockableWindow.win.removeEventListener("maximized", this.setWindowMaximized);
-        dockableWindow.win.removeEventListener("focused", this.setWindowFocused);
-        dockableWindow.win.removeEventListener("shown", this.bringGroupToFront);
-        // these two deal with undocking/setting the isHidden boolean (which causes docking to skip windows when figuring out whether to snap.
-        dockableWindow.win.removeEventListener("hidden", this.onWindowHidden);
-        dockableWindow.win.removeEventListener("shown", this.onWindowShown);
-        if (dockableWindow.closeEventListener)
-            dockableWindow.win.removeEventListener("closed", dockableWindow.closeEventListener);
-        super.removeWindowInternal(windowName);
-    }
-    /**
-     * Sets the initial buffer size.
-     */
-    setupDockingCalculator() {
-        var _a, _b;
-        Logger.system.log("Docking initialization", serviceConfig);
-        this.setTilingOrTabbingEnabled(serviceConfig);
-        this.setWindowsAeroSnap(serviceConfig);
-        this.setAllowGroupsToSnap(serviceConfig.ALLOW_GROUPS_TO_SNAP);
-        this.setGroupMode(serviceConfig.GROUP_MODE);
-        this.setBufferSize(serviceConfig.BUFFER_SIZE);
-        this.setSnappingOpacity((_a = serviceConfig.SNAPPING_OPACITY) !== null && _a !== void 0 ? _a : 1);
-        this.setResizeThrottlePeriod((_b = serviceConfig.RESIZE_EVENT_THROTTLE_PERIOD) !== null && _b !== void 0 ? _b : 0);
-        this.setGlobalMinimums(serviceConfig);
-    }
-    addMonitor(monitor, isDockableWindowAction) {
-        const dockableMonitor = new DockableMonitor({ bounds: monitor, monitor: monitor._monitor, dockingMain: this });
-        dockableMonitor.setBufferSize(this.bufferSize);
-        MonitorPoolSingleton.add(dockableMonitor.name, dockableMonitor);
-        if (!isDockableWindowAction) {
-            this.AutoArrange.isArranged[monitor.name] = false;
-            this.cachedPositions[monitor.name] = {};
-        }
-    }
-    setGroupMode(groupMode) {
-        super.setGroupMode(groupMode);
-        RouterClient.publish("DockingService.groupMode", groupMode);
-    }
-    setWindowsAeroSnap(setWindowsAeroSnapArg) {
-        this.enableWindowsAeroSnap = setWindowsAeroSnapArg.enableWindowsAeroSnap || false;
-    }
-    /** **********************************************
-     *												*
-     * 				Debugging Helpers				*
-     *												*
-     *********************************************** */
-    /**
-     * For debugging.
-     * @function {function name}
-     * @return {type} {description}
-     */
-    getGridWindows() {
-        const self = this;
-        ["A", "B", "C", "D", "E", "F", "G", "H", "I"].forEach((windowName) => {
-            window[windowName + windowName] = self.getWindow(windowName);
-        });
-    }
-    /**
-     * @function {function name}
-     * @return {type} {description}
-     */
-    logger() {
-        const boundingBoxes = {};
-        for (const windowName in this.getWindows()) {
-            const win = this.getWindow(windowName);
-            boundingBoxes[windowName] = JSON.stringify(win.windowBoundingBox);
-        }
-        let box = "";
-        box = `${box}+----------------------------------------+\n`;
-        box = `${box}|             |             |            |\n`;
-        box = `${box}|   ${boundingBoxes.A}          |    ${boundingBoxes.B}         |   ${boundingBoxes.C}         |\n`;
-        box = `${box}|             |             |            |\n`;
-        box = `${box}|             |             |            |\n`;
-        box = `${box}+----------------------------------------+\n`;
-        box = `${box}|             |             |            |\n`;
-        box = `${box}|   ${boundingBoxes.D}          |    ${boundingBoxes.E}         |   ${boundingBoxes.F}         |\n`;
-        box = `${box}|             |             |            |\n`;
-        box = `${box}|             |             |            |\n`;
-        box = `${box}+----------------------------------------+\n`;
-        box = `${box}|             |             |            |\n`;
-        box = `${box}|   ${boundingBoxes.G}          |    ${boundingBoxes.H}         |   ${boundingBoxes.I}         |\n`;
-        box = `${box}|             |             |            |\n`;
-        box = `${box}|             |             |            |\n`;
-        box = `${box}+----------------------------------------+\n`;
-        Logger.system.log(box);
-    }
-    /**
-     * returns true if intersection in groups
-     */
-    isACommonGroup(firstSet, secondSet) {
-        return firstSet.some((i) => secondSet.includes(i));
-    }
-    /**
-     * Sends a message asking windows to save their position.  If window is in a group, then all windows in same group are told; otherwise, only the independent window is told
-     * @returns true if window that changed was in a group (which also changed)
-     */
-    tellWindowOrGroupToSaveLocation(changedWindow) {
-        let windowInGroupChanged = false;
-        const windowIter = DockingPoolSingleton.iterator();
-        for (const win of windowIter) {
-            // to ensure all the grouping functions works correctly, update any windows in the same group as changedWindow.
-            let isOneCommonGroup = this.isACommonGroup(win.groupNames, changedWindow.groupNames);
-            Logger.system.debug("tellWindowOrGroupToSaveLocation isACommonGroup?", changedWindow.name, win.win.name, isOneCommonGroup ? "CommonGroup" : "differentGroups");
-            if (isOneCommonGroup || changedWindow.name === win.win.name) {
-                if (isOneCommonGroup) {
-                    windowInGroupChanged = true;
-                }
-                // This is a hack until we have proper events in finsemble. We need to notify windows that aren't part of the workspace so that they can save their bounds.
-                if (win.isDockableComponent) {
-                    // Awful hack to get the toolbar _not_ to save it's state. This allows the toolbar to start docked when you restart the app.
-                    win.win.dockedPosition = win.dockedPosition;
-                    // Will trigger the bounds-change-end event.
-                    win.win.stopMove();
-                }
-                // win.win is the underlying wrapper. win is the dockableWindow. win.win is the WebWindowWrapper
-                win.win._saveWindowOptions({});
-                Logger.system.debug("tellWindowOrGroupToSaveLocation saved window", changedWindow.name, win.win.name);
-            }
-        }
-        return windowInGroupChanged;
-    }
-    /**
-     * Sends a message asking windows to update their position in memory but not save.
-     */
-    tellWindowsToUpdateLocation() {
-        const windowIter = DockingPoolSingleton.iterator();
-        for (const win of windowIter) {
-            RouterClient.transmit(`DockingService.${win.name}`, {
-                command: "updateWindowLocation",
-                bounds: win.getBounds(),
-            });
-        }
-    }
-    /**
-     * Updates the groupData object, which is pushed out to components.
-     * Returns true if the groupData has changed, else false.
-     */
-    _updateGroupData() {
-        const groups = this.getGroups();
-        const groupUpdate = {};
-        for (const groupName in groups) {
-            const group = groups[groupName];
-            groupUpdate[groupName] = group.getJSON();
-        }
-        const changed = !isEqualIgnoringArrayOrder(groupUpdate, groupData);
-        if (changed) {
-            groupData = groupUpdate;
-        }
-        return changed;
-    }
-    /**
-     * Sends the groupData object out to the rest of the application.
-     */
-    publishGroupUpdate() {
-        const self = this;
-        Logger.system.debug("Publishing Group Update:", groupData, Logger.callStack());
-        /**
-         * DH 3/18/2019 - It's very strange that this workspace concern
-         * is published from within docking; however, we have to keep it
-         * for backwards compatability with previous seed branches (the UI
-         * depends on this update). When we can afford a break, this should
-         * go.
-         */
-        RouterClient.publish(constants.DOCKING.WORKSPACE_GROUP_UPDATE, self.buildWorkspaceGroupUpdate());
-        RouterClient.publish(constants.DOCKING.GROUP_UPDATE, self.buildGroupUpdate());
-    }
-    handleWorkspaceUpdate(err, response) {
-        const self = this;
-        Logger.system.debug("HANDLING WORKSPACE UPDATE");
-        const { data } = response;
-        // The first publish is empty.
-        if (!data || !data.activeWorkspace) {
-            return;
-        }
-        this.activeWorkspace = data.activeWorkspace;
-        groupData = data.activeWorkspace.groups || {};
-        Logger.system.debug("HandleWorkspaceUpdate Publish");
-        self.publishGroupUpdate();
-        self.moveCount = 0;
-    }
-    /**
-     * Checks to see if a window belongs to any groups.
-     */
-    checkIfWindowIsInGroup(name) {
-        if (groupData) {
-            for (const groupName in groupData) {
-                const groupWindows = groupData[groupName].windowNames;
-                if (groupWindows.includes(name)) {
-                    const params = {
-                        groupName,
-                        win: this.getWindow(name),
-                    };
-                    Object.assign(params, groupData[groupName]);
-                    this.addWindowToGroup(params);
-                }
-            }
-        }
-    }
-    /**
-     * Sends the update to all toolbars.
-     */
-    sendAutoArrangeStatusUpdate() {
-        RouterClient.publish(DockingMain_AUTO_ARRANGE_CHANNEL, {
-            isAutoArranged: this.AutoArrange.isArranged,
-        });
-    }
-    /**
-     * @private
-     * @param {LauncherClient~windowDescriptor} windowDescriptor
-     * @param {monitorDimensions} monitorDimensions
-     * @returns {boolean} Whether window is on the current monitor.
-     */
-    windowOnMonitor(windowDescriptor, monitorDimensions) {
-        if (!windowDescriptor.monitor) {
-            return false;
-        }
-        // if right or left edge is within the window's bounds.
-        return windowDescriptor.monitor.name === monitorDimensions.name;
-    }
-    /**
-     * Get bounds for a window.
-     */
-    getBounds(params, cb = Function.prototype) {
-        Logger.system.debug(".getBounds", params);
-        const win = this.getWindow(params.name);
-        let bounds = { left: 0, right: 0, top: 0, bottom: 0 };
-        if (win) {
-            bounds = win.getBounds();
-            cb(null, bounds);
-        }
-        else {
-            cb("Window is not registered with Docking. No bounds retrieved.", null);
-        }
-        Logger.system.debug(".getBounds return", bounds);
-        return bounds;
-    }
-    deregisterAllWindows() {
-        const self = this;
-        return new Promise((resolve) => {
-            const windows = self.getWindows();
-            for (const windowName in windows) {
-                self.removeWindow(windowName);
-            }
-            resolve();
-        });
-    }
-    /* Stuff for Tabbing and Tiling */
-    async getMouseInGroups(mousePosition) {
-        if (!mousePosition)
-            mousePosition = await System.getMousePosition();
-        const groups = this.getGroups();
-        const movableGroups = [];
-        const immobileGroups = [];
-        for (const g in groups) {
-            const group = groups[g];
-            const win = group.getWindow(group.getWindowNames()[0]);
-            if (!win)
-                continue;
-            if ([constants.WINDOWSTATE.MINIMIZED_WAS_MAXIMIZED, constants.WINDOWSTATE.MINIMIZED_WAS_NORMAL].includes(win.win.windowState) ||
-                win.isHidden) {
-                continue;
-            }
-            if (BoxMath.isPointInBox(mousePosition, group.getBounds())) {
-                if (group.isMovable)
-                    movableGroups.push(group);
-                else
-                    immobileGroups.push(group);
-            }
-        }
-        return { movableGroups, immobileGroups };
-    }
-    async getMouseInWindows(mousePosition) {
-        if (!mousePosition)
-            mousePosition = await System.getMousePosition();
-        const windows = this.getWindows();
-        const mouseWindows = [];
-        for (const w in windows) {
-            const win = windows[w];
-            if ([constants.WINDOWSTATE.MINIMIZED_WAS_MAXIMIZED, constants.WINDOWSTATE.MINIMIZED_WAS_NORMAL].includes(win.win.windowState) ||
-                win.isHidden) {
-                continue;
-            }
-            const bounds = win.getBounds();
-            if (mousePosition &&
-                win &&
-                BoxMath.isPointInBox(mousePosition, Object.assign(Object.assign({}, bounds), { width: bounds.right - bounds.left, height: bounds.bottom - bounds.top }))) {
-                mouseWindows.push(win);
-            }
-        }
-        return mouseWindows;
-    }
-    startTrackingMouse(interval, cb = Function.prototype) {
-        var _a;
-        if ((_a = this.mouseTracker) === null || _a === void 0 ? void 0 : _a.interval) {
-            clearInterval(this.mouseTracker.interval);
-            this.mouseTracker.callback && this.mouseTracker.callback("New tracker overrode this one");
-        }
-        else {
-            this.mouseTracker = {};
-        }
-        this.mouseTracking = true;
-        this.mouseTracker.callback = cb;
-        this.mouseTracker.interval = setInterval(() => {
-            System.getMousePosition((err, mousePosition) => {
-                if (!this.mouseTracker)
-                    this.mouseTracker = {};
-                if (!err)
-                    this.mouseTracker.mousePosition = mousePosition;
-                cb(err, mousePosition);
-            });
-        }, interval);
-    }
-    stopTrackingMouse(cb) {
-        var _a, _b;
-        this.mouseTracking = false;
-        cb(null, ((_a = this.mouseTracker) === null || _a === void 0 ? void 0 : _a.interval) ? this.mouseTracker.mousePosition : null);
-        if ((_b = this.mouseTracker) === null || _b === void 0 ? void 0 : _b.interval)
-            clearInterval(this.mouseTracker.interval);
-        this.mouseTracker = {};
-    }
-    /**
-     * Check if we are near the edge of a rectangle within x% or xpx
-     * Returns the edge that we're nearest or false if we're not within range of any edge
-     */
-    isPositionNearEdge(position, bounds, tolerance, toleranceType = "percent") {
-        // inside box
-        const edge = {};
-        if (position.x < bounds.left || position.x > bounds.right || position.y < bounds.top || position.y > bounds.bottom)
-            return false;
-        let edgeToReturn = false;
-        let left = position.x - bounds.left;
-        let right = bounds.right - position.x;
-        let top = position.y - bounds.top;
-        let bottom = bounds.bottom - position.y;
-        if (toleranceType === "percent") {
-            left = left / bounds.width;
-            right = right / bounds.width;
-            top = top / bounds.height;
-            bottom = bottom / bounds.height;
-        }
-        // The next four are single edge
-        if (left < tolerance) {
-            edge.left = left;
-            edgeToReturn = "left";
-        }
-        if (right < tolerance) {
-            edge.right = right;
-            edgeToReturn = "right";
-        }
-        if (top < tolerance) {
-            edge.top = top;
-            edgeToReturn = "top";
-        }
-        if (bottom < tolerance) {
-            edge.bottom = bottom;
-            edgeToReturn = "bottom";
-        }
-        // These are within tolerance for two edges - near the corner, so pick the absolute closest
-        if (edge.left && edge.top) {
-            if (left < top)
-                return "left";
-            return "top";
-        }
-        if (edge.left && edge.bottom) {
-            if (left < bottom)
-                return "left";
-            return "bottom";
-        }
-        if (edge.right && edge.top) {
-            if (left < top)
-                return "right";
-            return "top";
-        }
-        if (edge.right && edge.bottom) {
-            if (right < bottom)
-                return "right";
-            return "bottom";
-        }
-        return edgeToReturn;
-    }
-    identifierForTilingOrTabbing(err, response) {
-        Logger.system.debug("identifierForTilingOrTabbing got identifier", response.data.windowIdentifier);
-        FinsembleWindowInternal.getInstance({ name: response.data.windowIdentifier.windowName }, (getInstanceErr, windowWrap) => {
-            this.tilingAndTabbingWindow = windowWrap;
-            Logger.system.debug("identifierForTilingOrTabbing got wrap", windowWrap.name);
-        });
-    }
-    setSwap(win, group, bounds) {
-        // swapping - swap within same group
-        this.operation = {
-            type: "swapping",
-            window: win,
-            group,
-        };
-        this.runScrimShower("full", bounds);
-    }
-    /**
-     * Returns true if the tiling operation is set (false if the window dimensions make it invalid)
-     */
-    setTiling(edge, win, bounds) {
-        const vertical = edge === "top" || edge === "bottom";
-        const horizontal = edge === "left" || edge === "right";
-        const tooShort = vertical && bounds.height < this.MINIMUM_HEIGHT * 2;
-        const tooThin = horizontal && bounds.width < 2 * this.MINIMUM_WIDTH;
-        if (tooShort || tooThin)
-            return false;
-        this.operation = {
-            type: "tiling",
-            tileWith: "window",
-            window: win,
-            edge,
-        };
-        this.operation.newBounds = this.runScrimShower(edge, bounds);
-        return true;
-    }
-    setTilingGroup(edge, group, bounds) {
-        var _a, _b, _c, _d, _e;
-        // show mask occupying proper half
-        const alreadyTiling = ((_a = this.operation) === null || _a === void 0 ? void 0 : _a.type) === "tiling" &&
-            ((_b = this.operation) === null || _b === void 0 ? void 0 : _b.tileWith) === "group" &&
-            ((_d = (_c = this.operation) === null || _c === void 0 ? void 0 : _c.group) === null || _d === void 0 ? void 0 : _d.name) === group.name;
-        this.operation = {
-            type: "tiling",
-            tileWith: "group",
-            group,
-            edge,
-        };
-        // flashing from bringing to front fix
-        if (!alreadyTiling) {
-            // Bring window to front, then bring mask to front
-            group.bringToFront({});
-            (_e = this.groupMask) === null || _e === void 0 ? void 0 : _e.win._bringToFront({});
-        }
-        this.operation.newBounds = this.runScrimShower(edge, bounds);
-    }
-    relations(win, sourceWin, sourceParentWindow) {
-        var _a;
-        const sourceWindowName = sourceWin ? sourceWin.name : null;
-        const { parentWindow } = win.win;
-        const isSelf = sourceWindowName === win.name ||
-            win.win.windowState === constants.WINDOWSTATE.MINIMIZED_WAS_MAXIMIZED ||
-            win.win.windowState === constants.WINDOWSTATE.MINIMIZED_WAS_NORMAL ||
-            win.isHidden;
-        // Don't allow tiling on the scrim when it's visible
-        const isMask = win.name === ((_a = this.groupMask) === null || _a === void 0 ? void 0 : _a.name);
-        const isParent = win.name === (sourceParentWindow === null || sourceParentWindow === void 0 ? void 0 : sourceParentWindow.name);
-        const sharedParent = sourceParentWindow && parentWindow && sourceParentWindow.name === parentWindow.name;
-        return {
-            isSelf,
-            isMask,
-            isParent,
-            sharedParent,
-        };
-    }
-    maybeSetOperation({ win, sourceGroup, sourceParentWindow, sourceParentGroup, mousePosition, }) {
-        const { headerHeight } = this;
-        const windowBounds = completeBounds(win.getBounds());
-        const swapWithinSameGroup = sourceGroup && sourceGroup === this.getMovableGroup(win.name);
-        const parentIsPartOfGroup = sourceParentWindow && sourceParentGroup && sourceParentGroup === this.getMovableGroup(win.name);
-        // specific cases when tiling should be enabled
-        const destinationWindowAllowTiling = 
-        // window service tiling is enabled in config
-        this.tilingEnabled &&
-            // destination window is resizable
-            win.win.windowOptions.resizable !== false &&
-            // destination window is not maximized
-            win.win.windowState !== WINDOWSTATE.MAXIMIZED;
-        // break the function if the destination window doesn't allow tiling
-        if (!destinationWindowAllowTiling) {
-            return true;
-        }
-        if (swapWithinSameGroup) {
-            this.setSwap(win, sourceGroup, windowBounds);
-        }
-        else if (parentIsPartOfGroup) {
-            // also swap tabbed windows
-            this.setSwap(win, sourceParentGroup, windowBounds);
-        }
-        else if (win.allowTiling) {
-            const edge = this.isPositionNearEdge(mousePosition, Object.assign(Object.assign({}, windowBounds), { top: windowBounds.top + headerHeight, height: windowBounds.height - headerHeight }), 0.5);
-            if (edge && !this.setTiling(edge, win, windowBounds))
-                return false;
-        }
-        return true;
-    }
-    didNotFindAGroupTile({ sourceWin, wins, sourceParentWindow, sourceParentGroup, sourceGroup, mousePosition, }) {
-        let showScrim = false;
-        let allowDetaching = true;
-        for (const win of wins) {
-            const { isSelf, isMask, isParent, sharedParent } = this.relations(win, sourceWin, sourceParentWindow);
-            if (!win.allowTiling || isSelf || isMask || isParent || sharedParent) {
-                allowDetaching = false;
-                continue;
-            }
-            if (this.maybeSetOperation({ win, sourceGroup, sourceParentGroup, sourceParentWindow, mousePosition })) {
-                showScrim = true;
-                break;
-            }
-        }
-        return { showScrim, allowDetaching };
-    }
-    async handleNotTabbing({ sourceWin, mousePosition, wins, }) {
-        let showScrim = false;
-        let allowDetaching = true;
-        const sourceWindowName = sourceWin ? sourceWin.name : null;
-        const { headerHeight } = this;
-        const { movableGroups: groups } = await this.getMouseInGroups(mousePosition);
-        const sourceParentWindow = sourceWin ? sourceWin.parentWindow : null;
-        const sourceGroup = sourceWindowName ? this.getMovableGroup(sourceWindowName) : null;
-        const sourceParentGroup = sourceParentWindow ? this.getMovableGroup(sourceParentWindow.name) : null;
-        // tabbing gets priority
-        for (const group of groups) {
-            // group tile
-            if (!group.isARectangle())
-                continue;
-            const groupBounds = group.getBounds();
-            const edge = this.isPositionNearEdge(mousePosition, Object.assign(Object.assign({}, groupBounds), { top: groupBounds.top + headerHeight, height: groupBounds.height - headerHeight }), this.groupTileBuffer, "pixel");
-            const isSameGroupAsParent = sourceGroup === group || sourceParentGroup === group;
-            if (edge && this.tilingEnabled) {
-                if (isSameGroupAsParent)
-                    continue;
-                this.setTilingGroup(edge, group, groupBounds);
-                showScrim = true;
-                break;
-            }
-        }
-        // did not find a group tile
-        if (!showScrim) {
-            ({ showScrim, allowDetaching } = this.didNotFindAGroupTile({
-                wins,
-                sourceWin,
-                sourceParentWindow,
-                sourceParentGroup,
-                sourceGroup,
-                mousePosition,
-            }));
-        }
-        return { showScrim, allowDetaching };
-    }
-    runScrimShower(edge, bounds) {
-        if (!this.mouseTracking)
-            return;
-        const newBounds = scrimShower(edge, bounds);
-        this.showGroupMask({ bounds: newBounds.maskBounds, opacity: 0.5 });
-        return newBounds;
-    }
-    areWeTabbing(sourceWin, wins, mousePosition) {
-        const areWePositionedOnTab = (win) => {
-            const { headerHeight } = this;
-            const actualWindowBounds = win.getBounds();
-            const edge = this.isPositionNearEdge(mousePosition, actualWindowBounds, headerHeight, "pixel");
-            return edge === "top";
-        };
-        const sourceWindowName = sourceWin ? sourceWin.name : null;
-        for (const win of wins) {
-            const isSelf = win.name === sourceWindowName ||
-                win.win.windowState === constants.WINDOWSTATE.MINIMIZED_WAS_MAXIMIZED ||
-                win.win.windowState === constants.WINDOWSTATE.MINIMIZED_WAS_NORMAL ||
-                win.isHidden;
-            if (!isSelf && areWePositionedOnTab(win)) {
-                if (!(this.operation && this.operation.window && this.operation.window.name == win.name)) {
-                    win.bringToFront();
-                }
-                this.operation = {
-                    window: win,
-                };
-                return true;
-            }
-        }
-        return false;
-    }
-    /**
-     * Checks if mousePosition is in group or window
-     */
-    async boundsChecker({ sourceWin, mpErr, mousePosition, componentType, }) {
-        var _a;
-        if (mpErr) {
-            delete this.operation;
-            return;
-        }
-        if (!sourceWin && this.tilingAndTabbingWindow) {
-            sourceWin = this.tilingAndTabbingWindow;
-            delete this.tilingAndTabbingWindow;
-        }
-        // the following conditional previously also invoked clearInterval(mouseTracker.interval), but the interval wasn't defined.
-        // Checking if it was defined broke tiling, so the main functionality here must be just the return.
-        if (!this.mouseTracking)
-            return;
-        const wins = await this.getMouseInWindows(mousePosition);
-        let amITabbing = this.areWeTabbing(sourceWin, wins, mousePosition);
-        let allowDetaching = true;
-        let showScrim = false;
-        if (!amITabbing &&
-            // allow tiling if it is enabled for the source window
-            sourceWin.tiling &&
-            // allow tiling if window is resizable
-            sourceWin.windowOptions.resizable !== false &&
-            // allow tiling if window is not maximized
-            sourceWin.windowState !== WINDOWSTATE.MAXIMIZED) {
-            ({ showScrim, allowDetaching } = await this.handleNotTabbing({ sourceWin, mousePosition, wins }));
-        }
-        // if we are not tabbing or tiling, we are detaching
-        if (!showScrim && !amITabbing && componentType) {
-            // This means that we are trying to tab/tile with an as yet un-spawned window. Show a window sized scrim
-            showScrim = true;
-            this.operation = {
-                type: "detaching",
-            };
-            this.runScrimShower("full", Object.assign(mousePosition, this.configCache[componentType]));
-        }
-        if (!showScrim) {
-            this.hideGroupMask();
-            // if we are not tabbing, we are detaching
-            if (!amITabbing && allowDetaching) {
-                this.operation = {
-                    type: "detaching",
-                };
-            }
-        }
-        this.operation = (_a = this.operation) !== null && _a !== void 0 ? _a : {};
-        this.operation.sourceWindowName = sourceWin === null || sourceWin === void 0 ? void 0 : sourceWin.name;
-    }
-    startTilingOrTabbing(err, response, sourceWin) {
-        var _a;
-        const { windowIdentifier } = response.data;
-        // Gotta make sure we always pass the right thing around.
-        windowIdentifier.windowName = (_a = windowIdentifier.windowName) !== null && _a !== void 0 ? _a : windowIdentifier.name;
-        const sourceDockableWindow = this.getWindow(windowIdentifier.windowName);
-        if (!sourceWin && !response.data.waitForIdentifier && !sourceDockableWindow) {
-            FinsembleWindowInternal.getInstance({ name: windowIdentifier.windowName }, (getInstanceErr, windowWrap) => this.startTilingOrTabbing(getInstanceErr, response, windowWrap));
-            return;
-        }
-        Logger.system.debug("StartTilingOrTabbing");
-        const { componentType } = response.data;
-        this.startTrackingMouse(5, (mpErr, mousePosition) => {
-            this.boundsChecker({ mpErr, mousePosition, componentType, sourceWin: sourceWin !== null && sourceWin !== void 0 ? sourceWin : sourceDockableWindow.win });
-        });
-    }
-    cancelTilingOrTabbing() {
-        Logger.system.debug("CancelTilingOrTabbing");
-        delete this.operation;
-        this.stopTrackingMouse(() => { });
-    }
-    buildSnapRelationshipsForGroup(group) {
-        const windows = group.getWindows();
-        for (const w in windows) {
-            this.buildSnapRelationships(windows[w]);
-        }
-    }
-    getFillHolesFor(sourceWindow) {
-        let fillHolesFor = [];
-        if (sourceWindow.groupNames && sourceWindow.groupNames.length) {
-            // check if we need to fill holes
-            for (let i = sourceWindow.groupNames.length - 1; i >= 0; i--) {
-                const g = sourceWindow.groupNames[i];
-                const group = this.getGroup(g);
-                if (group.isARectangle() && group.isMovable) {
-                    fillHolesFor.push(group);
-                }
-            }
-        }
-        return fillHolesFor;
-    }
-    async fillHoles(group, bounds) {
-        await group.fillHole(bounds);
-        this.cleanupGroupGaps(group);
-        this.buildSnapRelationshipsForGroup(group);
-    }
-    actualStopTilingRequestMove({ sourceWindow, placement, groupNames, fillHolesFor, operation, oldBounds, }) {
-        const sourceMoveRequest = {
-            name: sourceWindow.name,
-            changeType: 0,
-        };
-        // this.buildSnapRelationships(sourceWindow);
-        Object.assign(sourceMoveRequest, placement);
-        Logger.system.debug("Docking:stopTilingOrTabbing requestMove 0", sourceMoveRequest);
-        this.requestMove(sourceMoveRequest, (bounds) => {
-            if (bounds && !bounds.finished)
-                return;
-            Logger.system.debug("Docking:stopTilingOrTabbing requestMove", bounds);
-            // If target is already part of a group or merging with a group
-            if (groupNames && groupNames.length) {
-                for (const g of groupNames) {
-                    const group = this.addWindowToGroup({
-                        groupName: g,
-                        win: sourceWindow,
-                    });
-                    if (group) {
-                        this.cleanupGroupGaps(group);
-                        this.buildSnapRelationshipsForGroup(group);
-                        group.updateBounds();
-                    }
-                }
-            }
-            else {
-                const group = this.addWindowToGroup({
-                    win: operation.window,
-                    isMovable: true,
-                    groupName: uuidv4(),
-                });
-                if (group) {
-                    this.addWindowToGroup({
-                        win: sourceWindow,
-                        groupName: group.name,
-                    });
-                }
-            }
-            this.updateGroupData();
-            this.onMouseUp();
-            for (const g of fillHolesFor) {
-                this.fillHoles(g, oldBounds);
-            }
-            if (groupNames && groupNames.length == 1) {
-                // this was a snapping group. Need to dock.
-                this.formGroup(sourceWindow.name, { isMovable: true });
-                this.updateGroupData();
-            }
-        });
-    }
-    actualStopTiling(params, fillHolesFor, sourceWindow) {
-        var _a;
-        const { err, operation } = params;
-        let groupNames;
-        const oldBounds = sourceWindow.getBounds();
-        Logger.system.debug("Docking:stopTilingOrTabbing case Tiling", err, operation);
-        const placement = this.checkShortCircuits(operation.newBounds.maskBounds, operation.newBounds.maskBounds);
-        operation.newBounds.newWindowBounds = this.checkShortCircuits(operation.newBounds.newWindowBounds, operation.newBounds.newWindowBounds);
-        // 2nd param is 'deleteGroupsWith1Window'
-        this.removeWindowFromAllGroups(sourceWindow, false);
-        (_a = sourceWindow.win.parentWindow) === null || _a === void 0 ? void 0 : _a._removeWindow({
-            windowIdentifier: sourceWindow.win.identifier,
-        });
-        if (operation.tileWith === "group") {
-            Logger.system.debug("Docking:stopTilingOrTabbing case GROUP", "removeWindow", sourceWindow.name, err);
-            CALCULATOR.removeWindow(sourceWindow.name, false);
-            if (fillHolesFor.some((grp) => operation.group.name === grp.name)) {
-                this.fillHoles(operation.group, oldBounds);
-                fillHolesFor = [];
-            }
-            operation.group.scale(operation.newBounds.newWindowBounds, operation.edge, this);
-            operation.group.resizeHandle = operation.edge;
-            operation.group.updateBounds();
-            const groupBounds = operation.group.getBounds();
-            // If the scale short circuits, we'll want to shift the window's placement to reflect the actual group bounds instead of what we planned for.
-            switch (operation.edge) {
-                case "right":
-                    placement.left = groupBounds.right;
-                    placement.right = placement.width + placement.left;
-                    break;
-                case "left":
-                    placement.right = groupBounds.left;
-                    placement.left = placement.right - placement.width;
-                    break;
-                case "top":
-                    placement.bottom = groupBounds.top;
-                    placement.top = placement.bottom - placement.height;
-                    break;
-                case "bottom":
-                    placement.top = groupBounds.bottom;
-                    placement.bottom = placement.top + placement.height;
-                    break;
-                default:
-                    break;
-            }
-            groupNames = [operation.group.name];
-            Logger.system.debug("Docking:stopTilingOrTabbing case GROUP", "addWindow", sourceWindow.name);
-            CALCULATOR.addWindow(sourceWindow.name, sourceWindow);
-        }
-        else if (operation.tileWith === "window") {
-            Logger.system.debug("Docking:stopTilingOrTabbing case window", "removeWindow", operation);
-            // If the scale short circuits, we'll want to shift the window's placement to reflect the actual group bounds instead of what we planned for.
-            switch (operation.edge) {
-                case "right":
-                    placement.left = operation.newBounds.newWindowBounds.right;
-                    placement.right = placement.width + placement.left;
-                    break;
-                case "left":
-                    placement.right = operation.newBounds.newWindowBounds.left;
-                    placement.left = placement.right - placement.width;
-                    break;
-                case "top":
-                    placement.bottom = operation.newBounds.newWindowBounds.top;
-                    placement.top = placement.bottom - placement.height;
-                    break;
-                case "bottom":
-                    placement.top = operation.newBounds.newWindowBounds.bottom;
-                    placement.bottom = placement.top + placement.height;
-                    break;
-                default:
-                    break;
-            }
-            operation.window.setBounds(operation.newBounds.newWindowBounds);
-            operation.window.win.stopMove();
-            ({ groupNames } = operation.window);
-        }
-        this.actualStopTilingRequestMove({
-            fillHolesFor,
-            operation,
-            sourceWindow,
-            placement,
-            groupNames,
-            oldBounds,
-        });
-    }
-    actualStopSwapping(sourceWindow, operation) {
-        Logger.system.debug("Docking:stopTilingOrTabbing case swapping", operation);
-        const sourceWindowNewBounds = operation.window.getBounds();
-        const targetWindowNewBounds = sourceWindow.getBounds();
-        sourceWindow.setBounds(sourceWindowNewBounds);
-        operation.window.setBounds(targetWindowNewBounds);
-        sourceWindow.win.stopMove();
-        operation.window.win.stopMove();
-        this.buildSnapRelationships(sourceWindow);
-        this.buildSnapRelationships(operation.window);
-        this.buildSnapRelationshipsForGroup(operation.group);
-        this.updateGroupData();
-    }
-    actualStopDetaching(fillHolesFor, sourceWindow, operation, mousePosition) {
-        const newBounds = {
-            top: mousePosition.y,
-            left: mousePosition.x,
-            right: sourceWindow.width + mousePosition.x,
-            bottom: sourceWindow.height + mousePosition.y,
-            width: sourceWindow.width,
-            height: sourceWindow.height,
-        };
-        const parent = sourceWindow.win.parentWindow;
-        if (parent) {
-            // detaching from tabs
-            Logger.system.debug("Docking:stopTilingOrTabbing case detaching with parent", operation, newBounds, parent.name);
-            parent._removeWindow({
-                showWindow: true,
-                windowIdentifier: sourceWindow.win.identifier,
-            });
-            sourceWindow.setBounds(newBounds);
-        }
-        Logger.system.debug("Docking:stopTilingOrTabbing case detaching no parent", operation, newBounds);
-        this.removeWindowFromAllGroups(sourceWindow, false);
-        this.updateGroupData();
-        const sourceMoveRequest = {
-            name: sourceWindow.name,
-            changeType: 0,
-        };
-        Object.assign(sourceMoveRequest, newBounds);
-        const oldBounds = sourceWindow.getBounds();
-        this.requestMove(sourceMoveRequest, (bounds) => {
-            if (bounds && !bounds.finished)
-                return;
-            if (fillHolesFor.length) {
-                for (const g of fillHolesFor) {
-                    this.fillHoles(g, oldBounds);
-                }
-            }
-            this.onMouseUp();
-        });
-    }
-    actualStopTabbing(fillHolesFor, sourceWindow) {
-        const sourceMoveRequest = {
-            name: sourceWindow.name,
-            changeType: 0,
-        };
-        // If old window was in a group, fill holes for that group
-        Object.assign(sourceMoveRequest, sourceWindow.getBounds());
-        /** We want to remove the source window from all its groups.
-         * We also want to disband any groups that, as a result of
-         * that removal, only have 1 window in the group. That said,
-         * if we remove the group before the call to fillHoles(),
-         * the math won't be right, and we'll have a bug in some
-         * edge cases. Ideally, calling this.updateGroupData() should
-         * automatically disband any group with only 1 window, but, as
-         * things are, there are timing issues that cause things to
-         * break down with this approach.
-         *
-         * The current solution is to cache the groups sourceWindow
-         * belongs to, remove the sourceWindow from all its groups
-         * but DON'T disband any of them, call fillHole(),
-         * then go back and remove any single-member groups if there
-         * are any.
-         */
-        const oldGroupNames = clone(sourceWindow.groupNames);
-        this.removeWindowFromAllGroups(sourceWindow, false);
-        this.removeWindow(sourceWindow.name);
-        if (fillHolesFor.length) {
-            for (const g of fillHolesFor) {
-                this.fillHoles(g, sourceWindow.getBounds());
-            }
-        }
-        // This loop checks for any newly created single-member groups and disbands them.
-        for (const groupName of oldGroupNames) {
-            const group = this.getGroup(groupName);
-            if (!group)
-                continue;
-            const groupWindowsNames = group.getWindowNames();
-            if (groupWindowsNames.length !== 1)
-                continue;
-            this.removeWindowFromGroup(groupWindowsNames[0], groupName, true);
-        }
-        this.onMouseUp();
-        this.updateGroupData();
-    }
-    actualStopTilingOrTabbing(params, callback) {
-        const { mousePosition, operation } = params;
-        // This will only happen if you're dragging a pin or something from a menu --- the window hasn't been spawned yet.
-        if (!operation.sourceWindowName) {
-            // dragged a non-existent window. wait.
-            if (this.tilingAndTabbingWindow) {
-                operation.sourceWindowName = this.tilingAndTabbingWindow.name;
-                this.tilingAndTabbingWindow = undefined;
-            }
-            else {
-                setTimeout(() => {
-                    Logger.system.debug("StopTilingOrTabbing.actualStopTilingOrTabbing waiting for window");
-                    this.actualStopTilingOrTabbing(params, callback);
-                }, 100);
-                return;
-            }
-        }
-        const sourceWindow = this.getWindow(operation.sourceWindowName);
-        // take what the user sent on dragend
-        Logger.system.debug("StopTilingOrTabbing.actualStopTilingOrTabbing", operation.sourceWindowName, mousePosition);
-        if (!sourceWindow) {
-            // detaching from tabbing so window is not registered with docking
-            FinsembleWindowInternal.getInstance({ name: operation.sourceWindowName }, (getInstanceErr, windowWrap) => {
-                Logger.system.debug("StopTilingOrTabbing.no source window. Adding to docking.", operation.sourceWindowName);
-                this.addWindow(windowWrap)
-                    .then(() => {
-                    this.checkIfWindowIsInGroup(windowWrap.name);
-                    Logger.system.debug("StopTilingOrTabbing.recursive call");
-                    this.actualStopTilingOrTabbing(params, callback);
-                })
-                    .catch((err) => {
-                    Logger.system.debug("StopTilingOrTabbing.recursive call caught reject", err);
-                    this.actualStopTilingOrTabbing(params, callback);
-                });
-            });
-            return;
-        }
-        const fillHolesFor = this.getFillHolesFor(sourceWindow);
-        this.hideGroupMask();
-        // When we call request-move, docking will stp if the window is between two snapping regions. By temporarily reducing the buffer size, we prevent inadvertent snaps and move our window to where we calculated it should go.
-        const BUFFER = this.bufferSize;
-        this.setBufferSize(0);
-        if (!operation.type) {
-            operation.type = "detaching";
-        }
-        switch (operation.type) {
-            case "tiling":
-                this.actualStopTiling(params, fillHolesFor, sourceWindow);
-                break;
-            case "swapping":
-                this.actualStopSwapping(sourceWindow, operation);
-                break;
-            case "detaching":
-                this.actualStopDetaching(fillHolesFor, sourceWindow, operation, mousePosition);
-                break;
-            case "tabbing":
-                Logger.system.debug("Docking:stopTilingOrTabbing case tabbing break", operation ? operation.type : null);
-                this.actualStopTabbing(fillHolesFor, sourceWindow);
-                break;
-            default:
-                break;
-        }
-        this.setBufferSize(BUFFER);
-        if (operation.group) {
-            operation.group.resizeHandle = null;
-        }
-        callback();
-    }
-    stopTilingOrTabbing(err, response, callback) {
-        Logger.system.debug("Docking:stopTilingOrTabbing start", err, response, this.operation ? this.operation.type : null);
-        if (!this.operation) {
-            Logger.system.debug("Docking:stopTilingOrTabbing invariant: this.operation is unset");
-            callback();
-            return;
-        }
-        const op = this.operation;
-        delete this.operation;
-        if (response.data.action) {
-            op.type = response.data.action;
-        }
-        /* Show Window at Last Scrim Position */
-        Logger.system.debug("Stop tiling or tabbing");
-        this.stopTrackingMouse((stopTrackingMouseErr, mousePosition) => {
-            mousePosition = response.data.mousePosition || mousePosition;
-            if (op.type === "swapping" && op.sourceWindowName) {
-                FinsembleWindowInternal.getInstance({ name: op.sourceWindowName }, (getInstanceErr, windowWrap) => {
-                    // replace the sourceWindowName with the parent's name. This way the whole stacked group gets swapped instead of the individual tab.
-                    if (windowWrap.parentWindow) {
-                        op.sourceWindowName = windowWrap.parentWindow.name;
-                    }
-                    this.actualStopTilingOrTabbing({ err: getInstanceErr, mousePosition, operation: op }, callback);
-                });
-            }
-            else {
-                this.actualStopTilingOrTabbing({ err: stopTrackingMouseErr, mousePosition, operation: op }, callback);
-            }
-        });
-    }
-    //KB40615 Listen for a change in the config (see AssimilationService) indicating that assimilation
-    // startup failed, then disable claimed space (otherwise it may cause issues with toolbar
-    // visibility, which is only reset when monitor resize events are triggered by claimSpace)
-    maybeAssimilationFailed() {
-        ConfigClient.addListener({ field: "finsemble.servicesConfig.servicesConfig.assimilation.enabled" }, (err, change) => {
-            var _a;
-            if (!change.value) {
-                //disable claimed space
-                serviceConfig.assimilationEnabled = change.value;
-                if ((_a = serviceConfig.claimSpace) === null || _a === void 0 ? void 0 : _a.enabled) {
-                    serviceConfig.claimSpace.enabled = change.value;
-                    Logger.system.error("Claimed space disabled at runtime, probably due to a failure to start assimilation");
-                }
-                this.claimSpace = this.claimSpace && change.value;
-            }
-        });
-    }
-    async initialize() {
-        this.createRouterEndpoints();
-        this.initiateGroupMaskCreation();
-        const setupDockingCalculator = async () => {
-            var _a, _b, _c, _d, _e, _f;
-            const { data: response } = await ConfigClient.getValue({ field: "finsemble" });
-            const isWindows = await util.isWindows();
-            this.isWindows = isWindows;
-            // Finsemble config
-            serviceConfig = response.services.windowService.config || response.services.dockingService.config;
-            /* Assimilation config can come from the defaults (/finsemble/configs/core/services.json),
-                client-configured servicesConfig, or in betaFeatures config (deprecated).  */
-            const servicesConfigAssim = response.servicesConfig.assimilation;
-            const betaAssim = response.betaFeatures.assimilation;
-            const defaultAssim = response.services.assimilationService.config;
-            const assimilationConfig = Object.assign(defaultAssim, servicesConfigAssim || betaAssim);
-            serviceConfig.assimilationEnabled = isWindows && assimilationConfig.enabled;
-            // right place is servicesConfig, old place was top-level config. Otherwise we use an empty object that gets merged with finsemble defaults.
-            const docking = (_c = (_b = (_a = response === null || response === void 0 ? void 0 : response.servicesConfig) === null || _a === void 0 ? void 0 : _a.docking) !== null && _b !== void 0 ? _b : response === null || response === void 0 ? void 0 : response.docking) !== null && _c !== void 0 ? _c : {};
-            serviceConfig = Object.assign(Object.assign(Object.assign({}, serviceConfig), docking), { GROUP_MODE: {
-                    enabled: docking.enabled,
-                    behavior: "explicit",
-                    groupTileBuffer: docking.groupTileBuffer || 30,
-                    headerHeight: docking.headerHeight || 32,
-                    requireRectangularityForGroupResize: docking.requireRectangularityForGroupResize,
-                    fillHolesOnUndock: docking.fillHolesOnUndock,
-                    undockDisbandsEntireGroup: docking.undockDisbandsEntireGroup,
-                } });
-            if (!isWindows || !serviceConfig.assimilationEnabled) {
-                serviceConfig.claimSpace = {
-                    enabled: false,
-                };
-            }
-            this.claimSpace = (_e = (_d = serviceConfig.claimSpace) === null || _d === void 0 ? void 0 : _d.enabled) !== null && _e !== void 0 ? _e : false;
-            this.preventOverlapClaimSpace = (_f = serviceConfig.preventOverlapClaimSpace) !== null && _f !== void 0 ? _f : false;
-            this.maybeAssimilationFailed();
-            this.serviceConfig = serviceConfig;
-            this.setupDockingCalculator();
-        };
-        const initializeMonitors = async () => {
-            const res = await getAllMonitors();
-            this.updateMonitorInfo(res);
-        };
-        await Promise.all([setupDockingCalculator(), initializeMonitors()]);
-        this.dockingReady = true;
-    }
-}
-export default DockingMain;
-//# sourceMappingURL=dockingMain.js.map