@finsemble/finsemble-ui 8.3.0 → 8.3.1

package/clients/windowClient.js

@@ -7,7 +7,7 @@
  * @module WindowClient
  */
 /**
-This is how we want our API to work going foward, the way the world does it: import { processAndSet } from "configClient"
+This is how we want our API to work going forward, the way the world does it: import { processAndSet } from "configClient"
 ```
 export const processAndSet = () => { ... }
 ```
@@ -26,7 +26,6 @@ This can be eliminated when our core core is converted to normal imports as in t
 export default ConfigClient;
 ```
 */
-import { LauncherClient } from "./launcherClient";
 import { System } from "../common/system";
 import { Logger } from "./logger";
 import { RouterClient } from "./routerClient";
@@ -38,6 +37,8 @@ import { cacheInitialBounds as cacheInitialBoundsFromStartup } from "./Startup/w
 import { singleton } from "../common/Singleton";
 import SystemManagerClient from "../common/systemManagerClient";
 import { FinsembleWindow } from "../common/FinsembleWindow";
+import { actions, emptyStore } from "../platform/services/window/modules/actions";
+import { getRemoteStoreAsSingleton, getRemoteState } from "../common/redux/getRemoteStore";
 /**
  * The WindowClientController is a singleton which serves as the backing for the WindowClient export. Even though WindowClient
  * is exported, there can still be more than one instance when running with an FEA preload. In these circumstances, the singleton
@@ -54,7 +55,6 @@ class WindowClientController {
         this.options = {};
         this.title = null;
         this.windowGroups = [];
-        this.commandChannel = undefined;
     }
     /**
      * Handler for group updates from the window service.  Stores the groups that this window is in,
@@ -71,28 +71,12 @@ class WindowClientController {
             return;
         this.windowGroups = Object.values(res.data.groupData).filter((group) => group.windowNames.includes(deprecatedGetWindowNameForDocking(FEAGlobals.finsembleWindow)));
     }
-    /**
-     * Sends a command to the header. Commands affect the header state,
-     * so that the UI reflects what is going on in the component window.
-     * @param {string} command The state object to set
-     * @param {object} state The new state (merged with existing)
-     */
-    updateHeaderState(command, state) {
-        var _a;
-        (_a = this.commandChannel) === null || _a === void 0 ? void 0 : _a.call(this, command, state);
-    }
     setStartupData(systemStartupData) {
         this.options = systemStartupData;
     }
     async start() {
         await SystemManagerClient.waitForStartup("windowService");
         RouterClient.subscribe("Finsemble.WorkspaceService.groupUpdate", (groupUpdateSubscribeErr, res) => this.groupUpdateHandler(groupUpdateSubscribeErr, res));
-        FEAGlobals.finsembleWindow.addEventListener("maximized", () => {
-            this.updateHeaderState("Maximize", { hide: true });
-        });
-        FEAGlobals.finsembleWindow.addEventListener("restored", () => {
-            this.updateHeaderState("Maximize", { hide: false });
-        });
         // On Blur remove the border from window
         FEAGlobals.finsembleWindow.addEventListener("blurred", () => {
             deprecatedSetActive(false);
@@ -108,8 +92,8 @@ class WindowClientController {
  */
 export const getControllerInstance = () => singleton("WindowClient", WindowClientController);
 /**
- * Returns a list of the groups this window is in, if any.
  * @deprecated
+ * Returns a list of the groups this window is in, if any.
  */
 const getWindowGroups = () => {
     Logger.deprecated("getWindowGroups() is deprecated and will be removed in a future release.");
@@ -117,6 +101,7 @@ const getWindowGroups = () => {
     return controller.windowGroups;
 };
 /**
+ * @language javascript, java, dotnet
  * Closes window. Defaults are to remove the window from the workspace if the user presses the X button, but not if the window is closed via an app-level request (e.g., switching workspaces, so all windows need to close).
  *
  * ```javascript
@@ -129,27 +114,19 @@ const getWindowGroups = () => {
  * @param {boolean} params.removeFromWorkspace Whether to remove the window from the workspace.
  * @param {boolean} params.closeWindow Whether to close the window. On shutdown this method is called, but the Window Service actually closes the window.
  * @param {boolean} params.userInitiated Whether the user clicked the X, or if the system asked the window to close.
- * @param {boolean} params.ignoreParent Whether or not to update the parent (stack) window when closing.
  * @param {function} cb The callback to be invoked after the method completes successfully.
  */
 export const close = (params, cb) => {
     if (!params) {
         params = { removeFromWorkspace: true, closeWindow: true };
     }
-    const { parentWindow } = FEAGlobals.finsembleWindow;
-    if (params.userInitiated && parentWindow) {
-        return parentWindow.close(params, cb);
-    }
-    else {
-        return FEAGlobals.finsembleWindow.close(params, cb);
-    }
+    return FEAGlobals.finsembleWindow.close(params, cb);
 };
 /**
+ * @language javascript, java, dotnet
  * Retrieves the window's title.
  *
- * ```javascript
- * let windowTitle = FSBL.Clients.WindowClient.getWindowTitle();
- * ```
+ * @deprecated
  * @returns {String} title
  */
 export const getWindowTitle = () => {
@@ -195,7 +172,7 @@ const getWindowBounds = () => {
  *
  * The code below is the bulk of our listener for the <code>bounds-changed</code> event from the window. Every time the <code>bounds-changed</code> event is fired (when the window is resized or moved), we save the window's state. The first few lines just prevent the window from being dropped behind the toolbar.
  * ```javascript
- *finWindow.addEventListener('disabled-frame-bounds-changed', function (bounds) {
+ * finWindow.addEventListener('disabled-frame-bounds-changed', function (bounds) {
  * 	if (bounds.top < 45) {
  *		finWindow.moveTo(bounds.left, 45);
  *		return;
@@ -235,6 +212,7 @@ const saveWindowBounds = (bounds, setActiveWorkspaceDirty) => {
     }
 };
 /**
+ * @language javascript, java, dotnet
  * Maximizes the window taking into account any claimed space on the monitor.
  *
  * ```javascript
@@ -244,6 +222,7 @@ const saveWindowBounds = (bounds, setActiveWorkspaceDirty) => {
  */
 export const maximize = (cb) => FEAGlobals.finsembleWindow.maximize(null, cb);
 /**
+ * @language javascript, java, dotnet
  * Minimizes window.
  *
  * ```javascript
@@ -253,6 +232,7 @@ export const maximize = (cb) => FEAGlobals.finsembleWindow.maximize(null, cb);
  */
 export const minimize = (cb) => FEAGlobals.finsembleWindow.minimize(null, cb);
 /**
+ * @language javascript, java
  * Brings the window to the top of all other windows.
  *
  * ```javascript
@@ -261,9 +241,12 @@ export const minimize = (cb) => FEAGlobals.finsembleWindow.minimize(null, cb);
  */
 export const bringToFront = (cb) => FEAGlobals.finsembleWindow.bringToFront({ forceFocus: true }, cb);
 /**
+ * @language javascript, java, dotnet
+ * @deprecated Use [`bringToFront()`](#bringtofront) instead, which returns a promise.
+ *
  * Brings the window to the top of all other windows
  *
- * This is a non-promisifed version for backward compatibility. Please use WindowClient.bringToFront()
+ * This is a non-promise version for backward compatibility. Please use WindowClient.bringToFront()
  *
  * @deprecated Use `bringToFront()` instead, which returns a promise.
  */
@@ -272,6 +255,7 @@ export const bringWindowToFront = (cb) => {
     FEAGlobals.finsembleWindow.bringToFront({ forceFocus: true }, cb);
 };
 /**
+ * @language javascript, java, dotnet
  * Sets whether window is always on top. By default, this is false.
  *
  * ```javascript
@@ -282,6 +266,7 @@ export const bringWindowToFront = (cb) => {
  */
 export const setAlwaysOnTop = (alwaysOnTop, cb) => FEAGlobals.finsembleWindow.setAlwaysOnTop({ alwaysOnTop }, cb);
 /**
+ * @language javascript, java, dotnet
  * Restores window from a maximized or minimized state.
  *
  * ```javascript
@@ -291,15 +276,21 @@ export const setAlwaysOnTop = (alwaysOnTop, cb) => FEAGlobals.finsembleWindow.se
  */
 export const restore = (cb) => FEAGlobals.finsembleWindow.restore(null, cb);
 /**
+ * @language javascript, java
+ * :::tip Important
  * _This feature is experimental. The signature may change in the future._
+ * :::
  *
  * Sets an overlay image on the MS Windows taskbar, for instance to indicate activity.
  * (This is sometimes referred to as a "badge").
  *
  * The url must point to a 16x16 png image. Images of other sizes or types will not display.
  *
- * Note: MacOS does not support taskbar overlay images. This function is safe to call
+ * :::note
+ * MacOS does not support taskbar overlay images. This function is safe to call
  * on MacOS but will not perform any function.
+ * :::
+ *
  * @param url - The url of the icon to use. Pass null to remove the overlay icon.
  */
 export const setTaskbarIconOverlay = (url) => {
@@ -338,6 +329,7 @@ const getElementFinsembleWindow = async (params) => {
     return FEAGlobals.finsembleWindow;
 };
 /**
+ * @language javascript, java, dotnet
  * Given a field, this function retrieves app state. If no params are given, the full state is returned.
  *
  * The example below shows how we retrieve data to restore the layout in our charts.
@@ -375,6 +367,7 @@ export const getComponentState = async (params, cb) => new Promise(async (resolv
     });
 });
 /**
+ * @language javascript, java, dotnet
  * Given a field, this function sets and persists app state.
  *
  * The example below shows how we save our chart layout when it changes.
@@ -382,7 +375,10 @@ export const getComponentState = async (params, cb) => new Promise(async (resolv
  * let s = stx.exportLayout(true);
  * //saving layout'
  * FSBL.Clients.WindowClient.setComponentState({ field: 'myChartLayout', value: s });
- * FSBL.Clients.WindowClient.setComponentState({ fields: [{field:'myChartLayout', value: s }, {field:'chartType', value: 'mountain'}]);
+ * FSBL.Clients.WindowClient.setComponentState({ fields: [
+ * 	{field:'myChartLayout', value: s },
+ * 	{field:'chartType', value: 'mountain'}
+ * ]});
  * ```
  * @param {object} params Object of data to be saved
  * @param {string} params.field The key name of the field to be saved. Required if not using `fields`.
@@ -399,13 +395,14 @@ export const setComponentState = async (params, cb) => new Promise(async (resolv
     });
 });
 /**
+ * @language javascript, java, dotnet
  * Given a field, this function removes it from app state.
  *
  * The example below shows how we would remove our chart layout when it no longer needed.
  * ```javascript
  * // remove unused state value
  * FSBL.Clients.WindowClient.removeComponentState({ field: 'myChartLayout'});
- * FSBL.Clients.WindowClient.removeComponentState({ fields: [{field:'myChartLayout'}, {field:'chartType'}]);
+ * FSBL.Clients.WindowClient.removeComponentState({ fields: [{field:'myChartLayout'}, {field:'chartType'}]});
  * ```
  * @param {object} params Object of data to be removed
  * @param {string} params.field The key name of the field to be saved. Required if not using `fields`.
@@ -421,14 +418,18 @@ export const removeComponentState = async (params, cb) => new Promise(async (res
     });
 });
 /**
- * Gets the window name of current window or the parent, if tabbed. The code that manages window movement will not see a child window if it's part of a stacked window. This function will return the window name that the Window Service cares about for window movement.
+ * @language javascript
+ * Gets the window name of current window. The code that manages window movement will not see a child window if it's part of a stacked window. This function will return the window name that the Window Service cares about for window movement.
  * @deprecated
+ *
+ * Gets the window name of current window or the parent, if tabbed. The code that manages window movement will not see a child window if it's part of a stacked window. This function will return the window name that the Window Service cares about for window movement.
  */
 export const getWindowNameForDocking = () => {
     Logger.deprecated("WindowClient.getWindowNameForDocking is deprecated and will be removed");
     return deprecatedGetWindowNameForDocking(FEAGlobals.finsembleWindow);
 };
 /**
+ * @language javascript
  * Forms a group with any window that is touching the border of this window.
  */
 export const formGroup = () => {
@@ -444,49 +445,35 @@ const addListeners = () => {
     Logger.deprecated("Do not call WindowClient.addListeners() directly");
 };
 /**
- * Establishes a command channel with the <a href="tutorial-UIComponents.html#window-title-bar-aka-the-fsblheader">Finsemble window title bar component</a>. The Window Client can
- * update the title bar's state via this channel. This code will be moved into finsemble-ui.
- * @param {function} commandChannel A function callback that receives commands.
- */
-const headerCommandChannel = (commandChannel) => {
-    const controller = getControllerInstance();
-    controller.commandChannel = commandChannel;
-};
-/**
+ * @language javascript
  * Ejects the window from the docking group
  * @deprecated This code will be moved to finsemble-ui
+ * Ejects the window from the docking group
  */
 export const ejectFromGroup = () => {
     Logger.deprecated("WindowClient.ejectFromGroup is deprecated and will be removed");
     FEAGlobals.finsembleWindow.ejectFromGroup();
 };
 /**
- * @param title Title for the window
- */
-const setWindowTitlePrivate = (title) => {
-    const controller = getControllerInstance();
-    controller.title = title;
-    // TODO, singleton
-    // document.title = title;  // causes flickering in chromium 53
-    controller.updateHeaderState("Main", { windowTitle: title });
-    FEAGlobals.finsembleWindow.setTitle(title);
-};
-/**
- * Deprecated. Please simply set the application's `document.title` element to change the title that appears
- * in the window's title bar. Or, set `components["Window Manager"].title` in the app's manifest.
- *
- * Old documentation:
- * This function sets the window's title in the window title bar area as well as in the DOM's title element.
- * This is useful to set the title dynamically based on state information: you can keep the window's title in sync with a piece of data (e.g., a Symbol).
- * This title will not persist between sessions automatically; use setComponentState/getComponentState to persist the title.
- * @param {String} title Window title.
- * @deprecated
+ * @language javascript, java, dotnet
+ * This method overrides the app title that displays in the app's title bar or tab. This will take precedence over
+ * the document.title or title that is set in the app's config. This will however be overridden by an user edited title.
+ * @param title Window title.
  */
 const setWindowTitle = (title) => {
-    Logger.system.deprecated("This method is deprecated and will be removed in a future release. Please simply set the application's `document.title` element to change the title. Or, set `components['Window Manager'].title` in the app's manifest.");
-    setWindowTitlePrivate(title);
+    const store = getRemoteStoreAsSingleton({
+        singletonName: "WindowClient::setWindowTitle",
+        server: "@@finsemble/remoteRedux/WindowServiceStore",
+        slice: "windowTitleBar",
+        emptyStore,
+        dispatchOnly: true,
+    });
+    store.dispatch(actions.setAPITitle({
+        title,
+    }));
 };
 /**
+ * @language javascript, java, dotnet
  * Retrieves data that was set with <a href="/docs/reference/typedocs/modules/LauncherClient#spawn">LauncherClient.spawn</a>.
  * @returns The spawnData that was passed to calls to LauncherClient.spawn, or an empty object.
  */
@@ -496,9 +483,11 @@ export const getSpawnData = () => {
     return (_c = (_b = (_a = controller.options) === null || _a === void 0 ? void 0 : _a.customData) === null || _b === void 0 ? void 0 : _b.spawnData) !== null && _c !== void 0 ? _c : {};
 };
 /**
+ * @language javascript, java, dotnet
+ * @deprecated Use `FSBL.System.Window.getCurrent()`
+ *
  * Returns a reference to the current FEAWindow for the component.
  * @returns {finWindow}
- * @deprecated Use `FSBL.System.Window.getCurrent()`
  */
 export const getCurrentWindow = () => {
     // getCurrentWindow() is still being used by e2e tests and the zoom.js preload. Don't change this to
@@ -532,6 +521,7 @@ const isMouseOverDOMElement = (element, cb) => {
     return isMouseOverDOMElementFromUtil(element, cb);
 };
 /**
+ * @language javascript, java, dotnet
  * Returns the window identifier for the current component.
  * @returns {WindowIdentifier}
  */
@@ -545,22 +535,24 @@ export const getWindowIdentifier = () => {
     };
 };
 /**
+ * @deprecated
  * Highlights the window as active by creating a border around the window.
  *
  * @param {boolean} active  Set to false to turn off activity
- * @deprecated
  */
 const setActive = (active) => {
     Logger.deprecated("WindowClient.setActive is deprecated and will be removed");
     deprecatedSetActive(active);
 };
 /**
+ * @language javascript, java, dotnet
  * Returns the object defining bounds for the current window including the position of the left and right edges measured in pixels from the left edge of the monitor, the top and bottom edges measured in pixels from the top edge, and the width and height of the component in pixels.
  * Please note that this method differs from the right and bottom coordinates passed to LauncherClient.spawn(); those are measured from the right and bottom edges of the screen.
  * @param {StandardCallback} cb The callback to be invoked after the method completes successfully.
  */
 export const getBounds = (cb) => FEAGlobals.finsembleWindow.getBounds(cb);
 /**
+ * @language javascript
  * Defines areas of the window that will be displayed and clickable. All other areas of the window will be transparent.
  * Can be used to create click-through areas of a window.
  *
@@ -578,6 +570,7 @@ export const setShape = (params, callback = Function.prototype) => {
     FEAGlobals.finsembleWindow.setShape(params, callback);
 };
 /**
+ * @language javascript
  * This is used by the Finsemble window title bar when a tab is dragged for tiling or tabbing.
  * @param {*} params - <code>params.windowIdentifier</code> is required.
  * @param {WindowIdentifier} params.windowIdentifier The Finsemble identifier for the target window.
@@ -590,6 +583,7 @@ export const startTilingOrTabbing = (params, cb) => {
     cb === null || cb === void 0 ? void 0 : cb();
 };
 /**
+ * @language javascript
  * Begin programmatically moving the window; the first parameter is a mouse event. Until `stopMovingWindow` is invoked, the window will follow the user's mouse. This should be invoked inside of a `mouseDown` event handler.
  */
 export const startMovingWindow = (event) => {
@@ -597,6 +591,7 @@ export const startMovingWindow = (event) => {
     currentWindow.startMovingWindow(event);
 };
 /**
+ * @language javascript
  * Stops moving a window that was set in motion via `startMovingWindow`.
  */
 export const stopMovingWindow = () => {
@@ -604,6 +599,7 @@ export const stopMovingWindow = () => {
     currentWindow.stopMovingWindow();
 };
 /**
+ * @language javascript
  * This is used to cancel a tabbing or tiling operation.
  *
  * @param {object} params
@@ -618,18 +614,7 @@ export const cancelTilingOrTabbing = (params, cb) => {
     cb === null || cb === void 0 ? void 0 : cb();
 };
 /**
- * This is used to let Finsemble know which window is being dragged. <code>params.windowIdentifier</code> must be the identifier of the tab being dragged. This is only used if the identifier is unknown when <code>startTilingOrTabbing</code> is called.
- * @param {*} params - The <code>windowIdentifier</code> is required.
- * @param {WindowIdentifier} params.windowIdentifier The Finsemble identifier for the target window.
- * @param {*} cb - The callback to be invoked after the method completes successfully.
- * @deprecated This code will be moved into finsemble-ui
- */
-export const sendIdentifierForTilingOrTabbing = (params, cb) => {
-    Logger.deprecated("WindowClient.sendIdentifierForTilingOrTabbing is deprecated and will be removed");
-    RouterClient.transmit("DockingService.identifierForTilingOrTabbing", params);
-    cb === null || cb === void 0 ? void 0 : cb();
-};
-/**
+ * @language javascript, java
  * This function is used by the Finsemble window title bar to end tiling or tabbing.
  * @param {*} params
  * @param {object} params.mousePosition Where the pointer is on the screen
@@ -663,52 +648,6 @@ export const stopTilingOrTabbing = (params, cb) => {
     if (!params.allowDropOnSelf)
         cb === null || cb === void 0 ? void 0 : cb();
 };
-/**
- * Gets the stackedWindow (if this window is a child of a stacked window).
- *
- * If the calling window is not part of a stacked window, the stacked window identifier will be returned null -- unless params.create is true. In this case, a stacked window will be created and the calling window will be set as the first child
- *
- * (Typically used by Tabbing Presentation component to manage tabs.)
- *
- * @param {object=} params
- * @param {array=} params.create if true and StackedWindow isn't defined, then it will be created
- * @param {array=} params.windowIdentifiers if creating, then can optionally specify an array of other windowIdentifiers to add to stack on creation (in addition to this window).
- * @param {function} cb cb(err, stackedWindowIdentifier)
- *
- * Typically used by Tabbing Presentation component.
- * @deprecated Move this code into UI library (windowTitleBarStore)
- */
-const getStackedWindow = (params, cb) => {
-    Logger.deprecated("WindowClient.getStackedWindow is deprecated and will be removed");
-    Logger.system.debug("WindowClient.getStackedWindow", params);
-    cb = cb || params;
-    params = params || {};
-    params.windowIdentifiers = params.windowIdentifiers || [];
-    if (!FEAGlobals.finsembleWindow.parentWindow && params.create) {
-        const onParentSet = (evt) => {
-            const { parentName } = evt.data;
-            FEAGlobals.finsembleWindow.setParent({ windowName: parentName }, (err2, windowWrapper) => {
-                cb === null || cb === void 0 ? void 0 : cb(err2, windowWrapper);
-            });
-            FEAGlobals.finsembleWindow.removeListener("parent-set", onParentSet);
-        };
-        FEAGlobals.finsembleWindow.addListener("parent-set", onParentSet);
-        LauncherClient.spawn("StackedWindow", {
-            windowType: "StackedWindow",
-            data: { windowIdentifiers: params.windowIdentifiers },
-            options: { newStack: true },
-        }, (err, windowInfo) => {
-            Logger.system.debug("WindowClient.getStackedWindow-success", err, windowInfo);
-            if (!err) {
-                return;
-            }
-            cb === null || cb === void 0 ? void 0 : cb(err, null);
-        });
-    }
-    else {
-        FEAGlobals.finsembleWindow.getParent(cb);
-    }
-};
 /**
  *
  */
@@ -717,11 +656,24 @@ const getMonitorInfo = async (params = {}, cb) => {
     return getWhichMonitorClientSide(RouterClient, params, cb);
 };
 /**
+ * @language javascript, java, dotnet
  * Moves the window so that it's centered above the user's mouse.
  */
 export const showAtMousePosition = () => {
     RouterClient.transmit("DockingService.showAtMousePosition", getWindowIdentifier());
 };
+/**
+ * @language javascript
+ * Resize the window to fit the contents of the window's DOM, with optional padding.
+ *
+ * @param [params] optional parameters
+ * @param [params.padding] allow for padding around to DOM contents
+ * @param {number} [params.padding.height] extra pixels to add to the total height of the window. Default is 0
+ * @param {number} [params.padding.width] extra pixels to add to the total width of the window. Default is 0
+ * @param {number} [params.maxHeight] the maximum height to size the window to
+ * @param {number} [params.maxWidth] the maximum width to size the window to
+ * @param [cb] The callback to be invoked after the method completes successfully.
+ */
 export const fitToDOM = async (params, cb) => {
     var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k;
     if (typeof params === "function") {
@@ -734,7 +686,7 @@ export const fitToDOM = async (params, cb) => {
     if (!bounds)
         return;
     /*
-    // Injected titlebars monkey with the body height by setting a calc() in the css
+    // Injected title bars monkey with the body height by setting a calc() in the css
     // We have to remove this to get the necessary calculations to fit to the DOM
     if(document.body.style.height?.includes("calc"))
         document.body.style.height = "auto";
@@ -771,6 +723,209 @@ export const fitToDOM = async (params, cb) => {
     }
     cb === null || cb === void 0 ? void 0 : cb();
 };
+/**
+ * @language javascript, dotnet
+ * Forms a tab collection from a list of _existing_ windows. (See [LauncherClient.spawnTabCollection()](./LauncherClient#spawnTabCollection) to form a tab
+ * collection from non-existing windows.)
+ *
+ * ```javascript
+ * await FSBL.Clients.windowClient.createTabCollection({
+ * 	windowNames: ["MyApp-3443-fdf-343-fdfdf","MyOtherApp-dfdf-sdsd-dfdf-sdsd"],
+ * 	promotedTab: "MyOtherApp-dfdf-sdsd-dfdf-sdsd"
+ * })
+ * ```
+ * @param __namedParameters.windowNames - An array of window names to put in the collection. The tabs will retain the ordering of this array.
+ * @param __namedParameters.promotedTab - The name of the tab to be promoted. If not set then the first window will be promoted.
+ */
+export const createTabCollection = async ({ windowNames, promotedTab, }) => {
+    const store = getRemoteStoreAsSingleton({
+        singletonName: "WindowClient::tabCollection",
+        server: "@@finsemble/remoteRedux/WindowServiceStore",
+        slice: "api",
+        emptyStore,
+        dispatchOnly: true,
+    });
+    store.dispatch(actions.createTabCollection({
+        windowNames,
+        promotedWindowName: promotedTab,
+    }));
+};
+/**
+ * @language javascript, dotnet
+ * Adds one or more windows to an existing tab collection.
+ *
+ * ```javascript
+ * await FSBL.Clients.windowClient.addToTabCollection({
+ * 	tabCollectionId: ["StackedWindow-sdsd-343-dsds"],
+ * 	windowNames: ["MyApp-3443-fdf-343-fdfdf","MyOtherApp-dfdf-sdsd-dfdf-sdsd"],
+ * 	position: 2,
+ * 	promotedTab: "MyOtherApp-dfdf-sdsd-dfdf-sdsd"
+ * })
+ * ```
+ * @param __namedParameters.windowNames - An array of window names to be added to the collection.
+ * @param __namedParameters.tabCollectionId - ID of the tabCollection to join.
+ * @param __namedParameters.position - Specifies where in the collection to add the new tabs. If not set then they will be appended to the end of the collection.
+ * @param __namedParameters.promotedTab - Tab to be promoted. If not set then the promoted tab will not be changed.
+ */
+export const addToTabCollection = async ({ windowNames, tabCollectionId, position, promotedTab, }) => {
+    const store = getRemoteStoreAsSingleton({
+        singletonName: "WindowClient::tabCollection",
+        server: "@@finsemble/remoteRedux/WindowServiceStore",
+        slice: "api",
+        emptyStore,
+        dispatchOnly: true,
+    });
+    store.dispatch(actions.addTabsToTabCollection({
+        windowNames,
+        tabCollectionId,
+        position,
+        promotedWindowName: promotedTab,
+    }));
+};
+/**
+ * @language javascript, dotnet
+ * Removes one or more tabs from their tab collection(s). The tab collection is identified automatically.
+ * Tab collections with fewer than two tabs are removed from the system. If the tab collection is maximized then
+ * windows that are removed will be restored to their previous unmaximized position and size.
+ *
+ * ```javascript
+ * await FSBL.Clients.windowClient.removeFromTabCollection({
+ * 	windowNames: ["MyApp-3443-fdf-343-fdfdf","MyOtherApp-dfdf-sdsd-dfdf-sdsd"],
+ * })
+ * ```
+ * @param __namedParameters.windowNames - The array of window names to be removed.
+ */
+export const removeFromTabCollection = async ({ windowNames }) => {
+    const store = getRemoteStoreAsSingleton({
+        singletonName: "WindowClient::tabCollection",
+        server: "@@finsemble/remoteRedux/WindowServiceStore",
+        slice: "api",
+        emptyStore,
+        dispatchOnly: true,
+    });
+    store.dispatch(actions.removeTabsFromTabCollection({
+        windowNames,
+    }));
+};
+/**
+ * @language javascript, dotnet
+ * Changes the visible tab in a tab collection. (The tab collection is identified automatically.)
+ *
+ * ```javascript
+ * await FSBL.Clients.windowClient.promoteTab("MyApp-3443-fdf-343-fdfdf");
+ * ```
+ * @param windowName - The name of the tab to be promoted.
+ */
+export const promoteTab = async (windowName) => {
+    const store = getRemoteStoreAsSingleton({
+        singletonName: "WindowClient::tabCollection",
+        server: "@@finsemble/remoteRedux/WindowServiceStore",
+        slice: "windowTitleBar",
+        emptyStore,
+        dispatchOnly: true,
+    });
+    store.dispatch(actions.promoteTab({
+        targetWindowName: windowName,
+    }));
+};
+/**
+ * @language javascript, dotnet
+ * Gets the name of the promoted tab for a given tab collection.
+ *
+ * ```javascript
+ * const {err, data: windowName } = await FSBL.Clients.windowClient.getPromotedTab({
+ * 	tabCollectionId: ["StackedWindow-dfdf-sdsd-dfdfdf-343434"]
+ * });
+ * if(windowName) console.log(`The promoted window is ${windowName}`)
+ * ```
+ * @param __namedParameters.tabCollectionId - ID of the tab collection.
+ * @param cb - Optional callback to be invoked after the method completes successfully.
+ * @return - Resolves to a tuple containing an error message and the name of the promoted tab in the collection.
+ */
+export const getPromotedTab = async ({ tabCollectionId }, cb) => {
+    var _a, _b, _c;
+    const state = (await getRemoteState({
+        server: "@@finsemble/remoteRedux/WindowServiceStore",
+        slice: "windowTitleBar",
+    }));
+    const promotedTab = (_c = (_b = (_a = state === null || state === void 0 ? void 0 : state.windowTitleBar) === null || _a === void 0 ? void 0 : _a.tabCollections) === null || _b === void 0 ? void 0 : _b[tabCollectionId]) === null || _c === void 0 ? void 0 : _c.promotedWindowName;
+    if (!promotedTab) {
+        const err = `No promoted tab found for tab collection ${tabCollectionId}`;
+        cb === null || cb === void 0 ? void 0 : cb(err);
+        return { err };
+    }
+    else {
+        cb === null || cb === void 0 ? void 0 : cb(null, promotedTab);
+        return { err: null, data: promotedTab };
+    }
+};
+/**
+ * @language javascript, dotnet
+ * Gets the tabCollectionId for a given window, if it is a member of a tab collection.
+ *
+ * ```javascript
+ * const {err, data } = await FSBL.Clients.windowClient.getTabCollectionForWindow({
+ * 	windowName: ["MyApp-dfdf-sdsd-dfdfdf-343434"]
+ * });
+ * if(data) console.log(`The tab collection ${data.id} contains these windows: ${data.windows}`);
+ * ```
+ * @param __namedParameters.windowName - The name of a window that should be in a tab collection.
+ * @param cb - Optional callback to be invoked after the method completes.
+ * @return - Resolves to a tuple with error message and object containing the tabCollectionId and a list of the windows in that collection.
+ * An error will result if the window is not a member of any tab collection.
+ */
+export const getTabCollectionForWindow = async ({ windowName }, cb) => {
+    var _a, _b, _c, _d, _e, _f, _g;
+    const state = (await getRemoteState({
+        server: "@@finsemble/remoteRedux/WindowServiceStore",
+        slice: "windowTitleBar",
+    }));
+    const id = (_c = (_b = (_a = state === null || state === void 0 ? void 0 : state.windowTitleBar) === null || _a === void 0 ? void 0 : _a.windows) === null || _b === void 0 ? void 0 : _b[windowName]) === null || _c === void 0 ? void 0 : _c.tabCollectionId;
+    if (!id) {
+        const err = id ? null : `No tab collection found for window ${windowName}`;
+        cb === null || cb === void 0 ? void 0 : cb(err);
+        return { err };
+    }
+    const data = {
+        id,
+        windows: (_e = (_d = state === null || state === void 0 ? void 0 : state.windowTitleBar) === null || _d === void 0 ? void 0 : _d.tabCollections[id]) === null || _e === void 0 ? void 0 : _e.tabs,
+        promotedWindowName: (_g = (_f = state === null || state === void 0 ? void 0 : state.windowTitleBar) === null || _f === void 0 ? void 0 : _f.tabCollections[id]) === null || _g === void 0 ? void 0 : _g.promotedWindowName,
+    };
+    cb === null || cb === void 0 ? void 0 : cb(null, data);
+    return { err: null, data };
+};
+/**
+ * @language javascript, dotnet
+ * Gets the tabCollectionId for a given window, if it is a member of a tab collection.
+ *
+ * ```javascript
+ * const {err, data } = await FSBL.Clients.windowClient.getTabCollection({
+ * 	windowName: ["StackedWindow-dfdf-sdsd-dfdfdf-343434"]
+ * });
+ * if(data) console.log(`The tab collection contains these windows: ${data.windows}`);
+ * ```
+ * @param __namedParameters.collectionId - The name of the tab collection.
+ * @param cb - Optional callback to be invoked after the method completes.
+ * @return - Resolves to a tuple with error message and object containing the list of the windows in that collection and the currently promoted window.
+ */
+export const getTabCollection = async ({ id }, cb) => {
+    const state = (await getRemoteState({
+        server: "@@finsemble/remoteRedux/WindowServiceStore",
+        slice: "windowTitleBar",
+    }));
+    const collection = state.windowTitleBar.tabCollections[id];
+    if (!collection) {
+        const err = `No tab collection "${id}" found.`;
+        cb === null || cb === void 0 ? void 0 : cb(err);
+        return { err };
+    }
+    const data = {
+        windows: collection.tabs,
+        promotedWindowName: collection.promotedWindowName,
+    };
+    cb === null || cb === void 0 ? void 0 : cb(null, data);
+    return { err: null, data };
+};
 /**
  * @ignore
  *
@@ -795,11 +950,13 @@ export const WindowClient = {
         cb === null || cb === void 0 ? void 0 : cb();
     },
     addListeners,
+    addToTabCollection,
     bringToFront,
     bringWindowToFront,
     cacheInitialBounds,
     cancelTilingOrTabbing,
     close,
+    createTabCollection,
     ejectFromGroup,
     fitToDOM,
     formGroup,
@@ -808,31 +965,32 @@ export const WindowClient = {
     getCurrentWindow,
     getDesktopBoundingBox,
     getMonitorInfo,
+    getPromotedTab,
     getSpawnData,
-    getStackedWindow,
+    getTabCollection,
+    getTabCollectionForWindow,
     getWindowTitle,
     getWindowBounds,
     getWindowGroups,
     getWindowNameForDocking,
     getWindowIdentifier,
-    headerCommandChannel,
     injectDOM,
     isMouseOverDOMElement,
     isPointInBox,
     maximize,
     minimize,
+    promoteTab,
     removeComponentState,
+    removeFromTabCollection,
     restore,
     retrieveMonitorDimensions,
     saveWindowBounds,
-    sendIdentifierForTilingOrTabbing,
     setActive,
     setAlwaysOnTop,
     setComponentState,
     setShape,
     setTaskbarIconOverlay,
     setWindowTitle,
-    setWindowTitlePrivate,
     showAtMousePosition,
     stopTilingOrTabbing,
     startMovingWindow,
@@ -856,12 +1014,6 @@ export const WindowClient = {
     set windowGroups(replacement) {
         getControllerInstance().windowGroups = replacement;
     },
-    get commandChannel() {
-        return getControllerInstance().commandChannel;
-    },
-    set commandChannel(replacement) {
-        getControllerInstance().commandChannel = replacement;
-    },
 };
 /**
  * @ignore