@arim-aisdc/public-components 0.0.2 → 0.0.4

package/dist/components/Foo/index.d.ts

@@ -0,0 +1,6 @@
+import { FC } from 'react';
+import './index.less';
+declare const Foo: FC<{
+    title: string;
+}>;
+export default Foo;

package/dist/{Foo → components/Foo}/index.js

@@ -6,4 +6,10 @@ var Foo = function Foo(props) {
     children: props.title
   });
 };
+
+// const Foo: FC<{ title: string }> = (props) => {
+
+//   return <h4 className="title">{props.title}</h4>
+// }
+
 export default Foo;

package/dist/components/Foo/index.less

@@ -0,0 +1,3 @@
+.title {
+  color: @globalColor1;
+}

package/dist/components/TableMax/TableBody/Row.d.ts

@@ -0,0 +1,38 @@
+import { OnSelectChangeType } from "../type";
+import { Table } from '@tanstack/react-table';
+import { Dispatch, FC, SetStateAction } from 'react';
+import './index.less';
+declare const Row: ({ table, tableId, row, rowSelectedId, setRowSelectedId, selectedRowChange, onSelectChange, canSelection, reorderRow, tableContainerWidth, canRowDrag, rowClassName, cellClassName, rowStyle, getCellProps, editting, rowEditing, renderSubComponent, selectedRowDragging, setSelectedRowDragging, onRowMouseEnter, onRowMouseLeave, onRowMouseClick, onRowMouseDoubleClick, rowHeight, disableDragRowIds, selectRowWhenClick, hasVerticalScrollBar, handleEditRowWhenDClick, canEditRowWhenDClick, theme, }: {
+    table: Table<any>;
+    tableId: string;
+    row: any;
+    rowSelectedId?: string;
+    setRowSelectedId?: Dispatch<SetStateAction<string | undefined>>;
+    selectedRowChange?: Function;
+    onSelectChange?: OnSelectChangeType;
+    tableContainerWidth?: number;
+    canSelection?: boolean;
+    reorderRow?: Function;
+    canRowDrag?: boolean;
+    rowClassName?: Function;
+    cellClassName?: Function;
+    rowStyle?: object;
+    getCellProps?: Function;
+    editting?: boolean;
+    rowEditing?: boolean;
+    renderSubComponent?: FC<any>;
+    selectedRowDragging?: boolean;
+    setSelectedRowDragging?: FC<any>;
+    onRowMouseEnter?: Function;
+    onRowMouseLeave?: Function;
+    onRowMouseClick?: Function;
+    onRowMouseDoubleClick?: Function;
+    rowHeight: number;
+    disableDragRowIds: any[];
+    selectRowWhenClick: boolean;
+    hasVerticalScrollBar: boolean;
+    handleEditRowWhenDClick: (row: any) => void;
+    canEditRowWhenDClick: boolean;
+    theme: string;
+}) => import("react/jsx-runtime").JSX.Element;
+export default Row;

package/dist/{TableMax → components/TableMax}/TableBody/Row.js

