@finos/legend-application-studio 22.6.0 → 23.0.1

package/lib/stores/EditorStore.js

@@ -1,844 +0,0 @@
-/**
- * Copyright (c) 2020-present, Goldman Sachs
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-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, } 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';
-import { ChangeDetectionState } from './ChangeDetectionState.js';
-import { NewElementState } from './editor/NewElementState.js';
-import { WorkspaceUpdaterState } from './sidebar-state/WorkspaceUpdaterState.js';
-import { ProjectOverviewState } from './sidebar-state/ProjectOverviewState.js';
-import { WorkspaceReviewState } from './sidebar-state/WorkspaceReviewState.js';
-import { FormLocalChangesState, TextLocalChangesState, } from './sidebar-state/LocalChangesState.js';
-import { WorkspaceWorkflowManagerState } from './sidebar-state/WorkflowManagerState.js';
-import { GrammarTextEditorState } from './editor-state/GrammarTextEditorState.js';
-import { LogEvent, isNonNullable, assertErrorThrown, guaranteeNonNullable, UnsupportedOperationError, ActionState, 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';
-import { ModelImporterState } from './editor-state/ModelImporterState.js';
-import { FunctionEditorState } from './editor-state/element-editor-state/FunctionEditorState.js';
-import { ProjectConfigurationEditorState } from './editor-state/project-configuration-editor-state/ProjectConfigurationEditorState.js';
-import { PackageableRuntimeEditorState } from './editor-state/element-editor-state/RuntimeEditorState.js';
-import { PackageableConnectionEditorState } from './editor-state/element-editor-state/connection/ConnectionEditorState.js';
-import { PackageableDataEditorState } from './editor-state/element-editor-state/data/DataEditorState.js';
-import { FileGenerationEditorState } from './editor-state/element-editor-state/FileGenerationEditorState.js';
-import { CHANGE_DETECTION_EVENT } from './ChangeDetectionEvent.js';
-import { GenerationSpecificationEditorState } from './editor-state/GenerationSpecificationEditorState.js';
-import { UnsupportedElementEditorState } from './editor-state/UnsupportedElementEditorState.js';
-import { DevToolState } from './aux-panel-state/DevToolState.js';
-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';
-import { StandardEditorMode } from './editor/StandardEditorMode.js';
-import { WorkspaceUpdateConflictResolutionState } from './sidebar-state/WorkspaceUpdateConflictResolutionState.js';
-import { graph_addElement, graph_deleteElement, graph_deleteOwnElement, graph_renameElement, } from './shared/modifier/GraphModifierHelper.js';
-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';
-import { EditorTabManagerState } from './EditorTabManagerState.js';
-import { BulkServiceRegistrationState } from './sidebar-state/BulkServiceRegistrationState.js';
-export class EditorExtensionState {
-    /**
-     * This helps to better type-check for this empty abtract type
-     * See https://github.com/finos/legend-studio/blob/master/docs/technical/typescript-usage.md#understand-typescript-structual-type-system
-     */
-    _$nominalTypeBrand;
-}
-export class EditorStore {
-    applicationStore;
-    sdlcServerClient;
-    depotServerClient;
-    pluginManager;
-    initState = ActionState.create();
-    initialEntityPath;
-    graphEditMode = GRAPH_EDITOR_MODE.FORM;
-    editorMode;
-    // 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;
-    editorExtensionStates = [];
-    explorerTreeState;
-    sdlcState;
-    graphState;
-    graphManagerState;
-    changeDetectionState;
-    grammarTextEditorState;
-    modelImporterState;
-    projectConfigurationEditorState;
-    projectOverviewState;
-    workspaceWorkflowManagerState;
-    globalTestRunnerState;
-    workspaceUpdaterState;
-    workspaceReviewState;
-    localChangesState;
-    conflictResolutionState;
-    devToolState;
-    embeddedQueryBuilderState;
-    newElementState;
-    bulkServiceRegistrationState;
-    /**
-     * Since we want to share element generation state across all element in the editor, we will create 1 element generate state
-     * per file generation configuration type.
-     */
-    elementGenerationStates = [];
-    searchElementCommandState = new NonBlockingDialogState();
-    activeAuxPanelMode = AUX_PANEL_MODE.CONSOLE;
-    auxPanelDisplayState = new PanelDisplayState({
-        initial: 0,
-        default: 300,
-        snap: 100,
-    });
-    activeActivity = ACTIVITY_MODE.EXPLORER;
-    sideBarDisplayState = new PanelDisplayState({
-        initial: 300,
-        default: 300,
-        snap: 150,
-    });
-    tabManagerState = new EditorTabManagerState(this);
-    constructor(applicationStore, sdlcServerClient, depotServerClient, graphManagerState) {
-        makeObservable(this, {
-            editorMode: observable,
-            mode: observable,
-            graphEditMode: observable,
-            activeAuxPanelMode: observable,
-            activeActivity: observable,
-            isInViewerMode: computed,
-            isInConflictResolutionMode: computed,
-            isInitialized: computed,
-            isInGrammarTextMode: computed,
-            isInFormMode: computed,
-            setEditorMode: action,
-            setMode: action,
-            setActiveAuxPanelMode: action,
-            cleanUp: action,
-            reset: action,
-            setGraphEditMode: flow,
-            setActiveActivity: action,
-            initialize: flow,
-            initMode: flow,
-            initStandardMode: flow,
-            initConflictResolutionMode: flow,
-            buildGraph: flow,
-            addElement: flow,
-            deleteElement: flow,
-            renameElement: flow,
-            toggleTextMode: flow,
-        });
-        this.applicationStore = applicationStore;
-        this.sdlcServerClient = sdlcServerClient;
-        this.depotServerClient = depotServerClient;
-        this.pluginManager = applicationStore.pluginManager;
-        this.editorMode = new StandardEditorMode(this);
-        this.sdlcState = new EditorSDLCState(this);
-        this.graphState = new EditorGraphState(this);
-        this.graphManagerState = graphManagerState;
-        this.changeDetectionState = new ChangeDetectionState(this, this.graphState);
-        this.devToolState = new DevToolState(this);
-        this.embeddedQueryBuilderState = new EmbeddedQueryBuilderState(this);
-        // side bar panels
-        this.explorerTreeState = new ExplorerTreeState(this);
-        this.projectOverviewState = new ProjectOverviewState(this, this.sdlcState);
-        this.globalTestRunnerState = new GlobalTestRunnerState(this, this.sdlcState);
-        this.workspaceWorkflowManagerState = new WorkspaceWorkflowManagerState(this, this.sdlcState);
-        this.workspaceUpdaterState = new WorkspaceUpdaterState(this, this.sdlcState);
-        this.workspaceReviewState = new WorkspaceReviewState(this, this.sdlcState);
-        this.localChangesState = new FormLocalChangesState(this, this.sdlcState);
-        this.conflictResolutionState = new WorkspaceUpdateConflictResolutionState(this, this.sdlcState);
-        this.newElementState = new NewElementState(this);
-        this.bulkServiceRegistrationState = new BulkServiceRegistrationState(this, this.sdlcState);
-        // special (singleton) editors
-        this.grammarTextEditorState = new GrammarTextEditorState(this);
-        this.modelImporterState = new ModelImporterState(this);
-        this.projectConfigurationEditorState = new ProjectConfigurationEditorState(this, this.sdlcState);
-        // extensions
-        this.editorExtensionStates = this.pluginManager
-            .getApplicationPlugins()
-            .flatMap((plugin) => plugin.getExtraEditorExtensionStateCreators?.() ?? [])
-            .map((creator) => creator(this))
-            .filter(isNonNullable);
-    }
-    get isInitialized() {
-        if (this.isInViewerMode) {
-            return ((Boolean(this.sdlcState.currentProject && this.sdlcState.currentWorkspace) ||
-                Boolean(this.sdlcState.editorStore.editorMode
-                    .viewerStore.projectGAVCoordinates)) &&
-                this.graphManagerState.systemBuildState.hasSucceeded);
-        }
-        else {
-            return (Boolean(this.sdlcState.currentProject &&
-                this.sdlcState.currentWorkspace &&
-                this.sdlcState.currentRevision &&
-                this.sdlcState.remoteWorkspaceRevision) && this.graphManagerState.systemBuildState.hasSucceeded);
-        }
-    }
-    get isInGrammarTextMode() {
-        return this.graphEditMode === GRAPH_EDITOR_MODE.GRAMMAR_TEXT;
-    }
-    get isInFormMode() {
-        return this.graphEditMode === GRAPH_EDITOR_MODE.FORM;
-    }
-    get isInViewerMode() {
-        return this.mode === EDITOR_MODE.VIEWER;
-    }
-    get isInConflictResolutionMode() {
-        return this.mode === EDITOR_MODE.CONFLICT_RESOLUTION;
-    }
-    setEditorMode(val) {
-        this.editorMode = val;
-    }
-    setMode(val) {
-        this.mode = val;
-    }
-    *setGraphEditMode(graphEditor) {
-        this.graphEditMode = graphEditor;
-        this.changeLocalChangesState();
-        this.graphState.clearProblems();
-        if (graphEditor === GRAPH_EDITOR_MODE.GRAMMAR_TEXT) {
-            // Stop change detection as we don't need the actual change detection in text mode
-            this.changeDetectionState.stop();
-            try {
-                yield flowResult(this.changeDetectionState.computeLocalChangesInTextMode((yield this.graphManagerState.graphManager.pureCodeToEntities(this.grammarTextEditorState.graphGrammarText))));
-            }
-            catch (error) {
-                assertErrorThrown(error);
-                this.applicationStore.logService.warn(LogEvent.create(GRAPH_MANAGER_EVENT.PARSING_FAILURE), error);
-            }
-        }
-    }
-    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.applicationStore.alertService.setBlockingAlert(undefined);
-        this.applicationStore.alertService.setActionAlertInfo(undefined);
-        // stop change detection to avoid memory-leak
-        this.changeDetectionState.stop();
-    }
-    /**
-     * 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());
-    }
-    registerCommands() {
-        this.applicationStore.commandService.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.commandService.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.commandService.registerCommand({
-            key: LEGEND_STUDIO_COMMAND_KEY.CREATE_ELEMENT,
-            trigger: this.createEditorCommandTrigger(() => !this.isInViewerMode),
-            action: () => this.newElementState.openModal(),
-        });
-        this.applicationStore.commandService.registerCommand({
-            key: LEGEND_STUDIO_COMMAND_KEY.SEARCH_ELEMENT,
-            trigger: this.createEditorCommandTrigger(),
-            action: () => this.searchElementCommandState.open(),
-        });
-        this.applicationStore.commandService.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.commandService.registerCommand({
-            key: LEGEND_STUDIO_COMMAND_KEY.TOGGLE_MODEL_LOADER,
-            trigger: this.createEditorCommandTrigger(() => !this.isInViewerMode),
-            action: () => this.tabManagerState.openTab(this.modelImporterState),
-        });
-        this.applicationStore.commandService.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.commandService.registerCommand({
-            key: LEGEND_STUDIO_COMMAND_KEY.TOGGLE_AUX_PANEL,
-            trigger: this.createEditorCommandTrigger(() => !this.isInViewerMode),
-            action: () => this.auxPanelDisplayState.toggle(),
-        });
-        this.applicationStore.commandService.registerCommand({
-            key: LEGEND_STUDIO_COMMAND_KEY.TOGGLE_SIDEBAR_EXPLORER,
-            trigger: this.createEditorCommandTrigger(),
-            action: () => this.setActiveActivity(ACTIVITY_MODE.EXPLORER),
-        });
-        this.applicationStore.commandService.registerCommand({
-            key: LEGEND_STUDIO_COMMAND_KEY.TOGGLE_SIDEBAR_LOCAL_CHANGES,
-            trigger: this.createEditorCommandTrigger(() => !this.isInViewerMode),
-            action: () => this.setActiveActivity(ACTIVITY_MODE.LOCAL_CHANGES),
-        });
-        this.applicationStore.commandService.registerCommand({
-            key: LEGEND_STUDIO_COMMAND_KEY.TOGGLE_SIDEBAR_WORKSPACE_REVIEW,
-            trigger: this.createEditorCommandTrigger(() => !this.isInViewerMode),
-            action: () => this.setActiveActivity(ACTIVITY_MODE.WORKSPACE_REVIEW),
-        });
-        this.applicationStore.commandService.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.commandService.deregisterCommand(key));
-    }
-    reset() {
-        this.tabManagerState.closeAllTabs();
-        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.navigationService.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
-     * If either of them does not exist, we cannot proceed.
-     */
-    *initialize(projectId, workspaceId, workspaceType) {
-        if (!this.initState.isInInitialState) {
-            /**
-             * Since React `fast-refresh` will sometimes cause `Editor` to rerender, this method will be called again
-             * as all hooks are recalled, as such, ONLY IN DEVELOPMENT mode we allow this to not fail-fast
-             * we also have to `undo` some of what the `cleanUp` does to this store as the cleanup part of all hooks will be triggered
-             * as well
-             */
-            // eslint-disable-next-line no-process-env
-            if (process.env.NODE_ENV === 'development') {
-                this.applicationStore.logService.info(LogEvent.create(APPLICATION_EVENT.DEVELOPMENT_ISSUE), `Fast-refreshing the app - undoing cleanUp() and preventing initialize() recall in editor store...`);
-                this.changeDetectionState.start();
-                return;
-            }
-            this.applicationStore.notificationService.notifyIllegalState('Editor store is re-initialized');
-            return;
-        }
-        this.initState.inProgress();
-        const onLeave = (hasBuildSucceeded) => {
-            this.initState.complete(hasBuildSucceeded);
-            this.initState.setMessage(undefined);
-        };
-        this.initState.setMessage(`Setting up workspace...`);
-        yield flowResult(this.sdlcState.fetchCurrentProject(projectId, {
-            suppressNotification: true,
-        }));
-        if (!this.sdlcState.currentProject) {
-            // If the project is not found or the user does not have access to it,
-            // we will not automatically redirect them to the setup page as they will lose the URL
-            // instead, we give them the option to:
-            // - reload the page (in case they later gain access)
-            // - back to the setup page
-            this.applicationStore.alertService.setActionAlertInfo({
-                message: `Project not found or inaccessible`,
-                prompt: 'Please check that the project exists and request access to it',
-                type: ActionAlertType.STANDARD,
-                actions: [
-                    {
-                        label: 'Reload application',
-                        default: true,
-                        type: ActionAlertActionType.STANDARD,
-                        handler: () => {
-                            this.applicationStore.navigationService.navigator.reload();
-                        },
-                    },
-                    {
-                        label: 'Back to workspace setup',
-                        type: ActionAlertActionType.STANDARD,
-                        handler: () => {
-                            this.applicationStore.navigationService.navigator.goToLocation(generateSetupRoute(undefined));
-                        },
-                    },
-                ],
-            });
-            onLeave(false);
-            return;
-        }
-        yield flowResult(this.sdlcState.fetchCurrentWorkspace(projectId, workspaceId, workspaceType, {
-            suppressNotification: true,
-        }));
-        if (!this.sdlcState.currentWorkspace) {
-            // If the workspace is not found,
-            // we will not automatically redirect the user to the setup page as they will lose the URL
-            // instead, we give them the option to:
-            // - create the workspace
-            // - view project
-            // - back to the setup page
-            const createWorkspaceAndRelaunch = async () => {
-                try {
-                    this.applicationStore.alertService.setBlockingAlert({
-                        message: 'Creating workspace...',
-                        prompt: 'Please do not close the application',
-                    });
-                    const workspace = await this.sdlcServerClient.createWorkspace(projectId, workspaceId, workspaceType);
-                    this.applicationStore.alertService.setBlockingAlert(undefined);
-                    this.applicationStore.notificationService.notifySuccess(`Workspace '${workspace.workspaceId}' is succesfully created. Reloading application...`);
-                    this.applicationStore.navigationService.navigator.reload();
-                }
-                catch (error) {
-                    assertErrorThrown(error);
-                    this.applicationStore.logService.error(LogEvent.create(LEGEND_STUDIO_APP_EVENT.WORKSPACE_SETUP_FAILURE), error);
-                    this.applicationStore.notificationService.notifyError(error);
-                }
-            };
-            this.applicationStore.alertService.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,
-                actions: [
-                    {
-                        label: 'View project',
-                        default: true,
-                        type: ActionAlertActionType.STANDARD,
-                        handler: () => {
-                            this.applicationStore.navigationService.navigator.goToLocation(generateViewProjectRoute(projectId));
-                        },
-                    },
-                    {
-                        label: 'Create workspace',
-                        type: ActionAlertActionType.STANDARD,
-                        handler: () => {
-                            createWorkspaceAndRelaunch().catch(this.applicationStore.alertUnhandledError);
-                        },
-                    },
-                    {
-                        label: 'Back to workspace setup',
-                        type: ActionAlertActionType.STANDARD,
-                        handler: () => {
-                            this.applicationStore.navigationService.navigator.goToLocation(generateSetupRoute(projectId, workspaceId, workspaceType));
-                        },
-                    },
-                ],
-            });
-            onLeave(false);
-            return;
-        }
-        yield Promise.all([
-            this.sdlcState.fetchCurrentRevision(projectId, this.sdlcState.activeWorkspace),
-            this.graphManagerState.initializeSystem(),
-            this.graphManagerState.graphManager.initialize({
-                env: this.applicationStore.config.env,
-                tabSize: TAB_SIZE,
-                clientConfig: {
-                    baseUrl: this.applicationStore.config.engineServerUrl,
-                    queryBaseUrl: this.applicationStore.config.engineQueryServerUrl,
-                    enableCompression: true,
-                },
-            }, {
-                tracerService: this.applicationStore.tracerService,
-            }),
-        ]);
-        yield flowResult(this.initMode());
-        onLeave(true);
-    }
-    *initMode() {
-        switch (this.mode) {
-            case EDITOR_MODE.STANDARD:
-                yield flowResult(this.initStandardMode());
-                return;
-            case EDITOR_MODE.CONFLICT_RESOLUTION:
-                yield flowResult(this.initConflictResolutionMode());
-                return;
-            default:
-                throw new UnsupportedOperationError(`Can't initialize editor for unsupported mode '${this.mode}'`);
-        }
-    }
-    *initStandardMode() {
-        yield Promise.all([
-            this.buildGraph(),
-            this.sdlcState.checkIfWorkspaceIsOutdated(),
-            this.workspaceReviewState.fetchCurrentWorkspaceReview(),
-            this.workspaceUpdaterState.fetchLatestCommittedReviews(),
-            this.projectConfigurationEditorState.fetchLatestProjectStructureVersion(),
-            this.graphState.graphGenerationState.fetchAvailableFileGenerationDescriptions(),
-            this.graphState.graphGenerationState.externalFormatState.fetchExternalFormatsDescriptions(),
-            this.sdlcState.fetchProjectVersions(),
-        ]);
-    }
-    *initConflictResolutionMode() {
-        this.applicationStore.alertService.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,
-            actions: [
-                {
-                    label: 'Discard your changes',
-                    type: ActionAlertActionType.PROCEED_WITH_CAUTION,
-                    handler: () => {
-                        this.setActiveActivity(ACTIVITY_MODE.CONFLICT_RESOLUTION);
-                        flowResult(this.conflictResolutionState.discardConflictResolutionChanges()).catch((error) => this.applicationStore.alertUnhandledError(error));
-                    },
-                },
-                {
-                    label: 'Resolve merge conflicts',
-                    default: true,
-                    type: ActionAlertActionType.STANDARD,
-                },
-            ],
-        });
-        yield Promise.all([
-            this.conflictResolutionState.initialize(),
-            this.sdlcState.checkIfWorkspaceIsOutdated(),
-            this.projectConfigurationEditorState.fetchLatestProjectStructureVersion(),
-            this.graphState.graphGenerationState.fetchAvailableFileGenerationDescriptions(),
-            this.graphState.graphGenerationState.externalFormatState.fetchExternalFormatsDescriptions(),
-            this.sdlcState.fetchProjectVersions(),
-        ]);
-    }
-    *buildGraph(graphEntities) {
-        const startTime = Date.now();
-        let entities;
-        let projectConfiguration;
-        this.initState.setMessage(`Fetching entities...`);
-        try {
-            // fetch workspace entities and config at the same time
-            const projectId = this.sdlcState.activeProject.projectId;
-            const activeWorkspace = this.sdlcState.activeWorkspace;
-            const result = (yield Promise.all([
-                this.sdlcServerClient.getEntities(projectId, activeWorkspace),
-                this.sdlcServerClient.getConfiguration(projectId, activeWorkspace),
-            ]));
-            entities = result[0];
-            projectConfiguration = result[1];
-            this.projectConfigurationEditorState.setProjectConfiguration(ProjectConfiguration.serialization.fromJson(projectConfiguration));
-            // make sure we set the original project configuration to a different object
-            this.projectConfigurationEditorState.setOriginalProjectConfiguration(ProjectConfiguration.serialization.fromJson(projectConfiguration));
-            this.changeDetectionState.workspaceLocalLatestRevisionState.setEntities(entities);
-            this.applicationStore.logService.info(LogEvent.create(GRAPH_MANAGER_EVENT.FETCH_GRAPH_ENTITIES__SUCCESS), Date.now() - startTime, 'ms');
-        }
-        catch {
-            return;
-        }
-        finally {
-            this.initState.setMessage(undefined);
-        }
-        try {
-            const result = (yield flowResult(
-            // NOTE: if graph entities are provided, we will use that to build the graph.
-            // We use this method as a way to fully reset the application with the entities, but we still use
-            // the workspace entities for hashing as those are the base entities.
-            this.graphState.buildGraph(graphEntities ?? entities)));
-            if (result.error) {
-                if (result.status === GraphBuilderStatus.REDIRECTED_TO_TEXT_MODE) {
-                    yield flowResult(this.changeDetectionState.workspaceLocalLatestRevisionState.buildEntityHashesIndex(entities, LogEvent.create(CHANGE_DETECTION_EVENT.CHANGE_DETECTION_BUILD_LOCAL_HASHES_INDEX__SUCCESS)));
-                }
-                return;
-            }
-            this.initState.setMessage(`Starting change detection engine...`);
-            // 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.tabManagerState.openElementEditor(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());
-            yield Promise.all([
-                this.changeDetectionState.preComputeGraphElementHashes(),
-                this.changeDetectionState.workspaceLocalLatestRevisionState.buildEntityHashesIndex(entities, LogEvent.create(CHANGE_DETECTION_EVENT.CHANGE_DETECTION_BUILD_LOCAL_HASHES_INDEX__SUCCESS)),
-                this.sdlcState.buildWorkspaceBaseRevisionEntityHashesIndex(),
-                this.sdlcState.buildProjectLatestRevisionEntityHashesIndex(),
-            ]);
-            this.changeDetectionState.start();
-            yield Promise.all([
-                this.changeDetectionState.computeAggregatedWorkspaceChanges(true),
-                this.changeDetectionState.computeAggregatedProjectLatestChanges(true),
-            ]);
-            this.applicationStore.logService.info(LogEvent.create(CHANGE_DETECTION_EVENT.CHANGE_DETECTION_RESTART__SUCCESS), '[ASNYC]');
-            // ======= FINISHED (RE)START CHANGE DETECTION =======
-        }
-        catch (error) {
-            assertErrorThrown(error);
-            this.applicationStore.logService.error(LogEvent.create(GRAPH_MANAGER_EVENT.GRAPH_BUILDER_FAILURE), error);
-            // since errors have been handled accordingly, we don't need to do anything here
-            return;
-        }
-        finally {
-            this.initState.setMessage(undefined);
-        }
-    }
-    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;
-    }
-    createElementEditorState(element) {
-        if (element instanceof PrimitiveType) {
-            throw new UnsupportedOperationError(`Can't create element state for primitive type`);
-        }
-        else if (element instanceof Class) {
-            return new ClassEditorState(this, element);
-        }
-        else if (element instanceof Association ||
-            element instanceof Enumeration ||
-            element instanceof Profile) {
-            return new UMLEditorState(this, element);
-        }
-        else if (element instanceof ConcreteFunctionDefinition) {
-            return new FunctionEditorState(this, element);
-        }
-        else if (element instanceof Measure ||
-            element instanceof Database ||
-            element instanceof FlatData) {
-            return new UnsupportedElementEditorState(this, element);
-        }
-        else if (element instanceof PackageableRuntime) {
-            return new PackageableRuntimeEditorState(this, element);
-        }
-        else if (element instanceof PackageableConnection) {
-            return new PackageableConnectionEditorState(this, element);
-        }
-        else if (element instanceof Mapping) {
-            return new MappingEditorState(this, element);
-        }
-        else if (element instanceof Service) {
-            return new ServiceEditorState(this, element);
-        }
-        else if (element instanceof GenerationSpecification) {
-            return new GenerationSpecificationEditorState(this, element);
-        }
-        else if (element instanceof FileGenerationSpecification) {
-            return new FileGenerationEditorState(this, element);
-        }
-        else if (element instanceof DataElement) {
-            return new PackageableDataEditorState(this, element);
-        }
-        const extraElementEditorStateCreators = this.pluginManager
-            .getApplicationPlugins()
-            .flatMap((plugin) => plugin.getExtraElementEditorStateCreators?.() ?? []);
-        for (const creator of extraElementEditorStateCreators) {
-            const elementEditorState = creator(this, element);
-            if (elementEditorState) {
-                return elementEditorState;
-            }
-        }
-        throw new UnsupportedOperationError(`Can't create editor state for element: no compatible editor state creator available from plugins`, element);
-    }
-    *addElement(element, packagePath, openAfterCreate) {
-        graph_addElement(this.graphManagerState.graph, element, packagePath, this.changeDetectionState.observerContext);
-        this.explorerTreeState.reprocess();
-        if (openAfterCreate) {
-            this.tabManagerState.openElementEditor(element);
-        }
-    }
-    *deleteElement(element) {
-        if (this.graphState.checkIfApplicationUpdateOperationIsRunning() ||
-            isElementReadOnly(element)) {
-            return;
-        }
-        const generatedChildrenElements = (this.graphState.graphGenerationState.generatedEntities.get(element.path) ?? [])
-            .map((genChildEntity) => this.graphManagerState.graph.generationModel.allOwnElements.find((genElement) => genElement.path === genChildEntity.path))
-            .filter(isNonNullable);
-        const elementsToDelete = [element, ...generatedChildrenElements];
-        this.tabManagerState.tabs = this.tabManagerState.tabs.filter((elementState) => {
-            if (elementState instanceof ElementEditorState) {
-                if (elementState === this.tabManagerState.currentTab) {
-                    // avoid closing the current editor state as this will be taken care of
-                    // by the `closeState()` call later
-                    return true;
-                }
-                return !elementsToDelete.includes(elementState.element);
-            }
-            return true;
-        });
-        if (this.tabManagerState.currentTab &&
-            this.tabManagerState.currentTab instanceof ElementEditorState &&
-            elementsToDelete.includes(this.tabManagerState.currentTab.element)) {
-            this.tabManagerState.closeTab(this.tabManagerState.currentTab);
-        }
-        // remove/retire the element's generated children before remove the element itself
-        generatedChildrenElements.forEach((el) => graph_deleteOwnElement(this.graphManagerState.graph.generationModel, el));
-        graph_deleteElement(this.graphManagerState.graph, element);
-        const extraElementEditorPostDeleteActions = this.pluginManager
-            .getApplicationPlugins()
-            .flatMap((plugin) => plugin.getExtraElementEditorPostDeleteActions?.() ?? []);
-        for (const postDeleteAction of extraElementEditorPostDeleteActions) {
-            postDeleteAction(this, element);
-        }
-        // reprocess project explorer tree
-        this.explorerTreeState.reprocess();
-        // recompile
-        yield flowResult(this.graphState.globalCompileInFormMode({
-            message: `Can't compile graph after deletion and error cannot be located in form mode. Redirected to text mode for debugging`,
-        }));
-    }
-    *renameElement(element, newPath) {
-        if (isElementReadOnly(element)) {
-            return;
-        }
-        graph_renameElement(this.graphManagerState.graph, element, newPath, this.changeDetectionState.observerContext);
-        const extraElementEditorPostRenameActions = this.pluginManager
-            .getApplicationPlugins()
-            .flatMap((plugin) => plugin.getExtraElementEditorPostRenameActions?.() ?? []);
-        for (const postRenameAction of extraElementEditorPostRenameActions) {
-            postRenameAction(this, element);
-        }
-        // reprocess project explorer tree
-        this.explorerTreeState.reprocess();
-        if (element instanceof Package) {
-            this.explorerTreeState.openNode(element);
-        }
-        else if (element.package) {
-            this.explorerTreeState.openNode(element.package);
-        }
-        // recompile
-        yield flowResult(this.graphState.globalCompileInFormMode({
-            message: `Can't compile graph after renaming and error cannot be located in form mode. Redirected to text mode for debugging`,
-        }));
-    }
-    *toggleTextMode() {
-        if (this.isInFormMode) {
-            if (this.graphState.checkIfApplicationUpdateOperationIsRunning()) {
-                return;
-            }
-            this.applicationStore.alertService.setBlockingAlert({
-                message: 'Switching to text mode...',
-                showLoading: true,
-            });
-            try {
-                const graphGrammar = (yield this.graphManagerState.graphManager.graphToPureCode(this.graphManagerState.graph));
-                yield flowResult(this.grammarTextEditorState.setGraphGrammarText(graphGrammar));
-            }
-            catch (error) {
-                assertErrorThrown(error);
-                this.applicationStore.notificationService.notifyWarning(`Can't enter text mode: transformation to grammar text failed. Error: ${error.message}`);
-                this.applicationStore.alertService.setBlockingAlert(undefined);
-                return;
-            }
-            this.applicationStore.alertService.setBlockingAlert(undefined);
-            yield flowResult(this.setGraphEditMode(GRAPH_EDITOR_MODE.GRAMMAR_TEXT));
-            // navigate to the currently opened element immediately after entering text mode editor
-            if (this.tabManagerState.currentTab instanceof ElementEditorState) {
-                this.grammarTextEditorState.setCurrentElementLabelRegexString(this.tabManagerState.currentTab.element);
-            }
-        }
-        else if (this.isInGrammarTextMode) {
-            yield flowResult(this.graphState.leaveTextMode());
-        }
-        else {
-            throw new UnsupportedOperationError('Editor only support form mode and text mode at the moment');
-        }
-    }
-    getSupportedElementTypes() {
-        return [
-            PACKAGEABLE_ELEMENT_TYPE.CLASS,
-            PACKAGEABLE_ELEMENT_TYPE.ENUMERATION,
-            PACKAGEABLE_ELEMENT_TYPE.PROFILE,
-            PACKAGEABLE_ELEMENT_TYPE.ASSOCIATION,
-            PACKAGEABLE_ELEMENT_TYPE.FUNCTION,
-            PACKAGEABLE_ELEMENT_TYPE.MEASURE,
-            PACKAGEABLE_ELEMENT_TYPE.MAPPING,
-            PACKAGEABLE_ELEMENT_TYPE.RUNTIME,
-            PACKAGEABLE_ELEMENT_TYPE.CONNECTION,
-            PACKAGEABLE_ELEMENT_TYPE.SERVICE,
-            PACKAGEABLE_ELEMENT_TYPE.GENERATION_SPECIFICATION,
-            PACKAGEABLE_ELEMENT_TYPE.FILE_GENERATION,
-            PACKAGEABLE_ELEMENT_TYPE.FLAT_DATA_STORE,
-            PACKAGEABLE_ELEMENT_TYPE.DATABASE,
-            PACKAGEABLE_ELEMENT_TYPE.DATA,
-        ].concat(this.pluginManager
-            .getApplicationPlugins()
-            .flatMap((plugin) => plugin.getExtraSupportedElementTypes?.() ?? []));
-    }
-    changeLocalChangesState() {
-        if (this.isInFormMode) {
-            this.localChangesState = new FormLocalChangesState(this, this.sdlcState);
-        }
-        else {
-            this.localChangesState = new TextLocalChangesState(this, this.sdlcState);
-        }
-    }
-}
-//# sourceMappingURL=EditorStore.js.map