@dtjoy/dt-design 1.1.2 → 1.1.5

package/es/table/components/VirtualTableBody/index.js

@@ -0,0 +1,102 @@
+function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
+function _extends() { _extends = Object.assign ? Object.assign.bind() : function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : String(i); }
+function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+import { clsx } from 'clsx';
+import getValue from 'rc-util/lib/utils/get';
+import useEvent from "../../../_util/hooks/useEvent";
+import warning from 'rc-util/lib/warning';
+import * as React from 'react';
+import { INTERNAL_HOOKS } from "../../constant";
+import { makeImmutable } from "../../shared/context/TableContext";
+import Table, { DEFAULT_PREFIX } from "../RcTable";
+import Grid from "./BodyGrid";
+import { StaticContext } from "./context";
+var renderBody = function renderBody(rawData, props) {
+  var ref = props.ref,
+    onScroll = props.onScroll;
+  return /*#__PURE__*/React.createElement(Grid, {
+    ref: ref,
+    data: rawData,
+    onScroll: onScroll
+  });
+};
+var VirtualTable = function VirtualTable(props, ref) {
+  var data = props.data,
+    columns = props.columns,
+    scroll = props.scroll,
+    _props$sticky = props.sticky,
+    sticky = _props$sticky === void 0 ? false : _props$sticky,
+    _props$prefixCls = props.prefixCls,
+    prefixCls = _props$prefixCls === void 0 ? DEFAULT_PREFIX : _props$prefixCls,
+    className = props.className,
+    _props$listItemHeight = props.listItemHeight,
+    listItemHeight = _props$listItemHeight === void 0 ? 24 : _props$listItemHeight,
+    components = props.components,
+    onScroll = props.onScroll;
+  var _ref = scroll || {},
+    scrollX = _ref.x,
+    scrollY = _ref.y;
+
+  // Fill scrollX
+  if (typeof scrollX !== 'number') {
+    if (process.env.NODE_ENV !== 'production') {
+      warning(false, '`scroll.x` in virtual table must be number.');
+    }
+    scrollX = 1;
+  }
+
+  // Fill scrollY
+  if (typeof scrollY !== 'number') {
+    scrollY = 500;
+    if (process.env.NODE_ENV !== 'production') {
+      warning(false, '`scroll.y` in virtual table must be number.');
+    }
+  }
+  var getComponent = useEvent(function (path, defaultComponent) {
+    return getValue(components, path) || defaultComponent;
+  });
+
+  // Memo this
+  var onInternalScroll = useEvent(onScroll !== null && onScroll !== void 0 ? onScroll : function () {});
+
+  // ========================= Context ==========================
+  var context = React.useMemo(function () {
+    return {
+      sticky: sticky,
+      scrollY: scrollY,
+      listItemHeight: listItemHeight,
+      getComponent: getComponent,
+      onScroll: onInternalScroll
+    };
+  }, [sticky, scrollY, listItemHeight, getComponent, onInternalScroll]);
+
+  // ========================== Render ==========================
+  return /*#__PURE__*/React.createElement(StaticContext.Provider, {
+    value: context
+  }, /*#__PURE__*/React.createElement(Table, _extends({}, props, {
+    className: clsx(className, "".concat(prefixCls, "-virtual")),
+    scroll: _objectSpread(_objectSpread({}, scroll), {}, {
+      x: scrollX
+    }),
+    components: _objectSpread(_objectSpread({}, components), {}, {
+      // fix https://github.com/ant-design/ant-design/issues/48991
+      body: data !== null && data !== void 0 && data.length ? renderBody : undefined
+    }),
+    columns: columns,
+    internalHooks: INTERNAL_HOOKS,
+    tailor: true,
+    ref: ref
+  })));
+};
+var RefVirtualTable = /*#__PURE__*/React.forwardRef(VirtualTable);
+if (process.env.NODE_ENV !== 'production') {
+  RefVirtualTable.displayName = 'VirtualTable';
+}
+export var genVirtualTable = function genVirtualTable(shouldTriggerRender) {
+  return makeImmutable(RefVirtualTable, shouldTriggerRender);
+};
+export default genVirtualTable();

package/es/table/constant.d.ts

