@zat-design/sisyphus-react 3.6.6 → 3.6.7-beta.1

package/es/ProLayout/utils/index.js

@@ -15,7 +15,7 @@ export var getIdsByPathName = function getIdsByPathName(menus, activeMenu) {
     _pathName = activeMenu;
   }
   var result;
-  var menuDeep = function menuDeep(menuDeepItem) {
+  var _menuDeep = function menuDeep(menuDeepItem) {
     for (var i = 0; i <= menuDeepItem.length - 1; i++) {
       var item = menuDeepItem[i];
       // 只包含一级菜单时，解决URL：/endorsement/demo/123无法选中问题
@@ -24,7 +24,7 @@ export var getIdsByPathName = function getIdsByPathName(menus, activeMenu) {
         break;
       }
       if (Array.isArray(item.children) && item.children.length) {
-        menuDeep(item.children);
+        _menuDeep(item.children);
       } else if (((item === null || item === void 0 ? void 0 : item.url) && _pathName.includes(item.url.split('?')[0]) || (item === null || item === void 0 ? void 0 : item.redirectUrl) && _pathName.includes(item.redirectUrl.split('?')[0])) && !result) {
         // 当循环到最后一层时判断URL是否包含最后一层的URL，解决URL在URL中不存在的场景
         result = item.keyIdPath;
@@ -32,7 +32,7 @@ export var getIdsByPathName = function getIdsByPathName(menus, activeMenu) {
       }
     }
   };
-  menuDeep(menus);
+  _menuDeep(menus);
   return result || [];
 };
 /**
@@ -42,7 +42,7 @@ export var getIdsByPathName = function getIdsByPathName(menus, activeMenu) {
  */
 export var transformMenu = function transformMenu(menuData, pathPrefix) {
   var data = _toConsumableArray(menuData);
-  var menuDeep = function menuDeep(menuDeepItem) {
+  var _menuDeep2 = function menuDeep(menuDeepItem) {
     if (!Array.isArray(menuDeepItem) || !menuDeepItem.length) {
       return [];
     }
@@ -75,11 +75,11 @@ export var transformMenu = function transformMenu(menuData, pathPrefix) {
           childrenItem.keyUrlPath = _toConsumableArray(item.keyUrlPath);
           childrenItem.keyIdPath = _toConsumableArray(item.keyIdPath);
         });
-        menuDeep(item.children);
+        _menuDeep2(item.children);
       }
     });
   };
