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

package/common/FinsembleWindow.js

@@ -2,9 +2,11 @@ import { RouterClient } from "../clients/routerClient";
 import { Logger } from "../clients/logger";
 import * as util from "./util";
 import PublicEventManager from "./events/PublicEventManager";
-import { WINDOWSTATE, DOCKING } from "./constants";
+import { WINDOWSTATE } from "./constants";
 import { System } from "./system";
 import { FEAGlobals } from "./Globals";
+import { actions, emptyStore } from "../platform/services/window/modules/actions";
+import { getRemoteStoreAsSingleton } from "../common/redux/getRemoteStore";
 import clone from "lodash/cloneDeep";
 export class FinsembleView {
     constructor(params) {
@@ -21,45 +23,6 @@ export class FinsembleView {
         await this.win.bringViewToFront(this, cb);
     }
 }
-/**
- * Subscribes to a Router pubsub that will contain the 'parent state' for the window (i.e. is this window part
- * of a tabbed group / has a parent). The state received (and any later updates to it) are applied to the
- * FinsembleWindow.
- *
- * current state.
- * @param wrap Wrap that should be subscribing to parent state.
- * @param identifier WindowIdentifier of the window whose state should be observed.
- * @returns a promise that will resolve when the subscription has returned the initial state.
- */
-const waitForParentChangeMessage = async (wrap, identifier) => new Promise((resolve) => {
-    // Subscribe to parent inside the wrap so if getInstance is called after window creation the parent window will be available.
-    wrap.parentSubscribeID = RouterClient.subscribe(`Finsemble.parentChange.${identifier.windowName}`, async (err, message) => {
-        if (err) {
-            Logger.system.error("FinsembleWindow Parent Notification: notification error", err);
-        }
-        else {
-            const parentState = message.data || {};
-            if (parentState.type === "Added") {
-                Logger.system.debug("FinsembleWindow Parent Notification: window.addedToStack listener", parentState);
-                await wrap.setParent(parentState.stackedWindowIdentifier);
-            }
-            else if (parentState.type === "Exists") {
-                Logger.system.debug("FinsembleWindow Parent Notification: Parent already exists, checking if added to wrap", parentState);
-                await wrap.setParentOnWrap(parentState.stackedWindowIdentifier);
-            }
-            else if (parentState.type === "Removed") {
-                Logger.system.debug("FinsembleWindow Parent Notification: window.removedFromStack listener", parentState);
-                wrap.clearParent();
-            }
-            else if (parentState.type) {
-                // if defined but unknown type
-                Logger.system.error("FinsembleWindow Parent Notification: unknown type", parentState);
-            }
-        }
-        resolve();
-        wrap.determiningParent = null;
-    });
-});
 /**
  *
   <h2>Finsemble Window</h2>
@@ -80,8 +43,6 @@ export class FinsembleWindow extends PublicEventManager {
             name: params.name,
             sourceType: "Window",
         });
-        /** Promise that should be resolved when the initial state opf the parent relationship for this window has been determined. */
-        this.determiningParent = null;
         this.types = {};
         this.wrapState = params.wrapState || "initializing";
         this.componentState = {};
@@ -94,7 +55,6 @@ export class FinsembleWindow extends PublicEventManager {
         this.windowOptions = {};
         // because we were doing this[i]=params[i] in the constructor jscrambler was creating a reference to "this" above _super_, causing everything to break
         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);
         FinsembleWindow.bindFunctions(this);
@@ -116,10 +76,6 @@ export class FinsembleWindow extends PublicEventManager {
                 return "bounds-change-start";
             case "bringToFront":
                 return "broughtToFront";
-            case "setParent":
-                return "parent-set";
-            case "clearParent":
-                return "parent-unset";
             default:
                 return event;
         }
@@ -163,7 +119,7 @@ export class FinsembleWindow extends PublicEventManager {
     /**
      * Internal use only - Returns the name of the window service channel for a given service or topic
      * @private
-     * @param {string} channelTopic - the topic or service (eg, "close", "maximize", "getParent")
+     * @param {string} channelTopic - the topic or service (eg, "close", "maximize")
      * @returns {string} the window service channel name, which can be used for router queries/listening
      */
     windowServiceChannelName(channelTopic) {
@@ -226,8 +182,6 @@ export class FinsembleWindow extends PublicEventManager {
      * @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.handleWrapRemoveRequest = obj.handleWrapRemoveRequest.bind(obj);
@@ -438,13 +392,6 @@ export class FinsembleWindow extends PublicEventManager {
                     RouterClient.unsubscribe(subscribeID);
                 }
             });
-            // Runs a background task to identity this window's parent. The parent is only used when wrap.getParent() is called,
-            // at which time if the parent is not yet available it will wait for this promise to complete.
-            // We can't move this function into getParent() because this function subscribes to a router message that
-            // tracks changes to the window's parent. Note that there's a subtle race condition in that the parent could
-            // change in the millisecond instant between when we create the wrap and when our subscribe is accepted.
-            // The reason why we don't await the promise is to avoid introducing delay into createWrap().
-            wrap.determiningParent = waitForParentChangeMessage(wrap, identifier);
             resolve({ wrap });
         });
     }