@@ -0,0 +1,2 @@
+export declare const EXPAND_COLUMN: {};
+export declare const INTERNAL_HOOKS = "rc-table-internal-hook";

package/es/table/constant.js

@@ -0,0 +1,2 @@
+export var EXPAND_COLUMN = {};
+export var INTERNAL_HOOKS = 'rc-table-internal-hook';

package/es/table/features/columns/Column.d.ts

@@ -0,0 +1,7 @@
+import type { AnyObject } from '../../../_util/type';
+import type { ColumnType } from '../../interface';
+export interface ColumnProps<RecordType = AnyObject> extends ColumnType<RecordType> {
+    children?: null;
+}
+declare const Column: <RecordType extends AnyObject>(_: ColumnProps<RecordType>) => null;
+export default Column;

package/es/table/features/columns/Column.js

@@ -0,0 +1,4 @@
+var Column = function Column(_) {
+  return null;
+};
+export default Column;

package/es/table/features/columns/ColumnGroup.d.ts

@@ -0,0 +1,9 @@
+import type * as React from 'react';
+import type { AnyObject } from '../../../_util/type';
+import type { ColumnProps } from './Column';
+import type { ColumnType } from '../../interface';
+export interface ColumnGroupProps<RecordType = AnyObject> extends Omit<ColumnType<RecordType>, 'children'> {
+    children: React.ReactElement<ColumnProps<RecordType>> | React.ReactElement<ColumnProps<RecordType>>[];
+}
+declare const ColumnGroup: <RecordType extends AnyObject>(_: ColumnGroupProps<RecordType>) => null;
+export default ColumnGroup;

package/es/table/features/columns/ColumnGroup.js

@@ -0,0 +1,4 @@
+var ColumnGroup = function ColumnGroup(_) {
+  return null;
+};
+export default ColumnGroup;

package/es/table/features/columns/index.d.ts

@@ -0,0 +1,8 @@
+export { default as Column } from './Column';
+export type { ColumnProps } from './Column';
+export { default as ColumnGroup } from './ColumnGroup';
+export type { ColumnGroupProps } from './ColumnGroup';
+export { convertChildrenToColumns, default as useColumns } from './useColumns';
+export { default as useFilledColumns } from './useFilledColumns';
+export { default as useTitleColumns } from './useTitleColumns';
+export { default as useWidthColumns } from './useWidthColumns';

package/es/table/features/columns/index.js

@@ -0,0 +1,6 @@
+export { default as Column } from "./Column";
+export { default as ColumnGroup } from "./ColumnGroup";
+export { convertChildrenToColumns, default as useColumns } from "./useColumns";
+export { default as useFilledColumns } from "./useFilledColumns";
+export { default as useTitleColumns } from "./useTitleColumns";
+export { default as useWidthColumns } from "./useWidthColumns";

package/es/table/features/columns/useColumns.d.ts

@@ -0,0 +1,31 @@
+import * as React from 'react';
+import type { ColumnsType, ColumnType, Direction, FixedType, GetRowKey, Key, RenderExpandIcon, TriggerEventHandler } from '../../interface';
+export declare function convertChildrenToColumns<RecordType>(children: React.ReactNode): ColumnsType<RecordType>;
+/**
+ * Parse `columns` & `children` into `columns`.
+ */
+declare function useColumns<RecordType>({ prefixCls, columns, children, expandable, expandedKeys, columnTitle, getRowKey, onTriggerExpand, expandIcon, rowExpandable, expandIconColumnIndex, expandedRowOffset, direction, expandRowByClick, columnWidth, fixed, scrollWidth, clientWidth, }: {
+    prefixCls?: string;
+    columns?: ColumnsType<RecordType>;
+    children?: React.ReactNode;
+    expandable: boolean;
+    expandedKeys: Set<Key>;
+    columnTitle?: React.ReactNode;
+    getRowKey: GetRowKey<RecordType>;
+    onTriggerExpand: TriggerEventHandler<RecordType>;
+    expandIcon: RenderExpandIcon<RecordType>;
+    rowExpandable?: (record: RecordType) => boolean;
+    expandIconColumnIndex?: number;
+    direction?: Direction;
+    expandRowByClick?: boolean;
+    columnWidth?: number | string;
+    clientWidth: number;
+    fixed?: FixedType;
+    scrollWidth?: number | null;
+    expandedRowOffset?: number;
+}, transformColumns: (columns: ColumnsType<RecordType>) => ColumnsType<RecordType>): [
+    columns: ColumnsType<RecordType>,
+    flattenColumns: readonly ColumnType<RecordType>[],
+    realScrollWidth: undefined | number
+];
+export default useColumns;

