@finsemble/finsemble-ui 8.4.0-beta.1 → 8.4.0

package/clients/launcherClient.js

@@ -1,576 +1,13 @@
-/*!
- * Copyright 2017 - 2020 by ChartIQ, Inc.
- * All rights reserved.
- */
 /**
- * The Launcher Client handles spawning windows of all kinds.
- * Finsemble provides the architecture to launch, resize, and reposition any component, whether native, modern, or third-party.
- *
- *
- * The Launcher API has capabilities to customize your end user's experience.
- * This includes CSS-like positioning and a fully display-aware positioning that deals with idiosyncrasies such as monitors with different scaling resolutions.
+ * The Launcher Client is now known as the AppsClient. The Launcher Client
+ * (found at `FSBL.Clients.LauncherClient`) is an alias to the AppsClient
+ * provided for backward compatibility. Hence, please refer to AppsClient
+ * documentation for details on usage.
  *
- *
- * CSS provides higher level abstractions that aid in laying out an application that is composed of constituent parts.
- * Finsemble has borrowed CSS’s positioning paradigm and applied it to the task of laying out windows on the desktop.
- * This CSS-style positioning allows windows to be positioned on the `left`, `right`, `top`, or `bottom` of the end user’s screen for instance; we also developed new positions, such as `adjacent`, which allows a child window to spawn adjacent to their parent.
- * Components can be positioned and sized by percentage, relative to the monitor or to each other (nested windows).
- *
- * The Launcher Client frequently uses the parameters <code>windowName</code> and <code>componentType</code>. [Learn more about them here](/docs/productivity/componentTypesAndWindowNames).
  * @module LauncherClient
  */
