@flowgram.ai/form-materials 0.4.9 → 0.4.11

package/dist/cjs/shared/flow-value/utils.js

@@ -0,0 +1,142 @@
+"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__, {
+    FlowValueUtils: ()=>utils_FlowValueUtils
+});
+const external_lodash_es_namespaceObject = require("lodash-es");
+const json_schema_namespaceObject = require("@flowgram.ai/json-schema");
+const external_schema_js_namespaceObject = require("./schema.js");
+(function(FlowValueUtils) {
+    function isConstant(value) {
+        return external_schema_js_namespaceObject.constantSchema.safeParse(value).success;
+    }
+    FlowValueUtils.isConstant = isConstant;
+    function isRef(value) {
+        return external_schema_js_namespaceObject.refSchema.safeParse(value).success;
+    }
+    FlowValueUtils.isRef = isRef;
+    function isExpression(value) {
+        return external_schema_js_namespaceObject.expressionSchema.safeParse(value).success;
+    }
+    FlowValueUtils.isExpression = isExpression;
+    function isTemplate(value) {
+        return external_schema_js_namespaceObject.templateSchema.safeParse(value).success;
+    }
+    FlowValueUtils.isTemplate = isTemplate;
+    function isConstantOrRef(value) {
+        return isConstant(value) || isRef(value);
+    }
+    FlowValueUtils.isConstantOrRef = isConstantOrRef;
+    function isFlowValue(value) {
+        return isConstant(value) || isRef(value) || isExpression(value) || isTemplate(value);
+    }
+    FlowValueUtils.isFlowValue = isFlowValue;
+    function* traverse(value, options) {
+        const { includeTypes = [
+            'ref',
+            'template'
+        ], path = '' } = options;
+        if ((0, external_lodash_es_namespaceObject.isPlainObject)(value)) {
+            if (isRef(value) && includeTypes.includes('ref')) return void (yield {
+                value,
+                path
+            });
+            if (isTemplate(value) && includeTypes.includes('template')) return void (yield {
+                value,
+                path
+            });
+            if (isExpression(value) && includeTypes.includes('expression')) return void (yield {
+                value,
+                path
+            });
+            if (isConstant(value) && includeTypes.includes('constant')) return void (yield {
+                value,
+                path
+            });
+            for (const [_key, _value] of Object.entries(value))yield* traverse(_value, {
+                ...options,
+                path: `${path}.${_key}`
+            });
+            return;
+        }
+        if ((0, external_lodash_es_namespaceObject.isArray)(value)) for (const [_idx, _value] of value.entries())yield* traverse(_value, {
+            ...options,
+            path: `${path}[${_idx}]`
+        });
+    }
+    FlowValueUtils.traverse = traverse;
+    function getTemplateKeyPaths(value) {
+        const keyPathReg = /\{\{([^\}\{]+)\}\}/g;
+        return (0, external_lodash_es_namespaceObject.uniq)(value.content?.match(keyPathReg) || []).map((_keyPath)=>_keyPath.slice(2, -2).split('.'));
+    }
+    FlowValueUtils.getTemplateKeyPaths = getTemplateKeyPaths;
+    function inferConstantJsonSchema(value) {
+        if (value?.schema) return value.schema;
+        if ('string' == typeof value.content) return {
+            type: 'string'
+        };
+        if ('number' == typeof value.content) return {
+            type: 'number'
+        };
+        if ('boolean' == typeof value.content) return {
+            type: 'boolean'
+        };
+        if ((0, external_lodash_es_namespaceObject.isObject)(value.content)) return {
+            type: 'object'
+        };
+    }
+    FlowValueUtils.inferConstantJsonSchema = inferConstantJsonSchema;
+    function inferJsonSchema(values, scope) {
+        if ((0, external_lodash_es_namespaceObject.isPlainObject)(values)) {
+            if (isConstant(values)) return inferConstantJsonSchema(values);
+            if (isRef(values)) {
+                const variable = scope.available.getByKeyPath(values?.content);
+                const schema = variable?.type ? json_schema_namespaceObject.JsonSchemaUtils.astToSchema(variable?.type) : void 0;
+                return schema;
+            }
+            if (isTemplate(values)) return {
+                type: 'string'
+            };
+            return {
+                type: 'object',
+                properties: Object.keys(values).reduce((acc, key)=>{
+                    const schema = inferJsonSchema(values[key], scope);
+                    if (schema) acc[key] = schema;
+                    return acc;
+                }, {})
+            };
+        }
+    }
+    FlowValueUtils.inferJsonSchema = inferJsonSchema;
+})(utils_FlowValueUtils || (utils_FlowValueUtils = {}));
+var utils_FlowValueUtils;
+exports.FlowValueUtils = __webpack_exports__.FlowValueUtils;
+for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+    "FlowValueUtils"
+].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/shared/format-legacy-refs/index.js

