@finsemble/finsemble-ui 6.2.0 → 6.3.0-beta.20211008

package/react/components/toolbar/workspaceManagementMenu/stores/workspaceManagementMenuStore.js

@@ -1,9 +1,10 @@
 import async from "async";
+import { Util } from "@finsemble/finsemble-core";
 const SAVE_DIALOG_CANCEL_ERROR = "Cancel";
 const NEGATIVE = "Negative";
 let PROMPT_ON_SAVE = false;
-let WorkspaceManagementStore, Actions, WindowClient, StoreClient, Logger, ToolbarStore, WorkspaceManagementGlobalStore;
-let defaultData = {
+let WorkspaceManagementStore, StoreClient, Logger, WorkspaceManagementGlobalStore;
+const defaultData = {
     activeWorkspace: {},
     menuWidth: 285,
     WorkspaceList: [],
@@ -11,20 +12,15 @@ let defaultData = {
     isSwitchingWorkspaces: false,
     isPromptingUser: false,
 };
-function uuidv4() {
-    return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, (c) => {
-        var r = (Math.random() * 16) | 0, v = c === "x" ? r : (r & 0x3) | 0x8;
-        return v.toString(16);
-    });
-}
-Actions = {
+const Actions = {
     autoSave: (callback) => {
-        let activeName = FSBL.Clients.WorkspaceClient.activeWorkspace.name;
+        var _a;
+        const activeName = (_a = FSBL.Clients.WorkspaceClient.activeWorkspace) === null || _a === void 0 ? void 0 : _a.name;
         if (!PROMPT_ON_SAVE) {
             FSBL.Clients.WorkspaceClient.saveAs({
                 name: activeName,
                 force: true,
-            }, (err, response) => {
+            }, (err) => {
                 callback(err);
             });
         }
@@ -32,7 +28,7 @@ Actions = {
             callback(null);
         }
     },
-    initialize: function () {
+    initialize: () => {
         FSBL.Clients.WorkspaceClient.getWorkspaces((err, workspaces) => {
             Logger.system.debug("WorkspaceManagementStore init getWorkspaces", workspaces);
             WorkspaceManagementStore.setValue({
@@ -81,45 +77,32 @@ Actions = {
                         Logger.system.debug("WorkspaceManagementStore renameWorkspace", action.data);
                         Actions.renameWorkspace(action.data);
                         break;
+                    default:
+                        break;
                 }
             });
         });
     },
-    getActiveWorkspace: function () {
-        return WorkspaceManagementStore.getValue("activeWorkspace");
-    },
-    getWorkspaceBeingEdited: function () {
-        return WorkspaceManagementStore.getValue("workspaceBeingEdited");
-    },
-    getWorkspaceList: function () {
-        return WorkspaceManagementStore.getValue("WorkspaceList");
-    },
-    getIsSwitchingWorkspaces: function () {
-        return WorkspaceManagementStore.getValue("isSwitchingWorkspaces");
-    },
-    setIsSwitchingWorkspaces: function (val) {
-        return WorkspaceManagementStore.setValue({
-            field: "isSwitchingWorkspaces",
-            value: val,
-        });
-    },
-    getIsPromptingUser: function () {
-        return WorkspaceManagementStore.getValue("isPromptingUser");
-    },
-    setIsPromptingUser: function (val) {
-        return WorkspaceManagementStore.setValue({
-            field: "isPromptingUser",
-            value: val,
-        });
-    },
+    getActiveWorkspace: () => WorkspaceManagementStore.getValue("activeWorkspace"),
+    getWorkspaceBeingEdited: () => WorkspaceManagementStore.getValue("workspaceBeingEdited"),
+    getWorkspaceList: () => WorkspaceManagementStore.getValue("WorkspaceList"),
+    getIsSwitchingWorkspaces: () => WorkspaceManagementStore.getValue("isSwitchingWorkspaces"),
+    setIsSwitchingWorkspaces: (val) => WorkspaceManagementStore.setValue({
+        field: "isSwitchingWorkspaces",
+        value: val,
+    }),
+    getIsPromptingUser: () => WorkspaceManagementStore.getValue("isPromptingUser"),
+    setIsPromptingUser: (val) => WorkspaceManagementStore.setValue({
+        field: "isPromptingUser",
+        value: val,
+    }),
     newWorkspace: function () {
         let newWorkspaceName;
         Logger.system.log("New workspace - start.");
-        let newWorkspaceDialogIsActive = WorkspaceManagementStore.getValue("newWorkspaceDialogIsActive");
-        let activeWorkspace = WorkspaceManagementStore.getValue("activeWorkspace");
+        const newWorkspaceDialogIsActive = WorkspaceManagementStore.getValue("newWorkspaceDialogIsActive");
         function createIt(params, cb) {
             Logger.system.log("createIt", params);
-            let { workspaceName, template } = params;
+            const { workspaceName, template } = params;
             FSBL.Clients.WorkspaceClient.createNewWorkspace(workspaceName, { templateName: template }, (err, response) => {
                 Logger.system.log("createIt createNewWorkspace response", workspaceName, template, response);
                 newWorkspaceName = response.workspaceName;
@@ -149,19 +132,9 @@ Actions = {
         }
         async.waterfall(tasks, Actions.onAsyncComplete);
     },
-    removeWorkspace: function (data, cb = Function.prototype) {
-        let workspaceName = data.name;
-        if (FSBL.Clients.WorkspaceClient.activeworkspaceName === workspaceName) {
-            let dialogParams = {
-                question: "Workspace cannot be deleted while it is in use. Please switch workspaces and try again.",
-                affirmativeResponseLabel: "OK",
-                showNegativeButton: false,
-                showCancelButton: false,
-                hideModalOnClose: data.hideModalOnClose,
-            };
-            return Actions.spawnDialog("yesNo", dialogParams);
-        }
-        let dialogParams = {
+    removeWorkspace: (data, cb = (val) => { }) => {
+        const workspaceName = data.name;
+        const dialogParams = {
             title: "Delete this workspace?",
             question: `Are you sure you want to delete the workspace "${workspaceName}"?`,
             showNegativeButton: false,
@@ -181,22 +154,20 @@ Actions = {
         }
         Actions.spawnDialog("yesNo", dialogParams, onUserInput);
     },
-    saveWorkspace: function (cb) {
-        let activeWorkspace = WorkspaceManagementStore.getValue("activeWorkspace");
+    saveWorkspace: (cb) => {
+        const activeWorkspace = WorkspaceManagementStore.getValue("activeWorkspace");
         FSBL.Clients.WorkspaceClient.saveAs({
             force: true,
             name: activeWorkspace.name,
-        }, (err, response) => {
-            if (cb) {
-                cb();
-            }
+        }, () => {
+            cb === null || cb === void 0 ? void 0 : cb(null);
         });
     },
-    reorderWorkspaceList: function ({ oldIndex, newIndex }) {
+    reorderWorkspaceList: ({ oldIndex, newIndex }) => {
         let workspaces = WorkspaceManagementStore.getValue({
             field: "WorkspaceList",
         });
-        let workspaceToMove = workspaces[oldIndex];
+        const workspaceToMove = workspaces[oldIndex];
         workspaces.splice(oldIndex, 1);
         workspaces.splice(newIndex, 0, workspaceToMove);
         const workspacesWithExpectedStructure = workspaces.map((WSName) => {
@@ -206,37 +177,21 @@ Actions = {
         });
         FSBL.Clients.WorkspaceClient.setWorkspaces({
             workspaces: workspacesWithExpectedStructure,
-        });
+        }, () => { });
         WorkspaceManagementStore.setValue({
             field: "WorkspaceList",
             value: workspaces,
         });
     },
-    renameWorkspace: function ({ oldName, newName }) {
-        function saveIt(workspaceName, done) {
-            FSBL.Clients.WorkspaceClient.rename({
-                oldName: oldName,
-                newName: workspaceName,
-                removeOldWorkspace: true,
-                overWriteExistng: true,
-            }, (err, response) => {
-                done();
-            });
-        }
-        async.waterfall([
-            Actions.checkIfWorkspaceAlreadyExists.bind(null, { value: newName }),
-            (result, callback) => {
-                if (result.workspaceExists) {
-                    callback(null, FSBL.Clients.WorkspaceClient.getWorkspaceName(newName));
-                }
-                else {
-                    callback(null, newName);
-                }
-            },
-            saveIt,
-        ], Actions.onAsyncComplete);
+    renameWorkspace: ({ oldName, newName }) => {
+        FSBL.Clients.WorkspaceClient.rename({
+            oldName: oldName,
+            newName: newName,
+            removeOldWorkspace: true,
+            overwriteExisting: true,
+        });
     },
-    showPreferences: function () {
+    showPreferences: () => {
         FSBL.Clients.LauncherClient.showWindow({
             componentType: "UserPreferences",
         }, {
@@ -245,7 +200,7 @@ Actions = {
             top: "center",
         });
     },
-    saveWorkspaceAs: function () {
+    saveWorkspaceAs: () => {
         function saveIt(workspaceName, callback) {
             FSBL.Clients.WorkspaceClient.saveAs({
                 name: workspaceName,
@@ -264,24 +219,24 @@ Actions = {
             saveIt,
         ], Actions.onAsyncComplete);
     },
-    switchToWorkspace: async function (data) {
+    switchToWorkspace: async function ({ name }) {
+        var _a;
         const prompting = Actions.getIsPromptingUser();
         Logger.system.log("workspaceManagementMenuStore: switchToWorkspace", prompting ? "prompting" : "not-prompting");
         if (prompting)
             return;
         Actions.setIsSwitchingWorkspaces(true);
         Actions.blurWindow();
-        let { name } = data;
-        let activeWorkspace = WorkspaceManagementStore.getValue("activeWorkspace");
-        function switchWorkspace(callback = Function.prototype) {
+        const activeWorkspace = WorkspaceManagementStore.getValue("activeWorkspace");
+        const switchWorkspace = (callback = () => { }) => {
             FSBL.Clients.WorkspaceClient.switchTo({
                 name: name,
             }, () => {
                 Actions.setIsSwitchingWorkspaces(false);
                 callback();
             });
-        }
-        function askAboutReload(callback) {
+        };
+        const askAboutReload = (callback) => {
             Actions.spawnDialog("yesNo", {
                 monitor: "primary",
                 title: "Save your workspace?",
@@ -289,14 +244,14 @@ Actions = {
                 affirmativeResponseLabel: "Save",
                 negativeResponseLabel: "Don't Save",
             }, callback);
-        }
-        let tasks = [];
+        };
         if (await FSBL.Clients.WorkspaceClient.isWorkspaceDirty()) {
+            let tasks = [];
             Actions.setIsPromptingUser(true);
             let firstMethod = Actions.autoSave, secondMethod = null;
             if (PROMPT_ON_SAVE === true) {
                 firstMethod = Actions.askIfUserWantsToSave;
-                if (name === FSBL.Clients.WorkspaceClient.activeWorkspace.name) {
+                if (name === ((_a = FSBL.Clients.WorkspaceClient.activeWorkspace) === null || _a === void 0 ? void 0 : _a.name)) {
                     firstMethod = askAboutReload;
                 }
                 secondMethod = Actions.handleSaveDialogResponse;
@@ -312,13 +267,13 @@ Actions = {
             switchWorkspace();
         }
     },
-    onAsyncComplete(err, result) {
+    onAsyncComplete(err) {
         Logger.system.debug("workspaceManagementMenuStore: onAsyncComplete");
         WorkspaceManagementStore.setValue({
             field: "newWorkspaceDialogIsActive",
             value: false,
         });
-        const errMessage = err && err.message;
+        const errMessage = err === null || err === void 0 ? void 0 : err.message;
         if (errMessage && errMessage !== NEGATIVE && errMessage !== SAVE_DIALOG_CANCEL_ERROR) {
             Logger.system.error(err);
         }
@@ -334,17 +289,18 @@ Actions = {
         }
         FSBL.Clients.DialogManager.open(type, data, responseCallback);
     },
-    spawnSaveAsDialog: function (cb) {
-        function onUserInput(err, response) {
-            Logger.system.log("SpawnWorkspaceInput onUserInput", response);
-            if (err) {
-                err = new Error(err);
+    spawnSaveAsDialog: (cb) => {
+        const onUserInput = (err, response) => {
+            Logger.system.log("SpawnSaveAsDialog onUserInput", response);
+            let callbackError = null;
+            if (typeof err === "string") {
+                callbackError = new Error(err);
             }
             if (cb) {
-                cb(err, response);
+                cb(callbackError || err, response);
             }
-        }
-        let dialogParams = {
+        };
+        const dialogParams = {
             title: "Enter a name for your new workspace.",
             inputLabel: "Enter a name for your new workspace.",
             affirmativeResponseLabel: "Confirm",
@@ -353,18 +309,19 @@ Actions = {
         };
         Actions.spawnDialog("singleInput", dialogParams, onUserInput);
     },
-    spawnWorkspaceInputField: function (cb) {
+    spawnWorkspaceInputField: (cb) => {
         Logger.system.log("SpawnWorkspaceInput - start");
-        function onUserInput(err, response) {
+        const onUserInput = (err, response) => {
             Logger.system.log("SpawnWorkspaceInput onUserInput", response);
-            if (err) {
-                err = new Error(err);
+            let callbackError = null;
+            if (typeof err === "string") {
+                callbackError = new Error(err);
             }
             if (cb) {
-                cb(err, response);
+                cb(callbackError || err, response);
             }
-        }
-        let dialogParams = {
+        };
+        const dialogParams = {
             title: "Enter a name for your new workspace.",
             inputLabel: "Enter a name for your new workspace.",
             affirmativeResponseLabel: "Confirm",
@@ -374,27 +331,25 @@ Actions = {
         Actions.spawnDialog("singleInput", dialogParams, onUserInput);
     },
     askIfUserWantsToSave: async function (callback) {
-        let activeWorkspace = WorkspaceManagementStore.getValue("activeWorkspace");
+        const activeWorkspace = WorkspaceManagementStore.getValue("activeWorkspace");
         if (await FSBL.Clients.WorkspaceClient.isWorkspaceDirty()) {
             Logger.system.log("NewWorkspace.spawnDialog start.");
-            let dialogParams = {
+            const dialogParams = {
                 monitor: "primary",
                 title: "Save your workspace?",
                 question: `\"${activeWorkspace.name}\" has unsaved changes. Would you like to save?`,
                 affirmativeResponseLabel: "Save",
                 negativeResponseLabel: "Don't Save",
             };
-            function waitForUserInput() {
-                return new Promise((resolve) => {
-                    function onUserInput(err, response) {
-                        Logger.system.log("Spawn Dialog callback.");
-                        if (callback)
-                            callback(null, response);
-                        resolve(response);
-                    }
-                    Actions.spawnDialog("yesNo", dialogParams, onUserInput);
-                });
-            }
+            const waitForUserInput = () => new Promise((resolve) => {
+                const onUserInput = (err, response) => {
+                    Logger.system.log("Spawn Dialog callback.");
+                    if (callback)
+                        callback(null, response);
+                    resolve(response);
+                };
+                Actions.spawnDialog("yesNo", dialogParams, onUserInput);
+            });
             return await waitForUserInput();
         }
         else {
@@ -408,7 +363,7 @@ Actions = {
             Actions.saveWorkspace(callback);
         }
         else if (response.choice === "negative") {
-            callback();
+            callback(null);
         }
         else {
             callback(new Error(SAVE_DIALOG_CANCEL_ERROR));
@@ -424,7 +379,7 @@ Actions = {
                 showNegativeButton: false,
                 showCancelButton: false,
             };
-            Actions.spawnDialog("yesNo", dialogParams, Function.prototype);
+            Actions.spawnDialog("yesNo", dialogParams, () => { });
             return callback(new Error("Invalid workspace name."));
         }
         else if (response.choice === "cancel") {
@@ -433,21 +388,21 @@ Actions = {
         callback(null, response);
     },
     askAboutOverwrite(params, callback) {
-        let { workspaceExists, workspaceName } = params;
-        let dialogParams = {
+        const { workspaceExists, workspaceName } = params;
+        const dialogParams = {
             title: "Overwrite Workspace?",
             question: `This will overwrite the saved data for  "${workspaceName}". Would you like to proceed?`,
             affirmativeResponseLabel: "Overwrite",
             showNegativeButton: false,
         };
-        function onUserInput(err, response) {
+        const onUserInput = (err, response) => {
             if (response.choice === "affirmative") {
                 callback(null, workspaceName);
             }
             else {
                 callback(new Error(NEGATIVE));
             }
-        }
+        };
         if (workspaceExists) {
             Actions.spawnDialog("yesNo", dialogParams, onUserInput);
         }
@@ -479,8 +434,9 @@ Actions = {
         }
     },
     checkIfWorkspaceAlreadyExists(response, callback) {
-        let workspaceName = response.value;
-        let workspaceExists = FSBL.Clients.WorkspaceClient.workspaces.some((workspace) => workspace === workspaceName);
+        const workspaceName = response.value;
+        const camelCaseWorkspaceName = Util.camelCase(workspaceName);
+        const workspaceExists = FSBL.Clients.WorkspaceClient.workspaces.some((workspace) => Util.camelCase(workspace) === camelCaseWorkspaceName);
         callback(null, {
             workspaceExists,
             workspaceName,
@@ -512,12 +468,11 @@ function getPreferences(done) {
         field: "finsemble.preferences.workspaceService.promptUserOnDirtyWorkspace",
     }, (err, data) => {
         let prompt = data;
-        PROMPT_ON_SAVE = prompt === null ? PROMPT_ON_SAVE : prompt;
+        PROMPT_ON_SAVE = prompt === null || prompt === undefined ? PROMPT_ON_SAVE : prompt;
         done();
     });
 }
 function initialize(cb) {
-    WindowClient = FSBL.Clients.WindowClient;
     StoreClient = FSBL.Clients.DistributedStoreClient;
     Logger = FSBL.Clients.Logger;
     async.parallel([createGlobalStore, createLocalStore, getPreferences], () => {
@@ -544,7 +499,7 @@ class StoreManager {
         });
     }
     addInitializedListener(cb) {
-        if (this.initialized)
+        if (this.initialized && this.store !== null)
             return cb(this.store);
         this.callbacks.push(cb);
     }
@@ -553,10 +508,5 @@ class StoreManager {
     }
 }
 const storeManager = new StoreManager();
-export { storeManager };
-export { WorkspaceManagementGlobalStore as GlobalStore };
-export { initialize };
-export { WorkspaceManagementStore as Store };
-export { Actions };
-export { getStore };
+export { storeManager, WorkspaceManagementGlobalStore as GlobalStore, initialize, WorkspaceManagementStore as Store, Actions, getStore, };
 //# sourceMappingURL=workspaceManagementMenuStore.js.map