@ant-design/pro-components 3.1.12-0 → 3.1.13-0

package/es/table/useFetchData.js

@@ -1,9 +1,16 @@
 import { useControlledState } from '@rc-component/util';
-import { useCallback, useEffect, useRef, useState } from 'react';
+import { useEffect, useRef, useState } from 'react';
 import { runFunction, useDebounceFn, useDeepCompareEffect, usePrevious, useRefFunction } from "../utils";
 import { postDataPipeline } from "./utils/index";
 import { usePageInfo } from "./utils/usePageInfo";
 
+/**
+ * 轮询的最小间隔（毫秒）。低于此值会被钳制为此值，避免在请求 RTT 较大时
+ * 出现「上一次还没回来就发起下一次」导致一直 loading 的问题。
+ * 该协议被 `tests/table/polling.test.tsx#85 polling min time is 2000` 明确锁定。
+ */
+const MIN_POLLING_INTERVAL_MS = 2000;
+
 /**
  * useFetchData hook 用来获取数据并控制数据的状态和分页
  * @template T
@@ -48,7 +55,7 @@ const useFetchData = (getData, defaultData, options) => {
    * 用于存储最新的数据，这样可以在切换的时候保持数据的一致性
    */
   const [tableDataList, setTableDataListInner] = useControlledState(defaultData, options?.dataSource);
-  const setTableDataList = useCallback(updater => {
+  const setTableDataList = useRefFunction(updater => {
     setTableDataListInner(prev => {
       const next = typeof updater === 'function' ? updater(prev) : updater;
       // 使用 queueMicrotask 延迟回调，避免在渲染期间更新其他组件状态
@@ -57,7 +64,7 @@ const useFetchData = (getData, defaultData, options) => {
       });
       return next;
     });
-  }, [options?.onDataSourceChange]);
+  });
 
   /**
    * 表格的加载状态
@@ -76,7 +83,7 @@ const useFetchData = (getData, defaultData, options) => {
    * 包装 setTableLoading，使用 queueMicrotask 延迟回调调用
    * 避免在渲染阶段调用外部回调导致的 React 警告
    */
