@flowgram.ai/form-materials 0.4.9 → 0.4.10

package/dist/cjs/components/condition-row/constants.js

@@ -0,0 +1,165 @@
+"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__, {
+    defaultOpConfigs: ()=>defaultOpConfigs,
+    defaultRules: ()=>defaultRules
+});
+const external_types_js_namespaceObject = require("./types.js");
+const defaultRules = {
+    string: {
+        [external_types_js_namespaceObject.Op.EQ]: 'string',
+        [external_types_js_namespaceObject.Op.NEQ]: 'string',
+        [external_types_js_namespaceObject.Op.CONTAINS]: 'string',
+        [external_types_js_namespaceObject.Op.NOT_CONTAINS]: 'string',
+        [external_types_js_namespaceObject.Op.IN]: 'array',
+        [external_types_js_namespaceObject.Op.NIN]: 'array',
+        [external_types_js_namespaceObject.Op.IS_EMPTY]: null,
+        [external_types_js_namespaceObject.Op.IS_NOT_EMPTY]: null
+    },
+    number: {
+        [external_types_js_namespaceObject.Op.EQ]: 'number',
+        [external_types_js_namespaceObject.Op.NEQ]: 'number',
+        [external_types_js_namespaceObject.Op.GT]: 'number',
+        [external_types_js_namespaceObject.Op.GTE]: 'number',
+        [external_types_js_namespaceObject.Op.LT]: 'number',
+        [external_types_js_namespaceObject.Op.LTE]: 'number',
+        [external_types_js_namespaceObject.Op.IN]: 'array',
+        [external_types_js_namespaceObject.Op.NIN]: 'array'
+    },
+    integer: {
+        [external_types_js_namespaceObject.Op.EQ]: 'number',
+        [external_types_js_namespaceObject.Op.NEQ]: 'number',
+        [external_types_js_namespaceObject.Op.GT]: 'number',
+        [external_types_js_namespaceObject.Op.GTE]: 'number',
+        [external_types_js_namespaceObject.Op.LT]: 'number',
+        [external_types_js_namespaceObject.Op.LTE]: 'number',
+        [external_types_js_namespaceObject.Op.IN]: 'array',
+        [external_types_js_namespaceObject.Op.NIN]: 'array'
+    },
+    boolean: {
+        [external_types_js_namespaceObject.Op.EQ]: 'boolean',
+        [external_types_js_namespaceObject.Op.NEQ]: 'boolean',
+        [external_types_js_namespaceObject.Op.IS_TRUE]: null,
+        [external_types_js_namespaceObject.Op.IS_FALSE]: null,
+        [external_types_js_namespaceObject.Op.IN]: 'array',
+        [external_types_js_namespaceObject.Op.NIN]: 'array'
+    },
+    object: {
+        [external_types_js_namespaceObject.Op.IS_EMPTY]: null,
+        [external_types_js_namespaceObject.Op.IS_NOT_EMPTY]: null
+    },
+    array: {
+        [external_types_js_namespaceObject.Op.IS_EMPTY]: null,
+        [external_types_js_namespaceObject.Op.IS_NOT_EMPTY]: null,
+        [external_types_js_namespaceObject.Op.CONTAINS]: 'array',
+        [external_types_js_namespaceObject.Op.NOT_CONTAINS]: 'array',
+        [external_types_js_namespaceObject.Op.EQ]: 'array',
+        [external_types_js_namespaceObject.Op.NEQ]: 'array'
+    },
+    map: {
+        [external_types_js_namespaceObject.Op.IS_EMPTY]: null,
+        [external_types_js_namespaceObject.Op.IS_NOT_EMPTY]: null
+    },
+    ['date-time']: {
+        [external_types_js_namespaceObject.Op.EQ]: 'date-time',
+        [external_types_js_namespaceObject.Op.NEQ]: 'date-time',
+        [external_types_js_namespaceObject.Op.GT]: 'date-time',
+        [external_types_js_namespaceObject.Op.GTE]: 'date-time',
+        [external_types_js_namespaceObject.Op.LT]: 'date-time',
+        [external_types_js_namespaceObject.Op.LTE]: 'date-time'
+    }
+};
+const defaultOpConfigs = {
+    [external_types_js_namespaceObject.Op.EQ]: {
+        label: 'Equal',
+        abbreviation: '='
+    },
+    [external_types_js_namespaceObject.Op.NEQ]: {
+        label: 'Not Equal',
+        abbreviation: "\u2260"
+    },
+    [external_types_js_namespaceObject.Op.GT]: {
+        label: 'Greater Than',
+        abbreviation: '>'
+    },
+    [external_types_js_namespaceObject.Op.GTE]: {
+        label: 'Greater Than or Equal',
+        abbreviation: '>='
+    },
+    [external_types_js_namespaceObject.Op.LT]: {
+        label: 'Less Than',
+        abbreviation: '<'
+    },
+    [external_types_js_namespaceObject.Op.LTE]: {
+        label: 'Less Than or Equal',
+        abbreviation: '<='
+    },
+    [external_types_js_namespaceObject.Op.IN]: {
+        label: 'In',
+        abbreviation: "\u2208"
+    },
+    [external_types_js_namespaceObject.Op.NIN]: {
+        label: 'Not In',
+        abbreviation: "\u2209"
+    },
+    [external_types_js_namespaceObject.Op.CONTAINS]: {
+        label: 'Contains',
+        abbreviation: "\u2287"
+    },
+    [external_types_js_namespaceObject.Op.NOT_CONTAINS]: {
+        label: 'Not Contains',
+        abbreviation: "\u2289"
+    },
+    [external_types_js_namespaceObject.Op.IS_EMPTY]: {
+        label: 'Is Empty',
+        abbreviation: '=',
+        rightDisplay: 'Empty'
+    },
+    [external_types_js_namespaceObject.Op.IS_NOT_EMPTY]: {
+        label: 'Is Not Empty',
+        abbreviation: "\u2260",
+        rightDisplay: 'Empty'
+    },
+    [external_types_js_namespaceObject.Op.IS_TRUE]: {
+        label: 'Is True',
+        abbreviation: '=',
+        rightDisplay: 'True'
+    },
+    [external_types_js_namespaceObject.Op.IS_FALSE]: {
+        label: 'Is False',
+        abbreviation: '=',
+        rightDisplay: 'False'
+    }
+};
+exports.defaultOpConfigs = __webpack_exports__.defaultOpConfigs;
+exports.defaultRules = __webpack_exports__.defaultRules;
+for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+    "defaultOpConfigs",
+    "defaultRules"
+].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/components/condition-row/hooks/useOp.js