package/es/table/features/columns/useColumns.js

@@ -0,0 +1,227 @@
+var _excluded = ["children"];
+function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }
+function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+function _iterableToArrayLimit(r, l) { var t = null == r ? null : "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (null != t) { var e, n, i, u, a = [], f = !0, o = !1; try { if (i = (t = t.call(r)).next, 0 === l) { if (Object(t) !== t) return; f = !1; } else for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = !0); } catch (r) { o = !0, n = r; } finally { try { if (!f && null != t.return && (u = t.return(), Object(u) !== u)) return; } finally { if (o) throw n; } } return a; } }
+function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
+function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); }
+function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+function _iterableToArray(iter) { if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter); }
+function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) return _arrayLikeToArray(arr); }
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; }
+function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : String(i); }
+function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; }
+function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; }
+import toArray from 'rc-util/lib/Children/toArray';
+import warning from 'rc-util/lib/warning';
+import * as React from 'react';
+import { EXPAND_COLUMN } from "../../constant";
+import { INTERNAL_COL_DEFINE } from "../../shared/utils/legacyUtil";
+import useWidthColumns from "./useWidthColumns";
+export function convertChildrenToColumns(children) {
+  return toArray(children).filter(function (node) {
+    return /*#__PURE__*/React.isValidElement(node);
+  }).map(function (node) {
+    var _ref = node,
+      key = _ref.key,
+      props = _ref.props;
+    var nodeChildren = props.children,
+      restProps = _objectWithoutProperties(props, _excluded);
+    var column = _objectSpread({
+      key: key
+    }, restProps);
+    if (nodeChildren) {
+      column.children = convertChildrenToColumns(nodeChildren);
+    }
+    return column;
+  });
+}
+function filterHiddenColumns(columns) {
+  return columns.filter(function (column) {
+    return column && _typeof(column) === 'object' && !column.hidden;
+  }).map(function (column) {
+    var subColumns = column.children;
+    if (subColumns && subColumns.length > 0) {
+      return _objectSpread(_objectSpread({}, column), {}, {
+        children: filterHiddenColumns(subColumns)
+      });
+    }
+    return column;
+  });
+}
+function flatColumns(columns) {
+  var parentKey = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 'key';
+  return columns.filter(function (column) {
+    return column && _typeof(column) === 'object';
+  }).reduce(function (list, column, index) {
+    var fixed = column.fixed;
+    var parsedFixed = fixed === true || fixed === 'left' ? 'start' : fixed === 'right' ? 'end' : fixed;
+    var mergedKey = "".concat(parentKey, "-").concat(index);
+    var subColumns = column.children;
+    if (subColumns && subColumns.length > 0) {
+      return [].concat(_toConsumableArray(list), _toConsumableArray(flatColumns(subColumns, mergedKey).map(function (subColum) {
+        var _subColum$fixed;
+        return _objectSpread(_objectSpread({}, subColum), {}, {
+          fixed: (_subColum$fixed = subColum.fixed) !== null && _subColum$fixed !== void 0 ? _subColum$fixed : parsedFixed
+        });
+      })));
+    }
+    return [].concat(_toConsumableArray(list), [_objectSpread(_objectSpread({
+      key: mergedKey
+    }, column), {}, {
+      fixed: parsedFixed
+    })]);
+  }, []);
+}
+
+/**
+ * Parse `columns` & `children` into `columns`.
+ */
+function useColumns(_ref2, transformColumns) {
+  var prefixCls = _ref2.prefixCls,
+    columns = _ref2.columns,
+    children = _ref2.children,
+    expandable = _ref2.expandable,
+    expandedKeys = _ref2.expandedKeys,
+    columnTitle = _ref2.columnTitle,
+    getRowKey = _ref2.getRowKey,
+    onTriggerExpand = _ref2.onTriggerExpand,
+    expandIcon = _ref2.expandIcon,
+    rowExpandable = _ref2.rowExpandable,
+    expandIconColumnIndex = _ref2.expandIconColumnIndex,
+    _ref2$expandedRowOffs = _ref2.expandedRowOffset,
+    expandedRowOffset = _ref2$expandedRowOffs === void 0 ? 0 : _ref2$expandedRowOffs,
+    direction = _ref2.direction,
+    expandRowByClick = _ref2.expandRowByClick,
+    columnWidth = _ref2.columnWidth,
+    fixed = _ref2.fixed,
+    scrollWidth = _ref2.scrollWidth,
+    clientWidth = _ref2.clientWidth;
+  var baseColumns = React.useMemo(function () {
+    var newColumns = columns || convertChildrenToColumns(children) || [];
+    return filterHiddenColumns(newColumns.slice());
+  }, [columns, children]);
+
+  // ========================== Expand ==========================
+  var withExpandColumns = React.useMemo(function () {
+    if (expandable) {
+      var cloneColumns = baseColumns.slice();
+
+      // >>> Warning if use `expandIconColumnIndex`
+      if (process.env.NODE_ENV !== 'production' && (expandIconColumnIndex !== null && expandIconColumnIndex !== void 0 ? expandIconColumnIndex : -1) >= 0) {
+        warning(false, '`expandIconColumnIndex` is deprecated. Please use `Table.EXPAND_COLUMN` in `columns` instead.');
+      }
+
+      // >>> Insert expand column if not exist
+      if (!cloneColumns.includes(EXPAND_COLUMN)) {
+        var expandColIndex = expandIconColumnIndex || 0;
+        var insertIndex = expandColIndex === 0 && (fixed === 'right' || fixed === 'end') ? baseColumns.length : expandColIndex;
+        if (insertIndex >= 0) {
+          cloneColumns.splice(insertIndex, 0, EXPAND_COLUMN);
+        }
+      }
+
+      // >>> Deduplicate additional expand column
+      if (process.env.NODE_ENV !== 'production' && cloneColumns.filter(function (c) {
+        return c === EXPAND_COLUMN;
+      }).length > 1) {
+        warning(false, 'There exist more than one `EXPAND_COLUMN` in `columns`.');
+      }
+      var expandColumnIndex = cloneColumns.indexOf(EXPAND_COLUMN);
+      cloneColumns = cloneColumns.filter(function (column, index) {
+        return column !== EXPAND_COLUMN || index === expandColumnIndex;
+      });
+
+      // >>> Check if expand column need to fixed
+      var prevColumn = baseColumns[expandColumnIndex];
+      var fixedColumn;
+      if (fixed) {
+        fixedColumn = fixed;
+      } else {
+        // Keep the runtime value of `prevColumn.fixed` untouched (it may be `undefined`)
+        fixedColumn = prevColumn ? prevColumn.fixed : null;
+      }
+
+      // >>> Create expandable column
+      var expandColumn = _defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty({}, INTERNAL_COL_DEFINE, {
+        className: "".concat(prefixCls, "-expand-icon-col"),
+        columnType: 'EXPAND_COLUMN'
+      }), "title", columnTitle), "fixed", fixedColumn), "className", "".concat(prefixCls, "-row-expand-icon-cell")), "width", columnWidth), "render", function render(_, record, index) {
+        var rowKey = getRowKey(record, index);
+        var expanded = expandedKeys.has(rowKey);
+        var recordExpandable = rowExpandable ? rowExpandable(record) : true;
+        var icon = expandIcon({
+          // `prefixCls` is optional in the options but always provided by the caller;
+          // pass the value through as-is.
+          prefixCls: prefixCls,
+          expanded: expanded,
+          expandable: recordExpandable,
+          record: record,
+          onExpand: onTriggerExpand
+        });
+        if (expandRowByClick) {
+          return /*#__PURE__*/React.createElement("span", {
+            onClick: function onClick(e) {
+              return e.stopPropagation();
+            }
+          }, icon);
+        }
+        return icon;
+      });
+      return cloneColumns.map(function (col, index) {
+        var column = col === EXPAND_COLUMN ? expandColumn : col;
+        if (index < expandedRowOffset) {
+          return _objectSpread(_objectSpread({}, column), {}, {
+            fixed: column.fixed || 'start'
+          });
+        }
+        return column;
+      });
+    }
+    if (process.env.NODE_ENV !== 'production' && baseColumns.includes(EXPAND_COLUMN)) {
+      warning(false, '`expandable` is not config but there exist `EXPAND_COLUMN` in `columns`.');
+    }
+    return baseColumns.filter(function (col) {
+      return col !== EXPAND_COLUMN;
+    });
+  }, [expandable, baseColumns, getRowKey, expandedKeys, expandIcon, direction, expandedRowOffset]);
+
+  // ========================= Transform ========================
+  var mergedColumns = React.useMemo(function () {
+    var finalColumns = withExpandColumns;
+    if (transformColumns) {
+      finalColumns = transformColumns(finalColumns);
+    }
+
+    // Always provides at least one column for table display
+    if (!finalColumns.length) {
+      finalColumns = [{
+        render: function render() {
+          return null;
+        }
+      }];
+    }
+    return finalColumns;
+  }, [transformColumns, withExpandColumns, direction]);
+
+  // ========================== Flatten =========================
+  var flattenColumns = React.useMemo(function () {
+    return flatColumns(mergedColumns);
+  }, [mergedColumns, direction, scrollWidth]);
+
+  // ========================= FillWidth ========================
+  var _useWidthColumns = useWidthColumns(flattenColumns,
+    // `useWidthColumns` treats falsy values uniformly and returns `scrollWidth`
+    // verbatim, so pass the value through as-is.
+    scrollWidth, clientWidth),
+    _useWidthColumns2 = _slicedToArray(_useWidthColumns, 2),
+    filledColumns = _useWidthColumns2[0],
+    realScrollWidth = _useWidthColumns2[1];
+  return [mergedColumns, filledColumns, realScrollWidth];
+}
+export default useColumns;

