@qsxy/element-plus-react 1.0.0-next.1

package/dist/Table/TableColumn.js

@@ -0,0 +1,51 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/Table/TableColumn.tsx
+var TableColumn_exports = {};
+__export(TableColumn_exports, {
+  default: () => TableColumn_default
+});
+module.exports = __toCommonJS(TableColumn_exports);
+var import_react = __toESM(require("react"));
+var import_hooks = require("../hooks");
+var TableColumn = (props) => {
+  const getChildren = (0, import_hooks.useChildrenInstance)("TableColumn");
+  if (props.children instanceof Function) {
+    return /* @__PURE__ */ import_react.default.createElement("div", null);
+  } else {
+    const columns = props.children ? getChildren(props.children) : [];
+    return /* @__PURE__ */ import_react.default.createElement("div", null, columns);
+  }
+};
+TableColumn.defaultProps = {
+  resizable: true,
+  filterMultiple: true
+};
+TableColumn.displayName = "TableColumn";
+var TableColumn_default = TableColumn;

package/dist/Table/TableContext.d.ts

@@ -0,0 +1,37 @@
+import { MutableRefObject } from 'react';
+import { Action, State } from './hooks/useSelection';
+import { TableColumnCtx, TableProps, TableRefs, TreeNode } from './typings';
+export interface TableContextProps<T> {
+    tableId: string;
+    columns: TableColumnCtx<T>[][];
+    flattenColumns: TableColumnCtx<T>[];
+    fixedLeftColumns: TableColumnCtx<T>[];
+    fixedRightColumns: TableColumnCtx<T>[];
+    tableRefs: TableRefs;
+    props: Omit<TableProps<T>, 'children'>;
+    data: T[];
+    setData: (data: T[]) => void;
+}
+export interface TableHeaderContextProps {
+    sortProp?: string;
+    setSortProp: (sortProp?: string) => void;
+    init: MutableRefObject<boolean | null>;
+}
+export interface TableBodyContextProps<T> {
+    oldActiveRow: MutableRefObject<T | null | undefined>;
+    state: State<T>;
+    dispatch: (action: Action) => void;
+    initialData: MutableRefObject<T[]>;
+    sortedData: MutableRefObject<T[]>;
+    disabledRows: MutableRefObject<T[]>;
+    isTreeTable: () => boolean;
+    isTreeExpandCell: (id: string) => boolean;
+    treeProps: {
+        hasChildren: string;
+        children: string;
+    };
+    treeNodes: MutableRefObject<TreeNode[]>;
+}
+export declare const TableContext: import("react").Context<TableContextProps<any>>;
+export declare const TableHeaderContext: import("react").Context<TableHeaderContextProps>;
+export declare const TableBodyContext: import("react").Context<TableBodyContextProps<any>>;

package/dist/Table/TableContext.js

@@ -0,0 +1,72 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/Table/TableContext.ts
+var TableContext_exports = {};
+__export(TableContext_exports, {
+  TableBodyContext: () => TableBodyContext,
+  TableContext: () => TableContext,
+  TableHeaderContext: () => TableHeaderContext
+});
+module.exports = __toCommonJS(TableContext_exports);
+var import_noop = __toESM(require("lodash/noop"));
+var import_react = require("react");
+var TableContext = (0, import_react.createContext)({
+  tableId: "",
+  columns: [],
+  flattenColumns: [],
+  fixedLeftColumns: [],
+  fixedRightColumns: [],
+  // @ts-ignore
+  props: {},
+  data: [],
+  setData: import_noop.default
+});
+var TableHeaderContext = (0, import_react.createContext)({
+  sortProp: "",
+  setSortProp: import_noop.default,
+  init: { current: null }
+});
+var TableBodyContext = (0, import_react.createContext)({
+  oldActiveRow: { current: null },
+  state: { isIndeterminate: false, selection: [], currentRow: null },
+  dispatch: import_noop.default,
+  initialData: { current: [] },
+  sortedData: { current: [] },
+  disabledRows: { current: [] },
+  isTreeTable: () => false,
+  isTreeExpandCell: () => false,
+  treeProps: { hasChildren: "hasChildren", children: "children" },
+  treeNodes: { current: [] }
+});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  TableBodyContext,
+  TableContext,
+  TableHeaderContext
+});

