@zat-design/sisyphus-react 4.4.2 → 4.4.3

package/es/ProEditTable/components/RenderField/propsType.d.ts

@@ -0,0 +1,30 @@
+import { FormInstance } from 'antd';
+import { InternalNamePath, NamePath } from 'antd/lib/form/interface';
+import { DiffOriginalParams } from '../../utils/diffOriginal';
+export interface GetOriginalValueParams {
+    namePath: InternalNamePath;
+    originalName: InternalNamePath;
+    originalNames?: InternalNamePath[];
+    originalValues?: any;
+    rowKeyPath?: InternalNamePath;
+    form: FormInstance;
+}
+export interface Props {
+    name?: NamePath;
+    names?: NamePath[];
+    originalName?: NamePath;
+    originalNames?: NamePath[];
+    namesStr?: NamePath;
+    originalValues?: any;
+    form: FormInstance;
+    onDiff?: DiffOriginalParams['onDiff'];
+    [name: string]: any;
+}
+/** RenderField 的 props 多为表格运行期动态结构（column/config/record），保留显式 any */
+export interface RenderFieldComparableProps {
+    text?: any;
+    record?: any;
+    index: number;
+    column?: any;
+    config?: any;
+}

package/es/ProEditTable/components/RenderField/propsType.js

@@ -0,0 +1 @@
+export {};

package/es/ProEditTable/components/RenderField/tools.d.ts

@@ -0,0 +1,22 @@
+import { InternalNamePath, NamePath } from 'antd/lib/form/interface';
+import { GetOriginalValueParams, RenderFieldComparableProps } from './propsType';
+/** 列配置中不应透传到 Form.Item 或 DOM 的字段（与 ProForm Render 保持一致） */
+export declare const OMIT_FORM_ITEM_AND_DOM_KEYS: string[];
+/** 克隆子元素时需从 props 中剔除，避免透传到 div 等 DOM 导致 React 警告 */
+export declare const OMIT_FROM_DOM_KEYS: string[];
+export declare const toNamePath: (name: NamePath) => InternalNamePath;
+export declare const toNamePaths: (names: NamePath[]) => InternalNamePath[];
+export declare const getOriginalValue: ({ namePath, originalName, originalNames, originalValues, rowKeyPath, form, }: GetOriginalValueParams) => {
+    originalValue: any;
+    originRecord: any;
+    record: any;
+} | {
+    originalValue: any;
+    originRecord: any;
+    record?: undefined;
+};
+/**
+ * memo 自定义比较函数：只有关键 props 变化时才重新渲染。
+ * 从 RenderField 拆出，行为与原内联实现保持一致。
+ */
+export declare const arePropsEqual: (prevProps: RenderFieldComparableProps, nextProps: RenderFieldComparableProps) => boolean;

package/es/ProEditTable/components/RenderField/tools.js