package/es/table/features/columns/useFilledColumns.d.ts

@@ -0,0 +1,4 @@
+import type { AnyObject } from '../../../_util/type';
+import type { ColumnsType, ColumnType } from '../../interface';
+declare const useFilledColumns: <RecordType extends AnyObject = AnyObject>(columns: ColumnsType<RecordType>, column?: Partial<ColumnType<RecordType>>) => ColumnsType<RecordType>;
+export default useFilledColumns;

package/es/table/features/columns/useFilledColumns.js

@@ -0,0 +1,34 @@
+function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : String(i); }
+function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+import * as React from 'react';
+import { EXPAND_COLUMN } from "../../constant";
+import { mergeProps, omit } from "../../../_util/rcUtil";
+import { SELECTION_COLUMN } from "../selection/useSelection";
+var useFilledColumns = function useFilledColumns(columns, column) {
+  return React.useMemo(function () {
+    if (!column) {
+      return columns;
+    }
+    var fillColumns = function fillColumns(currentColumns) {
+      return currentColumns.map(function (col) {
+        if (col === SELECTION_COLUMN || col === EXPAND_COLUMN) {
+          return col;
+        }
+        if ('children' in col && Array.isArray(col.children)) {
+          var mergedColumn = mergeProps(column, col);
+          return _objectSpread(_objectSpread({}, mergedColumn), {}, {
+            children: fillColumns(col.children)
+          });
+        }
+        var columnWithoutChildren = omit(column, ['children']);
+        return mergeProps(columnWithoutChildren, col);
+      });
+    };
+    return fillColumns(columns);
+  }, [columns, column]);
+};
+export default useFilledColumns;

