@flowgram.ai/form-materials 0.2.0 → 0.2.2

package/src/components/variable-selector/use-variable-tree.tsx

@@ -1,16 +1,18 @@
 import React, { useCallback } from 'react';
 
-import { useScopeAvailable, ASTMatch, BaseVariableField, VarJSONSchema } from '@flowgram.ai/editor';
+import { useScopeAvailable, ASTMatch, BaseVariableField } from '@flowgram.ai/editor';
 import { TreeNodeData } from '@douyinfe/semi-ui/lib/es/tree';
 import { Icon } from '@douyinfe/semi-ui';
 
 import { ArrayIcons, VariableTypeIcons } from '../type-selector/constants';
+import { JsonSchemaUtils } from '../../utils/json-schema';
+import { IJsonSchema } from '../../typings/json-schema';
 
 type VariableField = BaseVariableField<{ icon?: string | JSX.Element; title?: string }>;
 
 export function useVariableTree(params: {
-  includeSchema?: VarJSONSchema.ISchema | VarJSONSchema.ISchema[];
-  excludeSchema?: VarJSONSchema.ISchema | VarJSONSchema.ISchema[];
+  includeSchema?: IJsonSchema | IJsonSchema[];
+  excludeSchema?: IJsonSchema | IJsonSchema[];
 }): TreeNodeData[] {
   const { includeSchema, excludeSchema } = params;
 
@@ -68,8 +70,12 @@ export 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 not match, and no children, return null

package/src/effects/auto-rename-ref/config.json

@@ -0,0 +1,5 @@
+{
+  "name": "auto-rename-ref",
+  "depMaterials": ["flow-value"],
+  "depPackages": ["lodash"]
+}

package/src/effects/auto-rename-ref/index.ts

@@ -0,0 +1,104 @@
+import { isArray, isObject } from 'lodash';
+import {
+  DataEvent,
+  Effect,
+  EffectOptions,
+  VariableFieldKeyRenameService,
+} from '@flowgram.ai/editor';
+
+import { IFlowRefValue } from '../../typings';
+
+/**
+ * Auto rename ref when form item's key is renamed
+ *
+ * Example:
+ *
+ * formMeta: {
+ *  effects: {
+ *    "inputsValues": autoRenameRefEffect,
+ *  }
+ * }
+ */
+export const autoRenameRefEffect: EffectOptions[] = [
+  {
+    event: DataEvent.onValueInit,
+    effect: ((params) => {
+      const { context, form, name } = params;
+
+      const renameService = context.node.getService(VariableFieldKeyRenameService);
+
+      const disposable = renameService.onRename(({ before, after }) => {
+        const beforeKeyPath = [
+          ...before.parentFields.map((_field) => _field.key).reverse(),
+          before.key,
+        ];
+        const afterKeyPath = [
+          ...after.parentFields.map((_field) => _field.key).reverse(),
+          after.key,
+        ];
+
+        // traverse rename refs inside form item 'name'
+        traverseRef(name, form.getValueIn(name), (_drilldownName, _v) => {
+          if (isRefMatch(_v, beforeKeyPath)) {
+            _v.content = [...afterKeyPath, ...(_v.content || [])?.slice(beforeKeyPath.length)];
+            form.setValueIn(_drilldownName, _v);
+          }
+        });
+      });
+
+      return () => {
+        disposable.dispose();
+      };
+    }) as Effect,
+  },
+];
+
+/**
+ * If ref value's keyPath is the under as targetKeyPath
+ * @param value
+ * @param targetKeyPath
+ * @returns
+ */
+function isRefMatch(value: IFlowRefValue, targetKeyPath: string[]) {
+  return targetKeyPath.every((_key, index) => _key === value.content?.[index]);
+}
+
+/**
+ * If value is ref
+ * @param value
+ * @returns
+ */
+function isRef(value: any): value is IFlowRefValue {
+  return (
+    value?.type === 'ref' && Array.isArray(value?.content) && typeof value?.content[0] === 'string'
+  );
+}
+
+/**
+ * Traverse value to find ref
+ * @param value
+ * @param options
+ * @returns
+ */
+function traverseRef(name: string, value: any, cb: (name: string, _v: IFlowRefValue) => void) {
+  if (isObject(value)) {
+    if (isRef(value)) {
+      cb(name, value);
+      return;
+    }
+
+    Object.entries(value).forEach(([_key, _value]) => {
+      traverseRef(`${name}.${_key}`, _value, cb);
+    });
+    return;
+  }
+
+  if (isArray(value)) {
+    value.forEach((_value, idx) => {
+      traverseRef(`${name}[${idx}]`, _value, cb);
+    });
+    return;
+  }
+
+  return;
+}

package/src/effects/index.ts

@@ -1,2 +1,3 @@
 export * from './provide-batch-input';
 export * from './provide-batch-outputs';
+export * from './auto-rename-ref';

package/src/typings/index.ts

@@ -1 +1,2 @@
 export * from './flow-value';
+export * from './json-schema';

package/src/typings/json-schema/config.json

@@ -0,0 +1,5 @@
+{
+  "name": "json-schema",
+  "depMaterials": [],
+  "depPackages": []
+}

package/src/typings/json-schema/index.ts

@@ -0,0 +1,31 @@
+export type JsonSchemaBasicType =
+  | 'boolean'
+  | 'string'
+  | 'integer'
+  | 'number'
+  | 'object'
+  | 'array'
+  | 'map';
+
+export interface IJsonSchema<T = string> {
+  type?: T;
+  default?: any;
+  title?: string;
+  description?: string;
+  enum?: (string | number)[];
+  properties?: Record<string, IJsonSchema<T>>;
+  additionalProperties?: IJsonSchema<T>;
+  items?: IJsonSchema<T>;
+  required?: string[];
+  $ref?: string;
+  extra?: {
+    index?: number;
+    // Used in BaseType.isEqualWithJSONSchema, the type comparison will be weak
+    weak?: boolean;
+    // Set the render component
+    formComponent?: string;
+    [key: string]: any;
+  };
+}
+
+export type IBasicJsonSchema = IJsonSchema<JsonSchemaBasicType>;

package/src/utils/index.ts

@@ -1 +1,2 @@
 export * from './format-legacy-refs';
+export * from './json-schema';

package/src/utils/json-schema/config.json

@@ -0,0 +1,5 @@
+{
+  "name": "json-schema",
+  "depMaterials": ["typings/json-schema"],
+  "depPackages": ["lodash"]
+}

package/src/utils/json-schema/index.ts

@@ -0,0 +1,161 @@
+import { get } from 'lodash';
+import { ASTFactory, ASTKind, ASTMatch, ASTNode, ASTNodeJSON, BaseType } from '@flowgram.ai/editor';
+
+import { IJsonSchema } from '../../typings/json-schema';
+
+export namespace JsonSchemaUtils {
+  /**
+   * Converts a JSON schema to an Abstract Syntax Tree (AST) representation.
+   * This function recursively processes the JSON schema and creates corresponding AST nodes.
+   *
+   * For more information on JSON Schema, refer to the official documentation:
+   * https://json-schema.org/
+   *
+   * @param jsonSchema - The JSON schema to convert.
+   * @returns An AST node representing the JSON schema, or undefined if the schema type is not recognized.
+   */
+  export function schemaToAST(jsonSchema: IJsonSchema): ASTNodeJSON | undefined {
+    const { type, extra } = jsonSchema || {};
+    const { weak = false } = extra || {};
+
+    if (!type) {
+      return undefined;
+    }
+
+    switch (type) {
+      case 'object':
+        if (weak) {
+          return { kind: ASTKind.Object, weak: true };
+        }
+        return ASTFactory.createObject({
+          properties: Object.entries(jsonSchema.properties || {})
+            /**
+             * Sorts the properties of a JSON schema based on the 'extra.index' field.
+             * If the 'extra.index' field is not present, the property will be treated as having an index of 0.
+             */
+            .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:
+        // If the type is not recognized, return CustomType
+        return ASTFactory.createCustomType({ typeName: type });
+    }
+  }
+
+  /**
+   * Convert AST To JSON Schema
+   * @param typeAST
+   * @returns
+   */
+  export function astToSchema(
+    typeAST: ASTNode,
+    options?: { drilldown?: boolean }
+  ): IJsonSchema | undefined {
+    const { drilldown = true } = options || {};
+
+    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: drilldown
+          ? Object.fromEntries(
+              Object.entries(typeAST.properties).map(([key, value]) => [key, astToSchema(value)!])
+            )
+          : {},
+      };
+    }
+
+    if (ASTMatch.isArray(typeAST)) {
+      return {
+        type: 'array',
+        items: drilldown ? astToSchema(typeAST.items) : undefined,
+      };
+    }
+
+    if (ASTMatch.isMap(typeAST)) {
+      return {
+        type: 'map',
+        items: drilldown ? astToSchema(typeAST.valueType) : undefined,
+      };
+    }
+
+    if (ASTMatch.isCustomType(typeAST)) {
+      return {
+        type: typeAST.typeName,
+      };
+    }
+
+    return undefined;
+  }
+
+  /**
+   * Check if the AST type is match the JSON Schema
+   * @param typeAST
+   * @param schema
+   * @returns
+   */
+  export function isASTMatchSchema(
+    typeAST: BaseType,
+    schema: IJsonSchema | IJsonSchema[]
+  ): boolean {
+    if (Array.isArray(schema)) {
+      return typeAST.isTypeEqual(
+        ASTFactory.createUnion({
+          types: schema.map((_schema) => schemaToAST(_schema)!).filter(Boolean),
+        })
+      );
+    }
+
+    return typeAST.isTypeEqual(schemaToAST(schema));
+  }
+}

package/src/components/type-selector/types.ts

@@ -1,5 +0,0 @@
-import { VarJSONSchema } from '@flowgram.ai/editor';
-
-export type BasicType = VarJSONSchema.BasicType;
-
-export type JsonSchema = VarJSONSchema.ISchema;