@finos/legend-application 8.0.2 → 9.0.1

package/src/components/shared/LambdaParameterValuesEditor.tsx

@@ -1,118 +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 { Dialog } from '@finos/legend-art';
-import {
-  type PureModel,
-  type ValueSpecification,
-  PRIMITIVE_TYPE,
-} from '@finos/legend-graph';
-import { prettyCONSTName } from '@finos/legend-shared';
-import { observer } from 'mobx-react-lite';
-import type { LambdaParametersState } from '../../stores/shared/LambdaParameterState.js';
-import { useApplicationStore } from '../ApplicationStoreProvider.js';
-import { BasicValueSpecificationEditor } from './BasicValueSpecificationEditor.js';
-
-// TODO we may want to further componentize this by removing the dialog wrapper
-export const LambdaParameterValuesEditor = observer(
-  (props: {
-    graph: PureModel;
-    lambdaParametersState: LambdaParametersState;
-  }) => {
-    const { lambdaParametersState, graph } = props;
-    const valuesEdtiorState = lambdaParametersState.parameterValuesEditorState;
-    const close = (): void => valuesEdtiorState.close();
-    const applicationStore = useApplicationStore();
-    const submitAction = valuesEdtiorState.submitAction;
-    const submit = applicationStore.guardUnhandledError(async () => {
-      if (submitAction) {
-        close();
-        await submitAction.handler();
-      }
-    });
-    return (
-      <Dialog
-        open={Boolean(valuesEdtiorState.showModal)}
-        onClose={close}
-        classes={{
-          root: 'editor-modal__root-container',
-          container: 'editor-modal__container',
-          paper: 'editor-modal__content',
-        }}
-      >
-        <div className="modal modal--dark editor-modal lambda-parameter-values__modal">
-          <div className="modal__header">
-            <div className="modal__title">Set Parameter Values</div>
-          </div>
-          <div className="modal__body lambda-parameter-values__modal__body">
-            {lambdaParametersState.parameterStates.map((paramState) => {
-              const stringType = graph.getPrimitiveType(PRIMITIVE_TYPE.STRING);
-              const variableType = paramState.variableType ?? stringType;
-              return (
-                <div
-                  key={paramState.uuid}
-                  className="panel__content__form__section"
-                >
-                  <div className="lambda-parameter-values__value__label">
-                    <div className="lambda-parameter-values__value__label__name">
-                      {paramState.parameter.name}
-                    </div>
-                    <div className="lambda-parameter-values__value__label__type">
-                      {variableType.name}
-                    </div>
-                  </div>
-                  {paramState.value && (
-                    <BasicValueSpecificationEditor
-                      valueSpecification={paramState.value}
-                      setValueSpecification={(
-                        val: ValueSpecification,
-                      ): void => {
-                        paramState.setValue(val);
-                      }}
-                      graph={graph}
-                      typeCheckOption={{
-                        expectedType: variableType,
-                        match:
-                          variableType ===
-                          graph.getPrimitiveType(PRIMITIVE_TYPE.DATETIME),
-                      }}
-                      className="query-builder__parameters__value__editor"
-                      resetValue={(): void => paramState.mockParameterValue()}
-                    />
-                  )}
-                </div>
-              );
-            })}
-          </div>
-          <div className="modal__footer">
-            {submitAction && (
-              <button
-                className="btn modal__footer__close-btn"
-                title={submitAction.label}
-                onClick={submit}
-              >
-                {prettyCONSTName(submitAction.label)}
-              </button>
-            )}
-            <button className="btn modal__footer__close-btn" onClick={close}>
-              Close
-            </button>
-          </div>
-        </div>
-      </Dialog>
-    );
-  },
-);

package/src/stores/CJS__Fuse.cts

@@ -1,28 +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.
- */
-
-/**
- * Previously, these exports rely on ES module interop to expose `default` export
- * properly. But since we use `ESM` for Typescript resolution now, we lose this
- * so we have to workaround by importing these and re-export them from CJS
- *
- * TODO: remove these when the package properly work with Typescript's nodenext
- * module resolution
- *
- * @workaround ESM
- * See https://github.com/microsoft/TypeScript/issues/49298
- */
-export { default as Fuse } from 'fuse.js';

package/src/stores/shared/LambdaEditorState.ts