package/dist/Table/TableHeader.d.ts

@@ -0,0 +1,6 @@
+import React from 'react';
+interface Props {
+    scheduleLayout: (needUpdateColumns?: boolean, immediate?: boolean) => void;
+}
+declare const TableHeader: ({ scheduleLayout }: Props) => React.JSX.Element;
+export default TableHeader;

package/dist/Table/TableHeader.js

@@ -0,0 +1,107 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/Table/TableHeader.tsx
+var TableHeader_exports = {};
+__export(TableHeader_exports, {
+  default: () => TableHeader_default
+});
+module.exports = __toCommonJS(TableHeader_exports);
+var import_classnames = __toESM(require("classnames"));
+var import_some = __toESM(require("lodash/some"));
+var import_react = __toESM(require("react"));
+var import_hooks = require("../hooks");
+var import_TableContext = require("./TableContext");
+var import_TableHeaderCell = __toESM(require("./TableHeaderCell"));
+var TableHeader = ({ scheduleLayout }) => {
+  const { tableId, columns, fixedLeftColumns, fixedRightColumns, props } = (0, import_react.useContext)(import_TableContext.TableContext);
+  const { headerRowClassName, headerRowStyle, defaultSort } = props;
+  const { is, bm } = (0, import_hooks.useClassNames)("table");
+  const initSortRef = (0, import_react.useRef)(false);
+  const [sortProp, setSortProp] = (0, import_react.useState)(defaultSort == null ? void 0 : defaultSort.prop);
+  const middleColumns = (0, import_react.useMemo)(
+    () => columns.map((col, index) => {
+      if (index === 0) {
+        return col.filter((item) => !(0, import_some.default)([...fixedLeftColumns, ...fixedRightColumns], { id: item.id }));
+      }
+      return col;
+    }),
+    [fixedLeftColumns, fixedRightColumns, columns]
+  );
+  return /* @__PURE__ */ import_react.default.createElement(import_TableContext.TableHeaderContext.Provider, { value: { sortProp, setSortProp, init: initSortRef } }, /* @__PURE__ */ import_react.default.createElement("thead", { className: is({ group: columns.length > 1 }) }, middleColumns.map((row, rowIndex) => {
+    let columnIndex = -1;
+    return /* @__PURE__ */ import_react.default.createElement(
+      "tr",
+      {
+        key: `${tableId}_${rowIndex}`,
+        className: typeof headerRowClassName === "function" ? headerRowClassName == null ? void 0 : headerRowClassName({ row, rowIndex }) : headerRowClassName,
+        style: typeof headerRowStyle === "function" ? headerRowStyle == null ? void 0 : headerRowStyle({ row, rowIndex }) : headerRowStyle
+      },
+      rowIndex === 0 && fixedLeftColumns.map((column) => {
+        columnIndex++;
+        return /* @__PURE__ */ import_react.default.createElement(
+          import_TableHeaderCell.default,
+          {
+            key: column.id,
+            row,
+            rowIndex,
+            column,
+            columnIndex,
+            className: (0, import_classnames.default)(
+              bm("fixed-column", "left"),
+              is({ leaf: column.isSubColumn, "last-column": columnIndex === fixedLeftColumns.length - 1 })
+            ),
+            style: { left: column.offsetWidth },
+            scheduleLayout
+          }
+        );
+      }),
+      row.map((column) => {
+        columnIndex++;
+        return /* @__PURE__ */ import_react.default.createElement(import_TableHeaderCell.default, { key: column.id, row, rowIndex, column, columnIndex, scheduleLayout });
+      }),
+      rowIndex === 0 && fixedRightColumns.map((column) => {
+        columnIndex++;
+        return /* @__PURE__ */ import_react.default.createElement(
+          import_TableHeaderCell.default,
+          {
+            key: column.id,
+            row,
+            rowIndex,
+            column,
+            columnIndex,
+            className: (0, import_classnames.default)(bm("fixed-column", "right"), is({ leaf: column.isSubColumn, "first-column": columnIndex === 0 })),
+            style: { right: column.offsetWidth },
+            scheduleLayout
+          }
+        );
+      })
+    );
+  })));
+};
+var TableHeader_default = TableHeader;