-  const setTableLoading = useCallback(updater => {
+  const setTableLoading = useRefFunction(updater => {
     setTableLoadingInner(prev => {
       const next = typeof updater === 'function' ? updater(prev) : updater;
       queueMicrotask(() => {
@@ -84,7 +91,7 @@ const useFetchData = (getData, defaultData, options) => {
       });
       return next;
     });
-  }, [onLoadingChange]);
+  });
 
   /**
    * 表示页面信息的类型
@@ -101,8 +108,12 @@ const useFetchData = (getData, defaultData, options) => {
   const setDataAndLoading = (newData, dataTotal) => {
     setTableDataList(newData);
     if (pageInfo?.total !== dataTotal) {
+      // 旧实现 `setPageInfo({ ...pageInfo, total: ... })` 会用 fetchList 启动时
+      // 捕获的 pageInfo 快照（含 current / pageSize）覆盖回去：如果用户在 await 期间
+      // 已经改了 current（如点了下一页），await 完成后此处会把 current 倒退回快照值。
+      // setPageInfo 来自 usePageInfo，本身接受 Partial<PageInfo> 并自动 merge 到
+      // 最新 pageInfo ref 上，所以这里只需传 total 这一个真正要变的字段。
       setPageInfo({
-        ...pageInfo,
         total: dataTotal || newData.length
       });
     }
@@ -181,9 +192,12 @@ const useFetchData = (getData, defaultData, options) => {
         return [];
       }
       // 如果没有传递这个方法的话，需要把错误抛出去，以免吞掉错误
-      if (onRequestError === undefined) throw new Error(e);
+      const requestError = e instanceof Error ? e : new Error(String(e));
+      if (onRequestError === undefined) {
+        throw requestError;
+      }
       if (tableDataList === undefined) setTableDataList([]);
-      onRequestError(e);
+      onRequestError(requestError);
     } finally {
       if (!signal?.aborted) {
         requestFinally();
@@ -216,11 +230,23 @@ const useFetchData = (getData, defaultData, options) => {
        * 此时第二个 Promise 就会被取消。
        */
       const msg = await Promise.race([fetchList(isPolling, abort.signal), new Promise((_, reject) => {
-        abortRef.current?.signal?.addEventListener?.('abort', () => {
+        // 关键修复：监听局部 `abort.signal` 而不是 `abortRef.current.signal`。
+        // 旧实现 `abortRef.current?.signal?.addEventListener(...)` 在 await 期间
+        // 如果再次触发 fetchListDebounce，abortRef.current 被新 abort 覆盖，
+        // 旧 listener 反而监听到新 signal —— 新 abort 触发时旧 Promise 也跟着 reject，
+        // 而且回调里的 `fetchListDebounce.cancel()` 会把刚发起的新请求一并取消。
+        // 用局部 abort 变量保证「listener 与对应的 fetchList 调用绑定的是同一个 signal」。
+        //
+        // { once: true }：abort 是一次性事件，旧实现没有 once / 没有 removeEventListener，
+        // 高频 reload + 长 await getData 的场景下回调（持有 reject / fetchListDebounce
+        // / requestFinally 闭包）会短时间累积，存在轻量内存泄漏风险。
+        abort.signal.addEventListener?.('abort', () => {
           reject('aborted');
           // 结束请求，并且清空loading控制
           fetchListDebounce.cancel();
           requestFinally();
+        }, {
+          once: true
         });
       })]);
       if (abort.signal.aborted) return;
@@ -228,15 +254,21 @@ const useFetchData = (getData, defaultData, options) => {
       const needPolling = runFunction(polling, msg);
 
       /*
-       * 这段代码是用于控制轮询的。其中，needPolling 参数表明当前是否需要进行轮询，umountRef 是一个 ref，用来记录组件是否被卸载。
-       * 如果需要轮询并且组件没有被卸载，就会调用 setTimeout，等待一定的时间，然后再次调用 fetchListDebounce 函数，并传入需要轮询的时间参数。
-       * 其中 Math.max(needPolling, 2000) 用于确定最小的轮询时间为 2000ms，避免频繁请求导致一直处于 loading 状态。
+       * 控制下一次轮询：
+       *  - needPolling 为 truthy（数字 / boolean true）且组件未卸载时才排期；
+       *  - 排期间隔被 `MIN_POLLING_INTERVAL_MS`（2000ms）钳制为下界，避免请求 RTT
+       *    较大时上一次还没回来就发起下一次导致一直 loading；
+       *  - 当用户传入数字且 < 下界时，仅在开发模式下打一次 warn 提醒被钳制
+       *    （旧实现对此完全沉默，用户排查"为什么我传 500 实际是 2000"困难）。
        */
       if (needPolling && !umountRef.current) {
+        if (process.env.NODE_ENV !== 'production' && typeof needPolling === 'number' && needPolling < MIN_POLLING_INTERVAL_MS) {
+          // eslint-disable-next-line no-console
+          console.warn(`[ProTable] polling=${needPolling}ms is below the minimum interval ${MIN_POLLING_INTERVAL_MS}ms and has been clamped to ${MIN_POLLING_INTERVAL_MS}ms. Lower values are not supported to avoid request pile-up.`);
+        }
         pollingSetTimeRef.current = setTimeout(() => {
           fetchListDebounce.run(needPolling);
-          // 这里判断最小要2000ms，不然一直loading
-        }, Math.max(needPolling, 2000));
+        }, Math.max(needPolling, MIN_POLLING_INTERVAL_MS));
       }
       return msg;
     } catch (error) {
@@ -281,20 +313,29 @@ const useFetchData = (getData, defaultData, options) => {
       current,
       pageSize
     } = pageInfo || {};
-    // 如果上次的页码为空或者两次页码等于是没必要查询的
-    // 如果 pageSize 发生变化是需要查询的，所以又加了 prePageSize
+
+    // 上次的页码为空、或者两次页码相同、且 pageSize 也未变化时，
+    // 说明本次重渲染并非真正的翻页，直接返回不重请求。
     if ((!prePage || prePage === current) && (!prePageSize || prePageSize === pageSize)) {
       return;
     }
-    if (options.pageInfo && tableDataList && tableDataList?.length > pageSize || 0) {
+
+    // 「假分页」守门：
+    // 当用户启用 pageInfo（即 ProTable 自带分页），且当前已加载数据条数超过 pageSize 时，
+    // 说明上游 request 一次性返回了「跨页全量数据」，本地表格自己做切片即可，
+    // 翻页不应该再发起新请求。该协议被 `pagination.test.tsx#227 request call once
+    // when data.length more then pageSize` 锁定。
+    //
+    // 旧实现末尾的 `|| 0` 是 dead expression（`||` 优先级低于整个表达式，最终参与判断的
+    // 只是 0 这个 falsy 值，对条件无影响）。这里直接移除。
+    if (options.pageInfo && tableDataList && tableDataList.length > pageSize) {
       return;
     }
 
-    // 如果 list 的长度大于 pageSize 的长度
-    // 说明是一个假分页
-    // (pageIndex - 1 || 1) 至少要第一页
-    // 在第一页大于 10
-    // 第二页也应该是大于 10
+    // 走到这里说明是真分页（后端按 page 返回数据）：
+    // 当前页码已知，且本地数据条数 <= pageSize，发起新请求拉取下一页。
+    // （旧注释「list 长度大于 pageSize 是假分页」与下面的判断 `<= pageSize` 完全反向，
+    //  实际上「假分页」已在上面那段提前 return 了，这里处理的是「真分页」场景。）
     if (current !== undefined && tableDataList && tableDataList.length <= pageSize) {
       abortFetch();
       fetchListDebounce.run(false);
@@ -349,17 +390,22 @@ const useFetchData = (getData, defaultData, options) => {
     } : tableLoading,
     /**
      * 重新加载表格数据的函数。
-     * @type {function}
+     *
+     * 协议（与 `UseFetchDataAction.reload: () => Promise<void>` 对齐）：
+     *   - 仅作为副作用触发，不向调用方返回数据；
+     *   - 旧 doc 写 `Promise<boolean>`、旧实现把 `fetchListDebounce.run` 的结果（DataSource[]
+     *     | undefined）返回出去，与公共类型 `Promise<void>` 三处不一致。这里统一以
+     *     typing.ts 的公共类型为准，不做返回。
+     *
      * @async
-     * @returns {Promise<boolean>} - 数据重新加载完成后解决为 true 的 Promise。
+     * @returns {Promise<void>} - 数据重新加载完成后 resolve 的 Promise。
      */
     reload: async () => {
       abortFetch();
       // 对于手动 reload，我们需要强制执行请求，即使在 manualRequest 模式下
       manualRequestRef.current = false;
-      const result = await fetchListDebounce.run(false);
+      await fetchListDebounce.run(false);
       // 如果之前是手动模式，不要重置为 true，因为用户已经手动触发了请求
-      return result;
     },
     /**
      * 当前的分页信息。

package/es/table/utils/cellRenderToFromItem.d.ts

@@ -7,8 +7,14 @@ import type { ProColumnType } from '../index';
 import type { ContainerType } from '../Store/Provide';
 /**
  * 拼接用于编辑的 key
+ *
+ * @deprecated 请使用 buildNamePath，spellNamePath 是历史命名，保留以兼容外部引用
  */
 export declare const spellNamePath: (...rest: any[]) => React.Key[];
+/**
+ * 拼接用于编辑的表单字段路径（name path）
+ */
+export declare const buildNamePath: (...rest: any[]) => React.Key[];
 type CellRenderFromItemProps<T extends AnyObject> = {
     text: string | number | (string | number)[];
     valueType: ProColumnType['valueType'];

package/es/table/utils/cellRenderToFromItem.js

@@ -2,15 +2,22 @@ import { get } from '@rc-component/util';
 import { Form } from 'antd';
 import React, { useCallback, useContext, useEffect, useMemo, useState } from 'react';
 import { FieldContext, ProForm, ProFormField } from "../../form";
-import { InlineErrorFormItem, getFieldPropsOrFormItemProps, runFunction } from "../../utils";
+import { InlineErrorFormItem, getFieldPropsOrFormItemProps, isDeepEqualReact, runFunction } from "../../utils";
 import { jsx as _jsx } from "react/jsx-runtime";
 import { Fragment as _Fragment } from "react/jsx-runtime";
 const SHOW_EMPTY_TEXT_LIST = ['', null, undefined];
 
 /**
  * 拼接用于编辑的 key
+ *
+ * @deprecated 请使用 buildNamePath，spellNamePath 是历史命名，保留以兼容外部引用
  */
-export const spellNamePath = (...rest) => {
+export const spellNamePath = (...rest) => buildNamePath(...rest);
+
+/**
+ * 拼接用于编辑的表单字段路径（name path）
+ */
+export const buildNamePath = (...rest) => {
   return rest.filter(index => index !== undefined).map(item => {
     if (typeof item === 'number') {
       return item.toString();
@@ -35,32 +42,25 @@ const CellRenderFromItem = props => {
   const editableForm = ProForm.useFormInstance();
   const key = recordKey || index;
   const realIndex = useMemo(() => editableUtils?.getRealIndex?.(rowData) ?? index, [editableUtils, index, rowData]);
-  const [formItemName, setName] = useState(() => spellNamePath(prefixName, prefixName ? subName : [], prefixName ? realIndex : key, columnProps?.key ?? columnProps?.dataIndex ?? index));
+  const [formItemName, setName] = useState(() => buildNamePath(prefixName, prefixName ? subName : [], prefixName ? realIndex : key, columnProps?.key ?? columnProps?.dataIndex ?? index));
   const rowName = useMemo(() => {
     return formItemName.slice(0, -1);
   }, [formItemName]);
   useEffect(() => {
-    const value = spellNamePath(prefixName, prefixName ? subName : [], prefixName ? realIndex : key, columnProps?.key ?? columnProps?.dataIndex ?? index);
-    if (value.join('-') !== formItemName.join('-')) setName(value);
-  }, [columnProps?.dataIndex, columnProps?.key, index, recordKey, prefixName, key, subName, formItemName, realIndex]);
+    const nextName = buildNamePath(prefixName, prefixName ? subName : [], prefixName ? realIndex : key, columnProps?.key ?? columnProps?.dataIndex ?? index);
+    // 用 functional update 读取最新 prev 值进行比较，避免把 formItemName
+    // 加入 deps 导致「state 变 → effect 跑 → setName → state 变」的循环依赖。
+    setName(prev => {
+      if (nextName.join('-') !== prev.join('-')) return nextName;
+      return prev;
+    });
+  }, [columnProps?.dataIndex, columnProps?.key, index, recordKey, prefixName, key, subName, realIndex]);
   const needProps = useMemo(() => [editableForm, {
     ...columnProps,
     rowKey: rowName,
     rowIndex: index,
     isEditable: true
   }], [columnProps, editableForm, index, rowName]);
-  const InlineItem = useCallback(({
-    children,
-    ...restProps
-  }) => /*#__PURE__*/_jsx(InlineErrorFormItem, {
-    popoverProps: {
-      getPopupContainer: formContext.getPopupContainer || (() => counter.rootDomRef.current || document.body)
-    },
-    errorType: "popover",
-    name: formItemName,
-    ...restProps,
-    children: children
-  }, key), [key, formItemName]);
   const generateFormItem = useCallback(() => {
     const formItemProps = {
       ...getFieldPropsOrFormItemProps(columnProps?.formItemProps, ...needProps)
@@ -70,7 +70,12 @@ const CellRenderFromItem = props => {
       type: columnProps?.valueType || '文本',
       ...formItemProps?.messageVariables
     };
-    formItemProps.initialValue = (prefixName ? null : text) ?? formItemProps?.initialValue ?? columnProps?.initialValue;
+
+    // 有 prefixName（EditableTable 嵌套场景）时不应强制覆盖 initialValue：
+    // 原写法 `(prefixName ? null : text) ?? ...` 中 `??` 不过滤 null，
+    // 导致有 prefixName 时 initialValue 被强制设为 null，覆盖了 formItemProps
+    // 和 columnProps 中的有效值。
+    formItemProps.initialValue = prefixName ? formItemProps?.initialValue ?? columnProps?.initialValue : text ?? formItemProps?.initialValue ?? columnProps?.initialValue;
     let fieldDom = /*#__PURE__*/_jsx(ProFormField, {
       cacheForSwr: true,
       name: formItemName,
@@ -105,11 +110,25 @@ const CellRenderFromItem = props => {
         children: fieldDom
       });
     }
-    return /*#__PURE__*/_jsx(InlineItem, {
+
+    // 注意：不能把 InlineErrorFormItem 包装成 useCallback<React.FC> 再作为组件使用。
+    // 每次 deps 变化会产生新函数引用，React 会认为是不同组件而 unmount/remount，
+    // 导致 Form.Item 内部校验状态丢失。此处直接内联 JSX 是正确做法。
+    return /*#__PURE__*/_jsx(InlineErrorFormItem, {
+      popoverProps: {
+        getPopupContainer: formContext.getPopupContainer || (() => counter.rootDomRef.current || document.body)
+      },
+      errorType: "popover",
+      name: formItemName,
       ...formItemProps,
       children: fieldDom
     }, formItemName.join('-'));
-  }, [columnProps, needProps, prefixName, text, key, formItemName, proFieldProps, InlineItem, index, recordKey, rowData, editableForm, props.editableUtils]);
+    // deps 说明：
+    // - needProps 已经 memo([columnProps, editableForm, index, rowName])，
+    //   因此 columnProps / editableForm / index 的变化都会通过 needProps 触发。
+    // - counter.rootDomRef 是 React ref 对象，引用永不变，不需要进 deps。
+    // - editableUtils 优先使用解构变量，与 props.editableUtils 引用相同。
+  }, [columnProps, needProps, prefixName, text, key, formItemName, proFieldProps, formContext.getPopupContainer, recordKey, rowData, editableUtils]);
   if (formItemName.length === 0) return null;
   if (typeof columnProps?.formItemRender === 'function' || typeof columnProps?.fieldProps === 'function' || typeof columnProps?.formItemProps === 'function') {
     return /*#__PURE__*/_jsx(Form.Item, {
@@ -117,11 +136,17 @@ const CellRenderFromItem = props => {
       shouldUpdate: (pre, next) => {
         if (pre === next) return false;
         const shouldName = [rowName].flat(1);
-        try {
-          return JSON.stringify(get(pre, shouldName)) !== JSON.stringify(get(next, shouldName));
-        } catch (_error) {
-          return true;
-        }
+        // rowName 为空（formItemName 只有一段，无法精确定位行数据）时，
+        // 直接返回 true 让 generateFormItem 重新执行，避免用空路径
+        // get(values, []) 拿到整个 form values 对象做全量 JSON.stringify。
+        if (shouldName.length === 0) return true;
+        const prevValue = get(pre, shouldName);
+        const nextValue = get(next, shouldName);
+        // 使用 isDeepEqualReact 做深比较：
+        // 1. 内部先做引用浅比较，相同引用直接返回 true，性能 O(1)
+        // 2. 深比较时自动处理循环引用，不会像 JSON.stringify 一样抛异常
+        // 3. 大数据量时性能优于 JSON.stringify（支持短路退出）
+        return !isDeepEqualReact(prevValue, nextValue);
       },
       children: () => generateFormItem()
     });
@@ -194,6 +219,6 @@ function cellRenderToFromItem(config) {
   return /*#__PURE__*/_jsx(CellRenderFromItem, {
     ...config,
     proFieldProps: proFieldProps
-  }, config.recordKey);
+  }, config.recordKey ?? config.index);
 }
 export default cellRenderToFromItem;

package/es/table/utils/columnRender.d.ts

@@ -22,7 +22,7 @@ type ColumnRenderInterface<T> = {
  *
  * @param item
  */
-export declare const renderColumnsTitle: (item: ProColumns<any>) => string | number | boolean | Iterable<React.ReactNode> | import("react/jsx-runtime").JSX.Element | null | undefined;
+export declare const renderColumnsTitle: (item: ProColumns<any>) => string | number | boolean | Iterable<React.ReactNode> | React.JSX.Element | null | undefined;
 /**
  * 默认的 filter 方法
  *

package/es/table/utils/genProColumnToColumn.js

@@ -124,7 +124,7 @@ export function genProColumnToColumn(params) {
       filteredValue,
       sortOrder,
       fixed,
-      width: columnProps.width || (columnProps.fixed ? 200 : undefined),
+      width: context.type === 'list' ? columnProps.width : columnProps.width || (columnProps.fixed ? 200 : undefined),
       children: columnProps.children ? genProColumnToColumn({
         columns: columnProps?.children ?? [],
         context,

package/es/table/utils/index.d.ts

@@ -1,7 +1,7 @@
 import type { TablePaginationConfig } from 'antd';
 import type { FilterValue as AntFilterValue, SorterResult, SortOrder } from 'antd/lib/table/interface';
 import type React from 'react';
-import { Key } from 'react';
+import { type ReactElement, Key } from 'react';
 import type { IntlType } from '../../provider';
 import type { UseEditableUtilType } from '../../utils';
 import type { ActionType, Bordered, BorderedType, FilterValue, ProColumns, ProColumnType, ProSorter, UseFetchDataAction } from '../typing';
@@ -116,4 +116,26 @@ export declare const parseProSortOrder: <T>(proSort: Record<string, SortOrder>,
  * @returns 筛选值
  */
 export declare const parseProFilteredValue: <T>(proFilter: Record<string, FilterValue>, columnProps: ProColumnType<T>) => FilterValue | undefined;
+/**
+ * 解析 tableViewRender 的 defaultDom：兼容 Element 或惰性工厂（避免在未使用时构造 Table）。
+ */
+export declare function resolveTableViewDefaultDom(defaultDom: ReactElement | (() => ReactElement)): ReactElement;
+/**
+ * 生成可编辑表格的 getRowKey 函数，供 CellEditorTable / RowEditorTable 复用。
+ *
+ * 规则与 Table.tsx useRowKey / EditableTable getRowKey 保持一致：
+ *  - index === -1 时（内部标识新行）直接取字段值，不走 index fallback
+ *  - name 模式下使用 index.toString() 作为 key（便于转换为数组索引）
+ *  - 否则取 rowKey 字段值，fallback 到 index.toString()
+ *
+ * rowKey 类型兼容 antd TableProps.rowKey 的完整联合类型：
+ *   string | number | symbol | GetRowKey<DataType>
+ * number / symbol 类型在运行时作为属性名使用（通过 String() 转换）。
+ */
+export declare function buildEditableTableRowKey<DataType extends Record<string, any>>(rowKey: string | number | symbol | import('antd/lib/table/interface').GetRowKey<DataType>, name: any): import('antd/lib/table/interface').GetRowKey<DataType>;
+/**
+ * 将 editableKeys 解析为 RowEditableConfig.onChange 的第二参数，
+ * 与 useEditableArray 内 setEditableRowKeys 一致：single 为单条（可为空场景下的 undefined），multiple 为数组。
+ */
+export declare function resolveEditingPayloadForRowEditableOnChange<DataType extends Record<string, any>>(keys: Key[], dataSource: readonly DataType[] | undefined, getRowKey: import('antd/lib/table/interface').GetRowKey<DataType>, editableType: 'single' | 'multiple' | undefined, childrenColumnName?: string): DataType | DataType[];
 export {};

package/es/table/utils/index.js

@@ -299,4 +299,62 @@ export const parseProFilteredValue = (proFilter, columnProps) => {
 
   // 返回对应的筛选值
   return filterKey ? proFilter[filterKey] : undefined;
-};
+};
+
+/**
+ * 解析 tableViewRender 的 defaultDom：兼容 Element 或惰性工厂（避免在未使用时构造 Table）。
+ */
+export function resolveTableViewDefaultDom(defaultDom) {
+  return typeof defaultDom === 'function' ? defaultDom() : defaultDom;
+}
+
+/**
+ * 生成可编辑表格的 getRowKey 函数，供 CellEditorTable / RowEditorTable 复用。
+ *
+ * 规则与 Table.tsx useRowKey / EditableTable getRowKey 保持一致：
+ *  - index === -1 时（内部标识新行）直接取字段值，不走 index fallback
+ *  - name 模式下使用 index.toString() 作为 key（便于转换为数组索引）
+ *  - 否则取 rowKey 字段值，fallback 到 index.toString()
+ *
+ * rowKey 类型兼容 antd TableProps.rowKey 的完整联合类型：
+ *   string | number | symbol | GetRowKey<DataType>
+ * number / symbol 类型在运行时作为属性名使用（通过 String() 转换）。
+ */
+export function buildEditableTableRowKey(rowKey, name) {
+  if (typeof rowKey === 'function') {
+    return rowKey;
+  }
+  const rowKeyStr = String(rowKey);
+  return (record, index) => {
+    if (index === -1) {
+      return record?.[rowKeyStr];
+    }
+    if (name) {
+      return index?.toString() ?? '';
+    }
+    return record?.[rowKeyStr] ?? index?.toString() ?? '';
+  };
+}
+
+/**
+ * 将 editableKeys 解析为 RowEditableConfig.onChange 的第二参数，
+ * 与 useEditableArray 内 setEditableRowKeys 一致：single 为单条（可为空场景下的 undefined），multiple 为数组。
+ */
+export function resolveEditingPayloadForRowEditableOnChange(keys, dataSource, getRowKey, editableType, childrenColumnName = 'children') {
+  const cleanKeys = keys.filter(key => key !== undefined);
+  const kvMap = new Map();
+  const dig = records => {
+    records.forEach((record, index) => {
+      const rowKey = getRowKey(record, index);
+      kvMap.set(rowKey, record);
+      if (record && typeof record === 'object' && childrenColumnName in record) {
+        dig(record[childrenColumnName] || []);
+      }
+    });
+  };
+  dig(dataSource ?? []);
+  const editingRecords = cleanKeys.map(key => kvMap.get(key)).filter(k => k !== undefined);
+  const type = editableType || 'single';
+  const editingPayload = type === 'single' ? editingRecords[0] : editingRecords;
+  return editingPayload;
+}

package/es/table/utils/useDragSort.d.ts

@@ -9,6 +9,6 @@ export interface UseDragSortOptions<T> {
     DragHandle: React.FC<any>;
 }
 export declare function useDragSort<T>(props: UseDragSortOptions<T>): {
-    DndContext: (contextProps: any) => import("react/jsx-runtime").JSX.Element;
+    DndContext: (contextProps: any) => React.JSX.Element;
     components: TableComponents<T>;
 };

package/es/table/utils/usePageInfo.js

@@ -1,5 +1,4 @@
 import { useControlledState } from '@rc-component/util';
-import { useCallback } from 'react';
 import { useRefFunction } from "../../utils";
 /**
  * 组合用户的配置和默认值
@@ -35,13 +34,13 @@ const mergeOptionAndPageInfo = ({
  */
 export function usePageInfo(options) {
   const [pageInfo, setPageInfoStateInner] = useControlledState(() => mergeOptionAndPageInfo(options), undefined);
-  const setPageInfoState = useCallback(updater => {
+  const setPageInfoState = useRefFunction(updater => {
     setPageInfoStateInner(prev => {
       const next = typeof updater === 'function' ? updater(prev) : updater;
       options?.onPageInfoChange?.(next);
       return next;
     });
-  }, [options?.onPageInfoChange]);
+  });
   const setPageInfo = useRefFunction(changePageInfo => {
     const newPageInfo = {
       ...pageInfo,

package/es/utils/components/DropdownFooter/index.d.ts

@@ -1,5 +1,5 @@
 import React from 'react';
-type LightFilterFooterRender = ((onConfirm?: (e?: React.MouseEvent) => void, onClear?: (e?: React.MouseEvent) => void) => React.JSX.Element | false) | false;
+import type { LightFilterFooterRender } from '../../../form/typing';
 type OnClick = (e?: React.MouseEvent) => void;
 export type DropdownFooterProps = {
     onClear?: OnClick;

package/es/utils/components/ErrorBoundary/index.d.ts

@@ -15,6 +15,6 @@ declare class ErrorBoundary extends React.Component<{
         errorInfo: string;
     };
     componentDidCatch(error: any, errorInfo: ErrorInfo): void;
-    render(): string | number | boolean | Iterable<React.ReactNode> | import("react/jsx-runtime").JSX.Element | null | undefined;
+    render(): string | number | boolean | Iterable<React.ReactNode> | React.JSX.Element | null | undefined;
 }
 export { ErrorBoundary };

package/es/utils/components/InlineErrorFormItem/index.d.ts

@@ -1,8 +1,9 @@
 import type { FormItemProps, PopoverProps } from 'antd';
+import React from 'react';
 interface InlineErrorFormItemProps extends FormItemProps {
     errorType?: 'popover' | 'default';
     popoverProps?: PopoverProps;
     children: any;
 }
-export declare const InlineErrorFormItem: (props: InlineErrorFormItemProps) => import("react/jsx-runtime").JSX.Element;
+export declare const InlineErrorFormItem: (props: InlineErrorFormItemProps) => React.JSX.Element;
 export {};

package/es/utils/conversionMomentValue/index.d.ts

@@ -2,11 +2,13 @@ import type { NamePath } from 'antd/lib/form/interface';
 import dayjs from 'dayjs';
 import type { ProFieldValueType } from '../typing';
 type DateFormatter = (string & {}) | 'number' | 'string' | ((value: dayjs.Dayjs, valueType: string) => string | number) | false;
+/** 周字段：表单提交转字符串用 ISO 周 `GGGG-[W]WW`；选择器/只读展示用 `gggg-wo`（与 rc-picker 一致） */
 export declare const dateFormatterMap: {
     time: string;
     timeRange: string;
     date: string;
     dateWeek: string;
+    dateWeekRange: string;
     dateMonth: string;
     dateQuarter: string;
     dateYear: string;
@@ -14,6 +16,10 @@ export declare const dateFormatterMap: {
     dateTime: string;
     dateTimeRange: string;
 };
+/**
+ * LightFilter 收起态日期范围展示。`dateWeekRange` 在 map 中为 ISO 周（提交用），标签需与周选择器展示一致。
+ */
+export declare function getLightFilterRangeDisplayFormat(valueType: string | undefined): string;
 /**
  * 判断是否是一个的简单的 object
  * @param  {{constructor:any}} o
@@ -28,15 +34,14 @@ export declare function isPlainObject(o: {
  * @param  {string|((value:dayjs.Dayjs} dateFormatter
  * @param  {string} valueType
  */
-export declare const convertMoment: (value: dayjs.Dayjs, dateFormatter: DateFormatter, valueType: string) => string | number | dayjs.Dayjs;
+export declare const convertMoment: (value: dayjs.Dayjs, dateFormatter: DateFormatter, valueType: string) => any;
 /**
  * 这里主要是来转化一下数据 将 dayjs 转化为 string 将 all 默认删除
  * @param  {T} value
  * @param  {DateFormatter} dateFormatter
  * @param  {Record<string} valueTypeMap
- * @param  {ProFieldValueType;dateFormat:string;}|any>} |{valueType
- * @param  {boolean} omitNil?
- * @param  {NamePath} parentKey?
+ * @param omitNil
+ * @param parentKey
  */
 export declare const conversionMomentValue: <T extends {} = any>(value: T, dateFormatter: DateFormatter, valueTypeMap: Record<string, {
     valueType: ProFieldValueType;