@finos/legend-application-studio 18.1.0 → 19.0.0

package/lib/stores/EditorStore.js

@@ -16,7 +16,7 @@
 import { action, computed, flow, flowResult, makeObservable, observable, } from 'mobx';
 import { ClassEditorState } from './editor-state/element-editor-state/ClassEditorState.js';
 import { ExplorerTreeState } from './ExplorerTreeState.js';
-import { ACTIVITY_MODE, AUX_PANEL_MODE, GRAPH_EDITOR_MODE, EDITOR_MODE, LEGEND_STUDIO_HOTKEY, LEGEND_STUDIO_HOTKEY_MAP, } from './EditorConfig.js';
+import { ACTIVITY_MODE, AUX_PANEL_MODE, GRAPH_EDITOR_MODE, EDITOR_MODE, } from './EditorConfig.js';
 import { ElementEditorState } from './editor-state/element-editor-state/ElementEditorState.js';
 import { MappingEditorState } from './editor-state/element-editor-state/mapping/MappingEditorState.js';
 import { EditorGraphState, GraphBuilderStatus, } from './EditorGraphState.js';
@@ -28,7 +28,7 @@ import { WorkspaceReviewState } from './sidebar-state/WorkspaceReviewState.js';
 import { LocalChangesState } from './sidebar-state/LocalChangesState.js';
 import { WorkspaceWorkflowManagerState } from './sidebar-state/WorkflowManagerState.js';
 import { GrammarTextEditorState } from './editor-state/GrammarTextEditorState.js';
-import { LogEvent, addUniqueEntry, isNonNullable, assertErrorThrown, guaranteeType, guaranteeNonNullable, UnsupportedOperationError, assertNonNullable, assertTrue, ActionState, filterByType, } from '@finos/legend-shared';
+import { LogEvent, isNonNullable, assertErrorThrown, guaranteeType, guaranteeNonNullable, UnsupportedOperationError, assertNonNullable, assertTrue, ActionState, filterByType, AssertionError, } from '@finos/legend-shared';
 import { UMLEditorState } from './editor-state/element-editor-state/UMLEditorState.js';
 import { ServiceEditorState } from './editor-state/element-editor-state/service/ServiceEditorState.js';
 import { EditorSDLCState } from './EditorSDLCState.js';
@@ -47,9 +47,9 @@ import { GenerationSpecificationEditorState } from './editor-state/GenerationSpe
 import { UnsupportedElementEditorState } from './editor-state/UnsupportedElementEditorState.js';
 import { FileGenerationViewerState } from './editor-state/FileGenerationViewerState.js';
 import { DevToolState } from './aux-panel-state/DevToolState.js';
-import { generateSetupRoute, generateViewProjectRoute, } from './LegendStudioRouter.js';
-import { HotkeyConfiguration, NonBlockingDialogState, PanelDisplayState, } from '@finos/legend-art';
-import { ProjectConfiguration, } from '@finos/legend-server-sdlc';
+import { generateEditorRoute, generateSetupRoute, generateViewProjectRoute, } from './LegendStudioRouter.js';
+import { NonBlockingDialogState, PanelDisplayState } from '@finos/legend-art';
+import { ProjectConfiguration, WorkspaceType, } from '@finos/legend-server-sdlc';
 import { GRAPH_MANAGER_EVENT, PrimitiveType, Class, Enumeration, Profile, Association, ConcreteFunctionDefinition, Measure, Database, FlatData, Mapping, Service, PackageableRuntime, PackageableConnection, FileGenerationSpecification, GenerationSpecification, Package, DataElement, isElementReadOnly, } from '@finos/legend-graph';
 import { ActionAlertActionType, ActionAlertType, APPLICATION_EVENT, TAB_SIZE, } from '@finos/legend-application';
 import { LEGEND_STUDIO_APP_EVENT } from './LegendStudioAppEvent.js';
