@flowgram.ai/form-materials 0.4.8 → 0.4.10

package/dist/cjs/components/variable-selector/index.js

@@ -0,0 +1,143 @@
+"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__, {
+    useVariableTree: ()=>external_use_variable_tree_js_namespaceObject.useVariableTree,
+    VariableSelector: ()=>VariableSelector,
+    VariableSelectorProvider: ()=>external_context_js_namespaceObject.VariableSelectorProvider,
+    InjectVariableSelector: ()=>InjectVariableSelector
+});
+const jsx_runtime_namespaceObject = require("react/jsx-runtime");
+const external_react_namespaceObject = require("react");
+const editor_namespaceObject = require("@flowgram.ai/editor");
+const semi_ui_namespaceObject = require("@douyinfe/semi-ui");
+const semi_icons_namespaceObject = require("@douyinfe/semi-icons");
+const index_js_namespaceObject = require("../../shared/index.js");
+const external_use_variable_tree_js_namespaceObject = require("./use-variable-tree.js");
+const external_styles_js_namespaceObject = require("./styles.js");
+const external_context_js_namespaceObject = require("./context.js");
+const VariableSelector = ({ value, config = {}, onChange, style, readonly = false, includeSchema, excludeSchema, hasError, triggerRender })=>{
+    const { skipVariable } = (0, external_context_js_namespaceObject.useVariableSelectorContext)();
+    const treeData = (0, external_use_variable_tree_js_namespaceObject.useVariableTree)({
+        includeSchema,
+        excludeSchema,
+        skipVariable
+    });
+    const treeValue = (0, external_react_namespaceObject.useMemo)(()=>{
+        if ('string' == typeof value) {
+            console.warn('The Value of VariableSelector is a string, it should be an ARRAY. \n', 'Please check the value of VariableSelector \n');
+            return value;
+        }
+        return value?.join('.');
+    }, [
+        value
+    ]);
+    const renderIcon = (icon)=>{
+        if ('string' == typeof icon) return /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)("img", {
+            style: {
+                marginRight: 8
+            },
+            width: 12,
+            height: 12,
+            src: icon
+        });
+        return icon;
+    };
+    return /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(jsx_runtime_namespaceObject.Fragment, {
+        children: /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(external_styles_js_namespaceObject.UITreeSelect, {
+            dropdownMatchSelectWidth: false,
+            disabled: readonly,
+            treeData: treeData,
+            size: "small",
+            value: treeValue,
+            clearIcon: null,
+            $error: hasError,
+            style: style,
+            validateStatus: hasError ? 'error' : void 0,
+            onChange: (_, _config)=>{
+                onChange(_config.keyPath);
+            },
+            renderSelectedItem: (_option)=>{
+                if (!_option?.keyPath) return /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(external_styles_js_namespaceObject.UITag, {
+                    prefixIcon: /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(semi_icons_namespaceObject.IconIssueStroked, {}),
+                    color: "amber",
+                    closable: !readonly,
+                    onClose: ()=>onChange(void 0),
+                    children: config?.notFoundContent ?? 'Undefined'
+                });
+                const rootIcon = renderIcon(_option.rootMeta?.icon || _option?.icon);
+                const rootTitle = /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(external_styles_js_namespaceObject.UIRootTitle, {
+                    children: _option.rootMeta?.title ? `${_option.rootMeta?.title} ${_option.isRoot ? '' : '-'} ` : null
+                });
+                return /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)("div", {
+                    children: /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(semi_ui_namespaceObject.Popover, {
+                        content: /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsxs)(external_styles_js_namespaceObject.UIPopoverContent, {
+                            children: [
+                                rootIcon,
+                                rootTitle,
+                                /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(external_styles_js_namespaceObject.UIVarName, {
+                                    children: _option.keyPath.slice(1).join('.')
+                                })
+                            ]
+                        }),
+                        children: /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsxs)(external_styles_js_namespaceObject.UITag, {
+                            prefixIcon: rootIcon,
+                            closable: !readonly,
+                            onClose: ()=>onChange(void 0),
+                            children: [
+                                rootTitle,
+                                !_option.isRoot && /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(external_styles_js_namespaceObject.UIVarName, {
+                                    $inSelector: true,
+                                    children: _option.label
+                                })
+                            ]
+                        })
+                    })
+                });
+            },
+            showClear: false,
+            arrowIcon: /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(semi_icons_namespaceObject.IconChevronDownStroked, {
+                size: "small"
+            }),
+            triggerRender: triggerRender,
+            placeholder: config?.placeholder ?? editor_namespaceObject.I18n.t('Select Variable')
+        })
+    });
+};
+VariableSelector.renderKey = 'variable-selector-render-key';
+const InjectVariableSelector = (0, index_js_namespaceObject.createInjectMaterial)(VariableSelector);
+exports.InjectVariableSelector = __webpack_exports__.InjectVariableSelector;
+exports.VariableSelector = __webpack_exports__.VariableSelector;
+exports.VariableSelectorProvider = __webpack_exports__.VariableSelectorProvider;
+exports.useVariableTree = __webpack_exports__.useVariableTree;
+for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+    "InjectVariableSelector",
+    "VariableSelector",
+    "VariableSelectorProvider",
+    "useVariableTree"
+].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/components/variable-selector/styles.js

