@formily-design/formily-antd 1.0.21 → 1.0.22

package/lib/components/Field/valueMapping.js

@@ -1,109 +1,149 @@
 "use strict";
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createValueMappingSettingsReaction = exports.validateValueMappingTargetPaths = void 0;
+exports.createValueMappingGroup = exports.createValueMappingSettingsReaction = exports.validateValueMappingTargetPaths = void 0;
 const reactive_1 = require("@formily/reactive");
 const core_1 = require("@formily-design/core");
-// 一个 Form 只允许排队一个 cleanup；WeakSet 不持有 Form 强引用，也不会串扰其它 Form。
+/** 防止清空字段时 reaction 的同步更新与异步清理互相重复。 */
 const pendingMappingCleanups = new WeakSet();
+/** 只有输入过非空文本才显示“不完整”字段的校验反馈。 */
 const hasInputText = (value) => typeof value === 'string' && Boolean(value.trim());
-/**
- * 校验一组手动输入的映射 target 路径。
- *
- * 空数组表示尚未启用映射；一旦任意路径有值，所有 target 都必须填写、合法且唯一。
- * 该方法与具体组件数量无关，日期范围、省市区等配置界面均可复用。
- */
-const validateValueMappingTargetPaths = (paths) => (0, core_1.validateValueMappingTargetPaths)(paths, { allowEmpty: true });
+const validateValueMappingTargetPaths = (paths, allowEmpty = true) => 
+// 设置器允许固定字段全部为空来表达删除配置；动态字段则由调用方传入对应规则。
+(0, core_1.validateValueMappingFieldPaths)(paths, { allowEmpty });
 exports.validateValueMappingTargetPaths = validateValueMappingTargetPaths;