@@ -0,0 +1,78 @@
+"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__, {
+    useOp: ()=>useOp
+});
+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 external_constants_js_namespaceObject = require("../constants.js");
+function useOp({ rule, op, onChange, readonly, userOps }) {
+    const options = (0, external_react_namespaceObject.useMemo)(()=>Object.keys(rule || {}).map((_op)=>({
+                ...external_constants_js_namespaceObject.defaultOpConfigs[_op] || {},
+                ...userOps?.[_op] || {},
+                value: _op,
+                label: editor_namespaceObject.I18n.t(userOps?.[_op]?.label || external_constants_js_namespaceObject.defaultOpConfigs[_op]?.label)
+            })), [
+        rule,
+        userOps
+    ]);
+    const opConfig = (0, external_react_namespaceObject.useMemo)(()=>external_constants_js_namespaceObject.defaultOpConfigs[op], [
+        op
+    ]);
+    const renderOpSelect = ()=>/*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(semi_ui_namespaceObject.Select, {
+            style: {
+                height: 22
+            },
+            disabled: readonly,
+            size: "small",
+            value: op,
+            optionList: options,
+            onChange: (v)=>{
+                onChange(v);
+            },
+            triggerRender: ({ value })=>/*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(semi_ui_namespaceObject.Button, {
+                    size: "small",
+                    disabled: !rule,
+                    children: opConfig?.abbreviation || /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(semi_icons_namespaceObject.IconChevronDownStroked, {
+                        size: "small"
+                    })
+                })
+        });
+    return {
+        renderOpSelect,
+        opConfig
+    };
+}
+exports.useOp = __webpack_exports__.useOp;
+for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+    "useOp"
+].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/components/condition-row/hooks/useRule.js

@@ -0,0 +1,68 @@
+"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__, {
+    useRule: ()=>useRule
+});
+const external_react_namespaceObject = require("react");
+const json_schema_namespaceObject = require("@flowgram.ai/json-schema");
+const editor_namespaceObject = require("@flowgram.ai/editor");
+const external_constants_js_namespaceObject = require("../constants.js");
+function useRule(left, userRules) {
+    const available = (0, editor_namespaceObject.useScopeAvailable)();
+    const rules = (0, external_react_namespaceObject.useMemo)(()=>({
+            ...external_constants_js_namespaceObject.defaultRules,
+            ...userRules || {}
+        }), [
+        userRules
+    ]);
+    const variable = (0, external_react_namespaceObject.useMemo)(()=>{
+        if (!left) return;
+        return available.getByKeyPath(left.content);
+    }, [
+        available,
+        left
+    ]);
+    const rule = (0, external_react_namespaceObject.useMemo)(()=>{
+        if (!variable) return;
+        const schema = json_schema_namespaceObject.JsonSchemaUtils.astToSchema(variable.type, {
+            drilldown: false
+        });
+        return rules[schema?.type];
+    }, [
+        variable?.type,
+        rules
+    ]);
+    return {
+        rule
+    };
+}
+exports.useRule = __webpack_exports__.useRule;
+for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+    "useRule"
+].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/components/condition-row/index.js

@@ -0,0 +1,123 @@
+"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__, {
+    ConditionRow: ()=>ConditionRow
+});
+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 index_js_namespaceObject = require("../variable-selector/index.js");
+const external_dynamic_value_input_index_js_namespaceObject = require("../dynamic-value-input/index.js");
+const external_styles_js_namespaceObject = require("./styles.js");
+const useRule_js_namespaceObject = require("./hooks/useRule.js");
+const useOp_js_namespaceObject = require("./hooks/useOp.js");
+const external_constants_js_namespaceObject = require("./constants.js");
+const defaultRuleConfig = {
+    ops: {},
+    rules: {}
+};
+function ConditionRow({ style, value, onChange, readonly, ruleConfig = defaultRuleConfig }) {
+    const { left, operator, right } = value || {};
+    const { rule } = (0, useRule_js_namespaceObject.useRule)(left, ruleConfig.rules);
+    const { renderOpSelect, opConfig } = (0, useOp_js_namespaceObject.useOp)({
+        rule,
+        op: operator,
+        onChange: (v)=>onChange({
+                ...value,
+                operator: v
+            }),
+        readonly,
+        userOps: ruleConfig.ops
+    });
+    const targetSchema = (0, external_react_namespaceObject.useMemo)(()=>{
+        const targetType = rule?.[operator || ''] || null;
+        return targetType ? {
+            type: targetType,
+            extra: {
+                weak: true
+            }
+        } : null;
+    }, [
+        rule,
+        opConfig
+    ]);
+    return /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsxs)(external_styles_js_namespaceObject.UIContainer, {
+        style: style,
+        children: [
+            /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(external_styles_js_namespaceObject.UIOperator, {
+                children: renderOpSelect()
+            }),
+            /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsxs)(external_styles_js_namespaceObject.UIValues, {
+                children: [
+                    /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(external_styles_js_namespaceObject.UILeft, {
+                        children: /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(index_js_namespaceObject.InjectVariableSelector, {
+                            readonly: readonly,
+                            style: {
+                                width: '100%'
+                            },
+                            value: left?.content,
+                            onChange: (v)=>onChange({
+                                    ...value,
+                                    left: {
+                                        type: 'ref',
+                                        content: v
+                                    }
+                                })
+                        })
+                    }),
+                    /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(external_styles_js_namespaceObject.UIRight, {
+                        children: targetSchema ? /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(external_dynamic_value_input_index_js_namespaceObject.InjectDynamicValueInput, {
+                            readonly: readonly || !rule,
+                            value: right,
+                            schema: targetSchema,
+                            onChange: (v)=>onChange({
+                                    ...value,
+                                    right: v
+                                })
+                        }) : /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(semi_ui_namespaceObject.Input, {
+                            size: "small",
+                            disabled: true,
+                            style: {
+                                pointerEvents: 'none'
+                            },
+                            value: opConfig?.rightDisplay || editor_namespaceObject.I18n.t('Empty')
+                        })
+                    })
+                ]
+            })
+        ]
+    });
+}
+ConditionRow.defaultRules = external_constants_js_namespaceObject.defaultRules;
+ConditionRow.defaultOpConfigs = external_constants_js_namespaceObject.defaultOpConfigs;
+exports.ConditionRow = __webpack_exports__.ConditionRow;
+for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+    "ConditionRow"
+].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/components/condition-row/styles.js

@@ -0,0 +1,77 @@
+"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__, {
+    UIOperator: ()=>UIOperator,
+    UIContainer: ()=>UIContainer,
+    UIRight: ()=>UIRight,
+    UIValues: ()=>UIValues,
+    UILeft: ()=>UILeft
+});
+const external_styled_components_namespaceObject = require("styled-components");
+var external_styled_components_default = /*#__PURE__*/ __webpack_require__.n(external_styled_components_namespaceObject);
+const UIContainer = external_styled_components_default().div`
+  display: flex;
+  align-items: center;
+  gap: 4px;
+`;
+const UIOperator = external_styled_components_default().div``;
+const UILeft = external_styled_components_default().div`
+  width: 100%;
+`;
+const UIRight = external_styled_components_default().div`
+  width: 100%;
+`;
+const UIValues = external_styled_components_default().div`
+  flex-grow: 1;
+  display: flex;
+  flex-direction: column;
+  align-items: center;
+  gap: 4px;
+`;
+exports.UIContainer = __webpack_exports__.UIContainer;
+exports.UILeft = __webpack_exports__.UILeft;
+exports.UIOperator = __webpack_exports__.UIOperator;
+exports.UIRight = __webpack_exports__.UIRight;
+exports.UIValues = __webpack_exports__.UIValues;
+for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+    "UIContainer",
+    "UILeft",
+    "UIOperator",
+    "UIRight",
+    "UIValues"
+].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/components/condition-row/types.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__, {
+    Op: ()=>Op
+});
+var Op = /*#__PURE__*/ function(Op) {
+    Op["EQ"] = "eq";
+    Op["NEQ"] = "neq";
+    Op["GT"] = "gt";
+    Op["GTE"] = "gte";
+    Op["LT"] = "lt";
+    Op["LTE"] = "lte";
+    Op["IN"] = "in";
+    Op["NIN"] = "nin";
+    Op["CONTAINS"] = "contains";
+    Op["NOT_CONTAINS"] = "not_contains";
+    Op["IS_EMPTY"] = "is_empty";
+    Op["IS_NOT_EMPTY"] = "is_not_empty";
+    Op["IS_TRUE"] = "is_true";
+    Op["IS_FALSE"] = "is_false";
+    return Op;
+}({});
+exports.Op = __webpack_exports__.Op;
+for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+    "Op"
+].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/components/constant-input/index.js