@@ -1,118 +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 { observable, action, computed, makeObservable, flow } from 'mobx';
-import { type GeneratorFn, uuid } from '@finos/legend-shared';
-import {
-  type ParserError,
-  type CompilationError,
-  SourceInformation,
-} from '@finos/legend-graph';
-
-/**
- * This is not strictly meant for lambda. The idea is to create an editor that allows
- * editing _something_ but allows user to edit via text.
- */
-export abstract class LambdaEditorState {
-  readonly uuid = uuid();
-  lambdaPrefix: string;
-  lambdaString: string; // value shown in lambda editor which can be edited
-  parserError?: ParserError | undefined;
-  compilationError?: CompilationError | undefined;
-
-  constructor(lambdaString: string, lambdaPrefix: string) {
-    makeObservable(this, {
-      lambdaString: observable,
-      parserError: observable,
-      compilationError: observable,
-      lambdaId: computed,
-      fullLambdaString: computed,
-      setLambdaString: action,
-      clearErrors: action,
-      setCompilationError: action,
-      setParserError: action,
-      convertLambdaGrammarStringToObject: flow,
-      convertLambdaObjectToGrammarString: flow,
-    });
-
-    this.lambdaString = lambdaString;
-    this.lambdaPrefix = lambdaPrefix;
-  }
-
-  abstract get lambdaId(): string;
-
-  // value shown in lambda editor with the prefix, used to send to the server to transformation from text to JSON
-  get fullLambdaString(): string {
-    return `${this.lambdaPrefix}${this.lambdaString}`;
-  }
-
-  setLambdaString(val: string): void {
-    this.lambdaString = val;
-  }
-
-  clearErrors(): void {
-    this.setCompilationError(undefined);
-    this.setParserError(undefined);
-  }
-
-  setCompilationError(compilationError: CompilationError | undefined): void {
-    // account for the lambda prefix offset in source information
-    if (compilationError?.sourceInformation) {
-      compilationError.sourceInformation = this.processSourceInformation(
-        compilationError.sourceInformation,
-      );
-    }
-    this.compilationError = compilationError;
-  }
-
-  setParserError(parserError: ParserError | undefined): void {
-    // account for the lambda prefix offset in source information
-    if (parserError?.sourceInformation) {
-      parserError.sourceInformation = this.processSourceInformation(
-        parserError.sourceInformation,
-      );
-    }
-    this.parserError = parserError;
-  }
-
-  processSourceInformation(
-    sourceInformation: SourceInformation,
-  ): SourceInformation {
-    const { sourceId, startLine, startColumn, endLine, endColumn } =
-      sourceInformation;
-    const lineOffset = 0;
-    const columnOffset = this.lambdaPrefix.length;
-    return new SourceInformation(
-      sourceId,
-      startLine + lineOffset,
-      startColumn - (startLine === 1 ? columnOffset : 0),
-      endLine + lineOffset,
-      endColumn - (endLine === 1 ? columnOffset : 0),
-    );
-  }
-
-  extractLambdaString(fullLambdaString: string): string {
-    return fullLambdaString.substring(
-      fullLambdaString.indexOf(this.lambdaPrefix) + this.lambdaPrefix.length,
-      fullLambdaString.length,
-    );
-  }
-
-  abstract convertLambdaGrammarStringToObject(): GeneratorFn<void>;
-  abstract convertLambdaObjectToGrammarString(
-    pretty: boolean,
-  ): GeneratorFn<void>;
-}

package/src/stores/shared/LambdaParameterState.ts

