@flowgram.ai/form-materials 0.1.0-alpha.14 → 0.1.0-alpha.16

package/dist/esm/form-plugins/infer-assign-plugin/index.mjs

@@ -0,0 +1,38 @@
+import { set, uniqBy } from "lodash-es";
+import { JsonSchemaUtils } from "@flowgram.ai/json-schema";
+import { ASTFactory, createEffectFromVariableProvider, defineFormPluginCreator, getNodeScope } from "@flowgram.ai/editor";
+const createInferAssignPlugin = defineFormPluginCreator({
+    onSetupFormMeta ({ addFormatOnSubmit, mergeEffect }, { assignKey, outputKey }) {
+        if (!assignKey || !outputKey) return;
+        mergeEffect({
+            [assignKey]: createEffectFromVariableProvider({
+                parse: (value, ctx)=>{
+                    const declareRows = uniqBy(value.filter((_v)=>'declare' === _v.operator && _v.left && _v.right), 'left');
+                    return [
+                        ASTFactory.createVariableDeclaration({
+                            key: `${ctx.node.id}`,
+                            meta: {
+                                title: ctx.node.form?.getValueIn('title'),
+                                icon: ctx.node.getNodeRegistry().info?.icon
+                            },
+                            type: ASTFactory.createObject({
+                                properties: declareRows.map((_v)=>ASTFactory.createProperty({
+                                        key: _v.left,
+                                        type: _v.right?.type === 'constant' ? JsonSchemaUtils.schemaToAST(_v.right?.schema || {}) : void 0,
+                                        initializer: _v.right?.type === 'ref' ? ASTFactory.createKeyPathExpression({
+                                            keyPath: _v.right?.content || []
+                                        }) : {}
+                                    }))
+                            })
+                        })
+                    ];
+                }
+            })
+        });
+        addFormatOnSubmit((formData, ctx)=>{
+            set(formData, outputKey, JsonSchemaUtils.astToSchema(getNodeScope(ctx.node).output.variables?.[0]?.type));
+            return formData;
+        });
+    }
+});
+export { createInferAssignPlugin };

package/dist/esm/form-plugins/infer-inputs-plugin/index.mjs

@@ -0,0 +1,40 @@
+import { get, omit, set } from "lodash-es";
+import { Immer } from "immer";
+import { defineFormPluginCreator, getNodePrivateScope, getNodeScope } from "@flowgram.ai/editor";
+import { FlowValueUtils } from "../../shared/index.mjs";
+const { produce } = new Immer({
+    autoFreeze: false
+});
+const createInferInputsPlugin = defineFormPluginCreator({
+    onSetupFormMeta ({ addFormatOnSubmit, addFormatOnInit }, { sourceKey, targetKey, scope, ignoreConstantSchema }) {
+        if (!sourceKey || !targetKey) return;
+        addFormatOnSubmit((formData, ctx)=>produce(formData, (draft)=>{
+                const sourceData = get(formData, sourceKey);
+                set(draft, targetKey, FlowValueUtils.inferJsonSchema(sourceData, 'private' === scope ? getNodePrivateScope(ctx.node) : getNodeScope(ctx.node)));
+                if (ignoreConstantSchema) {
+                    for (const { value, path } of FlowValueUtils.traverse(sourceData, {
+                        includeTypes: [
+                            'constant'
+                        ]
+                    }))if (FlowValueUtils.isConstant(value) && value?.schema) set(formData, `${sourceKey}.${path}`, omit(value, [
+                        'schema'
+                    ]));
+                }
+            }));
+        if (ignoreConstantSchema) addFormatOnInit((formData, ctx)=>{
+            const targetSchema = get(formData, targetKey);
+            if (!targetSchema) return formData;
+            for (const { value, pathArr } of FlowValueUtils.traverse(get(formData, sourceKey), {
+                includeTypes: [
+                    'constant'
+                ]
+            }))if (FlowValueUtils.isConstant(value) && !value?.schema) {
+                const schemaPath = pathArr.map((_item)=>`properties.${_item}`).join('.');
+                const schema = get(targetSchema, schemaPath);
+                if (schema) set(value, 'schema', schema);
+            }
+            return formData;
+        });
+    }
+});
+export { createInferInputsPlugin };

package/dist/esm/hooks/index.mjs