@@ -0,0 +1,99 @@
+"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__, {
+    formatLegacyRefOnInit: ()=>formatLegacyRefOnInit,
+    isNewFlowRefValueSchema: ()=>isNewFlowRefValueSchema,
+    formatNewRefToLegacyRef: ()=>formatNewRefToLegacyRef,
+    isLegacyFlowRefValueSchema: ()=>isLegacyFlowRefValueSchema,
+    formatLegacyRefToNewRef: ()=>formatLegacyRefToNewRef,
+    formatLegacyRefOnSubmit: ()=>formatLegacyRefOnSubmit
+});
+const external_lodash_es_namespaceObject = require("lodash-es");
+function formatLegacyRefOnSubmit(value) {
+    if ((0, external_lodash_es_namespaceObject.isObject)(value)) {
+        if (isLegacyFlowRefValueSchema(value)) return formatLegacyRefToNewRef(value);
+        return Object.fromEntries(Object.entries(value).map(([key, value])=>[
+                key,
+                formatLegacyRefOnSubmit(value)
+            ]));
+    }
+    if (Array.isArray(value)) return value.map(formatLegacyRefOnSubmit);
+    return value;
+}
+function formatLegacyRefOnInit(value) {
+    if ((0, external_lodash_es_namespaceObject.isObject)(value)) {
+        if (isNewFlowRefValueSchema(value)) return formatNewRefToLegacyRef(value);
+        return Object.fromEntries(Object.entries(value).map(([key, value])=>[
+                key,
+                formatLegacyRefOnInit(value)
+            ]));
+    }
+    if (Array.isArray(value)) return value.map(formatLegacyRefOnInit);
+    return value;
+}
+function isLegacyFlowRefValueSchema(value) {
+    return (0, external_lodash_es_namespaceObject.isObject)(value) && 2 === Object.keys(value).length && 'ref' === value.type && 'string' == typeof value.content;
+}
+function isNewFlowRefValueSchema(value) {
+    return (0, external_lodash_es_namespaceObject.isObject)(value) && 2 === Object.keys(value).length && 'ref' === value.type && Array.isArray(value.content);
+}
+function formatLegacyRefToNewRef(value) {
+    const keyPath = value.content.split('.');
+    if ('outputs' === keyPath[1]) return {
+        type: 'ref',
+        content: [
+            `${keyPath[0]}.${keyPath[1]}`,
+            ...keyPath.length > 2 ? keyPath.slice(2) : []
+        ]
+    };
+    return {
+        type: 'ref',
+        content: keyPath
+    };
+}
+function formatNewRefToLegacyRef(value) {
+    return {
+        type: 'ref',
+        content: value.content.join('.')
+    };
+}
+exports.formatLegacyRefOnInit = __webpack_exports__.formatLegacyRefOnInit;
+exports.formatLegacyRefOnSubmit = __webpack_exports__.formatLegacyRefOnSubmit;
+exports.formatLegacyRefToNewRef = __webpack_exports__.formatLegacyRefToNewRef;
+exports.formatNewRefToLegacyRef = __webpack_exports__.formatNewRefToLegacyRef;
+exports.isLegacyFlowRefValueSchema = __webpack_exports__.isLegacyFlowRefValueSchema;
+exports.isNewFlowRefValueSchema = __webpack_exports__.isNewFlowRefValueSchema;
+for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+    "formatLegacyRefOnInit",
+    "formatLegacyRefOnSubmit",
+    "formatLegacyRefToNewRef",
+    "formatNewRefToLegacyRef",
+    "isLegacyFlowRefValueSchema",
+    "isNewFlowRefValueSchema"
+].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/shared/index.js