@@ -0,0 +1,114 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.n = (module)=>{
+        var getter = module && module.__esModule ? ()=>module['default'] : ()=>module;
+        __webpack_require__.d(getter, {
+            a: getter
+        });
+        return getter;
+    };
+})();
+(()=>{
+    __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__, {
+    UITreeSelect: ()=>UITreeSelect,
+    UIRootTitle: ()=>UIRootTitle,
+    UIPopoverContent: ()=>UIPopoverContent,
+    UIVarName: ()=>UIVarName,
+    UITag: ()=>UITag
+});
+const external_styled_components_namespaceObject = require("styled-components");
+var external_styled_components_default = /*#__PURE__*/ __webpack_require__.n(external_styled_components_namespaceObject);
+const semi_ui_namespaceObject = require("@douyinfe/semi-ui");
+const UIRootTitle = external_styled_components_default().div`
+  margin-right: 4px;
+  min-width: 20px;
+  overflow: hidden;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+  color: var(--semi-color-text-2);
+`;
+const UIVarName = external_styled_components_default().div`
+  overflow: hidden;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+
+  ${({ $inSelector })=>$inSelector && (0, external_styled_components_namespaceObject.css)`
+      min-width: 50%;
+    `}
+`;
+const UITag = external_styled_components_default()(semi_ui_namespaceObject.Tag)`
+  width: 100%;
+  display: flex;
+  align-items: center;
+  justify-content: flex-start;
+
+  & .semi-tag-content-center {
+    justify-content: flex-start;
+  }
+
+  &.semi-tag {
+    margin: 0;
+    height: 22px;
+  }
+`;
+const UITreeSelect = external_styled_components_default()(semi_ui_namespaceObject.TreeSelect)`
+  outline: ${({ $error })=>$error ? '1px solid red' : 'none'};
+
+  & .semi-tree-select-selection {
+    padding: 0px;
+    height: 22px;
+  }
+
+  & .semi-tree-select-selection-content {
+    width: 100%;
+  }
+
+  & .semi-tree-select-selection-placeholder {
+    padding-left: 10px;
+  }
+`;
+const UIPopoverContent = external_styled_components_default().div`
+  padding: 10px;
+  display: inline-flex;
+  align-items: center;
+  justify-content: flex-start;
+  white-space: nowrap;
+`;
+exports.UIPopoverContent = __webpack_exports__.UIPopoverContent;
+exports.UIRootTitle = __webpack_exports__.UIRootTitle;
+exports.UITag = __webpack_exports__.UITag;
+exports.UITreeSelect = __webpack_exports__.UITreeSelect;
+exports.UIVarName = __webpack_exports__.UIVarName;
+for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+    "UIPopoverContent",
+    "UIRootTitle",
+    "UITag",
+    "UITreeSelect",
+    "UIVarName"
+].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/components/variable-selector/use-variable-tree.js

