@formily-design/formily-antd 1.0.21 → 1.0.22

package/esm/components/Cascader/preview.js

@@ -1,24 +1,103 @@
 import { Cascader as FormilyCascader } from '@formily/antd-v5';
-import { createBehavior, createResource } from '@formily-design/core';
-import { createFieldSchema } from '../Field';
+import { VALUE_MAPPING_CARDINALITY_MULTIPLE, VALUE_MAPPING_SCHEMA_KEY, VALUE_MAPPING_SCOPE_RELATIVE, VALUE_MAPPING_SCOPE_SOURCE, VALUE_MAPPING_TARGET_FIELDS, VALUE_MAPPING_TARGET_OBJECT, createBehavior, createResource, } from '@formily-design/core';
+import { createFieldSchema } from '../Field/shared';
+import { createValueMappingGroup } from '../Field/valueMapping';
 import { AllSchemas } from '../../schemas';
 import { AllLocales } from '../../locales';
+// 这些路径同时被 value-mapping 公共 reaction 和映射位置设置项读取，避免组件配置各自维护协议路径。
+const valueMappingFieldsPath = `${VALUE_MAPPING_SCHEMA_KEY}.target.fields`;
+const valueMappingTargetTypePath = `${VALUE_MAPPING_SCHEMA_KEY}.target.type`;
+const multiplePath = 'x-component-props.multiple';
+/**
+ * Cascader 复用 tuple adapter；字段数量由动态 ArrayItems 管理，target 则根据 multiple
+ * 和映射位置设置在运行时解析，从而让公共 value-mapping helper 不依赖 Cascader 属性。
+ */
+const ValueMappingGroup = createValueMappingGroup({
+    adapter: 'tuple',
+    fields: {
+        type: 'dynamic',
+        path: valueMappingFieldsPath,
+        token: 'fieldPath',
+    },
+    cardinality: { path: multiplePath },
+    target: {
+        resolve: ({ form, cardinality }) => {
+            // 多选业务值必须是对象数组，因此强制使用当前字段 object/source。
+            if (cardinality === VALUE_MAPPING_CARDINALITY_MULTIPLE) {
+                return {
+                    type: VALUE_MAPPING_TARGET_OBJECT,
+                    scope: VALUE_MAPPING_SCOPE_SOURCE,
+                };
+            }
+            // 单选允许在当前字段对象和同级字段之间切换，默认沿用当前字段。
+            return form.getValuesIn(valueMappingTargetTypePath) ===
+                VALUE_MAPPING_TARGET_FIELDS
+                ? {
+                    type: VALUE_MAPPING_TARGET_FIELDS,
+                    scope: VALUE_MAPPING_SCOPE_RELATIVE,
+                    includeSource: false,
+                }
+                : {
+                    type: VALUE_MAPPING_TARGET_OBJECT,
+                    scope: VALUE_MAPPING_SCOPE_SOURCE,
+                };
+        },
+    },
+    settingsProperties: {
+        // 映射位置是组件专属的设置 UI，最终只影响 target.type；scope/includeSource 由 resolver 固定。
+        [valueMappingTargetTypePath]: {
+            type: 'string',
+            title: '{{$node.getMessage("settings.value-mapping-group.mappingPosition")}}',
+            enum: [
+                {
+                    value: VALUE_MAPPING_TARGET_OBJECT,
+                    label: '{{$node.getMessage("settings.value-mapping-group.currentField")}}',
+                },
+                {
+                    value: VALUE_MAPPING_TARGET_FIELDS,
+                    label: '{{$node.getMessage("settings.value-mapping-group.siblingFields")}}',
+                },
+            ],
+            'x-decorator': 'FormItem',
+            'x-decorator-props': {
+                tooltip: '{{$node.getMessage("settings.value-mapping-group.multipleOnlyCurrent")}}',
+            },
+            'x-component': 'Radio.Group',
+            'x-component-props': {
+                optionType: 'button',
+                defaultValue: VALUE_MAPPING_TARGET_OBJECT,
+            },
+            'x-reactions': (field) => {
+                const fields = field.form.getValuesIn(valueMappingFieldsPath);
+                const multiple = field.form.getValuesIn(multiplePath);
+                // 没有字段行时不显示位置选项；multiple 开启后位置只能是当前字段。
+                field.visible = Array.isArray(fields) && fields.length > 0;
+                field.disabled = multiple === true;
+            },
+        },
+    },
+});
 export const Cascader = FormilyCascader;