@@ -0,0 +1,2 @@
+import { useObjectList } from "./use-object-list/index.mjs";
+export { useObjectList };

package/dist/esm/hooks/use-object-list/index.mjs

@@ -0,0 +1,102 @@
+import { useEffect, useRef, useState } from "react";
+import { nanoid } from "nanoid";
+import { difference, get, isObject, set } from "lodash-es";
+function genId() {
+    return nanoid();
+}
+function useObjectList({ value, onChange, sortIndexKey }) {
+    const [list, setList] = useState([]);
+    const effectVersion = useRef(0);
+    const changeVersion = useRef(0);
+    const getSortIndex = (value)=>{
+        if ('function' == typeof sortIndexKey) return get(value, sortIndexKey(value)) || 0;
+        return get(value, sortIndexKey || '') || 0;
+    };
+    useEffect(()=>{
+        effectVersion.current = effectVersion.current + 1;
+        if (effectVersion.current === changeVersion.current) return;
+        effectVersion.current = changeVersion.current;
+        setList((_prevList)=>{
+            const newKeys = Object.entries(value || {}).sort((a, b)=>getSortIndex(a[1]) - getSortIndex(b[1])).map(([key])=>key);
+            const oldKeys = _prevList.map((item)=>item.key).filter(Boolean);
+            const addKeys = difference(newKeys, oldKeys);
+            return _prevList.filter((item)=>!item.key || newKeys.includes(item.key)).map((item)=>({
+                    id: item.id,
+                    key: item.key,
+                    value: item.key ? value?.[item.key] : item.value
+                })).concat(addKeys.map((_key)=>({
+                    id: genId(),
+                    key: _key,
+                    value: value?.[_key]
+                })));
+        });
+    }, [
+        value
+    ]);
+    const add = (defaultValue)=>{
+        setList((prevList)=>[
+                ...prevList,
+                {
+                    id: genId(),
+                    value: defaultValue
+                }
+            ]);
+    };
+    const updateValue = (itemId, value)=>{
+        changeVersion.current = changeVersion.current + 1;
+        setList((prevList)=>{
+            const nextList = prevList.map((_item)=>{
+                if (_item.id === itemId) return {
+                    ..._item,
+                    value
+                };
+                return _item;
+            });
+            onChange(Object.fromEntries(nextList.filter((item)=>item.key).map((item)=>[
+                    item.key,
+                    item.value
+                ]).map((_res, idx)=>{
+                const indexKey = 'function' == typeof sortIndexKey ? sortIndexKey(_res[1]) : sortIndexKey;
+                if (isObject(_res[1]) && indexKey) set(_res[1], indexKey, idx);
+                return _res;
+            })));
+            return nextList;
+        });
+    };
+    const updateKey = (itemId, key)=>{
+        changeVersion.current = changeVersion.current + 1;
+        setList((prevList)=>{
+            const nextList = prevList.map((_item)=>{
+                if (_item.id === itemId) return {
+                    ..._item,
+                    key
+                };
+                return _item;
+            });
+            onChange(Object.fromEntries(nextList.filter((item)=>item.key).map((item)=>[
+                    item.key,
+                    item.value
+                ])));
+            return nextList;
+        });
+    };
+    const remove = (itemId)=>{
+        changeVersion.current = changeVersion.current + 1;
+        setList((prevList)=>{
+            const nextList = prevList.filter((_item)=>_item.id !== itemId);
+            onChange(Object.fromEntries(nextList.filter((item)=>item.key).map((item)=>[
+                    item.key,
+                    item.value
+                ])));
+            return nextList;
+        });
+    };
+    return {
+        list,
+        add,
+        updateKey,
+        updateValue,
+        remove
+    };
+}
+export { useObjectList };

package/dist/esm/index.mjs