@@ -1,253 +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 {
-  type ObserverContext,
-  type Type,
-  type ValueSpecification,
-  type PureModel,
-  GenericType,
-  GenericTypeExplicitReference,
-  observe_ValueSpecification,
-  observe_VariableExpression,
-  PrimitiveInstanceValue,
-  PRIMITIVE_TYPE,
-  VariableExpression,
-  LambdaFunction,
-  TYPICAL_MULTIPLICITY_TYPE,
-  CORE_PURE_PATH,
-  FunctionType,
-  SimpleFunctionExpression,
-  SUPPORTED_FUNCTIONS,
-  extractElementNameFromPath,
-  generateVariableExpressionMockValue,
-} from '@finos/legend-graph';
-import {
-  addUniqueEntry,
-  deleteEntry,
-  type Hashable,
-  hashArray,
-  IllegalStateError,
-  isNonNullable,
-  uuid,
-} from '@finos/legend-shared';
-import { makeObservable, observable, action, computed } from 'mobx';
-import {
-  genericType_setRawType,
-  multiplicity_setLowerBound,
-  multiplicity_setUpperBound,
-} from './ValueSpecificationModifierHelper.js';
-
-export enum PARAMETER_SUBMIT_ACTION {
-  EXECUTE = 'EXECUTE',
-  EXPORT = 'EXPORT',
-}
-
-enum LAMABA_PARAMETER_HASH_STRUCTURE {
-  LAMBDA_PARAMETER_STATE = 'LAMBDA_PARAMETER_STATE',
-  LAMBDA_PARAMETERS_STATE = 'LAMBDA_PARAMETERS_STATE',
-}
-
-export const buildParametersLetLambdaFunc = (
-  graph: PureModel,
-  lambdaParametersStates: LambdaParameterState[],
-): LambdaFunction => {
-  const multiplicityOne = graph.getTypicalMultiplicity(
-    TYPICAL_MULTIPLICITY_TYPE.ONE,
-  );
-  const typeString = graph.getPrimitiveType(PRIMITIVE_TYPE.STRING);
-  const typeAny = graph.getType(CORE_PURE_PATH.ANY);
-  const letlambdaFunction = new LambdaFunction(
-    new FunctionType(typeAny, multiplicityOne),
-  );
-  letlambdaFunction.expressionSequence = lambdaParametersStates
-    .map((queryParamState) => {
-      if (queryParamState.value) {
-        const letFunc = new SimpleFunctionExpression(
-          extractElementNameFromPath(SUPPORTED_FUNCTIONS.LET),
-          multiplicityOne,
-        );
-        const letVar = new PrimitiveInstanceValue(
-          GenericTypeExplicitReference.create(new GenericType(typeString)),
-          multiplicityOne,
-        );
-        letVar.values = [queryParamState.variableName];
-        letFunc.parametersValues.push(letVar);
-        letFunc.parametersValues.push(queryParamState.value);
-        return letFunc;
-      }
-      return undefined;
-    })
-    .filter(isNonNullable);
-  return letlambdaFunction;
-};
-
-export class LambdaParameterState implements Hashable {
-  readonly uuid = uuid();
-  readonly parameter: VariableExpression;
-  readonly graph: PureModel;
-  readonly observableContext: ObserverContext;
-
-  value: ValueSpecification | undefined;
-
-  constructor(
-    variableExpression: VariableExpression,
-    observableContext: ObserverContext,
-    graph: PureModel,
-  ) {
-    makeObservable(this, {
-      value: observable,
-      setValue: action,
-      mockParameterValue: action,
-      hashCode: computed,
-    });
-    this.observableContext = observableContext;
-    this.parameter = observe_VariableExpression(variableExpression);
-    this.graph = graph;
-  }
-
-  get hashCode(): string {
-    return hashArray([
-      LAMABA_PARAMETER_HASH_STRUCTURE.LAMBDA_PARAMETER_STATE,
-      this.parameter,
-    ]);
-  }
-
-  mockParameterValue(): void {
-    this.setValue(
-      generateVariableExpressionMockValue(this.parameter, this.graph),
-    );
-  }
-
-  setValue(value: ValueSpecification | undefined): void {
-    if (value instanceof VariableExpression) {
-      throw new IllegalStateError(
-        'Can not assign a parameter to another parameter',
-      );
-    }
-    this.value = value
-      ? observe_ValueSpecification(value, this.observableContext)
-      : undefined;
-  }
-
-  changeVariableType(type: Type): void {
-    if (type !== this.variableType) {
-      const genricType = this.parameter.genericType?.value;
-      if (genricType) {
-        genericType_setRawType(genricType, type);
-      }
-      this.mockParameterValue();
-    }
-  }
-
-  changeMultiplicity(
-    lowerBound: number,
-    uppderBound: number | undefined,
-  ): void {
-    const current = this.parameter.multiplicity;
-    if (
-      current.lowerBound !== lowerBound ||
-      current.upperBound !== uppderBound
-    ) {
-      multiplicity_setLowerBound(current, lowerBound);
-      multiplicity_setUpperBound(current, uppderBound);
-      this.mockParameterValue();
-    }
-  }
-
-  get variableName(): string {
-    return this.parameter.name;
-  }
-
-  get variableType(): Type | undefined {
-    return this.parameter.genericType?.value.rawType;
-  }
-}
-
-export class ParameterInstanceValuesEditorState {
-  showModal = false;
-  submitAction:
-    | {
-        handler: () => Promise<void>;
-        label: string;
-      }
-    | undefined;
-
-  constructor() {
-    makeObservable(this, {
-      showModal: observable,
-      submitAction: observable,
-      setShowModal: action,
-      open: action,
-      setSubmitAction: action,
-    });
-  }
-
-  setShowModal(val: boolean): void {
-    this.showModal = val;
-  }
-
-  setSubmitAction(
-    val:
-      | {
-          handler: () => Promise<void>;
-          label: string;
-        }
-      | undefined,
-  ): void {
-    this.submitAction = val;
-  }
-
-  open(handler: () => Promise<void>, label: string): void {
-    this.setSubmitAction({ handler, label });
-    this.setShowModal(true);
-  }
-
-  close(): void {
-    this.setSubmitAction(undefined);
-    this.setShowModal(false);
-  }
-}
-
-export class LambdaParametersState implements Hashable {
-  parameterStates: LambdaParameterState[] = [];
-  parameterValuesEditorState = new ParameterInstanceValuesEditorState();
-
-  constructor() {
-    makeObservable(this, {
-      hashCode: computed,
-    });
-  }
-
-  get hashCode(): string {
-    return hashArray([
-      LAMABA_PARAMETER_HASH_STRUCTURE.LAMBDA_PARAMETERS_STATE,
-      hashArray(this.parameterStates),
-    ]);
-  }
-
-  addParameter(val: LambdaParameterState): void {
-    addUniqueEntry(this.parameterStates, val);
-  }
-
-  removeParameter(val: LambdaParameterState): void {
-    deleteEntry(this.parameterStates, val);
-  }
-
-  setParameters(val: LambdaParameterState[]): void {
-    this.parameterStates = val;
-  }
-}

