@flowgram.ai/variable-core 0.1.31 → 0.2.0

package/dist/esm/index.js

@@ -217,7 +217,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";
@@ -552,6 +552,106 @@ var ASTNode = class _ASTNode {
   }
 };
 
+// src/ast/factory.ts
+import { get } from "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) => (get(a?.[1], "extra.index") || 0) - (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() {
@@ -559,7 +659,7 @@ var BaseType = class extends ASTNode {
     this.flags = 8 /* BasicType */;
   }
   /**
-   * 类型是否一致，节点有额外信息判断，请参考 extraTypeInfoEqual
+   * 类型是否一致
    * @param targetTypeJSON
    */
   isTypeEqual(targetTypeJSONOrKind) {
@@ -578,11 +678,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
@@ -642,6 +768,11 @@ var StringType = class extends BaseType {
   }
   fromJSON() {
   }
+  toJSONSchema() {
+    return {
+      type: "string"
+    };
+  }
 };
 StringType.kind = "String" /* String */;
 
@@ -653,6 +784,11 @@ var IntegerType = class extends BaseType {
   }
   fromJSON() {
   }
+  toJSONSchema() {
+    return {
+      type: "integer"
+    };
+  }
 };
 IntegerType.kind = "Integer" /* Integer */;
 
@@ -660,6 +796,11 @@ IntegerType.kind = "Integer" /* Integer */;
 var BooleanType = class extends BaseType {
   fromJSON() {
   }
+  toJSONSchema() {
+    return {
+      type: "boolean"
+    };
+  }
 };
 BooleanType.kind = "Boolean" /* Boolean */;
 
@@ -667,6 +808,11 @@ BooleanType.kind = "Boolean" /* Boolean */;
 var NumberType = class extends BaseType {
   fromJSON() {
   }
+  toJSONSchema() {
+    return {
+      type: "number"
+    };
+  }
 };
 NumberType.kind = "Number" /* Number */;
 
@@ -713,6 +859,12 @@ 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 */;
@@ -804,6 +956,15 @@ var ObjectType = class extends BaseType {
       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 */;
 
@@ -827,6 +988,11 @@ var CustomType = class extends BaseType {
     }
     return targetTypeJSON?.kind === this.kind && targetTypeJSON?.typeName === this.typeName;
   }
+  toJSONSchema() {
+    return {
+      type: this._typeName
+    };
+  }
 };
 CustomType.kind = "CustomType" /* CustomType */;
 
@@ -913,29 +1079,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
 import { shallowEqual as shallowEqual3 } from "fast-equals";
 var KeyPathExpression = class extends BaseExpression {
@@ -1117,6 +1260,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
 import { shallowEqual as shallowEqual5 } from "fast-equals";
 var BaseVariableField = class extends ASTNode {
@@ -1423,7 +1606,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);
   }
@@ -1479,56 +1662,6 @@ ASTRegisters = __decorateClass([
   injectable2()
 ], 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) {
@@ -2064,7 +2197,6 @@ export {
   CustomType,
   DataNode,
   EnumerateExpression,
-  ExpressionList,
   IntegerType,
   KeyPathExpression,
   KeyPathExpressionV2,
@@ -2085,6 +2217,7 @@ export {
   VariableEngine,
   VariableEngineProvider,
   VariableFieldKeyRenameService,
+  WrapArrayExpression,
   injectToAST,
   isMatchAST,
   postConstructAST,