@@ -0,0 +1,8 @@
+import { AssignRow, AssignRows, BaseCodeEditor, BatchOutputs, BatchVariableSelector, BlurInput, CodeEditor, CodeEditorMini, ConditionPresetOp, ConditionProvider, ConditionRow, ConstantInput, DBConditionRow, DisplayFlowValue, DisplayInputsValueAllInTag, DisplayInputsValues, DisplayOutputs, DisplaySchemaTag, DisplaySchemaTree, DynamicValueInput, EditorInputsTree, EditorVariableTagInject, EditorVariableTree, InjectDynamicValueInput, InjectTypeSelector, InjectVariableSelector, InputsValues, InputsValuesTree, JsonCodeEditor, JsonEditorWithVariables, JsonSchemaEditor, PromptEditor, PromptEditorWithInputs, PromptEditorWithVariables, PythonCodeEditor, SQLCodeEditor, SQLEditorWithVariables, ShellCodeEditor, TypeScriptCodeEditor, TypeSelector, VariableSelector, VariableSelectorProvider, getTypeSelectValue, parseTypeSelectValue, useCondition, useConditionContext, useVariableTree } from "./components/index.mjs";
+import { autoRenameRefEffect, listenRefSchemaChange, listenRefValueChange, provideBatchInputEffect, provideJsonSchemaOutputs, syncVariableTitle, validateWhenVariableSync } from "./effects/index.mjs";
+import { createBatchOutputsFormPlugin, createInferAssignPlugin, createInferInputsPlugin, provideBatchOutputsEffect } from "./form-plugins/index.mjs";
+import { useObjectList } from "./hooks/index.mjs";
+import { JsonSchemaTypePresetProvider, JsonSchemaUtils, createDisableDeclarationPlugin, createTypePresetPlugin, useTypeManager } from "./plugins/index.mjs";
+import { FlowValueUtils, createInjectMaterial, formatLegacyRefOnInit, formatLegacyRefOnSubmit, formatLegacyRefToNewRef, formatNewRefToLegacyRef, isLegacyFlowRefValueSchema, isNewFlowRefValueSchema, lazySuspense, polyfillCreateRoot, unstableSetCreateRoot, withSuspense } from "./shared/index.mjs";
+import { validateFlowValue } from "./validate/index.mjs";
+export { AssignRow, AssignRows, BaseCodeEditor, BatchOutputs, BatchVariableSelector, BlurInput, CodeEditor, CodeEditorMini, ConditionPresetOp, ConditionProvider, ConditionRow, ConstantInput, DBConditionRow, DisplayFlowValue, DisplayInputsValueAllInTag, DisplayInputsValues, DisplayOutputs, DisplaySchemaTag, DisplaySchemaTree, DynamicValueInput, EditorInputsTree, EditorVariableTagInject, EditorVariableTree, FlowValueUtils, InjectDynamicValueInput, InjectTypeSelector, InjectVariableSelector, InputsValues, InputsValuesTree, JsonCodeEditor, JsonEditorWithVariables, JsonSchemaEditor, JsonSchemaTypePresetProvider, JsonSchemaUtils, PromptEditor, PromptEditorWithInputs, PromptEditorWithVariables, PythonCodeEditor, SQLCodeEditor, SQLEditorWithVariables, ShellCodeEditor, TypeScriptCodeEditor, TypeSelector, VariableSelector, VariableSelectorProvider, autoRenameRefEffect, createBatchOutputsFormPlugin, createDisableDeclarationPlugin, createInferAssignPlugin, createInferInputsPlugin, createInjectMaterial, createTypePresetPlugin, formatLegacyRefOnInit, formatLegacyRefOnSubmit, formatLegacyRefToNewRef, formatNewRefToLegacyRef, getTypeSelectValue, isLegacyFlowRefValueSchema, isNewFlowRefValueSchema, lazySuspense, listenRefSchemaChange, listenRefValueChange, parseTypeSelectValue, polyfillCreateRoot, provideBatchInputEffect, provideBatchOutputsEffect, provideJsonSchemaOutputs, syncVariableTitle, unstableSetCreateRoot, useCondition, useConditionContext, useObjectList, useTypeManager, useVariableTree, validateFlowValue, validateWhenVariableSync, withSuspense };

package/dist/esm/plugins/disable-declaration-plugin/create-disable-declaration-plugin.mjs

@@ -0,0 +1,17 @@
+import { ASTMatch, VariableEngine, definePluginCreator } from "@flowgram.ai/editor";
+const createDisableDeclarationPlugin = definePluginCreator({
+    onInit (ctx) {
+        const variableEngine = ctx.get(VariableEngine);
+        const handleEvent = (action)=>{
+            if (ASTMatch.isVariableDeclaration(action.ast)) {
+                if (!action.ast.meta?.disabled) action.ast.updateMeta({
+                    ...action.ast.meta || {},
+                    disabled: true
+                });
+            }
+        };
+        variableEngine.onGlobalEvent('NewAST', handleEvent);
+        variableEngine.onGlobalEvent('UpdateAST', handleEvent);
+    }
+});
+export { createDisableDeclarationPlugin };