@@ -30,7 +30,6 @@ var Row = function Row(_ref) {
     selectedRowChange = _ref.selectedRowChange,
     onSelectChange = _ref.onSelectChange,
     canSelection = _ref.canSelection,
-    rowSelectionChange = _ref.rowSelectionChange,
     reorderRow = _ref.reorderRow,
     tableContainerWidth = _ref.tableContainerWidth,
     canRowDrag = _ref.canRowDrag,

package/dist/components/TableMax/TableBody/index.d.ts

@@ -0,0 +1,49 @@
+import { OnSelectChangeType } from "../type";
+import './index.less';
+type TableBodyPropsType = {
+    table: any;
+    tableId: any;
+    theme: any;
+    reorderRow: any;
+    rowSelectedId: any;
+    setRowSelectedId: any;
+    selectedRowChange: any;
+    onSelectChange: OnSelectChangeType;
+    canFilter: any;
+    canSelection: any;
+    tableBodyHeight: any;
+    tableHeadHeight: any;
+    setTableHeadHeight: any;
+    bodyContentHeight: any;
+    tableContainerWidth: any;
+    selectedRowDragging: any;
+    setSelectedRowDragging: any;
+    canRowDrag: any;
+    rowKey: any;
+    hasGroup: any;
+    tableDatas: any;
+    canSorting: any;
+    loading: boolean;
+    rowClassName: any;
+    cellClassName: any;
+    rowStyle: any;
+    getCellProps: any;
+    rowHeight: any;
+    renderSubComponent: any;
+    onRowMouseEnter: any;
+    onRowMouseLeave: any;
+    onRowMouseClick: any;
+    onRowMouseDoubleClick: any;
+    enableFilters: any;
+    enableVirtualList: any;
+    disableDragRowIds: any;
+    selectRowWhenClick: any;
+    datas: any;
+    hasVerticalScrollBar: boolean;
+    emptyDataHeight: number;
+    canEditRowWhenDClick: boolean;
+    editingRowId: string;
+    handleEditRowWhenDClick: (row: any) => void;
+};
+declare const TableBody: ({ table, tableId, theme, reorderRow, rowSelectedId, setRowSelectedId, selectedRowChange, onSelectChange, canFilter, canSelection, tableBodyHeight, tableHeadHeight, setTableHeadHeight, bodyContentHeight, tableContainerWidth, selectedRowDragging, setSelectedRowDragging, canRowDrag, rowKey, loading, rowClassName, cellClassName, rowStyle, getCellProps, rowHeight, renderSubComponent, onRowMouseEnter, onRowMouseLeave, onRowMouseClick, onRowMouseDoubleClick, enableFilters, enableVirtualList, disableDragRowIds, selectRowWhenClick, hasVerticalScrollBar, datas, emptyDataHeight, canEditRowWhenDClick, editingRowId, handleEditRowWhenDClick, }: TableBodyPropsType) => import("react/jsx-runtime").JSX.Element;
+export default TableBody;

package/dist/{TableMax → components/TableMax}/TableBody/index.js

@@ -1,16 +1,18 @@
+import "antd/es/spin/style";
+import _Spin from "antd/es/spin";
 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 _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 _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 _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; }
-import { Spin } from 'antd';
 // import { useVirtualizer } from "@tanstack/react-virtual";
 import { useDrop } from 'react-dnd';
 import { CustomDragLayer } from "../components/CustomDragerLayer";
 // import RowContent from "../components/RowContent";
-import "./index.less";
+
 import Row from "./Row";
