@finos/legend-application-studio 18.1.0 → 19.1.0

package/src/stores/EditorStore.ts

@@ -29,8 +29,6 @@ import {
   AUX_PANEL_MODE,
   GRAPH_EDITOR_MODE,
   EDITOR_MODE,
-  LEGEND_STUDIO_HOTKEY,
-  LEGEND_STUDIO_HOTKEY_MAP,
 } from './EditorConfig.js';
 import { ElementEditorState } from './editor-state/element-editor-state/ElementEditorState.js';
 import { MappingEditorState } from './editor-state/element-editor-state/mapping/MappingEditorState.js';
@@ -52,7 +50,6 @@ import {
   type GeneratorFn,
   type PlainObject,
   LogEvent,
-  addUniqueEntry,
   isNonNullable,
   assertErrorThrown,
   guaranteeType,
@@ -62,6 +59,7 @@ import {
   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';
@@ -85,20 +83,18 @@ import type { GenerationFile } from './shared/FileGenerationTreeUtils.js';
 import type { ElementFileGenerationState } from './editor-state/element-editor-state/ElementFileGenerationState.js';
 import { DevToolState } from './aux-panel-state/DevToolState.js';
 import {
+  generateEditorRoute,
   generateSetupRoute,
   generateViewProjectRoute,
+  type WorkspaceEditorPathParams,
 } from './LegendStudioRouter.js';
-import {
-  HotkeyConfiguration,
-  NonBlockingDialogState,
-  PanelDisplayState,
-} from '@finos/legend-art';
+import { NonBlockingDialogState, PanelDisplayState } from '@finos/legend-art';
 import type { DSL_LegendStudioApplicationPlugin_Extension } from './LegendStudioApplicationPlugin.js';
 import type { Entity } from '@finos/legend-storage';
 import {
   ProjectConfiguration,
+  WorkspaceType,
   type SDLCServerClient,
-  type WorkspaceType,
 } from '@finos/legend-server-sdlc';
 import {
   type PackageableElement,
@@ -126,8 +122,7 @@ import {
 import type { DepotServerClient } from '@finos/legend-server-depot';
 import type { LegendStudioPluginManager } from '../application/LegendStudioPluginManager.js';
 import {
-  type ActionAlertInfo,
-  type BlockingAlertInfo,
+  type CommandRegistrar,
   ActionAlertActionType,
   ActionAlertType,
   APPLICATION_EVENT,
@@ -147,6 +142,7 @@ import { PACKAGEABLE_ELEMENT_TYPE } from './shared/ModelClassifierUtils.js';
 import { GlobalTestRunnerState } from './sidebar-state/testable/GlobalTestRunnerState.js';
 import type { LegendStudioApplicationStore } from './LegendStudioBaseStore.js';
 import { EmbeddedQueryBuilderState } from './EmbeddedQueryBuilderState.js';
+import { LEGEND_STUDIO_COMMAND_KEY } from './LegendStudioCommand.js';
 
 export abstract class EditorExtensionState {
   /**
@@ -156,31 +152,19 @@ export abstract class EditorExtensionState {
   private readonly _$nominalTypeBrand!: 'EditorExtensionState';
 }
 
-export class EditorStore {
+export class EditorStore implements CommandRegistrar {
   applicationStore: LegendStudioApplicationStore;
   sdlcServerClient: SDLCServerClient;
   depotServerClient: DepotServerClient;
   pluginManager: LegendStudioPluginManager;
 
   editorMode: EditorMode;
-  setEditorMode(val: EditorMode): void {
-    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: EDITOR_MODE): void {
-    this.mode = val;
-  }
-  get isInViewerMode(): boolean {
-    return this.mode === EDITOR_MODE.VIEWER;
-  }
-  get isInConflictResolutionMode(): boolean {
-    return this.mode === EDITOR_MODE.CONFLICT_RESOLUTION;
-  }
 
   editorExtensionStates: EditorExtensionState[] = [];
   explorerTreeState: ExplorerTreeState;
@@ -202,7 +186,7 @@ export class EditorStore {
   embeddedQueryBuilderState: EmbeddedQueryBuilderState;
   newElementState: NewElementState;
 
-  private _isDisposed = false;
+  initialEntityPath?: string | undefined;
   initState = ActionState.create();
   graphEditMode = GRAPH_EDITOR_MODE.FORM;
 
@@ -221,12 +205,7 @@ export class EditorStore {
     snap: 150,
   });
 
-  // Hot keys
-  blockGlobalHotkeys = false;
-  readonly defaultHotkeys: HotkeyConfiguration[] = [];
-  hotkeys: HotkeyConfiguration[] = [];
-
-  // Tabs
+  // Editor Tabs
   currentEditorState?: EditorState | undefined;
   openedEditorStates: EditorState[] = [];
   /**
@@ -235,8 +214,6 @@ export class EditorStore {
    */
   elementGenerationStates: ElementFileGenerationState[] = [];
   searchElementCommandState = new NonBlockingDialogState();
-  ignoreNavigationBlocking = false;
-  isDevToolEnabled = true;
 
   constructor(
     applicationStore: LegendStudioApplicationStore,
@@ -246,20 +223,15 @@ export class EditorStore {
   ) {
     makeObservable<
       EditorStore,
-      '_isDisposed' | 'initStandardMode' | 'initConflictResolutionMode'
+      'initStandardMode' | 'initConflictResolutionMode'
     >(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,
@@ -274,17 +246,10 @@ 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,
@@ -362,101 +327,6 @@ export class EditorStore {
       )
       .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(): boolean {
@@ -478,57 +348,34 @@ export class EditorStore {
     return this.graphEditMode === GRAPH_EDITOR_MODE.FORM;
   }
 
-  setHotkeys(val: HotkeyConfiguration[]): void {
-    this.hotkeys = val;
-  }
-
-  addHotKey(val: HotkeyConfiguration): void {
-    addUniqueEntry(this.hotkeys, val);
-  }
-
-  resetHotkeys(): void {
-    this.hotkeys = this.defaultHotkeys;
-  }
-
-  setBlockGlobalHotkeys(val: boolean): void {
-    this.blockGlobalHotkeys = val;
-  }
-
-  setDevTool(val: boolean): void {
-    this.isDevToolEnabled = val;
-  }
-
-  setCurrentEditorState(val: EditorState | undefined): void {
-    this.currentEditorState = val;
-  }
-
-  setActiveAuxPanelMode(val: AUX_PANEL_MODE): void {
-    this.activeAuxPanelMode = val;
+  get isInViewerMode(): boolean {
+    return this.mode === EDITOR_MODE.VIEWER;
   }
 
-  setIgnoreNavigationBlocking(val: boolean): void {
-    this.ignoreNavigationBlocking = val;
+  get isInConflictResolutionMode(): boolean {
+    return this.mode === EDITOR_MODE.CONFLICT_RESOLUTION;
   }
 
-  refreshCurrentEntityDiffEditorState(): void {
-    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?: () => boolean): () => boolean {
+    return (): boolean =>
+      // 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: BlockingAlertInfo | undefined): void {
-    if (this._isDisposed) {
-      return;
-    }
-    this.setBlockGlobalHotkeys(Boolean(alertInfo)); // block global hotkeys if alert is shown
-    this.applicationStore.setBlockingAlert(alertInfo);
+  setEditorMode(val: EditorMode): void {
+    this.editorMode = val;
   }
 
-  setActionAlertInfo(alertInfo: ActionAlertInfo | undefined): void {
-    if (this._isDisposed) {
-      return;
-    }
-    this.applicationStore.setActionAlertInfo(alertInfo);
+  setMode(val: EDITOR_MODE): void {
+    this.mode = val;
   }
 
   cleanUp(): void {
@@ -536,11 +383,129 @@ export class EditorStore {
     // 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(): void {
+    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(): void {
+    [
+      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(): void {
@@ -552,6 +517,23 @@ export class EditorStore {
     this.explorerTreeState = new ExplorerTreeState(this);
   }
 
+  internalizeEntityPath(params: WorkspaceEditorPathParams): void {
+    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
@@ -576,7 +558,6 @@ export class EditorStore {
           `Fast-refreshing the app - undoing cleanUp() and preventing initialize() recall in editor store...`,
         );
         this.changeDetectionState.start();
-        this._isDisposed = false;
         return;
       }
       this.applicationStore.notifyIllegalState(
@@ -602,12 +583,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: (): void => this.setBlockGlobalHotkeys(true),
-        onClose: (): void => this.setBlockGlobalHotkeys(false),
         actions: [
           {
             label: 'Reload application',
@@ -673,12 +652,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: (): void => this.setBlockGlobalHotkeys(true),
-        onClose: (): void => this.setBlockGlobalHotkeys(false),
         actions: [
           {
             label: 'View project',
@@ -735,6 +712,7 @@ export class EditorStore {
       ),
     ]);
     yield flowResult(this.initMode());
+
     onLeave(true);
   }
 
@@ -767,13 +745,11 @@ export class EditorStore {
   }
 
   private *initConflictResolutionMode(): GeneratorFn<void> {
-    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: (): void => this.setBlockGlobalHotkeys(true),
-      onClose: (): void => this.setBlockGlobalHotkeys(false),
       actions: [
         {
           label: 'Discard your changes',
@@ -869,6 +845,25 @@ export class EditorStore {
       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());
@@ -907,6 +902,10 @@ export class EditorStore {
     }
   }
 
+  setCurrentEditorState(val: EditorState | undefined): void {
+    this.currentEditorState = val;
+  }
+
   getCurrentEditorState<T extends EditorState>(clazz: Clazz<T>): T {
     return guaranteeType(
       this.currentEditorState,
@@ -922,26 +921,6 @@ export class EditorStore {
     );
   }
 
-  setGraphEditMode(graphEditor: GRAPH_EDITOR_MODE): void {
-    this.graphEditMode = graphEditor;
-    this.graphState.clearCompilationError();
-  }
-
-  setActiveActivity(
-    activity: ACTIVITY_MODE,
-    options?: { keepShowingIfMatchedCurrent?: boolean },
-  ): void {
-    if (!this.sideBarDisplayState.isOpen) {
-      this.sideBarDisplayState.open();
-    } else if (
-      activity === this.activeActivity &&
-      !options?.keepShowingIfMatchedCurrent
-    ) {
-      this.sideBarDisplayState.close();
-    }
-    this.activeActivity = activity;
-  }
-
   closeState(editorState: EditorState): void {
     const elementIndex = this.openedEditorStates.findIndex(
       (e) => e === editorState,
@@ -968,7 +947,7 @@ export class EditorStore {
       this.openedEditorStates.find((e) => e === editorState),
       'Editor tab should be currently opened',
     );
-    this.currentEditorState = editorState;
+    this.setCurrentEditorState(editorState);
     this.openedEditorStates = [editorState];
     this.explorerTreeState.reprocess();
   }
@@ -1000,6 +979,12 @@ export class EditorStore {
     this.explorerTreeState.reprocess();
   }
 
+  refreshCurrentEntityDiffEditorState(): void {
+    if (this.currentEditorState instanceof EntityDiffEditorState) {
+      this.currentEditorState.refresh();
+    }
+  }
+
   openEntityDiff(entityDiffEditorState: EntityDiffViewState): void {
     const existingEditorState = this.openedEditorStates.find(
       (editorState) =>
@@ -1048,6 +1033,30 @@ export class EditorStore {
     this.setCurrentEditorState(editorState);
   }
 
+  setGraphEditMode(graphEditor: GRAPH_EDITOR_MODE): void {
+    this.graphEditMode = graphEditor;
+    this.graphState.clearCompilationError();
+  }
+
+  setActiveActivity(
+    activity: ACTIVITY_MODE,
+    options?: { keepShowingIfMatchedCurrent?: boolean },
+  ): void {
+    if (!this.sideBarDisplayState.isOpen) {
+      this.sideBarDisplayState.open();
+    } else if (
+      activity === this.activeActivity &&
+      !options?.keepShowingIfMatchedCurrent
+    ) {
+      this.sideBarDisplayState.close();
+    }
+    this.activeActivity = activity;
+  }
+
+  setActiveAuxPanelMode(val: AUX_PANEL_MODE): void {
+    this.activeAuxPanelMode = val;
+  }
+
   createElementState(
     element: PackageableElement,
   ): ElementEditorState | undefined {
@@ -1304,29 +1313,6 @@ export class EditorStore {
     this.setCurrentEditorState(generatedFileState);
   }
 
-  createGlobalHotKeyAction =
-    (
-      handler: (event?: KeyboardEvent) => void,
-      preventDefault = true,
-    ): ((event?: KeyboardEvent) => void) =>
-    (event?: KeyboardEvent): void => {
-      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(): void {
     this.setCurrentEditorState(undefined);
     this.openedEditorStates = [];
@@ -1337,7 +1323,7 @@ export class EditorStore {
       if (this.graphState.checkIfApplicationUpdateOperationIsRunning()) {
         return;
       }
-      this.setBlockingAlert({
+      this.applicationStore.setBlockingAlert({
         message: 'Switching to text mode...',
         showLoading: true,
       });
@@ -1354,10 +1340,10 @@ export class EditorStore {
         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) {