package/dist/esm/plugins/disable-declaration-plugin/index.mjs

@@ -0,0 +1,2 @@
+import { createDisableDeclarationPlugin } from "./create-disable-declaration-plugin.mjs";
+export { createDisableDeclarationPlugin };

package/dist/esm/plugins/index.mjs

@@ -0,0 +1,3 @@
+import { createDisableDeclarationPlugin } from "./disable-declaration-plugin/index.mjs";
+import { JsonSchemaTypePresetProvider, JsonSchemaUtils, createTypePresetPlugin, useTypeManager } from "./json-schema-preset/index.mjs";
+export { JsonSchemaTypePresetProvider, JsonSchemaUtils, createDisableDeclarationPlugin, createTypePresetPlugin, useTypeManager };

package/dist/esm/plugins/json-schema-preset/create-type-preset-plugin.mjs

@@ -0,0 +1,16 @@
+import { BaseTypeManager, jsonSchemaContainerModule } from "@flowgram.ai/json-schema";
+import { definePluginCreator } from "@flowgram.ai/editor";
+import { initRegistries, jsonSchemaTypePreset } from "./type-definition/index.mjs";
+initRegistries();
+const createTypePresetPlugin = definePluginCreator({
+    onInit (ctx, opts) {
+        const typeManager = ctx.get(BaseTypeManager);
+        jsonSchemaTypePreset.forEach((_type)=>typeManager.register(_type));
+        opts.types?.forEach((_type)=>typeManager.register(_type));
+        opts.unregisterTypes?.forEach((_type)=>typeManager.unregister(_type));
+    },
+    containerModules: [
+        jsonSchemaContainerModule
+    ]
+});
+export { createTypePresetPlugin };

package/dist/esm/plugins/json-schema-preset/index.mjs

@@ -0,0 +1,4 @@
+import { JsonSchemaUtils } from "@flowgram.ai/json-schema";
+import { JsonSchemaTypePresetProvider, useTypeManager } from "./react.mjs";
+import { createTypePresetPlugin } from "./create-type-preset-plugin.mjs";
+export { JsonSchemaTypePresetProvider, JsonSchemaUtils, createTypePresetPlugin, useTypeManager };

package/dist/esm/plugins/json-schema-preset/react.mjs

@@ -0,0 +1,14 @@
+import { jsx } from "react/jsx-runtime";
+import "react";
+import { TypePresetProvider, useTypeManager } from "@flowgram.ai/json-schema";
+import { initRegistries, jsonSchemaTypePreset } from "./type-definition/index.mjs";
+initRegistries();
+const react_useTypeManager = ()=>useTypeManager();
+const JsonSchemaTypePresetProvider = ({ types = [], children })=>/*#__PURE__*/ jsx(TypePresetProvider, {
+        types: [
+            ...jsonSchemaTypePreset,
+            ...types
+        ],
+        children: children
+    });
+export { JsonSchemaTypePresetProvider, react_useTypeManager as useTypeManager };

package/dist/esm/plugins/json-schema-preset/type-definition/array.mjs

@@ -0,0 +1,44 @@
+import { jsx } from "react/jsx-runtime";
+import "react";
+import { I18n } from "@flowgram.ai/editor";
+import { ConditionPresetOp } from "../../../components/condition-context/op.mjs";
+import { JsonCodeEditor } from "../../../components/code-editor/index.mjs";
+const arrayRegistry = {
+    type: 'array',
+    ConstantRenderer: (props)=>/*#__PURE__*/ jsx(JsonCodeEditor, {
+            mini: true,
+            value: props.value,
+            onChange: (v)=>props.onChange?.(v),
+            placeholder: I18n.t('Please Input Array'),
+            readonly: props.readonly
+        }),
+    conditionRule: {
+        [ConditionPresetOp.IS_EMPTY]: null,
+        [ConditionPresetOp.IS_NOT_EMPTY]: null,
+        [ConditionPresetOp.CONTAINS]: {
+            type: 'array',
+            extra: {
+                weak: true
+            }
+        },
+        [ConditionPresetOp.NOT_CONTAINS]: {
+            type: 'array',
+            extra: {
+                weak: true
+            }
+        },
+        [ConditionPresetOp.EQ]: {
+            type: 'array',
+            extra: {
+                weak: true
+            }
+        },
+        [ConditionPresetOp.NEQ]: {
+            type: 'array',
+            extra: {
+                weak: true
+            }
+        }
+    }
+};
+export { arrayRegistry };