package/dist/Table/TableHeaderCell.d.ts

@@ -0,0 +1,12 @@
+import React from 'react';
+import { NativeProps } from '../types/common';
+import { TableColumnCtx } from './typings';
+interface Props extends NativeProps {
+    row: any;
+    rowIndex: number;
+    column: TableColumnCtx<any>;
+    columnIndex: number;
+    scheduleLayout: (needUpdateColumns?: boolean, immediate?: boolean) => void;
+}
+declare const TableHeaderCell: (p: Props) => React.JSX.Element;
+export default TableHeaderCell;

package/dist/Table/TableHeaderCell.js

@@ -0,0 +1,178 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/Table/TableHeaderCell.tsx
+var TableHeaderCell_exports = {};
+__export(TableHeaderCell_exports, {
+  default: () => TableHeaderCell_default
+});
+module.exports = __toCommonJS(TableHeaderCell_exports);
+var import_ahooks = require("ahooks");
+var import_classnames = __toESM(require("classnames"));
+var import_isEqual = __toESM(require("lodash/isEqual"));
+var import_sortBy = __toESM(require("lodash/sortBy"));
+var import_react = __toESM(require("react"));
+var import_Checkbox = require("../Checkbox");
+var import_Util = require("../Util");
+var import_hooks = require("../hooks");
+var import_TableContext = require("./TableContext");
+var import_useResize = require("./hooks/useResize");
+var import_useSelection = require("./hooks/useSelection");
+var import_treeUtil = require("./treeUtil");
+var import_util = require("./util");
+var TableHeaderCell = (p) => {
+  const { row, rowIndex, column, columnIndex, scheduleLayout, className, style } = p;
+  const { data, props, setData, flattenColumns } = (0, import_react.useContext)(import_TableContext.TableContext);
+  const { sortProp, setSortProp, init } = (0, import_react.useContext)(import_TableContext.TableHeaderContext);
+  const { state, dispatch, initialData, sortedData, disabledRows, treeProps, treeNodes } = (0, import_react.useContext)(import_TableContext.TableBodyContext);
+  const { rowKey, headerCellClassName, headerCellStyle, onHeaderClick, onHeaderContextmenu, onSelectAll, onSelectionChange, selectOnIndeterminate, defaultSort, onSortChange } = props;
+  const { e, is, bm } = (0, import_hooks.useClassNames)("table");
+  const { handleMouseDown, handleMouseMove, handleMouseOut } = (0, import_useResize.useResize)(scheduleLayout);
+  const enableSort = (0, import_react.useMemo)(() => {
+    if (column.sortable === true || column.sortable === "custom") {
+      return true;
+    } else if ((defaultSort == null ? void 0 : defaultSort.prop) && (0, import_Util.isNotEmpty)(column.prop || column.name)) {
+      return defaultSort.prop === (column.prop || column.name);
+    }
+    return false;
+  }, [column.name, column.prop, column.sortable, defaultSort == null ? void 0 : defaultSort.prop]);
+  const sortOrders = (0, import_react.useMemo)(() => (column == null ? void 0 : column.sortOrders) ?? ["ascending", "descending", null], [column == null ? void 0 : column.sortOrders]);
+  const activeSort = (0, import_react.useMemo)(() => (0, import_Util.isNotEmpty)(sortProp) && sortProp === (column.prop || column.name), [column.name, column.prop, sortProp]);
+  const [order, setOrder] = (0, import_react.useState)(() => activeSort && !init.current ? defaultSort == null ? void 0 : defaultSort.order : null);
+  (0, import_react.useEffect)(() => {
+    if (enableSort && init.current && !activeSort) {
+      setOrder(sortOrders[sortOrders.length - 1]);
+    }
+  }, [sortProp]);
+  const handleCheckAll = (0, import_react.useCallback)(
+    (checked) => {
+      let selected = [];
+      const filterData = data.filter(
+        (item1) => !disabledRows.current.some((item2) => rowKey ? (0, import_util.getRowIdentity)(item1, rowKey) === (0, import_util.getRowIdentity)(item2, rowKey) : (0, import_isEqual.default)(item1, item2))
+      );
+      if (selectOnIndeterminate) {
+        selected = checked ? filterData : [];
+      } else {
+        selected = state.selection.length > 0 ? [] : filterData;
+      }
+      dispatch((0, import_useSelection.onCheck)({ selection: selected, isIndeterminate: false }));
+      onSelectAll == null ? void 0 : onSelectAll(selected);
+      onSelectionChange == null ? void 0 : onSelectionChange(selected);
+    },
+    [data, disabledRows, dispatch, onSelectAll, onSelectionChange, rowKey, selectOnIndeterminate, state.selection.length]
+  );
+  const handleSort = (0, import_react.useCallback)(
+    (_sort) => {
+      if (column.sortable === "custom" && sortProp && _sort) {
+        const _data = onSortChange == null ? void 0 : onSortChange({ column, prop: sortProp, order: _sort });
+        if (_data && _data instanceof Array) {
+          try {
+            setData((0, import_treeUtil.mergeTreeData)(initialData.current, treeNodes.current, treeProps, rowKey));
+          } catch (error) {
+            console.warn("warning： 返回的数据似乎有问题");
+          }
+        } else {
+          console.warn("warning： 返回的数据格式有问题");
+        }
+      } else if (column.sortMethod) {
+        const _data = initialData.current.sort((a, b) => column.sortMethod(a, b));
+        setData((0, import_treeUtil.mergeTreeData)(_data, treeNodes.current, treeProps, rowKey));
+      } else if ((0, import_Util.isEmpty)(_sort)) {
+        setData((0, import_treeUtil.mergeTreeData)(initialData.current, treeNodes.current, treeProps, rowKey));
+      } else {
+        const _data = (0, import_sortBy.default)(initialData.current, column.sortBy ? column.sortBy : column.prop || column.name);
+        sortedData.current = _sort === "descending" ? _data.reverse() : _data;
+        setData((0, import_treeUtil.mergeTreeData)(sortedData.current, treeNodes.current, treeProps, rowKey));
+      }
+    },
+    [column, sortProp, onSortChange, initialData, setData, treeNodes, treeProps, rowKey, sortedData]
+  );
+  (0, import_ahooks.useMount)(() => {
+    if (activeSort) {
+      handleSort(order);
+    }
+  });
+  const handleHeaderClick = (0, import_react.useCallback)(
+    (event) => {
+      onHeaderClick == null ? void 0 : onHeaderClick(column, event);
+      if (enableSort && order !== void 0) {
+        let nextIndex = sortOrders.indexOf(order) + 1;
+        nextIndex = nextIndex >= 3 ? 0 : nextIndex;
+        setOrder(sortOrders[nextIndex]);
+        if (!activeSort) {
+          setSortProp(column.prop || column.name);
+        }
+        init.current = true;
+        handleSort(sortOrders[nextIndex]);
+      }
+    },
+    [activeSort, column, enableSort, handleSort, init, onHeaderClick, order, setSortProp, sortOrders]
+  );
+  return /* @__PURE__ */ import_react.default.createElement(
+    "th",
+    {
+      className: (0, import_classnames.default)(
+        column.id,
+        e`cell`,
+        { [bm("column", "selection")]: column.type === "selection", [order]: activeSort },
+        is(column.headerAlign || column.align, { leaf: column.isSubColumn, sortable: enableSort }),
+        column.labelClassName,
+        className,
+        typeof headerCellClassName === "function" ? headerCellClassName == null ? void 0 : headerCellClassName({ row, column, rowIndex, columnIndex }) : headerCellClassName
+      ),
+      style: { ...style, ...typeof headerCellStyle === "function" ? headerCellStyle == null ? void 0 : headerCellStyle({ row, column, rowIndex, columnIndex }) : headerCellStyle },
+      colSpan: column.colSpan || 1,
+      rowSpan: column.rowSpan || 1,
+      onClick: handleHeaderClick,
+      onContextMenu: (event) => onHeaderContextmenu == null ? void 0 : onHeaderContextmenu(column, event),
+      onMouseDown: (event) => handleMouseDown(
+        event,
+        flattenColumns.find((item) => item.id === column.id)
+      ),
+      onMouseMove: (event) => handleMouseMove(event, column),
+      onMouseOut: handleMouseOut
+    },
+    /* @__PURE__ */ import_react.default.createElement("div", { className: e`cell-content` }, (() => {
+      var _a, _b, _c, _d, _e;
+      if (data.length > 0 && column.type === "selection") {
+        return /* @__PURE__ */ import_react.default.createElement(
+          import_Checkbox.Checkbox,
+          {
+            disabled: ((_a = disabledRows.current) == null ? void 0 : _a.length) === data.length,
+            checked: ((_b = state.selection) == null ? void 0 : _b.length) > 0 && ((_c = state.selection) == null ? void 0 : _c.length) + ((_d = disabledRows.current) == null ? void 0 : _d.length) === data.length,
+            indeterminate: ((_e = state.selection) == null ? void 0 : _e.length) > 0 && state.isIndeterminate,
+            onChange: (checked) => handleCheckAll(checked)
+          }
+        );
+      } else {
+        return /* @__PURE__ */ import_react.default.createElement(import_react.default.Fragment, null, column.label, enableSort && /* @__PURE__ */ import_react.default.createElement("span", { className: "caret-wrapper" }, /* @__PURE__ */ import_react.default.createElement("i", { className: "sort-caret ascending" }), /* @__PURE__ */ import_react.default.createElement("i", { className: "sort-caret descending" })));
+      }
+    })())
+  );
+};
+var TableHeaderCell_default = TableHeaderCell;

