@flowgram.ai/form-materials 0.2.0 → 0.2.1

package/dist/esm/index.js

@@ -4,7 +4,7 @@ import { IconChevronDownStroked, IconIssueStroked } from "@douyinfe/semi-icons";
 
 // src/components/variable-selector/use-variable-tree.tsx
 import React2, { useCallback } from "react";
-import { useScopeAvailable, ASTMatch } from "@flowgram.ai/editor";
+import { useScopeAvailable, ASTMatch as ASTMatch2 } from "@flowgram.ai/editor";
 import { Icon as Icon2 } from "@douyinfe/semi-ui";
 
 // src/components/type-selector/constants.tsx
@@ -396,6 +396,118 @@ var options = [
   }
 ];
 
+// src/utils/json-schema/index.ts
+import { get } from "lodash";
+import { ASTFactory, ASTKind, ASTMatch } from "@flowgram.ai/editor";
+var JsonSchemaUtils;
+((JsonSchemaUtils2) => {
+  function schemaToAST(jsonSchema) {
+    const { type, extra } = jsonSchema || {};
+    const { weak = false } = extra || {};
+    if (!type) {
+      return void 0;
+    }
+    switch (type) {
+      case "object":
+        if (weak) {
+          return { kind: ASTKind.Object, weak: true };
+        }
+        return ASTFactory.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: schemaToAST(_property),
+            meta: { description: _property.description }
+          }))
+        });
+      case "array":
+        if (weak) {
+          return { kind: ASTKind.Array, weak: true };
+        }
+        return ASTFactory.createArray({
+          items: schemaToAST(jsonSchema.items)
+        });
+      case "map":
+        if (weak) {
+          return { kind: ASTKind.Map, weak: true };
+        }
+        return ASTFactory.createMap({
+          valueType: schemaToAST(jsonSchema.additionalProperties)
+        });
+      case "string":
+        return ASTFactory.createString();
+      case "number":
+        return ASTFactory.createNumber();
+      case "boolean":
+        return ASTFactory.createBoolean();
+      case "integer":
+        return ASTFactory.createInteger();
+      default:
+        return ASTFactory.createCustomType({ typeName: type });
+    }
+  }
+  JsonSchemaUtils2.schemaToAST = schemaToAST;
+  function astToSchema(typeAST) {
+    if (ASTMatch.isString(typeAST)) {
+      return {
+        type: "string"
+      };
+    }
+    if (ASTMatch.isBoolean(typeAST)) {
+      return {
+        type: "boolean"
+      };
+    }
+    if (ASTMatch.isNumber(typeAST)) {
+      return {
+        type: "number"
+      };
+    }
+    if (ASTMatch.isInteger(typeAST)) {
+      return {
+        type: "integer"
+      };
+    }
+    if (ASTMatch.isObject(typeAST)) {
+      return {
+        type: "object",
+        properties: Object.fromEntries(
+          Object.entries(typeAST.properties).map(([key, value]) => [key, astToSchema(value)])
+        )
+      };
+    }
+    if (ASTMatch.isArray(typeAST)) {
+      return {
+        type: "array",
+        items: astToSchema(typeAST.items)
+      };
+    }
+    if (ASTMatch.isMap(typeAST)) {
+      return {
+        type: "map",
+        items: astToSchema(typeAST.valueType)
+      };
+    }
+    if (ASTMatch.isCustomType(typeAST)) {
+      return {
+        type: typeAST.typeName
+      };
+    }
+    return void 0;
+  }
+  JsonSchemaUtils2.astToSchema = astToSchema;
+  function isASTMatchSchema(typeAST, schema) {
+    if (Array.isArray(schema)) {
+      return typeAST.isTypeEqual(
+        ASTFactory.createUnion({
+          types: schema.map((_schema) => schemaToAST(_schema)).filter(Boolean)
+        })
+      );
+    }
+    return typeAST.isTypeEqual(schemaToAST(schema));
+  }
+  JsonSchemaUtils2.isASTMatchSchema = isASTMatchSchema;
+})(JsonSchemaUtils || (JsonSchemaUtils = {}));
+
 // src/components/variable-selector/use-variable-tree.tsx
 function useVariableTree(params) {
   const { includeSchema, excludeSchema } = params;
@@ -408,7 +520,7 @@ function useVariableTree(params) {
       return variable.meta.icon;
     }
     const _type = variable.type;
-    if (ASTMatch.isArray(_type)) {
+    if (ASTMatch2.isArray(_type)) {
       return /* @__PURE__ */ React2.createElement(
         Icon2,
         {
@@ -417,7 +529,7 @@ function useVariableTree(params) {
         }
       );
     }
-    if (ASTMatch.isCustomType(_type)) {
+    if (ASTMatch2.isCustomType(_type)) {
       return /* @__PURE__ */ React2.createElement(Icon2, { size: "small", svg: VariableTypeIcons[_type.typeName.toLowerCase()] });
     }
     return /* @__PURE__ */ React2.createElement(Icon2, { size: "small", svg: VariableTypeIcons[variable.type?.kind.toLowerCase()] });
@@ -428,7 +540,7 @@ function useVariableTree(params) {
       return null;
     }
     let children;
-    if (ASTMatch.isObject(type)) {
+    if (ASTMatch2.isObject(type)) {
       children = (type.properties || []).map((_property) => renderVariable(_property, [...parentFields, variable])).filter(Boolean);
       if (!children?.length) {
         return null;
@@ -436,8 +548,8 @@ function useVariableTree(params) {
     }
     const keyPath = [...parentFields.map((_field) => _field.key), variable.key];
     const key = keyPath.join(".");
-    const isSchemaInclude = includeSchema ? type.isEqualWithJSONSchema(includeSchema) : true;
-    const isSchemaExclude = excludeSchema ? type.isEqualWithJSONSchema(excludeSchema) : false;
+    const isSchemaInclude = includeSchema ? JsonSchemaUtils.isASTMatchSchema(type, includeSchema) : true;
+    const isSchemaExclude = excludeSchema ? JsonSchemaUtils.isASTMatchSchema(type, excludeSchema) : false;
     const isSchemaMatch = isSchemaInclude && !isSchemaExclude;
     if (!isSchemaMatch && !children?.length) {
       return null;
@@ -1132,32 +1244,32 @@ function DynamicValueInput({
 
 // src/effects/provide-batch-input/index.ts
 import {
-  ASTFactory,
+  ASTFactory as ASTFactory2,
   createEffectFromVariableProvider,
   getNodeForm
 } from "@flowgram.ai/editor";
 var provideBatchInputEffect = createEffectFromVariableProvider({
   private: true,
   parse: (value, ctx) => [
-    ASTFactory.createVariableDeclaration({
+    ASTFactory2.createVariableDeclaration({
       key: `${ctx.node.id}_locals`,
       meta: {
         title: getNodeForm(ctx.node)?.getValueIn("title"),
         icon: ctx.node.getNodeRegistry().info?.icon
       },
-      type: ASTFactory.createObject({
+      type: ASTFactory2.createObject({
         properties: [
-          ASTFactory.createProperty({
+          ASTFactory2.createProperty({
             key: "item",
-            initializer: ASTFactory.createEnumerateExpression({
-              enumerateFor: ASTFactory.createKeyPathExpression({
+            initializer: ASTFactory2.createEnumerateExpression({
+              enumerateFor: ASTFactory2.createKeyPathExpression({
                 keyPath: value.content || []
               })
             })
           }),
-          ASTFactory.createProperty({
+          ASTFactory2.createProperty({
             key: "index",
-            type: ASTFactory.createNumber()
+            type: ASTFactory2.createNumber()
           })
         ]
       })
@@ -1167,25 +1279,25 @@ var provideBatchInputEffect = createEffectFromVariableProvider({
 
 // src/effects/provide-batch-outputs/index.ts
 import {
-  ASTFactory as ASTFactory2,
+  ASTFactory as ASTFactory3,
   createEffectFromVariableProvider as createEffectFromVariableProvider2,
   getNodeForm as getNodeForm2
 } from "@flowgram.ai/editor";
 var provideBatchOutputsEffect = createEffectFromVariableProvider2({
   private: true,
   parse: (value, ctx) => [
-    ASTFactory2.createVariableDeclaration({
+    ASTFactory3.createVariableDeclaration({
       key: `${ctx.node.id}`,
       meta: {
         title: getNodeForm2(ctx.node)?.getValueIn("title"),
         icon: ctx.node.getNodeRegistry().info?.icon
       },
-      type: ASTFactory2.createObject({
+      type: ASTFactory3.createObject({
         properties: Object.entries(value).map(
-          ([_key, value2]) => ASTFactory2.createProperty({
+          ([_key, value2]) => ASTFactory3.createProperty({
             key: _key,
-            initializer: ASTFactory2.createWrapArrayExpression({
-              wrapFor: ASTFactory2.createKeyPathExpression({
+            initializer: ASTFactory3.createWrapArrayExpression({
+              wrapFor: ASTFactory3.createKeyPathExpression({
                 keyPath: value2.content || []
               })
             })
@@ -1263,6 +1375,7 @@ export {
   ConstantInput,
   DynamicValueInput,
   JsonSchemaEditor,
+  JsonSchemaUtils,
   TypeSelector,
   VariableSelector,
   VariableTypeIcons,