@formily-design/formily-antd 1.0.20 → 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,8 +1,26 @@
 import { DatePicker as FormilyDatePicker } from '@formily/antd-v5';
 import { createBehavior, createResource } from '@formily-design/core';
-import { createFieldSchema } from '../Field';
+import { createFieldSchema } from '../Field/shared';
+import { createValueMappingGroup } from '../Field/valueMapping';
 import { AllSchemas } from '../../schemas';
 import { AllLocales } from '../../locales';
+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'],
+    },
+    cardinality: 'single',
+    target: {
+        type: 'fields',
+        scope: 'relative',
+        includeSource: false,
+    },
+});
 export const DatePicker = FormilyDatePicker;
 DatePicker.Behavior = createBehavior({
     name: 'DatePicker',
@@ -17,7 +35,9 @@ DatePicker.Behavior = createBehavior({
     extends: ['Field'],
     selector: (node) => node.props['x-component'] === 'DatePicker.RangePicker',
     designerProps: {
-        propsSchema: createFieldSchema(AllSchemas.DatePicker.RangePicker),
+        propsSchema: createFieldSchema(AllSchemas.DatePicker.RangePicker, undefined, {
+            'value-mapping-group': ValueMappingGroup,
+        }),
     },
     designerLocales: AllLocales.DateRangePicker,
 });

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

@@ -1,2 +1,3 @@
 export * from './preview';
 export * from './shared';
+export * from './valueMapping';

package/esm/components/Field/index.js

@@ -1,2 +1,3 @@
 export * from './preview';
 export * from './shared';
+export * from './valueMapping';

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

@@ -1,4 +1,4 @@
 import { ISchema } from '@formily/json-schema';
 export declare const createComponentSchema: (component: ISchema, decorator: ISchema) => Record<string, ISchema | undefined>;
-export declare const createFieldSchema: (component?: ISchema, decorator?: ISchema) => ISchema;
+export declare const createFieldSchema: (component?: ISchema, decorator?: ISchema, additionalGroups?: Record<string, ISchema>) => ISchema;
 export declare const createVoidFieldSchema: (component?: ISchema, decorator?: ISchema) => ISchema;

package/esm/components/Field/shared.js

@@ -64,10 +64,10 @@ export const createComponentSchema = (component, decorator) => {
         },
     };
 };
-export const createFieldSchema = (component, decorator = AllSchemas.FormItem) => {
+export const createFieldSchema = (component, decorator = AllSchemas.FormItem, additionalGroups = {}) => {
     return {
         type: 'object',
-        properties: Object.assign({ 'field-group': {
+        properties: Object.assign(Object.assign({ 'field-group': {
                 type: 'void',
                 'x-component': 'CollapseItem',
                 properties: {
@@ -170,7 +170,7 @@ export const createFieldSchema = (component, decorator = AllSchemas.FormItem) =>
                         'x-component': 'Switch',
                     },
                 },
-            } }, createComponentSchema(component, decorator)),
+            } }, additionalGroups), createComponentSchema(component, decorator)),
     };
 };
 export const createVoidFieldSchema = (component, decorator = AllSchemas.FormItem) => {

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

@@ -0,0 +1,78 @@
+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 名称写入协议，转换实现由 designer runtime 注册。 */
+    adapter: string;
+    /** 映射字段的来源及设置器字段路径。 */
+    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;
+/**
+ * 创建统一处理协议同步、动态字段和校验反馈的设置 reaction。
+ * reaction 先读取设置状态，再决定删除协议、反馈错误或写入 canonical v1 协议。
+ */
+export declare const createValueMappingSettingsReaction: ({ adapter, fields, cardinality, target, getMessage, }: ICreateValueMappingSettingsReactionOptions) => SchemaReaction;
+/**
+ * 创建组件属性面板中的新 v1 value-mapping 分组。
+ * 具体组件可通过 settingsProperties 注入额外设置，但协议同步仍由公共 reaction 负责。
+ */
+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

@@ -0,0 +1,227 @@
+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_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());
+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 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,
+    };
+    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);
+        }
+    }
+};
+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(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));
+};
+/**
+ * 创建统一处理协议同步、动态字段和校验反馈的设置 reaction。
+ * reaction 先读取设置状态，再决定删除协议、反馈错误或写入 canonical v1 协议。
+ */
+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;
+        const settings = getFieldSettings(form, fields);
+        const error = validateValueMappingFieldPaths(settings.values, {
+            allowEmpty: fields.type === 'fixed',
+        });
+        const message = error ? getMessage(error, reactionScope) : undefined;
+        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 latest = getFieldSettings(form, fields);
+                    if (shouldDeleteMapping(latest.values, fields) &&
+                        form.getValuesIn(VALUE_MAPPING_SCHEMA_KEY) !== undefined) {
+                        form.deleteValuesIn(VALUE_MAPPING_SCHEMA_KEY);
+                    }
+                });
+            }
+            return;
+        }
+        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,
+    };
+};

package/esm/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/esm/locales/Cascader.js

@@ -7,6 +7,7 @@ export const Cascader = {
                     title: '选择时触发',
                     tooltip: '点选每级菜单选项值都会发生变化',
                 },
+                multiple: '多选',
                 displayRender: {
                     title: '渲染函数',
                     tooltip: '选择后展示的渲染函数，默认为label => label.join("/")	',
@@ -16,6 +17,18 @@ export const Cascader = {
                     tooltip: '默认值：{ label: "label", value: "value", children: "children" }',
                 },
             },
+            'value-mapping-group': {
+                title: '数据映射',
+                fieldPath: '业务字段路径',
+                mappingPosition: '映射位置',
+                currentField: '当前字段',
+                siblingFields: '同级字段',
+                multipleOnlyCurrent: '多选模式仅支持映射到当前字段',
+                empty: '至少配置一个业务字段路径',
+                incomplete: '各级字段路径必须同时填写',
+                duplicate: '各级字段路径不能相同',
+                invalid: '请输入合法的相对字段路径',
+            },
         },
     },
     'en-US': {
@@ -26,6 +39,7 @@ export const 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("/")	',
@@ -35,6 +49,18 @@ export const 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': {
@@ -45,6 +71,7 @@ export const Cascader = {
                     title: '선택 시 변경',
                     tooltip: '메뉴 옵션 값의 레벨을 클릭하면 변경됩니다.',
                 },
+                multiple: '다중 선택',
                 displayRender: {
                     title: '디스플레이 렌더링',
                     tooltip: '선택 후 실행되는 렌더링 함수로 기본 값은 label => label.join("/")	',
@@ -54,6 +81,18 @@ export const Cascader = {
                     tooltip: '기본 값：{ label: "label", value: "value", children: "children" }',
                 },
             },
+            'value-mapping-group': {
+                title: '데이터 매핑',
+                fieldPath: '업무 필드 경로',
+                mappingPosition: '매핑 위치',
+                currentField: '현재 필드',
+                siblingFields: '동급 필드',
+                multipleOnlyCurrent: '다중 선택 모드에서는 현재 필드 매핑만 지원됩니다',
+                empty: '하나 이상의 업무 필드 경로를 입력하세요',
+                incomplete: '모든 필드 경로를 입력하세요',
+                duplicate: '필드 경로는 달라야 합니다',
+                invalid: '올바른 상대 필드 경로를 입력하세요',
+            },
         },
     },
 };