@@ -0,0 +1,73 @@
+"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__, {
+    isNewFlowRefValueSchema: ()=>external_format_legacy_refs_index_js_namespaceObject.isNewFlowRefValueSchema,
+    FlowValueUtils: ()=>index_js_namespaceObject.FlowValueUtils,
+    isLegacyFlowRefValueSchema: ()=>external_format_legacy_refs_index_js_namespaceObject.isLegacyFlowRefValueSchema,
+    unstableSetCreateRoot: ()=>external_polyfill_create_root_index_js_namespaceObject.unstableSetCreateRoot,
+    formatLegacyRefOnSubmit: ()=>external_format_legacy_refs_index_js_namespaceObject.formatLegacyRefOnSubmit,
+    createInjectMaterial: ()=>external_inject_material_index_js_namespaceObject.createInjectMaterial,
+    lazySuspense: ()=>external_lazy_suspense_index_js_namespaceObject.lazySuspense,
+    formatNewRefToLegacyRef: ()=>external_format_legacy_refs_index_js_namespaceObject.formatNewRefToLegacyRef,
+    polyfillCreateRoot: ()=>external_polyfill_create_root_index_js_namespaceObject.polyfillCreateRoot,
+    withSuspense: ()=>external_lazy_suspense_index_js_namespaceObject.withSuspense,
+    formatLegacyRefToNewRef: ()=>external_format_legacy_refs_index_js_namespaceObject.formatLegacyRefToNewRef,
+    formatLegacyRefOnInit: ()=>external_format_legacy_refs_index_js_namespaceObject.formatLegacyRefOnInit
+});
+const index_js_namespaceObject = require("./flow-value/index.js");
+const external_format_legacy_refs_index_js_namespaceObject = require("./format-legacy-refs/index.js");
+const external_inject_material_index_js_namespaceObject = require("./inject-material/index.js");
+const external_lazy_suspense_index_js_namespaceObject = require("./lazy-suspense/index.js");
+const external_polyfill_create_root_index_js_namespaceObject = require("./polyfill-create-root/index.js");
+exports.FlowValueUtils = __webpack_exports__.FlowValueUtils;
+exports.createInjectMaterial = __webpack_exports__.createInjectMaterial;
+exports.formatLegacyRefOnInit = __webpack_exports__.formatLegacyRefOnInit;
+exports.formatLegacyRefOnSubmit = __webpack_exports__.formatLegacyRefOnSubmit;
+exports.formatLegacyRefToNewRef = __webpack_exports__.formatLegacyRefToNewRef;
+exports.formatNewRefToLegacyRef = __webpack_exports__.formatNewRefToLegacyRef;
+exports.isLegacyFlowRefValueSchema = __webpack_exports__.isLegacyFlowRefValueSchema;
+exports.isNewFlowRefValueSchema = __webpack_exports__.isNewFlowRefValueSchema;
+exports.lazySuspense = __webpack_exports__.lazySuspense;
+exports.polyfillCreateRoot = __webpack_exports__.polyfillCreateRoot;
+exports.unstableSetCreateRoot = __webpack_exports__.unstableSetCreateRoot;
+exports.withSuspense = __webpack_exports__.withSuspense;
+for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+    "FlowValueUtils",
+    "createInjectMaterial",
+    "formatLegacyRefOnInit",
+    "formatLegacyRefOnSubmit",
+    "formatLegacyRefToNewRef",
+    "formatNewRefToLegacyRef",
+    "isLegacyFlowRefValueSchema",
+    "isNewFlowRefValueSchema",
+    "lazySuspense",
+    "polyfillCreateRoot",
+    "unstableSetCreateRoot",
+    "withSuspense"
+].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/shared/inject-material/index.js

