@flowgram.ai/variable-core 0.1.30 → 0.2.0

package/dist/index.js

@@ -43,7 +43,6 @@ __export(src_exports, {
   CustomType: () => CustomType,
   DataNode: () => DataNode,
   EnumerateExpression: () => EnumerateExpression,
-  ExpressionList: () => ExpressionList,
   IntegerType: () => IntegerType,
   KeyPathExpression: () => KeyPathExpression,
   KeyPathExpressionV2: () => KeyPathExpressionV2,
@@ -64,6 +63,7 @@ __export(src_exports, {
   VariableEngine: () => VariableEngine,
   VariableEngineProvider: () => VariableEngineProvider,
   VariableFieldKeyRenameService: () => VariableFieldKeyRenameService,
+  WrapArrayExpression: () => WrapArrayExpression,
   injectToAST: () => injectToAST,
   isMatchAST: () => isMatchAST,
   postConstructAST: () => postConstructAST,
@@ -75,11 +75,11 @@ __export(src_exports, {
 module.exports = __toCommonJS(src_exports);
 
 // src/variable-container-module.ts
-var import_inversify7 = require("inversify");
+var import_inversify8 = require("inversify");
 
 // src/variable-engine.ts
 var import_rxjs6 = require("rxjs");
-var import_inversify5 = require("inversify");
+var import_inversify6 = require("inversify");
 var import_utils8 = require("@flowgram.ai/utils");
 var import_utils9 = require("@flowgram.ai/utils");
 
@@ -281,7 +281,7 @@ var ASTKind = /* @__PURE__ */ ((ASTKind2) => {
   ASTKind2["VariableDeclarationList"] = "VariableDeclarationList";
   ASTKind2["KeyPathExpression"] = "KeyPathExpression";
   ASTKind2["EnumerateExpression"] = "EnumerateExpression";
-  ASTKind2["ExpressionList"] = "ExpressionList";
+  ASTKind2["WrapArrayExpression"] = "WrapArrayExpression";
   ASTKind2["ListNode"] = "ListNode";
   ASTKind2["DataNode"] = "DataNode";
   ASTKind2["MapNode"] = "MapNode";
@@ -289,8 +289,8 @@ var ASTKind = /* @__PURE__ */ ((ASTKind2) => {
 })(ASTKind || {});
 
 // src/ast/ast-registers.ts
-var import_lodash3 = require("lodash");
-var import_inversify2 = require("inversify");
+var import_lodash4 = require("lodash");
+var import_inversify3 = require("inversify");
 
 // src/ast/utils/inversify.ts
 var injectToAST = (serviceIdentifier) => function(target, propertyKey) {
@@ -608,6 +608,106 @@ var ASTNode = class _ASTNode {
   }
 };
 
+// src/ast/factory.ts
+var import_lodash = require("lodash");
+var ASTFactory;
+((ASTFactory2) => {
+  ASTFactory2.createString = () => ({ kind: "String" /* String */ });
+  ASTFactory2.createNumber = () => ({ kind: "Number" /* Number */ });
+  ASTFactory2.createBoolean = () => ({ kind: "Boolean" /* Boolean */ });
+  ASTFactory2.createInteger = () => ({ kind: "Integer" /* Integer */ });
+  ASTFactory2.createObject = (json) => ({
+    kind: "Object" /* Object */,
+    ...json
+  });
+  ASTFactory2.createArray = (json) => ({
+    kind: "Array" /* Array */,
+    ...json
+  });
+  ASTFactory2.createMap = (json) => ({
+    kind: "Map" /* Map */,
+    ...json
+  });
+  ASTFactory2.createUnion = (json) => ({
+    kind: "Union" /* Union */,
+    ...json
+  });
+  ASTFactory2.createCustomType = (json) => ({
+    kind: "CustomType" /* CustomType */,
+    ...json
+  });
+  ASTFactory2.createVariableDeclaration = (json) => ({
+    kind: "VariableDeclaration" /* VariableDeclaration */,
+    ...json
+  });
+  ASTFactory2.createProperty = (json) => ({
+    kind: "Property" /* Property */,
+    ...json
+  });
+  ASTFactory2.createVariableDeclarationList = (json) => ({
+    kind: "VariableDeclarationList" /* VariableDeclarationList */,
+    ...json
+  });
+  ASTFactory2.createEnumerateExpression = (json) => ({
+    kind: "EnumerateExpression" /* EnumerateExpression */,
+    ...json
+  });
+  ASTFactory2.createKeyPathExpression = (json) => ({
+    kind: "KeyPathExpression" /* KeyPathExpression */,
+    ...json
+  });
+  ASTFactory2.createWrapArrayExpression = (json) => ({
+    kind: "WrapArrayExpression" /* WrapArrayExpression */,
+    ...json
+  });
+  function createTypeASTFromSchema(jsonSchema) {
+    const { type, extra } = jsonSchema || {};
+    const { weak = false } = extra || {};
+    if (!type) {
+      return void 0;
+    }
+    switch (type) {
+      case "object":
+        if (weak) {
+          return { kind: "Object" /* Object */, weak: true };
+        }
+        return ASTFactory2.createObject({
+          properties: Object.entries(jsonSchema.properties || {}).sort((a, b) => ((0, import_lodash.get)(a?.[1], "extra.index") || 0) - ((0, import_lodash.get)(b?.[1], "extra.index") || 0)).map(([key, _property]) => ({
+            key,
+            type: createTypeASTFromSchema(_property),
+            meta: { description: _property.description }
+          }))
+        });
+      case "array":
+        if (weak) {
+          return { kind: "Array" /* Array */, weak: true };
+        }
+        return ASTFactory2.createArray({
+          items: createTypeASTFromSchema(jsonSchema.items)
+        });
+      case "map":
+        if (weak) {
+          return { kind: "Map" /* Map */, weak: true };
+        }
+        return ASTFactory2.createMap({
+          valueType: createTypeASTFromSchema(jsonSchema.additionalProperties)
+        });
+      case "string":
+        return ASTFactory2.createString();
+      case "number":
+        return ASTFactory2.createNumber();
+      case "boolean":
+        return ASTFactory2.createBoolean();
+      case "integer":
+        return ASTFactory2.createInteger();
+      default:
+        return ASTFactory2.createCustomType({ typeName: type });
+    }
+  }
+  ASTFactory2.createTypeASTFromSchema = createTypeASTFromSchema;
+  ASTFactory2.create = (targetType, json) => ({ kind: targetType.kind, ...json });
+})(ASTFactory || (ASTFactory = {}));
+
 // src/ast/type/base-type.ts
 var BaseType = class extends ASTNode {
   constructor() {
@@ -615,7 +715,7 @@ var BaseType = class extends ASTNode {
     this.flags = 8 /* BasicType */;
   }
   /**
-   * 类型是否一致，节点有额外信息判断，请参考 extraTypeInfoEqual
+   * 类型是否一致
    * @param targetTypeJSON
    */
   isTypeEqual(targetTypeJSONOrKind) {
@@ -634,11 +734,37 @@ var BaseType = class extends ASTNode {
   getByKeyPath(keyPath = []) {
     throw new Error(`Get By Key Path is not implemented for Type: ${this.kind}`);
   }
+  /**
+   * Get AST JSON for current base type
+   * @returns
+   */
   toJSON() {
     return {
       kind: this.kind
     };
   }
+  /**
+   * Get Standard JSON Schema for current base type
+   * @returns
+   */
+  toJSONSchema() {
+    return {
+      type: this.kind.toLowerCase()
+    };
+  }
+  /**
+   * Check if the type is equal with json schema
+   */
+  isEqualWithJSONSchema(schema) {
+    if (Array.isArray(schema)) {
+      return this.isTypeEqual(
+        ASTFactory.createUnion({
+          types: schema.map((_schema) => ASTFactory.createTypeASTFromSchema(_schema)).filter(Boolean)
+        })
+      );
+    }
+    return this.isTypeEqual(ASTFactory.createTypeASTFromSchema(schema));
+  }
 };
 
 // src/ast/type/array.ts
@@ -698,6 +824,11 @@ var StringType = class extends BaseType {
   }
   fromJSON() {
   }
+  toJSONSchema() {
+    return {
+      type: "string"
+    };
+  }
 };
 StringType.kind = "String" /* String */;
 
@@ -709,6 +840,11 @@ var IntegerType = class extends BaseType {
   }
   fromJSON() {
   }
+  toJSONSchema() {
+    return {
+      type: "integer"
+    };
+  }
 };
 IntegerType.kind = "Integer" /* Integer */;
 
@@ -716,6 +852,11 @@ IntegerType.kind = "Integer" /* Integer */;
 var BooleanType = class extends BaseType {
   fromJSON() {
   }
+  toJSONSchema() {
+    return {
+      type: "boolean"
+    };
+  }
 };
 BooleanType.kind = "Boolean" /* Boolean */;
 
@@ -723,6 +864,11 @@ BooleanType.kind = "Boolean" /* Boolean */;
 var NumberType = class extends BaseType {
   fromJSON() {
   }
+  toJSONSchema() {
+    return {
+      type: "number"
+    };
+  }
 };
 NumberType.kind = "Number" /* Number */;
 
@@ -769,12 +915,18 @@ var MapType = class extends BaseType {
       valueType: this.valueType?.toJSON()
     };
   }
+  toJSONSchema() {
+    return {
+      type: "map",
+      additionalProperties: this.valueType?.toJSONSchema()
+    };
+  }
 };
 // public flags: ASTNodeFlags = ASTNodeFlags.DrilldownType | ASTNodeFlags.EnumerateType;
 MapType.kind = "Map" /* Map */;
 
 // src/ast/type/object.ts
-var import_lodash = require("lodash");
+var import_lodash2 = require("lodash");
 var ObjectType = class extends BaseType {
   constructor() {
     super(...arguments);
@@ -854,12 +1006,21 @@ var ObjectType = class extends BaseType {
     const targetProperties = targetTypeJSON.properties || [];
     const sourcePropertyKeys = Array.from(this.propertyTable.keys());
     const targetPropertyKeys = targetProperties.map((_target) => _target.key);
-    const isKeyStrongEqual = !(0, import_lodash.xor)(sourcePropertyKeys, targetPropertyKeys).length;
+    const isKeyStrongEqual = !(0, import_lodash2.xor)(sourcePropertyKeys, targetPropertyKeys).length;
     return isKeyStrongEqual && targetProperties.every((targetProperty) => {
       const sourceProperty = this.propertyTable.get(targetProperty.key);
       return sourceProperty && sourceProperty.key === targetProperty.key && sourceProperty.type?.isTypeEqual(targetProperty?.type);
     });
   }
+  toJSONSchema() {
+    return {
+      type: "object",
+      properties: this.properties.reduce((acc, _property) => {
+        acc[_property.key] = _property.type?.toJSONSchema();
+        return acc;
+      }, {})
+    };
+  }
 };
 ObjectType.kind = "Object" /* Object */;
 
@@ -883,6 +1044,11 @@ var CustomType = class extends BaseType {
     }
     return targetTypeJSON?.kind === this.kind && targetTypeJSON?.typeName === this.typeName;
   }
+  toJSONSchema() {
+    return {
+      type: this._typeName
+    };
+  }
 };
 CustomType.kind = "CustomType" /* CustomType */;
 
@@ -961,29 +1127,6 @@ var BaseExpression = class extends ASTNode {
   }
 };
 
-// src/ast/expression/expression-list.ts
-var ExpressionList = class extends ASTNode {
-  fromJSON({ expressions }) {
-    this.expressions = expressions.map((_expression, idx) => {
-      const prevExpression = this.expressions[idx];
-      if (prevExpression.kind !== _expression.kind) {
-        prevExpression.dispose();
-        this.fireChange();
-        return this.createChildNode(_expression);
-      }
-      prevExpression.fromJSON(_expression);
-      return prevExpression;
-    });
-  }
-  toJSON() {
-    return {
-      kind: "ExpressionList" /* ExpressionList */,
-      properties: this.expressions.map((_expression) => _expression.toJSON())
-    };
-  }
-};
-ExpressionList.kind = "ExpressionList" /* ExpressionList */;
-
 // src/ast/expression/keypath-expression.ts
 var import_fast_equals3 = require("fast-equals");
 var KeyPathExpression = class extends BaseExpression {
@@ -1073,12 +1216,12 @@ EnumerateExpression.kind = "EnumerateExpression" /* EnumerateExpression */;
 var import_fast_equals4 = require("fast-equals");
 
 // src/ast/utils/expression.ts
-var import_lodash2 = require("lodash");
+var import_lodash3 = require("lodash");
 function getAllRefs(ast) {
   return getAllChildren(ast).filter((_child) => _child.flags & 4 /* Expression */).map((_child) => _child.refs).flat().filter(Boolean);
 }
 function checkRefCycle(curr, refNodes) {
-  if ((0, import_lodash2.intersection)(curr.scope.coverScopes, refNodes.map((_ref) => _ref?.scope).filter(Boolean)).length === 0) {
+  if ((0, import_lodash3.intersection)(curr.scope.coverScopes, refNodes.map((_ref) => _ref?.scope).filter(Boolean)).length === 0) {
     return false;
   }
   const visited = /* @__PURE__ */ new Set();
@@ -1090,7 +1233,7 @@ function checkRefCycle(curr, refNodes) {
       queue.push(ref);
     }
   }
-  return (0, import_lodash2.intersection)(Array.from(visited), getParentFields(curr)).length > 0;
+  return (0, import_lodash3.intersection)(Array.from(visited), getParentFields(curr)).length > 0;
 }
 
 // src/ast/expression/keypath-expression-v2.ts
@@ -1165,6 +1308,46 @@ var KeyPathExpressionV2 = class extends BaseExpression {
 };
 KeyPathExpressionV2.kind = "KeyPathExpression" /* KeyPathExpression */;
 
+// src/ast/expression/wrap-array-expression.ts
+var WrapArrayExpression = class extends BaseExpression {
+  get wrapFor() {
+    return this._wrapFor;
+  }
+  get returnType() {
+    return this._returnType;
+  }
+  refreshReturnType() {
+    const childReturnTypeJSON = this.wrapFor?.returnType?.toJSON();
+    this.updateChildNodeByKey("_returnType", {
+      kind: "Array" /* Array */,
+      items: childReturnTypeJSON
+    });
+  }
+  getRefFields() {
+    return [];
+  }
+  fromJSON({ wrapFor: expression }) {
+    this.updateChildNodeByKey("_wrapFor", expression);
+  }
+  toJSON() {
+    return {
+      kind: "WrapArrayExpression" /* WrapArrayExpression */,
+      wrapFor: this.wrapFor?.toJSON()
+    };
+  }
+  init() {
+    this.toDispose.push(
+      this.subscribe(this.refreshReturnType, {
+        selector: (curr) => curr.wrapFor?.returnType
+      })
+    );
+  }
+};
+WrapArrayExpression.kind = "WrapArrayExpression" /* WrapArrayExpression */;
+__decorateClass([
+  postConstructAST()
+], WrapArrayExpression.prototype, "init", 1);
+
 // src/ast/declaration/base-variable-field.ts
 var import_fast_equals5 = require("fast-equals");
 var BaseVariableField = class extends ASTNode {
@@ -1471,7 +1654,7 @@ var ASTRegisters = class {
     this.registerAST(VariableDeclarationList);
     this.registerAST(KeyPathExpression);
     this.registerAST(EnumerateExpression);
-    this.registerAST(ExpressionList);
+    this.registerAST(WrapArrayExpression);
     this.registerAST(MapNode);
     this.registerAST(DataNode);
   }
@@ -1495,7 +1678,7 @@ var ASTRegisters = class {
       injector?.() || {}
     );
     node.changeLocked = true;
-    node.fromJSON((0, import_lodash3.omit)(json, ["key", "kind"]));
+    node.fromJSON((0, import_lodash4.omit)(json, ["key", "kind"]));
     node.changeLocked = false;
     if (Reflect.hasMetadata(POST_CONSTRUCT_AST_SYMBOL, node)) {
       const postConstructKey = Reflect.getMetadata(POST_CONSTRUCT_AST_SYMBOL, node);
@@ -1524,59 +1707,9 @@ var ASTRegisters = class {
   }
 };
 ASTRegisters = __decorateClass([
-  (0, import_inversify2.injectable)()
+  (0, import_inversify3.injectable)()
 ], ASTRegisters);
 
-// src/ast/factory.ts
-var ASTFactory;
-((ASTFactory2) => {
-  ASTFactory2.createString = () => ({ kind: "String" /* String */ });
-  ASTFactory2.createNumber = () => ({ kind: "Number" /* Number */ });
-  ASTFactory2.createBoolean = () => ({ kind: "Boolean" /* Boolean */ });
-  ASTFactory2.createInteger = () => ({ kind: "Integer" /* Integer */ });
-  ASTFactory2.createObject = (json) => ({
-    kind: "Object" /* Object */,
-    ...json
-  });
-  ASTFactory2.createArray = (json) => ({
-    kind: "Array" /* Array */,
-    ...json
-  });
-  ASTFactory2.createMap = (json) => ({
-    kind: "Map" /* Map */,
-    ...json
-  });
-  ASTFactory2.createUnion = (json) => ({
-    kind: "Union" /* Union */,
-    ...json
-  });
-  ASTFactory2.createCustomType = (json) => ({
-    kind: "CustomType" /* CustomType */,
-    ...json
-  });
-  ASTFactory2.createVariableDeclaration = (json) => ({
-    kind: "VariableDeclaration" /* VariableDeclaration */,
-    ...json
-  });
-  ASTFactory2.createProperty = (json) => ({
-    kind: "Property" /* Property */,
-    ...json
-  });
-  ASTFactory2.createVariableDeclarationList = (json) => ({
-    kind: "VariableDeclarationList" /* VariableDeclarationList */,
-    ...json
-  });
-  ASTFactory2.createEnumerateExpression = (json) => ({
-    kind: "EnumerateExpression" /* EnumerateExpression */,
-    ...json
-  });
-  ASTFactory2.createKeyPathExpression = (json) => ({
-    kind: "KeyPathExpression" /* KeyPathExpression */,
-    ...json
-  });
-  ASTFactory2.create = (targetType, json) => ({ kind: targetType.kind, ...json });
-})(ASTFactory || (ASTFactory = {}));
-
 // src/scope/datas/scope-output-data.ts
 var ScopeOutputData = class {
   constructor(scope) {
@@ -1661,7 +1794,7 @@ var ScopeOutputData = class {
 
 // src/scope/datas/scope-available-data.ts
 var import_rxjs4 = require("rxjs");
-var import_lodash4 = require("lodash");
+var import_lodash5 = require("lodash");
 var import_fast_equals7 = require("fast-equals");
 var import_utils5 = require("@flowgram.ai/utils");
 var import_utils6 = require("@flowgram.ai/utils");
@@ -1676,7 +1809,7 @@ var ScopeAvailableData = class {
      */
     this.variables$ = this.refresh$.pipe(
       // 输出变量是否 version 发生变化
-      (0, import_rxjs4.map)(() => (0, import_lodash4.flatten)(this.depScopes.map((scope) => scope.output.variables || []))),
+      (0, import_rxjs4.map)(() => (0, import_lodash5.flatten)(this.depScopes.map((scope) => scope.output.variables || []))),
       // 变量列表浅比较
       (0, import_rxjs4.distinctUntilChanged)(import_fast_equals7.shallowEqual),
       (0, import_rxjs4.share)()
@@ -1946,20 +2079,20 @@ var VariableEngine = class {
   }
 };
 __decorateClass([
-  (0, import_inversify5.inject)(ContainerProvider)
+  (0, import_inversify6.inject)(ContainerProvider)
 ], VariableEngine.prototype, "containerProvider", 2);
 __decorateClass([
-  (0, import_inversify5.preDestroy)()
+  (0, import_inversify6.preDestroy)()
 ], VariableEngine.prototype, "dispose", 1);
 VariableEngine = __decorateClass([
-  (0, import_inversify5.injectable)(),
-  __decorateParam(0, (0, import_inversify5.inject)(ScopeChain)),
-  __decorateParam(1, (0, import_inversify5.inject)(ASTRegisters))
+  (0, import_inversify6.injectable)(),
+  __decorateParam(0, (0, import_inversify6.inject)(ScopeChain)),
+  __decorateParam(1, (0, import_inversify6.inject)(ASTRegisters))
 ], VariableEngine);
 
 // src/services/variable-field-key-rename-service.ts
-var import_lodash5 = require("lodash");
-var import_inversify6 = require("inversify");
+var import_lodash6 = require("lodash");
+var import_inversify7 = require("inversify");
 var import_utils10 = require("@flowgram.ai/utils");
 var VariableFieldKeyRenameService = class {
   constructor() {
@@ -2001,7 +2134,7 @@ var VariableFieldKeyRenameService = class {
     this.renameEmitter.fire(renameNodeInfo);
   }
   notifyFieldsDispose(prev, next) {
-    const removedFields = (0, import_lodash5.difference)(prev || [], next || []);
+    const removedFields = (0, import_lodash6.difference)(prev || [], next || []);
     removedFields.forEach((_field) => this.disposeInListEmitter.fire(_field));
   }
   init() {
@@ -2025,20 +2158,20 @@ var VariableFieldKeyRenameService = class {
   }
 };
 __decorateClass([
-  (0, import_inversify6.inject)(VariableEngine)
+  (0, import_inversify7.inject)(VariableEngine)
 ], VariableFieldKeyRenameService.prototype, "variableEngine", 2);
 __decorateClass([
-  (0, import_inversify6.postConstruct)()
+  (0, import_inversify7.postConstruct)()
 ], VariableFieldKeyRenameService.prototype, "init", 1);
 __decorateClass([
-  (0, import_inversify6.preDestroy)()
+  (0, import_inversify7.preDestroy)()
 ], VariableFieldKeyRenameService.prototype, "dispose", 1);
 VariableFieldKeyRenameService = __decorateClass([
-  (0, import_inversify6.injectable)()
+  (0, import_inversify7.injectable)()
 ], VariableFieldKeyRenameService);
 
 // src/variable-container-module.ts
-var VariableContainerModule = new import_inversify7.ContainerModule((bind) => {
+var VariableContainerModule = new import_inversify8.ContainerModule((bind) => {
   bind(VariableEngine).toSelf().inSingletonScope();
   bind(ASTRegisters).toSelf().inSingletonScope();
   bind(VariableFieldKeyRenameService).toSelf().inSingletonScope();
@@ -2105,7 +2238,6 @@ function useAvailableVariables() {
   CustomType,
   DataNode,
   EnumerateExpression,
-  ExpressionList,
   IntegerType,
   KeyPathExpression,
   KeyPathExpressionV2,
@@ -2126,6 +2258,7 @@ function useAvailableVariables() {
   VariableEngine,
   VariableEngineProvider,
   VariableFieldKeyRenameService,
+  WrapArrayExpression,
   injectToAST,
   isMatchAST,
   postConstructAST,