@@ -0,0 +1,80 @@
+"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__, {
+    ConstantInput: ()=>ConstantInput
+});
+const jsx_runtime_namespaceObject = require("react/jsx-runtime");
+const external_react_namespaceObject = require("react");
+var external_react_default = /*#__PURE__*/ __webpack_require__.n(external_react_namespaceObject);
+const semi_ui_namespaceObject = require("@douyinfe/semi-ui");
+const index_js_namespaceObject = require("../../plugins/index.js");
+function ConstantInput(props) {
+    const { value, onChange, schema, strategies, fallbackRenderer, readonly, ...rest } = props;
+    const typeManager = (0, index_js_namespaceObject.useTypeManager)();
+    const Renderer = (0, external_react_namespaceObject.useMemo)(()=>{
+        const strategy = (strategies || []).find((_strategy)=>_strategy.hit(schema));
+        if (!strategy) return typeManager.getTypeBySchema(schema)?.ConstantRenderer;
+        return strategy?.Renderer;
+    }, [
+        strategies,
+        schema
+    ]);
+    if (!Renderer) {
+        if (fallbackRenderer) return /*#__PURE__*/ external_react_default().createElement(fallbackRenderer, {
+            value,
+            onChange,
+            readonly,
+            ...rest
+        });
+        return /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(semi_ui_namespaceObject.Input, {
+            size: "small",
+            disabled: true,
+            placeholder: "Unsupported type"
+        });
+    }
+    return /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(Renderer, {
+        value: value,
+        onChange: onChange,
+        readonly: readonly,
+        ...rest
+    });
+}
+exports.ConstantInput = __webpack_exports__.ConstantInput;
+for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+    "ConstantInput"
+].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/components/constant-input/types.js

@@ -0,0 +1,18 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __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__);
+for(var __webpack_i__ in __webpack_exports__)exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});