package/dist/esm/plugins/json-schema-preset/type-definition/boolean.mjs

@@ -0,0 +1,52 @@
+import { jsx } from "react/jsx-runtime";
+import "react";
+import { I18n } from "@flowgram.ai/editor";
+import { Select } from "@douyinfe/semi-ui";
+import { ConditionPresetOp } from "../../../components/condition-context/op.mjs";
+const booleanRegistry = {
+    type: 'boolean',
+    ConstantRenderer: (props)=>{
+        const { value, onChange, ...rest } = props;
+        return /*#__PURE__*/ jsx(Select, {
+            placeholder: I18n.t('Please Select Boolean'),
+            size: "small",
+            disabled: props.readonly,
+            optionList: [
+                {
+                    label: I18n.t('True'),
+                    value: 1
+                },
+                {
+                    label: I18n.t('False'),
+                    value: 0
+                }
+            ],
+            value: value ? 1 : 0,
+            onChange: (value)=>onChange?.(!!value),
+            ...rest
+        });
+    },
+    conditionRule: {
+        [ConditionPresetOp.EQ]: {
+            type: 'boolean'
+        },
+        [ConditionPresetOp.NEQ]: {
+            type: 'boolean'
+        },
+        [ConditionPresetOp.IS_TRUE]: null,
+        [ConditionPresetOp.IS_FALSE]: null,
+        [ConditionPresetOp.IN]: {
+            type: 'array',
+            items: {
+                type: 'boolean'
+            }
+        },
+        [ConditionPresetOp.NIN]: {
+            type: 'array',
+            items: {
+                type: 'boolean'
+            }
+        }
+    }
+};
+export { booleanRegistry };

package/dist/esm/plugins/json-schema-preset/type-definition/date-time.mjs

@@ -0,0 +1,47 @@
+import { jsx } from "react/jsx-runtime";
+import "react";
+import { format } from "date-fns";
+import { DatePicker } from "@douyinfe/semi-ui";
+import { ConditionPresetOp } from "../../../components/condition-context/op.mjs";
+const dateTimeRegistry = {
+    type: 'date-time',
+    ConstantRenderer: (props)=>/*#__PURE__*/ jsx(DatePicker, {
+            size: "small",
+            type: "dateTime",
+            density: "compact",
+            defaultValue: Date.now(),
+            style: {
+                width: '100%',
+                ...props.style || {}
+            },
+            disabled: props.readonly,
+            ...props,
+            onChange: (date)=>{
+                props.onChange?.(format(date, "yyyy-MM-dd'T'HH:mm:ss.SSS'Z'"));
+            },
+            value: props.value
+        }),
+    conditionRule: {
+        [ConditionPresetOp.EQ]: {
+            type: 'date-time'
+        },
+        [ConditionPresetOp.NEQ]: {
+            type: 'date-time'
+        },
+        [ConditionPresetOp.GT]: {
+            type: 'date-time'
+        },
+        [ConditionPresetOp.GTE]: {
+            type: 'date-time'
+        },
+        [ConditionPresetOp.LT]: {
+            type: 'date-time'
+        },
+        [ConditionPresetOp.LTE]: {
+            type: 'date-time'
+        },
+        [ConditionPresetOp.IS_EMPTY]: null,
+        [ConditionPresetOp.IS_NOT_EMPTY]: null
+    }
+};
+export { dateTimeRegistry };

package/dist/esm/plugins/json-schema-preset/type-definition/index.mjs