package/es/table/features/columns/useTitleColumns.d.ts

@@ -0,0 +1,4 @@
+import type { AnyObject } from '../../../_util/type';
+import type { ColumnTitleProps, TransformColumns } from '../../interface';
+declare const useTitleColumns: <RecordType extends AnyObject = AnyObject>(columnTitleProps: ColumnTitleProps<RecordType>) => readonly [TransformColumns<RecordType>];
+export default useTitleColumns;

package/es/table/features/columns/useTitleColumns.js

@@ -0,0 +1,26 @@
+function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : String(i); }
+function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+import * as React from 'react';
+import { renderColumnTitle } from "../../shared/utils/util";
+var fillTitle = function fillTitle(columns, columnTitleProps) {
+  var finalColumns = columns.map(function (column) {
+    var cloneColumn = _objectSpread({}, column);
+    cloneColumn.title = renderColumnTitle(column.title, columnTitleProps);
+    if ('children' in cloneColumn) {
+      cloneColumn.children = fillTitle(cloneColumn.children, columnTitleProps);
+    }
+    return cloneColumn;
+  });
+  return finalColumns;
+};
+var useTitleColumns = function useTitleColumns(columnTitleProps) {
+  var filledColumns = React.useCallback(function (columns) {
+    return fillTitle(columns, columnTitleProps);
+  }, [columnTitleProps]);
+  return [filledColumns];
+};
+export default useTitleColumns;

