@finsemble/finsemble-ui 1.0.0-beta-1

package/react/components/windowTitleBar/stores/windowTitleBarStore.js

@@ -0,0 +1,609 @@
+/*!
+ * Copyright 2017 by ChartIQ, Inc.
+ * All rights reserved.
+ */
+import windowTitleBarStoreDefaults from "./windowTitleBarStoreDefaults";
+const getWindowNameForDocking = (finsembleWindow) => {
+    const parent = finsembleWindow.parentWindow;
+    return parent ? parent.name : finsembleWindow.name;
+};
+const getStackedWindow = (params, cb) => {
+    if (!finsembleWindow.parentWindow && params.create) {
+        const onParentSet = (evt) => {
+            const { parentName } = evt.data;
+            finsembleWindow.setParent({ windowName: parentName }, (err2, windowWrapper) => {
+                cb === null || cb === void 0 ? void 0 : cb(err2, windowWrapper);
+            });
+            finsembleWindow.removeListener("parent-set", onParentSet);
+        };
+        finsembleWindow.addListener("parent-set", onParentSet);
+        FSBL.Clients.LauncherClient.spawn("StackedWindow", {
+            windowType: "StackedWindow",
+            data: { windowIdentifiers: params.windowIdentifiers },
+            options: { newStack: true },
+        }, (err) => {
+            if (!err) {
+                return;
+            }
+            cb === null || cb === void 0 ? void 0 : cb(err, null);
+        });
+    }
+    else {
+        finsembleWindow.getParent(cb);
+    }
+};
+let windowTitleBarStore;
+/**
+ * When a group update is publish, we sift through the data to see if this window is snapped or grouped with other windows. Then we publish that info, and the GroupingButton renders the correct icon.
+ * @param {*} err
+ * @param {*} response
+ */
+const onDockingGroupUpdate = (err, response) => {
+    if (err || !response.data || !response.data.groupData) {
+        return;
+    }
+    FSBL.Clients.Logger.system.debug("On docking group update", response.data.groupData);
+    let groupNames = Object.keys(response.data.groupData);
+    let movableGroups = groupNames
+        .filter((groupName) => response.data.groupData[groupName].isMovable)
+        .map((groupName) => response.data.groupData[groupName]);
+    // This is all movable and snapped groups. It's used later to figure out the icon to display.
+    windowTitleBarStore.setValue({
+        field: "Main.allDockingGroups",
+        value: response.data.groupData,
+    });
+    windowTitleBarStore.setValue({
+        field: "Main.allMovableDockingGroups",
+        value: movableGroups,
+    });
+    let myGroups = Actions.getMyDockingGroups(response.data.groupData);
+    windowTitleBarStore.setValue({
+        field: "Main.dockingGroups",
+        value: myGroups,
+    });
+    /**
+     * Goes through groups and sees if this window is grouped, snapped, or freely hanging out there.
+     */
+    let isSnapped = false;
+    let isInMovableGroup = false;
+    let isTopRight = false;
+    let windowName = getWindowNameForDocking(finsembleWindow);
+    for (let i = 0; i < myGroups.length; i++) {
+        let myGroup = myGroups[i];
+        if (myGroup.isMovable) {
+            isInMovableGroup = true;
+            if (windowName == myGroup.topRightWindow) {
+                isTopRight = true;
+            }
+        }
+        else {
+            isSnapped = true;
+        }
+    }
+    let icon = false;
+    if (isSnapped) {
+        icon = "joiner";
+    }
+    if (isInMovableGroup) {
+        icon = "ejector";
+    }
+    windowTitleBarStore.setValues([
+        { field: "isSnapped", value: isSnapped },
+        { field: "isGrouped", value: isInMovableGroup },
+        { field: "isTopRight", value: isTopRight },
+        { field: "Main.dockingIcon", value: icon },
+    ]);
+};
+/**
+ * Listen for updates from the dragAndDropClient.
+ */
+const listenForDNDUpdates = () => {
+    FSBL.Clients.RouterClient.subscribe(`${FSBL.Clients.WindowClient.options.name}Finsemble.Sharer`, (err, response) => {
+        if (err) {
+            return console.error(err);
+        }
+        windowTitleBarStore.setValues([
+            {
+                field: "Sharer.emitterEnabled",
+                value: response.data.emitterEnabled,
+            },
+            {
+                field: "Sharer.receiverEnabled",
+                value: response.data.receiverEnabled,
+            },
+        ]);
+    });
+};
+/**
+ * Handles whether to show the linker button.
+ */
+const showLinkerButton = () => {
+    // Get state (channel membership) from the linkerClient. Then set the value in the header so that the title bar accurately reflects the state.
+    const cb = (err, response) => {
+        if (response.channels) {
+            windowTitleBarStore.setValue({
+                field: "Linker.channels",
+                value: response.channels,
+            });
+        }
+        windowTitleBarStore.setValue({
+            field: "Linker.showLinkerButton",
+            value: true,
+        });
+    };
+    cb(null, FSBL.Clients.LinkerClient.getState());
+    FSBL.Clients.LinkerClient.onStateChange(cb);
+};
+const processInitialTabList = (err, values) => {
+    const onParentSet = () => {
+        Actions.parentWrapper = null;
+        Actions.getInitialTabList(() => {
+            FSBL.Clients.Logger.system.debug("docking group update after initial tab list");
+            onDockingGroupUpdate(null, {
+                data: {
+                    groupData: windowTitleBarStore.getValue({
+                        field: "Main.allDockingGroups",
+                    }),
+                },
+            });
+        });
+    };
+    const onParentCleared = () => {
+        Actions.parentWrapper = null;
+        FSBL.Clients.Logger.system.debug("ClearParent, setting tabs to null");
+        Actions.stopListeningOnParentWrapper(() => {
+            Actions.parentWrapperStore = null;
+            Actions._setTabs(null);
+            onDockingGroupUpdate(null, {
+                data: {
+                    groupData: windowTitleBarStore.getValue({
+                        field: "Main.allDockingGroups",
+                    }),
+                },
+            });
+        });
+    };
+    finsembleWindow === null || finsembleWindow === void 0 ? void 0 : finsembleWindow.addListener("setParent", onParentSet);
+    finsembleWindow === null || finsembleWindow === void 0 ? void 0 : finsembleWindow.addListener("clearParent", onParentCleared);
+    if (err) {
+        return FSBL.Clients.Logger.system.error("Error in getInitialTabList.", err);
+    }
+    if (values)
+        Actions._setTabs(values);
+};
+/**
+ * "FSBLHeader" can be true, false or an object. If false then we'll never even be here. If true, then maximize, minimize and close buttons will display. If an object, then the developer can override whether buttons are shown with "hideMaximize", "hideMinimize" and "hideClose"
+ */
+const processFSBLHeader = (FSBLHeader, windowTitleBarConfig, options) => {
+    var _a, _b;
+    // Display name is first up for display. If it doesn't exist, we look for a default title (or one that's already set on init). If no title, we display the window's name (e.g., '5434-Welcome Component-2321').
+    const displayName = (_b = (_a = options.customData) === null || _a === void 0 ? void 0 : _a.component) === null || _b === void 0 ? void 0 : _b.displayName;
+    const max = !!FSBLHeader.hideMaximize;
+    windowTitleBarStore.setValues([
+        { field: "Maximize.hide", value: max },
+        { field: "Minimize.hide", value: !!FSBLHeader.hideMinimize },
+        { field: "Close.hide", value: !!FSBLHeader.hideClose },
+        { field: "AlwaysOnTop.show", value: !!FSBLHeader.alwaysOnTop },
+    ]);
+    // By default, we hack the window's scroll bar so that it displays underneath the header. html.overflow: hidden body.overflow:auto
+    windowTitleBarStore.setValue({
+        field: "hackScrollbar",
+        value: windowTitleBarConfig.FSBLHeader.hackScrollbar !== false,
+    });
+    windowTitleBarStore.setValue({
+        field: "adjustContentHeights",
+        value: windowTitleBarConfig.FSBLHeader.adjustContentHeights !== false,
+    });
+    // By default, fixed positioned elements with a top style set to '0px' will be bumped by the header height and the
+    // DOM will be monitored for nodes that are added dynamically and bump them if they are fixed with a top style of 0px.
+    windowTitleBarStore.setValue({
+        field: "bumpElements",
+        value: Object.assign({ fixed: "0Positioned", bumpBy: "25px", monitorFixedAdditions: true }, windowTitleBarConfig.FSBLHeader.bumpElements),
+    });
+};
+// Once the above has been checked the individual component config is checked for customData.foreign.services[windowService || dockingService][!ignoreTilingAndTabbingRequests || allowTabbing]
+const getOptionsCallback = (err, opts) => {
+    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q;
+    const windowAllowTabbing = (_d = (_c = (_b = (_a = opts.customData) === null || _a === void 0 ? void 0 : _a.foreign) === null || _b === void 0 ? void 0 : _b.services) === null || _c === void 0 ? void 0 : _c.windowService) === null || _d === void 0 ? void 0 : _d.allowTabbing;
+    const windowIgnoreTabbing = (_h = (_g = (_f = (_e = opts.customData) === null || _e === void 0 ? void 0 : _e.foreign) === null || _f === void 0 ? void 0 : _f.services) === null || _g === void 0 ? void 0 : _g.windowService) === null || _h === void 0 ? void 0 : _h.ignoreTilingAndTabbingRequests;
+    const dockingAllowTabbing = (_m = (_l = (_k = (_j = opts.customData) === null || _j === void 0 ? void 0 : _j.foreign) === null || _k === void 0 ? void 0 : _k.services) === null || _l === void 0 ? void 0 : _l.dockingService) === null || _m === void 0 ? void 0 : _m.allowTabbing;
+    const dockingIgnoreTabbing = (_q = (_p = (_o = opts.customData) === null || _o === void 0 ? void 0 : _o.foreign.services) === null || _p === void 0 ? void 0 : _p.dockingService) === null || _q === void 0 ? void 0 : _q.ignoreTilingAndTabbingRequests;
+    const dontShowTabs = windowAllowTabbing === false ||
+        windowIgnoreTabbing === true ||
+        dockingAllowTabbing === false ||
+        dockingIgnoreTabbing === true;
+    windowTitleBarStore.setValue({
+        field: "showTabs",
+        value: !dontShowTabs,
+    });
+};
+const processFEAAndFinsembleConfig = (values, windowTitleBarConfig) => {
+    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k;
+    const finsembleConfig = values.finsemble;
+    // Check FEA config for DOM based movement configuration
+    const { useDOMBasedMovement } = values["finsemble-electron-adapter"];
+    windowTitleBarStore.setValue({
+        field: "Main.useDOMBasedMovement",
+        value: typeof useDOMBasedMovement === "undefined" ? true : useDOMBasedMovement,
+    });
+    // Override defaults if finsemble.Window Manager exists.
+    const globalWindowManagerConfig = finsembleConfig["Window Manager"] || {
+        alwaysOnTopIcon: false,
+        showTabs: false,
+    };
+    // Look to see if docking is enabled. Cascade through backward compatibility with old "betaFeatures" and then a default if no config is found at all.
+    finsembleConfig.servicesConfig = (_a = finsembleConfig.servicesConfig) !== null && _a !== void 0 ? _a : {};
+    const defaultDockingConfig = {
+        enabled: true,
+    };
+    let dockingConfig = (_e = (_c = (_b = finsembleConfig.servicesConfig.docking) !== null && _b !== void 0 ? _b : finsembleConfig.docking) !== null && _c !== void 0 ? _c : (_d = finsembleConfig.betaFeatures) === null || _d === void 0 ? void 0 : _d.docking) !== null && _e !== void 0 ? _e : defaultDockingConfig;
+    dockingConfig.tabbing = (_f = dockingConfig.tabbing) !== null && _f !== void 0 ? _f : {};
+    // Whether the alwaysOnTop pin is displayed depends this component's config (foreign.components["Widow Manager"].alwaysOnTop)
+    // and then on the global setting (finsemble["Window Manager"].alwaysOnTop)
+    const alwaysOnTopIcon = (_h = (_g = windowTitleBarConfig.alwaysOnTopIcon) !== null && _g !== void 0 ? _g : globalWindowManagerConfig.alwaysOnTopIcon) !== null && _h !== void 0 ? _h : false;
+    const servicesConfigWindow = finsembleConfig.servicesConfig.window;
+    windowTitleBarStore.setValues([
+        { field: "Main.dockingEnabled", value: dockingConfig.enabled },
+        {
+            field: "allowWindowTitleRenaming",
+            value: (_k = (_j = servicesConfigWindow.allowWindowTitleRenaming) !== null && _j !== void 0 ? _j : dockingConfig.tabbing.allowEditing) !== null && _k !== void 0 ? _k : false,
+        },
+        { field: "AlwaysOnTop.show", value: alwaysOnTopIcon },
+    ]);
+    // If tabbing is turned off, ignore global/local 'windowManager' config about whether to allow tabbing.
+    if (dockingConfig.tabbing.enabled === false) {
+        windowTitleBarStore.setValue({
+            field: "showTabs",
+            value: dockingConfig.tabbing.enabled,
+        });
+    }
+    else {
+        // If tabbing is enabled system-wide, look to the global config for its value. Then look to the local component's config.
+        // This is the global window manager config.
+        if (typeof windowTitleBarConfig.showTabs !== "boolean") {
+            windowTitleBarStore.setValue({
+                field: "showTabs",
+                value: globalWindowManagerConfig.showTabs,
+            });
+        }
+        // This is the component's config.
+        if (windowTitleBarConfig.showTabs || windowTitleBarConfig.showTabs === false) {
+            windowTitleBarStore.setValue({
+                field: "showTabs",
+                value: windowTitleBarConfig.showTabs,
+            });
+        }
+        finsembleWindow.getOptions(getOptionsCallback);
+    }
+};
+// these are constants that are set inside of setupStore. so they're declared as vars and not constants.
+let constants;
+const Actions = {
+    parentWrapperStore: null,
+    initialize: () => {
+        // This ensures that our config is correct, even if the developer missed some entries
+        const { options } = FSBL.Clients.WindowClient;
+        const windowTitleBarConfig = options.customData.foreign.components["Window Manager"];
+        const { FSBLHeader } = windowTitleBarConfig;
+        if (FSBLHeader)
+            processFSBLHeader(FSBLHeader, windowTitleBarConfig, options);
+        if (windowTitleBarConfig.showLinker)
+            showLinkerButton();
+        listenForDNDUpdates();
+        FSBL.Clients.RouterClient.subscribe("Finsemble.WorkspaceService.groupUpdate", onDockingGroupUpdate);
+        // default title.
+        windowTitleBarStore.setValue({
+            field: "Main.windowTitle",
+            value: FSBL.Clients.WindowClient.getWindowTitle(),
+        });
+        FSBL.Clients.ConfigClient.getValues([{ field: "finsemble" }, { field: "finsemble-electron-adapter" }], (err, config) => {
+            if (config)
+                processFEAAndFinsembleConfig(config, windowTitleBarConfig);
+        });
+        Actions.getInitialTabList(processInitialTabList);
+        /**
+         * This store does not listen on window events (such as "maximized" or "minimized") - that is the
+         * WindowClient's job. The headerCommandChannel allows the WindowClient to affect the display state
+         * of the windowTitleBar - such as changing the maximize icon when a "maximized" event is received.
+         */
+        FSBL.Clients.WindowClient.headerCommandChannel((command, state) => {
+            Actions.remoteStateUpdate(command, state);
+        });
+    },
+    /**
+     * Helper function to sift through all of the data coming from the windowService. Outputs an array of groups that the window belongs to.
+     */
+    getMyDockingGroups: function (groupData) {
+        let myGroups = [];
+        let windowName = getWindowNameForDocking(finsembleWindow);
+        if (finsembleWindow === null || finsembleWindow === void 0 ? void 0 : finsembleWindow.parentWindow) {
+            windowName = finsembleWindow === null || finsembleWindow === void 0 ? void 0 : finsembleWindow.parentWindow.name;
+        }
+        FSBL.Clients.Logger.system.debug("Getting docking groups for ", windowName, groupData);
+        if (groupData) {
+            for (let groupName in groupData) {
+                groupData[groupName].groupName = groupName;
+                if (groupData[groupName].windowNames.includes(windowName)) {
+                    myGroups.push(groupData[groupName]);
+                }
+            }
+        }
+        return myGroups;
+    },
+    onTabListScrollPositionChanged: function (err, response) {
+        windowTitleBarStore.setValue({
+            field: "tabListTranslateX",
+            value: response.data.translateX,
+        });
+    },
+    setTabListScrollPosition: function (translateX) {
+        FSBL.Clients.RouterClient.transmit(constants.TAB_SCROLL_POSITION_CHANGED, {
+            translateX,
+        });
+    },
+    /**
+     * Handles messages coming from the windowClient.
+     */
+    remoteStateUpdate: function (command, state) {
+        const key = Object.keys(state)[0];
+        const field = `${command}.${key}`;
+        windowTitleBarStore.setValue({ field: field, value: state[key] });
+    },
+    /**
+     * Minimizes the window.
+     */
+    clickMinimize: function () {
+        finsembleWindow.minimize(() => { });
+    },
+    /**
+     * Closes the window, allows for cleanup. Removes the window from workspace; this function is only invoked when the user clicks the close button.
+     */
+    clickClose: function () {
+        FSBL.Clients.WindowClient.close({
+            closeWindow: true,
+            removeFromWorkspace: true,
+            userInitiated: true,
+        });
+    },
+    /**
+     * Toggles group membership. If two windows are snapped, and this button is clicked, they become part of the same group that can be moved around together.
+     */
+    toggleGroup: function () {
+        const groups = windowTitleBarStore.getValue({ field: "Main.dockingGroups" });
+        const isInMovableGroup = groups.some((group) => group.isMovable);
+        if (isInMovableGroup) {
+            finsembleWindow.ejectFromGroup();
+        }
+        else {
+            finsembleWindow.formGroup();
+        }
+    },
+    /**
+     * Maximizes the window.
+     */
+    clickMaximize: function () {
+        if (finsembleWindow.windowOptions.windowState !== finsembleWindow.WINDOWSTATE.MAXIMIZED)
+            return finsembleWindow.maximize(() => {
+                windowTitleBarStore.setValue({
+                    field: "Maximize.maximized",
+                    value: true,
+                });
+            });
+        return finsembleWindow.restore(() => {
+            windowTitleBarStore.setValue({
+                field: "Maximize.maximized",
+                value: false,
+            });
+        });
+    },
+    getTabs() {
+        return windowTitleBarStore.getValue({ field: "tabs" });
+    },
+    _setTabs(tabs) {
+        FSBL.Clients.Logger.system.debug("Set tabs", tabs);
+        let activeIdentifier = finsembleWindow.identifier;
+        activeIdentifier.title = finsembleWindow.windowOptions.title;
+        return windowTitleBarStore.setValue({
+            field: "tabs",
+            value: tabs || [activeIdentifier],
+        });
+    },
+    addTabLocally: function (windowIdentifier, i) {
+        let tabs = Actions.getTabs();
+        if (typeof i === "undefined") {
+            i = tabs.length + 1;
+        }
+        tabs.splice(i, 0, windowIdentifier);
+        Actions._setTabs(tabs);
+    },
+    removeTabsLocally: function () {
+        Actions._setTabs(null);
+    },
+    removeTabLocally: function (windowIdentifier) {
+        let tabs = Actions.getTabs();
+        let i = tabs.findIndex((el) => el.windowName === windowIdentifier.windowName);
+        tabs.splice(i, 1);
+        Actions._setTabs(tabs);
+    },
+    reorderTabLocally: function (tab, newIndex) {
+        let tabs = Actions.getTabs();
+        let { currentIndex } = Actions.findTab(tab);
+        if (currentIndex === newIndex)
+            return;
+        if (currentIndex === -1) {
+            return Actions.addTabLocally(tab, newIndex);
+        }
+        tabs.splice(currentIndex, 1);
+        tabs.splice(newIndex, 0, tab);
+        Actions._setTabs(tabs);
+    },
+    addTab: function (windowIdentifier, i) {
+        let tabs = Actions.getTabs();
+        tabs.push(windowIdentifier);
+        // quick UI update
+        Actions._setTabs(tabs);
+        let callback = () => {
+            var _a;
+            (_a = Actions.parentWrapper) === null || _a === void 0 ? void 0 : _a.setVisibleWindow({ windowIdentifier });
+        };
+        if (!Actions.parentWrapper) {
+            return Actions.createParentWrapper({
+                windowIdentifiers: finsembleWindow.identifier
+                    ? [finsembleWindow.identifier, windowIdentifier]
+                    : [windowIdentifier],
+                visibleWindowIdentifier: windowIdentifier,
+                create: true,
+            });
+        }
+        return Actions.parentWrapper.addWindow({ windowIdentifier, position: i }, callback);
+    },
+    removeTab: function (windowIdentifier, i) {
+        var _a;
+        return (_a = Actions.parentWrapper) === null || _a === void 0 ? void 0 : _a.removeWindow({
+            windowIdentifier,
+            position: i,
+        });
+    },
+    closeTab: function (windowIdentifier) {
+        const close = (err, wrap) => {
+            wrap.close({ removeFromWorkspace: true });
+        };
+        FSBL.FinsembleWindow.getInstance(windowIdentifier, close);
+    },
+    reorderTab: function (tab, newIndex) {
+        let tabs = Actions.getTabs();
+        let { currentIndex } = Actions.findTab(tab);
+        if (currentIndex === -1 || !Actions.parentWrapper) {
+            return Actions.addTab(tab, newIndex);
+        }
+        tabs.splice(currentIndex, 1);
+        tabs.splice(newIndex, 0, tab);
+        // Local change, quickly updates the dom.
+        Actions._setTabs(tabs);
+        Actions.parentWrapper.reorder({ windowIdentifiers: tabs });
+    },
+    findTab: function (tab) {
+        let tabs = Actions.getTabs();
+        let currentIndex = tabs.findIndex((el) => tab.windowName === el.windowName);
+        return { tab, currentIndex };
+    },
+    setActiveTab: function (windowIdentifier) {
+        FSBL.Clients.Logger.system.debug("setActiveTab.visibleWindow");
+        return finsembleWindow.parentWindow.setVisibleWindow({ windowIdentifier });
+    },
+    parentWrapper: null,
+    onTabListChanged: function (err, response) {
+        FSBL.Clients.Logger.system.debug("OnTabListChanged", response.data);
+        if (response.data && response.data.hasOwnProperty(constants.CHILD_WINDOW_FIELD)) {
+            Actions._setTabs(response.data[constants.CHILD_WINDOW_FIELD]);
+        }
+    },
+    parentSubscriptions: [],
+    stopListeningOnParentWrapper: function (cb) {
+        Actions.parentSubscriptions.forEach((sub) => {
+            FSBL.Clients.RouterClient.unsubscribe(sub);
+        });
+        Actions.parentSubscriptions = []; // remove the subscribeId
+        // Syncs scroll state across all tabs in a stack.
+        FSBL.Clients.RouterClient.removeListener(constants.TAB_SCROLL_POSITION_CHANGED, Actions.onTabListScrollPositionChanged);
+        cb();
+    },
+    listenOnParentWrapper: function () {
+        let TABLIST_SUBSCRIPTION = FSBL.Clients.RouterClient.subscribe(constants.PARENT_WRAPPER_UPDATES, Actions.onTabListChanged);
+        FSBL.Clients.RouterClient.addListener(constants.TAB_SCROLL_POSITION_CHANGED, Actions.onTabListScrollPositionChanged);
+        Actions.parentSubscriptions.push(TABLIST_SUBSCRIPTION);
+    },
+    setupStore: function (cb = Function.prototype) {
+        var _a, _b, _c;
+        constants = {
+            PARENT_WRAPPER_UPDATES: `Finsemble.StackedWindow.${(_b = (_a = Actions.parentWrapper) === null || _a === void 0 ? void 0 : _a.identifier) === null || _b === void 0 ? void 0 : _b.windowName}`,
+            CHILD_WINDOW_FIELD: "childWindowIdentifiers",
+            VISIBLE_WINDOW_FIELD: "visibleWindowIdentifier",
+            TAB_SCROLL_POSITION_CHANGED: `${(_c = Actions.parentWrapper) === null || _c === void 0 ? void 0 : _c.name}.tabListTabListScrollPositionChanged`,
+        };
+        Actions.listenOnParentWrapper();
+        cb();
+    },
+    getInitialTabList: function (cb) {
+        finsembleWindow.getParent((err, parentWrapper) => {
+            Actions.parentWrapper = parentWrapper;
+            if (Actions.parentWrapper) {
+                FSBL.Clients.Logger.system.debug("GetInitialTabList, parent exists");
+                Actions.setupStore(cb);
+            }
+            else {
+                let activeIdentifier = finsembleWindow.identifier;
+                activeIdentifier.title = finsembleWindow.windowOptions.title;
+                let tabs = [activeIdentifier];
+                cb(null, tabs);
+            }
+        });
+    },
+    createParentWrapper(params, cb = Function.prototype) {
+        window.Actions = Actions;
+        if (Actions.parentWrapper) {
+            cb();
+        }
+        else {
+            const getStackedWindowCallback = (err, wrap) => {
+                if (err) {
+                    Actions.parentWrapper = null;
+                    Actions._setTabs(null);
+                }
+                else {
+                    Actions.parentWrapper = wrap;
+                    Actions.setupStore(cb);
+                }
+            };
+            getStackedWindow(params, getStackedWindowCallback);
+        }
+    },
+};
+/**
+ * Initializes the store for the windowTitleBar.
+ *
+ * @param {any} cb
+ */
+function initialize(cb) {
+    FSBL.Clients.DistributedStoreClient.createStore({ store: "windowTitleBarStore", values: windowTitleBarStoreDefaults }, (err, store) => {
+        if (!err && store) {
+            windowTitleBarStore = store;
+        }
+        Actions.initialize();
+        return cb(store, Actions);
+    });
+}
+let getStore = () => windowTitleBarStore;
+class StoreManager {
+    constructor() {
+        this.initialized = false;
+        this.initializing = false;
+        this.store = null;
+        this.callbacks = [];
+    }
+    initialize() {
+        if (this.initializing)
+            return;
+        this.initializing = true;
+        initialize((store) => {
+            this.initialized = true;
+            this.store = store;
+            this.callbacks.forEach((cb) => cb(store));
+        });
+    }
+    addInitializedListener(cb) {
+        if (this.initialized)
+            return cb(this.store);
+        this.callbacks.push(cb);
+    }
+    removeInitializedListener(cb) {
+        this.callbacks = this.callbacks.filter((entry) => entry !== cb);
+    }
+}
+const storeManager = new StoreManager();
+export { storeManager };
+export { initialize };
+export { windowTitleBarStore as Store };
+export { Actions };
+export { getStore };
+//# sourceMappingURL=windowTitleBarStore.js.map