-import { getMyWindowIdentifier as getMyWindowIdentifierUtil, clone } from "../common/util";
-import Logger from "./logger";
-import { FinsembleWindow } from "../common/FinsembleWindow";
-import { RouterClient } from "./routerClient";
-import SystemManagerClient from "../common/systemManagerClient";
-import { getAllMonitorsClientSide, getWhichMonitorClientSide, } from "../common/Monitors";
-import { registerComponent, unRegisterComponent, getMonitor, getActiveAndPendingWindowNames, getPendingWindows, getComponentsThatCanReceiveDataTypes, hyperFocus, createWindowGroup, addWindowsToGroup, removeWindowsFromGroup, getGroupsForWindow, addToGroups, } from "../deprecated/deprecatedlauncherClient";
-import { bringWindowsToFront, minimizeWindows } from "../common/Desktop";
-import { isMouseOverDOMElement } from "../common/util";
-// A map of related menus that is kept by handleToggle.
-const okayToOpenMenu = {};
-/**
- * Utility function that Converts a WindowLocator into a WindowIdentifier
- * @param locator The window locator Object to convert
- * @returns WindowIdentifier
- */
-const locatorToIdentifier = (locator) => {
-    let windowIdentifier = {};
-    if ("windowName" in locator) {
-        windowIdentifier.windowName = locator.windowName;
-    }
-    else {
-        windowIdentifier.windowName = "";
-    }
-    if ("componentType" in locator) {
-        windowIdentifier.componentType = locator.componentType;
-    }
-    if ("uuid" in locator) {
-        windowIdentifier.uuid = locator.uuid;
-    }
-    return windowIdentifier;
-};
-/**
- * Get a list of registered components (those that were entered into <i>components.json</i>).
- *
- * ```javascript
- * const {err, data} = await FSBL.Clients.LauncherClient.getComponentList();
- * if(!err){
- * 	 console.log(data);
- *   // {
- *   //   "Toolbar": { ... },
- *   //   "Tour": { ... },
- *   //   ...
- *   // }
- * }
- * ```
- *
- * @param cb Callback returns an object map of components. Each component object
- * contains the default config for that component.
- */
-export const getComponentList = async (cb) => {
-    await SystemManagerClient.waitForStartup("windowService");
-    const { err, response } = await RouterClient.query("Launcher.componentList", {});
-    cb === null || cb === void 0 ? void 0 : cb(err, response.data);
-    return { err, data: response.data };
-};
-/**
- * Get the component config (from <i>components.json</i>) for a specific component.
- *
- * ```javascript
- * const {err, data} = await FSBL.Clients.LauncherClient.getComponentDefaultConfig("ChartIQ Example App");
- * ```
- *
- * @param componentType The type of the component.
- * @param cb Callback returns the default config (windowDescriptor) for the requested componentType.
- */
-export const getComponentDefaultConfig = async (componentType, cb) => {
-    const { err, data } = await getComponentList();
-    const componentDescriptor = data === null || data === void 0 ? void 0 : data[componentType];
-    cb === null || cb === void 0 ? void 0 : cb(err, componentDescriptor);
-    return { err, data: componentDescriptor };
-};
-/**
- * Gets monitorInfo (dimensions and position) for all monitors. Returns an array of monitorInfo objects. See <a href="/docs/reference/typedocs/modules/LauncherClient#getMonitorInfo">LauncherClient#getMonitorInfo</a> for the format of a monitorInfo object.
- *
- * ```javascript
- * const {err, data} = await FSBL.Clients.LauncherClient.getMonitorInfoAll();
- * if(!err){
- *   console.log(`There are ${data.length} monitors.`);
- * }
- * ```
- *
- * @param cb Returns an array of monitorInfo objects.
- */
-export const getMonitorInfoAll = async (cb) => {
-    Logger.system.debug("LauncherClient.getMonitorInfoAll()");
-    return getAllMonitorsClientSide(RouterClient, cb);
-};
-/**
- * Gets monitor information for a given windowIdentifier or for a specific monitor.
- * If neither the identifier or monitor are provided then the monitorInfo for the current window is returned.
- *
- *
- * The information returned contains:
- *
- * **monitorRect** - The full dimensions for the monitor. <br/>
- * **availableRect** - The dimensions for the available space on the monitor (less the Windows task bar). <br/>
- * **position** - The position of the monitor, numerically from zero to X. Primary monitor is zero. <br/>
- * **whichMonitor** - Contains the string "primary" if it is the primary monitor. <br/>
- *
- * The dimensions are supplemented with the following additional members:
- *
- * **width** - The width as calculated (right - left). <br/>
- * **height** - The height as calculated (bottom - top). <br/>
- *
- * ```javascript
- * // Get the info for the monitor that the calling app is on
- * const {err, data} = await FSBL.Clients.LauncherClient.getMonitorInfo();
- * if(!err){
- *   console.log(data);
- * // Example results:
- * // {
- * //	availableRect: {width, height, bottom, left, ...},
- * //   deviceId: "123456",
- * //   deviceScaleFactor: 2,
- * //   displayDeviceActive: true,
- * //   monitor: {dipRect, scaledRect},
- * //   monitorRect: {width, height, bottom, left, right, ...}
- * //   name: "device0",
- * //   position: 0,
- * //   taskbar: {top, left, right, bottom, width, ...}
- * //   whichMonitor: "primary"
- * // }
- * }
- *
- * // Get monitor info for a given window
- * const {err, data} = await FSBL.Clients.LauncherClient.getMonitorInfo({
- *   windowIdentifier: {
- *     windowName: "ABC-uuid"
- *   }
- * });
- * if(!err){
- *   console.log(`App ABC-uuid is currently on the monitor with index ${data.position}`);
- * }
- *
- * // Get the dimensions of the first non-primary monitor
- * const {err, data} = await FSBL.Clients.LauncherClient.getMonitorInfo({monitor: 1});
- * if(!err){
- *   console.log("Available dimensions for monitor[1]: ", data.monitorRect);
- *   console.log("Available dimensions, minus claimed space, for monitor[1]: ", data.availableRect);
- * }
- * ```
- *
- * @param params
- * @param params.windowIdentifier The windowIdentifier to get the monitorInfo. If undefined, then the current window.
- * @param params.monitor If passed then a specific monitor is identified. Valid values include:
- *
- * <b>"mine"</b> - Place the window on the same monitor as the calling window.
- *
- * Integer value from 0-n (0 being the primary monitor).
- *
- * <b>"primary"</b> indicates the user's primary monitor.
- *
- * <b>"all"</b> - Put a copy of the component on all monitors.
- * @param cb Returns a monitorInfo object containing the monitorRect and availableRect.
- *
- * @returns A promise that resolves to a monitorInfo
- */
-export const getMonitorInfo = async (params = {}, cb) => {
-    Logger.system.debug("LauncherClient.getMonitorInfo()");
-    if (params.monitor === "all") {
-        Logger.deprecated(`Use of type "all" in LauncherClient.getMonitorInfo() is deprecated. Please use LauncherClient.getMonitorInfoAll()`);
-        return getMonitorInfoAll(cb);
-    }
-    return getWhichMonitorClientSide(RouterClient, params, cb);
-};
-/**
- * Displays a window and relocates/resizes it according to the values contained in parameters. If the specified window is in a group or tabbed, it will be unsnapped/ungrouped/untabbed from the other windows.
- * If invoked on a tabbed window or a window in a group, the window will be removed from the tab/group.
- *
- * Caution: A window can inherit parameters only once, at the time when it’s spawned. When the component already exists, changing parameters other than positioning arguments (monitor, relativeWindow, top, bottom, left, right, width, height) has no effect.
- *
- * ```javascript
- * FSBL.Clients.LauncherClient.showWindow({windowName: "Welcome Component-86-3416-Finsemble", componentType: "Welcome Component"}, {spawnIfNotFound: true}, (err, data)=> {});
- * ```
- * @param windowIdentifier A windowIdentifier. This is an object containing windowName and componentType. If windowName is not given, Finsemble will try to find it by componentType.
- * @param params Configuration settings from the <i><a href="/docs/reference/ConfigReference#finsemble-appd---manifest-window">finsemble.appd[].manifest.window</a></i> section of the application manifest may be used as parameters to this function, except for the `options` element.
- * These are the same as <a href="/docs/reference/typedocs/modules/LauncherClient#spawn">LauncherClient.spawn()</a> with the following exceptions:
- * <ul>
- * 	<li><b>monitor</b> - Same as spawn() except that null or undefined means don't move the window to a different monitor.</li>
- *  <li><b>left</b> - Same as spawn() except that null or undefined means don't move the window from current horizontal location.</li>
- *  <li><b>top</b> - Same as spawn() except that null or undefined means don't move the window from current vertical location.</li>
- *  <li><b>slave</b> - Cannot be set for an existing window. Will only go into effect if the window is spawned. (In other words, only use this in conjunction with spawnIfNotFound).</li>
- *  <li><b>spawnIfNotFound</b> - If true, then spawns a new window if the requested one cannot be found. Note: only works if the windowIdentifier contains a componentType.</li>
- *  <li><b>autoFocus</b> - Whether or not the window should be focused when shown.</li>
- * </ul>
- * @param cb Callback to be invoked after the function is completed regardless if the call fails or succeeds.
- * Callback contains two arguments in the following order.
- * <ol>
- * 	<li><b>error</b>: an object containing details related to the reason the call failed and where the exception occurred. This object will be null if the call has succeeded.</li>
- * 	<li><b>data</b>: an object with the following information:
- * 		<ul>
- * 			<li><b>windowIdentifier</b> - The <a href="/docs/productivity/componentTypesAndWindowNames">WindowIdentifier</a> for the new window.</li>
- * 			<li><b>windowDescriptor</b> - The <a href="/docs/productivity/componentTypesAndWindowNames">WindowDescriptor</a> of the new window.</li>
- * 			<li><b>finWindow</b> - A <code>finWindow</code> object referencing the new window.</li>
- * 		</ul>
- * 	</li>
- * </ol>
- */
-export const showWindow = async (windowLocator, params, cb) => {
-    if (!params) {
-        params = {};
-    }
-    params = clone(params);
-    if (!params.staggerPixels && params.staggerPixels !== 0) {
-        params.staggerPixels = 100;
-    }
-    params.windowIdentifier = locatorToIdentifier(windowLocator);
-    const myWindowIdentifier = await getMyWindowIdentifierUtil();
-    if (!params.relativeWindow) {
-        params.relativeWindow = myWindowIdentifier;
-    }
-    await SystemManagerClient.waitForStartup("windowService");
-    const { err, response } = await RouterClient.query("Launcher.showWindow", params);
-    if (err) {
-        cb === null || cb === void 0 ? void 0 : cb(err);
-        return { err };
-    }
-    else {
-        const name = response.data.windowIdentifier.windowName;
-        const { wrap: finWindow } = await FinsembleWindow.getInstance({
-            name,
-        });
-        const data = Object.assign(Object.assign({}, response.data), { windowIdentifier: Object.assign(Object.assign({}, response.data.windowIdentifier), { name }), finWindow });
-        cb === null || cb === void 0 ? void 0 : cb(err, data);
-        return { err, data: data };
-    }
-};
-/**
- * A convenient method for dealing with a common use-case, which is toggling the appearance and disappearance of a child window when a button is pressed, aka drop down menus.
- * Call this method from the click handler for your element. Your child window will need to close itself on blur events.
- * Caution: A window can inherit parameters only once, at the time when it’s spawned. When the component already exists, changing parameters other than positioning arguments (monitor, relativeWindow, top, bottom, left, right, width, height) has no effect.
- * @param element The DOM element, or selector, clicked by the end user.
- * @param windowIdentifier Identifies the child window
- * @param params Parameters to be passed to <a href="/docs/reference/typedocs/modules/LauncherClient#showWindow">LauncherClient.showWindow()</a> if the child window is allowed to open
- */
-export const toggleWindowOnClick = (element, windowLocator, params) => {
-    var _a, _b;
-    const windowIdentifier = locatorToIdentifier(windowLocator);
-    const key = (_b = (_a = windowIdentifier.windowName) !== null && _a !== void 0 ? _a : windowIdentifier.componentType) !== null && _b !== void 0 ? _b : "";
-    // If the element was clicked while the menu was open then return right away. The menu window will receive a blur event and close.
-    // This method is dependent on the fact that blur events are processed before click events.
-    // If this turns out to be a problem then put this call inside of a setTimeout().
-    if (okayToOpenMenu[key] === false) {
-        okayToOpenMenu[key] = true;
-        return;
-    }
-    const onDisplayed = (showError, showResponse) => {
-        if (!showResponse)
-            return;
-        const { finWindow } = showResponse;
-        const onBlur = () => {
-            okayToOpenMenu[key] = true;
-            isMouseOverDOMElement(element, (mouseIsOverElement) => {
-                okayToOpenMenu[key] = !mouseIsOverElement;
-            });
-            finWindow.removeEventListener("blurred", onBlur);
-        };
-        finWindow.addEventListener("blurred", onBlur);
-    };
-    if (!params.position)
-        params.position = "absolute";
-    showWindow(windowLocator, params, onDisplayed);
-};
-const waitForReadySignal = (name) => new Promise((resolve) => {
-    // Wait for a definite message that the component is ready (that FSBL has been initialized in the spawned app).
-    const subscriberID = RouterClient.subscribe(`Finsemble.${name}.componentReady`, (error, response) => {
-        if (error || !response.data) {
-            Logger.system.error(`RouterClient.waitForReadySignal() Error subscribing for component ready state ${error}`);
-            resolve(error);
-            // Ignore the initial "uninitialized" state message delivered by subscribe (the one with an empty string).
-        }
-        else if (Object.keys(response.data).length) {
-            // A second message will arrive with the actual data. Now we know that the client has initialized and signaled its readiness.
-            RouterClient.unsubscribe(subscriberID);
-            resolve(null);
-        }
-    });
-});
-const callSpawn = async (params) => {
-    const { err, response } = await RouterClient.query("Launcher.spawn", params);
-    Logger.system.debug("CallSpawn", "Initial launcher callback params", err, response);
-    if (err || !response) {
-        const error = err !== null && err !== void 0 ? err : `Internal error: callSpawn(): No data returned from service for "Launcher.spawn"`;
-        return { err: error };
-    }
-    else {
-        const { data: spawnResponseData } = response;
-        if (spawnResponseData.stackedWindow) {
-            return { err: "Legacy stacked window spawn" };
-        }
-        let spawnedWindowNames = [];
-        let spawnResponse;
-        // If we receive an array of spawn response means we've spawned a launch group.
-        // We select the first spawn response as the result so that a finWindow is available,
-        // additionally we put all the window names in an array and assigned it to a launchGroupWindows
-        // property to be placed in the result object so that we have all available window names for the
-        // launch group
-        if (Array.isArray(spawnResponseData)) {
-            spawnedWindowNames = spawnResponseData.reduce((acc, curr) => {
-                acc.push(curr.windowIdentifier.windowName);
-                return acc;
-            }, []);
-            spawnResponse = spawnResponseData[0];
-        }
-        else {
-            spawnResponse = spawnResponseData;
-        }
-        const name = spawnResponse.windowIdentifier.windowName;
-        const { wrap: finWindow } = await FinsembleWindow.getInstance({
-            name,
-        });
-        const result = Object.assign(Object.assign({}, spawnResponse), { windowIdentifier: Object.assign(Object.assign({}, spawnResponse.windowIdentifier), { name }), 
-            // Add a wrapped finWindow to the response (this can only be done client side)
-            finWindow });
-        // if we have an array of window names - means spawn of launchGroup
-        // so lets add it to the result
-        if (spawnedWindowNames.length > 0) {
-            result.launchGroupWindows = spawnedWindowNames;
-        }
-        Logger.system.debug("CallSpawn", "Waiting for ready signal", name);
-        const waitError = await waitForReadySignal(name);
-        Logger.system.debug("CallSpawn", "Got ready signal", name);
-        return { err: waitError, result };
-    }
-};
-/**
- * Asks the Launcher service to spawn a new component. Any parameter below can also be specified in <i>public/config/components.json</i>, which will
- * then operate as the default for that value.
- *
- * The launcher parameters mimic CSS window positioning.
- * For instance, to set a full screen window use `{left: 0, top: 0, right: 0, bottom: 0}`.
- * This is functionally equivalent to: `{left: 0, top: 0, width: "100%", height: "100%"}`.
- *
- * You can also spawn more than one component at a time by using a single action, such as clicking a button on a menu.
- * See https://github.com/ChartIQ/finsemble-seed/tree/recipes/SpawnComponentGroup for an example of spawning a component group.
- *
- * ```javascript
- * FSBL.Clients.LauncherClient.spawn("Welcome Component", {left: 0, top: 0, position: "relative"}, (err, data)=> {});
- * ```
- * @param component The application or component to spawn.
- * @param params Configuration settings from the <i><a href="/docs/reference/ConfigReference#finsemble-appd---manifest-window">finsemble.appd[].manifest.window</a></i> section of the application manifest may be used as parameters to this function, except for the `options` element.
- * @param cb Function invoked after the window is created
- */
-export const spawn = async (component, params, cb) => {
-    if (!params) {
-        params = {};
-    }
-    params = clone(params);
-    params.component = component;
-    if (!params.options) {
-        params.options = {};
-    }
-    if (!params.options.customData) {
-        params.options.customData = {};
-    }
-    if (!params.staggerPixels && params.staggerPixels !== 0) {
-        params.staggerPixels = 50;
-    }
-    Logger.system.debug(`LauncherClient.spawn starting for componentType:${component}`);
-    await SystemManagerClient.waitForStartup("windowService");
-    const windowIdentifier = await getMyWindowIdentifierUtil();
-    params.launchingWindow = windowIdentifier;
-    const { err, result: response } = await callSpawn(params);
-    Logger.system.debug(`LauncherClient.spawn completing for componentType:${component}`, err);
-    cb === null || cb === void 0 ? void 0 : cb(err, response);
-    return { error: err, response: response };
-};
-/**
- * Spawns a set of apps and assembles them into a tab collection. Spawn parameters may be specified for the entire collection
- * or for individual apps, however, positioning parameters (e.g. `left` or `top`) are disregarded when set on individual apps.
- *
- * ```javascript
- * await FSBL.Clients.LauncherClient.spawnTabCollection({
- *		componentList: [{appID: "Welcome Component", individualParams: { alwaysOnTop : true } }],
- *		globalParams: { left: 100, top: 100}
- *	});
- * ```
- * @param __namedParameters.componentList - The apps to open. Each should be an object that contains the appID (from AppD) and an optional set of SpawnParams.
- * @param __namedParameters.globalParams - Positioning parameters for the collection. If omitted then the collection will be spawned in a default location.
- * @returns - Resolves to an object that contains the id of the tab collection and the list of window names for the spawned apps
- */
-export const spawnTabCollection = async ({ componentList, globalParams, }, cb) => {
-    Logger.system.debug(`LauncherClient.spawn starting for componentType: tabCollection`);
-    await SystemManagerClient.waitForStartup("windowService");
-    const windowIdentifier = await getMyWindowIdentifierUtil();
-    globalParams = globalParams !== null && globalParams !== void 0 ? globalParams : {};
-    globalParams.launchingWindow = windowIdentifier;
-    const { err, response } = await RouterClient.query("Launcher.spawnTabCollection", {
-        componentList,
-        globalParams,
-    });
-    const { id, windows } = response.data;
-    let result = {
-        id: id,
-        windows: [],
-    };
-    for (const res of windows) {
-        const name = res.windowIdentifier.windowName;
-        const { wrap: finWindow } = await FinsembleWindow.getInstance({
-            name,
-        });
-        result.windows.push(Object.assign(Object.assign({}, res), { windowIdentifier: Object.assign(Object.assign({}, res.windowIdentifier), { name }), 
-            // Add a wrapped finWindow to the response (this can only be done client side)
-            finWindow }));
-    }
-    Logger.system.debug(`LauncherClient.spawn completing for tabCollection`, err);
-    cb === null || cb === void 0 ? void 0 : cb(err, result);
-    return { err: err, data: result };
-};
-/**
- * Returns a windowIdentifier for the current window.
- *
- * ```javascript
- * const myWindowIdentifier = await FSBL.Clients.LauncherClient.getMyWindowIdentifier();
- * console.log(myWindowIdentifier);
- * // {
- * //   windowName: "ABC-uuid",
- * //   componentType: "ABC"
- * // }
- * ```
- *
- * @param cb Callback function returns windowIdentifier for this window (optional or use the returned Promise)
- * @returns A promise that resolves to a windowIdentifier
- */
-export const getMyWindowIdentifier = async (cb) => {
-    const wi = await getMyWindowIdentifierUtil();
-    cb === null || cb === void 0 ? void 0 : cb(wi);
-    return wi;
-};
-/**
- * Gets the windowDescriptor for all open windows.
- *
- * :::note
- * This returns descriptors even if the window is not part of the workspace.
- * :::
- *
- * ```javascript
- * FSBL.Clients.LauncherClient.getActiveDescriptors(function (error, response) {
- * 	if (error) {
- *		Logger.system.error("Error getting active descriptors: ",  + JSON.stringify(error));
- *	} else {
- *		const activeDescriptors = response;
- *		//{
- *		//	...
- *		//	Toolbar-1-Finsemble: {...},
- *		//	Welcome-Component-80-6453-Finsemble: {...},
- *		//	...
- *		//}
- * 	}
- * });
- * ```
- * @param cb Callback returns an object containing windowDescriptors keyed by name.
- */
-export const getActiveDescriptors = async (cb) => {
-    await SystemManagerClient.waitForStartup("windowService");
-    const { err, response } = await RouterClient.query("Launcher.getActiveDescriptors", {});
-    if (err)
-        Logger.system.error(err);
-    cb === null || cb === void 0 ? void 0 : cb(err, response.data);
-    return { err, data: response.data };
-};
-/**
- * @private Adds a custom component.
- * @ignore
- */
-export const addUserDefinedComponent = async (params, cb) => {
-    await SystemManagerClient.waitForStartup("windowService");
-    const { err } = await RouterClient.query("Launcher.userDefinedComponentUpdate", {
-        type: "add",
-        name: params.name,
-        url: params.url,
-    });
-    if (err)
-        Logger.system.error(err);
-    cb === null || cb === void 0 ? void 0 : cb(err);
-    return { err };
-};
-/**
- * @private Adds a custom component.
- * @ignore
- */
-export const removeUserDefinedComponent = async (params, cb) => {
-    await SystemManagerClient.waitForStartup("windowService");
-    const { err } = await RouterClient.query("Launcher.userDefinedComponentUpdate", {
-        type: "remove",
-        name: params.name,
-        url: params.url,
-    });
-    if (err)
-        Logger.system.error(err);
-    cb === null || cb === void 0 ? void 0 : cb(err);
-    return { err };
-};
-/**
- * Adds new FDC3 App(s) to Finsemble.
- *
- * ```javascript
- * const {err, data} = await FSBL.Clients.AppsClient.addApps([anFDC3App]);
- * ```
- *
- * @param apps The array of FDC3AppDefinition to add
- * @param cb The callback to be invoked after the apps are set or on error.
- */
-const addApps = async (apps, cb) => {
-    if (!Array.isArray(apps)) {
-        const err = "The input was not an array. Please pass an array of type: FDC3AppDefinition[] (including if only adding a single app)";
-        cb === null || cb === void 0 ? void 0 : cb(err);
-        return { err };
-    }
-    const { err, response } = await RouterClient.query("configService.addApps", apps);
-    cb === null || cb === void 0 ? void 0 : cb(err, response.data);
-    return { err, data: response.data };
-};
-/**
- * Removes an FDC3 App(s) from Finsemble.
- *
- * ```javascript
- * const {err, data} = await FSBL.Clients.AppsClient.removeApps(["fdc3AppId"]);
- * ```
- *
- * @param apps The array of appIds to remove
- * @param cb The callback to be invoked after the apps are removed or on error.
- *
- */
-const removeApps = async (appIds, cb) => {
-    if (!Array.isArray(appIds)) {
-        const err = "The input was not an array. Please pass an array of string appIds to remove (including if only removing a single app)";
-        cb === null || cb === void 0 ? void 0 : cb(err);
-        return { err };
-    }
-    const { err, response } = await RouterClient.query("configService.removeApps", appIds);
-    cb === null || cb === void 0 ? void 0 : cb(err, response.data);
-    return { err, data: response.data };
-};
-/**
- * Retrieves a list of apps from Finsemble
- *
- * @param appIds an array of app IDs to retrieve. If not provided, all apps will be retrieved.
- * @param cb The callback to be invoked after the apps are retrieved or on error.
- * @returns A promise that resolves to an array of app objects.
- */
-const getApps = async (appIds, cb) => {
-    if (appIds && !Array.isArray(appIds)) {
-        const err = "The input was not an array. Please pass an array of string appIds to fetch (including if only retrieving a single app)";
-        cb === null || cb === void 0 ? void 0 : cb(err);
-        return { err };
-    }
-    const { err, response } = await RouterClient.query("configService.getApps", appIds);
-    cb === null || cb === void 0 ? void 0 : cb(err, response.data);
-    return { err, data: response.data };
-};
+import AppsClient from "./appsClient";
+import { Logger } from "./logger";
 /**
  * @ignore
  */