package/es/table/features/columns/useWidthColumns.d.ts

@@ -0,0 +1,5 @@
+import type { ColumnsType } from '../../interface';
+/**
+ * Fill all column with width
+ */
+export default function useWidthColumns(flattenColumns: ColumnsType<any>, scrollWidth: number, clientWidth: number): [columns: ColumnsType<any>, realScrollWidth: number];

package/es/table/features/columns/useWidthColumns.js

@@ -0,0 +1,75 @@
+function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : String(i); }
+function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+import * as React from 'react';
+function parseColWidth(totalWidth) {
+  var width = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : '';
+  if (typeof width === 'number') {
+    return width;
+  }
+  if (width.endsWith('%')) {
+    return totalWidth * Number.parseFloat(width) / 100;
+  }
+  return null;
+}
+
+/**
+ * Fill all column with width
+ */
+export default function useWidthColumns(flattenColumns, scrollWidth, clientWidth) {
+  return React.useMemo(function () {
+    // Fill width if needed
+    if (scrollWidth && scrollWidth > 0) {
+      var totalWidth = 0;
+      var missWidthCount = 0;
+
+      // collect not given width column
+      flattenColumns.forEach(function (col) {
+        var colWidth = parseColWidth(scrollWidth, col.width);
+        if (colWidth) {
+          totalWidth += colWidth;
+        } else {
+          missWidthCount += 1;
+        }
+      });
+
+      // Fill width
+      var maxFitWidth = Math.max(scrollWidth, clientWidth);
+      var restWidth = Math.max(maxFitWidth - totalWidth, missWidthCount);
+      var restCount = missWidthCount;
+      var avgWidth = restWidth / missWidthCount;
+      var realTotal = 0;
+      var filledColumns = flattenColumns.map(function (col) {
+        var clone = _objectSpread({}, col);
+        var colWidth = parseColWidth(scrollWidth, clone.width);
+        if (colWidth) {
+          clone.width = colWidth;
+        } else {
+          var colAvgWidth = Math.floor(avgWidth);
+          clone.width = restCount === 1 ? restWidth : colAvgWidth;
+          restWidth -= colAvgWidth;
+          restCount -= 1;
+        }
+        realTotal += clone.width;
+        return clone;
+      });
+
+      // If realTotal is less than clientWidth,
+      // We need extend column width
+      if (realTotal < maxFitWidth) {
+        var scale = maxFitWidth / realTotal;
+        restWidth = maxFitWidth;
+        filledColumns.forEach(function (col, index) {
+          var colWidth = Math.floor(col.width * scale);
+          col.width = index === filledColumns.length - 1 ? restWidth : colWidth;
+          restWidth -= colWidth;
+        });
+      }
+      return [filledColumns, Math.max(realTotal, maxFitWidth)];
+    }
+    return [flattenColumns, scrollWidth];
+  }, [flattenColumns, scrollWidth, clientWidth]);
+}

package/es/table/features/editable/BatchEditModal.d.ts

@@ -0,0 +1,4 @@
+import * as React from 'react';
+import type { BatchEditModalProps } from './batchEditTypes';
+declare const BatchEditModal: React.FC<BatchEditModalProps>;
+export default BatchEditModal;