@flowgram.ai/form-materials 0.4.8 → 0.4.10

package/dist/cjs/effects/provide-batch-input/index.js

@@ -0,0 +1,64 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ('undefined' != typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    provideBatchInputEffect: ()=>provideBatchInputEffect
+});
+const editor_namespaceObject = require("@flowgram.ai/editor");
+const provideBatchInputEffect = (0, editor_namespaceObject.createEffectFromVariableProvider)({
+    private: true,
+    parse: (value, ctx)=>[
+            editor_namespaceObject.ASTFactory.createVariableDeclaration({
+                key: `${ctx.node.id}_locals`,
+                meta: {
+                    title: (0, editor_namespaceObject.getNodeForm)(ctx.node)?.getValueIn('title'),
+                    icon: ctx.node.getNodeRegistry().info?.icon
+                },
+                type: editor_namespaceObject.ASTFactory.createObject({
+                    properties: [
+                        editor_namespaceObject.ASTFactory.createProperty({
+                            key: 'item',
+                            initializer: editor_namespaceObject.ASTFactory.createEnumerateExpression({
+                                enumerateFor: editor_namespaceObject.ASTFactory.createKeyPathExpression({
+                                    keyPath: value.content || []
+                                })
+                            })
+                        }),
+                        editor_namespaceObject.ASTFactory.createProperty({
+                            key: 'index',
+                            type: editor_namespaceObject.ASTFactory.createNumber()
+                        })
+                    ]
+                })
+            })
+        ]
+});
+exports.provideBatchInputEffect = __webpack_exports__.provideBatchInputEffect;
+for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+    "provideBatchInputEffect"
+].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/effects/provide-json-schema-outputs/index.js

@@ -0,0 +1,49 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ('undefined' != typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    provideJsonSchemaOutputs: ()=>provideJsonSchemaOutputs
+});
+const json_schema_namespaceObject = require("@flowgram.ai/json-schema");
+const editor_namespaceObject = require("@flowgram.ai/editor");
+const provideJsonSchemaOutputs = (0, editor_namespaceObject.createEffectFromVariableProvider)({
+    parse: (value, ctx)=>[
+            editor_namespaceObject.ASTFactory.createVariableDeclaration({
+                key: `${ctx.node.id}`,
+                meta: {
+                    title: (0, editor_namespaceObject.getNodeForm)(ctx.node)?.getValueIn('title') || ctx.node.id,
+                    icon: ctx.node.getNodeRegistry().info?.icon
+                },
+                type: json_schema_namespaceObject.JsonSchemaUtils.schemaToAST(value)
+            })
+        ]
+});
+exports.provideJsonSchemaOutputs = __webpack_exports__.provideJsonSchemaOutputs;
+for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+    "provideJsonSchemaOutputs"
+].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/effects/sync-variable-title/index.js

@@ -0,0 +1,52 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ('undefined' != typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    syncVariableTitle: ()=>syncVariableTitle
+});
+const editor_namespaceObject = require("@flowgram.ai/editor");
+const syncVariableTitle = [
+    {
+        event: editor_namespaceObject.DataEvent.onValueChange,
+        effect: ({ value, context })=>{
+            context.node.getData(editor_namespaceObject.FlowNodeVariableData).allScopes.forEach((_scope)=>{
+                _scope.output.variables.forEach((_var)=>{
+                    _var.updateMeta({
+                        ..._var.meta || {},
+                        title: value || context.node.id,
+                        icon: context.node.getNodeRegistry().info?.icon
+                    });
+                });
+            });
+        }
+    }
+];
+exports.syncVariableTitle = __webpack_exports__.syncVariableTitle;
+for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+    "syncVariableTitle"
+].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/effects/validate-when-variable-sync/index.js

@@ -0,0 +1,49 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ('undefined' != typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    validateWhenVariableSync: ()=>validateWhenVariableSync
+});
+const external_lodash_es_namespaceObject = require("lodash-es");
+const editor_namespaceObject = require("@flowgram.ai/editor");
+const validateWhenVariableSync = ({ scope } = {})=>[
+        {
+            event: editor_namespaceObject.DataEvent.onValueInit,
+            effect: ({ context, form })=>{
+                const nodeScope = 'private' === scope ? (0, editor_namespaceObject.getNodePrivateScope)(context.node) : (0, editor_namespaceObject.getNodeScope)(context.node);
+                const disposable = nodeScope.available.onListOrAnyVarChange(()=>{
+                    if (!(0, external_lodash_es_namespaceObject.isEmpty)(form.state.errors)) form.validate();
+                });
+                return ()=>disposable.dispose();
+            }
+        }
+    ];
+exports.validateWhenVariableSync = __webpack_exports__.validateWhenVariableSync;
+for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+    "validateWhenVariableSync"
+].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/form-plugins/batch-outputs-plugin/index.js

