@flowgram.ai/form-materials 0.4.9 → 0.4.11

package/dist/esm/effects/listen-ref-value-change/index.mjs

@@ -0,0 +1,20 @@
+import { DataEvent, getNodeScope } from "@flowgram.ai/editor";
+const listenRefValueChange = (cb)=>[
+        {
+            event: DataEvent.onValueInitOrChange,
+            effect: (params)=>{
+                const { context, value } = params;
+                if (value?.type !== 'ref') return ()=>null;
+                const disposable = getNodeScope(context.node).available.trackByKeyPath(value?.content || [], (v)=>{
+                    cb({
+                        ...params,
+                        variable: v
+                    });
+                });
+                return ()=>{
+                    disposable.dispose();
+                };
+            }
+        }
+    ];
+export { listenRefValueChange };

package/dist/esm/effects/provide-batch-input/index.mjs

@@ -0,0 +1,30 @@
+import { ASTFactory, createEffectFromVariableProvider, getNodeForm } from "@flowgram.ai/editor";
+const provideBatchInputEffect = createEffectFromVariableProvider({
+    private: true,
+    parse: (value, ctx)=>[
+            ASTFactory.createVariableDeclaration({
+                key: `${ctx.node.id}_locals`,
+                meta: {
+                    title: getNodeForm(ctx.node)?.getValueIn('title'),
+                    icon: ctx.node.getNodeRegistry().info?.icon
+                },
+                type: ASTFactory.createObject({
+                    properties: [
+                        ASTFactory.createProperty({
+                            key: 'item',
+                            initializer: ASTFactory.createEnumerateExpression({
+                                enumerateFor: ASTFactory.createKeyPathExpression({
+                                    keyPath: value.content || []
+                                })
+                            })
+                        }),
+                        ASTFactory.createProperty({
+                            key: 'index',
+                            type: ASTFactory.createNumber()
+                        })
+                    ]
+                })
+            })
+        ]
+});
+export { provideBatchInputEffect };

package/dist/esm/effects/provide-json-schema-outputs/index.mjs

@@ -0,0 +1,15 @@
+import { JsonSchemaUtils } from "@flowgram.ai/json-schema";
+import { ASTFactory, createEffectFromVariableProvider, getNodeForm } from "@flowgram.ai/editor";
+const provideJsonSchemaOutputs = createEffectFromVariableProvider({
+    parse: (value, ctx)=>[
+            ASTFactory.createVariableDeclaration({
+                key: `${ctx.node.id}`,
+                meta: {
+                    title: getNodeForm(ctx.node)?.getValueIn('title') || ctx.node.id,
+                    icon: ctx.node.getNodeRegistry().info?.icon
+                },
+                type: JsonSchemaUtils.schemaToAST(value)
+            })
+        ]
+});
+export { provideJsonSchemaOutputs };

package/dist/esm/effects/sync-variable-title/index.mjs

@@ -0,0 +1,18 @@
+import { DataEvent, FlowNodeVariableData } from "@flowgram.ai/editor";
+const syncVariableTitle = [
+    {
+        event: DataEvent.onValueChange,
+        effect: ({ value, context })=>{
+            context.node.getData(FlowNodeVariableData).allScopes.forEach((_scope)=>{
+                _scope.output.variables.forEach((_var)=>{
+                    _var.updateMeta({
+                        ..._var.meta || {},
+                        title: value || context.node.id,
+                        icon: context.node.getNodeRegistry().info?.icon
+                    });
+                });
+            });
+        }
+    }
+];
+export { syncVariableTitle };

package/dist/esm/effects/validate-when-variable-sync/index.mjs

@@ -0,0 +1,15 @@
+import { isEmpty } from "lodash-es";
+import { DataEvent, getNodePrivateScope, getNodeScope } from "@flowgram.ai/editor";
+const validateWhenVariableSync = ({ scope } = {})=>[
+        {
+            event: DataEvent.onValueInit,
+            effect: ({ context, form })=>{
+                const nodeScope = 'private' === scope ? getNodePrivateScope(context.node) : getNodeScope(context.node);
+                const disposable = nodeScope.available.onListOrAnyVarChange(()=>{
+                    if (!isEmpty(form.state.errors)) form.validate();
+                });
+                return ()=>disposable.dispose();
+            }
+        }
+    ];
+export { validateWhenVariableSync };

package/dist/esm/form-plugins/batch-outputs-plugin/index.mjs