@@ -592,38 +29,35 @@ export const LauncherClient = {
         Logger.system.deprecated("It is no longer necessary to call LauncherClient.onReady()");
         cb === null || cb === void 0 ? void 0 : cb();
     },
-    addToGroups,
-    addUserDefinedComponent,
-    addWindowsToGroup,
-    bringWindowsToFront,
-    createWindowGroup,
-    getActiveAndPendingWindowNames,
-    getActiveDescriptors,
-    getComponentDefaultConfig,
-    getComponentList,
-    getComponentsThatCanReceiveDataTypes,
-    getGroupsForWindow,
-    getMonitor,
-    getMonitorInfo,
-    getMonitorInfoAll,
-    getMyWindowIdentifier,
-    getPendingWindows,
-    hyperFocus,
-    minimizeWindows,
-    registerComponent,
-    removeUserDefinedComponent,
-    removeWindowsFromGroup,
-    showWindow,
-    spawn,
-    spawnTabCollection,
-    toggleWindowOnClick,
-    unRegisterComponent,
-    addApps,
-    removeApps,
-    getApps,
+    addToGroups: AppsClient.addToGroups,
+    getGroupsForWindow: AppsClient.getGroupsForWindow,
+    removeWindowsFromGroup: AppsClient.removeWindowsFromGroup,
+    addWindowsToGroup: AppsClient.addWindowsToGroup,
+    createWindowGroup: AppsClient.createWindowGroup,
+    minimizeWindows: AppsClient.minimizeWindows,
+    hyperFocus: AppsClient.hyperFocus,
+    bringWindowsToFront: AppsClient.bringWindowsToFront,
+    getComponentsThatCanReceiveDataTypes: AppsClient.getComponentsThatCanReceiveDataTypes,
+    removeUserDefinedComponent: AppsClient.removeUserDefinedComponent,
+    addUserDefinedComponent: AppsClient.addUserDefinedComponent,
+    getPendingWindows: AppsClient.getPendingWindows,
+    getActiveAndPendingWindowNames: AppsClient.getActiveAndPendingWindowNames,
+    getActiveDescriptors: AppsClient.getActiveDescriptors,
+    getMyWindowIdentifier: AppsClient.getMyWindowIdentifier,
+    getMonitor: AppsClient.getMonitor,
+    spawn: AppsClient.spawn,
+    toggleWindowOnClick: AppsClient.toggleWindowOnClick,
+    showWindow: AppsClient.showWindow,
+    unRegisterComponent: AppsClient.unRegisterComponent,
+    registerComponent: AppsClient.registerComponent,
+    getMonitorInfo: AppsClient.getMonitorInfo,
+    getMonitorInfoAll: AppsClient.getMonitorInfoAll,
+    getComponentDefaultConfig: AppsClient.getComponentDefaultConfig,
+    getComponentList: AppsClient.getComponentList,
+    addApps: AppsClient.addApps,
+    removeApps: AppsClient.removeApps,
+    getApps: AppsClient.getApps,
+    spawnTabCollection: AppsClient.spawnTabCollection,
 };
-/**
- * @ignore
- */
 export default LauncherClient;
 //# sourceMappingURL=launcherClient.js.map