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

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: ctx.node.form?.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,74 @@
+"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 external_immer_namespaceObject = require("immer");
+const editor_namespaceObject = require("@flowgram.ai/editor");
+const index_js_namespaceObject = require("../../shared/index.js");
+const { produce } = new external_immer_namespaceObject.Immer({
+    autoFreeze: false
+});
+const createInferInputsPlugin = (0, editor_namespaceObject.defineFormPluginCreator)({
+    onSetupFormMeta ({ addFormatOnSubmit, addFormatOnInit }, { sourceKey, targetKey, scope, ignoreConstantSchema }) {
+        if (!sourceKey || !targetKey) return;
+        addFormatOnSubmit((formData, ctx)=>produce(formData, (draft)=>{
+                const sourceData = (0, external_lodash_es_namespaceObject.get)(formData, sourceKey);
+                (0, external_lodash_es_namespaceObject.set)(draft, targetKey, index_js_namespaceObject.FlowValueUtils.inferJsonSchema(sourceData, 'private' === scope ? (0, editor_namespaceObject.getNodePrivateScope)(ctx.node) : (0, editor_namespaceObject.getNodeScope)(ctx.node)));
+                if (ignoreConstantSchema) {
+                    for (const { value, path } of index_js_namespaceObject.FlowValueUtils.traverse(sourceData, {
+                        includeTypes: [
+                            'constant'
+                        ]
+                    }))if (index_js_namespaceObject.FlowValueUtils.isConstant(value) && value?.schema) (0, external_lodash_es_namespaceObject.set)(formData, `${sourceKey}.${path}`, (0, external_lodash_es_namespaceObject.omit)(value, [
+                        'schema'
+                    ]));
+                }
+            }));
+        if (ignoreConstantSchema) addFormatOnInit((formData, ctx)=>{
+            const targetSchema = (0, external_lodash_es_namespaceObject.get)(formData, targetKey);
+            if (!targetSchema) return formData;
+            for (const { value, pathArr } of index_js_namespaceObject.FlowValueUtils.traverse((0, external_lodash_es_namespaceObject.get)(formData, sourceKey), {
+                includeTypes: [
+                    'constant'
+                ]
+            }))if (index_js_namespaceObject.FlowValueUtils.isConstant(value) && !value?.schema) {
+                const schemaPath = pathArr.map((_item)=>`properties.${_item}`).join('.');
+                const schema = (0, external_lodash_es_namespaceObject.get)(targetSchema, schemaPath);
+                if (schema) (0, external_lodash_es_namespaceObject.set)(value, 'schema', schema);
+            }
+            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
+});

package/dist/cjs/index.js

@@ -0,0 +1,270 @@
+"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__, {
+    JsonCodeEditor: ()=>index_js_namespaceObject.JsonCodeEditor,
+    TypeSelector: ()=>index_js_namespaceObject.TypeSelector,
+    createInjectMaterial: ()=>external_shared_index_js_namespaceObject.createInjectMaterial,
+    AssignRows: ()=>index_js_namespaceObject.AssignRows,
+    ConditionRow: ()=>index_js_namespaceObject.ConditionRow,
+    InjectDynamicValueInput: ()=>index_js_namespaceObject.InjectDynamicValueInput,
+    createBatchOutputsFormPlugin: ()=>external_form_plugins_index_js_namespaceObject.createBatchOutputsFormPlugin,
+    useObjectList: ()=>external_hooks_index_js_namespaceObject.useObjectList,
+    JsonEditorWithVariables: ()=>index_js_namespaceObject.JsonEditorWithVariables,
+    createTypePresetPlugin: ()=>external_plugins_index_js_namespaceObject.createTypePresetPlugin,
+    provideBatchInputEffect: ()=>external_effects_index_js_namespaceObject.provideBatchInputEffect,
+    useConditionContext: ()=>index_js_namespaceObject.useConditionContext,
+    BaseCodeEditor: ()=>index_js_namespaceObject.BaseCodeEditor,
+    PromptEditor: ()=>index_js_namespaceObject.PromptEditor,
+    validateWhenVariableSync: ()=>external_effects_index_js_namespaceObject.validateWhenVariableSync,
+    listenRefValueChange: ()=>external_effects_index_js_namespaceObject.listenRefValueChange,
+    JsonSchemaTypePresetProvider: ()=>external_plugins_index_js_namespaceObject.JsonSchemaTypePresetProvider,
+    useTypeManager: ()=>external_plugins_index_js_namespaceObject.useTypeManager,
+    DisplaySchemaTag: ()=>index_js_namespaceObject.DisplaySchemaTag,
+    ConditionPresetOp: ()=>index_js_namespaceObject.ConditionPresetOp,
+    InputsValues: ()=>index_js_namespaceObject.InputsValues,
+    PythonCodeEditor: ()=>index_js_namespaceObject.PythonCodeEditor,
+    SQLCodeEditor: ()=>index_js_namespaceObject.SQLCodeEditor,
+    provideBatchOutputsEffect: ()=>external_form_plugins_index_js_namespaceObject.provideBatchOutputsEffect,
+    useVariableTree: ()=>index_js_namespaceObject.useVariableTree,
+    formatLegacyRefOnSubmit: ()=>external_shared_index_js_namespaceObject.formatLegacyRefOnSubmit,
+    DisplayFlowValue: ()=>index_js_namespaceObject.DisplayFlowValue,
+    EditorVariableTagInject: ()=>index_js_namespaceObject.EditorVariableTagInject,
+    SQLEditorWithVariables: ()=>index_js_namespaceObject.SQLEditorWithVariables,
+    formatLegacyRefToNewRef: ()=>external_shared_index_js_namespaceObject.formatLegacyRefToNewRef,
+    formatLegacyRefOnInit: ()=>external_shared_index_js_namespaceObject.formatLegacyRefOnInit,
+    TypeScriptCodeEditor: ()=>index_js_namespaceObject.TypeScriptCodeEditor,
+    CodeEditor: ()=>index_js_namespaceObject.CodeEditor,
+    DisplayInputsValueAllInTag: ()=>index_js_namespaceObject.DisplayInputsValueAllInTag,
+    getTypeSelectValue: ()=>index_js_namespaceObject.getTypeSelectValue,
+    BatchOutputs: ()=>index_js_namespaceObject.BatchOutputs,
+    polyfillCreateRoot: ()=>external_shared_index_js_namespaceObject.polyfillCreateRoot,
+    VariableSelector: ()=>index_js_namespaceObject.VariableSelector,
+    BatchVariableSelector: ()=>index_js_namespaceObject.BatchVariableSelector,
+    AssignRow: ()=>index_js_namespaceObject.AssignRow,
+    createInferAssignPlugin: ()=>external_form_plugins_index_js_namespaceObject.createInferAssignPlugin,
+    CodeEditorMini: ()=>index_js_namespaceObject.CodeEditorMini,
+    DBConditionRow: ()=>index_js_namespaceObject.DBConditionRow,
+    DynamicValueInput: ()=>index_js_namespaceObject.DynamicValueInput,
+    EditorInputsTree: ()=>index_js_namespaceObject.EditorInputsTree,
+    PromptEditorWithVariables: ()=>index_js_namespaceObject.PromptEditorWithVariables,
+    lazySuspense: ()=>external_shared_index_js_namespaceObject.lazySuspense,
+    ConditionProvider: ()=>index_js_namespaceObject.ConditionProvider,
+    provideJsonSchemaOutputs: ()=>external_effects_index_js_namespaceObject.provideJsonSchemaOutputs,
+    createInferInputsPlugin: ()=>external_form_plugins_index_js_namespaceObject.createInferInputsPlugin,
+    InjectVariableSelector: ()=>index_js_namespaceObject.InjectVariableSelector,
+    unstableSetCreateRoot: ()=>external_shared_index_js_namespaceObject.unstableSetCreateRoot,
+    DisplayOutputs: ()=>index_js_namespaceObject.DisplayOutputs,
+    isLegacyFlowRefValueSchema: ()=>external_shared_index_js_namespaceObject.isLegacyFlowRefValueSchema,
+    DisplaySchemaTree: ()=>index_js_namespaceObject.DisplaySchemaTree,
+    useCondition: ()=>index_js_namespaceObject.useCondition,
+    createDisableDeclarationPlugin: ()=>external_plugins_index_js_namespaceObject.createDisableDeclarationPlugin,
+    validateFlowValue: ()=>external_validate_index_js_namespaceObject.validateFlowValue,
+    ConstantInput: ()=>index_js_namespaceObject.ConstantInput,
+    BlurInput: ()=>index_js_namespaceObject.BlurInput,
+    ShellCodeEditor: ()=>index_js_namespaceObject.ShellCodeEditor,
+    isNewFlowRefValueSchema: ()=>external_shared_index_js_namespaceObject.isNewFlowRefValueSchema,
+    FlowValueUtils: ()=>external_shared_index_js_namespaceObject.FlowValueUtils,
+    InjectTypeSelector: ()=>index_js_namespaceObject.InjectTypeSelector,
+    VariableSelectorProvider: ()=>index_js_namespaceObject.VariableSelectorProvider,
+    JsonSchemaEditor: ()=>index_js_namespaceObject.JsonSchemaEditor,
+    PromptEditorWithInputs: ()=>index_js_namespaceObject.PromptEditorWithInputs,
+    listenRefSchemaChange: ()=>external_effects_index_js_namespaceObject.listenRefSchemaChange,
+    InputsValuesTree: ()=>index_js_namespaceObject.InputsValuesTree,
+    parseTypeSelectValue: ()=>index_js_namespaceObject.parseTypeSelectValue,
+    syncVariableTitle: ()=>external_effects_index_js_namespaceObject.syncVariableTitle,
+    EditorVariableTree: ()=>index_js_namespaceObject.EditorVariableTree,
+    JsonSchemaUtils: ()=>external_plugins_index_js_namespaceObject.JsonSchemaUtils,
+    DisplayInputsValues: ()=>index_js_namespaceObject.DisplayInputsValues,
+    autoRenameRefEffect: ()=>external_effects_index_js_namespaceObject.autoRenameRefEffect,
+    formatNewRefToLegacyRef: ()=>external_shared_index_js_namespaceObject.formatNewRefToLegacyRef,
+    withSuspense: ()=>external_shared_index_js_namespaceObject.withSuspense
+});
+const index_js_namespaceObject = require("./components/index.js");
+const external_effects_index_js_namespaceObject = require("./effects/index.js");
+const external_form_plugins_index_js_namespaceObject = require("./form-plugins/index.js");
+const external_hooks_index_js_namespaceObject = require("./hooks/index.js");
+const external_plugins_index_js_namespaceObject = require("./plugins/index.js");
+const external_shared_index_js_namespaceObject = require("./shared/index.js");
+const external_validate_index_js_namespaceObject = require("./validate/index.js");
+exports.AssignRow = __webpack_exports__.AssignRow;
+exports.AssignRows = __webpack_exports__.AssignRows;
+exports.BaseCodeEditor = __webpack_exports__.BaseCodeEditor;
+exports.BatchOutputs = __webpack_exports__.BatchOutputs;
+exports.BatchVariableSelector = __webpack_exports__.BatchVariableSelector;
+exports.BlurInput = __webpack_exports__.BlurInput;
+exports.CodeEditor = __webpack_exports__.CodeEditor;
+exports.CodeEditorMini = __webpack_exports__.CodeEditorMini;
+exports.ConditionPresetOp = __webpack_exports__.ConditionPresetOp;
+exports.ConditionProvider = __webpack_exports__.ConditionProvider;
+exports.ConditionRow = __webpack_exports__.ConditionRow;
+exports.ConstantInput = __webpack_exports__.ConstantInput;
+exports.DBConditionRow = __webpack_exports__.DBConditionRow;
+exports.DisplayFlowValue = __webpack_exports__.DisplayFlowValue;
+exports.DisplayInputsValueAllInTag = __webpack_exports__.DisplayInputsValueAllInTag;
+exports.DisplayInputsValues = __webpack_exports__.DisplayInputsValues;
+exports.DisplayOutputs = __webpack_exports__.DisplayOutputs;
+exports.DisplaySchemaTag = __webpack_exports__.DisplaySchemaTag;
+exports.DisplaySchemaTree = __webpack_exports__.DisplaySchemaTree;
+exports.DynamicValueInput = __webpack_exports__.DynamicValueInput;
+exports.EditorInputsTree = __webpack_exports__.EditorInputsTree;
+exports.EditorVariableTagInject = __webpack_exports__.EditorVariableTagInject;
+exports.EditorVariableTree = __webpack_exports__.EditorVariableTree;
+exports.FlowValueUtils = __webpack_exports__.FlowValueUtils;
+exports.InjectDynamicValueInput = __webpack_exports__.InjectDynamicValueInput;
+exports.InjectTypeSelector = __webpack_exports__.InjectTypeSelector;
+exports.InjectVariableSelector = __webpack_exports__.InjectVariableSelector;
+exports.InputsValues = __webpack_exports__.InputsValues;
+exports.InputsValuesTree = __webpack_exports__.InputsValuesTree;
+exports.JsonCodeEditor = __webpack_exports__.JsonCodeEditor;
+exports.JsonEditorWithVariables = __webpack_exports__.JsonEditorWithVariables;
+exports.JsonSchemaEditor = __webpack_exports__.JsonSchemaEditor;
+exports.JsonSchemaTypePresetProvider = __webpack_exports__.JsonSchemaTypePresetProvider;
+exports.JsonSchemaUtils = __webpack_exports__.JsonSchemaUtils;
+exports.PromptEditor = __webpack_exports__.PromptEditor;
+exports.PromptEditorWithInputs = __webpack_exports__.PromptEditorWithInputs;
+exports.PromptEditorWithVariables = __webpack_exports__.PromptEditorWithVariables;
+exports.PythonCodeEditor = __webpack_exports__.PythonCodeEditor;
+exports.SQLCodeEditor = __webpack_exports__.SQLCodeEditor;
+exports.SQLEditorWithVariables = __webpack_exports__.SQLEditorWithVariables;
+exports.ShellCodeEditor = __webpack_exports__.ShellCodeEditor;
+exports.TypeScriptCodeEditor = __webpack_exports__.TypeScriptCodeEditor;
+exports.TypeSelector = __webpack_exports__.TypeSelector;
+exports.VariableSelector = __webpack_exports__.VariableSelector;
+exports.VariableSelectorProvider = __webpack_exports__.VariableSelectorProvider;
+exports.autoRenameRefEffect = __webpack_exports__.autoRenameRefEffect;
+exports.createBatchOutputsFormPlugin = __webpack_exports__.createBatchOutputsFormPlugin;
+exports.createDisableDeclarationPlugin = __webpack_exports__.createDisableDeclarationPlugin;
+exports.createInferAssignPlugin = __webpack_exports__.createInferAssignPlugin;
+exports.createInferInputsPlugin = __webpack_exports__.createInferInputsPlugin;
+exports.createInjectMaterial = __webpack_exports__.createInjectMaterial;
+exports.createTypePresetPlugin = __webpack_exports__.createTypePresetPlugin;
+exports.formatLegacyRefOnInit = __webpack_exports__.formatLegacyRefOnInit;
+exports.formatLegacyRefOnSubmit = __webpack_exports__.formatLegacyRefOnSubmit;
+exports.formatLegacyRefToNewRef = __webpack_exports__.formatLegacyRefToNewRef;
+exports.formatNewRefToLegacyRef = __webpack_exports__.formatNewRefToLegacyRef;
+exports.getTypeSelectValue = __webpack_exports__.getTypeSelectValue;
+exports.isLegacyFlowRefValueSchema = __webpack_exports__.isLegacyFlowRefValueSchema;
+exports.isNewFlowRefValueSchema = __webpack_exports__.isNewFlowRefValueSchema;
+exports.lazySuspense = __webpack_exports__.lazySuspense;
+exports.listenRefSchemaChange = __webpack_exports__.listenRefSchemaChange;
+exports.listenRefValueChange = __webpack_exports__.listenRefValueChange;
+exports.parseTypeSelectValue = __webpack_exports__.parseTypeSelectValue;
+exports.polyfillCreateRoot = __webpack_exports__.polyfillCreateRoot;
+exports.provideBatchInputEffect = __webpack_exports__.provideBatchInputEffect;
+exports.provideBatchOutputsEffect = __webpack_exports__.provideBatchOutputsEffect;
+exports.provideJsonSchemaOutputs = __webpack_exports__.provideJsonSchemaOutputs;
+exports.syncVariableTitle = __webpack_exports__.syncVariableTitle;
+exports.unstableSetCreateRoot = __webpack_exports__.unstableSetCreateRoot;
+exports.useCondition = __webpack_exports__.useCondition;
+exports.useConditionContext = __webpack_exports__.useConditionContext;
+exports.useObjectList = __webpack_exports__.useObjectList;
+exports.useTypeManager = __webpack_exports__.useTypeManager;
+exports.useVariableTree = __webpack_exports__.useVariableTree;
+exports.validateFlowValue = __webpack_exports__.validateFlowValue;
+exports.validateWhenVariableSync = __webpack_exports__.validateWhenVariableSync;
+exports.withSuspense = __webpack_exports__.withSuspense;
+for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+    "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"
+].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/plugins/disable-declaration-plugin/create-disable-declaration-plugin.js

@@ -0,0 +1,51 @@
+"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__, {
+    createDisableDeclarationPlugin: ()=>createDisableDeclarationPlugin
+});
+const editor_namespaceObject = require("@flowgram.ai/editor");
+const createDisableDeclarationPlugin = (0, editor_namespaceObject.definePluginCreator)({
+    onInit (ctx) {
+        const variableEngine = ctx.get(editor_namespaceObject.VariableEngine);
+        const handleEvent = (action)=>{
+            if (editor_namespaceObject.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);
+    }
+});
+exports.createDisableDeclarationPlugin = __webpack_exports__.createDisableDeclarationPlugin;
+for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+    "createDisableDeclarationPlugin"
+].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});