-/** 将同一份 target 快照规范化为运行时协议。 */
-const syncValueMappingProtocol = (form, targetValues, adapter, scope, submitSource) => {
-    const normalizedTargets = targetValues.map((path) => ({
+/** 将静态值或组件属性中的 truthy 值统一映射为协议 cardinality。 */
+const getCardinality = (form, cardinality) => {
+    if (typeof cardinality === 'string')
+        return cardinality;
+    return form.getValuesIn(cardinality.path)
+        ? core_1.VALUE_MAPPING_CARDINALITY_MULTIPLE
+        : core_1.VALUE_MAPPING_CARDINALITY_SINGLE;
+};
+/** 在写入协议前解析静态 target 或组件提供的动态 target。 */
+const resolveTarget = (form, cardinality, target) => {
+    if ('resolve' in target) {
+        return target.resolve({ form, cardinality });
+    }
+    return target;
+};
+/** 读取设置器当前字段值，并同时返回用于反馈错误的字段路径。 */
+const getFieldSettings = (form, fields) => {
+    if (fields.type === 'fixed') {
+        // 通过 query 优先读取已注册字段值，兼容设置器字段尚未注册时的 form 值。
+        return {
+            values: fields.paths.map((path) => {
+                let fieldValue;
+                form.query(path).take((field) => {
+                    fieldValue = field === null || field === void 0 ? void 0 : field.value;
+                });
+                return fieldValue === undefined ? form.getValuesIn(path) : fieldValue;
+            }),
+            paths: fields.paths,
+            dynamic: false,
+        };
+    }
+    // 动态字段的每一行都映射到协议中的一个 fields 项，路径顺序必须保持一致。
+    const current = form.getValuesIn(fields.path);
+    const values = Array.isArray(current) ? current : [];
+    return {
+        values: values.map((item) => item === null || item === void 0 ? void 0 : item.path),
+        paths: values.map((_, index) => `${fields.path}.${index}.path`),
+        dynamic: true,
+    };
+};
+const syncValueMappingProtocol = (form, values, adapter, cardinality, target, fields) => {
+    // 协议只保存规范化后的 path；设置器仍保留同一顺序，便于 ArrayItems 增删和排序。
+    const normalizedFields = values.map((path) => ({
         path: typeof path === 'string' ? path.trim() : '',
     }));
-    const currentTargets = form.getValuesIn(`${core_1.VALUE_MAPPING_SCHEMA_KEY}.targets`);
-    const targetsChanged = !Array.isArray(currentTargets) ||
-        currentTargets.length !== normalizedTargets.length ||
-        normalizedTargets.some((target, index) => { var _a; return ((_a = currentTargets[index]) === null || _a === void 0 ? void 0 : _a.path) !== target.path; });
-    // FormPath 的数字点路径默认可能生成对象，这里统一规范化为运行时协议要求的数组。
-    if (targetsChanged) {
-        form.setValuesIn(`${core_1.VALUE_MAPPING_SCHEMA_KEY}.targets`, normalizedTargets);
-    }
-    const setProtocolValue = (path, value) => {
-        if (form.getValuesIn(path) !== value) {
-            form.setValuesIn(path, value);
+    const targetValue = target.type === core_1.VALUE_MAPPING_TARGET_FIELDS
+        ? {
+            type: core_1.VALUE_MAPPING_TARGET_FIELDS,
+            scope: target.scope,
+            fields: normalizedFields,
+            includeSource: target.includeSource === true,
         }
+        : {
+            type: core_1.VALUE_MAPPING_TARGET_OBJECT,
+            scope: target.scope,
+            fields: normalizedFields,
+        };
+    const next = {
+        version: core_1.VALUE_MAPPING_VERSION,
+        adapter,
+        cardinality,
+        target: targetValue,
     };
-    setProtocolValue(`${core_1.VALUE_MAPPING_SCHEMA_KEY}.version`, core_1.VALUE_MAPPING_VERSION);
-    setProtocolValue(`${core_1.VALUE_MAPPING_SCHEMA_KEY}.adapter`, adapter);
-    setProtocolValue(`${core_1.VALUE_MAPPING_SCHEMA_KEY}.scope`, scope);
-    setProtocolValue(`${core_1.VALUE_MAPPING_SCHEMA_KEY}.submitSource`, submitSource);
+    const current = form.getValuesIn(core_1.VALUE_MAPPING_SCHEMA_KEY);
+    // 避免 reaction 在每次运行时重复写入，减少设置表单的二次 reaction。
+    if (JSON.stringify(current) !== JSON.stringify(next)) {
+        form.setValuesIn(core_1.VALUE_MAPPING_SCHEMA_KEY, next);
+    }
+    // 动态 ArrayItems 需要保持用户对字段顺序的修改；协议本身与设置数组共用同一顺序。
+    if (fields.type === 'dynamic') {
+        const currentFields = form.getValuesIn(fields.path);
+        if (JSON.stringify(currentFields) !== JSON.stringify(normalizedFields)) {
+            form.setValuesIn(fields.path, normalizedFields);
+        }
+    }
 };
-/** 同步 target Field 的错误反馈；它不读取 feedback，因此 feedback 只是 reaction 输出。 */
-const syncValueMappingErrors = (form, targetPaths, targetValues, error, message) => {
-    targetPaths.forEach((path, index) => {
-        form.query(path).take((targetField) => {
-            if (!(targetField === null || targetField === void 0 ? void 0 : targetField.setSelfErrors))
+const syncValueMappingErrors = (form, paths, values, error, message, dynamic) => {
+    // 动态行需要立即提示空项；固定字段只有在用户输入过时才提示 incomplete。
+    paths.forEach((path, index) => {
+        form.query(path).take((field) => {
+            if (!(field === null || field === void 0 ? void 0 : field.setSelfErrors))
                 return;
-            const hasInput = hasInputText(targetValues[index]);
-            const shouldShowError = Boolean(error && (error !== 'incomplete' || hasInput));
-            targetField.setSelfErrors(shouldShowError && message ? [message] : []);
+            const hasInput = hasInputText(values[index]);
+            const show = Boolean(error && (dynamic || error !== 'incomplete' || hasInput));
+            field.setSelfErrors(show && message ? [message] : []);
         });
     });
 };
+const shouldDeleteMapping = (values, fields) => {
+    // 动态字段“零行”与固定字段“所有值为空”都表示移除完整协议。
+    if (fields.type === 'dynamic') {
+        return values.length === 0;
+    }
+    return values.every((value) => !hasInputText(value));
+};
 /**
- * 读取一次 target 快照。主 reaction 和延迟 cleanup 必须使用同一口径：优先读
- * 已注册 Field 的 value，未注册的动态路径才从 Form values 兜底，避免 cleanup
- * 看到的值与主 reaction 不一致。
- */
-const readValueMappingTargetValues = (form, targetPaths) => targetPaths.map((path) => {
-    let hasField = false;
-    let fieldValue;
-    // 使用 take callback 兼容 Formily Query 和设置表单测试/动态节点实现。
-    form.query(path).take((targetField) => {
-        hasField = Boolean(targetField);
-        fieldValue = targetField === null || targetField === void 0 ? void 0 : targetField.value;
-    });
-    const fallbackValue = form.getValuesIn(path);
-    return hasField && fieldValue !== undefined ? fieldValue : fallbackValue;
-});
-/**
- * 创建设置表单使用的 value-mapping 协议与校验 reaction。
- *
- * 协议和反馈必须由一个 autorun 编排。若分别挂两个 x-reactions，它们对同一
- * 次 onInput 的调度顺序不稳定：协议 reaction 规范化数字路径时会再次写值，
- * 校验 reaction 可能拿到中间快照，导致残留错误或覆盖刚写入的配置。本 reaction
- * 先读取一次 targetValues，再同步反馈和协议，保证二者始终对应同一组输入。
- *
- * target 全空时先同步清除反馈，让界面立即恢复；父级协议延迟到当前 onInput/batch
- * 结束后的 Promise 微任务再删除。微任务执行前会重新读取最新 target：若用户已快速
- * 重新输入则跳过删除，避免旧 cleanup 误删。按 Form 隔离的 WeakSet 会合并同一 Form
- * 的重复 cleanup，同时不会影响其它设置 Form。
+ * 创建统一处理协议同步、动态字段和校验反馈的设置 reaction。
+ * reaction 先读取设置状态，再决定删除协议、反馈错误或写入 canonical v1 协议。
  */
-const createValueMappingSettingsReaction = ({ adapter, targetPaths, scope = core_1.VALUE_MAPPING_RELATIVE_SCOPE, submitSource = false, getMessage, }) => {
+const createValueMappingSettingsReaction = ({ adapter, fields, cardinality, target, getMessage, }) => {
     return (_field, reactionScope) => {
         const form = reactionScope === null || reactionScope === void 0 ? void 0 : reactionScope.$form;
         if (!form)
             return;
-        // 优先读取已注册 Field 的 value computed，让依赖绑定在稳定的 Field 上；协议
-        // 首次从数字路径对象规范化成数组后，后续另一个 Input 仍能触发同一 autorun。
-        // 未挂载的 target 则退回 Form values，兼容动态设置 Schema。
-        const targetValues = readValueMappingTargetValues(form, targetPaths);
-        const error = (0, exports.validateValueMappingTargetPaths)(targetValues);
+        const settings = getFieldSettings(form, fields);
+        const error = (0, core_1.validateValueMappingFieldPaths)(settings.values, {
+            allowEmpty: fields.type === 'fixed',
+        });
         const message = error ? getMessage(error, reactionScope) : undefined;
-        const hasTarget = targetValues.some(hasInputText);
-        if (!hasTarget) {
-            // 反馈清理同步执行；只有协议确实存在时才排队父对象删除。
-            (0, reactive_1.untracked)(() => {
-                syncValueMappingErrors(form, targetPaths, targetValues, error, message);
-            });
+        const empty = shouldDeleteMapping(settings.values, fields);
+        (0, reactive_1.untracked)(() => {
+            syncValueMappingErrors(form, settings.paths, settings.values, error, message, settings.dynamic);
+        });
+        if (empty) {
+            // 清空操作可能触发多次 reaction，放到微任务中读取最新状态后再删除协议。
             if (form.getValuesIn(core_1.VALUE_MAPPING_SCHEMA_KEY) !== undefined &&
                 !pendingMappingCleanups.has(form)) {
                 pendingMappingCleanups.add(form);
                 Promise.resolve().then(() => {
                     pendingMappingCleanups.delete(form);
-                    // 清空与重新输入可能发生在同一批次或连续微任务中，因此这里必须重新读值。
-                    const latestTargetValues = readValueMappingTargetValues(form, targetPaths);
-                    const latestHasTarget = latestTargetValues.some(hasInputText);
-                    if (!latestHasTarget &&
+                    const latest = getFieldSettings(form, fields);
+                    if (shouldDeleteMapping(latest.values, fields) &&
                         form.getValuesIn(core_1.VALUE_MAPPING_SCHEMA_KEY) !== undefined) {
                         form.deleteValuesIn(core_1.VALUE_MAPPING_SCHEMA_KEY);
                     }
@@ -111,12 +151,83 @@ const createValueMappingSettingsReaction = ({ adapter, targetPaths, scope = core
             }
             return;
         }
-        // feedback 是输出，不能反过来成为依赖；协议写入则保留通知，使 autorun
-        // 在数字路径从对象规范化为数组后重新建立对新数组叶节点的依赖。
-        (0, reactive_1.untracked)(() => {
-            syncValueMappingErrors(form, targetPaths, targetValues, error, message);
-        });
-        syncValueMappingProtocol(form, targetValues, adapter, scope, submitSource);
+        const currentCardinality = getCardinality(form, cardinality);
+        // target 必须在 cardinality 确定后解析，保证 Cascader.multiple 切换时协议组合合法。
+        syncValueMappingProtocol(form, settings.values, adapter, currentCardinality, resolveTarget(form, currentCardinality, target), fields);
     };
 };
 exports.createValueMappingSettingsReaction = createValueMappingSettingsReaction;
+const createFixedFieldsSchema = (fields, localeKey) => {
+    // 固定字段直接生成多个 Input，字段名即协议中对应的 settings path。
+    const getLocaleMessage = (token) => `{{$node.getMessage("settings.${localeKey}.${token}")}}`;
+    return fields.paths.reduce((properties, path, index) => {
+        properties[path] = {
+            type: 'string',
+            title: getLocaleMessage(fields.tokens[index]),
+            'x-decorator': 'FormItem',
+            'x-decorator-props': { feedbackLayout: 'loose' },
+            'x-component': 'Input',
+            'x-component-props': { allowClear: true },
+        };
+        return properties;
+    }, {});
+};
+const createDynamicFieldsSchema = (fields, localeKey) => ({
+    // 动态字段使用 ArrayItems 承载可变数量的映射项，顺序就是 tuple 层级顺序。
+    [fields.path]: {
+        type: 'array',
+        default: [],
+        'x-component': 'ArrayItems',
+        items: {
+            type: 'object',
+            'x-decorator': 'ArrayItems.Item',
+            'x-decorator-props': {
+                type: 'divide',
+                style: { borderBottom: 'none' },
+            },
+            properties: {
+                // remove 只负责删除当前行；字段顺序由 ArrayItems 自身维护。
+                path: {
+                    type: 'string',
+                    title: `{{$node.getMessage("settings.${localeKey}.${fields.token}")}}`,
+                    'x-decorator': 'FormItem',
+                    'x-decorator-props': { feedbackLayout: 'loose' },
+                    'x-component': 'Input',
+                    'x-component-props': { allowClear: true },
+                },
+                remove: {
+                    type: 'void',
+                    'x-component': 'ArrayItems.Remove',
+                },
+            },
+        },
+        properties: {
+            addition: {
+                type: 'void',
+                'x-component': 'ArrayItems.Addition',
+                'x-component-props': { style: { marginBottom: 8 } },
+            },
+        },
+    },
+});
+/**
+ * 创建组件属性面板中的新 v1 value-mapping 分组。
+ * 具体组件可通过 settingsProperties 注入额外设置，但协议同步仍由公共 reaction 负责。
+ */
+const createValueMappingGroup = (_a) => {
+    var { localeKey = 'value-mapping-group', settingsProperties } = _a, options = __rest(_a, ["localeKey", "settingsProperties"]);
+    const fieldProperties = options.fields.type === 'fixed'
+        ? createFixedFieldsSchema(options.fields, localeKey)
+        : createDynamicFieldsSchema(options.fields, localeKey);
+    const properties = Object.assign(Object.assign({}, fieldProperties), settingsProperties);
+    return {
+        type: 'void',
+        'x-component': 'CollapseItem',
+        'x-component-props': { defaultExpand: false },
+        'x-reactions': [
+            (0, exports.createValueMappingSettingsReaction)(Object.assign(Object.assign({}, options), { getMessage: (error, reactionScope) => { var _a; return (_a = reactionScope.$node) === null || _a === void 0 ? void 0 : _a.getMessage(`settings.${localeKey}.${error}`); } })),
+        ],
+        properties,
+    };
+};
+exports.createValueMappingGroup = createValueMappingGroup;

package/lib/locales/Cascader.d.ts

@@ -7,6 +7,7 @@ export declare const Cascader: {
                     title: string;
                     tooltip: string;
                 };
+                multiple: string;
                 displayRender: {
                     title: string;
                     tooltip: string;
@@ -16,6 +17,18 @@ export declare const Cascader: {
                     tooltip: string;
                 };
             };
+            'value-mapping-group': {
+                title: string;
+                fieldPath: string;
+                mappingPosition: string;
+                currentField: string;
+                siblingFields: string;
+                multipleOnlyCurrent: string;
+                empty: string;
+                incomplete: string;
+                duplicate: string;
+                invalid: string;
+            };
         };
     };
     'en-US': {
@@ -26,6 +39,7 @@ export declare const Cascader: {
                     title: string;
                     tooltip: string;
                 };
+                multiple: string;
                 displayRender: {
                     title: string;
                     tooltip: string;
@@ -35,6 +49,18 @@ export declare const Cascader: {
                     tooltip: string;
                 };
             };
+            'value-mapping-group': {
+                title: string;
+                fieldPath: string;
+                mappingPosition: string;
+                currentField: string;
+                siblingFields: string;
+                multipleOnlyCurrent: string;
+                empty: string;
+                incomplete: string;
+                duplicate: string;
+                invalid: string;
+            };
         };
     };
     'ko-KR': {
@@ -45,6 +71,7 @@ export declare const Cascader: {
                     title: string;
                     tooltip: string;
                 };
+                multiple: string;
                 displayRender: {
                     title: string;
                     tooltip: string;
@@ -54,6 +81,18 @@ export declare const Cascader: {
                     tooltip: string;
                 };
             };
+            'value-mapping-group': {
+                title: string;
+                fieldPath: string;
+                mappingPosition: string;
+                currentField: string;
+                siblingFields: string;
+                multipleOnlyCurrent: string;
+                empty: string;
+                incomplete: string;
+                duplicate: string;
+                invalid: string;
+            };
         };
     };
 };

package/lib/locales/Cascader.js

@@ -10,6 +10,7 @@ exports.Cascader = {
                     title: '选择时触发',
                     tooltip: '点选每级菜单选项值都会发生变化',
                 },
+                multiple: '多选',
                 displayRender: {
                     title: '渲染函数',
                     tooltip: '选择后展示的渲染函数，默认为label => label.join("/")	',
@@ -19,6 +20,18 @@ exports.Cascader = {
                     tooltip: '默认值：{ label: "label", value: "value", children: "children" }',
                 },
             },
+            'value-mapping-group': {
+                title: '数据映射',
+                fieldPath: '业务字段路径',
+                mappingPosition: '映射位置',
+                currentField: '当前字段',
+                siblingFields: '同级字段',
+                multipleOnlyCurrent: '多选模式仅支持映射到当前字段',
+                empty: '至少配置一个业务字段路径',
+                incomplete: '各级字段路径必须同时填写',
+                duplicate: '各级字段路径不能相同',
+                invalid: '请输入合法的相对字段路径',
+            },
         },
     },
     'en-US': {
@@ -29,6 +42,7 @@ exports.Cascader = {
                     title: 'Change On Select',
                     tooltip: 'Click on each level of menu option value will change',
                 },
+                multiple: 'Multiple',
                 displayRender: {
                     title: 'Display Render',
                     tooltip: 'The rendering function displayed after selection, the default is label => label.join("/")	',
@@ -38,6 +52,18 @@ exports.Cascader = {
                     tooltip: 'Defaults：{ label: "label", value: "value", children: "children" }',
                 },
             },
+            'value-mapping-group': {
+                title: 'Data Mapping',
+                fieldPath: 'Business field path',
+                mappingPosition: 'Mapping position',
+                currentField: 'Current field',
+                siblingFields: 'Sibling fields',
+                multipleOnlyCurrent: 'Multiple mode only supports mapping to the current field',
+                empty: 'Configure at least one business field path',
+                incomplete: 'All field paths are required',
+                duplicate: 'Field paths must be different',
+                invalid: 'Enter a valid relative field path',
+            },
         },
     },
     'ko-KR': {
@@ -48,6 +74,7 @@ exports.Cascader = {
                     title: '선택 시 변경',
                     tooltip: '메뉴 옵션 값의 레벨을 클릭하면 변경됩니다.',
                 },
+                multiple: '다중 선택',
                 displayRender: {
                     title: '디스플레이 렌더링',
                     tooltip: '선택 후 실행되는 렌더링 함수로 기본 값은 label => label.join("/")	',
@@ -57,6 +84,18 @@ exports.Cascader = {
                     tooltip: '기본 값：{ label: "label", value: "value", children: "children" }',
                 },
             },
+            'value-mapping-group': {
+                title: '데이터 매핑',
+                fieldPath: '업무 필드 경로',
+                mappingPosition: '매핑 위치',
+                currentField: '현재 필드',
+                siblingFields: '동급 필드',
+                multipleOnlyCurrent: '다중 선택 모드에서는 현재 필드 매핑만 지원됩니다',
+                empty: '하나 이상의 업무 필드 경로를 입력하세요',
+                incomplete: '모든 필드 경로를 입력하세요',
+                duplicate: '필드 경로는 달라야 합니다',
+                invalid: '올바른 상대 필드 경로를 입력하세요',
+            },
         },
     },
 };

package/lib/locales/DatePicker.js

@@ -82,8 +82,8 @@ exports.DateRangePicker = (0, core_1.createLocales)(exports.DatePicker, {
         settings: {
             'value-mapping-group': {
                 title: '数据映射',
-                startPath: '开始日期字段路径',
-                endPath: '结束日期字段路径',
+                startPath: '开始字段路径',
+                endPath: '结束字段路径',
                 incomplete: '开始和结束字段路径必须同时填写',
                 duplicate: '开始和结束字段路径不能相同',
                 invalid: '请输入合法的相对字段路径',
@@ -95,8 +95,8 @@ exports.DateRangePicker = (0, core_1.createLocales)(exports.DatePicker, {
         settings: {
             'value-mapping-group': {
                 title: 'Data Mapping',
-                startPath: 'Start date field path',
-                endPath: 'End date field path',
+                startPath: 'Start field path',
+                endPath: 'End field path',
                 incomplete: 'Both start and end field paths are required',
                 duplicate: 'Start and end field paths must be different',
                 invalid: 'Enter a valid relative field path',
@@ -108,8 +108,8 @@ exports.DateRangePicker = (0, core_1.createLocales)(exports.DatePicker, {
         settings: {
             'value-mapping-group': {
                 title: '데이터 매핑',
-                startPath: '시작 날짜 필드 경로',
-                endPath: '종료 날짜 필드 경로',
+                startPath: '시작 필드 경로',
+                endPath: '종료 필드 경로',
                 incomplete: '시작 및 종료 필드 경로를 모두 입력하세요',
                 duplicate: '시작 및 종료 필드 경로는 달라야 합니다',
                 invalid: '올바른 상대 필드 경로를 입력하세요',

package/lib/schemas/Cascader.js

@@ -17,6 +17,11 @@ exports.Cascader = {
             'x-decorator': 'FormItem',
             'x-component': 'Switch',
         },
+        multiple: {
+            type: 'boolean',
+            'x-decorator': 'FormItem',
+            'x-component': 'Switch',
+        },
         autoFocus: {
             type: 'boolean',
             'x-decorator': 'FormItem',

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@formily-design/formily-antd",
-  "version": "1.0.21",
+  "version": "1.0.22",
   "license": "MIT",
   "main": "lib",
   "module": "esm",
@@ -24,7 +24,7 @@
     "start": "webpack-dev-server --config playground/webpack.dev.ts"
   },
   "devDependencies": {
-    "@formily-design/react-settings-form": "1.0.21",
+    "@formily-design/react-settings-form": "1.0.22",
     "@formily/antd-v5": "^1.2.4",
     "@formily/core": "^2.0.2",
     "@formily/json-schema": "^2.0.2",
@@ -69,14 +69,14 @@
     "react-is": ">=16.8.0 || >=17.0.0"
   },
   "dependencies": {
-    "@formily-design/core": "1.0.21",
-    "@formily-design/formily-setters": "1.0.21",
-    "@formily-design/formily-transformer": "1.0.21",
-    "@formily-design/react": "1.0.21",
-    "@formily-design/shared": "1.0.21"
+    "@formily-design/core": "1.0.22",
+    "@formily-design/formily-setters": "1.0.22",
+    "@formily-design/formily-transformer": "1.0.22",
+    "@formily-design/react": "1.0.22",
+    "@formily-design/shared": "1.0.22"
   },
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "e0694bf3df21eeba42fa476affe8642d07fb3522"
+  "gitHead": "648b2e984e5823b5e712f4126ec7d675b7bc0f4e"
 }