@@ -0,0 +1,203 @@
+import _isFunction from "lodash/isFunction";
+import _isEqualWith from "lodash/isEqualWith";
+import _isEqual from "lodash/isEqual";
+import _get from "lodash/get";
+import { customEqualForFunction } from "../../../utils";
+import { getNamePath } from "../../utils/tools";
+/** 列配置中不应透传到 Form.Item 或 DOM 的字段（与 ProForm Render 保持一致） */
+export const OMIT_FORM_ITEM_AND_DOM_KEYS = ['format', 'toISOString', 'toCSTString', 'switchValue', 'precision', 'clearNotShow', 'dependNames', 'shouldCellUpdate' // 表格内部性能优化属性，不应传递给 Form.Item
+];
+
+/** 克隆子元素时需从 props 中剔除，避免透传到 div 等 DOM 导致 React 警告 */
+export const OMIT_FROM_DOM_KEYS = ['disabled',
+// div 不支持 disabled，且值可能非 string/number
+'toCSTString', 'toISOString', 'format', 'switchValue', 'precision', 'clearNotShow', 'dependNames'];
+export const toNamePath = name => {
+  if (Array.isArray(name)) {
+    return name;
+  }
+  return [name];
+};
+export const toNamePaths = names => {
+  return names.map(name => toNamePath(name));
+};
+export const getOriginalValue = ({
+  namePath,
+  originalName,
+  originalNames,
+  originalValues,
+  rowKeyPath,
+  form
+}) => {
+  if (!originalValues) {
+    return undefined;
+  }
+  let originRecord;
+  if (rowKeyPath) {
+    const rowValueNamePath = namePath.slice(0, rowKeyPath.length - 1); // 表单中变动值所在行
+    const rowKeyName = rowKeyPath[rowKeyPath.length - 1]; // rowKey在行内的name
+
+    const rowValue = form.getFieldValue(rowValueNamePath);
+    if (!rowValue) return undefined;
+    const keyValue = rowValue[rowKeyName]; // 获取表单中rowKey值
+    if (!keyValue) return undefined;
+    const originalValueList = _get(originalValues, originalName.slice(0, rowKeyPath.length - 2));
+    originRecord = originalValueList?.find(item => {
+      return item[rowKeyPath[rowKeyPath.length - 1]] === keyValue;
+    });
+    let originalValue;
+    if (originalNames?.length) {
+      const originalNamesValue = originalNames.map(originalName => {
+        return _get(originRecord, originalName.slice(rowKeyPath.length - 1));
+      });
+
+      // 有可能出现数组中全是undefined的情况  视为没有值
+      const fillUndefined = originalNamesValue.every(valItem => valItem === undefined);
+      originalValue = fillUndefined ? undefined : originalNamesValue;
+    } else {
+      originalValue = _get(originRecord, originalName.slice(rowKeyPath.length - 1));
+    }
+    return {
+      originalValue,
+      originRecord,
+      record: rowValue
+    };
+  }
+
+  // 这个方法是给editTable专用的  暂时不存在不传rowKey的情况
+  return {
+    originalValue: originalNames?.length ? originalNames.map(originalName => _get(originalValues, originalName)) : _get(originalValues, originalName),
+    originRecord
+  };
+};
+
+/**
+ * memo 自定义比较函数：只有关键 props 变化时才重新渲染。
+ * 从 RenderField 拆出，行为与原内联实现保持一致。
+ */
+export const arePropsEqual = (prevProps, nextProps) => {
+  const {
+    text: prevText,
+    record: prevRecord,
+    index: prevIndex,
+    column: prevColumn,
+    config: prevConfig
+  } = prevProps;
+  const {
+    text: nextText,
+    record: nextRecord,
+    index: nextIndex,
+    column: nextColumn,
+    config: nextConfig
+  } = nextProps;
+
+  // 函数型动态属性（component/editRender/fieldProps/rules/required/disabled/isEditable/valueType）
+  // 可能依赖行内兄弟字段；行对象为同引用（原地修改）时，浅比较无法区分，需强制重渲染
+  const hasFunctionDependency = _isFunction(prevColumn?.component) || _isFunction(prevColumn?.editRender) || _isFunction(prevColumn?.fieldProps) || _isFunction(prevColumn?.rules) || _isFunction(prevColumn?.required) || _isFunction(prevColumn?.disabled) || _isFunction(prevColumn?.isEditable) || _isFunction(prevColumn?.valueType) || _isFunction(nextColumn?.component) || _isFunction(nextColumn?.editRender) || _isFunction(nextColumn?.fieldProps) || _isFunction(nextColumn?.rules) || _isFunction(nextColumn?.required) || _isFunction(nextColumn?.disabled) || _isFunction(nextColumn?.isEditable) || _isFunction(nextColumn?.valueType);
+  if (hasFunctionDependency && prevRecord === nextRecord) {
+    return false;
+  }
+
+  // 构建新的参数格式（与 ProForm 保持一致）
+  const prevNamePath = getNamePath(prevConfig?.name, prevConfig?.virtualKey);
+  const nextNamePath = getNamePath(nextConfig?.name, nextConfig?.virtualKey);
+  const prevReactiveParams = {
+    form: prevConfig?.form,
+    index: prevIndex,
+    namePath: [...prevNamePath, prevIndex]
+  };
+  const nextReactiveParams = {
+    form: nextConfig?.form,
+    index: nextIndex,
+    namePath: [...nextNamePath, nextIndex]
+  };
+  if (_isFunction(prevColumn?.disabled) && _isFunction(nextColumn?.disabled)) {
+    if (prevColumn?.disabled(prevRecord, prevReactiveParams) !== nextColumn?.disabled(nextRecord, nextReactiveParams)) {
+      return false;
+    }
+  }
+
+  // fieldProps 函数化直接更新，无法比对返回值是否一致
+  // 优化：不直接调用函数，而是比较输入参数（record 和 reactiveParams）
+  // 如果输入参数相同，fieldProps 的返回值应该相同（纯函数假设）
+  if (_isFunction(prevColumn?.fieldProps) && _isFunction(nextColumn?.fieldProps)) {
+    // 比较 record 数据是否变化
+    if (!_isEqualWith(prevRecord, nextRecord, customEqualForFunction)) {
+      return false;
+    }
+    // reactiveParams 中的 form、index、namePath 已经在外层比较过了，无需重复比较
+  }
+  // fieldProps 为对象时，必须比较配置变化（如 dataSource 异步更新）
+  if (!_isFunction(prevColumn?.fieldProps) && !_isFunction(nextColumn?.fieldProps)) {
+    const isFieldPropsEqual = _isEqualWith(prevColumn?.fieldProps, nextColumn?.fieldProps, customEqualForFunction);
+    if (!isFieldPropsEqual) {
+      return false;
+    }
+  }
+
+  // 通用函数比较方法
+  // 优化：不直接调用函数，而是比较函数引用和输入参数
+  const compareFunctionResult = (prevCol, nextCol, prevValues, nextValues, _prevReactiveParams, _nextReactiveParams, functionName) => {
+    const prevFunc = prevCol?.[functionName];
+    const nextFunc = nextCol?.[functionName];
+    if (_isFunction(prevFunc) && _isFunction(nextFunc)) {
+      // 函数引用变化说明闭包可能捕获了新的外部状态（如异步加载的 list），必须重渲染
+      if (prevFunc !== nextFunc) return false;
+      // 同引用函数，比较输入参数（纯函数假设：输入相同则输出相同）
+      return _isEqualWith(prevValues, nextValues, customEqualForFunction);
+    }
+    return true; // 如果不是函数或只有一个是函数，认为相等
+  };
+
+  // 使用简化后的比较逻辑
+  const functionFields = ['rules', 'component', 'desensitization', 'isEditable', 'required'];
+  if (functionFields.some(field => !compareFunctionResult(prevColumn, nextColumn, prevRecord, nextRecord, prevReactiveParams, nextReactiveParams, field))) {
+    return false;
+  }
+
+  // 基本props比较
+  if (!_isEqual(prevText, nextText) || prevIndex !== nextIndex) {
+    return false;
+  }
+
+  // 记录关键字段比较（避免完整对象比较的性能开销）
+  if (prevRecord?.rowKey !== nextRecord?.rowKey || prevRecord?._addFlag !== nextRecord?._addFlag) {
+    return false;
+  }
+
+  // 列配置比较（只比较关键字段）,required,disabled为函数时，需要重新计算
+  if (prevColumn?.dataIndex !== nextColumn?.dataIndex || prevColumn?.type !== nextColumn?.type || prevColumn?.name !== nextColumn?.name) {
+    return false;
+  }
+
+  // config中关键字段比较
+  if (prevConfig?._isEditing !== nextConfig?._isEditing || prevConfig?.mode !== nextConfig?.mode) {
+    return false;
+  }
+
+  // 当前单元格的值比较
+  const prevDataIndex = prevColumn?.dataIndex;
+  const nextDataIndex = nextColumn?.dataIndex;
+  if (prevDataIndex && nextDataIndex && prevDataIndex === nextDataIndex) {
+    if (prevRecord?.[prevDataIndex] !== nextRecord?.[nextDataIndex]) {
+      return false;
+    }
+  }
+
+  // 特殊处理：当使用自定义 component 函数时，比较整个 record 对象
+  // 因为自定义组件可能依赖 record 中的其他字段（不只是当前列的 dataIndex）
+  if (_isFunction(prevColumn?.component) || _isFunction(nextColumn?.component)) {
+    // 浅比较 record 的所有属性
+    const prevKeys = Object.keys(prevRecord || {});
+    const nextKeys = Object.keys(nextRecord || {});
+    if (prevKeys.length !== nextKeys.length) {
+      return false;
+    }
+
+    // 使用 some 方法代替 for 循环
+    if (prevKeys.some(key => prevRecord?.[key] !== nextRecord?.[key])) {
+      return false;
+    }
+  }
+  return true;
+};