+// 将 Cascader 注册为可选中的设计器行为，并挂载专属属性面板配置。
 Cascader.Behavior = createBehavior({
     name: 'Cascader',
     extends: ['Field'],
     selector: (node) => node.props['x-component'] === 'Cascader',
     designerProps: {
-        propsSchema: createFieldSchema(AllSchemas.Cascader),
+        propsSchema: createFieldSchema(AllSchemas.Cascader, undefined, {
+            'value-mapping-group': ValueMappingGroup,
+        }),
     },
     designerLocales: AllLocales.Cascader,
 });
+// 将 Cascader 注册到资源面板，拖入画布时生成默认 Field Schema。
 Cascader.Resource = createResource({
     icon: 'CascaderSource',
     elements: [
         {
             componentName: 'Field',
             props: {
+                type: 'array',
                 title: 'Cascader',
                 'x-decorator': 'FormItem',
                 'x-component': 'Cascader',

package/esm/components/DatePicker/preview.js

@@ -1,46 +1,26 @@
 import { DatePicker as FormilyDatePicker } from '@formily/antd-v5';
 import { createBehavior, createResource } from '@formily-design/core';
-import { VALUE_MAPPING_SCHEMA_KEY } from '@formily-design/core';
 import { createFieldSchema } from '../Field/shared';
-import { createValueMappingSettingsReaction } from '../Field/valueMapping';
+import { createValueMappingGroup } from '../Field/valueMapping';
 import { AllSchemas } from '../../schemas';
 import { AllLocales } from '../../locales';
-const valueMappingTargetPaths = [
-    `${VALUE_MAPPING_SCHEMA_KEY}.targets.0.path`,
-    `${VALUE_MAPPING_SCHEMA_KEY}.targets.1.path`,
-];
-const createMappingPathSchema = (titleToken) => ({
-    type: 'string',
-    title: `{{$node.getMessage("settings.value-mapping-group.${titleToken}")}}`,
-    'x-decorator': 'FormItem',
-    'x-decorator-props': {
-        // SettingsForm 默认不展示 feedback；映射路径需要即时呈现输入校验结果。
-        feedbackLayout: 'loose',
+const ValueMappingGroup = createValueMappingGroup({
+    adapter: 'tuple',
+    fields: {
+        type: 'fixed',
+        paths: [
+            'x-value-mapping.target.fields.0.path',
+            'x-value-mapping.target.fields.1.path',
+        ],
+        tokens: ['startPath', 'endPath'],
     },
-    'x-component': 'Input',
-    'x-component-props': {
-        allowClear: true,
+    cardinality: 'single',
+    target: {
+        type: 'fields',
+        scope: 'relative',
+        includeSource: false,
     },
 });
-const ValueMappingGroup = {
-    type: 'void',
-    'x-component': 'CollapseItem',
-    'x-component-props': { defaultExpand: false },
-    // 分组只挂一个 reaction，避免协议同步与反馈校验的两个 autorun 产生竞态。
-    'x-reactions': [
-        createValueMappingSettingsReaction({
-            adapter: 'tuple',
-            targetPaths: valueMappingTargetPaths,
-            scope: 'relative',
-            submitSource: false,
-            getMessage: (error, scope) => { var _a; return (_a = scope.$node) === null || _a === void 0 ? void 0 : _a.getMessage(`settings.value-mapping-group.${error}`); },
-        }),
-    ],
-    properties: {
-        [valueMappingTargetPaths[0]]: createMappingPathSchema('startPath'),
-        [valueMappingTargetPaths[1]]: createMappingPathSchema('endPath'),
-    },
-};
 export const DatePicker = FormilyDatePicker;
 DatePicker.Behavior = createBehavior({
     name: 'DatePicker',

package/esm/components/Field/valueMapping.d.ts

@@ -1,45 +1,78 @@
-import type { IScopeContext, SchemaReaction } from '@formily/json-schema';
-import { VALUE_MAPPING_RELATIVE_SCOPE } from '@formily-design/core';
-import type { ValueMappingTargetValidationError } from '@formily-design/core';
+import type { ISchema, IScopeContext, SchemaReaction } from '@formily/json-schema';
+import type { Form } from '@formily/core';
+import { VALUE_MAPPING_TARGET_FIELDS, VALUE_MAPPING_TARGET_OBJECT, VALUE_MAPPING_SCOPE_RELATIVE, VALUE_MAPPING_SCOPE_SOURCE } from '@formily-design/core';
+import type { ValueMappingCardinality, ValueMappingTargetValidationError } from '@formily-design/core';
 export type { ValueMappingTargetValidationError } from '@formily-design/core';
+/** 固定字段由组件属性直接提供；动态字段由设置器中的 ArrayItems 提供。 */
+export type ValueMappingSettingsFieldSource = {
+    type: 'fixed';
+    paths: string[];
+    tokens: string[];
+} | {
+    type: 'dynamic';
+    path: string;
+    token: string;
+};
+export type ValueMappingSettingsCardinality = 
+/** 固定 cardinality 适合 RangePicker 等属性已知的组件。 */
+ValueMappingCardinality
+/** 动态 cardinality 从组件属性路径读取，供 Cascader.multiple 等属性联动。 */
+ | {
+    path: string;
+};
+/** 设置器侧只描述 target 的选择项，具体 fields 由 reaction 在运行时补全。 */
+export type ValueMappingSettingsTarget = {
+    type: typeof VALUE_MAPPING_TARGET_FIELDS;
+    scope: typeof VALUE_MAPPING_SCOPE_RELATIVE;
+    includeSource: boolean;
+} | {
+    type: typeof VALUE_MAPPING_TARGET_OBJECT;
+    scope: typeof VALUE_MAPPING_SCOPE_SOURCE;
+};
+/** 根据当前设置表单状态解析 target，使公共 helper 不需要识别具体组件。 */
+export type ValueMappingSettingsTargetResolver = {
+    resolve(context: {
+        form: Form;
+        cardinality: ValueMappingCardinality;
+    }): ValueMappingSettingsTarget;
+};
+export type ValueMappingSettingsTargetSource = ValueMappingSettingsTarget | ValueMappingSettingsTargetResolver;
 export interface ICreateValueMappingSettingsReactionOptions {
-    /**
-     * 映射运行时使用的 adapter 名称，例如 tuple。
-     */
+    /** adapter 名称写入协议，转换实现由 designer runtime 注册。 */
     adapter: string;
-    /**
-     * 设置表单中 target path 输入框的完整数据路径。
-     *
-     * 注意：这里配置的是输入框在设置表单中的路径，而不是用户最终填写的
-     * startDate、address.provinceCode 等业务字段路径。
-     */
-    targetPaths: string[];
-    scope?: typeof VALUE_MAPPING_RELATIVE_SCOPE;
-    submitSource?: boolean;
-    /**
-     * 根据校验错误码返回当前语言的提示文案。scope 会透传 Formily
-     * reaction 的作用域，因此设置器可以使用 `$node.getMessage` 读取节点语言。
-     */
+    /** 映射字段的来源及设置器字段路径。 */
+    fields: ValueMappingSettingsFieldSource;
+    /** 固定值或组件属性驱动的 cardinality。 */
+    cardinality: ValueMappingSettingsCardinality;
+    /** 静态 target 或依赖 form/cardinality 的 target resolver。 */
+    target: ValueMappingSettingsTargetSource;
+    /** 将协议校验错误转换为当前语言的设置器文案。 */
     getMessage: (error: ValueMappingTargetValidationError, scope: IScopeContext) => string | undefined;
 }
+export interface IValueMappingGroupOptions extends Omit<ICreateValueMappingSettingsReactionOptions, 'getMessage'> {
+    /** value-mapping 分组使用的 locale 命名空间。 */
+    localeKey?: string;
+    /** 由具体组件追加的配置项，例如 Cascader 的映射位置单选框。 */
+    settingsProperties?: Record<string, ISchema>;
+}
+export declare const validateValueMappingTargetPaths: (paths: unknown[], allowEmpty?: boolean) => ValueMappingTargetValidationError | undefined;
 /**
- * 校验一组手动输入的映射 target 路径。
- *
- * 空数组表示尚未启用映射；一旦任意路径有值，所有 target 都必须填写、合法且唯一。
- * 该方法与具体组件数量无关，日期范围、省市区等配置界面均可复用。
+ * 创建统一处理协议同步、动态字段和校验反馈的设置 reaction。
+ * reaction 先读取设置状态，再决定删除协议、反馈错误或写入 canonical v1 协议。
  */
-export declare const validateValueMappingTargetPaths: (paths: unknown[]) => ValueMappingTargetValidationError | undefined;
+export declare const createValueMappingSettingsReaction: ({ adapter, fields, cardinality, target, getMessage, }: ICreateValueMappingSettingsReactionOptions) => SchemaReaction;
 /**
- * 创建设置表单使用的 value-mapping 协议与校验 reaction。
- *
- * 协议和反馈必须由一个 autorun 编排。若分别挂两个 x-reactions，它们对同一
- * 次 onInput 的调度顺序不稳定：协议 reaction 规范化数字路径时会再次写值，
- * 校验 reaction 可能拿到中间快照，导致残留错误或覆盖刚写入的配置。本 reaction
- * 先读取一次 targetValues，再同步反馈和协议，保证二者始终对应同一组输入。
- *
- * target 全空时先同步清除反馈，让界面立即恢复；父级协议延迟到当前 onInput/batch
- * 结束后的 Promise 微任务再删除。微任务执行前会重新读取最新 target：若用户已快速
- * 重新输入则跳过删除，避免旧 cleanup 误删。按 Form 隔离的 WeakSet 会合并同一 Form
- * 的重复 cleanup，同时不会影响其它设置 Form。
+ * 创建组件属性面板中的新 v1 value-mapping 分组。
+ * 具体组件可通过 settingsProperties 注入额外设置，但协议同步仍由公共 reaction 负责。
  */
-export declare const createValueMappingSettingsReaction: ({ adapter, targetPaths, scope, submitSource, getMessage, }: ICreateValueMappingSettingsReactionOptions) => SchemaReaction;
+export declare const createValueMappingGroup: ({ localeKey, settingsProperties, ...options }: IValueMappingGroupOptions) => {
+    type: string;
+    'x-component': string;
+    'x-component-props': {
+        defaultExpand: boolean;
+    };
+    'x-reactions': SchemaReaction[];
+    properties: {
+        [x: string]: any;
+    };
+};

package/esm/components/Field/valueMapping.js

@@ -1,105 +1,145 @@
+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;
+};
 import { untracked } from '@formily/reactive';
-import { VALUE_MAPPING_RELATIVE_SCOPE, VALUE_MAPPING_SCHEMA_KEY, VALUE_MAPPING_VERSION, validateValueMappingTargetPaths as validateSharedTargetPaths, } from '@formily-design/core';
-// 一个 Form 只允许排队一个 cleanup；WeakSet 不持有 Form 强引用，也不会串扰其它 Form。
+import { VALUE_MAPPING_CARDINALITY_MULTIPLE, VALUE_MAPPING_CARDINALITY_SINGLE, VALUE_MAPPING_SCHEMA_KEY, VALUE_MAPPING_TARGET_FIELDS, VALUE_MAPPING_TARGET_OBJECT, VALUE_MAPPING_VERSION, validateValueMappingFieldPaths, } from '@formily-design/core';
+/** 防止清空字段时 reaction 的同步更新与异步清理互相重复。 */
 const pendingMappingCleanups = new WeakSet();
+/** 只有输入过非空文本才显示“不完整”字段的校验反馈。 */
 const hasInputText = (value) => typeof value === 'string' && Boolean(value.trim());
-/**
- * 校验一组手动输入的映射 target 路径。
- *
- * 空数组表示尚未启用映射；一旦任意路径有值，所有 target 都必须填写、合法且唯一。
- * 该方法与具体组件数量无关，日期范围、省市区等配置界面均可复用。
- */
-export const validateValueMappingTargetPaths = (paths) => validateSharedTargetPaths(paths, { allowEmpty: true });
-/** 将同一份 target 快照规范化为运行时协议。 */
-const syncValueMappingProtocol = (form, targetValues, adapter, scope, submitSource) => {
-    const normalizedTargets = targetValues.map((path) => ({
+export const validateValueMappingTargetPaths = (paths, allowEmpty = true) => 
+// 设置器允许固定字段全部为空来表达删除配置；动态字段则由调用方传入对应规则。
+validateValueMappingFieldPaths(paths, { allowEmpty });
+/** 将静态值或组件属性中的 truthy 值统一映射为协议 cardinality。 */
+const getCardinality = (form, cardinality) => {
+    if (typeof cardinality === 'string')
+        return cardinality;
+    return form.getValuesIn(cardinality.path)
+        ? VALUE_MAPPING_CARDINALITY_MULTIPLE
+        : 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(`${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(`${VALUE_MAPPING_SCHEMA_KEY}.targets`, normalizedTargets);
-    }
-    const setProtocolValue = (path, value) => {
-        if (form.getValuesIn(path) !== value) {
-            form.setValuesIn(path, value);
+    const targetValue = target.type === VALUE_MAPPING_TARGET_FIELDS
+        ? {
+            type: VALUE_MAPPING_TARGET_FIELDS,
+            scope: target.scope,
+            fields: normalizedFields,
+            includeSource: target.includeSource === true,
         }
+        : {
+            type: VALUE_MAPPING_TARGET_OBJECT,
+            scope: target.scope,
+            fields: normalizedFields,
+        };
+    const next = {
+        version: VALUE_MAPPING_VERSION,
+        adapter,
+        cardinality,
+        target: targetValue,
     };
-    setProtocolValue(`${VALUE_MAPPING_SCHEMA_KEY}.version`, VALUE_MAPPING_VERSION);
-    setProtocolValue(`${VALUE_MAPPING_SCHEMA_KEY}.adapter`, adapter);
-    setProtocolValue(`${VALUE_MAPPING_SCHEMA_KEY}.scope`, scope);
-    setProtocolValue(`${VALUE_MAPPING_SCHEMA_KEY}.submitSource`, submitSource);
+    const current = form.getValuesIn(VALUE_MAPPING_SCHEMA_KEY);
+    // 避免 reaction 在每次运行时重复写入，减少设置表单的二次 reaction。
+    if (JSON.stringify(current) !== JSON.stringify(next)) {
+        form.setValuesIn(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 协议。
  */
-export const createValueMappingSettingsReaction = ({ adapter, targetPaths, scope = VALUE_MAPPING_RELATIVE_SCOPE, submitSource = false, getMessage, }) => {
+export 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 = validateValueMappingTargetPaths(targetValues);
+        const settings = getFieldSettings(form, fields);
+        const error = validateValueMappingFieldPaths(settings.values, {
+            allowEmpty: fields.type === 'fixed',
+        });
         const message = error ? getMessage(error, reactionScope) : undefined;
-        const hasTarget = targetValues.some(hasInputText);
-        if (!hasTarget) {
-            // 反馈清理同步执行；只有协议确实存在时才排队父对象删除。
-            untracked(() => {
-                syncValueMappingErrors(form, targetPaths, targetValues, error, message);
-            });
+        const empty = shouldDeleteMapping(settings.values, fields);
+        untracked(() => {
+            syncValueMappingErrors(form, settings.paths, settings.values, error, message, settings.dynamic);
+        });
+        if (empty) {
+            // 清空操作可能触发多次 reaction，放到微任务中读取最新状态后再删除协议。
             if (form.getValuesIn(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(VALUE_MAPPING_SCHEMA_KEY) !== undefined) {
                         form.deleteValuesIn(VALUE_MAPPING_SCHEMA_KEY);
                     }
@@ -107,11 +147,81 @@ export const createValueMappingSettingsReaction = ({ adapter, targetPaths, scope
             }
             return;
         }
-        // feedback 是输出，不能反过来成为依赖；协议写入则保留通知，使 autorun
-        // 在数字路径从对象规范化为数组后重新建立对新数组叶节点的依赖。
-        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);
+    };
+};
+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 负责。
+ */
+export 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': [
+            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,
     };
 };