@@ -0,0 +1,97 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ('undefined' != typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    createBatchOutputsFormPlugin: ()=>createBatchOutputsFormPlugin,
+    provideBatchOutputsEffect: ()=>provideBatchOutputsEffect
+});
+const editor_namespaceObject = require("@flowgram.ai/editor");
+const provideBatchOutputsEffect = (0, editor_namespaceObject.createEffectFromVariableProvider)({
+    parse: (value, ctx)=>[
+            editor_namespaceObject.ASTFactory.createVariableDeclaration({
+                key: `${ctx.node.id}`,
+                meta: {
+                    title: (0, editor_namespaceObject.getNodeForm)(ctx.node)?.getValueIn('title'),
+                    icon: ctx.node.getNodeRegistry().info?.icon
+                },
+                type: editor_namespaceObject.ASTFactory.createObject({
+                    properties: Object.entries(value).map(([_key, value])=>editor_namespaceObject.ASTFactory.createProperty({
+                            key: _key,
+                            initializer: editor_namespaceObject.ASTFactory.createWrapArrayExpression({
+                                wrapFor: editor_namespaceObject.ASTFactory.createKeyPathExpression({
+                                    keyPath: value?.content || []
+                                })
+                            })
+                        }))
+                })
+            })
+        ]
+});
+const createBatchOutputsFormPlugin = (0, editor_namespaceObject.defineFormPluginCreator)({
+    name: 'batch-outputs-plugin',
+    onSetupFormMeta ({ mergeEffect }, { outputKey }) {
+        mergeEffect({
+            [outputKey]: provideBatchOutputsEffect
+        });
+    },
+    onInit (ctx, { outputKey }) {
+        const chainTransformService = ctx.node.getService(editor_namespaceObject.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,
+                    (0, editor_namespaceObject.getNodeScope)(node.parent)
+                ];
+                return covers;
+            },
+            transformDeps (scopes, ctx) {
+                const scopeMeta = ctx.scope.meta;
+                if (scopeMeta?.type === editor_namespaceObject.FlowNodeScopeType["private"]) return scopes;
+                const node = scopeMeta?.node;
+                if (node?.flowNodeType === batchNodeType) {
+                    const childBlocks = node.blocks;
+                    return [
+                        (0, editor_namespaceObject.getNodePrivateScope)(node),
+                        ...childBlocks.map((_childBlock)=>(0, editor_namespaceObject.getNodeScope)(_childBlock))
+                    ];
+                }
+                return scopes;
+            }
+        });
+    }
+});
+exports.createBatchOutputsFormPlugin = __webpack_exports__.createBatchOutputsFormPlugin;
+exports.provideBatchOutputsEffect = __webpack_exports__.provideBatchOutputsEffect;
+for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+    "createBatchOutputsFormPlugin",
+    "provideBatchOutputsEffect"
+].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/form-plugins/index.js

@@ -0,0 +1,47 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ('undefined' != typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    createBatchOutputsFormPlugin: ()=>index_js_namespaceObject.createBatchOutputsFormPlugin,
+    createInferAssignPlugin: ()=>external_infer_assign_plugin_index_js_namespaceObject.createInferAssignPlugin,
+    createInferInputsPlugin: ()=>external_infer_inputs_plugin_index_js_namespaceObject.createInferInputsPlugin,
+    provideBatchOutputsEffect: ()=>index_js_namespaceObject.provideBatchOutputsEffect
+});
+const index_js_namespaceObject = require("./batch-outputs-plugin/index.js");
+const external_infer_assign_plugin_index_js_namespaceObject = require("./infer-assign-plugin/index.js");
+const external_infer_inputs_plugin_index_js_namespaceObject = require("./infer-inputs-plugin/index.js");
+exports.createBatchOutputsFormPlugin = __webpack_exports__.createBatchOutputsFormPlugin;
+exports.createInferAssignPlugin = __webpack_exports__.createInferAssignPlugin;
+exports.createInferInputsPlugin = __webpack_exports__.createInferInputsPlugin;
+exports.provideBatchOutputsEffect = __webpack_exports__.provideBatchOutputsEffect;
+for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+    "createBatchOutputsFormPlugin",
+    "createInferAssignPlugin",
+    "createInferInputsPlugin",
+    "provideBatchOutputsEffect"
+].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/form-plugins/infer-assign-plugin/index.js

