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

package/react/components/sdd/smartDesktopClient.js

@@ -0,0 +1,1222 @@
+import { Logger } from "../../../clients/logger";
+import { RouterClient } from "../../../clients/routerClient";
+import { ConfigClient } from "../../../clients/configClient";
+import { System } from "../../../common/system";
+import { FEAGlobals } from "../../../common/Globals";
+import { httpPatch, httpGet, httpDelete, httpPut } from "../../../common/REST";
+import { restartApplication } from "../../../common/Desktop";
+const MAKER_TOPIC = "SmartDesktopClient";
+const UI_CHANGE_TOPIC = "Finsemble-ui-change";
+const assetTests = {
+    Image: { acceptedTypes: ["PNG", "JPEG", "JPG"], regex: /\.(jpe?g|png)$/i },
+    GIF: { acceptedTypes: ["GIF"], regex: /\.(gif)$/i },
+    Icon: { acceptedTypes: ["ICO"], regex: /\.(ico)$/i },
+    JS: { acceptedTypes: ["JS"], regex: /\.(js)$/i },
+    JSON: { acceptedTypes: ["JSON"], regex: /\.(json)$/i },
+    CSS: { acceptedTypes: ["CSS"], regex: /\.(css)$/i },
+    Text: { acceptedTypes: ["TXT"], regex: /\.(txt)$/i },
+};
+/**
+ * Determines if a SelectConnect `authorize` rule exists on a foreign app
+ * for this app.
+ *
+ * @param sourceApp FDC3 AppD definition for the app we're working on
+ * @param targetApp FDC3 AppD definition for the app we want to connect to
+ * @param contextType Optional context type to defined the rule
+ * @returns true if there is a matching rule
+ */
+const isInteropAuthorized = (sourceApp, targetApp, contextType) => {
+    var _a, _b, _c;
+    const rules = ((_c = (_b = (_a = targetApp.hostManifests) === null || _a === void 0 ? void 0 : _a.Finsemble) === null || _b === void 0 ? void 0 : _b.interop) === null || _c === void 0 ? void 0 : _c.selectConnect) || [];
+    // Find all authorized apps for any rules that match this context type
+    const allowedApps = rules.flatMap((rule) => {
+        var _a;
+        if (!contextType || (rule.contextType && rule.contextType !== contextType))
+            return [];
+        return (_a = rule.authorize) !== null && _a !== void 0 ? _a : [];
+    });
+    return allowedApps.some((rule) => rule.appId === sourceApp.appId);
+};
+/**
+ * Arranges an array of words for display to end user
+ * "apples"
+ * "apples or oranges"
+ * "apples, oranges, or bananas"
+ */
+const prettyList = (words) => {
+    const { length } = words;
+    if (length === 0)
+        return "";
+    if (length === 1)
+        return words[0];
+    if (length === 2)
+        return `${words[0]} or ${words[1]}`;
+    return `${words.slice(0, length - 2).join(", ")} or ${words[length - 1]}`;
+};
+/**
+ * checkValidProjectName
+ */
+const checkValidProjectName = (name) => /^[a-zA-Z0-9 \-_.]{1,}$/.test(name) && /[a-zA-Z0-9]{1,}/.test(name);
+/**
+ * Check an arbitrary string to see if it is a valid url
+ * The only checks for validity are:
+ * * if the string begins with "http://" or "https://"
+ *
+ * @param url - the potential URL
+ */
+const checkValidURL = (url) => {
+    if (url.length === 0) {
+        return true;
+    }
+    return /^https?:\/\/[^\s]+$/.test(url);
+};
+/**
+ * Check an arbitrary string to see if it is a valid path
+ * that begins with a macro.
+ * Note that macros must:
+ *  * Come at the beginning of the path
+ *  * Begin with "$"
+ *  * Otherwise only contain letters.
+ *
+ * Examples of macros: "$applicationRoot", "$moduleRoot"
+ * While all macros used by Finsemble end in "Root", clients can
+ * specify custom macros, which are not required to follow that practice.
+ *
+ * @param macroPath - path that potentially begins with a macro
+ */
+const checkValidMacroPath = (macroPath) => {
+    if (macroPath.length === 0) {
+        return false;
+    }
+    return /^\$[a-zA-Z]+[\/\\]/.test(macroPath);
+};
+const checkValidLocation = (urlOrMacroPath) => checkValidURL(urlOrMacroPath) || checkValidMacroPath(urlOrMacroPath);
+const manifestRoots = {};
+/**
+ *
+ * Test Driver Example (can paste into component console)
+ *
+ window.smartDesktopClientDriver = async function makerClientDriver() {
+    {
+        let { err, apps } = await SmartDesktopClient.getApps();
+        Logger.log("getApps", err ? err : "ok" , apps);
+    }
+    {
+        let { err, config } = await SmartDesktopClient.getAppConfig("Rates");
+        Logger.log("getAppConfig", err ? err : "ok" , config);
+    }
+    {
+        let { config } = SmartDesktopClient.getAppConfigTemplate();
+        let { err } = await SmartDesktopClient.addApp("testApp1", config);
+        Logger.log("addApp", err ? err : "ok" );
+    }
+    {
+        let { err } = await SmartDesktopClient.deleteApp("testApp1");
+        Logger.log("deleteApp", err ? err : "ok" );
+    }
+    {
+        Logger.log("updateTheme", err ? err : "ok" );
+        let { err } = await SmartDesktopClient.updateInstallerDescription({ name: "sample installer name", version: "V0.0.0", authors: "M. Smith", description: "sample installer descriptions" });
+        Logger.log("updateInstallerDescription", err ? err : "ok" );
+    }
+    {
+        let blob = await fetch("http://localhost:3375/assets/img/test.png").then(r => r.blob());
+        var file = new File([blob], "foo.png");
+        let { err } = await SmartDesktopClient.updateToolbarIcon(file);
+        console.log("updateToolbarIcon", err ? err : "ok" );
+    }
+    {
+        let blob = await fetch("http://localhost:3375/assets/img/test.png").then(r => r.blob());
+        var file = new File([blob], "foo.png");
+        let { err } = await SmartDesktopClient.updateTaskbarIcon(file);
+        console.log("updateTaskbarIcon", err ? err : "ok" );
+    }
+    {
+        let blob = await fetch("http://localhost:3375/assets/img/test.png").then(r => r.blob());
+        var file = new File([blob], "foo.png");
+        let { err } = await SmartDesktopClient.updateSystemTrayIcon(file);
+        console.log("updateSystemTrayIcon", err ? err : "ok" );
+    }
+    {
+        let blob = await fetch("http://localhost:3375/assets/img/test.ico").then(r => r.blob());
+        var file = new File([blob], "foo.ico");
+        let { err } = await SmartDesktopClient.updateInstallerIcon(file);
+        console.log("updateInstallerIcon", err ? err : "ok" );
+    }
+    {
+        let blob = await fetch("http://localhost:3375/assets/img/install-spinner.gif").then(r => r.blob());
+        var file = new File([blob], "foo.gif");
+        let { err } = await SmartDesktopClient.updateInstallerGraphic(file);
+        console.log("updateInstallerGraphic", err ? err : "ok" );
+    }
+    {
+        let blob = await fetch("http://localhost:3375/assets/img/test.svg").then(r => r.blob());
+        var file = new File([blob], "foo.svg");
+        let { err } = await SmartDesktopClient.updateSplashScreen(file);
+        console.log("updateSplashScreen", err ? err : "ok" );
+    }
+    {
+        let { err } = await SmartDesktopClient.updateTheme({ cssSampleData: 1 });
+        console.log("updateTheme", err ? err : "ok" );
+    }
+    {
+        let { err } = await SmartDesktopClient.createProjectZip("testApp", "~/Downloads/");
+        Logger.log("createProjectZip", err ? err : "ok" );
+    }
+    {
+        <input type="file" onChange={(e) => {
+            const file = e.target.files?.[0];
+
+            let { err } = await SmartDesktopClient.uploadAssets([
+                {
+                    file,
+                    type: AssetType.Image,
+                    targetPath: 'image.png',
+                }
+            ], (progress) => {
+                // ...
+            });
+
+            Logger.log("uploadAssets", err ? err : "ok" );
+        }} />
+    }
+}
+ */
+export const SmartDesktopClient = {
+    getSDServerInfo: async () => await System.getSDServerInfo(),
+    /**
+     * Confirm the Smart Desktop Server is enabled.  This should be true before constructing and using a client.
+     *
+     * @static
+     * @returns {Promise<Boolean>}
+     */
+    async isEnabled() {
+        const { enabled } = await System.getSDServerInfo();
+        return enabled;
+    },
+    /**
+     * Get the smart desktop server base URL.
+     *
+     * @static
+     * @returns {Promise<Boolean>}
+     */
+    async applicationRoot() {
+        const { applicationRoot } = await System.getSDServerInfo();
+        return applicationRoot ? applicationRoot : null;
+    },
+    /**
+     *
+     */
+    async projectConfig() {
+        const { projectConfig } = await System.getSDServerInfo();
+        return projectConfig ? projectConfig : null;
+    },
+    /**
+     * Get list of all AppD applications
+     *
+     * @returns {Promise<{ err:any, apps:FDC3AppDefinition[]}>}
+     *
+     * @example
+     * let { err, apps } = await SmartDesktopClient.getApps();
+     */
+    async getApps() {
+        var _a;
+        Logger.system.log("SmartDesktopClient.getApps");
+        const { err, response } = await RouterClient.query(`${MAKER_TOPIC}.getApps`, {});
+        Logger.system.log("SmartDesktopClient.getApps result", err ? err : "successful", response);
+        return { err, apps: (_a = response === null || response === void 0 ? void 0 : response.data.applications) !== null && _a !== void 0 ? _a : [] };
+    },
+    /**
+     * Get list of all AppD applications
+     *
+     * @returns {Promise<{ err:any, apps:FDC3AppDefinition[]}>}
+     *
+     * @example
+     * let { err, apps } = await SmartDesktopClient.getApps();
+     */
+    async removeAllEntriesFromAppDJson() {
+        Logger.system.log("SmartDesktopClient.removeAllEntriesFromAppDJson");
+        const { err, response } = await RouterClient.query(`${MAKER_TOPIC}.removeAllEntriesFromAppDJson`, {});
+        Logger.system.log("SmartDesktopClient.removeAllEntriesFromAppDJson result", err ? err : "successful", response);
+        return { err: err !== null && err !== void 0 ? err : null };
+    },
+    /**
+     * Get list of all AppD applications
+     *
+     * @returns {Promise<{ err:any, apps:FDC3AppDefinition[]}>}
+     *
+     * @example
+     * let { err, apps } = await SmartDesktopClient.getDeprecatedEntriesFromAppDJsonFile();
+     */
+    async getDeprecatedEntriesFromAppDJsonFile() {
+        var _a;
+        Logger.system.log("SmartDesktopClient.getDeprecatedEntriesFromAppDJsonFile");
+        const { err, response } = await RouterClient.query(`${MAKER_TOPIC}.getDeprecatedEntriesFromAppDJsonFile`, {});
+        Logger.system.log("SmartDesktopClient.getDeprecatedEntriesFromAppDJsonFile result", err ? err : "successful", response);
+        return { err, apps: (_a = response === null || response === void 0 ? void 0 : response.data.applications) !== null && _a !== void 0 ? _a : [] };
+    },
+    /**
+     * Get list of all Menus
+     *
+     * @returns {Promise<{ err:any, data:any}>}
+     *
+     * @example
+     * let { err, menus } = await SmartDesktopClient.getMenus();
+     */
+    async getMenus() {
+        Logger.system.log("ConfigClient getValue 'finsemble.toolbarMenus'");
+        const { err, data } = await ConfigClient.getValue({ field: "finsemble.toolbarMenus" });
+        Logger.system.log("finsemble.toolbarMenus result", err ? err : "successful", data);
+        return { err, menus: data };
+    },
+    /**
+     * Get the config.extensions.preloads object (from appd.json), which includes all registered
+     * preloads and their details
+     */
+    async getPreloads() {
+        var _a;
+        Logger.system.log("SmartDesktopClient.getPreloads");
+        const { err, response } = await RouterClient.query(`${MAKER_TOPIC}.getPreloads`, {});
+        Logger.system.log("SmartDesktopClient.getPreloads result", err ? err : "successful", response);
+        return { err, data: (_a = response === null || response === void 0 ? void 0 : response.data.preloads) !== null && _a !== void 0 ? _a : {} };
+    },
+    /**
+     * Get config for the specified AppD app.
+     *
+     * @example
+     * let { err, config } = await SmartDesktopClient.getAppConfig("testApp");
+     */
+    async getAppConfig(appId) {
+        var _a;
+        Logger.system.log("SmartDesktopClient.getAppConfig", appId);
+        const { err, response } = await RouterClient.query(`${MAKER_TOPIC}.getAppConfig`, { appId });
+        Logger.system.log("SmartDesktopClient.getAppConfig result", err ? err : "successful", response);
+        return { err, config: (_a = response === null || response === void 0 ? void 0 : response.data) !== null && _a !== void 0 ? _a : {} };
+    },
+    /**
+     * Helper function returning a AppD config template with Finsemble component in manifest property.
+     *
+     * @returns {Promise<{ config: any }>}
+     *
+     * @example
+     * let { config } = SmartDesktopClient.getAppConfigTemplate();
+     */
+    getAppConfigTemplate() {
+        Logger.system.log("SmartDesktopClient.getAppConfigTemplate");
+        const manifestJson = {
+            window: {
+                // url: "$applicationRoot/components/welcome/welcome.html",
+                url: "",
+                width: 1280,
+                height: 600,
+            },
+            foreign: {
+                components: {
+                    "App Launcher": {
+                        launchableByUser: true,
+                    },
+                    "Window Manager": {
+                        persistWindowState: true,
+                        FSBLHeader: true,
+                    },
+                },
+            },
+        };
+        const appConfigTemplate = {
+            appId: "123",
+            name: "",
+            type: "web",
+            details: {
+                url: "",
+            },
+            hostManifests: {
+                Finsemble: manifestJson,
+            },
+        };
+        Logger.system.log("SmartDesktopClient.getAppConfigTemplate result", appConfigTemplate);
+        return { config: appConfigTemplate };
+    },
+    /**
+     * Add AppD application, which will modify Finsemble config and invoke REST API to persist the change
+     *
+     * @example
+     * let { err } = await SmartDesktopClient.addApp("testApp", config);
+     */
+    async addApp(appId, appConfig) {
+        Logger.system.log("SmartDesktopClient.addApp", appId, appConfig);
+        const { err } = await RouterClient.query(`${MAKER_TOPIC}.addApp`, { appId, appConfig });
+        Logger.system.log("SmartDesktopClient.addApp result", err ? err : "successful");
+        return { err };
+    },
+    async addMenu(menuConfig) {
+        Logger.system.log("SmartDesktopClient.addMenu");
+        const { err } = await RouterClient.query(`${MAKER_TOPIC}.addMenu`, { menuConfig });
+        await this.syncMenuConfig();
+        Logger.system.log("SmartDesktopClient.addMenu result", err ? err : "successful");
+        return { err };
+    },
+    async syncMenuConfig() {
+        var _a;
+        Logger.system.log("SmartDesktopClient.syncMenuConfig");
+        const { response } = await RouterClient.query(`${MAKER_TOPIC}.getMenus`, {});
+        await ConfigClient.setValue({
+            field: "finsemble.toolbarMenus",
+            value: ((_a = response === null || response === void 0 ? void 0 : response.data) === null || _a === void 0 ? void 0 : _a.menus) || {},
+        });
+        Logger.system.log("SmartDesktopClient.syncMenuConfig completed");
+    },
+    async updateMenu(menuId, menuConfig) {
+        Logger.system.log("SmartDesktopClient.updateMenu", menuId, menuConfig);
+        const { err } = await RouterClient.query(`${MAKER_TOPIC}.updateMenu`, { menuId, menuConfig });
+        await this.syncMenuConfig();
+        Logger.system.log("SmartDesktopClient.updateMenu result", err ? err : "successful");
+        return { err };
+    },
+    /**
+     * Add AppD application, which will modify Finsemble config and invoke REST API to persist the change
+     *
+     * @example
+     * let { err } = await SmartDesktopClient.updateApp("testApp", config);
+     */
+    async updateApp(appId, appConfig) {
+        Logger.system.log("SmartDesktopClient.updateApp", appId, appConfig);
+        const { err } = await RouterClient.query(`${MAKER_TOPIC}.updateApp`, { appId, appConfig });
+        Logger.system.log("SmartDesktopClient.updateApp result", err ? err : "successful");
+        return { err };
+    },
+    /**
+     * Create/updates the preload with the specific preload alias
+     */
+    async savePreload(oldAlias, newAlias, detail) {
+        Logger.system.log("SmartDesktopClient.savePreload");
+        const { err } = await RouterClient.query(`${MAKER_TOPIC}.savePreload`, { oldAlias, newAlias, detail });
+        Logger.system.log("SmartDesktopClient.savePreload result", err ? err : "successful");
+        const { response } = await RouterClient.query(`${MAKER_TOPIC}.getPreloads`, {});
+        if (!err && response.data) {
+            await ConfigClient.setValue({
+                field: "finsemble.extensions.preloads",
+                value: response.data.preloads,
+            });
+        }
+        return { err };
+    },
+    /**
+     * Remove AppD application, which will modify Finsemble config and invoke REST API to persist the change
+     *
+     * @example
+     * let { err } = await SmartDesktopClient.deleteApp("testApp");
+     */
+    async deleteApp(appId) {
+        Logger.system.log("SmartDesktopClient.deleteApp", appId);
+        const { err } = await RouterClient.query(`${MAKER_TOPIC}.deleteApp`, { appId });
+        Logger.system.log("SmartDesktopClient.deleteApp result", err ? err : "successful");
+        return { err };
+    },
+    async deleteMenu(menuId) {
+        Logger.system.log("SmartDesktopClient.deleteMenu", menuId);
+        const { err } = await RouterClient.query(`${MAKER_TOPIC}.deleteMenu`, { menuId });
+        await this.syncMenuConfig();
+        Logger.system.log("SmartDesktopClient.deleteMenu result", err ? err : "successful");
+        return { err };
+    },
+    /**
+     * Remove a given preload from the registry in the config
+     */
+    async deletePreload(alias) {
+        Logger.system.log("SmartDesktopClient.deletePreload");
+        const { err } = await RouterClient.query(`${MAKER_TOPIC}.deletePreload`, { alias });
+        Logger.system.log("SmartDesktopClient.deletePreload result", err ? err : "successful");
+        const { response } = await RouterClient.query(`${MAKER_TOPIC}.getPreloads`, {});
+        if (!err && response.data) {
+            await ConfigClient.setValue({
+                field: "finsemble.extensions.preloads",
+                value: response.data.preloads,
+            });
+        }
+        return { err };
+    },
+    /**
+     * Update the theme of all components and invoke REST API to persist the change in Finsemble's theme.css file
+     *
+     * @example
+     * let { err } = await SmartDesktopClient.updateTheme(cssData);
+     */
+    async updateTheme(theme) {
+        Logger.system.log("SmartDesktopClient.updateTheme", theme);
+        const { err } = await RouterClient.query(`${MAKER_TOPIC}.updateTheme`, { theme });
+        Logger.system.log("SmartDesktopClient.updateTheme result", err ? err : "successful");
+        return { err };
+    },
+    /**
+     * Get the theme from the REST API
+     *
+     * @returns {Promise<{ err, theme }>}
+     * @memberOf SmartDesktopClient
+     *
+     * @example
+     * let { err, theme } = await SmartDesktopClient.getTheme(cssData);
+     */
+    async getTheme() {
+        Logger.system.log("SmartDesktopClient.getTheme");
+        const { err, response } = await RouterClient.query(`${MAKER_TOPIC}.getTheme`, {});
+        Logger.system.log("SmartDesktopClient.getTheme result", err ? err : "successful");
+        return { err, theme: response === null || response === void 0 ? void 0 : response.data };
+    },
+    /**
+     * Add handler listening for theme updates
+     *
+     * @returns When called, unsubscribes the handler
+     */
+    onThemeUpdated(themeUpdatedHandler) {
+        RouterClient.addListener(`${UI_CHANGE_TOPIC}.themeUpdate`, themeUpdatedHandler);
+        Logger.system.log("SmartDesktopClient.onThemeUpdated", themeUpdatedHandler);
+        return () => RouterClient.removeListener(`${UI_CHANGE_TOPIC}.themeUpdate`, themeUpdatedHandler);
+    },
+    /**
+     * Post a file to the smart desktop server
+     *
+     * @example
+     * ...
+     */
+    async uploadAssets(assets, progress) {
+        Logger.system.log("SmartDesktopClient.uploadAssets", assets);
+        const applicationRoot = await this.applicationRoot();
+        // Returns a string of accepted file types if the asset does not match a known type
+        const getAcceptedTypes = (asset) => {
+            let acceptedTypes = [];
+            let valid = false;
+            Object.entries(assetTests).forEach(([key, value]) => {
+                if (asset.type.includes(key)) {
+                    if (value.regex.test(asset.file.name))
+                        valid = true;
+                    acceptedTypes = acceptedTypes.concat(value.acceptedTypes);
+                }
+            });
+            return valid ? [] : acceptedTypes;
+        };
+        return new Promise((resolve) => {
+            const endpointURL = `${applicationRoot}/project/assets`;
+            const data = new FormData();
+            const assetMeta = [];
+            for (let index = 0; index < assets.length; index++) {
+                const asset = assets[index];
+                const meta = {
+                    key: `file-${index}`,
+                    name: asset.file.name,
+                    type: asset.file.type,
+                    size: asset.file.size,
+                    targetPath: asset.targetPath,
+                };
+                const acceptedTypes = getAcceptedTypes(asset);
+                if (acceptedTypes.length) {
+                    const error = `File must be of type ${prettyList(acceptedTypes)}`;
+                    Logger.system.log("SmartDesktopClient.uploadAssets wrong image type", error);
+                    return resolve({ err: error, paths: [] });
+                }
+                else {
+                    Logger.system.log("SmartDesktopClient.uploadAssets append", meta.key, asset.file);
+                    data.append(meta.key, asset.file);
+                    assetMeta.push(meta);
+                }
+            }
+            data.append("assets", JSON.stringify(assetMeta));
+            var xhr = new XMLHttpRequest();
+            Logger.system.log("SmartDesktopClient.uploadAssets put", data, endpointURL);
+            xhr.open("PUT", endpointURL, true);
+            xhr.addEventListener("progress", (e) => {
+                progress(Math.round((e.loaded / e.total) * 100));
+            });
+            // xhr.setRequestHeader("Content-Type", "application/x-www-form-urlencoded");
+            xhr.onreadystatechange = () => {
+                // Call a function when the state changes.
+                if (xhr.readyState === XMLHttpRequest.DONE) {
+                    progress(100);
+                    if (xhr.status !== 200) {
+                        Logger.system.log("SmartDesktopClient.uploadAssets Failed Response", xhr.response);
+                        resolve({ err: `Got response code: ${xhr.status}`, paths: [] });
+                    }
+                    else {
+                        try {
+                            const response = JSON.parse(xhr.response);
+                            Logger.system.log("SmartDesktopClient.uploadAssets Response", xhr.response);
+                            resolve({ err: null, paths: response.paths });
+                        }
+                        catch (e) {
+                            resolve({ err: "Couldn't parse response", paths: [] });
+                        }
+                    }
+                }
+            };
+            Logger.system.log("SmartDesktopClient.uploadAssets send", data);
+            xhr.send(data);
+        });
+    },
+    /**
+     * Post images to the smart desktop server
+     *
+     * @example
+     * ...
+     */
+    async uploadImages(files, progress) {
+        return this.uploadAssets(files.map((file) => ({
+            file,
+            type: ["Image", "GIF"],
+        })), progress);
+    },
+    /**
+     * Post an image to the smart desktop server
+     *
+     * @example
+     * ...
+     */
+    async uploadImage(file, progress) {
+        return new Promise((resolve, reject) => {
+            this.uploadImages([file], progress)
+                .then((response) => {
+                resolve({ err: response.err, path: response.paths[0] });
+            })
+                .catch(reject);
+        });
+    },
+    /**
+     * Update installer description by using REST API to persist the change
+     *
+     * @example
+     * let { err } = await SmartDesktopClient.updateInstallerDescription(installerDescription);
+     */
+    async updateInstallerDescription(installerDescription) {
+        Logger.system.log("SmartDesktopClient updateInstallerDescription", installerDescription);
+        const { err } = await httpPatch(`/project/installer`, installerDescription);
+        Logger.system.log("SmartDesktopClient.updateInstallerDescription Response", err ? err : "successful");
+        return { err };
+    },
+    /**
+     * Update installer description by using REST API to persist the change
+     *
+     * @example
+     * let { err } = await SmartDesktopClient.updateInstallerDescription(installerDescription);
+     */
+    async updateProjectSettings(settings) {
+        const { err } = await httpPatch(`/project/settings`, settings);
+        return { err };
+    },
+    /**
+     * Update installer description by using REST API to persist the change
+     *
+     * @example
+     * let { err } = await SmartDesktopClient.updateInstallerDescription(installerDescription);
+     */
+    async deleteProject(name) {
+        const { err } = await httpDelete(`/project/settings/${name}`);
+        return { err };
+    },
+    /**
+     * Get project settings
+     *
+     * @example
+     * let { settings, err } = await SmartDesktopClient.getProjectSettings();
+     */
+    async getProjectSettings() {
+        const response = await httpGet(`/project/settings`);
+        return response.getData;
+    },
+    /**
+     * Get all available projects and the current project name
+     *
+     * @example
+     * let { settings, err } = await SmartDesktopClient.getProjectSettings();
+     */
+    async getProjects() {
+        const response = await httpGet(`/projects`);
+        return response.getData;
+    },
+    /**
+     * Updates the @finsemble/finsemble-core dependency version in the package.json file for the given project
+     * @param projectName - The project to update
+     * @param finsembleCoreVersion - The version to set (obtained from getFSBLInfo() )
+     * @returns
+     */
+    async updateFinsembleCoreVersion(projectName, finsembleCoreVersion) {
+        const { err } = await httpPatch(`/projects/${projectName}/finsembleCoreVersion`, {
+            finsembleCoreVersion,
+        });
+        return { err };
+    },
+    /**
+     * Update project details
+     *
+     * @example
+     * let { err } = await SmartDesktopClient.updateProjectDetails({
+     *   oldName: string;
+     *   newName: string;
+     *   cloneCurrent: boolean;
+     * });
+     */
+    async updateProjectDetails(obj) {
+        const { err } = await httpPatch(`/project/details`, obj);
+        return { err };
+    },
+    /**
+     * Set the active project
+     *
+     * @example
+     * let { err } = await SmartDesktopClient.setActiveProject("projectName");
+     */
+    async setActiveProject(projectName) {
+        const { err } = await httpPut(`/project/details/active`, { activeProject: projectName });
+        return { err };
+    },
+    /**
+     * Helper function -- progress descriptor for updating files
+     *
+     */
+    progressIndicator(progress) {
+        Logger.system.log("SmartDesktopClient.progressIndicator Console-Only", progress);
+        console.log("Console-Only Progress Indicator:", progress);
+    },
+    /**
+     * Update Finsemble toolbar icon file and transmit correspond ui-changed message so UI will pick up change
+     *
+     * @returns {Promise<{ err: any }>}
+     */
+    async updateToolbarIcon(imageFile) {
+        const TARGET_FILE = "assets/img/Finsemble_Toolbar_Icon.png";
+        Logger.system.log("SmartDesktopClient.updateToolbarIcon", TARGET_FILE, imageFile);
+        const { err, paths } = await this.uploadAssets([
+            {
+                file: imageFile,
+                type: ["Image", "GIF"],
+                targetPath: TARGET_FILE,
+            },
+        ], this.progressIndicator);
+        if (!err) {
+            // transmit change notification so Finsemble can dynamically update (see toolbar)
+            RouterClient.transmit("Finsemble-ui-change.toolbarIconUpdate", {});
+        }
+        Logger.system.log("SmartDesktopClient.updateToolbarIcon result", err ? err : "successful");
+        return { err, path: paths[0] };
+    },
+    /**
+     * Update Finsemble taskbar icon file and transmit correspond ui-changed message so UI will pick up change
+     *
+     */
+    async updateTaskbarIcon(imageFile) {
+        const TARGET_FILE = "assets/img/Finsemble_Taskbar_Icon.png";
+        Logger.system.log("SmartDesktopClient.updateTaskbarIcon", imageFile);
+        const { err, paths } = await this.uploadAssets([
+            {
+                file: imageFile,
+                type: ["Image"],
+                targetPath: TARGET_FILE,
+            },
+        ], this.progressIndicator);
+        if (!err) {
+            // transmit notification so Finsemble can dynamically update (e.g. toolbar, taskbar)
+            RouterClient.transmit("Finsemble-ui-change.taskbarIconUpdate", {});
+        }
+        Logger.system.log("SmartDesktopClient.updateTaskbarIcon result", err ? err : "successful");
+        return { err, path: paths[0] };
+    },
+    /**
+     * Update system tray icon file and refresh config entry to trigger notification
+     *
+     */
+    async updateSystemTrayIcon(imageFile) {
+        const TARGET_FILE = "assets/img/Finsemble_SystemTray_Icon.png";
+        Logger.system.log("SmartDesktopClient.updateSystemTrayIcon", imageFile);
+        const { err: error1, paths } = await this.uploadAssets([
+            {
+                file: imageFile,
+                type: ["Image"],
+                targetPath: TARGET_FILE,
+            },
+        ], this.progressIndicator);
+        // since the icon URL is kept in config, refresh the config entry using the current value to trigger a notification
+        const { err: error2 } = await RouterClient.query(`${MAKER_TOPIC}.refreshSystemTrayIconConfig`, {});
+        Logger.system.log("SmartDesktopClient.updateSystemTrayIcon result", error1 || error2 ? { error1, error2 } : "successful");
+        // Jumping through typescript hoops due to CallbackError type
+        const error = error1 || error2 || null;
+        return { err: error ? error.toString() : null, path: paths[0] };
+    },
+    /**
+     * Update the installer Icon file -- the change will not be picked up until the installer is built
+     *
+     */
+    async updateInstallerIcon(iconFile) {
+        const TARGET_FILE = "assets/img/installer_icon.ico";
+        Logger.system.log("SmartDesktopClient.updateInstallerIcon", iconFile);
+        const { err, paths } = await this.uploadAssets([
+            {
+                file: iconFile,
+                type: ["Icon"],
+                targetPath: TARGET_FILE,
+            },
+        ], this.progressIndicator);
+        Logger.system.log("SmartDesktopClient.updateSystemTrayIcon result", err ? err : "successful");
+        return { err, path: paths[0] };
+    },
+    /**
+     * Update the installer graphic file -- the change will not be picked up until the installer is built
+     */
+    async updateInstallerGraphic(gifFile) {
+        const TARGET_FILE = "assets/img/installer_spinner.gif";
+        Logger.system.log("SmartDesktopClient.updateInstallerGraphic", gifFile);
+        const { err, paths } = await this.uploadAssets([
+            {
+                file: gifFile,
+                type: ["Image", "GIF"],
+                targetPath: TARGET_FILE,
+            },
+        ], this.progressIndicator);
+        Logger.system.log("SmartDesktopClient.updateInstallerGraphic result", err ? err : "successful");
+        return { err, path: paths[0] };
+    },
+    /**
+     * Update the splash screen image file -- the change will not be picked up until Finsemble/FEA is restarted
+     */
+    async updateSplashScreen(svgFile) {
+        const TARGET_FILE = "assets/img/FinsembleSplash.png";
+        Logger.system.log("SmartDesktopClient.updateSplashScreen", svgFile);
+        const { err, paths } = await this.uploadAssets([
+            {
+                file: svgFile,
+                type: ["Image", "GIF"],
+                targetPath: TARGET_FILE,
+            },
+        ], this.progressIndicator);
+        Logger.system.log("SmartDesktopClient.updateSplashScreen result", err ? err : "successful");
+        return { err, path: paths[0] };
+    },
+    /**
+     * Helper function to update a single theme variable within Finsemble's theme
+     */
+    async updateThemeVariable(varName, varValue) {
+        const theme = {};
+        theme[varName] = varValue;
+        Logger.system.log("SmartDesktopClient.updateThemeVariable", theme);
+        return this.updateTheme(theme);
+    },
+    /**
+     * Save a .zip file of the project with `appName` to the local filesystem at `targetPath`
+     * @example
+     * let { err } = await SmartDesktopClient.createProjectZip("testApp", "~/Downloads/");
+     */
+    async createProjectZip(appName, targetPath = undefined) {
+        const applicationRoot = await this.applicationRoot();
+        Logger.system.log("SmartDesktopClient.createProjectZip", applicationRoot);
+        return new Promise((resolve, reject) => {
+            const onTargetPath = (targetPathInner) => {
+                const endpointURL = `${applicationRoot}/project/${appName}/zip?targetPath=${encodeURIComponent(targetPathInner)}`;
+                Logger.system.log(endpointURL);
+                fetch(endpointURL)
+                    .then((response) => response.json())
+                    .then((data) => {
+                    resolve(data.file);
+                })
+                    .catch(reject);
+            };
+            if (targetPath) {
+                onTargetPath(targetPath);
+            }
+            else {
+                FEAGlobals.finsembleWindow.showNativeOpenDialog({
+                    title: "Select an output directory",
+                    buttonLabel: "Save .zip file",
+                    properties: ["openDirectory"],
+                }, (err, response) => {
+                    var _a, _b, _c;
+                    if (((_b = (_a = response === null || response === void 0 ? void 0 : response[0]) === null || _a === void 0 ? void 0 : _a.filePaths) === null || _b === void 0 ? void 0 : _b.length) > 0) {
+                        onTargetPath((_c = response === null || response === void 0 ? void 0 : response[0]) === null || _c === void 0 ? void 0 : _c.filePaths[0]);
+                    }
+                    else {
+                        reject("No file selected");
+                    }
+                });
+            }
+        });
+    },
+    /**
+     * Copy project assets/config to target dir
+     *
+     * @example
+     * await SmartDesktopClient.copyProjectFiles("testApp");
+     * await SmartDesktopClient.copyProjectFiles("testApp", "/specific/path");
+     */
+    async copyProjectFiles(appName, targetPath = undefined // allow passing manually specified targetPath
+    ) {
+        const applicationRoot = await this.applicationRoot();
+        Logger.system.log("SmartDesktopClient.createProjectZip", applicationRoot);
+        return new Promise((resolve, reject) => {
+            // callback to forward targetPath to the server REST API endpoint
+            // regardless of whether targetPath is manually specified or retrieved via showNativeOpenDialog
+            const onTargetPath = (selectedTargetPath) => {
+                const endpointURL = `${applicationRoot}/project/${appName}/copy?targetPath=${encodeURIComponent(selectedTargetPath)}`;
+                Logger.system.debug(`copyProjectFiles: copying ${selectedTargetPath}, ${endpointURL}`);
+                fetch(endpointURL)
+                    .then((response) => response.json())
+                    .then((data) => {
+                    if (data.error) {
+                        reject(data.error);
+                    }
+                    else {
+                        resolve();
+                    }
+                })
+                    .catch(reject);
+            };
+            if (targetPath) {
+                // we've manually specified a targetPath
+                onTargetPath(targetPath);
+            }
+            else {
+                // Open a native file selection dialog and relay the selected file to our callback
+                FEAGlobals.finsembleWindow.showNativeOpenDialog({
+                    title: "Select Filesystem Destination",
+                    buttonLabel: "Copy Project",
+                    properties: ["openDirectory"],
+                }, (err, response) => {
+                    var _a, _b, _c;
+                    if (((_b = (_a = response === null || response === void 0 ? void 0 : response[0]) === null || _a === void 0 ? void 0 : _a.filePaths) === null || _b === void 0 ? void 0 : _b.length) > 0) {
+                        onTargetPath((_c = response === null || response === void 0 ? void 0 : response[0]) === null || _c === void 0 ? void 0 : _c.filePaths[0]);
+                    }
+                    else {
+                        reject("No file selected");
+                    }
+                });
+            }
+        });
+    },
+    /**
+     * Copy project assets/config to target dir
+     *
+     * @example
+     * let {err, data: newFolderLocation} = await SmartDesktopClient.moveProjectFiles("testApp");
+     */
+    async moveProjectFiles(appName) {
+        const applicationRoot = await this.applicationRoot();
+        Logger.system.log("SmartDesktopClient.moveProjectFiles", applicationRoot);
+        return new Promise((resolve, reject) => {
+            // callback to forward targetPath to the server REST API endpoint
+            // regardless of whether targetPath is manually specified or retrieved via showNativeOpenDialog
+            const onTargetPath = (selectedTargetPath) => {
+                const endpointURL = `${applicationRoot}/project/${appName}/move?targetPath=${encodeURIComponent(selectedTargetPath)}`;
+                Logger.system.debug(`moving project files: moving ${selectedTargetPath}, ${endpointURL}`);
+                fetch(endpointURL)
+                    .then((response) => response.json())
+                    .then((data) => {
+                    if (data.error) {
+                        reject(data.error);
+                    }
+                    else {
+                        resolve({ data: selectedTargetPath });
+                    }
+                })
+                    .catch(reject);
+            };
+            // Open a native file selection dialog and relay the selected file to our callback
+            FEAGlobals.finsembleWindow.showNativeOpenDialog({
+                title: "Select Filesystem Destination",
+                buttonLabel: "Select",
+                properties: ["openDirectory"],
+            }, (err, response) => {
+                var _a, _b, _c;
+                if (((_b = (_a = response === null || response === void 0 ? void 0 : response[0]) === null || _a === void 0 ? void 0 : _a.filePaths) === null || _b === void 0 ? void 0 : _b.length) > 0) {
+                    onTargetPath((_c = response === null || response === void 0 ? void 0 : response[0]) === null || _c === void 0 ? void 0 : _c.filePaths[0]);
+                }
+                else {
+                    reject("No file selected");
+                }
+            });
+        });
+    },
+    /**
+     * Import project from a directory
+     *
+     * @example
+     * let {err} = await SmartDesktopClient.importProjectFolder();
+     */
+    async importProjectFolder() {
+        const applicationRoot = await this.applicationRoot();
+        Logger.system.log("SmartDesktopClient.importProjectFolder", applicationRoot);
+        return new Promise((resolve, reject) => {
+            // callback to forward targetPath to the server REST API endpoint
+            // regardless of whether targetPath is manually specified or retrieved via showNativeOpenDialog
+            const onTargetPath = (selectedTargetPath) => {
+                const endpointURL = `${applicationRoot}/project/import?targetPath=${encodeURIComponent(selectedTargetPath)}`;
+                Logger.system.debug(`moving project files: moving ${selectedTargetPath}, ${endpointURL}`);
+                fetch(endpointURL)
+                    .then((response) => response.json())
+                    .then((data) => {
+                    if (data.error) {
+                        reject(data.error);
+                    }
+                    else {
+                        resolve({ data: selectedTargetPath });
+                    }
+                })
+                    .catch(reject);
+            };
+            // Open a native file selection dialog and relay the selected file to our callback
+            FEAGlobals.finsembleWindow.showNativeOpenDialog({
+                title: "Select existing project folder",
+                buttonLabel: "Select",
+                properties: ["openDirectory"],
+            }, (err, response) => {
+                var _a, _b, _c;
+                if (((_b = (_a = response === null || response === void 0 ? void 0 : response[0]) === null || _a === void 0 ? void 0 : _a.filePaths) === null || _b === void 0 ? void 0 : _b.length) > 0) {
+                    onTargetPath((_c = response === null || response === void 0 ? void 0 : response[0]) === null || _c === void 0 ? void 0 : _c.filePaths[0]);
+                }
+                else {
+                    reject("No file selected");
+                }
+            });
+        });
+    },
+    /**
+     * Change the path of the current project in smartDesktops.json
+     *
+     * @param appName name of app to zip
+     * @param [targetPath] output path for zip file
+     *
+     * @example
+     * let { err } = await SmartDesktopClient.createProjectZip("testApp", "~/Downloads/");
+     */
+    async selectProjectPath() {
+        return new Promise((resolve, reject) => {
+            FEAGlobals.finsembleWindow.showNativeOpenDialog({
+                title: "Select Seed Project",
+                buttonLabel: "Select Seed Project",
+                properties: ["openDirectory"],
+            }, (err, response) => {
+                var _a, _b, _c;
+                if (((_b = (_a = response === null || response === void 0 ? void 0 : response[0]) === null || _a === void 0 ? void 0 : _a.filePaths) === null || _b === void 0 ? void 0 : _b.length) > 0) {
+                    const path = (_c = response === null || response === void 0 ? void 0 : response[0]) === null || _c === void 0 ? void 0 : _c.filePaths[0];
+                    Logger.system.log("SmartDesktopClient.selectProjectPath", path);
+                    resolve(path);
+                }
+                else {
+                    reject("No file selected");
+                }
+            });
+        });
+    },
+    /**
+     * checkValidProjectName
+     */
+    checkValidProjectName(name) {
+        return checkValidProjectName(name);
+    },
+    /**
+     * Check an arbitrary string to see if it is a valid url
+     * The only checks for validity are:
+     * * if the string begins with "http://" or "https://"
+     *
+     * @param url - the potential URL
+     */
+    checkValidURL(url) {
+        return checkValidURL(url);
+    },
+    /**
+     * Check an arbitrary string to see if it is a valid path
+     * that begins with a macro.
+     * Note that macros must:
+     *  * Come at the beginning of the path
+     *  * Begin with "$"
+     *  * Otherwise only contain letters.
+     *
+     * Examples of macros: "$applicationRoot", "$moduleRoot"
+     * While all macros used by Finsemble end in "Root", clients can
+     * specify custom macros, which are not required to follow that practice.
+     *
+     * @param macroPath - path that potentially begins with a macro
+     */
+    checkValidMacroPath(macroPath) {
+        return checkValidMacroPath(macroPath);
+    },
+    /**
+     * Check an arbitrary string to see if it is a valid macro-beginning path
+     * OR a valid URL
+     *
+     * @param urlOrMacroPath - potential macro-beginning path or URL
+     */
+    checkValidLocation(urlOrMacroPath) {
+        return checkValidLocation(urlOrMacroPath);
+    },
+    async isInboundInteropAuthorized(sourceApp, targetApp, contextType) {
+        return isInteropAuthorized(sourceApp, targetApp, contextType);
+    },
+    async isOutboundInteropAuthorized(sourceApp, targetApp, contextType) {
+        return isInteropAuthorized(targetApp, sourceApp, contextType);
+    },
+    /**
+     * Publish `.zip` file to the Cosaic Cloud
+     *
+     * @returns {Promise}
+     *
+     * @example
+     * let { err } = await SmartDesktopClient.publishToCosaicCloud();
+     */
+    async publishToCosaicCloud(uuid) {
+        const applicationRoot = await this.applicationRoot();
+        Logger.system.log("SmartDesktopClient.publishToCosaicCloud", applicationRoot);
+        return new Promise(async (resolve, reject) => {
+            const endpointURL = `${applicationRoot}/project/publish/cosaicCloud?uuid=${encodeURIComponent(uuid || "")}`;
+            const response = await fetch(endpointURL, {
+                method: "PUT",
+            });
+            // We get json data back whether it's a 200 or 500 response
+            const data = await response.json();
+            if (response.ok) {
+                resolve(data);
+            }
+            else {
+                reject(data);
+            }
+        });
+    },
+    /**
+     * Get the progress of a publish request
+     *
+     * @returns {Promise}
+     *
+     */
+    async getPublishProgress() {
+        const applicationRoot = await this.applicationRoot();
+        Logger.system.log("SmartDesktopClient.getPublishProgress", applicationRoot);
+        return new Promise((resolve, reject) => {
+            const endpointURL = `${applicationRoot}/project/publish/progress`;
+            fetch(endpointURL)
+                .then((response) => response.json())
+                .then((data) => {
+                resolve(data);
+            })
+                .catch(reject);
+        });
+    },
+    /**
+     * Resets the a project to factory defaults. If no project name is provided then the current working
+     * project is assumed. In the case of the current working project, Finsemble is restarted after the reset
+     * so that the changes can take effect.
+     */
+    async resetProject(projectName) {
+        const applicationRoot = await this.applicationRoot();
+        Logger.system.log("SmartDesktopClient.resetProject", applicationRoot);
+        const endpointURL = projectName
+            ? `${applicationRoot}/projects/${projectName}/reset`
+            : `${applicationRoot}/project/reset`;
+        const response = await fetch(endpointURL, {
+            method: "PUT",
+        });
+        const data = await response.json();
+        const error = response.ok ? null : new Error(data.message);
+        response.ok && !projectName && restartApplication();
+        return [error, data];
+    },
+    /**
+     * Saves the auth providers to config.json
+     */
+    async getAuthenticationProviders() {
+        const applicationRoot = await this.applicationRoot();
+        Logger.system.log("SmartDesktopClient.getAuthenticationProviders", applicationRoot);
+        const endpointURL = `${applicationRoot}/authentication`;
+        const response = await fetch(endpointURL, {
+            method: "get",
+            headers: {
+                Accept: "application/json",
+            },
+        });
+        const data = await response.json();
+        if (!data || !Array.isArray(data.providers)) {
+            return [];
+        }
+        return data.providers;
+    },
+    /**
+     * Saves the auth providers to config.json
+     */
+    async setAuthenticationProviders(authenticationProviders) {
+        const applicationRoot = await this.applicationRoot();
+        Logger.system.log("SmartDesktopClient.setAuthenticationProviders", applicationRoot);
+        const endpointURL = `${applicationRoot}/authentication`;
+        const response = await fetch(endpointURL, {
+            method: "PUT",
+            headers: {
+                Accept: "application/json",
+                "Content-Type": "application/json",
+            },
+            body: JSON.stringify({ authenticationProviders }),
+        });
+        const data = await response.json();
+        return response.ok ? null : new Error(data.message);
+    },
+    /**
+     * Gett all AppD server listings
+     *
+     * @example
+     * let { err, servers } = await SmartDesktopClient.getAppDServers();
+     */
+    async getAppDServers() {
+        var _a;
+        Logger.system.log("SmartDesktopClient.getAppDServers");
+        const { err, response } = await RouterClient.query(`${MAKER_TOPIC}.getAppDServers`, {});
+        Logger.system.log("SmartDesktopClient.getAppDServers result", err ? err : "successful");
+        return { err, servers: (_a = response.data.servers) !== null && _a !== void 0 ? _a : [] };
+    },
+    /**
+     * Add a new AppD server (and its config items)
+     *
+     * @example
+     * let { err } = await SmartDesktopClient.addAppDServer({
+     * 	displayName: "MyServer",
+     * 	url: "/path/to/server"
+     * });
+     */
+    async addAppDServer(config) {
+        Logger.system.log("SmartDesktopClient.addAppDServer", config);
+        const { err } = await RouterClient.query(`${MAKER_TOPIC}.addAppDServer`, { config });
+        Logger.system.log("SmartDesktopClient.addAppDServer result", err ? err : "successful");
+        return { err };
+    },
+    /**
+     * Update an AppD server's metadata
+     *
+     * @example
+     * let { err } = await SmartDesktopClient.updateAppDServer(1, {
+     * 	displayName: "MyServer Updated",
+     * });
+     */
+    async updateAppDServer(index, config) {
+        Logger.system.log("SmartDesktopClient.updateAppDServer", config);
+        const { err } = await RouterClient.query(`${MAKER_TOPIC}.updateAppDServer`, { index, config });
+        Logger.system.log("SmartDesktopClient.updateAppDServer result", err ? err : "successful");
+        return { err };
+    },
+    /**
+     * Remove an AppD server's listing/metadata
+     *
+     * @example
+     * let { err } = await SmartDesktopClient.deleteAppDServer(1);
+     */
+    async deleteAppDServer(index) {
+        Logger.system.log("SmartDesktopClient.deleteAppDServer", index);
+        const { err } = await RouterClient.query(`${MAKER_TOPIC}.deleteAppDServer`, { index });
+        Logger.system.log("SmartDesktopClient.deleteAppDServer result", err ? err : "successful");
+        return { err };
+    },
+    async getManifestRoots() {
+        var _a;
+        if (Object.keys(manifestRoots).length > 0) {
+            return manifestRoots;
+        }
+        const { err, data } = await FEAGlobals.FSBL.Clients.ConfigClient.getManifest();
+        if (err || !data) {
+            return {};
+        }
+        const keys = Object.keys((_a = data.finsemble) !== null && _a !== void 0 ? _a : {}).filter((key) => key.match(/\w+Root$/));
+        keys.forEach((key) => {
+            manifestRoots[key] = data.finsemble[key];
+        });
+        return manifestRoots;
+    },
+};
+//# sourceMappingURL=smartDesktopClient.js.map