@flowgram.ai/form-materials 0.4.9 → 0.4.11

package/dist/cjs/effects/index.js

@@ -0,0 +1,60 @@
+"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__, {
+    autoRenameRefEffect: ()=>index_js_namespaceObject.autoRenameRefEffect,
+    syncVariableTitle: ()=>external_sync_variable_title_index_js_namespaceObject.syncVariableTitle,
+    listenRefSchemaChange: ()=>external_listen_ref_schema_change_index_js_namespaceObject.listenRefSchemaChange,
+    listenRefValueChange: ()=>external_listen_ref_value_change_index_js_namespaceObject.listenRefValueChange,
+    provideJsonSchemaOutputs: ()=>external_provide_json_schema_outputs_index_js_namespaceObject.provideJsonSchemaOutputs,
+    validateWhenVariableSync: ()=>external_validate_when_variable_sync_index_js_namespaceObject.validateWhenVariableSync,
+    provideBatchInputEffect: ()=>external_provide_batch_input_index_js_namespaceObject.provideBatchInputEffect
+});
+const index_js_namespaceObject = require("./auto-rename-ref/index.js");
+const external_listen_ref_schema_change_index_js_namespaceObject = require("./listen-ref-schema-change/index.js");
+const external_listen_ref_value_change_index_js_namespaceObject = require("./listen-ref-value-change/index.js");
+const external_provide_batch_input_index_js_namespaceObject = require("./provide-batch-input/index.js");
+const external_provide_json_schema_outputs_index_js_namespaceObject = require("./provide-json-schema-outputs/index.js");
+const external_sync_variable_title_index_js_namespaceObject = require("./sync-variable-title/index.js");
+const external_validate_when_variable_sync_index_js_namespaceObject = require("./validate-when-variable-sync/index.js");
+exports.autoRenameRefEffect = __webpack_exports__.autoRenameRefEffect;
+exports.listenRefSchemaChange = __webpack_exports__.listenRefSchemaChange;
+exports.listenRefValueChange = __webpack_exports__.listenRefValueChange;
+exports.provideBatchInputEffect = __webpack_exports__.provideBatchInputEffect;
+exports.provideJsonSchemaOutputs = __webpack_exports__.provideJsonSchemaOutputs;
+exports.syncVariableTitle = __webpack_exports__.syncVariableTitle;
+exports.validateWhenVariableSync = __webpack_exports__.validateWhenVariableSync;
+for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+    "autoRenameRefEffect",
+    "listenRefSchemaChange",
+    "listenRefValueChange",
+    "provideBatchInputEffect",
+    "provideJsonSchemaOutputs",
+    "syncVariableTitle",
+    "validateWhenVariableSync"
+].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/effects/listen-ref-schema-change/index.js

@@ -0,0 +1,57 @@
+"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__, {
+    listenRefSchemaChange: ()=>listenRefSchemaChange
+});
+const json_schema_namespaceObject = require("@flowgram.ai/json-schema");
+const editor_namespaceObject = require("@flowgram.ai/editor");
+const listenRefSchemaChange = (cb)=>[
+        {
+            event: editor_namespaceObject.DataEvent.onValueInitOrChange,
+            effect: (params)=>{
+                const { context, value } = params;
+                if (value?.type !== 'ref') return ()=>null;
+                const disposable = (0, editor_namespaceObject.getNodeScope)(context.node).available.trackByKeyPath(value?.content || [], (_type)=>{
+                    cb({
+                        ...params,
+                        schema: json_schema_namespaceObject.JsonSchemaUtils.astToSchema(_type)
+                    });
+                }, {
+                    selector: (_v)=>_v?.type
+                });
+                return ()=>{
+                    disposable.dispose();
+                };
+            }
+        }
+    ];
+exports.listenRefSchemaChange = __webpack_exports__.listenRefSchemaChange;
+for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+    "listenRefSchemaChange"
+].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/effects/listen-ref-value-change/index.js

@@ -0,0 +1,54 @@
+"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__, {
+    listenRefValueChange: ()=>listenRefValueChange
+});
+const editor_namespaceObject = require("@flowgram.ai/editor");
+const listenRefValueChange = (cb)=>[
+        {
+            event: editor_namespaceObject.DataEvent.onValueInitOrChange,
+            effect: (params)=>{
+                const { context, value } = params;
+                if (value?.type !== 'ref') return ()=>null;
+                const disposable = (0, editor_namespaceObject.getNodeScope)(context.node).available.trackByKeyPath(value?.content || [], (v)=>{
+                    cb({
+                        ...params,
+                        variable: v
+                    });
+                });
+                return ()=>{
+                    disposable.dispose();
+                };
+            }
+        }
+    ];
+exports.listenRefValueChange = __webpack_exports__.listenRefValueChange;
+for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+    "listenRefValueChange"
+].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

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
+});