-  menuDeep(data);
+  _menuDeep2(data);
   return data;
 };
 /**
@@ -134,7 +134,7 @@ export var getPathNameKey = function getPathNameKey(_ref) {
   var menus = _ref.menus,
     pathName = _ref.pathName;
   var result;
-  var menuDeep = function menuDeep(menuDeepItem) {
+  var _menuDeep3 = function menuDeep(menuDeepItem) {
     if (!Array.isArray(menuDeepItem) || !menuDeepItem.length) {
       return [];
     }
@@ -148,7 +148,7 @@ export var getPathNameKey = function getPathNameKey(_ref) {
         break;
       }
       if (Array.isArray(item.children) && item.children.length) {
-        menuDeep(item.children);
+        _menuDeep3(item.children);
       } else if (((item === null || item === void 0 ? void 0 : item.url) && pathName.includes(item.url.split('?')[0]) || (item === null || item === void 0 ? void 0 : item.redirectUrl) && pathName.includes(item.redirectUrl.split('?')[0])) && !result) {
         // URL未匹配时，循环到最后一层时判断URL是否包含最后一层的URL，解决URL在URL中不存在的场景
         result = item.keyIdPath;
@@ -156,6 +156,6 @@ export var getPathNameKey = function getPathNameKey(_ref) {
       }
     }
   };
-  menuDeep(menus);
+  _menuDeep3(menus);
   return result;
 };

package/es/ProSelect/components/AdaptiveTooltip.d.ts

@@ -1,4 +1,4 @@
 declare const AdaptiveTooltip: ({ children }: {
     children: any;
-}) => JSX.Element;
+}) => import("react/jsx-runtime").JSX.Element;
 export default AdaptiveTooltip;

package/es/ProSelect/index.d.ts

@@ -1,6 +1,6 @@
 import React from 'react';
 import { PropSelectProps, ProSelectAction } from './propsType';
 import './index.less';
-export declare const ProSelect: (props: PropSelectProps, ref: React.Ref<ProSelectAction> | undefined) => JSX.Element;
+export declare const ProSelect: (props: PropSelectProps, ref: React.Ref<ProSelectAction> | undefined) => import("react/jsx-runtime").JSX.Element;
 declare const _default: React.ForwardRefExoticComponent<PropSelectProps & React.RefAttributes<ProSelectAction>>;
 export default _default;

package/es/ProSelect/index.js

@@ -338,7 +338,7 @@ export var ProSelect = function ProSelect(props, ref) {
               title: OptionRender(item),
               children: OptionRender(item)
             }) : _jsx("span", {
-              title: "".concat(item[code], "-").concat(item[label]),
+              title: selectProps.showCodeName ? "".concat(item[code], "-").concat(item[label]) : item[label],
               children: selectProps.showCodeName ? "".concat(item[code], "-").concat(item[label]) : item[label]
             })
           }, item[code])

package/es/ProStep/components/Anchor/index.d.ts

@@ -1,2 +1,2 @@
-export declare const MenuItem: (props: any) => JSX.Element;
+export declare const MenuItem: (props: any) => import("react/jsx-runtime").JSX.Element;
 export default MenuItem;

package/es/ProStep/components/Item/index.d.ts

@@ -1,3 +1,3 @@
 import { ProStepItem } from '../../propsType';
-declare const _default: ({ id, title, collapse: collapseItem, children, ...restProps }: ProStepItem) => JSX.Element;
+declare const _default: ({ id, title, collapse: collapseItem, children, ...restProps }: ProStepItem) => import("react/jsx-runtime").JSX.Element;
 export default _default;

package/es/ProStep/components/Step/index.d.ts

@@ -1,5 +1,5 @@
 import { ProStepPropsType } from '../../propsType';
 export declare const Step: ({ fixedTop, dataSource, activeKey, errorCollection, style, targetOffset, scrollToError, }: ProStepPropsType & {
     errorCollection: object;
-}) => JSX.Element;
+}) => import("react/jsx-runtime").JSX.Element;
 export default Step;

package/es/ProStep/index.d.ts

@@ -4,9 +4,9 @@ import './style/index.less';
 export declare const ProStepContext: import("react").Context<any>;
 export declare const useStep: () => any;
 declare const ProStep: {
-    ({ children, ...resetProps }: ProStepPropsType): JSX.Element;
+    ({ children, ...resetProps }: ProStepPropsType): import("react/jsx-runtime").JSX.Element;
     useStep: () => any;
-    Item: ({ id, title, collapse: collapseItem, children, ...restProps }: import("./propsType").ProStepItem) => JSX.Element;
+    Item: ({ id, title, collapse: collapseItem, children, ...restProps }: import("./propsType").ProStepItem) => import("react/jsx-runtime").JSX.Element;
     Listener: ({ children, delayTime, ...props }: any) => import("react").DetailedReactHTMLElement<any, HTMLElement>;
 };
 export default ProStep;

package/es/ProTable/components/DndWrapper/index.d.ts

@@ -5,11 +5,12 @@ interface RowProps extends React.HTMLAttributes<HTMLTableRowElement> {
     disabled?: boolean;
 }
 export declare const Row: FC<RowProps>;
-declare const DndWrapper: ({ draggable, value, onChange, disabled, children }: {
+declare const DndWrapper: ({ draggable, value, onChange, disabled, children, rowKey }: {
     draggable: any;
     value: any;
     onChange: any;
     disabled: any;
     children: any;
+    rowKey: any;
 }) => any;
 export default DndWrapper;

package/es/ProTable/components/DndWrapper/index.js

@@ -1,11 +1,13 @@
+import _toConsumableArray from "@babel/runtime/helpers/esm/toConsumableArray";
 import _objectSpread from "@babel/runtime/helpers/esm/objectSpread2";
 import _objectWithoutProperties from "@babel/runtime/helpers/esm/objectWithoutProperties";
 var _excluded = ["disabled", "children"];
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import React from 'react';
-import { DndContext } from '@dnd-kit/core';
+import { DndContext, closestCorners } from '@dnd-kit/core';
 import { arrayMove, useSortable, SortableContext, verticalListSortingStrategy } from '@dnd-kit/sortable';
 import { CSS } from '@dnd-kit/utilities';
+import { addLevelAndParentId, treeNodeFind, transformTreeToArray, createTreeFromArray } from './utils/index';
 import ProIcon from '../../../ProIcon';
 export var Row = function Row(props) {
   var disabled = props.disabled,
@@ -60,30 +62,67 @@ export var Row = function Row(props) {
   }));
 };
 var DndWrapper = function DndWrapper(_ref2) {
-  var _value$;
+  var _flatTree$;
   var draggable = _ref2.draggable,
     value = _ref2.value,
     onChange = _ref2.onChange,
     disabled = _ref2.disabled,
-    children = _ref2.children;
+    children = _ref2.children,
+    rowKey = _ref2.rowKey;
   var onDragEnd = function onDragEnd(_ref3) {
     var active = _ref3.active,
       over = _ref3.over;
+    // 为数据源划分层级及parentId
+    var transformedValue = addLevelAndParentId(value, rowKey);
+    // 同一level层级的且parentId相同的，可以互相之间拖拽替换
     if (active.id !== (over === null || over === void 0 ? void 0 : over.id)) {
-      var activeIndex = value.findIndex(function (i) {
-        return i.rowKey === active.id;
+      var activeObject = treeNodeFind(transformedValue, function (t) {
+        return t.rowKey === active.id;
       });
-      var overIndex = value.findIndex(function (i) {
-        return i.rowKey === (over === null || over === void 0 ? void 0 : over.id);
+      var overObject = treeNodeFind(transformedValue, function (t) {
+        return t.rowKey === (over === null || over === void 0 ? void 0 : over.id);
       });
-      var nextValue = arrayMove(value, activeIndex, overIndex);
-      onChange(nextValue);
+      if (activeObject && overObject) {
+        var activeLevel = activeObject.level,
+          activeParentId = activeObject.parentId;
+        var overLevel = overObject.level,
+          overParentId = overObject.parentId;
+        if (activeLevel === overLevel && activeParentId === overParentId) {
+          // 将树平铺
+          var _flatTree = transformTreeToArray(transformedValue).map(function (item) {
+            return _objectSpread(_objectSpread({}, item), {}, {
+              children: undefined
+            });
+          });
+          var activeIndex = _flatTree.findIndex(function (i) {
+            return i.rowKey === active.id;
+          });
+          var overIndex = _flatTree.findIndex(function (i) {
+            return i.rowKey === (over === null || over === void 0 ? void 0 : over.id);
+          });
+          var nextValue = arrayMove(_flatTree, activeIndex, overIndex);
+          onChange(createTreeFromArray(nextValue, {
+            itemKey: 'rowKey',
+            parentKey: 'parentId',
+            childrenKey: 'children'
+          }));
+        }
+      }
+    } else {
+      onChange(_toConsumableArray(value));
     }
   };
+  // 将树平铺
+  var flatTree = transformTreeToArray(value).map(function (item) {
+    return _objectSpread(_objectSpread({}, item), {}, {
+      children: undefined
+    });
+  });
   return draggable && !disabled ? _jsx(DndContext, {
     onDragEnd: onDragEnd,
+    collisionDetection: closestCorners,
     children: _jsx(SortableContext, {
-      items: (value === null || value === void 0 ? void 0 : (_value$ = value[0]) === null || _value$ === void 0 ? void 0 : _value$.rowKey) ? value.map(function (i) {
+      items: (flatTree === null || flatTree === void 0 ? void 0 : (_flatTree$ = flatTree[0]) === null || _flatTree$ === void 0 ? void 0 : _flatTree$.rowKey) ? flatTree.map(function (i) {
         return i.rowKey;
       }) : [],
       strategy: verticalListSortingStrategy,

package/es/ProTable/components/DndWrapper/utils/index.d.ts

@@ -0,0 +1,8 @@
+import { ChildrenKey, Tree, BaseCallbackMeta, BaseInnerOptions, FindCallback, FindOptions, ArrayItemWithParentKey, FromArrayOptions, TreeWithParentKey, TypeOfKey, ForeachOptions, ForeachCallback, ToArrayOptions } from './propsType';
+export declare const getRowKey: (rowKey: any, record: any) => any;
+export declare const addLevelAndParentId: (tree: any[], rowKey: any, currentLevel?: number, currentParentId?: any) => any[];
+export declare function getFinalChildrenKey<T extends ChildrenKey>(tree: Tree<T>, meta: BaseCallbackMeta, options: BaseInnerOptions<T>): ChildrenKey;
+export declare function treeNodeFind<T extends ChildrenKey>(tree: Tree<T> | Tree<T>[], callback: FindCallback<T>, options?: FindOptions): Tree<T> | undefined;
+export declare function createTreeFromArray<K extends TypeOfKey, P extends TypeOfKey, T extends ChildrenKey>(array: ArrayItemWithParentKey<K, P>[], options?: FromArrayOptions): TreeWithParentKey<K, P, T>[];
+export declare function treeForEach<T extends ChildrenKey>(tree: Tree<T> | Tree<T>[], callback: ForeachCallback<T>, options?: ForeachOptions): void;
+export declare function transformTreeToArray<T extends ChildrenKey>(tree: Tree<T> | Tree<T>[], options?: ToArrayOptions): Tree<T>[];

package/es/ProTable/components/DndWrapper/utils/index.js

@@ -0,0 +1,165 @@
+import _toConsumableArray from "@babel/runtime/helpers/esm/toConsumableArray";
+import _objectSpread from "@babel/runtime/helpers/esm/objectSpread2";
+export var getRowKey = function getRowKey(rowKey, record) {
+  // 默认取id
+  var key = record.rowKey || 'id';
+  if (rowKey) {
+    var _ref;
+    key = (_ref = typeof rowKey === 'function' ? rowKey(record) : record[rowKey]) !== null && _ref !== void 0 ? _ref : key;
+  }
+  return key;
+};
+var _addLevelAndParentId = function addLevelAndParentId(tree, rowKey) {
+  var currentLevel = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 0;
+  var currentParentId = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : null;
+  return tree.map(function (node) {
+    var newNode = _objectSpread({}, node);
+    newNode.level = currentLevel;
+    newNode.parentId = currentParentId;
+    newNode.rowKey = getRowKey(rowKey, node);
+    if (node.children) {
+      newNode.children = _addLevelAndParentId(node.children, rowKey, currentLevel + 1, newNode.rowKey);
+    }
+    return newNode;
+  });
+};
+export { _addLevelAndParentId as addLevelAndParentId };
+export function getFinalChildrenKey(tree, meta, options) {
+  if (typeof options.getChildrenKey === 'function') {
+    var dynamicChildrenKey = options.getChildrenKey(tree, meta);
+    if (dynamicChildrenKey != null) {
+      return dynamicChildrenKey;
+    }
+  }
+  return options.childrenKey;
+}
+// 前置深度优先遍历
+var _treeNodePreImpl = function treeNodePreImpl(treeItem, callback, options) {
+  var callbackResult = callback(treeItem, options);
+  if (callbackResult) {
+    return treeItem;
+  }
+  var finalChildrenKey = getFinalChildrenKey(treeItem, options, options);
+  var children = treeItem === null || treeItem === void 0 ? void 0 : treeItem[finalChildrenKey];
+  if (!children || !Array.isArray(children)) {
+    return undefined;
+  }
+  for (var i = 0, count = children.length; i < count; i++) {
+    var childItem = children[i];
+    var findOne = _treeNodePreImpl(childItem, callback, _objectSpread(_objectSpread({}, options), {}, {
+      parents: [].concat(_toConsumableArray(options.parents), [treeItem]),
+      depth: options.depth + 1
+    }));
+    if (findOne) {
+      return findOne;
+    }
+  }
+  return undefined;
+};
+var treeNodeStrategies = {
+  pre: _treeNodePreImpl
+};
+export function treeNodeFind(tree, callback, options) {
+  var _options$childrenKey, _options$strategy;
+  var childrenKey = (_options$childrenKey = options === null || options === void 0 ? void 0 : options.childrenKey) !== null && _options$childrenKey !== void 0 ? _options$childrenKey : 'children';
+  var strategy = (_options$strategy = options === null || options === void 0 ? void 0 : options.strategy) !== null && _options$strategy !== void 0 ? _options$strategy : 'pre';
+  var getChildrenKey = options === null || options === void 0 ? void 0 : options.getChildrenKey;
+  var method = treeNodeStrategies[strategy];
+  var innerOptions = {
+    childrenKey: childrenKey,
+    depth: 0,
+    parents: [],
+    getChildrenKey: getChildrenKey
+  };
+  if (Array.isArray(tree)) {
+    for (var i = 0, count = tree.length; i < count; i++) {
+      var treeItem = tree[i];
+      var result = method(treeItem, callback, innerOptions);
+      if (result) {
+        return result;
+      }
+    }
+    return undefined;
+  }
+  return method(tree, callback, innerOptions);
+}
+export function createTreeFromArray(array, options) {
+  var result = [];
+  var _ref2 = options || {},
+    _ref2$parentKey = _ref2.parentKey,
+    parentKey = _ref2$parentKey === void 0 ? 'pid' : _ref2$parentKey,
+    _ref2$itemKey = _ref2.itemKey,
+    itemKey = _ref2$itemKey === void 0 ? 'id' : _ref2$itemKey,
+    _ref2$childrenKey = _ref2.childrenKey,
+    childrenKey = _ref2$childrenKey === void 0 ? 'children' : _ref2$childrenKey;
+  var map = new Map();
+  array.map(function (item) {
+    var itemKeyValue = item[itemKey];
+    if (!map.get(itemKeyValue)) {
+      map.set(itemKeyValue, item);
+    }
+    return item;
+  });
+  array.map(function (item) {
+    var parentKeyValue = item[parentKey];
+    var parentItem = map.get(parentKeyValue);
+    if (!parentItem || !parentKeyValue) {
+      result.push(item);
+      return;
+    }
+    var siblings = parentItem[childrenKey];
+    if (siblings === null || siblings === undefined) {
+      // disable eslint tslint
+      parentItem[childrenKey] = [item];
+    } else if (Array.isArray(siblings)) {
+      siblings.push(item);
+    } else {
+      var msg = "the key \"".concat(childrenKey, "\" is not an array, please check your data");
+      throw new Error(msg);
+    }
+    return item;
+  });
+  return result;
+}
+// 前置遍历
+var _treeForEachPreImpl = function treeForEachPreImpl(treeItem, callback, options) {
+  callback(treeItem, options);
+  var finalChildrenKey = getFinalChildrenKey(treeItem, options, options);
+  var children = treeItem === null || treeItem === void 0 ? void 0 : treeItem[finalChildrenKey];
+  if (children && Array.isArray(children)) {
+    var nextLevelOptions = _objectSpread(_objectSpread({}, options), {}, {
+      parents: [].concat(_toConsumableArray(options.parents), [treeItem]),
+      depth: options.depth + 1
+    });
+    children.forEach(function (childItem) {
+      _treeForEachPreImpl(childItem, callback, nextLevelOptions);
+    });
+  }
+};
+var treeForEachStrategies = {
+  pre: _treeForEachPreImpl
+};
+export function treeForEach(tree, callback, options) {
+  var _options$childrenKey2, _options$strategy2;
+  var childrenKey = (_options$childrenKey2 = options === null || options === void 0 ? void 0 : options.childrenKey) !== null && _options$childrenKey2 !== void 0 ? _options$childrenKey2 : 'children';
+  var strategy = (_options$strategy2 = options === null || options === void 0 ? void 0 : options.strategy) !== null && _options$strategy2 !== void 0 ? _options$strategy2 : 'pre';
+  var getChildrenKey = options === null || options === void 0 ? void 0 : options.getChildrenKey;
+  var isForest = Array.isArray(tree);
+  var method = treeForEachStrategies[strategy];
+  var innerOptions = {
+    childrenKey: childrenKey,
+    depth: 0,
+    parents: [],
+    getChildrenKey: getChildrenKey
+  };
+  isForest ? tree.forEach(function (tree) {
+    method(tree, callback, innerOptions);
+  }) : method(tree, callback, innerOptions);
+}
+export function transformTreeToArray(tree, options) {
+  var results = [];
+  treeForEach(tree, function (t) {
+    results.push(t);
+  }, options);
+  return results;
+}

package/es/ProTable/components/DndWrapper/utils/propsType.d.ts

@@ -0,0 +1,61 @@
+export type TreeKey = string | number;
+export type ChildrenKey = TreeKey;
+export type Tree<T extends ChildrenKey = 'children'> = {
+    [key in T]?: Tree<T>[];
+} & {
+    [key in TreeKey]: any;
+};
+export type Strategy = 'pre' | 'post' | 'breadth';
+export interface BaseOptions {
+    itemKey?: String;
+    parentKey?: String;
+    childrenKey?: ChildrenKey;
+    strategy?: Strategy;
+    getChildrenKey?: (tree: Tree, meta: BaseCallbackMeta) => ChildrenKey | undefined;
+}
+export interface BaseInnerOptions<T extends ChildrenKey = 'children'> {
+    childrenKey: ChildrenKey;
+    parents: Tree<T>[];
+    depth: number;
+    getChildrenKey?: (tree: Tree, meta: BaseCallbackMeta) => ChildrenKey | undefined;
+}
+export interface BaseCallbackMeta<T extends ChildrenKey = 'children'> {
+    depth: number;
+    parents?: Tree<T>[];
+}
+export type FindOptions = BaseOptions;
+export type FindCallbackMeta<T extends ChildrenKey> = BaseCallbackMeta<T>;
+export type FindCallback<T extends ChildrenKey> = (treeItem: Tree<T>, meta: FindCallbackMeta<T>) => boolean | undefined;
+type FindInnerOption<T extends ChildrenKey> = BaseInnerOptions<T>;
+export type FindImpl<T extends ChildrenKey> = (treeItem: Tree<T>, callback: FindCallback<T>, options: FindInnerOption<T>) => Tree<T> | undefined;
+export interface QueueItem {
+    tree: Tree<ChildrenKey>;
+    options: FindInnerOption<ChildrenKey>;
+}
+export type TypeOfKey = string;
+export type KeyValue = string | number | undefined | null;
+export type ArrayItemWithParentKey<P extends TypeOfKey, K extends TypeOfKey> = Record<string, any> & {
+    [key in P]?: KeyValue;
+} & {
+    [key in K]?: KeyValue;
+};
+export type TreeWithParentKey<K extends TypeOfKey, P extends TypeOfKey, T extends ChildrenKey> = Record<string, any> & {
+    [key in P]?: KeyValue;
+} & {
+    [key in K]: KeyValue;
+} & {
+    [key in T]?: TreeWithParentKey<K, P, T>[];
+};
+export interface FromArrayOptions {
+    parentKey?: TypeOfKey;
+    itemKey?: TypeOfKey;
+    childrenKey?: ChildrenKey;
+}
+export type FromArray<K extends TypeOfKey, P extends TypeOfKey, T extends ChildrenKey> = (array: ArrayItemWithParentKey<K, P>[], options: FromArrayOptions) => TreeWithParentKey<K, P, T>[];
+export type ForeachOptions = BaseOptions;
+export type ForeachCallbackMeta<T extends ChildrenKey> = BaseCallbackMeta<T>;
+export type ForeachCallback<T extends ChildrenKey> = (treeItem: Tree<T>, meta: ForeachCallbackMeta<T>) => void;
+export type ForeachInnerOption<T extends ChildrenKey> = BaseInnerOptions<T>;
+export type ForeachImpl<T extends ChildrenKey> = (treeItem: Tree<T>, callback: ForeachCallback<T>, options: ForeachInnerOption<T>) => void;
+export type ToArrayOptions = ForeachOptions;
+export {};

package/es/ProTable/components/DndWrapper/utils/propsType.js

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

package/es/ProTable/components/ResizableLine/index.d.ts

@@ -1,2 +1,2 @@
-declare const ResizableLine: () => JSX.Element;
+declare const ResizableLine: () => import("react/jsx-runtime").JSX.Element;
 export default ResizableLine;

package/es/ProTable/components/TableResizable/index.d.ts

@@ -6,7 +6,7 @@ declare const _default: {
                 onDrag: any;
                 width: number;
                 minwidth?: number;
-            }) => JSX.Element;
+            }) => import("react/jsx-runtime").JSX.Element;
         };
     };
 };

package/es/ProTable/index.d.ts

@@ -5,7 +5,7 @@ export declare const defaultPage: {
     pageNum: number;
     pageSize: number;
 };
-declare function ProTable(props: ProTableProps): JSX.Element;
+declare function ProTable(props: ProTableProps): import("react/jsx-runtime").JSX.Element;
 declare namespace ProTable {
     var defaultProps: {
         quickConfig: boolean;

package/es/ProTable/index.js

@@ -370,6 +370,7 @@ function ProTable(props) {
         onChange: onDataSourceChange,
         disabled: false,
         draggable: draggable,
+        rowKey: rowKey,
         children: [(headerRender || columnConfig || resizeColumn) && _jsxs("div", {
           className: "column-config",
           children: [_jsx("div", {

package/es/ProTable/propsType.d.ts

@@ -72,11 +72,12 @@ export interface PaginationProps {
     pageNum: number;
     pageSize: number;
 }
+type RowSelectionTypeWithPick = Pick<TableProps<any>, 'rowSelection'>['rowSelection'];
 export interface RequestOptions<T, R> {
     form?: FormInstance;
     isResetQuery?: boolean;
     rowKey?: string | GetRowKey<R>;
-    rowSelection?: boolean;
+    rowSelection?: boolean | RowSelectionTypeWithPick;
     rowSelectType?: RowSelectionType;
     rowSelections?: boolean;
     extraParams?: Partial<T>;

package/es/ProTable/style/index.less

@@ -9,6 +9,15 @@
       }
     }
   }
+  .@{ant-prefix}-table-cell-with-append {
+    white-space: nowrap;
+    position: relative;
+    z-index: 100;
+  }
+  .@{ant-prefix}-table-row-expand-icon {
+    position: absolute;
+    left: -16px;
+  }
 
   .@{ant-prefix}-table-content {
     >table {

package/es/ProTable/useAntdTable.d.ts

@@ -11,7 +11,7 @@ declare function useAntdTable<I, R extends Record<string, any>, S extends Servic
         selectedRowKeys: Key[];
         onChange(rowKeys: Key[], rows: any[]): void;
         onSelectAll: (selected: boolean) => void;
-        getCheckboxProps: () => {
+        getCheckboxProps: (record?: any) => {
             className: string;
         };
         selections: boolean | ({
@@ -57,7 +57,7 @@ declare function useAntdTable<I, R extends Record<string, any>, S extends Servic
             selectedRowKeys: Key[];
             onChange(rowKeys: Key[], rows: any[]): void;
             onSelectAll: (selected: boolean) => void;
-            getCheckboxProps: () => {
+            getCheckboxProps: (record?: any) => {
                 className: string;
             };
             selections: boolean | ({

package/es/ProTable/useAntdTable.js

@@ -9,7 +9,7 @@ import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
 var _excluded = ["page", "filters", "sorter"];
 import { useCallback, useMemo, useState } from 'react';
 import { useRequest, useSetState, useDeepCompareEffect } from 'ahooks';
-import { pickBy } from 'lodash';
+import { pickBy, isObject, merge, set, isEqual } from 'lodash';
 import { defaultPage } from './index';
 import { isListResult } from './utils';
 import locale, { formatMessage } from '../locale';
@@ -313,7 +313,7 @@ function useAntdTable(service, options, useRequestOptions) {
       }));
     }
   }, [extraParams]);
-  var rowSelection = {
+  var _rowSelection = {
     fixed: true,
     type: rowSelectType,
     columnWidth: rowSelections ? 64 : undefined,
@@ -355,7 +355,7 @@ function useAntdTable(service, options, useRequestOptions) {
         });
       }
     },
-    getCheckboxProps: function getCheckboxProps() {
+    getCheckboxProps: function getCheckboxProps(record) {
       return {
         className: allSelected && rowSelections ? 'checkbox-disabled' : ''
       };
@@ -424,6 +424,20 @@ function useAntdTable(service, options, useRequestOptions) {
       }()
     }] : false
   };
+  var rowSelection = isObject(returnRowSelection) ? merge(_rowSelection, returnRowSelection) : _rowSelection;
+  if (isObject(returnRowSelection) && !isEqual(rowSelection, _rowSelection)) {
+    // getCheckboxProps需要特殊兼容原有的逻辑，特殊处理
+    var isHasGetCheckboxProps = Reflect.ownKeys(returnRowSelection).includes('getCheckboxProps');
+    if (isHasGetCheckboxProps) {
+      set(rowSelection, 'getCheckboxProps', function (record) {
+        var _rowSelection$getChec;
+        var passReturnObjects = (_rowSelection$getChec = rowSelection.getCheckboxProps(record)) !== null && _rowSelection$getChec !== void 0 ? _rowSelection$getChec : {};
+        return _objectSpread({
+          className: allSelected && rowSelections ? 'checkbox-disabled' : ''
+        }, passReturnObjects);
+      });
+    }
+  }
   var selectedTip = allSelected || selectedRowKeys.length ? formatMessage(locale === null || locale === void 0 ? void 0 : (_locale$ProTable5 = locale.ProTable) === null || _locale$ProTable5 === void 0 ? void 0 : _locale$ProTable5.selectAll, {
     selectedNum: allSelected ? total : selectedRowKeys === null || selectedRowKeys === void 0 ? void 0 : selectedRowKeys.length
   }) : null;

package/es/ProTable/utils.js

@@ -382,15 +382,15 @@ export var getParentElement = function getParentElement(element, name) {
   if (!element || !name) {
     return result;
   }
-  var searchDom = function searchDom(element, name) {
+  var _searchDom = function searchDom(element, name) {
     var type = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 'className';
     if (element.parentElement[type] === name) {
       result = element.parentElement;
       return false;
     }
-    searchDom(element.parentElement, name, type = 'className');
+    _searchDom(element.parentElement, name, type = 'className');
   };
-  searchDom(element, name, type = 'className');
+  _searchDom(element, name, type = 'className');
   return result;
 };
 /**

package/es/ProTabs/components/Card/index.d.ts

@@ -1,3 +1,3 @@
 import { CardProps } from '../../propType';
-declare const Card: (props: CardProps) => JSX.Element;
+declare const Card: (props: CardProps) => import("react/jsx-runtime").JSX.Element;
 export default Card;

package/es/ProThemeTools/component/PrdTools/index.d.ts

@@ -1,3 +1,3 @@
 import type { DevToolsPropsType } from '../../propsType';
-declare const PrdTools: ({ onReset, onClose, setState, open, state, tableBorder, tableStripe, }: DevToolsPropsType) => JSX.Element;
+declare const PrdTools: ({ onReset, onClose, setState, open, state, tableBorder, tableStripe, }: DevToolsPropsType) => import("react/jsx-runtime").JSX.Element;
 export default PrdTools;

package/es/ProThemeTools/index.d.ts

@@ -1,6 +1,6 @@
 import type { ProThemeToolsProps } from './propsType';
 declare const ProThemeTools: {
-    ({ size, className, cacheTime, color, mode, iconFollowTheme, prefixCls, tableBorder, tableStripe, theme, onChange, ...props }: ProThemeToolsProps): JSX.Element;
+    ({ size, className, cacheTime, color, mode, iconFollowTheme, prefixCls, tableBorder, tableStripe, theme, onChange, ...props }: ProThemeToolsProps): import("react/jsx-runtime").JSX.Element;
     defaultProps: {
         size: number;
         mode: string;