@@ -0,0 +1,60 @@
+import { ASTFactory, FlowNodeScopeType, ScopeChainTransformService, createEffectFromVariableProvider, defineFormPluginCreator, getNodeForm, getNodePrivateScope, getNodeScope } from "@flowgram.ai/editor";
+const provideBatchOutputsEffect = createEffectFromVariableProvider({
+    parse: (value, ctx)=>[
+            ASTFactory.createVariableDeclaration({
+                key: `${ctx.node.id}`,
+                meta: {
+                    title: getNodeForm(ctx.node)?.getValueIn('title'),
+                    icon: ctx.node.getNodeRegistry().info?.icon
+                },
+                type: ASTFactory.createObject({
+                    properties: Object.entries(value).map(([_key, value])=>ASTFactory.createProperty({
+                            key: _key,
+                            initializer: ASTFactory.createWrapArrayExpression({
+                                wrapFor: ASTFactory.createKeyPathExpression({
+                                    keyPath: value?.content || []
+                                })
+                            })
+                        }))
+                })
+            })
+        ]
+});
+const createBatchOutputsFormPlugin = defineFormPluginCreator({
+    name: 'batch-outputs-plugin',
+    onSetupFormMeta ({ mergeEffect }, { outputKey }) {
+        mergeEffect({
+            [outputKey]: provideBatchOutputsEffect
+        });
+    },
+    onInit (ctx, { outputKey }) {
+        const chainTransformService = ctx.node.getService(ScopeChainTransformService);
+        const batchNodeType = ctx.node.flowNodeType;
+        const transformerId = `${batchNodeType}-outputs`;
+        if (chainTransformService.hasTransformer(transformerId)) return;
+        chainTransformService.registerTransformer(transformerId, {
+            transformCovers: (covers, ctx)=>{
+                const node = ctx.scope.meta?.node;
+                if (node?.parent?.flowNodeType === batchNodeType) return [
+                    ...covers,
+                    getNodeScope(node.parent)
+                ];
+                return covers;
+            },
+            transformDeps (scopes, ctx) {
+                const scopeMeta = ctx.scope.meta;
+                if (scopeMeta?.type === FlowNodeScopeType["private"]) return scopes;
+                const node = scopeMeta?.node;
+                if (node?.flowNodeType === batchNodeType) {
+                    const childBlocks = node.blocks;
+                    return [
+                        getNodePrivateScope(node),
+                        ...childBlocks.map((_childBlock)=>getNodeScope(_childBlock))
+                    ];
+                }
+                return scopes;
+            }
+        });
+    }
+});
+export { createBatchOutputsFormPlugin, provideBatchOutputsEffect };

package/dist/esm/form-plugins/index.mjs