package/src/stores/shared/ValueSpecificationModifierHelper.ts

@@ -1,104 +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 {
-  type GenericType,
-  type Type,
-  type Multiplicity,
-  type FunctionExpression,
-  type ValueSpecification,
-  type ObserverContext,
-  type VariableExpression,
-  type InstanceValue,
-  type GraphFetchTree,
-  type AbstractPropertyExpression,
-  observe_ValueSpecification,
-} from '@finos/legend-graph';
-import { addUniqueEntry, deleteEntry } from '@finos/legend-shared';
-import { action } from 'mobx';
-
-export const genericType_setRawType = action(
-  (genericType: GenericType, type: Type): void => {
-    genericType.rawType = type;
-  },
-);
-
-export const multiplicity_setLowerBound = action(
-  (_m: Multiplicity, val: number): void => {
-    _m.lowerBound = val;
-  },
-);
-export const multiplicity_setUpperBound = action(
-  (_m: Multiplicity, val: number | undefined): void => {
-    _m.upperBound = val;
-  },
-);
-
-export const functionExpression_setParametersValues = action(
-  (
-    functionExpression: FunctionExpression,
-    val: ValueSpecification[],
-    context: ObserverContext,
-  ): void => {
-    functionExpression.parametersValues = val.map((v) =>
-      observe_ValueSpecification(v, context),
-    );
-  },
-);
-
-export const variableExpression_setName = action(
-  (v: VariableExpression, val: string): void => {
-    v.name = val;
-  },
-);
-
-export const instanceValue_changeValue = action(
-  (instanceValue: InstanceValue, val: unknown, idx: number) => {
-    instanceValue.values[idx] = val;
-  },
-);
-
-export const instanceValue_changeValues = action(
-  (instanceValue: InstanceValue, val: unknown[]) => {
-    instanceValue.values = val;
-  },
-);
-
-export const graphFetchTree_addSubTree = action(
-  (tree: GraphFetchTree, val: GraphFetchTree): void => {
-    addUniqueEntry(tree.subTrees, val);
-  },
-);
-
-export const graphFetchTree_removeSubTree = action(
-  (tree: GraphFetchTree, val: GraphFetchTree): void => {
-    deleteEntry(tree.subTrees, val);
-  },
-);
-
-export const propertyExpression_setParametersValue = action(
-  (
-    propertyExpression: AbstractPropertyExpression,
-    idx: number,
-    val: ValueSpecification,
-    context: ObserverContext,
-  ): void => {
-    propertyExpression.parametersValues[idx] = observe_ValueSpecification(
-      val,
-      context,
-    );
-  },
-);