@finsemble/finsemble-ui 7.3.1 → 8.0.0-alpha-3

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

@@ -0,0 +1,1346 @@
+var _a;
+import { RouterClient } from "../../../../clients/routerClient";
+import { ConfigClient } from "../../../../clients/configClient";
+import { Logger } from "../../../../clients/logger";
+import { isEqualIgnoringArrayOrder } from "../../../../common/util";
+import * as util from "../../../../common/util";
+import PrivateEventManager from "../../../../common/events/PrivateEventManager";
+import * as constants from "../../../../common/constants";
+import { System } from "../../../../common/system";
+import { WORKSPACE } from "../../../../common/constants";
+import { DistributedStoreClient } from "../../../../clients/distributedStoreClient";
+import { StorageClient } from "../../../../clients/storageClient";
+import { setWindowState } from "../../../../clients/workspaceClient";
+import uuidv4 from "uuid-random";
+import merge from "deepmerge";
+import clone from "lodash/cloneDeep";
+// The store name for the distributed store which tracks tab titles
+const WINDOW_TAB_TITLE_STORE = "window-tab-title";
+/**
+ * Gets the store which tracks the tab title for a windowName. This is a distributed store shared by all components.
+ *
+ * @returns a Promise which resolves the StoreModel associated with window and tab names
+ */
+const getWindowTabNameStore = async () => {
+    let { data: store } = await DistributedStoreClient.createGlobalStore({ store: WINDOW_TAB_TITLE_STORE });
+    return store;
+};
+export class BaseWindow {
+    constructor(params) {
+        this.name = "Unknown window";
+        this.windowName = "Unknown window";
+        this.eventlistenerHandlerMap = {};
+        // ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+        // Handlers to generate wrapper events from incoming transmits
+        // ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+        this.handleWrapStateChange = (error, response) => {
+            const { state } = response.data;
+            // closed gets emitted from the window. we don't want to emit a window closed event because the wrap state changed to closed.
+            if (state && state !== this.wrapState && state !== "closed") {
+                this.wrapState = state;
+                this.eventManager.trigger(state);
+                this.eventManager.trigger("wrap-state-changed", { state });
+            }
+        };
+        this.types = {};
+        this.guid = uuidv4();
+        this.wrapState = "initializing";
+        this.componentState = {};
+        this.windowState = BaseWindow.WINDOWSTATE.NORMAL;
+        this.type = null;
+        this.windowType = null;
+        this.windowOptions = {};
+        this.bounds = {};
+        this.name;
+        this.enableWindowsAeroSnap = false;
+        // because we were doing this[i]=params[i] in the constructor jscrambler was creating a reference to "this" above _super_, causing everything to break and it made me cry.
+        this.doConstruction(params);
+        this.TITLE_CHANGED_CHANNEL = `Finsemble.${this.name}.titleChanged`;
+        this.componentKey = util.camelCase("activeWorkspace", this.name, this.name);
+        this.windowKey = util.camelCase("activeWorkspace", this.name);
+        BaseWindow.bindFunctions(this);
+        this.wrapStateChangeSubscription = RouterClient.subscribe(`Finsemble.Component.State.${this.name}`, this.handleWrapStateChange);
+        this.eventManager = new PrivateEventManager({
+            name: this.name,
+            sourceType: "Window",
+        });
+        this.finishedMove = true;
+        this.oldState = {};
+    }
+    windowServiceChannelName(channelTopic) {
+        return `WindowService-Request-${channelTopic}`;
+    }
+    eventChannelName(channelTopic) {
+        const name = this.name || this.windowName;
+        return `WindowService-Event-${name}-${channelTopic}`;
+    }
+    _startMove(changeType = 0) {
+        window.aeroMode = false;
+        if (changeType === 0) {
+            this.finishedMove = false;
+        }
+    }
+    _stopMove() {
+        this.finishedMove = true;
+    }
+    doConstruction(params) {
+        if (!params.setWindowType && !params.windowType) {
+            // Default WindowType
+            params.windowType = "WebWindow";
+        }
+        if (params.windowType) {
+            // We need to make a specific kind of Window
+            params.setWindowType = params.windowType;
+            delete params.windowType; // Prevent infinite loop
+            const BW = BaseWindow; // have to do this because we're mutating the class using static functions and all kinds of bad stuff. This tells the typescript compiler that the BaseWindow here is of type any -- basically don't worry about its type.
+            return new BW.types[params.setWindowType](params);
+        } // We are a specific kind of window
+        if (params) {
+            for (const i in params) {
+                this[i] = params[i];
+            }
+        }
+        if (!this.name)
+            this.name = params.windowName;
+        this.windowType = this.setWindowType;
+    }
+    static registerType(name, type /*typeof import("../WindowAbstractions/WebWindowWrapper").default */) {
+        const BW = BaseWindow; // have to do this because we're mutating the class using static functions and all kinds of bad stuff. This tells the typescript compiler that the BaseWindow here is of type any -- basically don't worry about its type.
+        if (!BW.types) {
+            BW.types = {};
+        }
+        BW.types[name] = type;
+    }
+    /**
+     * This is used to bind all functions only in BaseWindow and not in the child wrappers to the wrappers. Without this binding, the value of "this" in the functions is wrong.
+     * @param {} obj
+     */
+    static bindFunctions(obj) {
+        obj.setParent = obj.setParent.bind(obj);
+        obj.getParent = obj.getParent.bind(obj);
+        obj.eventChannelName = obj.eventChannelName.bind(obj);
+        obj.windowServiceChannelName = obj.windowServiceChannelName.bind(obj);
+        obj.setupListeners = obj.setupListeners.bind(obj);
+        obj.onTitleChanged = obj.onTitleChanged.bind(obj);
+        obj.handleWrapRemoveRequest = obj.handleWrapRemoveRequest.bind(obj);
+    }
+    // set up this window's listeners
+    setupListeners(name) {
+        Logger.system.debug("BaseWindow parent change notification setup", name);
+        this.parentSubscribeID = RouterClient.subscribe(`Finsemble.parentChange.${name}`, (err, message) => {
+            if (err) {
+                Logger.system.error("BaseWindow parent change notification error", err);
+            }
+            else {
+                const parentState = message.data || {};
+                if (parentState.type == "Added") {
+                    Logger.system.debug("BaseWindow Parent Notification: window.addedToStack listener", parentState);
+                    this.setParent(parentState.stackedWindowIdentifier);
+                }
+                else if (parentState.type == "Removed") {
+                    Logger.system.debug("BaseWindow Parent Notification: window.removedFromStack listener", parentState);
+                    this.clearParent();
+                }
+                else if (parentState.type === "Exists") {
+                    // Do nothing
+                }
+                else if (parentState.type) {
+                    // if defined but unknown type
+                    Logger.system.error("BaseWindow Parent Notification: unknown type", parentState);
+                }
+            }
+        });
+        this.TITLE_CHANGED_SUBSCRIPTION = RouterClient.subscribe(this.TITLE_CHANGED_CHANNEL, this.onTitleChanged);
+    }
+    /**
+     * Event handler which is invoked when the title for a window changes.
+     *
+     * Title change events look like:
+     *   title: string		- the new title
+     *   windowName: string	- the name of the window which changed
+     *
+     * @param error the error from the event
+     * @param response the event response
+     */
+    async onTitleChanged(error, response) {
+        var _b, _c, _d;
+        if (typeof ((_b = response.data) === null || _b === void 0 ? void 0 : _b.title) !== "string" && typeof response.data.title !== "number") {
+            return;
+        }
+        if (this._updateOptions) {
+            this._updateOptions({ title: response.data.title });
+        }
+        // The window/tab store should be updated (in order to keep tab titles up to date)
+        if (((_c = response.data) === null || _c === void 0 ? void 0 : _c.windowName) && ((_d = response.data) === null || _d === void 0 ? void 0 : _d.title)) {
+            Logger.debug(`Component window "${response.data.windowName}" is changing title to "${response.data.title}"`);
+            // Setting the store value is asynchronous
+            try {
+                // Get the store for window/tab names
+                const store = await getWindowTabNameStore();
+                if (!store) {
+                    // This is not critical, but tab titles may be stale
+                    Logger.warn("Error setting tab title: the store was not found");
+                    return;
+                }
+                // Setting the store value will trigger listeners (tab title components)
+                await store.setValue({ field: response.data.windowName, value: response.data.title });
+            }
+            catch (err) {
+                // This is unfortunate but not critical; when an error is reached here the WORST CASE is that a tab will render with the not-current title
+                Logger.system.warn(`Error saving window "${response.data.windowName}" tab name "${response.data.title}" to store "${WINDOW_TAB_TITLE_STORE}"`, err);
+            }
+            finally {
+                // Although this is not used within the core code to manage titles, this is a "public" event that must be triggered
+                this.eventManager.trigger("title-changed", {
+                    name: this.name,
+                    title: response.data.title,
+                });
+            }
+        }
+    }
+    static async getInstanceStandardized(params) {
+        try {
+            const result = await BaseWindow.getInstance(params);
+            return { data: result.wrap };
+        }
+        catch (err) {
+            return { err };
+        }
+    }
+    static getInstance(params, cb) {
+        return new Promise(async (resolve, reject) => {
+            var _b, _c;
+            const myName = System.Window.getCurrent().name;
+            const name = (_b = params === null || params === void 0 ? void 0 : params.name) !== null && _b !== void 0 ? _b : params === null || params === void 0 ? void 0 : params.windowName;
+            const { waitForReady, uuid, windowType } = params;
+            if (!name) {
+                const error = `"name" is a required parameter`;
+                cb === null || cb === void 0 ? void 0 : cb(error);
+                reject(error);
+                return;
+            }
+            params.windowName = name; // just in case
+            if (waitForReady !== false) {
+                Logger.system.debug("WRAP LIFECYCLE:WAIT FOR READY", name);
+                await BaseWindow._windowReady(name); // wait to insure the window is fully ready in the window service
+                Logger.system.debug("WRAP LIFECYCLE:WAIT DONE -- READY", name);
+            }
+            // Return early if we already have the wrap cached.
+            if (BaseWindow.cache[name]) {
+                Logger.system.debug("WRAP LIFECYCLE:", name, "Window found in the cache, returning without going to the Launcher");
+                const wrap = BaseWindow.cache[name];
+                resolve({ wrap });
+                cb === null || cb === void 0 ? void 0 : cb(null, wrap);
+                return;
+            }
+            // If we already have all of the information, just call createWrap.
+            if (uuid && name) {
+                const windowIdentifier = {
+                    uuid,
+                    name,
+                    windowName: name,
+                    windowType,
+                };
+                Logger.system.debug("WRAP LIFECYCLE:", name, "All information for wrap passed in, creating wrap locally");
+                const { wrap } = await BaseWindow._createWrap(Object.assign(Object.assign({}, params), { windowIdentifier: (_c = params.windowIdentifier) !== null && _c !== void 0 ? _c : windowIdentifier }));
+                resolve({ wrap });
+                cb === null || cb === void 0 ? void 0 : cb(null, wrap);
+                return;
+            }
+            const wrapFromServer = async (err, response) => {
+                var _b;
+                if (err || !response.data) {
+                    Logger.system.error(err);
+                    reject(err);
+                    cb === null || cb === void 0 ? void 0 : cb(err);
+                    return;
+                }
+                if (BaseWindow.cache[name]) {
+                    const wrap = BaseWindow.cache[name];
+                    Logger.system.debug("WRAP LIFECYCLE:", name, "Information received from launcher, but wrap exists in cache. Returning cached wrap.");
+                    resolve({ wrap });
+                    cb === null || cb === void 0 ? void 0 : cb(null, wrap);
+                    return;
+                }
+                const { identifier } = response.data;
+                Logger.system.debug("WRAP LIFECYCLE:", name, "Information received from launcher. Creating wrap.");
+                const { wrap } = await BaseWindow._createWrap(Object.assign(Object.assign({}, params), { retrievedIdentifier: Object.assign(Object.assign({}, identifier), { name: (_b = identifier.windowName) !== null && _b !== void 0 ? _b : identifier.name }) }));
+                resolve({ wrap });
+                cb === null || cb === void 0 ? void 0 : cb(null, wrap);
+            };
+            // All we have is a windowName. we send a request to the launcher for more information so that we can construct the proper object. This also the place where
+            RouterClient.query("WindowService-Request-getWindowIdentifier", { windowName: params.name, requester: myName }, wrapFromServer);
+        });
+    }
+    static _createWrap(params) {
+        return new Promise((resolve) => {
+            const identifier = params.retrievedIdentifier || params.windowIdentifier;
+            // Top level keeps important info (e.g., uuid, name, windowType).
+            let paramsForWindow = Object.assign({}, identifier);
+            if ((!params.setWindowType && !identifier.windowType) || identifier.windowType === "WebApplication") {
+                // Default WindowType
+                identifier.windowType = "WebWindow";
+            }
+            // Also pull in anything that was passed into the constructor (e.g., windowDescriptor, etc);
+            paramsForWindow = Object.assign(paramsForWindow, params);
+            paramsForWindow = Object.assign(paramsForWindow, identifier);
+            paramsForWindow.setWindowType = paramsForWindow.windowType;
+            delete paramsForWindow.windowType; // Prevent infinite loop
+            Logger.system.debug("WRAP LIFECYCLE: Placing wrap into the local cache.", identifier.windowName);
+            const BW = BaseWindow; // have to do this because we're mutating the class using static functions.
+            if (BaseWindow.cache.hasOwnProperty(identifier.windowName)) {
+                Logger.system.error("DUPLICATE WRAPPER for", identifier.windowName);
+            }
+            else {
+                BaseWindow.cache[identifier.windowName] = new BW.types[paramsForWindow.setWindowType](paramsForWindow);
+            }
+            let wrap = BaseWindow.cache[identifier.windowName];
+            wrap.windowType = identifier.windowType;
+            wrap.identifier = identifier;
+            wrap.setupListeners(identifier.windowName);
+            resolve({ wrap });
+        });
+    }
+    static _getRemoveWrapChannel(name) {
+        return `${System.Window.getCurrent().name}.removeWrap.${name}`;
+    }
+    handleWrapRemoveRequest() {
+        // wrap is the Web or stacked window. if the removeListeners function exists, we remove all listeners we added during the lifecycle of that window wrapper.
+        if (this.removeListeners) {
+            this.removeListeners();
+        }
+        this.eventManager.cleanup();
+        for (const event in this.eventlistenerHandlerMap) {
+            for (let i = 0; i < this.eventlistenerHandlerMap[event].length; i++) {
+                this.eventlistenerHandlerMap[event][i].interceptor.removeAllListeners();
+            }
+        }
+        this.eventManager.cleanup();
+        Logger.system.debug("WRAP CLOSE. Deleting cached wrap.");
+        delete BaseWindow.cache[this.name];
+        this.cleanupRouter();
+    }
+    cleanupRouter() {
+        const REMOVE_WRAP_CHANNEL = BaseWindow._getRemoveWrapChannel(this.name);
+        RouterClient.removeResponder(REMOVE_WRAP_CHANNEL);
+        if (this.TITLE_CHANGED_SUBSCRIPTION) {
+            RouterClient.unsubscribe(this.TITLE_CHANGED_SUBSCRIPTION);
+        }
+        RouterClient.unsubscribe(this.wrapStateChangeSubscription);
+    }
+    onReady(cb) {
+        return new Promise((resolve) => {
+            if (this.wrapState === "ready") {
+                cb === null || cb === void 0 ? void 0 : cb();
+                resolve();
+            }
+            else {
+                this.addEventListener("ready", () => {
+                    cb === null || cb === void 0 ? void 0 : cb();
+                    resolve();
+                });
+            }
+        });
+    }
+    // ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+    // Common template for window-function requests to window service -- see public functions
+    // ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+    /**
+     * @param {string} methodName method name (e.g. "minimize", "maximize")
+     * @param {object} params
+     * @param {function=} callback
+     * @memberof FinsembleWindow
+     * @private
+     */
+    queryWindowService(methodName, params, callback = Function.prototype) {
+        if (typeof params === "function") {
+            callback = params;
+            params = {};
+        }
+        params = params || {};
+        params.windowIdentifier = this.identifier; // add this window's identifier
+        Logger.system.debug("FinsembleWindow.queryWindowService", this.windowServiceChannelName(methodName), params);
+        console.debug("FinsembleWindow.queryWindowService", this, this.windowServiceChannelName(methodName), params);
+        let responseData = null;
+        RouterClient.query(this.windowServiceChannelName(methodName), params, (err, queryResponseMessage) => {
+            if (err) {
+                Logger.system.warn(`WindowService.${methodName}: failed`, err);
+                console.debug(`WindowService.${methodName}: failed`, err);
+            }
+            else {
+                responseData = queryResponseMessage.data;
+                Logger.system.debug(`${this.windowServiceChannelName(methodName)} successful`, responseData);
+                console.debug(`${this.windowServiceChannelName(methodName)} successful`, responseData);
+            }
+            if (callback)
+                callback(err, responseData);
+        });
+    }
+    // ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+    // Core Window Functions: can be invoked by any service or component.  Most are sent to the WindowService to be executed.
+    // ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+    addEventListener(eventName, handler) {
+        this.eventManager.addEventListener(eventName, handler);
+    }
+    removeEventListener(eventName, handler) {
+        return this.eventManager.removeEventListener(eventName, handler);
+    }
+    /**
+     *Register a window with docking. Use this if you don't want to use the full initialization function
+     *
+     * @param {Object} params - can be anything that is passed to docking for window registration.
+     * @param {Function} cb
+     * @memberof FSBLWindow
+     */
+    registerWithDocking(params, cb) {
+        RouterClient.query("DockingService.registerWindow", {
+            type: this.type,
+            windowType: this.windowType,
+            windowMsg: params,
+            name: this.windowName,
+        }, cb);
+    }
+    /**
+     *Unregister a window with docking
+     *
+     * @memberof FSBLWindow
+     */
+    unRegisterWithDocking() {
+        RouterClient.transmit("DockingService.deregisterWindow", {
+            name: this.windowName,
+        });
+    }
+    /**
+     *This is if we want to handle the full register/ready state inside of the window
+     register with docking
+     send the message to launcher saying that component is ready
+     *
+     * @memberof FSBLWindow
+     */
+    initializeWindow(params) {
+        this.registerWithDocking(params, () => {
+            RouterClient.publish(`Finsemble.${this.windowName}.componentReady`, {
+                // signal workspace and launcher service that component is ready
+                name: this.windowName,
+            });
+        });
+    }
+    wrapReady() {
+        RouterClient.publish(`Finsemble.${this.windowName}.wrapReady`, {
+            name: this.windowName,
+            state: "open",
+        });
+    }
+    // ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+    // Core Private Window Functions: generally should only be directly invoked by the WindowService (an exception is _close)
+    // Note: These private window functions can also optionally be invoked from the derived class definition.  See WebWindowWrapper _minimize for example.
+    // ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+    // Private base window function optionally invoked by derived class (e.g. WebWindowWrapper, FinsembleNativeWindow).  All base function follow same template.
+    // If parent defined then let parent decide appropriate functionality, including passing result back to caller specifying what to do next.
+    _minimize(params, cb = Function.prototype) {
+        Logger.system.debug("BaseWindow._minimize", params);
+        params = params || {};
+        if (!params.invokedByParent && this.parentWindow) {
+            // if parent defined and not circular loop, invoke parent functionality.  Parent result passed back to caller
+            params.windowIdentifier = this.identifier; // add this window's identifier for parent invocation
+            this.parentWindow._minimize(params, (err, result) => {
+                Logger.system.debug("BaseWindow._minimize parent", result);
+                cb(err, { shouldContinue: false });
+            });
+        }
+        else {
+            cb(null, { shouldContinue: true });
+        }
+    }
+    // Private base window function optionally invoked by derived class (e.g. WebWindowWrapper, FinsembleNativeWindow). All base function follow same template.
+    // If parent defined then let parent decide appropriate functionality, including passing result back to caller specifying what to do next.
+    _maximize(params, cb = Function.prototype) {
+        Logger.system.debug("BaseWindow._maximize", params);
+        cb(null, { shouldContinue: true });
+    }
+    // Private base window function optionally invoked by derived class (e.g. WebWindowWrapper, FinsembleNativeWindow). All base function follow same template.
+    // If parent defined then let parent decide appropriate functionality, including passing result back to caller specifying what to do next.
+    _restore(params, cb) {
+        return new Promise((resolve) => {
+            Logger.system.debug("BaseWindow._restore", params);
+            params = params || {};
+            if (!params.invokedByParent && this.parentWindow) {
+                // if parent defined and not circular loop, invoke parent functionality.  Parent result passed back to caller
+                params.windowIdentifier = this.identifier; // add this window's identifier for parent invocation
+                this.parentWindow._restore(params, (err, result) => {
+                    Logger.system.debug("BaseWindow._restore parent", result);
+                    cb === null || cb === void 0 ? void 0 : cb(err, { shouldContinue: false });
+                    resolve({ err, data: { shouldContinue: false } });
+                });
+            }
+            else {
+                cb === null || cb === void 0 ? void 0 : cb(null, { shouldContinue: true });
+                resolve({ data: { shouldContinue: true } });
+            }
+        });
+    }
+    _blur(params, cb = Function.prototype) {
+        Logger.system.debug("BaseWindow._blur", params);
+        params = params || {};
+        if (!params.invokedByParent && this.parentWindow) {
+            // if parent defined and not circular loop, invoke parent functionality.  Parent result passed back to caller
+            params.windowIdentifier = this.identifier; // add this window's identifier for parent invocation
+            this.parentWindow._blur(params, (err, result) => {
+                Logger.system.debug("BaseWindow._blur parent", result);
+                cb(err, { shouldContinue: false });
+            });
+        }
+        else {
+            cb(null, { shouldContinue: true });
+        }
+    }
+    // Private base window function optionally invoked by derived class (e.g. WebWindowWrapper, FinsembleNativeWindow). All base function follow same template.
+    // If parent defined then let parent decide appropriate functionality, including passing result back to caller specifying what to do next.
+    _focus(params, cb = Function.prototype) {
+        Logger.system.debug("BaseWindow._focus", params);
+        params = params || {};
+        if (!params.invokedByParent && this.parentWindow) {
+            // if parent defined and not circular loop, invoke parent functionality.  Parent result passed back to caller
+            params.windowIdentifier = this.identifier; // add this window's identifier for parent invocation
+            this.parentWindow._focus(params, (err, result) => {
+                Logger.system.debug("BaseWindow._focus parent", result);
+                cb(err, { shouldContinue: false });
+            });
+        }
+        else {
+            cb(null, { shouldContinue: true });
+        }
+    }
+    // Private base window function optionally invoked by derived class (e.g. WebWindowWrapper, FinsembleNativeWindow). All base function follow same template.
+    // If parent defined then let parent decide appropriate functionality, including passing result back to caller specifying what to do next.
+    _bringToFront(params, cb = Function.prototype) {
+        Logger.system.debug("BaseWindow._bringToFront", params);
+        params = params || {};
+        if (!params.invokedByParent && this.parentWindow) {
+            // if parent defined and not circular loop, invoke parent functionality.  Parent result passed back to caller
+            params.windowIdentifier = this.identifier; // add this window's identifier for parent invocation
+            this.parentWindow._bringToFront(params, (err, result) => {
+                Logger.system.debug("BaseWindow._bringToFront parent", result);
+                cb(err, { shouldContinue: false });
+            });
+        }
+        else {
+            cb(null, { shouldContinue: true });
+        }
+    }
+    // Private base window function optionally invoked by derived class (e.g. WebWindowWrapper, FinsembleNativeWindow). All base function follow same template.
+    // If parent defined then let parent decide appropriate functionality, including passing result back to caller specifying what to do next.
+    _isShowing(params, cb = Function.prototype) {
+        Logger.system.debug("BaseWindow._isShowing", params);
+        params = params || {};
+        if (!params.invokedByParent && this.parentWindow) {
+            // if parent defined and not circular loop, invoke parent functionality.  Parent result passed back to caller
+            params.windowIdentifier = this.identifier; // add this window's identifier for parent invocation
+            this.parentWindow._isShowing(params, (err, result) => {
+                Logger.system.debug("BaseWindow._isShowing parent", result);
+                cb(err, { shouldContinue: false });
+            });
+        }
+        else {
+            cb(null, { shouldContinue: true });
+        }
+    }
+    disableFrame(cb) {
+        cb === null || cb === void 0 ? void 0 : cb();
+    }
+    // Private base window function optionally invoked by derived class (e.g. WebWindowWrapper, FinsembleNativeWindow). All base function follow same template.
+    // If parent defined then let parent decide appropriate functionality, including passing result back to caller specifying what to do next.
+    _setBounds(params, cb = Function.prototype) {
+        Logger.system.verbose("BaseWindow._setBounds", params);
+        params = params || {};
+        const { bounds } = params;
+        this.mergeBounds(bounds); // This happens twice...remove this
+        if (!params.invokedByParent && this.parentWindow) {
+            // if parent defined and not circular loop, invoke parent functionality.  Parent result passed back to caller
+            params.windowIdentifier = this.identifier; // add this window's identifier for parent invocation
+            this.parentWindow._setBounds(params, (err, result) => {
+                Logger.system.verbose("BaseWindow._setBounds parent", result);
+                cb(err, { shouldContinue: false });
+            });
+        }
+        else {
+            cb(null, { shouldContinue: true });
+        }
+    }
+    // Private base window function optionally invoked by derived class (e.g. WebWindowWrapper, FinsembleNativeWindow). All base function follow same template.
+    // If parent defined then let parent decide appropriate functionality, including passing result back to caller specifying what to do next.
+    // First parameter, "params" is pass-by-references (its values can change)
+    _getBounds(params, cb) {
+        return new Promise((resolve) => {
+            Logger.system.verbose("BaseWindow._getBounds", params);
+            params = params || {};
+            if (!params.invokedByParent && this.parentWindow) {
+                // if parent defined and not circular loop, invoke parent functionality.  Parent result passed back to caller
+                params.windowIdentifier = this.identifier; // add this window's identifier for parent invocation
+                this.parentWindow._getBounds(params, (err, bounds) => {
+                    Logger.system.verbose("BaseWindow._getBounds parent", bounds);
+                    cb(err, bounds); // shouldContinue not defined in return value, but implicitly false
+                    resolve({ err, data: bounds });
+                });
+            }
+            else {
+                cb(null, { shouldContinue: true }); // if should continue, bounds will be calculated by derived class
+                resolve({ data: { shouldContinue: true } });
+            }
+        });
+    }
+    // Private base window function optionally invoked by derived class (e.g. FinsembleNativeWindow). All base function follow same template.
+    // If parent defined then let parent decide appropriate functionality, including passing result back to caller specifying what to do next.
+    _getBoundsFromSystem(params, cb) {
+        Logger.system.debug("BaseWindow._getBoundsFromSystem", params);
+        params = params || {};
+        if (!params.invokedByParent && this.parentWindow) {
+            // if parent defined and not circular loop, invoke parent functionality.  Parent result passed back to caller
+            params.windowIdentifier = this.identifier; // add this window's identifier for parent invocation
+            this.parentWindow._getBoundsFromSystem(params, (err, bounds) => {
+                Logger.system.verbose("BaseWindow._getBoundsFromSystem parent", bounds);
+                cb(err, bounds); // shouldContinue not defined in return value, but implicitly false
+            });
+        }
+        else {
+            cb(null, { shouldContinue: true }); // if should continue, bounds will be calculated by derived class
+        }
+    }
+    // Private base window function optionally invoked by derived class (e.g. WebWindowWrapper, FinsembleNativeWindow). All base function follow same template.
+    // If parent defined then let parent decide appropriate functionality, including passing result back to caller specifying what to do next.
+    _updateOptions(params, cb = Function.prototype) {
+        // @todo: Couldn't get title to update when calling `finsembleWindow.updateOptions({title: "Hello World"})` on a random window. Is title really supported here?
+        Logger.system.debug("BaseWindow._updateOptions", params);
+        params = params || {};
+        if (!params.invokedByParent && this.parentWindow) {
+            // if parent defined and not circular loop, invoke parent functionality.  Parent result passed back to caller
+            params.windowIdentifier = this.identifier; // add this window's identifier for parent invocation
+            this.parentWindow._updateOptions(params, (err, result) => {
+                Logger.system.debug("BaseWindow._updateOptions parent", result);
+                cb(err, { shouldContinue: false });
+            });
+        }
+        else {
+            cb(null, { shouldContinue: true });
+        }
+    }
+    // Private base window function optionally invoked by derived class (e.g. WebWindowWrapper, FinsembleNativeWindow). All base function follow same template.
+    // If parent defined then let parent decide appropriate functionality, including passing result back to caller specifying what to do next.
+    _hide(params, cb = Function.prototype) {
+        // Note: passed-through params.windowIdentifier is either not used or overwritten. Passing through the value will cause it to be dropped if not side-effect'd.
+        Logger.system.debug("BaseWindow._hide", params);
+        params = params || {};
+        if (!params.invokedByParent && this.parentWindow) {
+            // if parent defined and not circular loop, invoke parent functionality.  Parent result passed back to caller
+            params.windowIdentifier = this.identifier; // add this window's identifier for parent invocation
+            this.parentWindow._hide(params, (err, result) => {
+                Logger.system.debug("BaseWindow._hide parent", result);
+                cb(err, { shouldContinue: false });
+            });
+        }
+        else {
+            cb(null, { shouldContinue: true });
+        }
+    }
+    // Private base window function optionally invoked by derived class (e.g. WebWindowWrapper, FinsembleNativeWindow). All base function follow same template.
+    // If parent defined then let parent decide appropriate functionality, including passing result back to caller specifying what to do next.
+    async _show(params, cb) {
+        Logger.system.debug("BaseWindow._show", params);
+        params = params || {};
+        if (!params.invokedByParent && this.parentWindow) {
+            // if parent defined and not circular loop, invoke parent functionality.  Parent result passed back to caller
+            params.windowIdentifier = this.identifier; // add this window's identifier for parent invocation
+            const { err, data } = await this.parentWindow._show(params);
+            Logger.system.debug("BaseWindow._show parent", data);
+            cb === null || cb === void 0 ? void 0 : cb(err, { shouldContinue: false });
+            return { err, data: { shouldContinue: false } };
+        }
+        else {
+            cb === null || cb === void 0 ? void 0 : cb(null, { shouldContinue: true });
+            return { data: { shouldContinue: true } };
+        }
+    }
+    _showAt(params, cb = Function.prototype) {
+        Logger.system.debug("BaseWindow._showAt", params);
+        params = params || {};
+        if (!params.invokedByParent && this.parentWindow) {
+            // if parent defined and not circular loop, invoke parent functionality.  Parent result passed back to caller
+            params.windowIdentifier = this.identifier; // add this window's identifier for parent invocation
+            this.parentWindow._showAt(params, (err, result) => {
+                Logger.system.debug("BaseWindow._showAt parent", result);
+                cb(err, { shouldContinue: false });
+            });
+        }
+        else {
+            cb(null, { shouldContinue: true });
+        }
+    }
+    // Private base window function optionally invoked by derived class (e.g. WebWindowWrapper, FinsembleNativeWindow). All base function follow same template.
+    // If parent defined then let parent decide appropriate functionality, including passing result back to caller specifying what to do next.
+    /**
+     * Close
+     * @param params
+     * @param params.fromSystem Bool. If true, event bubbled up because of an alt+f4, task manager, etc. Something closed the window that wasn't Finsemble.
+     * @param cb
+     */
+    _close(params = {}, cb) {
+        return new Promise((resolve) => {
+            Logger.system.debug("WRAP CLOSE. BaseWindow._close", this.name, params);
+            const { parentWindow } = this;
+            if (params.fromSystem) {
+                // If the close is initiated from a system close (i.e. close from the taskbar or using the hotkey) and we're closing a stacked window, close the entire stacked window.
+                // Except for when a native window is part of that stack and the system close is initiated on the native window, in which case we only close the native window instead of the whole stack.
+                // fromSystem is only set by the WebWindowWrapper in _systemClosed. It is not set by other kinds of windows.
+                if (parentWindow && parentWindow.componentType.toLowerCase() === "stackedwindow") {
+                    params = {};
+                    params.removeFromWorkspace = true;
+                    params.fromSystem = true;
+                    params.stackedWindowIdentifier = parentWindow.identifier;
+                    parentWindow.close(params, (err, result) => {
+                        Logger.system.debug("BaseWindow.close stacked window", result);
+                        cb === null || cb === void 0 ? void 0 : cb(err, { shouldContinue: false });
+                        resolve({ err, data: { shouldContinue: false } });
+                    });
+                }
+                else {
+                    cb === null || cb === void 0 ? void 0 : cb(null, { shouldContinue: true });
+                    resolve({ data: { shouldContinue: true } });
+                }
+            }
+            else if (!params.invokedByParent && !params.ignoreParent && parentWindow) {
+                // if parent defined and not circular loop, invoke parent functionality.  Parent result passed back to caller
+                params.windowIdentifier = this.identifier; // add this window's identifier for parent invocation
+                params.noDocking = true; // when removing from stacked window don't register child with docking
+                parentWindow._removeWindow(params, (err, result) => {
+                    Logger.system.debug("BaseWindow._close parent", result);
+                    cb === null || cb === void 0 ? void 0 : cb(err, { shouldContinue: true });
+                    resolve({ err, data: { shouldContinue: true } });
+                });
+            }
+            else {
+                cb === null || cb === void 0 ? void 0 : cb(null, { shouldContinue: true });
+                resolve({ data: { shouldContinue: true } });
+            }
+        });
+    }
+    // Private base window function optionally invoked by derived class (e.g. WebWindowWrapper, FinsembleNativeWindow). All base function follow same template.
+    // If parent defined then let parent decide appropriate functionality, including passing result back to caller specifying what to do next.
+    _alwaysOnTop(params, cb = Function.prototype) {
+        Logger.system.debug("BaseWindow._alwaysOnTop", params);
+        params = params || {};
+        if (!params.invokedByParent && this.parentWindow) {
+            // if parent defined and not circular loop, invoke parent functionality.  Parent result passed back to caller
+            params.windowIdentifier = this.identifier; // add this window's identifier for parent invocation
+            this.parentWindow._alwaysOnTop(params, (err, result) => {
+                Logger.system.debug("BaseWindow._alwaysOnTop parent", result);
+                cb(err, { shouldContinue: false });
+            });
+        }
+        else {
+            cb(null, { shouldContinue: true });
+        }
+    }
+    /**
+     * Returns the alwaysOnTop state for the window.
+     * @param params This parameter is ignored.
+     * @param cb A callback accepting two arguments: an error object (which is always `null` for this method), and a boolean value representing the alwaysOnTop state.
+     * Disable eslint below because params is undefined, but we don't want to refactor the other calls to expect the 1st param to equal the callback.
+     */
+    _isAlwaysOnTop(params = {}, cb = Function.prototype) {
+        cb(null, Boolean(this.windowOptions.alwaysOnTop));
+        return Boolean(this.windowOptions.alwaysOnTop);
+    }
+    // Private base window function optionally invoked by derived class (e.g. WebWindowWrapper, FinsembleNativeWindow). All base function follow same template.
+    // If parent defined then let parent decide appropriate functionality, including passing result back to caller specifying what to do next.
+    _setOpacity(params, cb = Function.prototype) {
+        Logger.system.debug("BaseWindow._setOpacity", params);
+        params = params || {};
+        if (!params.invokedByParent && this.parentWindow) {
+            // if parent defined and not circular loop, invoke parent functionality.  Parent result passed back to caller
+            params.windowIdentifier = this.identifier; // add this window's identifier for parent invocation
+            this.parentWindow._setOpacity(params, (err, result) => {
+                Logger.system.debug("BaseWindow._setOpacity parent", result);
+                cb(err, { shouldContinue: false });
+            });
+        }
+        else {
+            cb(null, { shouldContinue: true });
+        }
+    }
+    // Private base window function optionally invoked by derived class (e.g. WebWindowWrapper, FinsembleNativeWindow). All base function follow same template.
+    // If parent defined then let parent decide appropriate functionality, including passing result back to caller specifying what to do next.
+    _saveWindowOptions(params, cb = Function.prototype) {
+        Logger.system.debug("BaseWindow._saveWindowOptions", params);
+        params = params || {};
+        if (!params.invokedByParent && this.parentWindow) {
+            // if parent defined and not circular loop, invoke parent functionality.  Parent result passed back to caller
+            params.windowIdentifier = this.identifier; // add this window's identifier for parent invocation
+            this.parentWindow._saveWindowOptions(params, (err, result) => {
+                Logger.system.debug("BaseWindow._saveWindowOptions parent", result);
+                cb(err, { shouldContinue: true });
+            });
+        }
+        else {
+            cb(null, { shouldContinue: true });
+        }
+    }
+    _getOptions(_params, cb = Function.prototype) {
+        return cb(null, {});
+    }
+    // ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+    // Other Baseclass Function: These are common functions shared across derived classes
+    // ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+    /**
+     * Invoked to indicate an operation (e.g. dragging out of tab region) has started. This signals the Docking service to start tracking the mouse location and invoking tiling behavior as needed. Typically inherited (base function only).
+     * @param {object} params for future use
+     *
+     * @example
+     *	// dragging tab example using tracking and group
+     * 	BaseWindow.startTabTileMonitoring();
+     *	// if dragging tab is in a group, then remove it given tracking results will decide what to do with the window
+     * 	BaseWindow.Group.getGroupID(this.identifier, function (err, tileGroupId) {
+     * 		if (!err) { // if no error then must be in a tile group
+     *			self.Group.removeWindow(this.identifier);
+     *		}
+     *	});
+     */
+    startTabTileMonitoring(params) {
+        Logger.system.debug("BaseWindow.startTabTileMonitoring", params);
+        RouterClient.transmit("TabTile.startTabTile", { params });
+    }
+    /**
+     * Invoked by client originating a dragStart that it has has ended. Typically inherited (base function only).
+     * @param {object} params for future use
+     * @param {function=} callback option callback that support overriding default behavior
+     *
+     * 	BaseWindow.stopTabTileMonitoring(params, function(err, results, defaultTabTileAction) {
+     * 		// . . . custom code goes here . . .
+     *		defaultTabTileAction(results); // now take default action or call your own function instead
+     * 	});
+     *
+     */
+    stopTabTileMonitoring(params, callback) {
+        Logger.system.debug("BaseWindow.stopTabTileMonitoring", params);
+        RouterClient.query("TabTile.stopTabTile", { params }, function (err, queryResponseMessage) {
+            if (err) {
+                Logger.system.warn("TabTile.stopTabTile: query failed", err);
+            }
+            else {
+                Logger.system.debug("TabTile.stopTabTile results", queryResponseMessage.data);
+            }
+            const stopTabTileResults = queryResponseMessage.data;
+            if (callback) {
+                callback(err, stopTabTileResults, this.defaultStopTrackingAction);
+            }
+            else {
+                this.defaultTabTileAction(stopTabTileResults);
+            }
+        });
+    }
+    /**
+     * Defines default TabTile action for stopTabTileMonitoring.  May be overwritten by client -- see example in stopTabTileMonitoring. Typically inherited (base function only).
+     *
+     * @param {any} stopTabTileResults
+     * @memberof BaseWindow
+     *
+     * @private
+     */
+    defaultTabTileAction(stopTabTileResults) {
+        const self = this;
+        Logger.system.debug("BaseWindow.defaultTabTileAction", stopTabTileResults);
+        switch (stopTabTileResults.stoppedLocation) {
+            case "OutsideWindow":
+                // move window to drop location (since for now assuming only single-tabbed windows)
+                break;
+            case "TabSection":
+                // WindowStack.addWindowToStack(callback) // for when we get to tabbing
+                break;
+            case "InsideWindow":
+                if (stopTabTileResults.tileGroupId) {
+                    // if dropped in an existing tile group (which might be the same it was dragging from)
+                    self.Group.addWindow(this.identifier, stopTabTileResults.tileGroupId, stopTabTileResults.dropCoordinates);
+                }
+                else {
+                    // if dropped in a separate window outside a tile group
+                    self.Group.createGroup(function (newGroupId) {
+                        // add dragging window to new tile group, but specify the dropped on window as the starting window in the tile group
+                        self.Group.addWindow(this.identifier, newGroupId, stopTabTileResults.dropCoordinates, {
+                            startingWindowIdentifier: stopTabTileResults.droppedOnWindowIdentifier,
+                        });
+                    });
+                }
+                break;
+            default:
+                Logger.system.error("stopTracking returned an unknown stoppedLocation result", stopTabTileResults);
+        }
+    }
+    mergeBounds(bounds) {
+        if (!bounds || !Number.isInteger(bounds.top)) {
+            console.error("Invalid bounds", bounds);
+            Logger.system.warn("BaseWindow.mergeBounds Invalid bounds", "bounds=", bounds);
+            return;
+        }
+        const newBounds = {
+            top: Math.round(bounds.top),
+            left: Math.round(bounds.left),
+            width: Math.round(bounds.width),
+            height: Math.round(bounds.height),
+        };
+        newBounds.bottom = newBounds.top + newBounds.height;
+        newBounds.right = newBounds.left + newBounds.width;
+        const defaultBounds = {
+            defaultLeft: newBounds.left,
+            defaultWidth: newBounds.width,
+            defaultTop: newBounds.top,
+            defaultHeight: newBounds.height,
+        };
+        Object.assign(this.windowOptions, newBounds);
+        Object.assign(this.windowOptions, defaultBounds);
+        this.windowOptions.bounds = newBounds;
+    }
+    startMove(params) {
+        // Note: the params are not being used, should we remove them? @todo
+        Logger.system.debug("BaseWindow.startMove", params);
+        params = params || {};
+        params.windowIdentifier = this.identifier; // add this window's identifier
+        this.eventManager.trigger("bounds-change-start", Object.assign({}, this.windowOptions.bounds));
+    }
+    stopMove(params) {
+        // Note: the params are not being used, should we remove them? @todo
+        Logger.system.debug("BaseWindow.stopMove", params);
+        params = params || {};
+        params.windowIdentifier = this.identifier; // add this window's identifier
+        this.eventManager.trigger("bounds-change-end", Object.assign({ name: this.name, eventName: "bounds-change-end", dockedPosition: this.dockedPosition }, this.windowOptions.bounds));
+    }
+    /**
+     * Given a field, this function retrieves component or window state. If no params are given you get the full state
+     * @param {object} params
+     * @param {string} params.stateVar A string containing "componentState" or "windowState"
+     * @param {string} params.field field
+     * @param {array} params.fields fields
+     * @param {string} params.key The storage key for the window.
+     * @param {function} cb Callback
+     * @private
+     * */
+    async getFSBLState(params, cb) {
+        Logger.system.debug("BaseWindow.getState", params);
+        const { err, data: response } = await StorageClient.getStandardized({
+            topic: WORKSPACE.CACHE_STORAGE_TOPIC,
+            key: params.key,
+        });
+        if (params.stateVar === "componentState") {
+            this.componentState = response;
+        }
+        const { field, fields } = params;
+        if (!err && response) {
+            if (field) {
+                cb === null || cb === void 0 ? void 0 : cb(err, response[field]);
+                return { data: response[field] };
+            }
+            else if (fields) {
+                const respObject = {};
+                for (let i = 0; i < fields.length; i++) {
+                    if (response[fields[i]]) {
+                        respObject[fields[i]] = response[fields[i]];
+                    }
+                }
+                cb === null || cb === void 0 ? void 0 : cb(null, respObject);
+                return { data: respObject };
+            }
+            else {
+                cb === null || cb === void 0 ? void 0 : cb(null, response);
+                return { data: response };
+            }
+        }
+        else {
+            const error = `Not found`;
+            Logger.system.info("WindowClient:getComponentState:error, response, params", err, response, params);
+            cb === null || cb === void 0 ? void 0 : cb(error, response);
+            return { err: error };
+        }
+    }
+    /**
+     * Given params, will return the component state. Either the params to search for, or the entire state.
+     *
+     * @param {object} params
+     * @param {string} params.field field
+     * @param {array} params.fields fields
+     * @param {function} cb Callback
+     */
+    getComponentState(params, cb) {
+        if (!params)
+            params = {};
+        if (params.fields && !Array.isArray(params.fields)) {
+            params.fields = [params.fields];
+        }
+        return this.getFSBLState(Object.assign(Object.assign({}, params), { key: this.componentKey, stateVar: "componentState" }), cb);
+    }
+    /**
+     * Given params, will return the window state. Either the params to search for, or the entire state.
+     *
+     * @param {object} params
+     * @param {string} params.field field
+     *  @param {array} params.fields fields
+     * @param {function} cb Callback
+     */
+    getWindowState(params, cb) {
+        if (!params)
+            params = {};
+        if (params.fields && !Array.isArray(params.fields)) {
+            params.fields = [params.fields];
+        }
+        params.key = this.windowKey;
+        params.stateVar = "windowData";
+        return this.getFSBLState(params, cb);
+    }
+    /**
+     * Given params, will set the component state. Any fields included will be added to the state
+     *
+     * @param {object} params
+     * @param {string} params.field field
+     *  @param {array} params.fields fields
+     * @param {function} cb Callback
+     */
+    setComponentState(params, cb = Function.prototype) {
+        if (!params)
+            params = {};
+        if (params.fields && !Array.isArray(params.fields)) {
+            params.fields = [params.fields];
+        }
+        return this.setFSBLState(Object.assign(Object.assign({}, params), { key: this.componentKey, stateVar: "componentState" }), cb);
+    }
+    /**
+     * Removes one or more specified attributes from a component state in storage
+     * for this window.
+     *
+     * In addition to the name of the window, params should include either a `field`
+     * property as a string or a `fields` property as an array of strings.
+     *
+     * @param {object} params
+     * @param {string} [params.field] field
+     * @param {array} [params.fields] fields
+     * @param {function} cb Callback
+     */
+    removeComponentState(params, cb = () => { }) {
+        if (params.fields && !Array.isArray(params.fields)) {
+            params.fields = [params.fields];
+        }
+        return this.removeFSBLState(Object.assign(Object.assign({}, params), { key: this.componentKey, stateVar: "componentState" }), cb);
+    }
+    /**
+     * Given params, will set the window state. Any fields included will be added to the state
+     *
+     * @param {object} params
+     * @param {string} params.field field
+     *  @param {array} params.fields fields
+     * @param {function} cb Callback
+     */
+    setWindowState(params, cb) {
+        if (!params)
+            params = {};
+        if (params.fields && !Array.isArray(params.fields)) {
+            params.fields = [params.fields];
+        }
+        return this.setFSBLState(Object.assign(Object.assign({}, params), { key: this.windowKey, stateVar: "windowData" }), cb);
+    }
+    saveWindowState(state) {
+        this.windowState = state;
+    }
+    static async cleanupState(state) {
+        const stateToSave = {
+            componentType: state.componentType,
+            name: state.name,
+        };
+        if (!BaseWindow.additionalWorkspaceFields) {
+            try {
+                const additionalFields = await ConfigClient.getValue("finsemble.servicesConfig.window.additionalWorkspaceFields");
+                BaseWindow.additionalWorkspaceFields = additionalFields.data || [];
+            }
+            catch (_b) {
+                BaseWindow.additionalWorkspaceFields = [];
+            }
+        }
+        let windowTypeProps;
+        if (WORKSPACE.ADDITIONAL_WINDOW_PROPS[state.windowType]) {
+            windowTypeProps = WORKSPACE.ADDITIONAL_WINDOW_PROPS[state.windowType];
+        }
+        else {
+            windowTypeProps = WORKSPACE.ADDITIONAL_WINDOW_PROPS["WebWindow"];
+        }
+        if (state.windowType === "WebApplication") {
+            state.windowType = "WebWindow";
+        }
+        const allowedKeys = [
+            ...WORKSPACE.DEFAULT_WINDOW_PROPS,
+            ...windowTypeProps,
+            ...BaseWindow.additionalWorkspaceFields,
+        ];
+        for (const key of allowedKeys) {
+            if (state[key] !== undefined) {
+                stateToSave[key] = state[key];
+            }
+        }
+        return stateToSave;
+    }
+    async saveCompleteWindowState(state, cb = Function.prototype) {
+        Logger.system.debug("COMPONENT LIFECYCLE:SAVING STATE:", state.name);
+        if (!state) {
+            cb("No State Provided");
+        }
+        else {
+            if (state.windowType === "StackedWindow") {
+                state.componentType = "StackedWindow";
+                this.mergeBounds(state.bounds);
+            }
+            const stateToSave = await BaseWindow.cleanupState(state);
+            // don't save if no change from previously saved state
+            if (isEqualIgnoringArrayOrder(this.oldState, stateToSave)) {
+                Logger.system.debug("saveCompleteWindowState -- deep equal");
+                cb();
+            }
+            else {
+                Logger.system.debug("saveCompleteWindowState -- not deep equal", this.oldState, stateToSave);
+                this.oldState = clone(stateToSave);
+                try {
+                    await setWindowState({
+                        windowName: this.windowName,
+                        state: { windowData: stateToSave },
+                    });
+                }
+                catch (_b) { }
+                cb();
+            }
+        }
+    }
+    /**
+     * Given a field, this function sets and persists app state.
+     * @param {object} params
+     * @param {string} [params.field] field
+     * @param {array} [params.fields] fields
+     * @param {function=} cb Callback
+     * */
+    async setFSBLState(params, cb) {
+        const getParams = {
+            key: params.key,
+            stateVar: params.stateVar,
+        };
+        if (!getParams.key) {
+            if (getParams.stateVar === "componentState") {
+                getParams.key = this.componentKey;
+            }
+            else if (getParams.stateVar === "windowData") {
+                getParams.key = this.windowKey;
+            }
+        }
+        const propertyToUse = params.stateVar === "componentState" ? "componentState" : "windowOptions";
+        await this.getFSBLState(getParams);
+        /* Sidd Notes: We are always comparing the entire saved state to see if things have changed instead of just the new fields - that is expensive. */
+        Logger.system.debug("BaseWindow.getState", params);
+        let localComponentState = merge(this[propertyToUse], {});
+        let { fields } = params;
+        if (params.field) {
+            fields = [
+                {
+                    field: params.field,
+                    value: params.value,
+                },
+            ];
+        }
+        for (let i = 0; i < fields.length; i++) {
+            const field = fields[i];
+            if (!field.field || typeof field.value === "undefined") {
+                continue;
+            }
+            localComponentState[field.field] = field.value;
+        }
+        params.value = localComponentState;
+        Logger.system.debug(`COMPONENT LIFECYCLE: SAVING ${params.stateVar}:`, localComponentState);
+        if (params.stateVar === "windowData") {
+            localComponentState = await BaseWindow.cleanupState(localComponentState);
+        }
+        try {
+            await setWindowState({
+                windowName: this.windowName,
+                state: { [params.stateVar]: localComponentState },
+            });
+        }
+        catch (_b) { }
+        this[propertyToUse] = localComponentState;
+        cb === null || cb === void 0 ? void 0 : cb();
+    }
+    /**
+     * Removes one or more specified attributes from either component or window state in storage.
+     *
+     * In addition to the name of the window, params should include either a `field`
+     * property as a string or a `fields` property as an array of strings.
+     *
+     * @param {object} params
+     * @param {string} [params.field] field
+     * @param {array} [params.fields] fields
+     * @param {function=} cb Callback
+     * */
+    removeFSBLState(params, cb = () => { }) {
+        var _b;
+        const getParams = {
+            key: params.key,
+            stateVar: params.stateVar,
+        };
+        // Ensure that we have a key
+        const defaultKey = getParams.stateVar === "componentState" ? this.componentKey : this.windowKey;
+        const key = (_b = getParams.key) !== null && _b !== void 0 ? _b : defaultKey;
+        const propertyToUse = params.stateVar === "componentState" ? "componentState" : "windowOptions";
+        this.getFSBLState(Object.assign(Object.assign({}, getParams), { key }), async () => {
+            var _b;
+            /* Sidd Notes: We are always comparing the entire saved state to see if things have changed instead of just the new fields - that is expensive. */
+            Logger.system.debug("BaseWindow.getState", params);
+            // deepmerge treats undefined as empty object
+            let localComponentState = merge(this[propertyToUse], {});
+            let { fields = [] } = params;
+            if (params.field) {
+                fields = [
+                    {
+                        field: params.field,
+                    },
+                ];
+            }
+            for (let i = 0; i < fields.length; i++) {
+                const field = fields[i];
+                if (!field.field) {
+                    continue;
+                }
+                delete localComponentState[field.field];
+            }
+            params.value = localComponentState;
+            Logger.system.debug(`COMPONENT LIFECYCLE: SAVING ${params.stateVar}:`, localComponentState);
+            if (params.stateVar === "windowData") {
+                localComponentState = await BaseWindow.cleanupState(localComponentState);
+            }
+            const stateVar = (_b = params.stateVar) !== null && _b !== void 0 ? _b : "windowData";
+            try {
+                await setWindowState({
+                    windowName: this.windowName,
+                    state: { [stateVar]: localComponentState },
+                });
+            }
+            catch (_c) { }
+            this[propertyToUse] = localComponentState;
+            cb(null);
+        });
+    }
+    /**
+     *Cancels startTabTileMonitoring. Example use is a user "excapes" out of a drag operation.
+     *
+     * @param {object} params for future use
+     * @memberof BaseWindow
+     */
+    cancelTabTileMonitoring(params) {
+        Logger.system.debug("BaseWindow.cancelTabTileMonitoring", params);
+        RouterClient.transmit("TabTile.cancelTabTile", { params });
+    }
+    /**
+     * Return the parent window's wrapper (e.g. StackedWindow).
+     *
+     */
+    getParent() {
+        return this.parentWindow;
+    }
+    /**
+     * Sets the parent window (e.g. stackedWindow) and emits "setParent" event to window listeners.
+     *
+     * @param {object} stackedWindowIdentifier identifer of window to set as parent (e.g. stackedWindowIdentifier).
+     *
+     */
+    setParent(windowIdentifier, cb = Function.prototype) {
+        if (this.parentWindow && this.parentWindow.name === windowIdentifier.windowName) {
+            Logger.system.debug("BaseWindow.setParent already set", windowIdentifier);
+            cb(null, windowIdentifier);
+        }
+        else {
+            Logger.system.debug("BaseWindow.setParent", windowIdentifier);
+            // set up store listener to change if
+            BaseWindow.getInstance(windowIdentifier, (err, wrappedStackedWindow) => {
+                if (!err) {
+                    Logger.system.debug("BaseWindow.setParent wrap success", windowIdentifier);
+                    console.debug("BaseWindow.setParent wrap success", this, wrappedStackedWindow);
+                    this.parentWindow = wrappedStackedWindow;
+                    this.eventManager.trigger("parent-set", {
+                        parentName: this.parentWindow.name,
+                    });
+                }
+                else {
+                    Logger.system.error("BaseWindow.setParent error", err);
+                }
+                cb(err, windowIdentifier);
+            });
+        }
+    }
+    /**
+     * Clears the parent reference and emits "clearParent" event to window listeners. Used only internally.
+     *
+     * @private
+     *
+     */
+    clearParent() {
+        Logger.system.debug("BaseWindow.clearParent");
+        this.parentWindow = null;
+        this.eventManager.trigger("parent-unset", this.parentWindow);
+    }
+    setTitle(title) {
+        if (this.windowOptions) {
+            this.windowOptions.title = title;
+        }
+        Logger.system.debug("Title change", title);
+        // Publish a title changed event (include the target window (windowName) and the new title (title))
+        RouterClient.publish(this.TITLE_CHANGED_CHANNEL, { title, windowName: this.windowName });
+    }
+    // public Window functions - needed to handle events properly e.g. for close.
+    close(params = {}, cb) {
+        return new Promise((resolve) => {
+            this.queryWindowService("close", params, (err, data) => {
+                cb === null || cb === void 0 ? void 0 : cb(err, data);
+                resolve({ err });
+            });
+        });
+    }
+    _animate(params, cb) {
+        if (typeof params === "function") {
+            cb = params;
+            params = null;
+        }
+        cb("Method not implemented for window", { shouldContinue: true });
+    }
+}
+_a = BaseWindow;
+BaseWindow.cache = {};
+BaseWindow.WINDOWSTATE = constants.WINDOWSTATE;
+// ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+// The window wrappers
+// ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+/**
+ * Async wrap. Given a name/windowName, it will query the launcher for information required to wrap the window. Then it will return an object that can be operated on. Also this creates a cache of all wrapped windows for performance. Our clients wrap the same window often and this was causing excessive messaging to the store and degrading performance.
+ * @param {*} params Need only name in most cases. For service and other cases where the window is not part of what the launcher considers active windows, name and uuid are required
+ * @param {*} cb
+ */
+BaseWindow.wrap = BaseWindow.getInstance;
+BaseWindow._windowReady = (windowName) => {
+    const promiseResolver = async (resolve) => {
+        Logger.system.debug(`windowServiceReady: ${windowName} waiting`);
+        const subscribeId = RouterClient.subscribe(`Finsemble.Component.State.${windowName}`, (error, response) => {
+            const { state } = response.data;
+            Logger.system.debug(`windowServiceReady: ${windowName} state change: ${state}`);
+            switch (state) {
+                case "ready":
+                case "reloading":
+                case "closing": // if ready state or any state beyond
+                    Logger.system.debug(`windowServiceReady: ${windowName} ${state}`);
+                    RouterClient.unsubscribe(subscribeId);
+                    resolve();
+                    break;
+                default:
+                    Logger.system.debug(`windowServiceReady default: ${windowName} ${state}`);
+            }
+        });
+    };
+    return new Promise(promiseResolver);
+};
+//# sourceMappingURL=BaseWindow.js.map