package/es/ProEditTable/utils/config.js

@@ -89,7 +89,9 @@ export const actions = {
       delete record._isEditing;
     }
     // 防止value引用不变, 值不更新 - (自定义组件)
-    const values = form.getFieldsValue();
+    // 必须取全量 store（true）：names 组合列只注册合并字段，拆分子字段（如 address/postcode）
+    // 未注册；getFieldsValue() 会丢掉它们，叠加 setFieldsValue 对数组「整体覆盖」会抹掉其他行的子字段
+    const values = form.getFieldsValue(true);
     _set(values, rowName, record);
     // 同步清理虚拟路径上的 _addFlag，避免再次编辑→取消时把已保存行误删
     _set(values, virtualRowName, record);
@@ -128,8 +130,9 @@ export const actions = {
       });
     } else {
       // 取消时使用主 form 原始行数据重置虚拟 form，避免编辑值残留
+      // 同 save：取全量 store（true），避免抹掉其他行未注册的 names 拆分子字段
       const originalRecord = form.getFieldValue(rowName);
-      const values = form.getFieldsValue();
+      const values = form.getFieldsValue(true);
       _set(values, virtualRowName, originalRecord ?? record);
       form.setFieldsValue(values);
     }

package/es/ProEditTable/utils/index.js

@@ -344,6 +344,9 @@ export const transformColumns = (columns = [], config, caches) => {
     // 精准控制单元格更新，减少不必要的渲染
     if (!item.shouldCellUpdate) {
       const hasComponent = _isFunction(item.component);
+      // 函数型动态属性会依赖整行数据（可能是当前列之外的兄弟字段），
+      // 这类列在行内任意字段变化时都需重渲染，不能只比对本列 dataIndex
+      const hasFunctionDependency = hasComponent || _isFunction(item.editRender) || _isFunction(item.fieldProps) || _isFunction(item.rules) || _isFunction(item.required) || _isFunction(item.disabled) || _isFunction(item.isEditable) || _isFunction(item.valueType);
       const columnCacheKey = `${Array.isArray(name) ? name.join('.') : String(name)}::${String(columnName)}`;
 
       // Fix 问题1：用原始列引用（克隆前）比对 dataSource
@@ -387,22 +390,24 @@ export const transformColumns = (columns = [], config, caches) => {
         if (virtualKey && record?._isEditing !== prevRecord?._isEditing) {
           return true;
         }
-        // 动态 component 可能依赖行内其他字段，需比较整行
+        // 动态 component 函数引用变化说明外部依赖（如异步 list）已更新，必须重渲染
+        // 即使行数据未变，旧闭包仍持有过时的外部状态
         if (hasComponent) {
-          // component 函数引用变化说明外部依赖（如异步 list）已更新，必须重渲染
-          // 即使行数据未变，旧闭包仍持有过时的外部状态
           const prevComponentRef = cellCaches.componentRef.get(columnCacheKey);
           const currentComponentRef = item.component;
           if (prevComponentRef !== currentComponentRef) {
             cellCaches.componentRef.set(columnCacheKey, currentComponentRef);
             return true;
           }
-          // 同引用时 isEqual 恒为 true，无法感知原地修改，必须重渲染
+        }
+        // 函数型动态属性（component/fieldProps/rules/required/disabled/isEditable/valueType）
+        // 可能依赖行内其他字段（兄弟字段），需比较整行；
+        // 同引用原地修改时 isEqual 恒为 true，无法感知，必须强制重渲染
+        if (hasFunctionDependency) {
           if (record === prevRecord) {
             return true;
           }
-          const rowChanged = !_isEqual(record, prevRecord);
-          return rowChanged;
+          return !_isEqual(record, prevRecord);
         }
         const key = item.dataIndex || item.key;
         if (!key) return true;

package/es/ProEditTable/utils/tools.js

@@ -114,15 +114,16 @@ export const onDelete = ({
   selectedRowKeys
 }) => {
   // 正常的form数据流处理
+  // 行可能为 undefined/null（单行编辑下虚拟数组多轮增删改后残留的空位），过滤时需先做空值守卫
   let dataSource = form.getFieldValue(name);
-  dataSource = dataSource.filter(row => !selectedRowKeys.includes(row.rowKey));
+  dataSource = dataSource.filter(row => row && !selectedRowKeys.includes(row.rowKey));
   form.setFieldValue(name, dataSource);
   // 单行模式数据流处理 重置中间正在编辑状态单行数据
   if (virtualKey) {
     const namePath = getNamePath(name, virtualKey);
     let virtualList = form.getFieldValue(namePath);
     if (virtualList?.length) {
-      virtualList = virtualList.filter(row => !selectedRowKeys.includes(row.rowKey));
+      virtualList = virtualList.filter(row => row && !selectedRowKeys.includes(row.rowKey));
       form.setFieldValue(namePath, virtualList);
     }
   }

package/es/ProEnum/index.js

@@ -16,7 +16,7 @@ import getEnumLabel from "./utils/getEnumLabel";
 import useEnum from "./hooks/useEnum";
 import getEnum from "./utils/getEnum";
 import locale from "../locale";
-import { useFieldProps } from "../ProForm/utils/useFieldProps";
+import { useFieldProps } from "../ProForm/hooks/useFieldProps";
 import { jsx as _jsx, Fragment as _Fragment } from "react/jsx-runtime";
 const ProEnum = props => {
   const {

package/es/ProForm/components/FormFooter/propsType.d.ts

@@ -1,6 +1,6 @@
 /// <reference types="react" />
 import { ButtonProps, ColProps, FormInstance } from 'antd';
-import { ModifiedFormInstanceType } from '../../utils/useForm';
+import type { ModifiedFormInstanceType } from '../../propsType';
 export interface ButtonItem extends ButtonProps {
     children?: any;
 }

package/es/ProForm/components/base/DatePicker/index.js

@@ -62,10 +62,11 @@ const DatePicker = props => {
     let viewChildren = null;
     if (!value) {
       viewChildren = null;
-    } else if (typeof format === 'string' && _isObject(value)) {
-      viewChildren = value.format?.(format) || value;
     } else if (_isFunction(format)) {
       viewChildren = format(value);
+    } else if (_isObject(value) && _isFunction(value.format)) {
+      // dayjs / dayjs-like 对象：format 字符串优先，否则用 viewFormat（valueType > picker default）
+      viewChildren = value.format(typeof format === 'string' ? format : viewFormat);
     } else if (_isString(value)) {
       viewChildren = dayjs(value).format(viewFormat);
     }

package/es/ProForm/components/combination/Group/component/ComRender.js

@@ -2,7 +2,7 @@ import _omit from "lodash/omit";
 import React from 'react';
 import { Form } from 'antd';
 import ConfirmWrapper from "../../../../components/render/ConfirmWrapper";
-import { FieldProvider } from "../../../../utils/useFieldProps";
+import { FieldProvider } from "../../../../hooks/useFieldProps";
 import * as componentMap from "../../../../../index";
 import AddonWrapper from "./AddonWrapper";
 import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";

package/es/ProForm/components/combination/Group/component/FlexibleGroup.js

@@ -3,7 +3,7 @@ import _isEmpty from "lodash/isEmpty";
 import React from 'react';
 import { Space, Form } from 'antd';
 import classnames from 'classnames';
-import { FieldProvider } from "../../../../utils/useFieldProps";
+import { FieldProvider } from "../../../../hooks/useFieldProps";
 import ProForm from "../../../../../ProForm";
 import Render from "../../../render/Render";
 import * as componentMap from "../../../../../index";
@@ -189,6 +189,8 @@ const FlexibleGroupRender = props => {
       namePath: childNamePath || contextProps.namePath,
       formDisabled: otherProps?.formDisabled,
       globalControl: otherProps?.globalControl,
+      diffConfig: otherProps?.diffConfig,
+      shouldUpdateDebounce: otherProps?.shouldUpdateDebounce,
       // 灵活模式样式属性
       flexibleGroupProps: {
         className: formItemClassName,
@@ -204,27 +206,18 @@ const FlexibleGroupRender = props => {
       value: renderOtherProps,
       children: /*#__PURE__*/_jsx(Render, {
         show: child.show,
-        form: form,
         disabled: child.disabled,
-        formDisabled: otherProps?.formDisabled,
-        type: type,
         originComponent: child.component,
         component: TargetComponent,
         formItemProps: formItemProps,
         confirm: child.confirm,
-        colProps: {
-          span: 24
-        },
         componentProps: adjustedFieldProps || {},
         otherProps: renderOtherProps,
         fieldProps: child.fieldProps,
         isSelect: false // 由 Render 内部计算
         ,
-        diffConfig: otherProps?.diffConfig,
         requiredOnView: otherProps?.requiredOnView,
-        globalControl: otherProps?.globalControl,
-        viewRender: child.viewRender,
-        shouldUpdateDebounce: otherProps?.shouldUpdateDebounce
+        viewRender: child.viewRender
       })
     }, child.name || `item-${index}`);
   };

package/es/ProForm/components/combination/Group/hooks/index.js

@@ -3,7 +3,7 @@ import _isEqual from "lodash/isEqual";
 import _cloneDeep from "lodash/cloneDeep";
 /* eslint-disable no-lonely-if */
 import { useRef, useEffect } from 'react';
-import { useDeepCompareMemo } from "../../../../utils/useDeepCompareMemo";
+import { useDeepCompareMemo } from "../../../../hooks/useDeepCompareMemo";
 import { difference } from "../../../../../ProEditTable/utils/tools";
 import { getReactiveProps, getValueTypeTrans, valueFromEventWrapper } from "../utils";
 /** 转换columns */
@@ -65,7 +65,6 @@ export const useTransformColumns = params => {
     };
 
     // 响应式字段
-    // eslint-disable-next-line react-hooks/rules-of-hooks
     const reactiveProps = useDeepCompareMemo(() => {
       return getReactiveProps({
         form,

package/es/ProForm/components/combination/Group/utils/index.d.ts

@@ -75,33 +75,28 @@ export declare const useFormItemProps: (column: FlexibleGroupColumnType, context
     confirm?: boolean | import("antd").ModalFuncProps | import("../../../render/propsType").FunctionArgs<any, boolean | import("antd").ModalFuncProps>;
     show?: boolean | ReactiveFunction<any, boolean>;
     component?: React.ReactNode | ReactiveFunction<any, React.ReactNode>;
-    prefixCls?: string;
-    htmlFor?: string;
     className?: string;
     hidden?: boolean;
     id?: string;
     style?: React.CSSProperties;
     children?: React.ReactNode | ((form: FormInstance<any>) => React.ReactNode);
     onReset?: () => void;
-    trim?: boolean;
-    normalize?: (value: any, prevValue: any, allValues: import("@rc-component/form/lib/interface").Store) => any;
-    vertical?: boolean;
+    prefixCls?: string;
     isView?: boolean;
-    trigger?: string;
-    toISOString?: boolean;
-    toCSTString?: boolean;
-    switchValue?: [any, any];
-    clearNotShow?: boolean;
-    validateTrigger?: string | false | string[];
+    desensitization?: [number, number] | ReactiveFunction<any, [number, number]>;
     rootClassName?: string;
     status?: "" | "warning" | "error" | "success" | "validating";
-    valueType?: import("../../../render/propsType").ProFormValueType;
+    vertical?: boolean;
     getValueProps?: ((value: any) => Record<string, unknown>) & ((value: any) => Record<string, unknown>);
-    shouldUpdate?: import("@rc-component/form/lib/Field").ShouldUpdate<any>;
     colon?: boolean;
+    htmlFor?: string;
     labelAlign?: import("antd/es/form/interface").FormLabelAlign;
     labelCol?: import("antd").ColProps;
     getValueFromEvent?: (...args: import("@rc-component/form/lib/interface").EventArgs) => any;
+    normalize?: (value: any, prevValue: any, allValues: import("@rc-component/form/lib/interface").Store) => any;
+    shouldUpdate?: import("@rc-component/form/lib/Field").ShouldUpdate<any>;
+    trigger?: string;
+    validateTrigger?: string | false | string[];
     validateDebounce?: number;
     valuePropName?: string;
     messageVariables?: Record<string, string>;
@@ -119,14 +114,19 @@ export declare const useFormItemProps: (column: FlexibleGroupColumnType, context
     wrapperCol?: import("antd").ColProps;
     help?: React.ReactNode;
     fieldId?: string;
-    desensitization?: [number, number] | ReactiveFunction<any, [number, number]>;
+    valueType?: import("../../../render/propsType").ProFormValueType;
+    toISOString?: boolean;
+    toCSTString?: boolean;
+    switchValue?: [any, any];
+    clearNotShow?: boolean;
+    trim?: boolean;
+    upperCase?: boolean;
     viewRender?: (value: any, record: any, { form, index, namePath, }: {
         [key: string]: any;
         form: FormInstance<any>;
         index?: number;
     }) => string | React.ReactElement<any, any>;
     viewType?: import("../../../render/propsType").ViewType;
-    upperCase?: boolean;
     name: any;
     dependencies: any[];
     tooltip: string | {
@@ -141,7 +141,7 @@ export declare const useFormItemProps: (column: FlexibleGroupColumnType, context
  * 创建组件属性
  */
 export declare const createComponentProps: (column: FlexibleGroupColumnType, formItemProps: any) => {
-    componentProps: import("lodash").Omit<any, "format" | "toISOString" | "toCSTString" | "switchValue" | "precision" | "clearNotShow" | "dependNames" | "valueType">;
+    componentProps: import("lodash").Omit<any, "precision" | "valueType" | "toISOString" | "toCSTString" | "switchValue" | "format" | "clearNotShow" | "dependNames">;
     formItemTransform: {
         getValueProps: any;
         normalize: any;