package/dist/Table/hooks/useResize.d.ts

@@ -0,0 +1,7 @@
+import React from 'react';
+import { TableColumnCtx } from '../typings';
+export declare const useResize: <T>(scheduleLayout: (immediate?: boolean) => void) => {
+    handleMouseDown: (event: React.MouseEvent<Element>, column: TableColumnCtx<T>) => void;
+    handleMouseMove: (event: React.MouseEvent<Element>, column: TableColumnCtx<T>) => void;
+    handleMouseOut: () => void;
+};

package/dist/Table/hooks/useResize.js

@@ -0,0 +1,131 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/Table/hooks/useResize.ts
+var useResize_exports = {};
+__export(useResize_exports, {
+  useResize: () => useResize
+});
+module.exports = __toCommonJS(useResize_exports);
+var import_dom_lib = require("dom-lib");
+var import_react = require("react");
+var import_TableContext = require("../TableContext");
+var useResize = (scheduleLayout) => {
+  const { props, tableRefs } = (0, import_react.useContext)(import_TableContext.TableContext);
+  const draggingColumn = (0, import_react.useRef)(null);
+  const dragging = (0, import_react.useRef)(false);
+  const dragState = (0, import_react.useRef)({});
+  const handleMouseDown = (event, column) => {
+    if (column.children && column.children.length > 0) {
+      return;
+    }
+    if (draggingColumn.current && props.border) {
+      dragging.current = true;
+      const tableEl = tableRefs.tableWrapper;
+      if (tableEl.current && tableRefs.resizeHelper.current) {
+        const resizeProxy = tableRefs.resizeHelper.current;
+        resizeProxy.style.display = "";
+        const tableLeft = tableEl.current.getBoundingClientRect().left;
+        const columnEl = tableEl.current.querySelector(`th.${column.id}`);
+        if (columnEl) {
+          const columnRect = columnEl.getBoundingClientRect();
+          const minLeft = (columnRect == null ? void 0 : columnRect.left) - tableLeft + 30;
+          (0, import_dom_lib.addClass)(columnEl, "noclick");
+          dragState.current = {
+            startMouseLeft: event.clientX,
+            startLeft: columnRect.right - tableLeft,
+            startColumnLeft: columnRect.left - tableLeft,
+            tableLeft
+          };
+          resizeProxy.style.left = `${dragState.current.startLeft}px`;
+          document.onselectstart = function() {
+            return false;
+          };
+          document.ondragstart = function() {
+            return false;
+          };
+          const handleMouseMove2 = (e) => {
+            const deltaLeft = e.clientX - dragState.current.startMouseLeft;
+            const proxyLeft = dragState.current.startLeft + deltaLeft;
+            resizeProxy.style.left = `${Math.max(minLeft, proxyLeft)}px`;
+          };
+          const handleMouseUp = () => {
+            var _a;
+            if (dragging.current) {
+              const { startColumnLeft, startLeft } = dragState.current;
+              const finalLeft = Number.parseInt(resizeProxy.style.left, 10);
+              const columnWidth = finalLeft - startColumnLeft;
+              column.width = column.realWidth = columnWidth;
+              (_a = props == null ? void 0 : props.onHeaderDragend) == null ? void 0 : _a.call(props, column.width, startLeft - startColumnLeft, column, event);
+              requestAnimationFrame(() => scheduleLayout == null ? void 0 : scheduleLayout(false));
+              document.body.style.cursor = "";
+              dragging.current = false;
+              draggingColumn.current = null;
+              dragState.current = {};
+              resizeProxy.style.display = "none";
+            }
+            document.removeEventListener("mousemove", handleMouseMove2);
+            document.removeEventListener("mouseup", handleMouseUp);
+            document.onselectstart = null;
+            document.ondragstart = null;
+            setTimeout(() => {
+              (0, import_dom_lib.removeClass)(columnEl, "noclick");
+            }, 0);
+          };
+          document.addEventListener("mousemove", handleMouseMove2);
+          document.addEventListener("mouseup", handleMouseUp);
+        }
+      }
+    }
+  };
+  const handleMouseMove = (event, column) => {
+    var _a;
+    if (column.children && column.children.length > 0) {
+      return;
+    }
+    const target = (_a = event.target) == null ? void 0 : _a.closest("th");
+    if (!column || !column.resizable) {
+      return;
+    }
+    if (!dragging.current && target && props.border) {
+      const rect = target.getBoundingClientRect();
+      const bodyStyle = document.body.style;
+      if (rect.width > 12 && rect.right - event.pageX < 8) {
+        bodyStyle.cursor = "col-resize";
+        if ((0, import_dom_lib.hasClass)(target, "is-sortable")) {
+          target.style.cursor = "col-resize";
+        }
+        draggingColumn.current = column;
+      } else if (!dragging.current) {
+        bodyStyle.cursor = "";
+        if ((0, import_dom_lib.hasClass)(target, "is-sortable")) {
+          target.style.cursor = "pointer";
+        }
+        draggingColumn.current = null;
+      }
+    }
+  };
+  const handleMouseOut = () => {
+    document.body.style.cursor = "";
+  };
+  return { handleMouseDown, handleMouseMove, handleMouseOut };
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  useResize
+});

package/dist/Table/hooks/useScroll.d.ts

@@ -0,0 +1,7 @@
+import { TableProps, TableRefs } from '../typings';
+export declare const useScroll: <T>(props: TableProps<T>, data: T[], refs: TableRefs, m: (...classes: any[]) => string) => {
+    setHeight: (height: number | string) => void;
+    scrollTo: (options: number, yCoord?: number) => void;
+    setScrollTop: (top?: number) => void;
+    setScrollLeft: (left?: number) => void;
+};