@@ -0,0 +1,66 @@
+"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__, {
+    createInjectMaterial: ()=>createInjectMaterial
+});
+const external_react_namespaceObject = require("react");
+var external_react_default = /*#__PURE__*/ __webpack_require__.n(external_react_namespaceObject);
+const editor_namespaceObject = require("@flowgram.ai/editor");
+function createInjectMaterial(Component, params) {
+    const renderKey = params?.renderKey || Component.renderKey || Component.name || '';
+    const InjectComponent = (props)=>{
+        const container = (0, editor_namespaceObject.usePlaygroundContainer)();
+        if (!container?.isBound(editor_namespaceObject.FlowRendererRegistry)) return /*#__PURE__*/ external_react_default().createElement(Component, {
+            ...props
+        });
+        const rendererRegistry = container.get(editor_namespaceObject.FlowRendererRegistry);
+        const renderer = rendererRegistry.tryToGetRendererComponent(renderKey);
+        if (renderer?.type !== editor_namespaceObject.FlowRendererComponentType.REACT) return /*#__PURE__*/ external_react_default().createElement(Component, {
+            ...props
+        });
+        return /*#__PURE__*/ external_react_default().createElement(renderer.renderer, {
+            ...props
+        });
+    };
+    InjectComponent.renderKey = renderKey;
+    return InjectComponent;
+}
+exports.createInjectMaterial = __webpack_exports__.createInjectMaterial;
+for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+    "createInjectMaterial"
+].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/shared/lazy-suspense/index.js

@@ -0,0 +1,58 @@
+"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__, {
+    withSuspense: ()=>withSuspense,
+    lazySuspense: ()=>lazySuspense
+});
+const jsx_runtime_namespaceObject = require("react/jsx-runtime");
+const external_react_namespaceObject = require("react");
+const semi_ui_namespaceObject = require("@douyinfe/semi-ui");
+function withSuspense(Component, fallback) {
+    const WithSuspenseComponent = (props)=>/*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(external_react_namespaceObject.Suspense, {
+            fallback: fallback || /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(semi_ui_namespaceObject.Skeleton.Paragraph, {
+                style: {
+                    width: '100%'
+                },
+                rows: 1
+            }),
+            children: /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(Component, {
+                ...props
+            })
+        });
+    return WithSuspenseComponent;
+}
+function lazySuspense(params, fallback) {
+    return withSuspense(/*#__PURE__*/ (0, external_react_namespaceObject.lazy)(params), fallback);
+}
+exports.lazySuspense = __webpack_exports__.lazySuspense;
+exports.withSuspense = __webpack_exports__.withSuspense;
+for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+    "lazySuspense",
+    "withSuspense"
+].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/shared/polyfill-create-root/index.js

@@ -0,0 +1,53 @@
+"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__, {
+    polyfillCreateRoot: ()=>polyfillCreateRoot,
+    unstableSetCreateRoot: ()=>unstableSetCreateRoot
+});
+const external_react_dom_namespaceObject = require("react-dom");
+let unstableCreateRoot = (dom)=>({
+        render (children) {
+            external_react_dom_namespaceObject.render(children, dom);
+        },
+        unmount () {
+            external_react_dom_namespaceObject.unmountComponentAtNode(dom);
+        }
+    });
+function polyfillCreateRoot(dom) {
+    return unstableCreateRoot(dom);
+}
+function unstableSetCreateRoot(createRoot) {
+    unstableCreateRoot = createRoot;
+}
+exports.polyfillCreateRoot = __webpack_exports__.polyfillCreateRoot;
+exports.unstableSetCreateRoot = __webpack_exports__.unstableSetCreateRoot;
+for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+    "polyfillCreateRoot",
+    "unstableSetCreateRoot"
+].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/validate/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__, {
+    validateFlowValue: ()=>index_js_namespaceObject.validateFlowValue
+});
+const index_js_namespaceObject = require("./validate-flow-value/index.js");
+exports.validateFlowValue = __webpack_exports__.validateFlowValue;
+for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+    "validateFlowValue"
+].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/validate/validate-flow-value/index.js