+import "./index.less";
 import { jsx as _jsx } from "react/jsx-runtime";
 import { jsxs as _jsxs } from "react/jsx-runtime";
 var TableBody = function TableBody(_ref) {
@@ -25,14 +27,10 @@ var TableBody = function TableBody(_ref) {
     onSelectChange = _ref.onSelectChange,
     canFilter = _ref.canFilter,
     canSelection = _ref.canSelection,
-    rowSelectionChange = _ref.rowSelectionChange,
-    scroll = _ref.scroll,
-    setScroll = _ref.setScroll,
     tableBodyHeight = _ref.tableBodyHeight,
     tableHeadHeight = _ref.tableHeadHeight,
     setTableHeadHeight = _ref.setTableHeadHeight,
     bodyContentHeight = _ref.bodyContentHeight,
-    setBodyContentHeight = _ref.setBodyContentHeight,
     tableContainerWidth = _ref.tableContainerWidth,
     selectedRowDragging = _ref.selectedRowDragging,
     setSelectedRowDragging = _ref.setSelectedRowDragging,
@@ -45,7 +43,6 @@ var TableBody = function TableBody(_ref) {
     getCellProps = _ref.getCellProps,
     rowHeight = _ref.rowHeight,
     renderSubComponent = _ref.renderSubComponent,
-    isAllRowExpanded = _ref.isAllRowExpanded,
     onRowMouseEnter = _ref.onRowMouseEnter,
     onRowMouseLeave = _ref.onRowMouseLeave,
     onRowMouseClick = _ref.onRowMouseClick,
@@ -183,7 +180,7 @@ var TableBody = function TableBody(_ref) {
           width: "".concat(tableContainerWidth - (hasVerticalScrollBar ? 10 : 0), "px"),
           height: emptyDataHeight
         },
-        children: loading ? /*#__PURE__*/_jsx(Spin, {}) : /*#__PURE__*/_jsxs("span", {
+        children: loading ? /*#__PURE__*/_jsx(_Spin, {}) : /*#__PURE__*/_jsxs("span", {
           className: "empty-content",
           ref: dropRef,
           children: [/*#__PURE__*/_jsx("img", {
@@ -216,7 +213,6 @@ var TableBody = function TableBody(_ref) {
         canSelection: canSelection,
         selectedRowDragging: selectedRowDragging,
         setSelectedRowDragging: setSelectedRowDragging,
-        rowSelectionChange: rowSelectionChange,
         canRowDrag: canRowDrag,
         rowClassName: rowClassName,
         cellClassName: cellClassName,
@@ -260,9 +256,7 @@ var TableBody = function TableBody(_ref) {
       children: [/*#__PURE__*/_jsx("colgroup", {
         children: headerGroups === null || headerGroups === void 0 || (_headerGroups = headerGroups[headerGroups.length - 1]) === null || _headerGroups === void 0 || (_headerGroups = _headerGroups.headers) === null || _headerGroups === void 0 ? void 0 : _headerGroups.map(function (header) {
           return /*#__PURE__*/_jsx("col", {
-            style: {
-              width: header.getSize() || 80
-            }
+            width: header.getSize() || 80
           }, header.id);
         })
       }), /*#__PURE__*/_jsx("tbody", {

package/dist/components/TableMax/TableHeader/Cell.d.ts

@@ -0,0 +1,13 @@
+import { TableMaxColumnType } from "../type";
+import { ColumnResizeMode, Header, Table } from '@tanstack/react-table';
+import './index.less';
+type ICellType = {
+    header: Header<TableMaxColumnType, unknown>;
+    table: Table<TableMaxColumnType>;
+    hasGroup?: boolean;
+    canSorting?: boolean;
+    getHeaderCellProps?: Function;
+    columnResizeMode: ColumnResizeMode;
+};
+declare const Cell: ({ header, table, hasGroup, canSorting, getHeaderCellProps, columnResizeMode }: ICellType) => import("react/jsx-runtime").JSX.Element;
+export default Cell;

package/dist/{TableMax → components/TableMax}/TableHeader/Cell.js

@@ -1,4 +1,6 @@
 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); }
+import "antd/es/tooltip/style";
+import _Tooltip from "antd/es/tooltip";
 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 _iterableToArray(iter) { if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter); }
@@ -15,25 +17,19 @@ function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len
 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; }
 import { flexRender } from '@tanstack/react-table';
-import { useState } from 'react';
-import "./index.less";
+import { useMemo } from 'react';
 import { useDrag, useDrop } from 'react-dnd';
-import { ColumnType } from '..';
+import { ColumnType } from "../TableMax";
+import "./index.less";
 import { jsx as _jsx } from "react/jsx-runtime";
 import { jsxs as _jsxs } from "react/jsx-runtime";
 var Cell = function Cell(_ref) {
   var header = _ref.header,
     table = _ref.table,
-    filterFn = _ref.filterFn,
-    canFilter = _ref.canFilter,
     hasGroup = _ref.hasGroup,
     canSorting = _ref.canSorting,
-    rowHeight = _ref.rowHeight,
-    getHeaderCellProps = _ref.getHeaderCellProps;
-  var _useState = useState('onChange'),
-    _useState2 = _slicedToArray(_useState, 2),
-    columnResizeMode = _useState2[0],
-    setColumnResizeMode = _useState2[1];
+    getHeaderCellProps = _ref.getHeaderCellProps,
+    columnResizeMode = _ref.columnResizeMode;
   var getState = table.getState,
     setColumnOrder = table.setColumnOrder;
   var _getState = getState(),
@@ -84,22 +80,41 @@ var Cell = function Cell(_ref) {
       })
     }[header.column.getIsSorted()];
   }
+  var columnDef = useMemo(function () {
+    return header.column.columnDef;
+  }, [header]);
+  var columns = useMemo(function () {
+    return columnDef.columns;
+  }, [header]);
   return /*#__PURE__*/_jsx("div", {
     ref: dropRef,
     children: /*#__PURE__*/_jsxs("div", {
-      className: "cell-wapper ".concat(header.column.columnDef.columns ? 'wapper-top-parent' : '', " tableMax-cell-wrapper"),
+      className: "cell-wapper ".concat(columns ? 'wapper-top-parent' : '', " tableMax-cell-wrapper"),
       ref: previewRef,
       style: _objectSpread({
-        transform: header.column.parent || header.column.columnDef.columns || !hasGroup ? 'translateY(0px)' : 'translateY(-20px)'
-      }, getHeaderCellProps === null || getHeaderCellProps === void 0 ? void 0 : getHeaderCellProps(header.column.columnDef.columns)),
+        transform: header.column.parent || columns || !hasGroup ? 'translateY(0px)' : 'translateY(-20px)'
+      }, getHeaderCellProps === null || getHeaderCellProps === void 0 ? void 0 : getHeaderCellProps(columns)),
       children: [/*#__PURE__*/_jsxs("div", {
         className: "cell-left",
         onClick: header.column.getToggleSortingHandler(),
         style: {
-          display: 'inline-block',
-          textAlign: header.column.columnDef.columns ? 'center' : 'left'
+          textAlign: columns ? 'center' : 'left'
         },
-        children: [flexRender(header.column.columnDef.header, header.getContext()), canSorting ? sortingRender() : null]
+        children: [columnDef.ellipsis ? /*#__PURE__*/_jsx(_Tooltip, {
+          placement: "topLeft"
+          // @ts-ignore
+          ,
+          title: flexRender(columnDef.header, header.getContext()),
+          mouseEnterDelay: 0.5,
+          children: /*#__PURE__*/_jsx("div", {
+            className: "cell-left-header",
+            children:
+            // @ts-ignore
+            flexRender(columnDef.header, header.getContext())
+          })
+        }) :
+        // @ts-ignore
+        flexRender(columnDef.header, header.getContext()), canSorting ? sortingRender() : null]
       }), /*#__PURE__*/_jsx("div", {
         className: "cell-right",
         onClick: header.column.getToggleSortingHandler(),

package/dist/components/TableMax/TableHeader/index.d.ts

@@ -0,0 +1,16 @@
+import { ColumnResizeMode } from '@tanstack/react-table';
+import './index.less';
+type TableHeaderProps = {
+    table: any;
+    canFilter?: boolean;
+    enableFilters?: boolean;
+    canSorting?: boolean;
+    rowHeight?: number;
+    hasGroup?: boolean;
+    headerGroups?: any[];
+    hasVerticalScrollBar: boolean;
+    getHeaderCellProps?: Function;
+    columnResizeMode: ColumnResizeMode;
+};
+declare const TableHeader: ({ table, headerGroups, canFilter, enableFilters, canSorting, rowHeight, hasGroup, hasVerticalScrollBar, getHeaderCellProps, columnResizeMode, }: TableHeaderProps) => import("react/jsx-runtime").JSX.Element;
+export default TableHeader;

package/dist/{TableMax → components/TableMax}/TableHeader/index.js

@@ -6,6 +6,7 @@ function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return _ty
 function _toPrimitive(input, hint) { if (_typeof(input) !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (_typeof(res) !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
 // import { Column, flexRender } from '@tanstack/react-table';
 // import { useDrag, useDrop } from 'ahooks';
+
 import { useEffect, useMemo } from 'react';
 import { Filter } from "../components/ColumnFilter";
 import Cell from "./Cell";
@@ -19,12 +20,12 @@ var TableHeader = function TableHeader(_ref) {
     headerGroups = _ref.headerGroups,
     canFilter = _ref.canFilter,
     enableFilters = _ref.enableFilters,
-    filterFn = _ref.filterFn,
     canSorting = _ref.canSorting,
     rowHeight = _ref.rowHeight,
     hasGroup = _ref.hasGroup,
     hasVerticalScrollBar = _ref.hasVerticalScrollBar,
-    getHeaderCellProps = _ref.getHeaderCellProps;
+    getHeaderCellProps = _ref.getHeaderCellProps,
+    columnResizeMode = _ref.columnResizeMode;
   var getState = table.getState,
     setColumnOrder = table.setColumnOrder,
     columnPinning = table.columnPinning;
@@ -67,14 +68,10 @@ var TableHeader = function TableHeader(_ref) {
     children: [/*#__PURE__*/_jsxs("colgroup", {
       children: [headerGroups === null || headerGroups === void 0 || (_headerGroups = headerGroups[headerGroups.length - 1]) === null || _headerGroups === void 0 || (_headerGroups = _headerGroups.headers) === null || _headerGroups === void 0 ? void 0 : _headerGroups.map(function (header) {
         return /*#__PURE__*/_jsx("col", {
-          style: {
-            width: header.getSize() || 80
-          }
+          width: header.getSize() || 80
         }, header.id);
       }), hasVerticalScrollBar ? /*#__PURE__*/_jsx("col", {
-        style: {
-          width: 10
-        }
+        width: 10
       }, "verticalScrollBar") : null]
     }), /*#__PURE__*/_jsxs("thead", {
       children: [headerGroups === null || headerGroups === void 0 ? void 0 : headerGroups.map(function (headerGroup) {
@@ -91,12 +88,10 @@ var TableHeader = function TableHeader(_ref) {
               children: header.isPlaceholder ? null : /*#__PURE__*/_jsx(Cell, {
                 header: header,
                 table: table,
-                canFilter: canFilter,
-                filterFn: filterFn,
                 hasGroup: hasGroup,
                 canSorting: canSorting,
-                rowHeight: rowHeight,
-                getHeaderCellProps: getHeaderCellProps
+                getHeaderCellProps: getHeaderCellProps,
+                columnResizeMode: columnResizeMode
               }, header.id)
             }, header.id);
           }), hasVerticalScrollBar ? /*#__PURE__*/_jsx("th", {
@@ -111,9 +106,7 @@ var TableHeader = function TableHeader(_ref) {
             style: _objectSpread({}, getPinningStyle(header, table, hasVerticalScrollBar)),
             children: header.column.getCanFilter() ? /*#__PURE__*/_jsx("div", {
               children: /*#__PURE__*/_jsx(Filter, {
-                column: header.column,
-                table: table,
-                filterFn: filterFn
+                column: header.column
               })
             }) : null
           }, header.id + '1');

package/dist/{TableMax → components/TableMax}/TableHeader/index.less

@@ -35,7 +35,16 @@ table {
     color: @tableColor1;
     cursor: pointer;
     overflow: hidden;
-    white-space: nowrap
+    white-space: nowrap;
+    display: flex;
+    align-items: center;
+    margin-right: 20px;
+    .cell-left-header {
+      display: inline-block;
+      overflow: hidden;
+      text-overflow: ellipsis;
+      white-space: nowrap;
+    }
   }
 
   .drag-handler {
@@ -63,10 +72,10 @@ table {
       height: 0;
       border-left: 4px solid transparent;
       border-right: 4px solid transparent;
-      border-bottom: 6px solid #B4B6BFFF;
+      border-bottom: 6px solid #b4b6bfff;
 
       &-red {
-        border-bottom: 6px solid #FA541CFF;
+        border-bottom: 6px solid #fa541cff;
       }
     }
 
@@ -77,10 +86,10 @@ table {
       margin-top: 3px;
       border-left: 4px solid transparent;
       border-right: 4px solid transparent;
-      border-top: 6px solid #B4B6BFFF;
+      border-top: 6px solid #b4b6bfff;
 
       &-red {
-        border-top: 6px solid #FA541CFF;
+        border-top: 6px solid #fa541cff;
       }
     }
   }
@@ -107,7 +116,6 @@ table {
   .column-resizer.column-is-resizing {
     height: 60%;
     top: 20%;
-
   }
 }
 
@@ -125,29 +133,28 @@ table {
     vertical-align: top;
     padding: 6px 2px;
 
-
     .custom-light-select:not(.custom-light-select-customize-input) .custom-light-select-selector {
       border-radius: 2px;
-      background-color: #F5F6F7FF;
+      background-color: #f5f6f7ff;
       padding: 0 2px;
     }
 
     .custom-dark-select:not(.custom-dark-select-customize-input) .custom-dark-select-selector {
       border-radius: 2px;
-      background-color: #494C5DFF;
+      background-color: #494c5dff;
       padding: 0 2px;
     }
 
     .custom-light-input-number {
       width: 100% !important;
       border-radius: 2px;
-      background-color: #F5F6F7FF;
+      background-color: #f5f6f7ff;
     }
 
     .custom-dark-input-number {
       width: 100% !important;
       border-radius: 2px;
-      background-color: #494C5DFF;
+      background-color: #494c5dff;
     }
 
     .custom-dark-select-single .custom-dark-select-selector .custom-dark-select-selection-search {
@@ -166,21 +173,20 @@ table {
 
     .custom-dark-picker {
       padding: 4px;
-      background: #494C5DFF;
+      background: #494c5dff;
     }
 
     .custom-dark-picker-input .custom-dark-picker-clear {
-      background: #494C5DFF;
+      background: #494c5dff;
     }
 
     .custom-light-picker {
       padding: 4px;
-      background: #F5F6F7FF;
+      background: #f5f6f7ff;
     }
 
     .custom-light-picker-input .custom-light-picker-clear {
-      background: #F5F6F7FF;
+      background: #f5f6f7ff;
     }
   }
-
-}
+}

package/dist/components/TableMax/TableHeader/utils.d.ts

@@ -0,0 +1 @@
+export declare const getPinningStyle: any;

package/dist/components/TableMax/TableMax.d.ts

@@ -0,0 +1,18 @@
+import { RowData } from '@tanstack/react-table';
+import React from 'react';
+import './tableMax.less';
+import type { TableContextType, TableMaxProps } from './type';
+declare module '@tanstack/react-table' {
+    interface TableMeta<TData extends RowData> {
+        updateData: (rowIndex: number, columnId: string, value: unknown) => void;
+    }
+}
+export declare enum ColumnType {
+    Selection = "selection-column",
+    Darg = "darg-column",
+    PlaceHolder = "placeholder-column",
+    Expander = "expander"
+}
+export declare const TableContext: React.Context<TableContextType>;
+declare const _default: React.ForwardRefExoticComponent<TableMaxProps & React.RefAttributes<unknown>>;
+export default _default;