@finos/legend-application-studio 13.1.0 → 14.0.0

package/src/stores/editor-state/element-editor-state/external-format/SchemaSetEditorState.ts

@@ -33,16 +33,22 @@ import {
   isEmpty,
   ActionState,
   deleteEntry,
+  assertTrue,
+  generateEnumerableNameFromToken,
 } from '@finos/legend-shared';
 import {
   type GenerationProperty,
   type PackageableElement,
+  GenerationPropertyItemType,
   type ExternalFormatDescription,
+  type PureModel,
   CompilationError,
   ConfigurationProperty,
-  GenerationPropertyItemType,
   ExternalFormatSchema as Schema,
   SchemaSet,
+  isValidFullPath,
+  resolvePackagePathAndElementName,
+  Package,
 } from '@finos/legend-graph';
 import type { Entity } from '@finos/legend-storage';
 import { type EntityChange, EntityChangeType } from '@finos/legend-server-sdlc';
@@ -52,43 +58,72 @@ import { LEGEND_STUDIO_APP_EVENT } from '../../../LegendStudioAppEvent.js';
 import { configurationProperty_setValue } from '../../../graphModifier/DSLGeneration_GraphModifierHelper.js';
 
 export enum SCHEMA_SET_TAB_TYPE {
-  GENERAL = 'GENERAL',
-  MODEL_GENERATION = 'MODEL_GENERATION',
+  SCHEMAS = 'SCHEMAS',
+  GENERATE_MODEL = 'GENERATE_MODEL',
 }
 