@@ -59,6 +59,7 @@ import { graph_addElement, graph_deleteElement, graph_deleteOwnElement, graph_re
 import { PACKAGEABLE_ELEMENT_TYPE } from './shared/ModelClassifierUtils.js';
 import { GlobalTestRunnerState } from './sidebar-state/testable/GlobalTestRunnerState.js';
 import { EmbeddedQueryBuilderState } from './EmbeddedQueryBuilderState.js';
+import { LEGEND_STUDIO_COMMAND_KEY } from './LegendStudioCommand.js';
 export class EditorExtensionState {
     /**
      * This helps to better type-check for this empty abtract type
@@ -72,24 +73,12 @@ export class EditorStore {
     depotServerClient;
     pluginManager;
     editorMode;
-    setEditorMode(val) {
-        this.editorMode = val;
-    }
     // NOTE: once we clear up the editor store to make modes more separated
     // we should remove these sets of functions. They are basically hacks to
     // ensure hiding parts of the UI based on the editing mode.
     // Instead, we will gradually move these `boolean` flags into `EditorMode`
     // See https://github.com/finos/legend-studio/issues/317
     mode = EDITOR_MODE.STANDARD;
-    setMode(val) {
-        this.mode = val;
-    }
-    get isInViewerMode() {
-        return this.mode === EDITOR_MODE.VIEWER;
-    }
-    get isInConflictResolutionMode() {
-        return this.mode === EDITOR_MODE.CONFLICT_RESOLUTION;
-    }
     editorExtensionStates = [];
     explorerTreeState;
     sdlcState;
@@ -109,7 +98,7 @@ export class EditorStore {
     devToolState;
     embeddedQueryBuilderState;
     newElementState;
-    _isDisposed = false;
+    initialEntityPath;
     initState = ActionState.create();
     graphEditMode = GRAPH_EDITOR_MODE.FORM;
     // Aux Panel
@@ -126,11 +115,7 @@ export class EditorStore {
         default: 300,
         snap: 150,
     });
-    // Hot keys
-    blockGlobalHotkeys = false;
-    defaultHotkeys = [];
-    hotkeys = [];
-    // Tabs
+    // Editor Tabs
     currentEditorState;
     openedEditorStates = [];
     /**
@@ -139,22 +124,15 @@ export class EditorStore {
      */
     elementGenerationStates = [];
     searchElementCommandState = new NonBlockingDialogState();
-    ignoreNavigationBlocking = false;
-    isDevToolEnabled = true;
     constructor(applicationStore, sdlcServerClient, depotServerClient, graphManagerState) {
         makeObservable(this, {
             editorMode: observable,
             mode: observable,
-            _isDisposed: observable,
             graphEditMode: observable,
             activeAuxPanelMode: observable,
             activeActivity: observable,
-            blockGlobalHotkeys: observable,
-            hotkeys: observable,
             currentEditorState: observable,
             openedEditorStates: observable,
-            ignoreNavigationBlocking: observable,
-            isDevToolEnabled: observable,
             isInViewerMode: computed,
             isInConflictResolutionMode: computed,
             isInitialized: computed,
@@ -167,17 +145,9 @@ export class EditorStore {
             graphManagerState: false,
             setEditorMode: action,
             setMode: action,
-            setDevTool: action,
-            setHotkeys: action,
-            addHotKey: action,
-            resetHotkeys: action,
-            setBlockGlobalHotkeys: action,
             setCurrentEditorState: action,
             setActiveAuxPanelMode: action,
-            setIgnoreNavigationBlocking: action,
             refreshCurrentEntityDiffEditorState: action,
-            setBlockingAlert: action,
-            setActionAlertInfo: action,
             cleanUp: action,
             reset: action,
             setGraphEditMode: action,
@@ -234,32 +204,6 @@ export class EditorStore {
             .flatMap((plugin) => plugin.getExtraEditorExtensionStateCreators?.() ?? [])
             .map((creator) => creator(this))
             .filter(isNonNullable);
-        // hotkeys
-        this.defaultHotkeys = [
-            // actions that need blocking
-            new HotkeyConfiguration(LEGEND_STUDIO_HOTKEY.COMPILE, [LEGEND_STUDIO_HOTKEY_MAP.COMPILE], this.createGlobalHotKeyAction(() => {
-                flowResult(this.graphState.globalCompileInFormMode()).catch(applicationStore.alertUnhandledError);
-            })),
-            new HotkeyConfiguration(LEGEND_STUDIO_HOTKEY.GENERATE, [LEGEND_STUDIO_HOTKEY_MAP.GENERATE], this.createGlobalHotKeyAction(() => {
-                flowResult(this.graphState.graphGenerationState.globalGenerate()).catch(applicationStore.alertUnhandledError);
-            })),
-            new HotkeyConfiguration(LEGEND_STUDIO_HOTKEY.CREATE_ELEMENT, [LEGEND_STUDIO_HOTKEY_MAP.CREATE_ELEMENT], this.createGlobalHotKeyAction(() => this.newElementState.openModal())),
-            new HotkeyConfiguration(LEGEND_STUDIO_HOTKEY.OPEN_ELEMENT, [LEGEND_STUDIO_HOTKEY_MAP.OPEN_ELEMENT], this.createGlobalHotKeyAction(() => this.searchElementCommandState.open())),
-            new HotkeyConfiguration(LEGEND_STUDIO_HOTKEY.TOGGLE_TEXT_MODE, [LEGEND_STUDIO_HOTKEY_MAP.TOGGLE_TEXT_MODE], this.createGlobalHotKeyAction(() => {
-                flowResult(this.toggleTextMode()).catch(applicationStore.alertUnhandledError);
-            })),
-            new HotkeyConfiguration(LEGEND_STUDIO_HOTKEY.TOGGLE_MODEL_LOADER, [LEGEND_STUDIO_HOTKEY_MAP.TOGGLE_MODEL_LOADER], this.createGlobalHotKeyAction(() => this.openState(this.modelImporterState))),
-            new HotkeyConfiguration(LEGEND_STUDIO_HOTKEY.SYNC_WITH_WORKSPACE, [LEGEND_STUDIO_HOTKEY_MAP.SYNC_WITH_WORKSPACE], this.createGlobalHotKeyAction(() => {
-                flowResult(this.localChangesState.pushLocalChanges()).catch(applicationStore.alertUnhandledError);
-            })),
-            // simple actions (no blocking is needed)
-            new HotkeyConfiguration(LEGEND_STUDIO_HOTKEY.TOGGLE_AUX_PANEL, [LEGEND_STUDIO_HOTKEY_MAP.TOGGLE_AUX_PANEL], this.createGlobalHotKeyAction(() => this.auxPanelDisplayState.toggle())),
-            new HotkeyConfiguration(LEGEND_STUDIO_HOTKEY.TOGGLE_SIDEBAR_EXPLORER, [LEGEND_STUDIO_HOTKEY_MAP.TOGGLE_SIDEBAR_EXPLORER], this.createGlobalHotKeyAction(() => this.setActiveActivity(ACTIVITY_MODE.EXPLORER))),
-            new HotkeyConfiguration(LEGEND_STUDIO_HOTKEY.TOGGLE_SIDEBAR_CHANGES, [LEGEND_STUDIO_HOTKEY_MAP.TOGGLE_SIDEBAR_CHANGES], this.createGlobalHotKeyAction(() => this.setActiveActivity(ACTIVITY_MODE.LOCAL_CHANGES))),
-            new HotkeyConfiguration(LEGEND_STUDIO_HOTKEY.TOGGLE_SIDEBAR_WORKSPACE_REVIEW, [LEGEND_STUDIO_HOTKEY_MAP.TOGGLE_SIDEBAR_WORKSPACE_REVIEW], this.createGlobalHotKeyAction(() => this.setActiveActivity(ACTIVITY_MODE.WORKSPACE_REVIEW))),
-            new HotkeyConfiguration(LEGEND_STUDIO_HOTKEY.TOGGLE_SIDEBAR_WORKSPACE_UPDATER, [LEGEND_STUDIO_HOTKEY_MAP.TOGGLE_SIDEBAR_WORKSPACE_UPDATER], this.createGlobalHotKeyAction(() => this.setActiveActivity(ACTIVITY_MODE.WORKSPACE_UPDATER))),
-        ];
-        this.hotkeys = this.defaultHotkeys;
     }
     get isInitialized() {
         return (Boolean(this.sdlcState.currentProject &&
@@ -273,64 +217,154 @@ export class EditorStore {
     get isInFormMode() {
         return this.graphEditMode === GRAPH_EDITOR_MODE.FORM;
     }
-    setHotkeys(val) {
-        this.hotkeys = val;
-    }
-    addHotKey(val) {
-        addUniqueEntry(this.hotkeys, val);
-    }
-    resetHotkeys() {
-        this.hotkeys = this.defaultHotkeys;
-    }
-    setBlockGlobalHotkeys(val) {
-        this.blockGlobalHotkeys = val;
-    }
-    setDevTool(val) {
-        this.isDevToolEnabled = val;
-    }
-    setCurrentEditorState(val) {
-        this.currentEditorState = val;
-    }
-    setActiveAuxPanelMode(val) {
-        this.activeAuxPanelMode = val;
+    get isInViewerMode() {
+        return this.mode === EDITOR_MODE.VIEWER;
     }
-    setIgnoreNavigationBlocking(val) {
-        this.ignoreNavigationBlocking = val;
+    get isInConflictResolutionMode() {
+        return this.mode === EDITOR_MODE.CONFLICT_RESOLUTION;
     }
-    refreshCurrentEntityDiffEditorState() {
-        if (this.currentEditorState instanceof EntityDiffEditorState) {
-            this.currentEditorState.refresh();
-        }
+    /**
+     * TODO?: we should really think of how we could simplify the trigger condition below
+     * after we refactor editor modes
+     *
+     * See https://github.com/finos/legend-studio/issues/317
+     */
+    createEditorCommandTrigger(additionalChecker) {
+        return () => 
+        // we don't want to leak any hotkeys when we have embedded query builder open
+        // TODO?: we probably should come up with a more generic mechanism for this
+        !this.embeddedQueryBuilderState.queryBuilderState &&
+            (!additionalChecker || additionalChecker());
     }
-    setBlockingAlert(alertInfo) {
-        if (this._isDisposed) {
-            return;
-        }
-        this.setBlockGlobalHotkeys(Boolean(alertInfo)); // block global hotkeys if alert is shown
-        this.applicationStore.setBlockingAlert(alertInfo);
+    setEditorMode(val) {
+        this.editorMode = val;
     }
-    setActionAlertInfo(alertInfo) {
-        if (this._isDisposed) {
-            return;
-        }
-        this.applicationStore.setActionAlertInfo(alertInfo);
+    setMode(val) {
+        this.mode = val;
     }
     cleanUp() {
         // dismiss all the alerts as these are parts of application, if we don't do this, we might
         // end up blocking other parts of the app
         // e.g. trying going to an unknown workspace, we will be redirected to the home page
         // but the blocking alert for not-found workspace will still block the app
-        this.setBlockingAlert(undefined);
-        this.setActionAlertInfo(undefined);
+        this.applicationStore.setBlockingAlert(undefined);
+        this.applicationStore.setActionAlertInfo(undefined);
         // stop change detection to avoid memory-leak
         this.changeDetectionState.stop();
-        this._isDisposed = true;
+    }
+    registerCommands() {
+        this.applicationStore.commandCenter.registerCommand({
+            key: LEGEND_STUDIO_COMMAND_KEY.COMPILE,
+            trigger: this.createEditorCommandTrigger(() => this.isInitialized &&
+                (!this.isInConflictResolutionMode ||
+                    this.conflictResolutionState.hasResolvedAllConflicts)),
+            action: () => {
+                if (this.isInFormMode) {
+                    flowResult(this.graphState.globalCompileInFormMode()).catch(this.applicationStore.alertUnhandledError);
+                }
+                else if (this.isInGrammarTextMode) {
+                    flowResult(this.graphState.globalCompileInTextMode()).catch(this.applicationStore.alertUnhandledError);
+                }
+            },
+        });
+        this.applicationStore.commandCenter.registerCommand({
+            key: LEGEND_STUDIO_COMMAND_KEY.GENERATE,
+            trigger: this.createEditorCommandTrigger(() => this.isInitialized &&
+                (!this.isInConflictResolutionMode ||
+                    this.conflictResolutionState.hasResolvedAllConflicts)),
+            action: () => {
+                flowResult(this.graphState.graphGenerationState.globalGenerate()).catch(this.applicationStore.alertUnhandledError);
+            },
+        });
+        this.applicationStore.commandCenter.registerCommand({
+            key: LEGEND_STUDIO_COMMAND_KEY.CREATE_ELEMENT,
+            trigger: this.createEditorCommandTrigger(() => !this.isInViewerMode),
+            action: () => this.newElementState.openModal(),
+        });
+        this.applicationStore.commandCenter.registerCommand({
+            key: LEGEND_STUDIO_COMMAND_KEY.SEARCH_ELEMENT,
+            trigger: this.createEditorCommandTrigger(),
+            action: () => this.searchElementCommandState.open(),
+        });
+        this.applicationStore.commandCenter.registerCommand({
+            key: LEGEND_STUDIO_COMMAND_KEY.TOGGLE_TEXT_MODE,
+            trigger: this.createEditorCommandTrigger(() => this.isInitialized &&
+                (!this.isInConflictResolutionMode ||
+                    this.conflictResolutionState.hasResolvedAllConflicts)),
+            action: () => {
+                flowResult(this.toggleTextMode()).catch(this.applicationStore.alertUnhandledError);
+            },
+        });
+        this.applicationStore.commandCenter.registerCommand({
+            key: LEGEND_STUDIO_COMMAND_KEY.TOGGLE_MODEL_LOADER,
+            trigger: this.createEditorCommandTrigger(() => !this.isInViewerMode),
+            action: () => this.openState(this.modelImporterState),
+        });
+        this.applicationStore.commandCenter.registerCommand({
+            key: LEGEND_STUDIO_COMMAND_KEY.SYNC_WITH_WORKSPACE,
+            trigger: this.createEditorCommandTrigger(() => !this.isInViewerMode),
+            action: () => {
+                flowResult(this.localChangesState.pushLocalChanges()).catch(this.applicationStore.alertUnhandledError);
+            },
+        });
+        this.applicationStore.commandCenter.registerCommand({
+            key: LEGEND_STUDIO_COMMAND_KEY.TOGGLE_AUX_PANEL,
+            trigger: this.createEditorCommandTrigger(() => !this.isInViewerMode),
+            action: () => this.auxPanelDisplayState.toggle(),
+        });
+        this.applicationStore.commandCenter.registerCommand({
+            key: LEGEND_STUDIO_COMMAND_KEY.TOGGLE_SIDEBAR_EXPLORER,
+            trigger: this.createEditorCommandTrigger(),
+            action: () => this.setActiveActivity(ACTIVITY_MODE.EXPLORER),
+        });
+        this.applicationStore.commandCenter.registerCommand({
+            key: LEGEND_STUDIO_COMMAND_KEY.TOGGLE_SIDEBAR_LOCAL_CHANGES,
+            trigger: this.createEditorCommandTrigger(() => !this.isInViewerMode),
+            action: () => this.setActiveActivity(ACTIVITY_MODE.LOCAL_CHANGES),
+        });
+        this.applicationStore.commandCenter.registerCommand({
+            key: LEGEND_STUDIO_COMMAND_KEY.TOGGLE_SIDEBAR_WORKSPACE_REVIEW,
+            trigger: this.createEditorCommandTrigger(() => !this.isInViewerMode),
+            action: () => this.setActiveActivity(ACTIVITY_MODE.WORKSPACE_REVIEW),
+        });
+        this.applicationStore.commandCenter.registerCommand({
+            key: LEGEND_STUDIO_COMMAND_KEY.TOGGLE_SIDEBAR_WORKSPACE_UPDATER,
+            trigger: this.createEditorCommandTrigger(() => !this.isInViewerMode),
+            action: () => this.setActiveActivity(ACTIVITY_MODE.WORKSPACE_UPDATER),
+        });
+    }
+    deregisterCommands() {
+        [
+            LEGEND_STUDIO_COMMAND_KEY.SYNC_WITH_WORKSPACE,
+            LEGEND_STUDIO_COMMAND_KEY.CREATE_ELEMENT,
+            LEGEND_STUDIO_COMMAND_KEY.SEARCH_ELEMENT,
+            LEGEND_STUDIO_COMMAND_KEY.TOGGLE_TEXT_MODE,
+            LEGEND_STUDIO_COMMAND_KEY.GENERATE,
+            LEGEND_STUDIO_COMMAND_KEY.COMPILE,
+            LEGEND_STUDIO_COMMAND_KEY.TOGGLE_AUX_PANEL,
+            LEGEND_STUDIO_COMMAND_KEY.TOGGLE_MODEL_LOADER,
+            LEGEND_STUDIO_COMMAND_KEY.TOGGLE_SIDEBAR_EXPLORER,
+            LEGEND_STUDIO_COMMAND_KEY.TOGGLE_SIDEBAR_LOCAL_CHANGES,
+            LEGEND_STUDIO_COMMAND_KEY.TOGGLE_SIDEBAR_WORKSPACE_REVIEW,
+            LEGEND_STUDIO_COMMAND_KEY.TOGGLE_SIDEBAR_WORKSPACE_UPDATER,
+        ].forEach((key) => this.applicationStore.commandCenter.deregisterCommand(key));
     }
     reset() {
         this.closeAllEditorTabs();
         this.projectConfigurationEditorState = new ProjectConfigurationEditorState(this, this.sdlcState);
         this.explorerTreeState = new ExplorerTreeState(this);
     }
+    internalizeEntityPath(params) {
+        const { projectId, entityPath } = params;
+        const workspaceType = params.groupWorkspaceId
+            ? WorkspaceType.GROUP
+            : WorkspaceType.USER;
+        const workspaceId = guaranteeNonNullable(params.groupWorkspaceId ?? params.workspaceId, `Workspace/group workspace ID is not provided`);
+        if (entityPath) {
+            this.initialEntityPath = entityPath;
+            this.applicationStore.navigator.updateCurrentLocation(generateEditorRoute(projectId, workspaceId, workspaceType));
+        }
+    }
     /**
      * This is the entry of the app logic where the initialization of editor states happens
      * Here, we ensure the order of calls after checking existence of current project and workspace
@@ -348,7 +382,6 @@ export class EditorStore {
             if (process.env.NODE_ENV === 'development') {
                 this.applicationStore.log.info(LogEvent.create(APPLICATION_EVENT.DEVELOPMENT_ISSUE), `Fast-refreshing the app - undoing cleanUp() and preventing initialize() recall in editor store...`);
                 this.changeDetectionState.start();
-                this._isDisposed = false;
                 return;
             }
             this.applicationStore.notifyIllegalState('Editor store is re-initialized');
@@ -369,12 +402,10 @@ export class EditorStore {
             // instead, we give them the option to:
             // - reload the page (in case they later gain access)
             // - back to the setup page
-            this.setActionAlertInfo({
+            this.applicationStore.setActionAlertInfo({
                 message: `Project not found or inaccessible`,
                 prompt: 'Please check that the project exists and request access to it',
                 type: ActionAlertType.STANDARD,
-                onEnter: () => this.setBlockGlobalHotkeys(true),
-                onClose: () => this.setBlockGlobalHotkeys(false),
                 actions: [
                     {
                         label: 'Reload application',
@@ -423,12 +454,10 @@ export class EditorStore {
                     this.applicationStore.notifyError(error);
                 }
             };
-            this.setActionAlertInfo({
+            this.applicationStore.setActionAlertInfo({
                 message: 'Workspace not found',
                 prompt: `Please note that you can check out the project in viewer mode. Workspace is only required if you need to work on the project.`,
                 type: ActionAlertType.STANDARD,
-                onEnter: () => this.setBlockGlobalHotkeys(true),
-                onClose: () => this.setBlockGlobalHotkeys(false),
                 actions: [
                     {
                         label: 'View project',
@@ -500,12 +529,10 @@ export class EditorStore {
         ]);
     }
     *initConflictResolutionMode() {
-        this.setActionAlertInfo({
+        this.applicationStore.setActionAlertInfo({
             message: 'Failed to update workspace.',
             prompt: 'You can discard all of your changes or review them, resolve all merge conflicts and fix any potential compilation issues as well as test failures',
             type: ActionAlertType.CAUTION,
-            onEnter: () => this.setBlockGlobalHotkeys(true),
-            onClose: () => this.setBlockGlobalHotkeys(false),
             actions: [
                 {
                     label: 'Discard your changes',
@@ -574,6 +601,19 @@ export class EditorStore {
             // build explorer tree
             this.explorerTreeState.buildImmutableModelTrees();
             this.explorerTreeState.build();
+            // open element if provided an element path
+            if (this.graphManagerState.graphBuildState.hasSucceeded &&
+                this.explorerTreeState.buildState.hasCompleted &&
+                this.initialEntityPath) {
+                try {
+                    this.openElement(this.graphManagerState.graph.getElement(this.initialEntityPath));
+                }
+                catch {
+                    const elementPath = this.initialEntityPath;
+                    this.initialEntityPath = undefined;
+                    throw new AssertionError(`Can't find element with path '${elementPath}'`);
+                }
+            }
             // ======= (RE)START CHANGE DETECTION =======
             this.changeDetectionState.stop();
             yield flowResult(this.changeDetectionState.observeGraph());
@@ -601,26 +641,15 @@ export class EditorStore {
             this.initState.setMessage(undefined);
         }
     }
+    setCurrentEditorState(val) {
+        this.currentEditorState = val;
+    }
     getCurrentEditorState(clazz) {
         return guaranteeType(this.currentEditorState, clazz, `Current editor state is not of the specified type (this is likely caused by calling this method at the wrong place)`);
     }
     getEditorExtensionState(clazz) {
         return guaranteeNonNullable(this.editorExtensionStates.find(filterByType(clazz)), `Can't find extension editor state of the specified type: no built extension editor state available from plugins`);
     }
-    setGraphEditMode(graphEditor) {
-        this.graphEditMode = graphEditor;
-        this.graphState.clearCompilationError();
-    }
-    setActiveActivity(activity, options) {
-        if (!this.sideBarDisplayState.isOpen) {
-            this.sideBarDisplayState.open();
-        }
-        else if (activity === this.activeActivity &&
-            !options?.keepShowingIfMatchedCurrent) {
-            this.sideBarDisplayState.close();
-        }
-        this.activeActivity = activity;
-    }
     closeState(editorState) {
         const elementIndex = this.openedEditorStates.findIndex((e) => e === editorState);
         assertTrue(elementIndex !== -1, `Can't close a tab which is not opened`);
@@ -640,7 +669,7 @@ export class EditorStore {
     }
     closeAllOtherStates(editorState) {
         assertNonNullable(this.openedEditorStates.find((e) => e === editorState), 'Editor tab should be currently opened');
-        this.currentEditorState = editorState;
+        this.setCurrentEditorState(editorState);
         this.openedEditorStates = [editorState];
         this.explorerTreeState.reprocess();
     }
@@ -672,6 +701,11 @@ export class EditorStore {
         }
         this.explorerTreeState.reprocess();
     }
+    refreshCurrentEntityDiffEditorState() {
+        if (this.currentEditorState instanceof EntityDiffEditorState) {
+            this.currentEditorState.refresh();
+        }
+    }
     openEntityDiff(entityDiffEditorState) {
         const existingEditorState = this.openedEditorStates.find((editorState) => editorState instanceof EntityDiffViewState &&
             editorState.fromEntityPath === entityDiffEditorState.fromEntityPath &&
@@ -704,6 +738,23 @@ export class EditorStore {
         }
         this.setCurrentEditorState(editorState);
     }
+    setGraphEditMode(graphEditor) {
+        this.graphEditMode = graphEditor;
+        this.graphState.clearCompilationError();
+    }
+    setActiveActivity(activity, options) {
+        if (!this.sideBarDisplayState.isOpen) {
+            this.sideBarDisplayState.open();
+        }
+        else if (activity === this.activeActivity &&
+            !options?.keepShowingIfMatchedCurrent) {
+            this.sideBarDisplayState.close();
+        }
+        this.activeActivity = activity;
+    }
+    setActiveAuxPanelMode(val) {
+        this.activeAuxPanelMode = val;
+    }
     createElementState(element) {
         if (element instanceof PrimitiveType) {
             throw new UnsupportedOperationError(`Can't create element state for primitive type`);
@@ -881,20 +932,6 @@ export class EditorStore {
         }
         this.setCurrentEditorState(generatedFileState);
     }
-    createGlobalHotKeyAction = (handler, preventDefault = true) => (event) => {
-        if (preventDefault) {
-            event?.preventDefault();
-        }
-        // TODO: maybe we should come up with a better way to block global hot keys, this seems highly restrictive.
-        const isResolvingConflicts = this.isInConflictResolutionMode &&
-            !this.conflictResolutionState.hasResolvedAllConflicts;
-        if ((this.isInitialized &&
-            !isResolvingConflicts &&
-            !this.blockGlobalHotkeys) ||
-            this.isInViewerMode) {
-            handler(event);
-        }
-    };
     closeAllEditorTabs() {
         this.setCurrentEditorState(undefined);
         this.openedEditorStates = [];
@@ -904,7 +941,7 @@ export class EditorStore {
             if (this.graphState.checkIfApplicationUpdateOperationIsRunning()) {
                 return;
             }
-            this.setBlockingAlert({
+            this.applicationStore.setBlockingAlert({
                 message: 'Switching to text mode...',
                 showLoading: true,
             });
@@ -915,10 +952,10 @@ export class EditorStore {
             catch (error) {
                 assertErrorThrown(error);
                 this.applicationStore.notifyWarning(`Can't enter text mode: transformation to grammar text failed. Error: ${error.message}`);
-                this.setBlockingAlert(undefined);
+                this.applicationStore.setBlockingAlert(undefined);
                 return;
             }
-            this.setBlockingAlert(undefined);
+            this.applicationStore.setBlockingAlert(undefined);
             this.setGraphEditMode(GRAPH_EDITOR_MODE.GRAMMAR_TEXT);
             // navigate to the currently opened element immediately after entering text mode editor
             if (this.currentEditorState instanceof ElementEditorState) {