@@ -0,0 +1,63 @@
+"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__, {
+    validateFlowValue: ()=>validateFlowValue
+});
+const external_lodash_es_namespaceObject = require("lodash-es");
+const editor_namespaceObject = require("@flowgram.ai/editor");
+const index_js_namespaceObject = require("../../shared/index.js");
+function validateFlowValue(value, ctx) {
+    const { node, required, errorMessages } = ctx;
+    const { required: requiredMessage = 'Field is required', unknownVariable: unknownVariableMessage = 'Unknown Variable' } = errorMessages || {};
+    if (required && ((0, external_lodash_es_namespaceObject.isNil)(value) || (0, external_lodash_es_namespaceObject.isNil)(value?.content) || value?.content === '')) return {
+        level: editor_namespaceObject.FeedbackLevel.Error,
+        message: requiredMessage
+    };
+    if (value?.type === 'ref') {
+        const variable = (0, editor_namespaceObject.getNodeScope)(node).available.getByKeyPath(value?.content || []);
+        if (!variable) return {
+            level: editor_namespaceObject.FeedbackLevel.Error,
+            message: unknownVariableMessage
+        };
+    }
+    if (value?.type === 'template') {
+        const allRefs = index_js_namespaceObject.FlowValueUtils.getTemplateKeyPaths(value);
+        for (const ref of allRefs){
+            const variable = (0, editor_namespaceObject.getNodeScope)(node).available.getByKeyPath(ref);
+            if (!variable) return {
+                level: editor_namespaceObject.FeedbackLevel.Error,
+                message: unknownVariableMessage
+            };
+        }
+    }
+}
+exports.validateFlowValue = __webpack_exports__.validateFlowValue;
+for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+    "validateFlowValue"
+].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/esm/components/assign-row/index.mjs

@@ -0,0 +1,78 @@
+import { jsx, jsxs } from "react/jsx-runtime";
+import "react";
+import { IconButton } from "@douyinfe/semi-ui";
+import { IconMinus } from "@douyinfe/semi-icons";
+import { InjectVariableSelector } from "../variable-selector/index.mjs";
+import { InjectDynamicValueInput } from "../dynamic-value-input/index.mjs";
+import { BlurInput } from "../blur-input/index.mjs";
+function AssignRow(props) {
+    const { value = {
+        operator: 'assign'
+    }, onChange, onDelete, readonly } = props;
+    return /*#__PURE__*/ jsxs("div", {
+        style: {
+            display: 'flex',
+            alignItems: 'center',
+            gap: 5
+        },
+        children: [
+            /*#__PURE__*/ jsx("div", {
+                style: {
+                    width: 150,
+                    minWidth: 150,
+                    maxWidth: 150
+                },
+                children: value?.operator === 'assign' ? /*#__PURE__*/ jsx(InjectVariableSelector, {
+                    style: {
+                        width: '100%',
+                        height: 26
+                    },
+                    value: value?.left?.content,
+                    config: {
+                        placeholder: 'Select Left'
+                    },
+                    onChange: (v)=>onChange?.({
+                            ...value,
+                            left: {
+                                type: 'ref',
+                                content: v
+                            }
+                        })
+                }) : /*#__PURE__*/ jsx(BlurInput, {
+                    style: {
+                        height: 26
+                    },
+                    size: "small",
+                    placeholder: "Input Name",
+                    value: value?.left,
+                    onChange: (v)=>onChange?.({
+                            ...value,
+                            left: v
+                        })
+                })
+            }),
+            /*#__PURE__*/ jsx("div", {
+                style: {
+                    flexGrow: 1
+                },
+                children: /*#__PURE__*/ jsx(InjectDynamicValueInput, {
+                    readonly: readonly,
+                    value: value?.right,
+                    onChange: (v)=>onChange?.({
+                            ...value,
+                            right: v
+                        })
+                })
+            }),
+            onDelete && /*#__PURE__*/ jsx("div", {
+                children: /*#__PURE__*/ jsx(IconButton, {
+                    size: "small",
+                    theme: "borderless",
+                    icon: /*#__PURE__*/ jsx(IconMinus, {}),
+                    onClick: ()=>onDelete?.()
+                })
+            })
+        ]
+    });
+}
+export { AssignRow };