+const DEFAULT_SCHEMA_NAME = 'MyShemaSet';
+
 export class SchemaSetModelGenerationState {
-  isGenerating = false;
-  isImportingGeneratedElements = false;
-  schemaSetEditorState: SchemaSetEditorState;
+  readonly editorStore: EditorStore;
+  readonly schemaSet: SchemaSet;
+  generatingModelsState = ActionState.create();
+  importGeneratedElementsState = ActionState.create();
+
   configurationProperties: ConfigurationProperty[] = [];
   generationValue = '';
+  targetBinding = '';
+  isolatedGraph: PureModel | undefined;
 
-  constructor(schemaSetEditorState: SchemaSetEditorState) {
-    this.schemaSetEditorState = schemaSetEditorState;
-
+  constructor(
+    schemaSet: SchemaSet,
+    editorStore: EditorStore,
+    graph?: PureModel | undefined,
+  ) {
+    this.schemaSet = schemaSet;
+    this.editorStore = editorStore;
     makeObservable(this, {
       configurationProperties: observable,
-      isGenerating: observable,
+      generatingModelsState: observable,
+      importGeneratedElementsState: observable,
       generationValue: observable,
+      targetBinding: observable,
       setConfigurationProperty: action,
       setGenerationValue: action,
+      setTargetBindingPath: action,
+      handleTargetBindingPathChange: action,
+      canGenerate: computed,
       generateModel: flow,
-      importGrammar: flow,
+      importGeneratedModelsIntoGraph: flow,
+      getImportEntities: flow,
     });
+    this.isolatedGraph = graph;
+    assertTrue(this.isolatedGraph !== this.editorStore.graphManagerState.graph);
   }
 
   setConfigurationProperty(val: ConfigurationProperty[]): void {
     this.configurationProperties = val;
   }
 
-  get description(): ExternalFormatDescription {
-    return this.schemaSetEditorState.editorStore.graphState.graphGenerationState.externalFormatState.getTypeDescription(
-      this.schemaSetEditorState.schemaSet.format,
+  get description(): ExternalFormatDescription | undefined {
+    return this.editorStore.graphState.graphGenerationState.externalFormatState.getTypeDescription(
+      this.schemaSet.format,
     );
   }
 
   get modelGenerationProperties(): GenerationProperty[] {
-    return this.description.modelGenerationProperties;
+    return this.description?.modelGenerationProperties ?? [];
+  }
+
+  get canGenerate(): boolean {
+    if (this.targetBinding === '') {
+      return true;
+    }
+    return isValidFullPath(this.targetBinding);
+  }
+
+  setTargetBindingPath(val: string): void {
+    this.targetBinding = val;
   }
 
   getConfigValue(name: string): unknown | undefined {
@@ -105,6 +140,39 @@ export class SchemaSetModelGenerationState {
     this.generationValue = val;
   }
 
+  handleTargetBindingPathChange(): void {
+    const isolatedGraph = this.isolatedGraph;
+    if (isolatedGraph && isValidFullPath(this.targetBinding)) {
+      try {
+        const [packagePath, bindingName] = resolvePackagePathAndElementName(
+          this.targetBinding,
+        );
+        const schemaName = `${DEFAULT_SCHEMA_NAME}For${bindingName}`;
+        const _package =
+          this.editorStore.graphManagerState.graph.getNullableElement(
+            packagePath,
+            true,
+          );
+        let reservedNames: string[] = [];
+        if (_package instanceof Package) {
+          reservedNames = _package.children.map((e) => e.name);
+        }
+        const newSchemaName = reservedNames.includes(schemaName)
+          ? generateEnumerableNameFromToken(reservedNames, schemaName)
+          : schemaName;
+        const newPath = `${packagePath}::${newSchemaName}`;
+        if (newPath !== this.schemaSet.path) {
+          isolatedGraph.renameElement(
+            this.schemaSet,
+            `${packagePath}::${newSchemaName}`,
+          );
+        }
+      } catch (error) {
+        assertErrorThrown(error);
+      }
+    }
+  }
+
   updateGenerationParameters(
     generationProperty: GenerationProperty,
     newValue: unknown,
@@ -159,85 +227,101 @@ export class SchemaSetModelGenerationState {
     }
   }
 
-  *generateModel(): GeneratorFn<void> {
-    this.isGenerating = true;
+  *generateModel(): GeneratorFn<boolean> {
+    this.generatingModelsState.inProgress();
     try {
-      const SCHEMA_SET_PROPERTY_NAME = 'sourceSchemaSet';
       const SCHEMA_FORMAT_PROPERTY_NAME = 'format';
       const properties = [...this.configurationProperties];
-      if (!properties.find((e) => e.name === SCHEMA_SET_PROPERTY_NAME)) {
-        const genProperty = new ConfigurationProperty(
-          SCHEMA_SET_PROPERTY_NAME,
-          this.schemaSetEditorState.schemaSet.path,
-        );
-        properties.push(genProperty);
-      }
       if (!properties.find((e) => e.name === SCHEMA_FORMAT_PROPERTY_NAME)) {
         const genProperty = new ConfigurationProperty(
           SCHEMA_FORMAT_PROPERTY_NAME,
-          this.schemaSetEditorState.schemaSet.format,
+          this.schemaSet.format,
         );
         properties.push(genProperty);
       }
       const val =
-        (yield this.schemaSetEditorState.editorStore.graphManagerState.graphManager.generateModelFromExternalFormat(
+        (yield this.editorStore.graphManagerState.graphManager.generateModelFromExternalFormat(
+          this.schemaSet,
+          this.targetBinding,
           properties,
-          this.schemaSetEditorState.editorStore.graphManagerState.graph,
+          this.isolatedGraph ?? this.editorStore.graphManagerState.graph,
         )) as string;
       this.setGenerationValue(val);
+      return true;
     } catch (error) {
       assertErrorThrown(error);
-      this.schemaSetEditorState.editorStore.applicationStore.log.error(
+      this.editorStore.applicationStore.log.error(
         LogEvent.create(LEGEND_STUDIO_APP_EVENT.EXTERNAL_FORMAT_FAILURE),
         error,
       );
-      this.schemaSetEditorState.editorStore.applicationStore.notifyError(error);
+      this.editorStore.applicationStore.notifyError(error);
+      this.setGenerationValue('');
+      return false;
     } finally {
-      this.isGenerating = false;
+      this.generatingModelsState.complete();
     }
   }
 
-  *importGrammar(): GeneratorFn<void> {
+  *importGeneratedModelsIntoGraph(): GeneratorFn<void> {
     try {
-      this.isImportingGeneratedElements = true;
-      const entities =
-        (yield this.schemaSetEditorState.editorStore.graphManagerState.graphManager.pureCodeToEntities(
-          this.generationValue,
-        )) as Entity[];
+      this.importGeneratedElementsState.inProgress();
+      const entities = (yield flowResult(this.getImportEntities())) as Entity[];
       const newEntities: EntityChange[] = entities.map((e) => ({
         type: EntityChangeType.CREATE,
         entityPath: e.path,
         content: e.content,
       }));
       yield flowResult(
-        this.schemaSetEditorState.editorStore.graphState.loadEntityChangesToGraph(
+        this.editorStore.graphState.loadEntityChangesToGraph(
           newEntities,
           undefined,
         ),
       );
-      this.schemaSetEditorState.editorStore.applicationStore.notifySuccess(
+      this.editorStore.applicationStore.notifySuccess(
         'Generated elements imported into project',
       );
     } catch (error) {
       assertErrorThrown(error);
-      this.schemaSetEditorState.editorStore.applicationStore.log.error(
+      this.editorStore.applicationStore.log.error(
         LogEvent.create(LEGEND_STUDIO_APP_EVENT.EXTERNAL_FORMAT_FAILURE),
         error,
       );
-      this.schemaSetEditorState.editorStore.applicationStore.notifyError(error);
+      this.editorStore.applicationStore.notifyError(error);
     } finally {
-      this.isImportingGeneratedElements = false;
+      this.importGeneratedElementsState.complete();
+    }
+  }
+
+  *getImportEntities(): GeneratorFn<Entity[]> {
+    try {
+      this.importGeneratedElementsState.inProgress();
+      const entities =
+        (yield this.editorStore.graphManagerState.graphManager.pureCodeToEntities(
+          this.generationValue,
+        )) as Entity[];
+      return entities;
+    } catch (error) {
+      assertErrorThrown(error);
+      this.editorStore.applicationStore.log.error(
+        LogEvent.create(LEGEND_STUDIO_APP_EVENT.EXTERNAL_FORMAT_FAILURE),
+        error,
+      );
+      this.editorStore.applicationStore.notifyError(error);
+      throw error;
+    } finally {
+      this.importGeneratedElementsState.complete();
     }
   }
 }
+
 export class ImportSchemaContentState {
   editorStore: EditorStore;
-  schemaSetEditorState: SchemaSetEditorState;
+  schemaSetEditorState: InnerSchemaSetEditorState | SchemaSetEditorState;
   loadingSchemaContentState = ActionState.create();
   files: File[] | undefined;
   importSchemaModal = false;
   constructor(
-    schemaSetEditorState: SchemaSetEditorState,
+    schemaSetEditorState: InnerSchemaSetEditorState | SchemaSetEditorState,
     editorStore: EditorStore,
   ) {
     this.editorStore = editorStore;
@@ -304,9 +388,81 @@ export class ImportSchemaContentState {
   }
 }
 
+export class InnerSchemaSetEditorState {
+  readonly editorStore: EditorStore;
+  isReadOnly: boolean;
+  schemaSet: SchemaSet;
+  currentSchema?: Schema | undefined;
+  selectedTab = SCHEMA_SET_TAB_TYPE.SCHEMAS;
+  schemaValidationError?: CompilationError;
+  importSchemaContentState: ImportSchemaContentState;
+  schemaSetModelGenerationState: SchemaSetModelGenerationState;
+
+  constructor(
+    isReadOnly: boolean,
+    schemaSet: SchemaSet,
+    editorStore: EditorStore,
+    graph: PureModel,
+  ) {
+    this.editorStore = editorStore;
+    makeObservable(this, {
+      schemaValidationError: observable,
+      currentSchema: observable,
+      selectedTab: observable,
+      schemaSet: observable,
+      schemaSetModelGenerationState: observable,
+      setSelectedTab: action,
+      setCurrentSchema: action,
+      setSchemaValidationerror: action,
+      reset: action,
+    });
+    this.schemaSet = schemaSet;
+    this.isReadOnly = isReadOnly;
+    if (this.schemaSet.schemas.length !== 0) {
+      this.currentSchema =
+        this.schemaSet.schemas[this.schemaSet.schemas.length - 1];
+    }
+    this.schemaSetModelGenerationState = new SchemaSetModelGenerationState(
+      this.schemaSet,
+      this.editorStore,
+      graph,
+    );
+    this.importSchemaContentState = new ImportSchemaContentState(
+      this,
+      this.editorStore,
+    );
+  }
+
+  reset(): void {
+    this.currentSchema = undefined;
+    this.selectedTab = SCHEMA_SET_TAB_TYPE.SCHEMAS;
+    this.schemaSetModelGenerationState = new SchemaSetModelGenerationState(
+      this.schemaSet,
+      this.editorStore,
+      this.schemaSetModelGenerationState.isolatedGraph,
+    );
+    this.importSchemaContentState = new ImportSchemaContentState(
+      this,
+      this.editorStore,
+    );
+  }
+
+  setCurrentSchema(value: Schema | undefined): void {
+    this.currentSchema = value;
+  }
+
+  setSelectedTab(tab: SCHEMA_SET_TAB_TYPE): void {
+    this.selectedTab = tab;
+  }
+
+  setSchemaValidationerror(error: CompilationError): void {
+    this.schemaValidationError = error;
+  }
+}
+
 export class SchemaSetEditorState extends ElementEditorState {
   currentSchema?: Schema | undefined;
-  selectedTab = SCHEMA_SET_TAB_TYPE.GENERAL;
+  selectedTab = SCHEMA_SET_TAB_TYPE.SCHEMAS;
   schemaValidationError?: CompilationError;
   importSchemaContentState: ImportSchemaContentState;
 
@@ -331,7 +487,8 @@ export class SchemaSetEditorState extends ElementEditorState {
         this.schemaSet.schemas[this.schemaSet.schemas.length - 1];
     }
     this.schemaSetModelGenerationState = new SchemaSetModelGenerationState(
-      this,
+      this.schemaSet,
+      this.editorStore,
     );
     this.importSchemaContentState = new ImportSchemaContentState(
       this,

package/src/stores/editor-state/element-editor-state/service/ServiceExecutionState.ts

@@ -125,6 +125,7 @@ export class ServiceExecutionParameterState extends LambdaParametersState {
       const parmeterState = new LambdaParameterState(
         p,
         this.executionState.editorStore.changeDetectionState.observerContext,
+        this.executionState.editorStore.graphManagerState.graph,
       );
       parmeterState.mockParameterValue();
       return parmeterState;

package/src/stores/editor-state/element-editor-state/service/testable/ServiceTestDataState.ts

@@ -44,6 +44,7 @@ import {
   isNonNullable,
   returnUndefOnError,
   getNullableFirstElement,
+  uniq,
 } from '@finos/legend-shared';
 import { action, flow, makeObservable, observable } from 'mobx';
 import type { EditorStore } from '../../../../EditorStore.js';
@@ -360,6 +361,6 @@ export class ServiceTestDataState {
     } else if (execution instanceof PureMultiExecution) {
       runtimes = execution.executionParameters.map((t) => t.runtime);
     }
-    return runtimes.flatMap(getAllIdentifiedConnectionsFromRuntime);
+    return uniq(runtimes.flatMap(getAllIdentifiedConnectionsFromRuntime));
   }
 }

package/src/stores/editor-state/element-editor-state/service/testable/ServiceTestEditorState.ts

@@ -136,7 +136,10 @@ export class ServiceValueSpecificationTestParameterState extends ServiceTestPara
   }
 
   resetValueSpec(): void {
-    const mockValue = generateVariableExpressionMockValue(this.varExpression);
+    const mockValue = generateVariableExpressionMockValue(
+      this.varExpression,
+      this.editorStore.graphManagerState.graph,
+    );
     if (mockValue) {
       this.updateValueSpecification(mockValue);
     }
@@ -258,7 +261,10 @@ export class ServiceTestSetupState {
   addExpressionParameterValue(expression: VariableExpression): void {
     try {
       const mockValue = guaranteeNonNullable(
-        generateVariableExpressionMockValue(expression),
+        generateVariableExpressionMockValue(
+          expression,
+          this.editorStore.graphManagerState.graph,
+        ),
       );
       const paramValue = new ParameterValue();
       paramValue.name = expression.name;
@@ -338,7 +344,10 @@ export class ServiceTestSetupState {
       const varExpressions = this.queryVariableExpressions;
       const parameterValueStates = varExpressions
         .map((varExpression) => {
-          const mockValue = generateVariableExpressionMockValue(varExpression);
+          const mockValue = generateVariableExpressionMockValue(
+            varExpression,
+            this.editorStore.graphManagerState.graph,
+          );
           if (mockValue) {
             const paramValue = new ParameterValue();
             paramValue.name = varExpression.name;

package/src/stores/graphModifier/DSLExternalFormat_GraphModifierHelper.ts

@@ -55,6 +55,11 @@ export const externalFormat_schemaSet_setFormat = action(
     ss.format = value;
   },
 );
+export const externalFormat_schemaSet_setSchemas = action(
+  (ss: SchemaSet, value: ExternalFormatSchema[]): void => {
+    ss.schemas = value;
+  },
+);
 export const externalFormat_schemaSet_addSchema = action(
   (ss: SchemaSet, value: ExternalFormatSchema): void => {
     addUniqueEntry(ss.schemas, observe_ExternalFormatSchema(value));

package/src/stores/graphModifier/StoreRelational_GraphModifierHelper.ts

@@ -38,6 +38,7 @@ import {
   type StaticDatasourceSpecification,
   type UsernamePasswordAuthenticationStrategy,
   type GCPWorkloadIdentityFederationAuthenticationStrategy,
+  type MiddleTierUsernamePasswordAuthenticationStrategy,
   type ObserverContext,
   type EnumerationMappingReference,
   type TableAlias,
@@ -163,6 +164,15 @@ export const gcpWorkloadIdentityFederationAuthenticationStrategy_setAdditionalGc
     },
   );
 
+export const middleTierUsernamePasswordAuthenticationStrategy_setVaultReference =
+  action(
+    (
+      v: MiddleTierUsernamePasswordAuthenticationStrategy,
+      val: string,
+    ): void => {
+      v.vaultReference = val;
+    },
+  );
 // --------------------------------------------- DatasourceSpecification -------------------------------------
 export const staticDatasourceSpecification_setHost = action(
   (v: StaticDatasourceSpecification, val: string): void => {

package/src/stores/shared/testable/TestableUtils.ts

@@ -63,13 +63,14 @@ export const getAllIdentifiedConnectionsFromRuntime = (
 ): IdentifiedConnection[] => {
   const resolvedRuntimes: EngineRuntime[] = [];
   if (runtime instanceof RuntimePointer) {
-    const engineRuntime = runtime.packageableRuntime.value.runtimeValue;
-    resolvedRuntimes.push(engineRuntime);
+    resolvedRuntimes.push(runtime.packageableRuntime.value.runtimeValue);
   } else if (runtime instanceof EngineRuntime) {
     resolvedRuntimes.push(runtime);
   }
   return resolvedRuntimes
-    .flatMap((e) => e.connections.map((l) => l.storeConnections))
+    .flatMap((e) =>
+      e.connections.map((connection) => connection.storeConnections),
+    )
     .flat();
 };
 

package/tsconfig.json

@@ -72,7 +72,7 @@
     "./src/stores/editor-state/GenerationSpecificationEditorState.ts",
     "./src/stores/editor-state/GrammarTextEditorState.ts",
     "./src/stores/editor-state/GraphGenerationState.ts",
-    "./src/stores/editor-state/ModelLoaderState.ts",
+    "./src/stores/editor-state/ModelImporterState.ts",
     "./src/stores/editor-state/ProjectConfigurationEditorState.ts",
     "./src/stores/editor-state/UnsupportedElementEditorState.ts",
     "./src/stores/editor-state/element-editor-state/ClassEditorState.ts",
@@ -160,7 +160,7 @@
     "./src/components/editor/edit-panel/FunctionEditor.tsx",
     "./src/components/editor/edit-panel/GenerationSpecificationEditor.tsx",
     "./src/components/editor/edit-panel/GrammarTextEditor.tsx",
-    "./src/components/editor/edit-panel/ModelLoader.tsx",
+    "./src/components/editor/edit-panel/ModelImporter.tsx",
     "./src/components/editor/edit-panel/RuntimeEditor.tsx",
     "./src/components/editor/edit-panel/UnsupportedElementEditor.tsx",
     "./src/components/editor/edit-panel/connection-editor/ConnectionEditor.tsx",
@@ -179,6 +179,7 @@
     "./src/components/editor/edit-panel/external-format-editor/ExternalFormatConnectionEditor.tsx",
     "./src/components/editor/edit-panel/external-format-editor/NewSchemaSetDriver.tsx",
     "./src/components/editor/edit-panel/external-format-editor/SchemaSetElementEditor.tsx",
+    "./src/components/editor/edit-panel/external-format-editor/SchemaSetModelGenerationEditor.tsx",
     "./src/components/editor/edit-panel/mapping-editor/ClassMappingEditor.tsx",
     "./src/components/editor/edit-panel/mapping-editor/EnumerationMappingEditor.tsx",
     "./src/components/editor/edit-panel/mapping-editor/FlatDataPropertyMappingEditor.tsx",

package/lib/components/editor/edit-panel/ModelLoader.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"ModelLoader.d.ts","sourceRoot":"","sources":["../../../../src/components/editor/edit-panel/ModelLoader.tsx"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;;AA8BH,eAAO,MAAM,WAAW;;CAsNtB,CAAC"}

package/lib/components/editor/edit-panel/ModelLoader.js

@@ -1,95 +0,0 @@
-import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
-/**
- * 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 { observer } from 'mobx-react-lite';
-import { ModelLoaderState, MODEL_UPDATER_INPUT_TYPE, } from '../../../stores/editor-state/ModelLoaderState.js';
-import { prettyCONSTName } from '@finos/legend-shared';
-import { DropdownMenu, MenuContent, MenuContentItem, CaretDownIcon, CheckSquareIcon, TruckLoadingIcon, EmptySquareIcon, } from '@finos/legend-art';
-import { flowResult } from 'mobx';
-import { useEditorStore } from '../EditorStoreProvider.js';
-import { ActionAlertType, ActionAlertActionType, useApplicationStore, EDITOR_LANGUAGE, useApplicationNavigationContext, } from '@finos/legend-application';
-import { StudioTextInputEditor } from '../../shared/StudioTextInputEditor.js';
-import { LEGEND_STUDIO_APPLICATION_NAVIGATION_CONTEXT_KEY } from '../../../stores/LegendStudioApplicationNavigationContext.js';
-export const ModelLoader = observer(() => {
-    const editorStore = useEditorStore();
-    const applicationStore = useApplicationStore();
-    const modelLoaderState = editorStore.getCurrentEditorState(ModelLoaderState);
-    const nativeInputTypes = Object.values(MODEL_UPDATER_INPUT_TYPE);
-    const externalFormatInputTypes = modelLoaderState.modelImportDescriptions;
-    const extraModelLoaderExtensionsConfigs = modelLoaderState.modelLoaderExtensionConfigurations;
-    // input type
-    const currentModelLoadType = modelLoaderState.currentModelLoadType;
-    // replace flag
-    const replace = modelLoaderState.replace;
-    const toggleReplace = () => modelLoaderState.setReplaceFlag(!replace);
-    // actions
-    const loadCurrentProjectEntities = applicationStore.guardUnhandledError(() => flowResult(modelLoaderState.loadCurrentProjectEntities()));
-    const setCurrentInputType = (inputType) => () => {
-        modelLoaderState.setCurrentModelLoadType(inputType);
-    };
-    const loaderExtensionConfig = modelLoaderState.getLoaderExtensionConfiguration(currentModelLoadType);
-    const label = modelLoaderState.getImportConfigurationDescription(currentModelLoadType)
-        ?.label ??
-        loaderExtensionConfig?.label ??
-        loaderExtensionConfig?.key ??
-        currentModelLoadType;
-    const allowHardReplace = !loaderExtensionConfig || loaderExtensionConfig.allowHardReplace;
-    const isNativeInput = Object.values(MODEL_UPDATER_INPUT_TYPE).includes(currentModelLoadType);
-    const loadModel = () => {
-        if (loaderExtensionConfig) {
-            loaderExtensionConfig
-                .load(editorStore)
-                .catch(applicationStore.alertUnhandledError);
-        }
-        else if (editorStore.hasUnpushedChanges) {
-            editorStore.setActionAlertInfo({
-                message: 'You have unpushed changes',
-                prompt: 'This action will discard these changes and refresh the application',
-                type: ActionAlertType.CAUTION,
-                onEnter: () => editorStore.setBlockGlobalHotkeys(true),
-                onClose: () => editorStore.setBlockGlobalHotkeys(false),
-                actions: [
-                    {
-                        label: 'Proceed to load model',
-                        type: ActionAlertActionType.PROCEED_WITH_CAUTION,
-                        handler: () => {
-                            editorStore.setIgnoreNavigationBlocking(true);
-                            flowResult(modelLoaderState.loadModel()).catch(applicationStore.alertUnhandledError);
-                        },
-                    },
-                    {
-                        label: 'Abort',
-                        type: ActionAlertActionType.PROCEED,
-                        default: true,
-                    },
-                ],
-            });
-        }
-        else {
-            flowResult(modelLoaderState.loadModel()).catch(applicationStore.alertUnhandledError);
-        }
-    };
-    const updateModel = (val) => modelLoaderState.setModelText(val);
-    useApplicationNavigationContext(LEGEND_STUDIO_APPLICATION_NAVIGATION_CONTEXT_KEY.MODEL_LOADER);
-    return (_jsxs("div", { className: "panel model-loader", children: [_jsxs("div", { className: "panel__header model-loader__header", children: [_jsxs("div", { className: "model-loader__header__configs", children: [_jsx(DropdownMenu, { content: _jsxs(MenuContent, { className: "model-loader__header__configs__type__menu", children: [_jsxs("div", { className: "model-loader__header__configs__type-option__group model-loader__header__configs__type-option__group--native", children: [_jsx("div", { className: "model-loader__header__configs__type-option__group__name", children: "native" }), _jsx("div", { className: "model-loader__header__configs__type-option__group__options", children: nativeInputTypes.map((inputType) => (_jsx(MenuContentItem, { className: "model-loader__header__configs__type-option__group__option", onClick: setCurrentInputType(inputType), children: prettyCONSTName(inputType) }, inputType))) })] }), Boolean(externalFormatInputTypes) && (_jsxs(_Fragment, { children: [_jsx("div", { className: "model-loader__header__configs__type-option__group__separator" }), _jsxs("div", { className: "model-loader__header__configs__type-option__group model-loader__header__configs__type-option__group--external", children: [_jsx("div", { className: "model-loader__header__configs__type-option__group__name", children: "external" }), _jsx("div", { className: "model-loader__header__configs__type-option__group__options", children: externalFormatInputTypes.map((inputType) => (_jsx(MenuContentItem, { className: "model-loader__header__configs__type-option__group__option", onClick: setCurrentInputType(inputType.key), children: inputType.label }, inputType.key))) })] })] })), Boolean(extraModelLoaderExtensionsConfigs.length > 0) && (_jsxs(_Fragment, { children: [_jsx("div", { className: "model-loader__header__configs__type-option__group__separator" }), _jsxs("div", { className: "model-loader__header__configs__type-option__group model-loader__header__configs__type-option__group--extension", children: [_jsx("div", { className: "model-loader__header__configs__type-option__group__name", children: "extensions" }), _jsx("div", { className: "model-loader__header__configs__type-option__group__options", children: extraModelLoaderExtensionsConfigs.map((config) => (_jsx(MenuContentItem, { className: "model-loader__header__configs__type-option__group__option", onClick: setCurrentInputType(config.key), children: config.label ?? prettyCONSTName(config.key) }, config.key))) })] })] }))] }), menuProps: {
-                                    anchorOrigin: { vertical: 'bottom', horizontal: 'right' },
-                                    transformOrigin: { vertical: 'top', horizontal: 'right' },
-                                }, children: _jsxs("div", { className: "model-loader__header__configs__type", children: [_jsx("div", { className: "model-loader__header__configs__type__label", children: prettyCONSTName(label) }), _jsx("div", { className: "model-loader__header__configs__type__icon", children: _jsx(CaretDownIcon, {}) })] }) }), allowHardReplace && (_jsxs("div", { className: "model-loader__header__configs__edit-mode", onClick: toggleReplace, children: [_jsx("div", { className: "model-loader__header__configs__edit-mode__icon", children: replace ? _jsx(CheckSquareIcon, {}) : _jsx(EmptySquareIcon, {}) }), _jsx("div", { className: "model-loader__header__configs__edit-mode__label", children: "replace" })] })), isNativeInput && (_jsx("button", { className: "model-loader__header__configs__load-project-entities-btn", tabIndex: -1, onClick: loadCurrentProjectEntities, title: "Load current project entities", children: _jsx(TruckLoadingIcon, {}) }))] }), _jsx("div", { className: "model-loader__header__action", children: _jsx("button", { className: "btn--dark model-loader__header__load-btn", onClick: loadModel, disabled: modelLoaderState.isLoadingModel, tabIndex: -1, title: "Load model", children: "Load" }) })] }), _jsx("div", { className: "panel__content model-loader__editor", children: loaderExtensionConfig?.renderer(editorStore) ?? (_jsx(StudioTextInputEditor, { language: modelLoaderState.currentModelLoadType ===
-                        MODEL_UPDATER_INPUT_TYPE.PURE_GRAMMAR
-                        ? EDITOR_LANGUAGE.PURE
-                        : EDITOR_LANGUAGE.JSON, inputValue: modelLoaderState.modelText, updateInput: updateModel, showMiniMap: true })) })] }));
-});
-//# sourceMappingURL=ModelLoader.js.map

package/lib/components/editor/edit-panel/ModelLoader.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"ModelLoader.js","sourceRoot":"","sources":["../../../../src/components/editor/edit-panel/ModelLoader.tsx"],"names":[],"mappings":"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"}