@@ -0,0 +1,24 @@
+import { jsonSchemaTypeManager } from "@flowgram.ai/json-schema";
+import { stringRegistry } from "./string.mjs";
+import { objectRegistry } from "./object.mjs";
+import { numberRegistry } from "./number.mjs";
+import { mapRegistry } from "./map.mjs";
+import { integerRegistry } from "./integer.mjs";
+import { dateTimeRegistry } from "./date-time.mjs";
+import { booleanRegistry } from "./boolean.mjs";
+import { arrayRegistry } from "./array.mjs";
+const jsonSchemaTypePreset = [
+    stringRegistry,
+    objectRegistry,
+    numberRegistry,
+    integerRegistry,
+    booleanRegistry,
+    arrayRegistry,
+    mapRegistry,
+    dateTimeRegistry
+];
+const initRegistries = ()=>{
+    if (jsonSchemaTypeManager.getTypeByName('string')?.ConstantRenderer) return;
+    jsonSchemaTypePreset.forEach((_type)=>jsonSchemaTypeManager.register(_type));
+};
+export { initRegistries, jsonSchemaTypePreset };

package/dist/esm/plugins/json-schema-preset/type-definition/integer.mjs

@@ -0,0 +1,48 @@
+import { jsx } from "react/jsx-runtime";
+import "react";
+import { I18n } from "@flowgram.ai/editor";
+import { InputNumber } from "@douyinfe/semi-ui";
+import { ConditionPresetOp } from "../../../components/condition-context/op.mjs";
+const integerRegistry = {
+    type: 'integer',
+    ConstantRenderer: (props)=>/*#__PURE__*/ jsx(InputNumber, {
+            placeholder: I18n.t('Please Input Integer'),
+            size: "small",
+            disabled: props.readonly,
+            precision: 0,
+            ...props
+        }),
+    conditionRule: {
+        [ConditionPresetOp.EQ]: {
+            type: 'number'
+        },
+        [ConditionPresetOp.NEQ]: {
+            type: 'number'
+        },
+        [ConditionPresetOp.GT]: {
+            type: 'number'
+        },
+        [ConditionPresetOp.GTE]: {
+            type: 'number'
+        },
+        [ConditionPresetOp.LT]: {
+            type: 'number'
+        },
+        [ConditionPresetOp.LTE]: {
+            type: 'number'
+        },
+        [ConditionPresetOp.IN]: {
+            type: 'array',
+            extra: {
+                weak: true
+            }
+        },
+        [ConditionPresetOp.NIN]: {
+            type: 'array',
+            extra: {
+                weak: true
+            }
+        }
+    }
+};
+export { integerRegistry };

package/dist/esm/plugins/json-schema-preset/type-definition/map.mjs

@@ -0,0 +1,20 @@
+import { jsx } from "react/jsx-runtime";
+import "react";
+import { I18n } from "@flowgram.ai/editor";
+import { ConditionPresetOp } from "../../../components/condition-context/op.mjs";
+import { JsonCodeEditor } from "../../../components/code-editor/index.mjs";
+const mapRegistry = {
+    type: 'map',
+    ConstantRenderer: (props)=>/*#__PURE__*/ jsx(JsonCodeEditor, {
+            mini: true,
+            value: props.value,
+            onChange: (v)=>props.onChange?.(v),
+            placeholder: I18n.t('Please Input Map'),
+            readonly: props.readonly
+        }),
+    conditionRule: {
+        [ConditionPresetOp.IS_EMPTY]: null,
+        [ConditionPresetOp.IS_NOT_EMPTY]: null
+    }
+};
+export { mapRegistry };

package/dist/esm/plugins/json-schema-preset/type-definition/number.mjs

@@ -0,0 +1,48 @@
+import { jsx } from "react/jsx-runtime";
+import "react";
+import { I18n } from "@flowgram.ai/editor";
+import { InputNumber } from "@douyinfe/semi-ui";
+import { ConditionPresetOp } from "../../../components/condition-context/op.mjs";
+const numberRegistry = {
+    type: 'number',
+    ConstantRenderer: (props)=>/*#__PURE__*/ jsx(InputNumber, {
+            placeholder: I18n.t('Please Input Number'),
+            size: "small",
+            disabled: props.readonly,
+            hideButtons: true,
+            ...props
+        }),
+    conditionRule: {
+        [ConditionPresetOp.EQ]: {
+            type: 'number'
+        },
+        [ConditionPresetOp.NEQ]: {
+            type: 'number'
+        },
+        [ConditionPresetOp.GT]: {
+            type: 'number'
+        },
+        [ConditionPresetOp.GTE]: {
+            type: 'number'
+        },
+        [ConditionPresetOp.LT]: {
+            type: 'number'
+        },
+        [ConditionPresetOp.LTE]: {
+            type: 'number'
+        },
+        [ConditionPresetOp.IN]: {
+            type: 'array',
+            extra: {
+                weak: true
+            }
+        },
+        [ConditionPresetOp.NIN]: {
+            type: 'array',
+            extra: {
+                weak: true
+            }
+        }
+    }
+};
+export { numberRegistry };