@@ -0,0 +1,72 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ('undefined' != typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    createInferAssignPlugin: ()=>createInferAssignPlugin
+});
+const external_lodash_es_namespaceObject = require("lodash-es");
+const json_schema_namespaceObject = require("@flowgram.ai/json-schema");
+const editor_namespaceObject = require("@flowgram.ai/editor");
+const createInferAssignPlugin = (0, editor_namespaceObject.defineFormPluginCreator)({
+    onSetupFormMeta ({ addFormatOnSubmit, mergeEffect }, { assignKey, outputKey }) {
+        if (!assignKey || !outputKey) return;
+        mergeEffect({
+            [assignKey]: (0, editor_namespaceObject.createEffectFromVariableProvider)({
+                parse: (value, ctx)=>{
+                    const declareRows = (0, external_lodash_es_namespaceObject.uniqBy)(value.filter((_v)=>'declare' === _v.operator && _v.left && _v.right), 'left');
+                    return [
+                        editor_namespaceObject.ASTFactory.createVariableDeclaration({
+                            key: `${ctx.node.id}`,
+                            meta: {
+                                title: (0, editor_namespaceObject.getNodeForm)(ctx.node)?.getValueIn('title'),
+                                icon: ctx.node.getNodeRegistry().info?.icon
+                            },
+                            type: editor_namespaceObject.ASTFactory.createObject({
+                                properties: declareRows.map((_v)=>editor_namespaceObject.ASTFactory.createProperty({
+                                        key: _v.left,
+                                        type: _v.right?.type === 'constant' ? json_schema_namespaceObject.JsonSchemaUtils.schemaToAST(_v.right?.schema || {}) : void 0,
+                                        initializer: _v.right?.type === 'ref' ? editor_namespaceObject.ASTFactory.createKeyPathExpression({
+                                            keyPath: _v.right?.content || []
+                                        }) : {}
+                                    }))
+                            })
+                        })
+                    ];
+                }
+            })
+        });
+        addFormatOnSubmit((formData, ctx)=>{
+            (0, external_lodash_es_namespaceObject.set)(formData, outputKey, json_schema_namespaceObject.JsonSchemaUtils.astToSchema((0, editor_namespaceObject.getNodeScope)(ctx.node).output.variables?.[0]?.type));
+            return formData;
+        });
+    }
+});
+exports.createInferAssignPlugin = __webpack_exports__.createInferAssignPlugin;
+for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+    "createInferAssignPlugin"
+].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/form-plugins/infer-inputs-plugin/index.js

@@ -0,0 +1,47 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ('undefined' != typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    createInferInputsPlugin: ()=>createInferInputsPlugin
+});
+const external_lodash_es_namespaceObject = require("lodash-es");
+const editor_namespaceObject = require("@flowgram.ai/editor");
+const index_js_namespaceObject = require("../../shared/index.js");
+const createInferInputsPlugin = (0, editor_namespaceObject.defineFormPluginCreator)({
+    onSetupFormMeta ({ addFormatOnSubmit }, { sourceKey, targetKey, scope }) {
+        if (!sourceKey || !targetKey) return;
+        addFormatOnSubmit((formData, ctx)=>{
+            (0, external_lodash_es_namespaceObject.set)(formData, targetKey, index_js_namespaceObject.FlowValueUtils.inferJsonSchema((0, external_lodash_es_namespaceObject.get)(formData, sourceKey), 'private' === scope ? (0, editor_namespaceObject.getNodePrivateScope)(ctx.node) : (0, editor_namespaceObject.getNodeScope)(ctx.node)));
+            return formData;
+        });
+    }
+});
+exports.createInferInputsPlugin = __webpack_exports__.createInferInputsPlugin;
+for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+    "createInferInputsPlugin"
+].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/hooks/index.js

@@ -0,0 +1,36 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ('undefined' != typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    useObjectList: ()=>index_js_namespaceObject.useObjectList
+});
+const index_js_namespaceObject = require("./use-object-list/index.js");
+exports.useObjectList = __webpack_exports__.useObjectList;
+for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+    "useObjectList"
+].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/hooks/use-object-list/index.js

@@ -0,0 +1,136 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ('undefined' != typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    useObjectList: ()=>useObjectList
+});
+const external_react_namespaceObject = require("react");
+const external_nanoid_namespaceObject = require("nanoid");
+const external_lodash_es_namespaceObject = require("lodash-es");
+function genId() {
+    return (0, external_nanoid_namespaceObject.nanoid)();
+}
+function useObjectList({ value, onChange, sortIndexKey }) {
+    const [list, setList] = (0, external_react_namespaceObject.useState)([]);
+    const effectVersion = (0, external_react_namespaceObject.useRef)(0);
+    const changeVersion = (0, external_react_namespaceObject.useRef)(0);
+    const getSortIndex = (value)=>{
+        if ('function' == typeof sortIndexKey) return (0, external_lodash_es_namespaceObject.get)(value, sortIndexKey(value)) || 0;
+        return (0, external_lodash_es_namespaceObject.get)(value, sortIndexKey || '') || 0;
+    };
+    (0, external_react_namespaceObject.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 = (0, external_lodash_es_namespaceObject.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 ((0, external_lodash_es_namespaceObject.isObject)(_res[1]) && indexKey) (0, external_lodash_es_namespaceObject.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
+    };
+}
+exports.useObjectList = __webpack_exports__.useObjectList;
+for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+    "useObjectList"
+].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});