@@ -0,0 +1,100 @@
+"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__, {
+    useVariableTree: ()=>useVariableTree
+});
+const jsx_runtime_namespaceObject = require("react/jsx-runtime");
+const external_react_namespaceObject = require("react");
+const json_schema_namespaceObject = require("@flowgram.ai/json-schema");
+const editor_namespaceObject = require("@flowgram.ai/editor");
+const semi_ui_namespaceObject = require("@douyinfe/semi-ui");
+const index_js_namespaceObject = require("../../plugins/index.js");
+function useVariableTree(params) {
+    const { includeSchema, excludeSchema, skipVariable } = params;
+    const typeManager = (0, index_js_namespaceObject.useTypeManager)();
+    const variables = (0, editor_namespaceObject.useAvailableVariables)();
+    const getVariableTypeIcon = (0, external_react_namespaceObject.useCallback)((variable)=>{
+        if (variable.meta?.icon) {
+            if ('string' == typeof variable.meta.icon) return /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)("img", {
+                style: {
+                    marginRight: 8
+                },
+                width: 12,
+                height: 12,
+                src: variable.meta.icon
+            });
+            return variable.meta.icon;
+        }
+        const schema = json_schema_namespaceObject.JsonSchemaUtils.astToSchema(variable.type, {
+            drilldownObject: false
+        });
+        return /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(semi_ui_namespaceObject.Icon, {
+            size: "small",
+            svg: typeManager.getDisplayIcon(schema || {})
+        });
+    }, []);
+    const renderVariable = (variable, parentFields = [])=>{
+        let type = variable?.type;
+        if (!type) return null;
+        let children;
+        if (editor_namespaceObject.ASTMatch.isObject(type)) children = (type.properties || []).map((_property)=>renderVariable(_property, [
+                ...parentFields,
+                variable
+            ])).filter(Boolean);
+        const keyPath = [
+            ...parentFields.map((_field)=>_field.key),
+            variable.key
+        ];
+        const key = keyPath.join('.');
+        const isSchemaInclude = includeSchema ? json_schema_namespaceObject.JsonSchemaUtils.isASTMatchSchema(type, includeSchema) : true;
+        const isSchemaExclude = excludeSchema ? json_schema_namespaceObject.JsonSchemaUtils.isASTMatchSchema(type, excludeSchema) : false;
+        const isCustomSkip = skipVariable ? skipVariable(variable) : false;
+        const isMetaDisabled = variable.meta?.disabled;
+        const isSchemaMatch = isSchemaInclude && !isSchemaExclude && !isCustomSkip && !isMetaDisabled;
+        if (!isSchemaMatch && !children?.length) return null;
+        return {
+            key: key,
+            label: variable.meta?.title || variable.key,
+            value: key,
+            keyPath,
+            icon: getVariableTypeIcon(variable),
+            children,
+            disabled: !isSchemaMatch,
+            rootMeta: parentFields[0]?.meta || variable.meta,
+            isRoot: !parentFields?.length
+        };
+    };
+    return [
+        ...variables.slice(0).reverse()
+    ].map((_variable)=>renderVariable(_variable)).filter(Boolean);
+}
+exports.useVariableTree = __webpack_exports__.useVariableTree;
+for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+    "useVariableTree"
+].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/effects/auto-rename-ref/index.js

@@ -0,0 +1,98 @@
+"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: ()=>autoRenameRefEffect
+});
+const editor_namespaceObject = require("@flowgram.ai/editor");
+const index_js_namespaceObject = require("../../shared/index.js");
+const autoRenameRefEffect = [
+    {
+        event: editor_namespaceObject.DataEvent.onValueInit,
+        effect: (params)=>{
+            const { context, form, name } = params;
+            const renameService = context.node.getService(editor_namespaceObject.VariableFieldKeyRenameService);
+            const disposable = renameService.onRename(({ before, after })=>{
+                const beforeKeyPath = [
+                    ...before.parentFields.map((_field)=>_field.key).reverse(),
+                    before.key
+                ];
+                const afterKeyPath = [
+                    ...after.parentFields.map((_field)=>_field.key).reverse(),
+                    after.key
+                ];
+                traverseRef(name, form.getValueIn(name), (_drilldownName, _v)=>{
+                    if ('ref' === _v.type) {
+                        if (isKeyPathMatch(_v.content, beforeKeyPath)) {
+                            _v.content = [
+                                ...afterKeyPath,
+                                ...(_v.content || [])?.slice(beforeKeyPath.length)
+                            ];
+                            form.setValueIn(_drilldownName, _v);
+                        }
+                    } else if ('template' === _v.type) {
+                        const templateKeyPaths = index_js_namespaceObject.FlowValueUtils.getTemplateKeyPaths(_v);
+                        let hasMatch = false;
+                        templateKeyPaths.forEach((_keyPath)=>{
+                            if (isKeyPathMatch(_keyPath, beforeKeyPath)) {
+                                hasMatch = true;
+                                const nextKeyPath = [
+                                    ...afterKeyPath,
+                                    ...(_keyPath || [])?.slice(beforeKeyPath.length)
+                                ];
+                                _v.content = _v.content?.replace(`{{${_keyPath.join('.')}}`, `{{${nextKeyPath.join('.')}}`);
+                            }
+                        });
+                        if (hasMatch) form.setValueIn(_drilldownName, {
+                            ..._v
+                        });
+                    }
+                });
+            });
+            return ()=>{
+                disposable.dispose();
+            };
+        }
+    }
+];
+function isKeyPathMatch(keyPath = [], targetKeyPath) {
+    return targetKeyPath.every((_key, index)=>_key === keyPath[index]);
+}
+function traverseRef(name, value, cb) {
+    for (const { value: _v, path } of index_js_namespaceObject.FlowValueUtils.traverse(value, {
+        includeTypes: [
+            'ref',
+            'template'
+        ],
+        path: name
+    }))cb(path, _v);
+}
+exports.autoRenameRefEffect = __webpack_exports__.autoRenameRefEffect;
+for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+    "autoRenameRefEffect"
+].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

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