@@ -0,0 +1,4 @@
+import { createBatchOutputsFormPlugin, provideBatchOutputsEffect } from "./batch-outputs-plugin/index.mjs";
+import { createInferAssignPlugin } from "./infer-assign-plugin/index.mjs";
+import { createInferInputsPlugin } from "./infer-inputs-plugin/index.mjs";
+export { createBatchOutputsFormPlugin, createInferAssignPlugin, createInferInputsPlugin, provideBatchOutputsEffect };

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, getNodeForm, 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: getNodeForm(ctx.node)?.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,13 @@
+import { get, set } from "lodash-es";
+import { defineFormPluginCreator, getNodePrivateScope, getNodeScope } from "@flowgram.ai/editor";
+import { FlowValueUtils } from "../../shared/index.mjs";
+const createInferInputsPlugin = defineFormPluginCreator({
+    onSetupFormMeta ({ addFormatOnSubmit }, { sourceKey, targetKey, scope }) {
+        if (!sourceKey || !targetKey) return;
+        addFormatOnSubmit((formData, ctx)=>{
+            set(formData, targetKey, FlowValueUtils.inferJsonSchema(get(formData, sourceKey), 'private' === scope ? getNodePrivateScope(ctx.node) : getNodeScope(ctx.node)));
+            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, BatchOutputs, BatchVariableSelector, BlurInput, CodeEditor, CodeEditorMini, ConditionRow, ConstantInput, DBConditionRow, DisplayFlowValue, DisplayInputsValueAllInTag, DisplayInputsValues, DisplayOutputs, DisplaySchemaTag, DisplaySchemaTree, DynamicValueInput, EditorInputsTree, EditorVariableTagInject, EditorVariableTree, InjectDynamicValueInput, InjectTypeSelector, InjectVariableSelector, InputsValues, InputsValuesTree, JsonEditorWithVariables, JsonSchemaEditor, PromptEditor, PromptEditorWithInputs, PromptEditorWithVariables, TypeSelector, VariableSelector, VariableSelectorProvider, getTypeSelectValue, parseTypeSelectValue, 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, BatchOutputs, BatchVariableSelector, BlurInput, CodeEditor, CodeEditorMini, ConditionRow, ConstantInput, DBConditionRow, DisplayFlowValue, DisplayInputsValueAllInTag, DisplayInputsValues, DisplayOutputs, DisplaySchemaTag, DisplaySchemaTree, DynamicValueInput, EditorInputsTree, EditorVariableTagInject, EditorVariableTree, FlowValueUtils, InjectDynamicValueInput, InjectTypeSelector, InjectVariableSelector, InputsValues, InputsValuesTree, JsonEditorWithVariables, JsonSchemaEditor, JsonSchemaTypePresetProvider, JsonSchemaUtils, PromptEditor, PromptEditorWithInputs, PromptEditorWithVariables, 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, 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,15 @@
+import { BaseTypeManager, jsonSchemaContainerModule } from "@flowgram.ai/json-schema";
+import { definePluginCreator } from "@flowgram.ai/editor";
+import { jsonSchemaTypePreset } from "./type-definition/index.mjs";
+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,14 @@
+import { jsx } from "react/jsx-runtime";
+import "react";
+import { JsonSchemaUtils, TypePresetProvider, useTypeManager } from "@flowgram.ai/json-schema";
+import { jsonSchemaTypePreset } from "./type-definition/index.mjs";
+import { createTypePresetPlugin } from "./create-type-preset-plugin.mjs";
+const json_schema_preset_useTypeManager = ()=>useTypeManager();
+const JsonSchemaTypePresetProvider = ({ types = [], children })=>/*#__PURE__*/ jsx(TypePresetProvider, {
+        types: [
+            ...jsonSchemaTypePreset,
+            ...types
+        ],
+        children: children
+    });
+export { JsonSchemaTypePresetProvider, JsonSchemaUtils, createTypePresetPlugin, json_schema_preset_useTypeManager as useTypeManager };

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

@@ -0,0 +1,15 @@
+import { jsx } from "react/jsx-runtime";
+import "react";
+import { I18n } from "@flowgram.ai/editor";
+import { CodeEditorMini } from "../../../components/code-editor-mini/index.mjs";
+const arrayRegistry = {
+    type: 'array',
+    ConstantRenderer: (props)=>/*#__PURE__*/ jsx(CodeEditorMini, {
+            value: props.value,
+            languageId: "json",
+            onChange: (v)=>props.onChange?.(v),
+            placeholder: I18n.t('Please Input Array'),
+            readonly: props.readonly
+        })
+};
+export { arrayRegistry };

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

@@ -0,0 +1,29 @@
+import { jsx } from "react/jsx-runtime";
+import "react";
+import { I18n } from "@flowgram.ai/editor";
+import { Select } from "@douyinfe/semi-ui";
+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
+        });
+    }
+};
+export { booleanRegistry };

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

@@ -0,0 +1,18 @@
+import { jsx } from "react/jsx-runtime";
+import "react";
+import { DatePicker } from "@douyinfe/semi-ui";
+const dateTimeRegistry = {
+    type: 'date-time',
+    ConstantRenderer: (props)=>/*#__PURE__*/ jsx(DatePicker, {
+            size: "small",
+            type: "dateTime",
+            density: "compact",
+            style: {
+                width: '100%',
+                ...props.style || {}
+            },
+            disabled: props.readonly,
+            ...props
+        })
+};
+export { dateTimeRegistry };

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

@@ -0,0 +1,19 @@
+import { jsonSchemaTypeManager } from "@flowgram.ai/json-schema";
+import { stringRegistry } from "./string.mjs";
+import { objectRegistry } from "./object.mjs";
+import { numberRegistry } from "./number.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,
+    dateTimeRegistry
+];
+jsonSchemaTypePreset.forEach((_type)=>jsonSchemaTypeManager.register(_type));
+export { jsonSchemaTypePreset };

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

@@ -0,0 +1,15 @@
+import { jsx } from "react/jsx-runtime";
+import "react";
+import { I18n } from "@flowgram.ai/editor";
+import { InputNumber } from "@douyinfe/semi-ui";
+const integerRegistry = {
+    type: 'integer',
+    ConstantRenderer: (props)=>/*#__PURE__*/ jsx(InputNumber, {
+            placeholder: I18n.t('Please Input Integer'),
+            size: "small",
+            disabled: props.readonly,
+            precision: 0,
+            ...props
+        })
+};
+export { integerRegistry };

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

@@ -0,0 +1,15 @@
+import { jsx } from "react/jsx-runtime";
+import "react";
+import { I18n } from "@flowgram.ai/editor";
+import { InputNumber } from "@douyinfe/semi-ui";
+const numberRegistry = {
+    type: 'number',
+    ConstantRenderer: (props)=>/*#__PURE__*/ jsx(InputNumber, {
+            placeholder: I18n.t('Please Input Number'),
+            size: "small",
+            disabled: props.readonly,
+            hideButtons: true,
+            ...props
+        })
+};
+export { numberRegistry };

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

@@ -0,0 +1,15 @@
+import { jsx } from "react/jsx-runtime";
+import "react";
+import { I18n } from "@flowgram.ai/editor";
+import { CodeEditorMini } from "../../../components/code-editor-mini/index.mjs";
+const objectRegistry = {
+    type: 'object',
+    ConstantRenderer: (props)=>/*#__PURE__*/ jsx(CodeEditorMini, {
+            value: props.value,
+            onChange: (v)=>props.onChange?.(v),
+            languageId: "json",
+            placeholder: I18n.t('Please Input Object'),
+            readonly: props.readonly
+        })
+};
+export { objectRegistry };

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

@@ -0,0 +1,20 @@
+import { jsx } from "react/jsx-runtime";
+import "react";
+import { I18n } from "@flowgram.ai/editor";
+import { Input, TextArea } from "@douyinfe/semi-ui";
+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
+        })
+};
+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 };