@finos/legend-application-studio 26.0.1 → 26.0.3

package/src/stores/editor/editor-state/element-editor-state/ProtocolValueBuilderState.ts

@@ -0,0 +1,364 @@
+/**
+ * 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, makeObservable, observable } from 'mobx';
+import {
+  getAllClassProperties,
+  type Class,
+  type PureModel,
+  PrimitiveType,
+  PRIMITIVE_TYPE,
+  PROPERTY_ACCESSOR,
+  type Property,
+  classHasCycle,
+} from '@finos/legend-graph';
+import { isString, uuid, type PlainObject } from '@finos/legend-shared';
+import type { TreeData, TreeNodeData } from '@finos/legend-art';
+
+export abstract class ProtocolValueFieldNode implements TreeNodeData {
+  readonly id: string;
+  readonly label: string;
+  readonly builderState: ProtocolValueBuilderState;
+  readonly property: Property;
+  readonly propertyPath: string;
+  isOpen = true;
+  childrenIds: string[] = [];
+  childrenNodes: ProtocolValueFieldNode[] = [];
+
+  constructor(
+    id: string,
+    label: string,
+    builderState: ProtocolValueBuilderState,
+    property: Property,
+    propertyPath: string,
+  ) {
+    makeObservable(this, {
+      isOpen: observable,
+      setIsOpen: action,
+    });
+
+    this.id = id;
+    this.label = label;
+    this.builderState = builderState;
+    this.property = property;
+    this.propertyPath = propertyPath;
+  }
+
+  setIsOpen(val: boolean): void {
+    this.isOpen = val;
+  }
+
+  abstract getValue(): unknown;
+}
+
+export class StringFieldNode extends ProtocolValueFieldNode {
+  value: string;
+
+  constructor(
+    id: string,
+    label: string,
+    builderState: ProtocolValueBuilderState,
+    property: Property,
+    propertyPath: string,
+    initialValue: string,
+  ) {
+    super(id, label, builderState, property, propertyPath);
+
+    makeObservable(this, {
+      value: observable,
+      setValue: action,
+    });
+
+    this.value = initialValue;
+  }
+
+  setValue(val: string): void {
+    this.value = val;
+
+    this.builderState.onValueChange?.(this.builderState.getValue());
+  }
+
+  getValue(): string {
+    return this.value;
+  }
+}
+
+export class OptionalStringFieldNode extends ProtocolValueFieldNode {
+  value: string | undefined;
+
+  constructor(
+    id: string,
+    label: string,
+    builderState: ProtocolValueBuilderState,
+    property: Property,
+    propertyPath: string,
+    initialValue: string | undefined,
+  ) {
+    super(id, label, builderState, property, propertyPath);
+
+    makeObservable(this, {
+      value: observable,
+      setValue: action,
+    });
+
+    this.value = initialValue;
+  }
+
+  setValue(val: string | undefined): void {
+    this.value = val;
+
+    this.builderState.onValueChange?.(this.builderState.getValue());
+  }
+
+  getValue(): string | undefined {
+    return this.value;
+  }
+}
+
+export class UnsupportedFieldNode extends ProtocolValueFieldNode {
+  readonly value: unknown; // we will not support editing unknown value
+
+  constructor(
+    id: string,
+    label: string,
+    builderState: ProtocolValueBuilderState,
+    property: Property,
+    propertyPath: string,
+    initialValue: unknown,
+  ) {
+    super(id, label, builderState, property, propertyPath);
+
+    this.value = initialValue;
+  }
+
+  getValue(): unknown {
+    return this.value;
+  }
+}
+
+export class ProtocolValueBuilderState {
+  readonly type: Class;
+  readonly isCyclic: boolean;
+  readonly graph: PureModel;
+  readonly excludedPaths: Map<string, string[]>;
+  readonly initialValue: PlainObject;
+  readonly onValueChange?: ((value: PlainObject) => void) | undefined;
+  readonly decorateValue?: ((value: PlainObject) => PlainObject) | undefined;
+
+  treeData: TreeData<ProtocolValueFieldNode> | undefined;
+
+  constructor(
+    type: Class,
+    options: {
+      graph: PureModel;
+      initialValue: PlainObject | undefined;
+      excludedPaths: string[];
+      onValueChange?: ((value: PlainObject) => void) | undefined;
+      decorateValue?: ((value: PlainObject) => PlainObject) | undefined;
+    },
+  ) {
+    makeObservable(this, { treeData: observable.ref });
+
+    this.type = type;
+    this.graph = options.graph;
+    this.onValueChange = options.onValueChange;
+    this.decorateValue = options.decorateValue;
+
+    this.excludedPaths = new Map<string, string[]>();
+    options.excludedPaths.forEach((path) => {
+      const idx = path.indexOf(PROPERTY_ACCESSOR);
+      if (idx === -1) {
+        return;
+      }
+      const classPath = path.substring(0, idx);
+      const propertyName = path.substring(idx + 1);
+      if (!this.excludedPaths.has(classPath)) {
+        this.excludedPaths.set(classPath, [propertyName]);
+      } else {
+        this.excludedPaths.get(classPath)?.push(propertyName);
+      }
+    });
+
+    this.isCyclic = classHasCycle(type, {
+      traverseNonRequiredProperties: true,
+      excludedPaths: this.excludedPaths,
+    });
+    this.initialValue =
+      options.initialValue ??
+      (this.isCyclic ? {} : this.generateInitialValue(type));
+    this.treeData = this.isCyclic ? undefined : this.buildTreeData(type);
+  }
+
+  buildTreeData(type: Class): TreeData<ProtocolValueFieldNode> {
+    const rootIds: string[] = [];
+    const nodes = new Map<string, ProtocolValueFieldNode>();
+
+    getAllClassProperties(type).forEach((property) => {
+      // filter properties
+      const propertyOwnerPath = property._OWNER.path;
+      const excludedProperties =
+        this.excludedPaths.get(propertyOwnerPath) ?? [];
+      if (excludedProperties.includes(property.name)) {
+        return;
+      }
+
+      const propertyType = property.genericType.value.rawType;
+      const multiplicity = property.multiplicity;
+
+      const childNodeValue = this.initialValue[property.name];
+      const childNodeId = uuid();
+      let childNode: ProtocolValueFieldNode;
+
+      if (!(propertyType instanceof PrimitiveType)) {
+        childNode = new UnsupportedFieldNode(
+          uuid(),
+          '',
+          this,
+          property,
+          property.name,
+          childNodeValue,
+        );
+      } else {
+        switch (propertyType.name) {
+          case PRIMITIVE_TYPE.STRING: {
+            if (multiplicity.lowerBound === 0) {
+              childNode = new OptionalStringFieldNode(
+                childNodeId,
+                '',
+                this,
+                property,
+                property.name,
+                childNodeValue === undefined
+                  ? undefined
+                  : isString(childNodeValue)
+                  ? childNodeValue
+                  : '',
+              );
+            } else if (multiplicity.upperBound === 1) {
+              childNode = new StringFieldNode(
+                childNodeId,
+                '',
+                this,
+                property,
+                property.name,
+                isString(childNodeValue) ? childNodeValue : '',
+              );
+            } else {
+              childNode = new UnsupportedFieldNode(
+                childNodeId,
+                '',
+                this,
+                property,
+                property.name,
+                childNodeValue,
+              );
+            }
+            break;
+          }
+          default: {
+            childNode = new UnsupportedFieldNode(
+              childNodeId,
+              '',
+              this,
+              property,
+              property.name,
+              childNodeValue,
+            );
+            break;
+          }
+        }
+      }
+      nodes.set(childNodeId, childNode);
+    });
+
+    nodes.forEach((node) => {
+      rootIds.push(node.id);
+    });
+
+    return { rootIds, nodes };
+  }
+
+  private generateInitialValue(type: Class): PlainObject {
+    const value: PlainObject = {};
+    const excludedProperties = this.excludedPaths.get(type.path) ?? [];
+    getAllClassProperties(type)
+      .filter((property) => !excludedProperties.includes(property.name))
+      .forEach((property) => {
+        // NOTE: for now, we only handle very basic properties: i.e. primitive property (except Date) with multiplicity [0..1] or [1]
+        // we have not handled list of primitives, enumeration type, list of enumeration values, complex type
+        //
+        // Note that subtype is something we need to think very carefully about: displaying subtype in the form is not necessarily hard
+        // as we can draw a selector dropdown for the type, but in terms of actually generate the right protocol value, it depends on the
+        // use case and that could add complexity, for example, if we use this to generate Pure protocol, we would need the information
+        // for _type flag for subtype
+        const propertyType = property.genericType.value.rawType;
+        const multiplicity = property.multiplicity;
+        if (
+          !(propertyType instanceof PrimitiveType) ||
+          (multiplicity.upperBound && multiplicity.upperBound > 1)
+        ) {
+          return;
+        }
+        if (multiplicity.lowerBound === 0) {
+          value[property.name] = undefined;
+        } else {
+          switch (propertyType.name) {
+            case PRIMITIVE_TYPE.BOOLEAN: {
+              value[property.name] = false;
+              break;
+            }
+            case PRIMITIVE_TYPE.FLOAT:
+            case PRIMITIVE_TYPE.DECIMAL: {
+              value[property.name] = 0.0;
+              break;
+            }
+            case PRIMITIVE_TYPE.NUMBER:
+            case PRIMITIVE_TYPE.INTEGER: {
+              value[property.name] = 0;
+              break;
+            }
+            case PRIMITIVE_TYPE.STRING: {
+              value[property.name] = '';
+              break;
+            }
+            case PRIMITIVE_TYPE.DATE:
+            case PRIMITIVE_TYPE.STRICTDATE:
+            case PRIMITIVE_TYPE.DATETIME:
+            default:
+              return; // unsupported
+          }
+        }
+      });
+
+    return value;
+  }
+
+  getValue(): PlainObject {
+    if (!this.treeData) {
+      return {};
+    }
+
+    const value: PlainObject = {};
+    this.treeData.rootIds.forEach((rootId) => {
+      const node = this.treeData?.nodes.get(rootId);
+      if (node) {
+        value[node.property.name] = node.getValue();
+      }
+    });
+
+    return this.decorateValue ? this.decorateValue(value) : value;
+  }
+}

package/src/stores/editor/editor-state/element-editor-state/connection/ConnectionEditorState.ts

@@ -62,6 +62,7 @@ import type { DSL_Mapping_LegendStudioApplicationPlugin_Extension } from '../../
 import {
   relationDbConnection_setNewAuthenticationStrategy,
   relationDbConnection_setDatasourceSpecification,
+  relationDbConnection_setLocalMode,
 } from '../../../../graph-modifier/STO_Relational_GraphModifierHelper.js';
 import {
   MapperPostProcessorEditorState,
@@ -117,6 +118,7 @@ export enum CORE_AUTHENTICATION_STRATEGY_TYPE {
 
 export class RelationalDatabaseConnectionValueState extends ConnectionValueState {
   override connection: RelationalDatabaseConnection;
+  localMode = false;
   selectedTab = RELATIONAL_DATABASE_TAB_TYPE.GENERAL;
   postProcessorState: PostProcessorEditorState | undefined;
 
@@ -126,10 +128,12 @@ export class RelationalDatabaseConnectionValueState extends ConnectionValueState
   ) {
     super(editorStore, connection);
     makeObservable(this, {
+      localMode: observable,
       selectedTab: observable,
       postProcessorState: observable,
       selectedDatasourceSpecificationType: computed,
       selectedAuthenticationStrategyType: computed,
+      setLocalMode: action,
       setSelectedTab: action,
       selectPostProcessor: action,
     });
@@ -176,6 +180,10 @@ export class RelationalDatabaseConnectionValueState extends ConnectionValueState
     this.selectedTab = val;
   }
 
+  setLocalMode(val: boolean): void {
+    this.localMode = val;
+  }
+
   label(): string {
     return `${this.connection.type} connection`;
   }
@@ -300,6 +308,10 @@ export class RelationalDatabaseConnectionValueState extends ConnectionValueState
       dataSpec,
       observerContext,
     );
+    relationDbConnection_setLocalMode(
+      this.connection,
+      this.connection.localMode,
+    );
   }
 
   get selectedAuthenticationStrategyType(): string | undefined {

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

@@ -20,7 +20,6 @@ import {
   type PlainObject,
   assertErrorThrown,
   guaranteeType,
-  ActionState,
 } from '@finos/legend-shared';
 import type { EditorStore } from '../../../EditorStore.js';
 import {
@@ -51,52 +50,6 @@ export enum SERVICE_TAB {
   TEST = 'TEST',
   REGISTRATION = 'REGISTRATION',
   POST_VALIDATION = 'POST_VALIDATION',
-  TEMPORARY__SNOWFLAKE_SERVICE_DEPLOYMENT = 'SNOWFLAKE_DEPLOYMENT',
-}
-
-class TEMPORARY__SnowflakeServiceRegistrationState {
-  readonly editorStore: EditorStore;
-  readonly service: Service;
-  readonly deploymentState = ActionState.create();
-
-  result?: PlainObject | undefined;
-
-  constructor(editorStore: EditorStore, service: Service) {
-    makeObservable(this, {
-      result: observable,
-      deploy: flow,
-    });
-
-    this.editorStore = editorStore;
-    this.service = service;
-  }
-
-  *deploy(): GeneratorFn<void> {
-    const deploymentUrl =
-      this.editorStore.applicationStore.config
-        .TEMPORARY__snowflakeServiceDeploymentUrl;
-
-    if (!deploymentUrl) {
-      this.editorStore.applicationStore.notificationService.notifyWarning(
-        `Can't deploy Snowflake service: deployment URL is not configured`,
-      );
-      return;
-    }
-
-    try {
-      this.deploymentState.inProgress();
-      this.result =
-        (yield this.editorStore.graphManagerState.graphManager.TEMPORARY__deploySnowflakeService(
-          (this.service.execution as PureExecution).func,
-          this.editorStore.graphManagerState.graph,
-        )) as PlainObject;
-    } catch (error) {
-      assertErrorThrown(error);
-      this.editorStore.applicationStore.notificationService.notifyError(error);
-    } finally {
-      this.deploymentState.reset();
-    }
-  }
 }
 
 export const MINIMUM_SERVICE_OWNERS = 2;
@@ -106,7 +59,6 @@ export class ServiceEditorState extends ElementEditorState {
   testableState: ServiceTestableState;
   selectedTab: SERVICE_TAB;
   postValidationState: ServicePostValidationsState;
-  TEMPORARY__snowflakeServiceRegistrationState: TEMPORARY__SnowflakeServiceRegistrationState;
 
   constructor(editorStore: EditorStore, element: PackageableElement) {
     super(editorStore, element);
@@ -140,11 +92,6 @@ export class ServiceEditorState extends ElementEditorState {
         ? SERVICE_TAB.EXECUTION
         : SERVICE_TAB.GENERAL;
     this.postValidationState = new ServicePostValidationsState(this);
-    this.TEMPORARY__snowflakeServiceRegistrationState =
-      new TEMPORARY__SnowflakeServiceRegistrationState(
-        this.editorStore,
-        this.service,
-      );
   }
 
   setSelectedTab(tab: SERVICE_TAB): void {

package/src/stores/editor/utils/MockDataUtils.ts

@@ -31,6 +31,7 @@ import {
   getAllClassProperties,
   DATE_FORMAT,
   DATE_TIME_FORMAT,
+  classHasCycle,
 } from '@finos/legend-graph';
 import {
   CLASS_PROPERTY_TYPE,
@@ -132,38 +133,14 @@ export const createMockClassInstance = (
   return mockData;
 };
 
-export const classHasCycle = (
-  _class: Class,
-  traverseNonRequiredProperties: boolean,
-  classesIndex: Set<string>,
-): boolean => {
-  if (classesIndex.has(_class.path)) {
-    return true;
-  }
-  const properties = traverseNonRequiredProperties
-    ? getAllClassProperties(_class)
-    : getAllClassProperties(_class).filter((p) => p.multiplicity.lowerBound);
-  const complexProperties = properties
-    .map((property) => property.genericType.value.rawType)
-    .filter((c) => getClassPropertyType(c) === CLASS_PROPERTY_TYPE.CLASS);
-  if (complexProperties.length > 0) {
-    // we only count classes with complex properties in the cycle. Example an address class with all primitive should not tigger a class to be cycled
-    classesIndex.add(_class.path);
-  }
-  // we only check unique complex property classes; 2 same property classes on the same level do not count as a cycle
-  return Boolean(
-    Array.from(new Set(complexProperties)).find((c) =>
-      classHasCycle(c as Class, traverseNonRequiredProperties, classesIndex),
-    ),
-  );
-};
-
 export const createMockDataForClass = (
   element: Class,
   maxDepth = 100,
   depthForCycle = 3,
 ): PlainObject => {
-  const depth = classHasCycle(element, true, new Set<string>())
+  const depth = classHasCycle(element, {
+    traverseNonRequiredProperties: true,
+  })
     ? Math.max(depthForCycle, 0)
     : Math.max(maxDepth, 0);
   return createMockClassInstance(element, true, depth);
@@ -181,7 +158,9 @@ export const createMockDataForClassWithFormat = (
   maxDepth = 100,
   depthForCycle = 3,
 ): string => {
-  const depth = classHasCycle(element, true, new Set<string>())
+  const depth = classHasCycle(element, {
+    traverseNonRequiredProperties: true,
+  })
     ? Math.max(depthForCycle, 0)
     : Math.max(maxDepth, 0);
   const obj = createMockClassInstance(element, true, depth);

package/src/stores/editor/utils/PackageTreeUtils.ts

@@ -117,7 +117,7 @@ export const generatePackageableElementTreeNodeDataLabel = (
   element: PackageableElement,
 ): string =>
   element instanceof ConcreteFunctionDefinition
-    ? generateFunctionPrettyName(element, false)
+    ? generateFunctionPrettyName(element)
     : element.name;
 
 export const getPackableElementTreeNodeData = (

package/src/stores/graph-modifier/DomainGraphModifierHelper.ts

@@ -20,6 +20,7 @@ import {
   deleteEntry,
   guaranteeType,
   swapEntry,
+  type PlainObject,
 } from '@finos/legend-shared';
 import { action } from 'mobx';
 import {
@@ -65,9 +66,10 @@ import {
   observe_RawLambda,
   isStubbed_PackageableElement,
   getOtherAssociatedProperty,
+  type INTERNAL__UnknownFunctionActivator,
 } from '@finos/legend-graph';
 
-// --------------------------------------------- PackageableElementReference -------------------------------------
+// --------------------------------------------- Packageable Element -------------------------------------
 
 export const packageableElementReference_setValue = action(
   <T extends PackageableElement>(
@@ -375,6 +377,12 @@ export const function_swapParameters = action(
   },
 );
 
+export const INTERNAL__UnknownFunctionActivator_setContent = action(
+  (metamodel: INTERNAL__UnknownFunctionActivator, val: PlainObject) => {
+    metamodel.content = val;
+  },
+);
+
 // --------------------------------------------- Enumeration -------------------------------------
 
 export const enum_setName = action((val: Enum, value: string): void => {

package/src/stores/graph-modifier/STO_Relational_GraphModifierHelper.ts

@@ -76,6 +76,12 @@ export const dBConnection_setQuoteIdentifiers = action(
   },
 );
 
+export const relationDbConnection_setLocalMode = action(
+  (con: RelationalDatabaseConnection, val: boolean | undefined): void => {
+    con.localMode = val;
+  },
+);
+
 export const relationDbConnection_setDatasourceSpecification = action(
   (
     con: RelationalDatabaseConnection,

package/src/stores/project-view/ProjectViewerStore.ts

@@ -435,13 +435,13 @@ export class ProjectViewerStore {
         graphBuilderReportData,
       );
 
-      // fetch available file generation descriptions
-      yield flowResult(
+      // fetch available editor configurations
+      yield Promise.all([
         this.editorStore.graphState.graphGenerationState.fetchAvailableFileGenerationDescriptions(),
-      );
-      yield flowResult(
-        this.editorStore.graphState.graphGenerationState.externalFormatState.fetchExternalFormatsDescriptions(),
-      );
+        this.editorStore.graphState.graphGenerationState.externalFormatState.fetchExternalFormatDescriptions(),
+        this.editorStore.graphState.graphGenerationState.externalFormatState.fetchExternalFormatDescriptions(),
+        this.editorStore.graphState.fetchAvailableFunctionActivatorConfigurations(),
+      ]);
 
       return true;
     } catch (error) {

package/tsconfig.json

@@ -85,7 +85,10 @@
     "./src/stores/editor/editor-state/element-editor-state/ElementExternalFormatGenerationState.ts",
     "./src/stores/editor/editor-state/element-editor-state/ElementFileGenerationState.ts",
     "./src/stores/editor/editor-state/element-editor-state/FileGenerationEditorState.ts",
+    "./src/stores/editor/editor-state/element-editor-state/FunctionActivatorBuilderState.ts",
     "./src/stores/editor/editor-state/element-editor-state/FunctionEditorState.ts",
+    "./src/stores/editor/editor-state/element-editor-state/INTERNAL__UnknownFunctionActivatorEditorState.ts",
+    "./src/stores/editor/editor-state/element-editor-state/ProtocolValueBuilderState.ts",
     "./src/stores/editor/editor-state/element-editor-state/RuntimeEditorState.ts",
     "./src/stores/editor/editor-state/element-editor-state/UMLEditorState.ts",
     "./src/stores/editor/editor-state/element-editor-state/connection/ConnectionEditorState.ts",
@@ -173,13 +176,14 @@
     "./src/components/editor/StatusBar.tsx",
     "./src/components/editor/__test-utils__/EditorComponentTestUtils.tsx",
     "./src/components/editor/command-center/ProjectSearchCommand.tsx",
-    "./src/components/editor/edit-panel/mapping-editor/testable/MappingTestableEditor.tsx",
     "./src/components/editor/editor-group/EditorGroup.tsx",
     "./src/components/editor/editor-group/FileGenerationViewer.tsx",
     "./src/components/editor/editor-group/FunctionEditor.tsx",
     "./src/components/editor/editor-group/GenerationSpecificationEditor.tsx",
     "./src/components/editor/editor-group/GrammarTextEditor.tsx",
+    "./src/components/editor/editor-group/INTERNAL__UnknownFunctionActivatorEdtior.tsx",
     "./src/components/editor/editor-group/ModelImporter.tsx",
+    "./src/components/editor/editor-group/ProtocolValueBuilder.tsx",
     "./src/components/editor/editor-group/RuntimeEditor.tsx",
     "./src/components/editor/editor-group/UnsupportedElementEditor.tsx",
     "./src/components/editor/editor-group/connection-editor/ConnectionEditor.tsx",
@@ -214,6 +218,7 @@
     "./src/components/editor/editor-group/mapping-editor/MappingExecutionBuilder.tsx",
     "./src/components/editor/editor-group/mapping-editor/MappingExecutionQueryBuilder.tsx",
     "./src/components/editor/editor-group/mapping-editor/MappingExplorer.tsx",
+    "./src/components/editor/editor-group/mapping-editor/MappingTestableEditor.tsx",
     "./src/components/editor/editor-group/mapping-editor/MappingTestsExplorer.tsx",
     "./src/components/editor/editor-group/mapping-editor/NewMappingElementModal.tsx",
     "./src/components/editor/editor-group/mapping-editor/OperationSetImplementationEditor.tsx",
@@ -231,7 +236,6 @@
     "./src/components/editor/editor-group/service-editor/ServiceExecutionQueryEditor.tsx",
     "./src/components/editor/editor-group/service-editor/ServicePostValidationEditor.tsx",
     "./src/components/editor/editor-group/service-editor/ServiceRegistrationEditor.tsx",
-    "./src/components/editor/editor-group/service-editor/TEMPORARY__SnowflakeServiceDeployer.tsx",
     "./src/components/editor/editor-group/service-editor/testable/ServiceTestDataEditor.tsx",
     "./src/components/editor/editor-group/service-editor/testable/ServiceTestableEditor.tsx",
     "./src/components/editor/editor-group/service-editor/testable/ServiceTestsEditor.tsx",

package/lib/components/editor/edit-panel/mapping-editor/testable/MappingTestableEditor.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"MappingTestableEditor.d.ts","sourceRoot":"","sources":["../../../../../../src/components/editor/edit-panel/mapping-editor/testable/MappingTestableEditor.tsx"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AA6DH,OAAO,EAEL,KAAK,oBAAoB,EAU1B,MAAM,yGAAyG,CAAC;AAo6CjH,eAAO,MAAM,qBAAqB,WACxB;IAAE,oBAAoB,EAAE,oBAAoB,CAAA;CAAE;;CA6IvD,CAAC"}