package/dist/esm/plugins/json-schema-preset/type-definition/object.mjs

@@ -0,0 +1,20 @@
+import { jsx } from "react/jsx-runtime";
+import "react";
+import { I18n } from "@flowgram.ai/editor";
+import { ConditionPresetOp } from "../../../components/condition-context/op.mjs";
+import { JsonCodeEditor } from "../../../components/code-editor/index.mjs";
+const objectRegistry = {
+    type: 'object',
+    ConstantRenderer: (props)=>/*#__PURE__*/ jsx(JsonCodeEditor, {
+            mini: true,
+            value: props.value,
+            onChange: (v)=>props.onChange?.(v),
+            placeholder: I18n.t('Please Input Object'),
+            readonly: props.readonly
+        }),
+    conditionRule: {
+        [ConditionPresetOp.IS_EMPTY]: null,
+        [ConditionPresetOp.IS_NOT_EMPTY]: null
+    }
+};
+export { objectRegistry };

package/dist/esm/plugins/json-schema-preset/type-definition/string.mjs

@@ -0,0 +1,49 @@
+import { jsx } from "react/jsx-runtime";
+import "react";
+import { I18n } from "@flowgram.ai/editor";
+import { Input, TextArea } from "@douyinfe/semi-ui";
+import { ConditionPresetOp } from "../../../components/condition-context/op.mjs";
+const stringRegistry = {
+    type: 'string',
+    ConstantRenderer: (props)=>props?.enableMultiLineStr ? /*#__PURE__*/ jsx(TextArea, {
+            autosize: true,
+            rows: 1,
+            placeholder: I18n.t('Please Input String'),
+            disabled: props.readonly,
+            ...props
+        }) : /*#__PURE__*/ jsx(Input, {
+            size: "small",
+            placeholder: I18n.t('Please Input String'),
+            disabled: props.readonly,
+            ...props
+        }),
+    conditionRule: {
+        [ConditionPresetOp.EQ]: {
+            type: 'string'
+        },
+        [ConditionPresetOp.NEQ]: {
+            type: 'string'
+        },
+        [ConditionPresetOp.CONTAINS]: {
+            type: 'string'
+        },
+        [ConditionPresetOp.NOT_CONTAINS]: {
+            type: 'string'
+        },
+        [ConditionPresetOp.IN]: {
+            type: 'array',
+            items: {
+                type: 'string'
+            }
+        },
+        [ConditionPresetOp.NIN]: {
+            type: 'array',
+            items: {
+                type: 'string'
+            }
+        },
+        [ConditionPresetOp.IS_EMPTY]: null,
+        [ConditionPresetOp.IS_NOT_EMPTY]: null
+    }
+};
+export { stringRegistry };

package/dist/esm/shared/flow-value/index.mjs

@@ -0,0 +1,2 @@
+import { FlowValueUtils } from "./utils.mjs";
+export { FlowValueUtils };

package/dist/esm/shared/flow-value/schema.mjs

@@ -0,0 +1,26 @@
+import zod from "zod";
+const extraSchema = zod.object({
+    index: zod.number().optional()
+}).optional();
+const constantSchema = zod.object({
+    type: zod.literal('constant'),
+    content: zod.any().optional(),
+    schema: zod.any().optional(),
+    extra: extraSchema
+});
+const refSchema = zod.object({
+    type: zod.literal('ref'),
+    content: zod.array(zod.string()).optional(),
+    extra: extraSchema
+});
+const expressionSchema = zod.object({
+    type: zod.literal('expression'),
+    content: zod.string().optional(),
+    extra: extraSchema
+});
+const templateSchema = zod.object({
+    type: zod.literal('template'),
+    content: zod.string().optional(),
+    extra: extraSchema
+});
+export { constantSchema, expressionSchema, extraSchema, refSchema, templateSchema };