@finsemble/finsemble-ui 1.0.0-beta-5 → 1.0.0-beta-9

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

@@ -0,0 +1,1168 @@
+import { BaseWindow } from "./BaseWindow";
+import { RouterClient } from "../../../../clients/routerClient";
+import { ConfigClient } from "../../../../clients/configClient";
+import { toast } from "../../../../common/toast";
+import { Logger } from "../../../../clients/logger";
+import { System } from "../../../../common/system";
+import { MOVE_REASON, WINDOWSTATE } from "../../../../common/constants";
+import { isWindows } from "../../../../common/util";
+function isNumeric(n) {
+    return !isNaN(parseFloat(n)) && isFinite(n);
+}
+/**
+ * WebWindow
+ */
+export class WebWindow extends BaseWindow {
+    /**
+     *
+     * @param {*} params
+     * @param {finWindow} [params.finWindow] If not provided, must provide uuid
+     * @param {string} [params.uuid] If not provided, must provide finWindow
+     * @param {string} [params.name]
+     */
+    constructor(params) {
+        super(params);
+        this._listeners = {};
+        // whether to notify the user that we failed to close the window if it times out.
+        this.throwNotificationOnFailedClose = false;
+        this.canMinimize = true;
+        this.canMaximize = true;
+        // On destruct, we'll go through all the listeners that we've added to the router and remove them
+        this.RouterHandlers = {};
+        // keeps track of Finsemble window event listeners and prevents duplicates
+        this.listeningFor = [];
+        // keeps track of the system event listeners that the Finsemble event listeners translate to and makes sure there are no duplicates
+        this.addedSystemListeners = {};
+        // This boolean is set to true when the window is closed by the operating system (outside of finsemble).
+        this.closing = false;
+        this.setBoundsFromFinsemble = false;
+        // Tracks wether the windows key is being held down. When the windows key is pressed inside a window a router message is dispatched to change this prop. Only when the opposite action fires from the router will this value change back.
+        this.windowsKeyDown = false;
+        this.lastWindowsKeyUp = 0;
+        this.windowState = WINDOWSTATE.NORMAL;
+        this.name = params.name || params.windowName;
+        Logger.system.debug("WebWindow constructor", this.name);
+        this.focused = false;
+        if (params.finWindow) {
+            this.finWindow = params.finWindow;
+            if (!this.name)
+                this.name = this.finWindow.name;
+        }
+        if (!this.finWindow) {
+            this.finWindow = System.Window.wrap(this.name);
+        }
+        this.windowIdentifier = { windowName: this.name, uuid: "dummyuuid" };
+        this.wrapFunctions();
+        this.windowOptions = {};
+        this.setMyOptions = this.setMyOptions.bind(this);
+        this.setCloseTimeout = this.setCloseTimeout.bind(this);
+        this.eventChannelName = this.eventChannelName.bind(this);
+        this.windowsKeyAction = this.windowsKeyAction.bind(this);
+        this._restore = this._restore.bind(this);
+        this.setParent = super.setParent.bind(this);
+        this.getParent = super.getParent.bind(this);
+        this.setMinimizeAbility = this.setMinimizeAbility.bind(this);
+        this.setMaximizeAbility = this.setMaximizeAbility.bind(this);
+        this.addListeners = this.addListeners.bind(this);
+        this.removeListeners = this.removeListeners.bind(this);
+        this._systemClosed = this._systemClosed.bind(this);
+        this._systemRestored = this._systemRestored.bind(this);
+        this._systemMaximized = this._systemMaximized.bind(this);
+        this._getBoundsFromSystem = this._getBoundsFromSystem.bind(this);
+        this.setupSystemBoundsChangedEvent = this.setupSystemBoundsChangedEvent.bind(this);
+        this.addListeners();
+    }
+    _addEventListener(params, handler = Function.prototype) {
+        const { eventName } = params;
+        this.addEventListener(eventName, handler);
+    }
+    _removeEventListener(params, handler = Function.prototype) {
+        const { eventName } = params;
+        this.removeEventListener(eventName, handler);
+    }
+    removeEventListener(params, handler = Function.prototype) {
+        super.removeEventListener(params.eventName || params, handler);
+    }
+    /**
+     * Make sure that only one event is added for system listeners that someone requests. These events are cleaned up when "addedSystemListeners" are removed.
+     * @param {string} systemEvent
+     * @param {Function} handler
+     */
+    setupSystemListener(systemEvent, handler) {
+        if (!this.addedSystemListeners[systemEvent]) {
+            this.addedSystemListeners[systemEvent] = handler;
+            this.finWindow.addEventListener(systemEvent, handler);
+        }
+    }
+    addEventListener(event, handler) {
+        // This makes sure that the handlers are triggered for each event and get removed when someone removes the handler
+        super.addEventListener(event, handler);
+        // For some events, add listeners in the finWindow so that we can then propagate the event to the rest of the system. These are only added one time.
+        if (!this.listeningFor.includes(event)) {
+            this.listeningFor.push(event);
+            switch (event) {
+                case "bounds-change-request":
+                    // translate disabled-frame-bounds-changing into a bounds-change-request event expected by the rest of the system.
+                    this.setupSystemListener("disabled-frame-bounds-changing", this.onDisabledFrameBoundsChanging.bind(this));
+                    break;
+                case "bounds-changed":
+                    this.setupSystemListener("disabled-frame-bounds-changed", this.onDisabledFrameBoundsChanged.bind(this));
+                    break;
+                case "system-bounds-changed":
+                    this.setupSystemListener("bounds-changed", this.setupSystemBoundsChangedEvent.bind(this));
+                    break;
+                case "system-maximized":
+                    this.setupSystemListener("maximized", () => this.eventManager.trigger("system-maximized"));
+                    break;
+                case "system-restored":
+                    this.setupSystemListener("restored", () => this.eventManager.trigger("system-restored"));
+                    break;
+                case "blurred":
+                case "focused":
+                case "hidden":
+                case "shown":
+                case "minimized":
+                // case "close-requested": <- using our custom close-requested event.
+                // case "closed": <- using custom close-event.
+                case "crashed":
+                    // keep track of events we're listening for so we don't add multiple listeners on the window. don't want to trigger more than a single remote event per single local event. Said differently, if we add this generic handler N times, the event will be triggered N times.
+                    // `super.addEventListener` will make sure that any events emitted by this wrapper are caught. However, we won't emit any events that we aren't listening to on the primitive window (in this case, the underlying finWindow).
+                    // So, when someone adds a listener(e.g., focus), we listen for the primitive to emit the event. At that point, the derived class will emit, and the handler will be fired.
+                    this.setupSystemListener(event, this.onNativeEvent.bind(this, event));
+                    break;
+                // 'system-closed' is a made up event. It means 'a closed event was emitted on the underlying window primitive that we weren't expecting'.
+                // This will happen when the user closes via the taskbar or via alt + f4.
+                case "system-closed":
+                    this.setupSystemListener("closed", () => this.eventManager.trigger("system-closed"));
+                    break;
+                default:
+                    Logger.system.debug("Listener added to Web wrap, Handler not passed to primitive. Using finsemble event instead.", event);
+                    break;
+            }
+        }
+    }
+    /**
+     * Sets up listeners for system-bounds-changed events. Currently only responds to aero snap moves
+     */
+    async setupSystemBoundsChangedEvent(evt) {
+        if (this.isDocked) {
+            this.eventManager.trigger("system-bounds-changed", Object.assign({}, evt));
+            return;
+        }
+        Logger.system.verbose("bounds-changed event", evt);
+        // If a setBounds call was made by Finsemble, do not trigger this event. The intent of this is to catch things like moves made by windows keyboard shortcuts or direct calls from OF.
+        // dockableWindow deals with these. For stacks, this event is propagated to the stack.
+        if (this.setBoundsFromFinsemble && this.checkIfBoundsAreTheSame(evt, this.requestedBounds)) {
+            this.setBoundsFromFinsemble = false;
+            return;
+        }
+        if (!this.finishedMove)
+            return;
+        if (this.windowsKeyDown) {
+            // If windows key is down, user is using shortcuts to position windows. Delay triggering the event until keyup.
+            this.windowsKeyUpHandler = () => {
+                if (this.windowState === WINDOWSTATE.MAXIMIZED) {
+                    this.windowState = WINDOWSTATE.NORMAL;
+                    this.eventManager.trigger("restored");
+                }
+                evt.action = MOVE_REASON.AERO_KEY;
+                this.eventManager.trigger("system-bounds-changed", Object.assign({}, evt));
+                // We set a global flag here that is available to all windowWrappers and docking. Aerosnapped windows fire a lot of spurious move events that need to be caught.
+                window.aeroMode = true;
+            };
+        }
+        else if (window.aeroMode) {
+            // this is for a window that is chosen from preview and is the only case except the initial aerosnap that needs to be dealt with.
+            if (this.windowState === WINDOWSTATE.MAXIMIZED) {
+                this.windowState = WINDOWSTATE.NORMAL;
+                this.eventManager.trigger("restored");
+            }
+            evt.action = MOVE_REASON.AERO_KEY;
+            this.eventManager.trigger("system-bounds-changed", Object.assign({}, evt));
+            window.aeroMode = false;
+        }
+    }
+    checkIfBoundsAreTheSame(bounds1, bounds2) {
+        if (bounds1 && bounds2) {
+            return (bounds1.top === bounds2.top &&
+                bounds1.left === bounds2.left &&
+                bounds1.height === bounds2.height &&
+                bounds1.width === bounds2.width);
+        }
+        return false;
+    }
+    // When a native event fires:
+    async _systemMaximized() {
+        let win = this;
+        // prevent second maximize event
+        if (win.windowState == WINDOWSTATE.MAXIMIZED)
+            return;
+        win.windowState = WINDOWSTATE.MAXIMIZED;
+        win.eventManager.trigger("maximized");
+    }
+    // When a native event fires:
+    async _systemRestored() {
+        var _a;
+        // Skip if this window is contained within a stacked window
+        // We found that restoring a workspace with a maximized window stack resulted in the ability to
+        // unmaximize the stack by switching tabs.  This is a workaround to that issue.
+        if (((_a = this.getParent()) === null || _a === void 0 ? void 0 : _a.setWindowType) === "StackedWindow") {
+            return;
+        }
+        let win = this;
+        // Maximize happens we resize the window under the titlebar, which causes restore to fire.
+        // We only want to actually deal with restore when the window is minimized previously
+        if (this.parentWindow)
+            win = this.parentWindow;
+        if (win.windowState === WINDOWSTATE.MINIMIZED_WAS_MAXIMIZED) {
+            win._maximize();
+            return;
+        }
+        /**
+         * If ignoreSystemRestore flag is present (was added from stackedWindowManager.setVisibleWindow) means that we are on a maximzed tabbed window
+         * and only switching tabs (which is triggering a system restored event) and therefore we simply want to:
+         * 	- remove the flag to prevent subquent inconsistent window states
+         * 	- maximize the window and bail out
+         */
+        /* The ignoreSystemRestore flag is used to workaround a Chromium bug where changing the visibility on a maximized window triggers a restore event. This could cause maximize stacked windows to restore when switching tabs. We can't prevent the window from restoring, so our only option is to maximize the window after the fact. The flag is set to true only when we initiate the tab switch in this specific case, then toggled off afterwards to prevent effecting other window states. */
+        if (this.ignoreSystemRestore) {
+            this.ignoreSystemRestore = false;
+            win._maximize();
+            return;
+        }
+        if (win.windowState === WINDOWSTATE.MINIMIZED_WAS_NORMAL) {
+            win._restore();
+            // If the previous restore position is now off-monitor the OS will have changed the restore position.
+            // Finsemble and FEA's values will be wrong in this case so we need to update our bounds if our bounds don't match Electron's bounds.
+            const { data: oldBounds } = await win._getBounds({});
+            const { data: updatedBounds } = await win._getBoundsFromSystem({});
+            const newBounds = Object.assign(Object.assign({}, updatedBounds), { action: MOVE_REASON.SYSTEM_RESTORED });
+            if (!this.checkIfBoundsAreTheSame(oldBounds, updatedBounds)) {
+                this.eventManager.trigger("system-bounds-changed", Object.assign({}, newBounds));
+            }
+            return;
+        }
+        if (win.windowState === WINDOWSTATE.MAXIMIZED)
+            win._restore();
+        win.windowState = WINDOWSTATE.NORMAL;
+        win.eventManager.trigger("restored");
+    }
+    // When a native event fires:
+    onNativeEvent(eventName) {
+        this.eventManager.trigger(eventName);
+    }
+    addListeners() {
+        this.addEventListener("minimized", () => {
+            // we set the new windowState based on whether the current windowState is maximized or normal.
+            // if it is not either of those things, that means it is already in a minimized state, so we don't do anything.
+            if (this.windowState === WINDOWSTATE.MAXIMIZED) {
+                this.windowState = WINDOWSTATE.MINIMIZED_WAS_MAXIMIZED;
+                this.windowOptions.windowState = WINDOWSTATE.MINIMIZED_WAS_MAXIMIZED;
+            }
+            else if (this.windowState === WINDOWSTATE.NORMAL) {
+                this.windowState = WINDOWSTATE.MINIMIZED_WAS_NORMAL;
+                this.windowOptions.windowState = WINDOWSTATE.MINIMIZED_WAS_NORMAL;
+            }
+        });
+        this.addEventListener("restored", () => {
+            this.windowState = WINDOWSTATE.NORMAL;
+            this.windowOptions.windowState = WINDOWSTATE.NORMAL;
+        });
+        this.addEventListener("maximized", () => {
+            this.windowState = WINDOWSTATE.MAXIMIZED;
+            this.windowOptions.windowState = WINDOWSTATE.MAXIMIZED;
+        });
+        this.addEventListener("system-maximized", this._systemMaximized);
+        this.addEventListener("system-restored", this._systemRestored);
+        this.addEventListener("system-closed", this._systemClosed);
+        const UPDATE_OPTIONS_CHANNEL = `${this.name}.updateOptions`;
+        const onUpdateOptions = (err, response) => {
+            for (const o in response.data) {
+                if (this.windowOptions[o] == response.data[o])
+                    return;
+                this.windowOptions[o] = response.data[o];
+                const dataToEmit = {
+                    windowName: this.name,
+                };
+                dataToEmit[o] = response.data[o];
+                this.eventManager.trigger(o, response.data);
+            }
+        };
+        this.RouterHandlers[UPDATE_OPTIONS_CHANNEL] = onUpdateOptions;
+        // Fire events when options are updated. e.g. alwaysOnTop
+        RouterClient.addListener(UPDATE_OPTIONS_CHANNEL, onUpdateOptions);
+        // When window key is pressed, we delay the system-set-bounds event trigger to after the key goes up.
+        RouterClient.addListener("Finsemble.WindowService.WindowsKey", this.windowsKeyAction);
+        /** DH 6/15/2019 - The OS and container maintain seperate records of
+         * which window is in focus, which can get out of sync;
+         * therefore, we have to maintain a seperate state here.
+         * Ideally this wouldn't be necessary and OS events would
+         * always bubble up to the container.
+         */
+        this.addEventListener("focused", () => {
+            this.focused = true;
+        });
+        this.addEventListener("blurred", () => {
+            this.focused = false;
+        });
+    }
+    addBrowserView(params, cb) {
+        this.finWindow.addBrowserView(params, (data) => {
+            cb(null, data.id);
+        });
+    }
+    removeBrowserView(params, cb) {
+        this.finWindow.removeBrowserView(params.viewId, () => {
+            cb(null);
+        });
+    }
+    bringViewToFront(params, cb) {
+        this.finWindow.bringViewToFront(params.viewId, () => {
+            cb(null);
+        });
+    }
+    setViewBounds(params, cb) {
+        this.finWindow.setViewBounds(params.viewId, params.bounds, () => {
+            cb(null);
+        });
+    }
+    onDisabledFrameBoundsChanged(evt) {
+        this.eventManager.trigger("bounds-changed", Object.assign({}, evt));
+    }
+    onDisabledFrameBoundsChanging(evt) {
+        this.eventManager.trigger("bounds-change-request", Object.assign({}, evt));
+    }
+    reload(params, cb = Function.prototype) {
+        if (typeof params === "function") {
+            cb = params;
+            params = null;
+        }
+        this.callWebWindowFunction("reload", null, cb);
+    }
+    /**
+     * @param params.property property to pull from 'finsemble' and from componentConfig.
+     * @param params.componentType which component to grab local config from.
+     */
+    getGlobalAndLocalComponentConfig(params) {
+        const { property, componentType } = params;
+        const promiseResolver = (resolve, reject) => {
+            if (typeof componentType === "undefined") {
+                reject("params.componentType must be defined.");
+            }
+            if (typeof property === "undefined") {
+                reject("params.property is required");
+            }
+            // In case config isn't initialized when this method is called.
+            const getConfig = () => {
+                ConfigClient.getValue({ field: "finsemble" }, (err, allConfig) => {
+                    if (err)
+                        return reject(err);
+                    const globalConfig = allConfig[property];
+                    const componentConfig = allConfig.components[componentType];
+                    // If we have the component config, return the property saved on that component. if not, return undefined.
+                    const localConfig = componentConfig && componentConfig.foreign && componentConfig.foreign.components
+                        ? componentConfig.foreign.components[property]
+                        : undefined;
+                    resolve({ localConfig, globalConfig, allConfig });
+                });
+            };
+            getConfig();
+        };
+        return new Promise(promiseResolver);
+    }
+    setCloseTimeout() {
+        const promiseResolver = (resolve) => {
+            let componentType;
+            // Have to make sure options are set. Sometimes wraps are created and then just used to close windows. Need options to know which kind of component it is..
+            this.setMyOptions(async () => {
+                if (this.windowOptions && this.windowOptions.customData && this.windowOptions.customData.component) {
+                    componentType = this.windowOptions.customData.component.type;
+                }
+                // Get the global timeout and the component-specific timeout. If the component-specific exists, use it. If it doesn't, try global. If global doesn't exist, use 5000ms.
+                const { localConfig, globalConfig, allConfig } = await this.getGlobalAndLocalComponentConfig({
+                    property: "Window Manager",
+                    componentType,
+                });
+                const globalTimeout = globalConfig ? globalConfig.componentCloseTimeout : undefined;
+                const componentTimeout = localConfig ? localConfig.componentCloseTimeout : undefined;
+                if (typeof componentTimeout !== "undefined") {
+                    this.closeTimeout = componentTimeout;
+                }
+                else if (typeof globalTimeout !== "undefined") {
+                    this.closeTimeout = globalTimeout;
+                }
+                else {
+                    this.closeTimeout = 5000;
+                }
+                this.throwNotificationOnFailedClose = allConfig.failedComponentCloseNotification;
+                Logger.system.info("Close timeout set for", this.name, JSON.stringify(this.closeTimeout));
+                resolve();
+            });
+        };
+        return new Promise(promiseResolver);
+    }
+    setMyOptions(cb) {
+        this.finWindow.getOptions((opts) => {
+            if (!opts) {
+                Logger.system.error("setMyOptions. options returned from FEA is empty", opts);
+            }
+            this.windowOptions = Object.assign(opts, this.windowOptions || {});
+            if (!this.windowOptions) {
+                Logger.system.error("window options is null");
+            }
+            if (cb)
+                cb();
+        });
+    }
+    setMinimizeAbility(canMinimize) {
+        if (typeof canMinimize !== "boolean") {
+            Logger.system.error("Ability to minimize cannot be a non-boolean value. Assuming true");
+            canMinimize = true;
+        }
+        this.canMinimize = canMinimize;
+    }
+    setMaximizeAbility(canMaximize) {
+        if (typeof canMaximize !== "boolean") {
+            throw new Error("Ability to maximize cannot be a non-boolean value");
+        }
+        this.canMaximize = canMaximize;
+    }
+    _updateOptions(params = {}, cb = Function.prototype) {
+        if (!params)
+            params = {};
+        params = params.options || params;
+        // Permissions and security policies are protected options. They cannot be modified. Overwrite them as long as they've been set on the window.
+        // Note: window options aren't set on instantiation. New functionality needs to be added to set the options on creation.
+        if (this.windowOptions && this.windowOptions.securityPolicy) {
+            params.permissions = this.windowOptions.permissions;
+            params.securityPolicy = this.windowOptions.securityPolicy;
+        }
+        this.callWebWindowFunction("updateOptions", params, () => {
+            this._saveWindowOptions();
+            cb();
+        });
+    }
+    // Had to move this because jScrambler was screwing up when we obfuscated.
+    wrapFunctions() {
+        // let self = this;
+        const WebWindowFunctionsWithoutParams = ["disableFrame", "isShowing", "getState"];
+        WebWindowFunctionsWithoutParams.forEach((f) => {
+            this[f] = (params, cb) => {
+                if (typeof params === "function") {
+                    cb = params;
+                    params = null;
+                }
+                this.callWebWindowFunction(f, false, cb);
+            };
+        });
+        const WebWindowFunctionsWithoutParamsToBeWrappedInIsShowing = ["focus"];
+        WebWindowFunctionsWithoutParamsToBeWrappedInIsShowing.forEach((f) => {
+            this[f] = (cb = Function.prototype) => {
+                // If the method is defined on the BaseWindow, call it.
+                if (super[f]) {
+                    super[f]({}, (err, response) => {
+                        // if BaseWindow says it's okay for us the method to trickle down to the wrapper, great. otherwise cb.
+                        if (!err && response.shouldContinue) {
+                            this.callWebWindowFunction(f, false, cb);
+                        }
+                        else {
+                            cb();
+                        }
+                    });
+                }
+                else {
+                    this.callWebWindowFunction(f, false, cb);
+                }
+            };
+        });
+    }
+    /**
+     * Called when a router message is received saying a windows key was pressed/released.
+     * @param {*} err Error from the router
+     * @param {*} response The response containing information about what keys were pressed
+     */
+    windowsKeyAction(err, response) {
+        let timeout;
+        const setWindowKeyDownFalse = () => {
+            this.windowsKeyDown = false;
+            this.lastWindowsKeyUp = Date.now();
+            if (this.windowsKeyUpHandler)
+                this.windowsKeyUpHandler();
+            this.windowsKeyUpHandler = null;
+            clearTimeout(timeout);
+        };
+        if (response.data === "down") {
+            this.windowsKeyDown = true;
+            // In case we never get a key up.
+            timeout = setTimeout(setWindowKeyDownFalse, 30000);
+        }
+        else if (response.data === "up") {
+            setWindowKeyDownFalse();
+        }
+    }
+    updateOptions(params) {
+        Logger.system.debug("callWebWindowFunction.updateOptions", params);
+        if (!params[0].dontFireEvents) {
+            RouterClient.transmit(`${this.name}.updateOptions`, params[0]);
+            for (const o in params[0]) {
+                // in some cases (such as our bringToFront hack we dont want to fire spurious events). Also dont fire events if the option doesn't change
+                if (o == "dontFireEvents" || this.windowOptions[o] == params[0][o])
+                    continue;
+                if (this.windowOptions[o] &&
+                    typeof this.windowOptions[o] === "object" &&
+                    params[0][o] &&
+                    typeof params[0][o] === "object") {
+                    Object.assign(this.windowOptions[o], params[0][o]);
+                }
+                else {
+                    this.windowOptions[o] = params[0][o];
+                }
+                if (!params[0].dontFireEvents) {
+                    const event = {
+                        windowName: this.name,
+                        [o]: params[0][o],
+                    };
+                    this.eventManager.trigger(o, event);
+                }
+            }
+        }
+    }
+    /**
+     *
+     * @param {*} functionName Name of the Web window function to call
+     * @param {*} params  The parameters to the function (except callbacks) as an array
+     * @param {*} cb The callback to be called. This is in the format function (err, response) {} and errors will be in err.
+     */
+    callWebWindowFunction(functionName, params, cb = Function.prototype) {
+        // If this.closing is true, the window was closed by the operating system.
+        // When that happens, the window receives focus. If that window is part of a group, this can trigger calls to bring to front, update options, etc.
+        // These function calls will error out because the window has already been closed.
+        if (this.closing) {
+            cb({
+                code: "function_dropped_window_closing",
+                message: `Window ${this.name} was closed by the operating system. Skipping call to ${functionName}`,
+            });
+            return;
+        }
+        if (!params) {
+            this.finWindow[functionName]((retval) => {
+                cb === null || cb === void 0 ? void 0 : cb(null, retval);
+            }, (err) => {
+                Logger.system.debug("Error in WebWindowWrapper method", functionName, err);
+                cb === null || cb === void 0 ? void 0 : cb(err);
+            });
+            return;
+        }
+        params = Array.isArray(params) ? params : [params];
+        // add success callback to params
+        params.push((...args) => {
+            var _a, _b;
+            // fire event for updateOptions
+            if (functionName == "updateOptions")
+                this.updateOptions(params);
+            // call the actual callback
+            if (cb) {
+                if (((_a = args[0]) === null || _a === void 0 ? void 0 : _a.status) === "failure") {
+                    cb(((_b = args[0]) === null || _b === void 0 ? void 0 : _b.message) || args[0].status, null);
+                    return;
+                }
+                cb(null, args);
+            }
+        });
+        // add error callback to params
+        params.push((err) => {
+            if (cb) {
+                err = `Error for ${this.name} from method ${functionName}: ${err}`;
+                Logger.system.error("Error in WebWindowWrapper method", functionName, err);
+                console.error(err);
+                cb(err);
+            }
+        });
+        // call the function
+        Logger.system.debug("callWebWindowFunction", functionName, params);
+        this.finWindow[functionName](...params);
+    }
+    /**
+     * Gets the bounds directly from Electron. The existing getbounds function tries it's best to pass in the bounds as Finsemble knows them instead of bounds
+     * sent up from the system.
+     * This is called in cases where the OS has moved a window. In these cases we need the updated bounds from the system to update the Finsemble bounds
+     * @param {*} params
+     * @param {*} cb
+     */
+    _getBoundsFromSystem(params, cb = Function.prototype) {
+        Logger.system.debug("WebWindowWrapper._getBoundsFromSystem", this.name, params);
+        const promiseResolver = (resolve) => {
+            this.callWebWindowFunction("getBoundsFromSystem", null, (err, bounds) => {
+                cb(err, bounds);
+                return resolve({ err, data: bounds });
+            });
+        };
+        return new Promise(promiseResolver);
+    }
+    _getBounds(params, cb = Function.prototype) {
+        Logger.system.debug("WebWindowWrapper._getBounds", this.name, params);
+        if (typeof params === "function") {
+            cb = params;
+            params = null;
+        }
+        const promiseResolver = (resolve) => {
+            // BOUNDS ARE WRONG! SERIOUSLY THEY REALLY ARE WRONG! AND THIS BREAKS STACKED WINDOWS IN DOCKED GROUPS BADLY!
+            // SO PLEASE do not remove this code. it wasted a whole 4 hours figuring out why group rectangularity problems were back in cleanup.
+            // return cached bounds if we have them
+            // WE HAVE TO CACHE THEM BECAUSE WINDOWS IN STACKS ARE DEREGISTERED FROM DOCKING. AND DOCKING DOESN'T GET BOUNDS FOR THOSE WHICH IS A PROBLEM FOR STACKS. Do not eliminate this cache.
+            if (this.windowOptions && this.windowOptions.bounds) {
+                cb(null, this.windowOptions.bounds);
+                return resolve({ err: null, data: this.windowOptions.bounds });
+            }
+            if (isNumeric(this.windowOptions.defaultLeft) &&
+                isNumeric(this.windowOptions.defaultTop) &&
+                isNumeric(this.windowOptions.defaultHeight) &&
+                isNumeric(this.windowOptions.defaultWidth)) {
+                const bounds = {
+                    top: this.windowOptions.defaultTop,
+                    left: this.windowOptions.defaultLeft,
+                    height: this.windowOptions.defaultHeight,
+                    width: this.windowOptions.defaultWidth,
+                };
+                bounds.right = bounds.left + bounds.width;
+                bounds.bottom = bounds.top + bounds.height;
+                this.windowOptions.bounds = bounds;
+                cb(null, this.windowOptions.bounds);
+                return resolve({ err: null, data: this.windowOptions.bounds });
+            }
+            // bounds are often different from what is expected by a couple of pixels. use as last resort
+            this.callWebWindowFunction("getBounds", null, (err, bounds) => {
+                cb(err, bounds);
+                return resolve({ err, data: bounds });
+            });
+        };
+        // get bounds from docking if not
+        return new Promise(promiseResolver);
+    }
+    _getOptions(params, cb) {
+        Logger.system.debug("WebWindowWrapper._getOptions", this.name, params);
+        this.callWebWindowFunction("getOptions", null, (err, opts) => {
+            const hasCachedOptions = Object.keys(this.windowOptions).length > 0;
+            const FEAReturnedOptions = Boolean(opts);
+            if (err) {
+                Logger.system.error("getOptions Error retrieving options:", err, params, opts);
+            }
+            else if (FEAReturnedOptions) {
+                // in the else case, we just use whatever was returned from FEA.
+                if (hasCachedOptions) {
+                    opts = Object.assign(opts, this.windowOptions);
+                }
+            }
+            else {
+                // FEA returned nothing. Shouldn't happen, but if it does.... Do we have windowOptions? If so, return them.
+                Logger.system.error("getOptions error. FEA failed to return options but did not send an error. Params:", params);
+                if (hasCachedOptions) {
+                    opts = this.windowOptions;
+                }
+                else {
+                    Logger.system.warn("Setting options to empty. FEA failed to return options and the WebWindowWrapper has no cached windowOptions. Error:", err, "Params:", params, opts);
+                    opts = {};
+                }
+            }
+            cb(err, opts);
+        });
+    }
+    _hide(params, cb = Function.prototype) {
+        Logger.system.debug("WebWindowWrapper._hide", this.name, params);
+        if (typeof params === "function") {
+            cb = params;
+            params = null;
+        }
+        if (params && params.invokedByParent) {
+            this.callWebWindowFunction("updateOptions", { autoShow: false }, () => {
+                this._saveWindowOptions();
+            });
+        }
+        this.callWebWindowFunction("hide", null, cb);
+    }
+    async _show(params, cb) {
+        return new Promise((resolve) => {
+            if (typeof params === "function") {
+                cb = params;
+                params = {};
+            }
+            const previousOpacity = this.windowOptions.opacity || 1;
+            // Calling restore/maximize on a window in a stack (where child windows are hidden) will potentially change tabs
+            // this will show the window, perform the action, then return it to its previous opactiy. This is necessary to keep windows
+            // from changing to an undesired state
+            // shouldMaximize and shouldRestore should not be true at the same time hence the shouldMaximize condition
+            // in the shouldRestore assigment - if shouldMaximize is true then shouldRestore must be false
+            let shouldMaximize = params.shouldMaximize || this.windowState === WINDOWSTATE.MAXIMIZED;
+            let shouldRestore = shouldMaximize ? false : params.shouldRestore || this.windowState === WINDOWSTATE.NORMAL;
+            //KW 20220825: Do not change opacity on should restore as it happens in all non-should maximize cases and causes performance degradation
+            if (shouldMaximize || params.switchedMonitors) {
+                this._setOpacity({ opacity: 0 });
+            }
+            if (shouldMaximize || shouldRestore || params.switchedMonitors) {
+                this.windowState = WINDOWSTATE.TRANSITIONING;
+            }
+            Logger.system.debug("WebWindowWrapper._show", this.name, params);
+            if (params && (params.invokedByParent || params.saveState)) {
+                this.callWebWindowFunction("updateOptions", { autoShow: true }, () => {
+                    this._saveWindowOptions();
+                });
+            }
+            this.callWebWindowFunction("show", null, () => {
+                if (shouldMaximize)
+                    this._maximize();
+                if (shouldRestore)
+                    this._restore();
+                //KW 20220825: Do not change opacity on should restore as it happens in all non-should maximize cases and causes performance degradation
+                if (shouldMaximize || params.switchedMonitors) {
+                    // TPina 2022/05/17
+                    // We need this setTimout here so that the _setOpacity call is removed from the
+                    // execution stack and placed in the callback queue of the event loop, which will wait for the
+                    // below cb and resolve to be run thus displaying the window. Only then we want to set the opacity back.
+                    // This prevents visible flickering of windows (repaints) when the screen scaling is different across monitors.
+                    // For toolbar menus, these windows are invisible and the user can drag the toolbar
+                    // from one monitor to the other and click a menu which will trigger a show and a repaint for the scalling.
+                    setTimeout(async () => {
+                        await this._setOpacity({ opacity: previousOpacity });
+                        cb === null || cb === void 0 ? void 0 : cb(null);
+                        resolve({});
+                    }, 0);
+                }
+                else {
+                    cb === null || cb === void 0 ? void 0 : cb(null);
+                    resolve({});
+                }
+            });
+        });
+    }
+    // TABBING NOTE: Example case below showing how the parent (through the base class) can optionally inject it's behavior. Exactly where and where this is done is still TBD.
+    _minimize(params = {
+        notifyDocking: true,
+        initialLoad: false,
+        invokedByParent: false,
+    }, cb = Function.prototype) {
+        Logger.system.debug("WebWindowWrapper._minimize", this.name, params);
+        const self = this;
+        // Some windows cannot minimize, e.g., (toolbars);
+        if (self.canMinimize === false)
+            return;
+        function doMinimize() {
+            if (self.windowState === WINDOWSTATE.MAXIMIZED) {
+                self.windowState = WINDOWSTATE.MINIMIZED_WAS_MAXIMIZED;
+                self.windowOptions.windowState = WINDOWSTATE.MINIMIZED_WAS_MAXIMIZED;
+            }
+            else if (self.windowState === WINDOWSTATE.NORMAL) {
+                self.windowState = WINDOWSTATE.MINIMIZED_WAS_NORMAL;
+                self.windowOptions.windowState = WINDOWSTATE.MINIMIZED_WAS_NORMAL;
+            }
+            self.finWindow.minimize();
+            // if minimize is being called during the workspace load to restore state, then don't dirty workspace
+            if (!params.initialLoad) {
+                self.windowOptions.windowState = self.windowState;
+                self.saveCompleteWindowState(self.windowOptions);
+            }
+            cb();
+        }
+        RouterClient.query("DockingService.windowMinimized", self.name, () => {
+            doMinimize();
+        });
+    }
+    _maximize(params = { notifyDocking: true, invokedByParent: false }, cb = Function.prototype) {
+        // If windows key is down, user is using hotkeys to maximize and could potentially cancel the maximize event. So delay doing anything until the key is up.
+        if (this.windowsKeyDown) {
+            this.windowsKeyUpHandler = () => {
+                this._maximize(params);
+            };
+            return;
+        }
+        Logger.system.debug("WebWindowWrapper._maximize", this.name, params);
+        // Some windows cannot maximize, e.g., (toolbars);
+        if (this.canMaximize === false)
+            return;
+        if (this.windowState === WINDOWSTATE.MAXIMIZED)
+            return cb();
+        this.finWindow.getBounds((bounds) => {
+            this.cachedBounds = bounds;
+        });
+        this.maximizeHelper(params, cb);
+    }
+    maximizeHelper(params, cb) {
+        super._maximize(params, (err, response) => {
+            if (!err && response.shouldContinue) {
+                this.finWindow.maximize();
+                this.windowState = WINDOWSTATE.MAXIMIZED;
+                this.eventManager.trigger("maximized");
+                // if maximize is being called during the workspace load to restore state, then don't dirty workspace
+                if (!params.initialLoad) {
+                    this.windowOptions.windowState = this.windowState;
+                    this.saveCompleteWindowState(this.windowOptions);
+                }
+            }
+            if (cb)
+                cb();
+        });
+    }
+    _resetBrowserView() {
+        this.finWindow.resetBrowserView();
+    }
+    // TABBING NOTE: Example case below showing how the parent (through the base class) can optionally inject it's behavior.
+    // ** Exactly where and where this for each derived window wrapper is still TBD, but easy to do/tweak. **
+    _restore(params = {}, cb = Function.prototype) {
+        Logger.system.debug("WebWindowWrapper._restore", this.name, params);
+        if (typeof params === "function") {
+            cb = params;
+            params = {};
+        }
+        if (this.windowState === WINDOWSTATE.NORMAL)
+            return cb();
+        this.restoreHelper(params, cb);
+    }
+    restoreHelper(params, cb) {
+        const success = () => {
+            this._getBoundsFromSystem({}, (err, bounds) => {
+                this.eventManager.trigger("restored", {
+                    bounds,
+                    previousState: this.previousState,
+                });
+            });
+            cb();
+        };
+        switch (this.windowState) {
+            case WINDOWSTATE.MINIMIZED_WAS_NORMAL:
+            case WINDOWSTATE.MAXIMIZED:
+                this.finWindow.restore(success, (err1) => console.error(err1));
+                this.windowState = WINDOWSTATE.NORMAL;
+                this.previousState = WINDOWSTATE.MAXIMIZED;
+                this.windowOptions.windowState = this.windowState;
+                this.saveCompleteWindowState(this.windowOptions);
+                break;
+            case WINDOWSTATE.MINIMIZED_WAS_MAXIMIZED:
+                this.finWindow.restore(success, (err1) => console.error(err1));
+                break;
+            case WINDOWSTATE.NORMAL:
+            case WINDOWSTATE.TRANSITIONING:
+                // nothing to do, but we treat it as success, since sometimes docking calls restore() on a window that is already normal
+                success();
+                break;
+            default:
+                Logger.system.error("_restore default case unexpected hit", params);
+        }
+    }
+    /**
+     * Brings a window to front
+     *
+     * @param {*} params
+     * @param {*} cb
+     */
+    async _bringToFront(params, cb = Function.prototype) {
+        if (typeof params === "function") {
+            cb = params;
+            params = {};
+        }
+        Logger.system.debug("WebWindowWrapper._bringToFront", this.name);
+        this.callWebWindowFunction("bringToFront", null, cb);
+    }
+    _isShowing(params, cb) {
+        return new Promise((resolve) => {
+            Logger.system.debug("WebWindowWrapper._isShowing", this.name, params);
+            if (typeof params === "function") {
+                cb = params;
+                params = null;
+            }
+            if (params && (params.invokedByParent || params.saveState)) {
+                this.callWebWindowFunction("updateOptions", { autoShow: true }, () => { });
+            }
+            this.callWebWindowFunction("isShowing", null, (err, result) => {
+                cb === null || cb === void 0 ? void 0 : cb(err, result);
+                resolve({ err, data: result });
+            });
+        });
+    }
+    /**
+     * Sets the window opacity.
+     * NOTE: This function takes the opacity argument as an object
+     * instead of a value - e.g. _setOpacity({opacity: 0.8})
+     *
+     * @param params The opacity value as an object.
+     * @param cb
+     */
+    _setOpacity(params, cb = Function.prototype) {
+        Logger.system.debug("WebWindowWrapper._setOpacity", this.name, params);
+        if (typeof params === "function") {
+            cb = params;
+            params = null;
+        }
+        this.callWebWindowFunction("updateOptions", { opacity: params.opacity, dontFireEvents: true }, () => {
+            if (cb)
+                cb();
+        });
+    }
+    /**
+     * Sets the window to alwaysOnTop.
+     * Operates on a queue such that no alwaysOnTop or bringToFront operations
+     * happen concurrently.
+     *
+     * NOTE: This function takes the alwaysOnTop as an object
+     * instead of a value - e.g. _alwaysOnTop({alwaysOnTop: true})
+     *
+     * @param {*} param
+     * @param {*} cb Zero-argument callback.
+     */
+    async _alwaysOnTop({ alwaysOnTop }, cb = Function.prototype) {
+        Logger.system.debug("WebWindowWrapper._alwaysOnTop", this.name, alwaysOnTop);
+        const { err, data: alwaysOnTopLevel } = await ConfigClient.getValue({
+            field: "finsemble.servicesConfig.docking.alwaysOnTopLevel",
+        });
+        if (err) {
+            Logger.system.error("Error getting config in setAlwaysOnTop:", err);
+        }
+        else if (this.windowOptions.alwaysOnTop !== alwaysOnTop) {
+            /**
+             * Electron AoT default level is "floating" (null). "floating" causes an issue where always on top hides the
+             * window behind all other windows when screen sharing. On Windows we use "normal" to avoid this problem
+             */
+            const defaultLevel = (await isWindows()) ? "normal" : null;
+            this.callWebWindowFunction("updateOptions", { alwaysOnTop, alwaysOnTopLevel: alwaysOnTopLevel ? alwaysOnTopLevel : defaultLevel }, () => {
+                this._saveWindowOptions();
+                cb();
+            });
+        }
+        else {
+            cb();
+        }
+    }
+    setTaskbarIconGroup(taskbarIconGroup, params, cb = Function.prototype) {
+        Logger.system.debug("WebWindowWrapper.setTaskbarIconGroup", this.name, taskbarIconGroup, params);
+        if (typeof params === "function") {
+            cb = params;
+            params = null;
+        }
+        this.callWebWindowFunction("updateOptions", { taskbarIconGroup }, cb);
+    }
+    _saveWindowOptions() {
+        Logger.system.debug("WebWindowWrapper._saveWindowOptions", this.name, this.windowOptions.bounds);
+        if (this.windowOptions.name) {
+            this.saveCompleteWindowState(this.windowOptions);
+        }
+        else {
+            this.setMyOptions(() => {
+                this.saveCompleteWindowState(this.windowOptions);
+            });
+        } // only save if we have the full descriptor
+    }
+    /**
+     * Send the requested reconfiguration data down to the FEA renderer window
+     *
+     * @param {object} params
+     * @return {undefined}
+     */
+    _setIgnoreMouseEvents(params, cb = Function.prototype) {
+        this.callWebWindowFunction("setIgnoreMouseEvents", params);
+        cb();
+    }
+    /**
+     * Open a native file selection dialog on a window
+     *
+     * @param {Object} params - see https://www.electronjs.org/docs/api/dialog
+     * @return {undefined}
+     */
+    _showNativeOpenDialog(params, cb = Function.prototype) {
+        this.callWebWindowFunction("showNativeOpenDialog", params, (err, response) => {
+            cb(err, response);
+        });
+    }
+    /**
+     * Enable/disable resizing
+     *
+     * @param {object} params
+     * @return {undefined}
+     */
+    _setResizable(isResizeable, cb = Function.prototype) {
+        this.callWebWindowFunction("setResizable", isResizeable);
+        cb();
+    }
+    /**
+     * Calls setShape on part or all of window
+     *
+     * @param {object} params. Optional. Takes an array of rectangles.
+     * @return {undefined}
+     */
+    _setShape(params, cb = Function.prototype) {
+        // Wrap the array of rectangles in an object so callWebWindowFunction does not strip out the array
+        let paramsObj = {};
+        if (Array.isArray(params)) {
+            paramsObj = { shapeArray: params };
+        }
+        this.callWebWindowFunction("setShape", paramsObj);
+        cb();
+    }
+    _setBounds(params, cb = Function.prototype) {
+        Logger.system.debug("WebWindowWrapper._setBounds", this.name, params);
+        // if (this.name.includes("Welcome")) console.info(this.name, params.bounds);
+        if (typeof params === "function") {
+            cb = params;
+            params = null;
+        }
+        params = params || {};
+        const { bounds } = params;
+        super._setBounds(params);
+        const ofParams = [bounds.left, bounds.top, bounds.width, bounds.height];
+        // if (!Object.keys(this.windowOptions).length || !this.windowOptions.name) bounds.persistBounds = false;
+        this.mergeBounds(bounds);
+        if (bounds.persistBounds !== false) {
+            this._saveWindowOptions();
+        }
+        Logger.system.verbose("WebWindow.setBounds", ofParams, bounds);
+        this.eventManager.trigger("bounds-changing", Object.assign({}, this.windowOptions.bounds));
+        // this is to make sure we dont fire system change events when we are triggering them.
+        this.requestedBounds = bounds;
+        if ((bounds === null || bounds === void 0 ? void 0 : bounds.internal) !== true) {
+            this.setBoundsFromFinsemble = true;
+            // sometimes the OF setBounds results in no events being fired. So clear this flag just to be safe.
+            if (this.timeout)
+                clearTimeout(this.timeout);
+            this.timeout = setTimeout(() => {
+                this.setBoundsFromFinsemble = false;
+            }, 100);
+            this.callWebWindowFunction("setBounds", ofParams, cb);
+        }
+    }
+    _animate(animateParams, params, cb = Function.prototype) {
+        Logger.system.debug("WebWindowWrapper.animate", this.name, animateParams, params);
+        if (typeof params === "function") {
+            cb = params;
+            params = null;
+        }
+        this.finWindow.animate(animateParams.transitions, animateParams.options, () => {
+            this._getBounds({}, (err, bounds) => {
+                if (animateParams.transitions.size) {
+                    if (animateParams.transitions.size.width) {
+                        bounds.width = animateParams.transitions.size.width;
+                        bounds.right = bounds.left + bounds.width;
+                    }
+                    if (animateParams.transitions.size.height) {
+                        bounds.height = animateParams.transitions.size.height;
+                        bounds.bottom = bounds.top + bounds.height;
+                    }
+                }
+                bounds.persistBounds = params.persistBounds;
+                this._setBounds({ bounds }, cb);
+            });
+        }, (error) => {
+            if (cb)
+                cb(error);
+        });
+    }
+    getMousePosition(params, cb = Function.prototype) {
+        if (typeof params === "function") {
+            cb = params;
+            params = null;
+        }
+        System.getMousePosition(cb);
+    }
+    cacheHandlerForRemoval(event, handler) {
+        if (!this._listeners[event]) {
+            this._listeners[event] = [];
+        }
+        this._listeners[event].push(handler);
+    }
+    _showAt(position, params, cb = Function.prototype) {
+        Logger.system.debug("WebWindowWrapper._showAt", this.name, position, params);
+        if (typeof params === "function") {
+            cb = params;
+            params = null;
+        }
+        this.callWebWindowFunction("showAt", [position.left, position.top, position.force], cb);
+    }
+    throwFailedCloseNotification(failureMessage) {
+        toast("dev", "ONCE-SINCE-STARTUP", "Window close timed out", failureMessage);
+    }
+    _blur(params = {}, cb = Function.prototype) {
+        Logger.system.debug("WebWindowWrapper._blur", this.name, params);
+        this.focused = false;
+        this.callWebWindowFunction("blur", null, cb);
+    }
+    _focus(params = {}, cb = Function.prototype) {
+        Logger.system.debug("WebWindowWrapper._focus", this.name, params);
+        this.focused = true;
+        this.callWebWindowFunction("focus", null, cb);
+    }
+    // Invoked when out-of-bounds closes are detected. This might be an alt+f4, a close from the task bar, etc.
+    // Only happens when electron emits a closed event for the window. When we close our windows, we suppress that event.
+    _systemClosed(params = {}, cb = Function.prototype) {
+        // ignore if already closing
+        if (this.wrapState === "closing") {
+            cb();
+            return;
+        }
+        // If we're closing, we shouldn't call focus/btf/update_options, etc.
+        this.closing = true;
+        const closeParams = {
+            fromSystem: true,
+            removeFromWorkspace: true,
+        };
+        Logger.system.debug("WebWindowWrapper.system closed", this.name, params);
+        super.close(closeParams, async () => {
+            cb();
+        });
+    }
+    _close(params = {}, cb) {
+        return new Promise(async (resolve) => {
+            // merging all params because otherwise the params dont pass properly and remove from workspace fails
+            this.removeEventListener("system-closed", this._systemClosed);
+            Logger.system.debug("WebWindowWrapper._close", this.name, params);
+            if (typeof params === "function") {
+                cb = params;
+                params = {};
+            }
+            // When we receive a close command, we first pass the command to the parent window. The parent window may decide to supersede. In its response, it will then set the flag "shouldContinue" to false if we shouldn't actually perform the close function.
+            const { err, data } = await super._close(params);
+            if (data === null || data === void 0 ? void 0 : data.shouldContinue) {
+                if (params.fromSystem) {
+                    // Just call the callback - window is destroyed already because the system closed it
+                    cb === null || cb === void 0 ? void 0 : cb(null, data);
+                    resolve({ data });
+                }
+                else {
+                    this.finWindow.close(true, () => {
+                        cb === null || cb === void 0 ? void 0 : cb(null, data);
+                        resolve({ data });
+                    }, (err1) => {
+                        if (!params.suppressError) {
+                            Logger.system.error("ERROR CLOSING WINDOW", err1);
+                        }
+                        cb === null || cb === void 0 ? void 0 : cb(null, data);
+                        resolve({ data });
+                    });
+                }
+                RouterClient.transmit(`${this.windowIdentifier.windowName}.close`, params, { suppressWarnings: true });
+            }
+            else {
+                cb === null || cb === void 0 ? void 0 : cb(err);
+                resolve({ err });
+            }
+        });
+    }
+    // Called on destruct so that we don't leave trash in the router or on the window.
+    removeListeners() {
+        const channels = Object.keys(this.RouterHandlers);
+        Logger.system.debug("WRAP Removing Listeners", channels);
+        for (const key in channels) {
+            RouterClient.removeListener(key, this.RouterHandlers[key]);
+        }
+        // These are listeners added directly to the wrapped window.
+        const events = Object.keys(this._listeners);
+        if (events.length) {
+            events.forEach((eventName) => {
+                this._listeners[eventName].forEach((handler) => {
+                    this.removeEventListener(eventName, handler);
+                });
+            });
+        }
+        // Remove all specialty listeners added to the window
+        for (const event in this.addedSystemListeners) {
+            this.finWindow.removeEventListener(event, this.addedSystemListeners[event]);
+        }
+    }
+}
+export default WebWindow;
+//# sourceMappingURL=WebWindowWrapper.js.map