@@ -493,10 +440,6 @@ export class FinsembleWindow extends PublicEventManager {
     cleanupRouter() {
         const REMOVE_WRAP_CHANNEL = FinsembleWindow._getRemoveWrapChannel(this.name);
         RouterClient.removeResponder(REMOVE_WRAP_CHANNEL);
-        if (this.TITLE_CHANGED_SUBSCRIPTION) {
-            RouterClient.unsubscribe(this.TITLE_CHANGED_SUBSCRIPTION);
-        }
-        RouterClient.unsubscribe(this.parentSubscribeID);
     }
     /**
      * Identify what to run when/if the component is ready.
@@ -549,7 +492,7 @@ export class FinsembleWindow extends PublicEventManager {
             var _a;
             // All window functions except add event listener must wait until the window is ready.
             // And then we re-run this same method
-            if (methodName !== "close" && methodName !== "setParent" && this.wrapState !== "ready") {
+            if (methodName !== "close" && this.wrapState !== "ready") {
                 await this.onReady();
                 this.wrapState = "ready";
                 const data = await this.queryWindowService(methodName, params);
@@ -776,7 +719,7 @@ export class FinsembleWindow extends PublicEventManager {
         this.queryWindowService("isAlwaysOnTop", params, callback);
     }
     /**
-     * Determine if the current window is showing. A window is not showing when it is minized or hidden.
+     * Determine if the current window is showing. A window is not showing when it is minimized or hidden.
      * See also: updateOptions
      *
      * @param params This parameter is ignored.
@@ -897,10 +840,10 @@ export class FinsembleWindow extends PublicEventManager {
      *   console.log("The width of the current window:", data.width);
      * })
      */
-    getBounds(cb, backwardCompatibilitycb) {
+    getBounds(cb, backwardCompatibilityCB) {
         const promiseResolver = (resolve) => {
             // Old signature was getBounds({}, callback). New signature is getBounds(callback).
-            const callback = typeof cb === "function" ? cb : backwardCompatibilitycb;
+            const callback = typeof cb === "function" ? cb : backwardCompatibilityCB;
             this.queryWindowService("getBounds", {}, (err, bounds) => {
                 callback === null || callback === void 0 ? void 0 : callback(err, bounds);
                 resolve({ err, data: bounds });
@@ -930,7 +873,6 @@ export class FinsembleWindow extends PublicEventManager {
      * Use the `.show()` method to bring the current window back.
      *
      * @param {object} [params]
-     * @param {boolean} [params.invokedByParent] - internal use only
      * @param [callback]
      * @example
      * const {err} = await finsembleWindow.hide();
@@ -964,7 +906,6 @@ export class FinsembleWindow extends PublicEventManager {
      * Shows the current window. This will undo hide or minimize.
      *
      * @param {object} [params]
-     * @param {boolean} [params.invokedByParent] - internal use only
      * @param {boolean} [params.shouldMaximize] - when the window is shown, it should also be maximized
      * @param {boolean} [params.shouldRestore] -
      * @param {boolean} [params.saveState] -
@@ -1044,12 +985,7 @@ export class FinsembleWindow extends PublicEventManager {
      */
     registerWithDocking(params = {}, cb) {
         this.onReady(() => {
-            RouterClient.query("DockingService.registerWindow", {
-                type: this.type,
-                windowType: this.windowType,
-                windowMsg: params,
-                name: this.windowName,
-            }, cb);
+            RouterClient.query("DockingService.registerWindow", params, cb);
         });
     }
     /**
@@ -1305,7 +1241,12 @@ export class FinsembleWindow extends PublicEventManager {
      * Alternative, use: `FSBL.Clients.WindowClient.getComponentState`
      */
     getComponentState(params, cb) {
-        this.queryWindowService("getComponentState", params, cb);
+        return new Promise((resolve) => {
+            this.queryWindowService("getComponentState", params, (err, data) => {
+                cb === null || cb === void 0 ? void 0 : cb(err, data);
+                resolve({ err, data });
+            });
+        });
     }
     /**
      * @private
@@ -1357,159 +1298,23 @@ export class FinsembleWindow extends PublicEventManager {
         Logger.system.debug("FinsembleWindow.cancelTabTileMonitoring", params);
         RouterClient.transmit("TabTile.cancelTabTile", { params });
     }
-    /**
-     * Return the parent window's wrapper (e.g. StackedWindow).
-     *
-     * @param cb - Callback with the parent (null if there's no parent)
-     * @example
-     * finsembleWindow.getParent((err, parent) => {
-     *   if(parent !== null){
-     *     // do something
-     *   }
-     * })
-     */
-    getParent(cb) {
-        const _getParent = (cb) => {
-            if (this.settingParent) {
-                FinsembleWindow.getInstance(this.settingParent, (err, stackWrap) => {
-                    cb(null, stackWrap);
-                });
-            }
-            else if (this.parentWindow) {
-                cb(null, this.parentWindow);
-            }
-            else {
-                cb(null, null);
-            }
-        };
-        //If we're still waiting for the intial state of the parent relationship, wait for that to happen before handling this call.
-        if (this.determiningParent) {
-            this.determiningParent.then(() => {
-                _getParent(cb);
-            });
-            Logger.system.debug("FinsembleWindow is determining parent, waiting on that...");
-        }
-        else {
-            _getParent(cb);
-        }
-    }
-    /**
-     * Sets the parent window (e.g. stackedWindow) and emits "setParent" event to window listeners.
-     *
-     * @param {object} stackedWindowIdentifier identifier of window to set as parent (e.g. stackedWindowIdentifier).
-     * @private
-     */
-    async setParent(stackedWindowIdentifier, cb) {
-        return new Promise((resolve) => {
-            if (this.settingParent) {
-                // Note: not checking that the parent is different
-                this.getParent((err, data) => {
-                    cb === null || cb === void 0 ? void 0 : cb(err, data);
-                    resolve({ err, data });
-                });
-                return;
-            }
-            this.settingParent = stackedWindowIdentifier;
-            if (this.parentWindow && this.parentWindow.name === stackedWindowIdentifier.windowName) {
-                Logger.system.debug("FinsembleWindow.setParent already set", stackedWindowIdentifier);
-                this.settingParent = false;
-                cb === null || cb === void 0 ? void 0 : cb(null, this.parentWindow);
-                resolve({ data: this.parentWindow });
-            }
-            else {
-                this.queryWindowService("setParent", stackedWindowIdentifier, () => {
-                    Logger.system.debug("FinsembleWindow.setParent", stackedWindowIdentifier);
-                    FinsembleWindow.getInstance(stackedWindowIdentifier, (err, wrappedStackedWindow) => {
-                        if (!err) {
-                            Logger.system.debug("FinsembleWindow.setParent wrap success", stackedWindowIdentifier);
-                            this.parentWindow = wrappedStackedWindow;
-                            if (!this.parentWindow.windowType.includes("StackedWindow") &&
-                                !this.parentWindow.windowName.includes("StackedWindow")) {
-                                Logger.system.error("FinsembleWindow.setParent error", this.parentWindow.name, stackedWindowIdentifier.windowName);
-                            }
-                        }
-                        else {
-                            Logger.system.error("FinsembleWindow.setParent error", err);
-                        }
-                        /** DH 11/8/2019
-                         * There is an intrinsic race between stacks and grouping:
-                         * The stack is the group, not the children, so the parent might
-                         * not be correct before the update arrives. This publish ensures
-                         * that there is at least one publish _after_ the parent has been set.
-                         */
-                        RouterClient.transmit(DOCKING.REQUEST_PUBLISH, null);
-                        this.settingParent = false;
-                        const parentSettingDone = () => {
-                            this.removeEventListener("parent-set", parentSettingDone);
-                            cb === null || cb === void 0 ? void 0 : cb(err, wrappedStackedWindow);
-                            resolve({ err, data: wrappedStackedWindow });
-                        };
-                        this.addEventListener("parent-set", parentSettingDone);
-                    });
-                });
-            }
-        });
-    }
-    /**
-     * Sets the parent window (e.g. stackedWindow) on a window wrap.
-     * This is for the case where a window already has a parent but it's wrap doesn't know about it.
-     * @param {object} stackedWindowIdentifier identifier of window to set as parent (e.g. stackedWindowIdentifier).
-     * @private
-     */
-    async setParentOnWrap(stackedWindowIdentifier, cb = Function.prototype) {
-        return new Promise((resolve) => {
-            if (this.parentWindow && this.parentWindow.name === stackedWindowIdentifier.windowName) {
-                Logger.system.debug("FinsembleWindow.setParentOnWrap already set", stackedWindowIdentifier);
-                cb(null, this.parentWindow);
-                resolve({ err: null, data: this.parentWindow });
-            }
-            else {
-                this.queryWindowService("setParent", stackedWindowIdentifier, () => {
-                    Logger.system.debug("FinsembleWindow.setParentOnWrap", stackedWindowIdentifier);
-                    FinsembleWindow.getInstance(stackedWindowIdentifier, (err, wrappedStackedWindow) => {
-                        if (!err) {
-                            Logger.system.debug("FinsembleWindow.setParentOnWrap success getting wrap", stackedWindowIdentifier);
-                            this.parentWindow = wrappedStackedWindow;
-                            if (this.parentWindow.windowType.includes("StackedWindow") === false &&
-                                this.parentWindow.windowName.includes("StackedWindow") === false) {
-                                Logger.system.error("FinsembleWindow.setParentOnWrap error", this.parentWindow.name, stackedWindowIdentifier.windowName);
-                            }
-                        }
-                        else {
-                            Logger.system.error("FinsembleWindow.setParentOnWrap error", err);
-                        }
-                        cb(err, wrappedStackedWindow);
-                        resolve({ err: null, data: wrappedStackedWindow });
-                    });
-                });
-            }
-        });
-    }
-    /**
-     * Clears the parent reference and emits "clearParent" event to window listeners. Used only internally.
-     *
-     * @private
-     */
-    clearParent() {
-        Logger.system.debug("FinsembleWindow.clearParent", this.parentWindow);
-        this.parentWindow = null;
-    }
     /**
      * Change the title of the current window.
      *
+     * @deprecated - Set document.title in your app or use FSBL.Clients.WindowClient.setTitle()
      * @param title - the new title
-     * @example
-     * finsembleWindow.setTitle("New title");
      */
     setTitle(title) {
-        Logger.system.debug("Title change", title);
-        // Title change events look like:
-        // title: string 		- the new title
-        // windowName: string	- the name of the window which changed
-        RouterClient.publish(this.TITLE_CHANGED_CHANNEL, {
-            title,
-            windowName: this.windowName,
+        const store = getRemoteStoreAsSingleton({
+            singletonName: "WindowClient::setWindowTitle",
+            server: "@@finsemble/remoteRedux/WindowServiceStore",
+            slice: "windowTitleBar",
+            emptyStore,
+            dispatchOnly: true,
         });
+        store.dispatch(actions.setAPITitle({
+            title,
+        }));
     }
     /**
      * Get all options related to the current window
@@ -1532,130 +1337,6 @@ export class FinsembleWindow extends PublicEventManager {
             });
         });
     }
-    // TO BE REMOVED WHEN TABBING API IS PUT IN PLACe
-    /**
-     * Handles common housekeeping checks and modifications on params at the beginning of each private window-management function
-     *
-     * @param {string} methodName method name (e.g. "minimize", "maximize")
-     * @param {object} params
-     * @private
-     */
-    _privateManagementPreface(methodName, params) {
-        var _a, _b;
-        if (typeof params === "function") {
-            Logger.system.error("StackedWindowWrapper.wrapPreface bad params", params);
-        }
-        params = params || {};
-        params.stackedWindowIdentifier = {
-            windowName: (_a = this.identifier) === null || _a === void 0 ? void 0 : _a.windowName,
-            windowType: (_b = this.identifier) === null || _b === void 0 ? void 0 : _b.windowType,
-        }; // add this window's identifier
-        Logger.system.debug(`StackedWindow.${methodName}  _privateManagementPreface`, params);
-        return params;
-    }
-    /**
-     * Adds window as a child to a stacked window.  Adds to the top of the stack, or if specified to a specific location in the stack;
-     *
-     * @param {object=} params
-     * @param {object} params.stackedWindowIdentifier stacked window to operate on stacked window to operate on
-     * @param {object} params.windowIdentifier window to add
-     * @param {number=} params.position the location in the stack to push the window.  Location 0 is the bottom of the stack. Defaults to the top of stack.
-     * @param {boolean=} params.noSave if true then don't save the store after updating it (will be saved by caller)
-     * @param {function=} callback function(err)
-     * @private
-     */
-    addWindow(params, callback = Function.prototype) {
-        params = this._privateManagementPreface("addWindow", params);
-        const promiseResolver = (resolve) => {
-            RouterClient.query("StackedWindow.addWindow", params, (err, queryResponseMessage) => {
-                Logger.system.debug("StackedWindow.addWindow callback", err, queryResponseMessage);
-                callback(err, queryResponseMessage.data);
-                resolve({ err, data: queryResponseMessage.data });
-            });
-        };
-        return new Promise(promiseResolver);
-    }
-    /**
-     * Removes a child window from a stacked window.  If removed window was visible, then the bottom child window (position 0) in stack will be made visible.
-     *
-     * @param {object} params
-     * @param {object} params.stackedWindowIdentifier stacked window to operate on
-     * @param {object} params.windowIdentifier window to remove
-     * @param {boolean=} params.noDocking if true then do not register removed window with docking (the workspace is unaffected)
-     * @param {function=} callback function(err)
-     * @private
-     */
-    removeWindow(params, callback = Function.prototype) {
-        params = this._privateManagementPreface("removeWindow", params);
-        const promiseResolver = (resolve) => {
-            RouterClient.query("StackedWindow.removeWindow", params, (err, queryResponseMessage) => {
-                Logger.system.debug("StackedWindow.removeWindow callback", err, queryResponseMessage);
-                callback(err, queryResponseMessage.data);
-                resolve({ err, data: queryResponseMessage.data });
-            });
-        };
-        return new Promise(promiseResolver);
-    }
-    /**
-     * Removes a window from the stack then closes it.  If removed window was visible, then the bottom child window (position 0) in stack will be made visible.
-     *
-     * @param {object} params
-     * @param {object} params.stackedWindowIdentifier stacked window to operate on
-     * @param {object} params.windowIdentifier window to delete
-     * @param {function=} callback function(err)
-     * @private
-     */
-    deleteWindow(params, callback = Function.prototype) {
-        params = this._privateManagementPreface("deleteWindow", params);
-        const promiseResolver = (resolve) => {
-            RouterClient.query("StackedWindow.deleteWindow", params, (err, queryResponseMessage) => {
-                Logger.system.debug("StackedWindow.deleteWindow callback", err, queryResponseMessage);
-                callback(err, queryResponseMessage.data);
-                resolve({ err, data: queryResponseMessage.data });
-            });
-        };
-        return new Promise(promiseResolver);
-    }
-    /**
-     * Sets the visible window within the stack.  The previously visible window in stack will be automatically hidden.
-     *
-     * @param {object} params
-     * @param {object} params.stackedWindowIdentifier stacked window to operate on
-     * @param {object} params.windowIdentifier
-     * @param {function=} callback function(err)
-     * @private
-     */
-    setVisibleWindow(params, callback = Function.prototype) {
-        params = this._privateManagementPreface("setVisibleWindow", params);
-        const promiseResolver = (resolve) => {
-            RouterClient.query("StackedWindow.setVisibleWindow", params, (err, queryResponseMessage) => {
-                Logger.system.debug("StackedWindow.setVisibleWindow callback", err, queryResponseMessage);
-                callback(err, queryResponseMessage.data);
-                resolve({ err, data: queryResponseMessage.data });
-            });
-        };
-        return new Promise(promiseResolver);
-    }
-    /**
-     * Reorders the stack, but does not affect visibility
-     *
-     * @param {object} params
-     * @param {object} params.stackedWindowIdentifier stacked window to operate on
-     * @param {array} params.windowIdentifiers array of windowIdentifiers which provides the new order
-     * @param {function=} callback function(err)
-     * @private
-     */
-    reorder(params, callback = Function.prototype) {
-        params = this._privateManagementPreface("reorder", params);
-        const promiseResolver = (resolve) => {
-            RouterClient.query("StackedWindow.reorder", params, (err, queryResponseMessage) => {
-                Logger.system.debug("StackedWindow.reorder callback", err, queryResponseMessage);
-                callback(err, queryResponseMessage.data);
-                resolve({ err, data: queryResponseMessage.data });
-            });
-        };
-        return new Promise(promiseResolver);
-    }
     /**
      * Form a docking group with any adjacent windows.
      * This is the equivalent of clicking the "Attach Windows" icon in the titlebar, if it's available.
@@ -1664,8 +1345,7 @@ export class FinsembleWindow extends PublicEventManager {
      * finsembleWindow.formGroup()
      */
     formGroup() {
-        const windowName = this.parentWindow ? this.parentWindow.name : this.name;
-        RouterClient.transmit("DockingService.formGroup", { windowName });
+        RouterClient.transmit("DockingService.formGroup", { windowName: this.name });
     }
     /**
      * Leave a docking group
@@ -1675,8 +1355,7 @@ export class FinsembleWindow extends PublicEventManager {
      * finsembleWindow.ejectFromGroup()
      */
     ejectFromGroup() {
-        const windowName = this.parentWindow ? this.parentWindow.name : this.name;
-        RouterClient.query("DockingService.leaveGroup", { name: windowName }, () => { });
+        RouterClient.query("DockingService.leaveGroup", { name: this.name }, () => { });
     }
 }
 FinsembleWindow.WINDOWSTATE = WINDOWSTATE;
@@ -1699,7 +1378,7 @@ FinsembleWindow.cache = {};
 FinsembleWindow._windowReady = function (windowName) {
     Logger.system.debug(`windowServiceReady: ${windowName} starting`);
     let subscribeId;
-    const promiseResolver = async (resolve, reject) => {
+    const promiseResolver = async (resolve) => {
         // Subscribe handler for component state. Once new state is retrieved, resolve out of _windowReady
         // This is a closure so it easily has access to the promise resolve method.
         const onComponentStateChanged = (err, response) => {