@arim-aisdc/public-components 2.3.48 → 2.3.50

package/dist/components/TableMax/TableHeader/TableHeader.js

@@ -0,0 +1,14 @@
+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 React from 'react';
+import { useTableComponents } from "../hooks/useTableComponents";
+import { jsx as _jsx } from "react/jsx-runtime";
+export var TableHeader = function TableHeader(props) {
+  var _useTableComponents = useTableComponents(),
+    HeaderComponent = _useTableComponents.TableHeader;
+  return /*#__PURE__*/_jsx(HeaderComponent, _objectSpread({}, props));
+};

package/dist/components/TableMax/TableHeader/VirtualTableHeader/ColGroup.d.ts

@@ -0,0 +1,11 @@
+import React from 'react';
+interface ColGroupProps {
+    leftPinnedColumns: any[];
+    scrollableColumns: any[];
+    rightPinnedColumns: any[];
+    virtualColumns: any[];
+    virtualPaddingLeft: number;
+    virtualPaddingRight: number;
+}
+export declare const ColGroup: React.FC<ColGroupProps>;
+export {};

package/dist/components/TableMax/TableHeader/VirtualTableHeader/ColGroup.js

@@ -0,0 +1,33 @@
+import React from 'react';
+import { useVirtualConfig } from "../../hooks/useVirtualScroll";
+import { jsx as _jsx } from "react/jsx-runtime";
+import { Fragment as _Fragment } from "react/jsx-runtime";
+import { jsxs as _jsxs } from "react/jsx-runtime";
+export var ColGroup = function ColGroup(_ref) {
+  var leftPinnedColumns = _ref.leftPinnedColumns,
+    scrollableColumns = _ref.scrollableColumns,
+    rightPinnedColumns = _ref.rightPinnedColumns,
+    virtualColumns = _ref.virtualColumns,
+    virtualPaddingLeft = _ref.virtualPaddingLeft,
+    virtualPaddingRight = _ref.virtualPaddingRight;
+  var renderColumn = function renderColumn(column) {
+    var size = column.getSize() || 120;
+    return /*#__PURE__*/_jsx("col", {
+      width: size
+    }, column.id);
+  };
+  var _useVirtualConfig = useVirtualConfig(),
+    openVirtualColumns = _useVirtualConfig.openVirtualColumns;
+  console.log(scrollableColumns, rightPinnedColumns, virtualColumns, virtualPaddingLeft, virtualPaddingRight, 'leftPinnedColumns');
+  return /*#__PURE__*/_jsxs("colgroup", {
+    children: [leftPinnedColumns === null || leftPinnedColumns === void 0 ? void 0 : leftPinnedColumns.map(renderColumn), !openVirtualColumns ? scrollableColumns.map(renderColumn) : /*#__PURE__*/_jsxs(_Fragment, {
+      children: [Number(virtualPaddingLeft) > 0 && /*#__PURE__*/_jsx("col", {
+        width: virtualPaddingLeft
+      }), virtualColumns.map(function (virtualColumn) {
+        return renderColumn(scrollableColumns[virtualColumn.index]);
+      }), Number(virtualPaddingRight) > 0 && /*#__PURE__*/_jsx("col", {
+        width: virtualPaddingRight
+      })]
+    }), rightPinnedColumns === null || rightPinnedColumns === void 0 ? void 0 : rightPinnedColumns.map(renderColumn)]
+  });
+};

package/dist/components/TableMax/TableHeader/VirtualTableHeader/PinnedColumns.d.ts

@@ -0,0 +1,19 @@
+import React from 'react';
+interface PinnedColumnsProps {
+    columns: any[];
+    headerGroup: any;
+    position: 'left' | 'right';
+    table: any;
+    tableContentRef: React.RefObject<HTMLDivElement>;
+    hasGroup?: boolean;
+    canSorting?: boolean;
+    getHeaderCellProps?: (columns: any[]) => object;
+    columnResizeMode: any;
+    disableColumnDrag?: boolean;
+    headerRowNum: number;
+    canFilter?: boolean;
+    manualFiltering: boolean;
+    getDynamicFilterOptionsFn?: Function;
+}
+export declare const PinnedColumns: React.FC<PinnedColumnsProps>;
+export {};

package/dist/components/TableMax/TableHeader/VirtualTableHeader/PinnedColumns.js

@@ -0,0 +1,46 @@
+// components/TableHeader/PinnedColumns.tsx
+import React from 'react';
+import HeaderCell from "../Cell";
+import { findHeaderByColumn, getPinningStyle } from "../utils";
+import { jsx as _jsx } from "react/jsx-runtime";
+import { Fragment as _Fragment } from "react/jsx-runtime";
+export var PinnedColumns = function PinnedColumns(_ref) {
+  var columns = _ref.columns,
+    headerGroup = _ref.headerGroup,
+    position = _ref.position,
+    table = _ref.table,
+    tableContentRef = _ref.tableContentRef,
+    hasGroup = _ref.hasGroup,
+    canSorting = _ref.canSorting,
+    getHeaderCellProps = _ref.getHeaderCellProps,
+    columnResizeMode = _ref.columnResizeMode,
+    disableColumnDrag = _ref.disableColumnDrag,
+    headerRowNum = _ref.headerRowNum,
+    canFilter = _ref.canFilter,
+    manualFiltering = _ref.manualFiltering,
+    getDynamicFilterOptionsFn = _ref.getDynamicFilterOptionsFn;
+  return /*#__PURE__*/_jsx(_Fragment, {
+    children: columns.map(function (column) {
+      var header = findHeaderByColumn(headerGroup, column);
+      if (!header) return null;
+      return /*#__PURE__*/_jsx("th", {
+        colSpan: header.colSpan,
+        style: getPinningStyle(header, table, true),
+        children: /*#__PURE__*/_jsx(HeaderCell, {
+          header: header,
+          table: table,
+          tableContentRef: tableContentRef,
+          hasGroup: hasGroup,
+          canSorting: canSorting,
+          getHeaderCellProps: getHeaderCellProps,
+          columnResizeMode: columnResizeMode,
+          disableColumnDrag: disableColumnDrag,
+          headerRowNum: headerRowNum,
+          canFilter: canFilter,
+          manualFiltering: manualFiltering,
+          getDynamicFilterOptionsFn: getDynamicFilterOptionsFn
+        })
+      }, header.id);
+    })
+  });
+};

package/dist/components/TableMax/TableHeader/VirtualTableHeader/ScrollColumns.d.ts

@@ -0,0 +1,18 @@
+import React from 'react';
+interface ScrollColumnsProps {
+    scrollableColumns: any[];
+    headerGroup: any;
+    table: any;
+    tableContentRef: React.RefObject<HTMLDivElement>;
+    hasGroup?: boolean;
+    canSorting?: boolean;
+    getHeaderCellProps?: (columns: any[]) => object;
+    columnResizeMode: any;
+    disableColumnDrag?: boolean;
+    headerRowNum: number;
+    canFilter?: boolean;
+    manualFiltering: boolean;
+    getDynamicFilterOptionsFn?: Function;
+}
+export declare const ScrollColumns: React.FC<ScrollColumnsProps>;
+export {};

package/dist/components/TableMax/TableHeader/VirtualTableHeader/ScrollColumns.js

@@ -0,0 +1,47 @@
+// components/TableHeader/ScrollColumns.tsx
+import React from 'react';
+import HeaderCell from "../Cell";
+import { findHeaderByColumn } from "../utils";
+import { jsx as _jsx } from "react/jsx-runtime";
+import { Fragment as _Fragment } from "react/jsx-runtime";
+export var ScrollColumns = function ScrollColumns(_ref) {
+  var scrollableColumns = _ref.scrollableColumns,
+    headerGroup = _ref.headerGroup,
+    table = _ref.table,
+    tableContentRef = _ref.tableContentRef,
+    hasGroup = _ref.hasGroup,
+    canSorting = _ref.canSorting,
+    getHeaderCellProps = _ref.getHeaderCellProps,
+    columnResizeMode = _ref.columnResizeMode,
+    disableColumnDrag = _ref.disableColumnDrag,
+    headerRowNum = _ref.headerRowNum,
+    canFilter = _ref.canFilter,
+    manualFiltering = _ref.manualFiltering,
+    getDynamicFilterOptionsFn = _ref.getDynamicFilterOptionsFn;
+  return /*#__PURE__*/_jsx(_Fragment, {
+    children: scrollableColumns.map(function (column) {
+      var header = findHeaderByColumn(headerGroup, column);
+      if (!header) return null;
+      return /*#__PURE__*/_jsx("th", {
+        colSpan: header.colSpan,
+        style: {
+          width: "".concat(header.getSize(), "px")
+        },
+        children: /*#__PURE__*/_jsx(HeaderCell, {
+          header: header,
+          table: table,
+          tableContentRef: tableContentRef,
+          hasGroup: hasGroup,
+          canSorting: canSorting,
+          getHeaderCellProps: getHeaderCellProps,
+          columnResizeMode: columnResizeMode,
+          disableColumnDrag: disableColumnDrag,
+          headerRowNum: headerRowNum,
+          canFilter: canFilter,
+          manualFiltering: manualFiltering,
+          getDynamicFilterOptionsFn: getDynamicFilterOptionsFn
+        })
+      }, header.id);
+    })
+  });
+};

package/dist/components/TableMax/TableHeader/VirtualTableHeader/VirtualColumns.d.ts

@@ -0,0 +1,19 @@
+import React from 'react';
+interface VirtualColumnsProps {
+    virtualColumns: any[];
+    scrollableColumns: any[];
+    headerGroup: any;
+    table: any;
+    tableContentRef: React.RefObject<HTMLDivElement>;
+    hasGroup?: boolean;
+    canSorting?: boolean;
+    getHeaderCellProps?: (columns: any[]) => object;
+    columnResizeMode: any;
+    disableColumnDrag?: boolean;
+    headerRowNum: number;
+    canFilter?: boolean;
+    manualFiltering: boolean;
+    getDynamicFilterOptionsFn?: Function;
+}
+export declare const VirtualColumns: React.FC<VirtualColumnsProps>;
+export {};

package/dist/components/TableMax/TableHeader/VirtualTableHeader/VirtualColumns.js

@@ -0,0 +1,49 @@
+// components/TableHeader/VirtualColumns.tsx
+import React from 'react';
+import HeaderCell from "../Cell";
+import { findHeaderByColumn } from "../utils";
+import { jsx as _jsx } from "react/jsx-runtime";
+import { Fragment as _Fragment } from "react/jsx-runtime";
+export var VirtualColumns = function VirtualColumns(_ref) {
+  var virtualColumns = _ref.virtualColumns,
+    scrollableColumns = _ref.scrollableColumns,
+    headerGroup = _ref.headerGroup,
+    table = _ref.table,
+    tableContentRef = _ref.tableContentRef,
+    hasGroup = _ref.hasGroup,
+    canSorting = _ref.canSorting,
+    getHeaderCellProps = _ref.getHeaderCellProps,
+    columnResizeMode = _ref.columnResizeMode,
+    disableColumnDrag = _ref.disableColumnDrag,
+    headerRowNum = _ref.headerRowNum,
+    canFilter = _ref.canFilter,
+    manualFiltering = _ref.manualFiltering,
+    getDynamicFilterOptionsFn = _ref.getDynamicFilterOptionsFn;
+  return /*#__PURE__*/_jsx(_Fragment, {
+    children: virtualColumns.map(function (virtualColumn) {
+      var column = scrollableColumns[virtualColumn.index];
+      var header = findHeaderByColumn(headerGroup, column);
+      if (!header) return null;
+      return /*#__PURE__*/_jsx("th", {
+        colSpan: header.colSpan,
+        style: {
+          width: "".concat(header.getSize(), "px")
+        },
+        children: /*#__PURE__*/_jsx(HeaderCell, {
+          header: header,
+          table: table,
+          tableContentRef: tableContentRef,
+          hasGroup: hasGroup,
+          canSorting: canSorting,
+          getHeaderCellProps: getHeaderCellProps,
+          columnResizeMode: columnResizeMode,
+          disableColumnDrag: disableColumnDrag,
+          headerRowNum: headerRowNum,
+          canFilter: canFilter,
+          manualFiltering: manualFiltering,
+          getDynamicFilterOptionsFn: getDynamicFilterOptionsFn
+        })
+      }, header.id);
+    })
+  });
+};

package/dist/components/TableMax/TableHeader/VirtualTableHeader/VirtualPadding.d.ts

@@ -0,0 +1,7 @@
+import React from 'react';
+interface VirtualPaddingProps {
+    type: 'left' | 'right';
+    width: number;
+}
+export declare const VirtualPadding: React.FC<VirtualPaddingProps>;
+export {};

package/dist/components/TableMax/TableHeader/VirtualTableHeader/VirtualPadding.js

@@ -0,0 +1,16 @@
+import React from 'react';
+import { jsx as _jsx } from "react/jsx-runtime";
+export var VirtualPadding = function VirtualPadding(_ref) {
+  var type = _ref.type,
+    width = _ref.width;
+  if (width <= 0) return null;
+  return /*#__PURE__*/_jsx("th", {
+    style: {
+      width: "".concat(width, "px"),
+      padding: 0,
+      border: 'none',
+      background: 'transparent'
+    },
+    "aria-hidden": "true"
+  });
+};

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

@@ -0,0 +1,4 @@
+import React from 'react';
+import { TableHeaderProps } from '../OriginalTableHeader';
+import './index.less';
+export declare const VirtualTableHeader: React.FC<TableHeaderProps>;

package/dist/components/TableMax/TableHeader/VirtualTableHeader/index.js

@@ -0,0 +1,79 @@
+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 React from 'react';
+import { useVirtualConfig, useVirtualState } from "../../hooks/useVirtualScroll";
+import { ColGroup } from "./ColGroup";
+import { PinnedColumns } from "./PinnedColumns";
+import { VirtualPadding } from "./VirtualPadding";
+import { VirtualColumns } from "./VirtualColumns";
+import "./index.less";
+import { ScrollColumns } from "./ScrollColumns";
+import { jsx as _jsx } from "react/jsx-runtime";
+import { Fragment as _Fragment } from "react/jsx-runtime";
+import { jsxs as _jsxs } from "react/jsx-runtime";
+export var VirtualTableHeader = function VirtualTableHeader(props) {
+  var table = props.table,
+    hasGroup = props.hasGroup,
+    _props$rowHeight = props.rowHeight,
+    rowHeight = _props$rowHeight === void 0 ? 40 : _props$rowHeight;
+  var state = useVirtualState();
+  var config = useVirtualConfig();
+  var headerGroups = table.getHeaderGroups();
+  var leftPinnedColumns = state.leftPinnedColumns,
+    rightPinnedColumns = state.rightPinnedColumns,
+    scrollableColumns = state.scrollableColumns,
+    virtualColumns = state.virtualColumns,
+    virtualPaddingLeft = state.virtualPaddingLeft,
+    virtualPaddingRight = state.virtualPaddingRight;
+  return /*#__PURE__*/_jsxs("table", {
+    children: [/*#__PURE__*/_jsx(ColGroup, {
+      leftPinnedColumns: leftPinnedColumns,
+      scrollableColumns: scrollableColumns,
+      rightPinnedColumns: rightPinnedColumns,
+      virtualColumns: virtualColumns,
+      virtualPaddingLeft: virtualPaddingLeft,
+      virtualPaddingRight: virtualPaddingRight
+    }), /*#__PURE__*/_jsx("thead", {
+      children: headerGroups.map(function (headerGroup) {
+        return /*#__PURE__*/_jsxs("tr", {
+          className: "table-thead-tr cus-table-thead-tr",
+          style: {
+            height: hasGroup && headerGroup.depth === 0 ? "".concat(rowHeight, "px") : 'auto',
+            width: '100%',
+            position: 'relative'
+          },
+          children: [/*#__PURE__*/_jsx(PinnedColumns, _objectSpread({
+            columns: leftPinnedColumns,
+            headerGroup: headerGroup,
+            position: "left"
+          }, props)), !config.openVirtualColumns ? /*#__PURE__*/_jsx(_Fragment, {
+            children: /*#__PURE__*/_jsx(ScrollColumns, _objectSpread({
+              scrollableColumns: scrollableColumns,
+              headerGroup: headerGroup
+            }, props))
+          }) : /*#__PURE__*/_jsxs(_Fragment, {
+            children: [/*#__PURE__*/_jsx(VirtualPadding, {
+              type: "left",
+              width: virtualPaddingLeft
+            }), /*#__PURE__*/_jsx(VirtualColumns, _objectSpread({
+              virtualColumns: virtualColumns,
+              scrollableColumns: scrollableColumns,
+              headerGroup: headerGroup
+            }, props)), /*#__PURE__*/_jsx(VirtualPadding, {
+              type: "right",
+              width: virtualPaddingRight
+            })]
+          }), /*#__PURE__*/_jsx(PinnedColumns, _objectSpread({
+            columns: rightPinnedColumns,
+            headerGroup: headerGroup,
+            position: "right"
+          }, props))]
+        }, headerGroup.id);
+      })
+    })]
+  });
+};

package/dist/components/TableMax/TableHeader/VirtualTableHeader/index.less

@@ -0,0 +1,225 @@
+table {
+  table-layout: fixed;
+  // background: @globalColor_14;
+  width: 100%;
+  border-collapse: collapse;
+  
+  // overflow: hidden;
+
+  th {
+    position: relative;
+    padding: 0;
+    border: 0;
+    background: @globalColor_14;
+    z-index: 1;
+  }
+
+  .th-scroll {
+    position: sticky;
+    right: 0;
+  }
+}
+
+.cell-wapper {
+  background: @globalColor_14;
+  height: fit-content;
+  line-height: 16px;
+  display: flex;
+  font-weight: 400;
+  padding: 8px;
+  text-align: left;
+  font-size: 14px;
+  // border-bottom: 1px solid @tableColor2;
+
+  .cell-left {
+    flex: 1;
+    // text-align: center;
+    user-select: none;
+    touch-action: none;
+    color: @tableColor1;
+    cursor: pointer;
+    overflow: hidden;
+    white-space: nowrap;
+    display: flex;
+    align-items: center;
+    justify-content: space-between;
+    height: 100%;
+
+    .cell-left-header {
+      display: -webkit-box;
+      -webkit-box-orient: vertical;
+      overflow: hidden;
+      text-overflow: ellipsis;
+      white-space: normal;
+      word-break: break-all;
+
+      .ant-checkbox-wrapper {
+        line-height: 16px;
+      }
+    }
+  }
+
+  .cell-right {
+    display: flex;
+    // gap: 4px;
+    align-items: center;
+  }
+
+  .drag-handler {
+    color: @tableColor3;
+    display: none;
+    // opacity: 0;
+    cursor: move;
+    position: absolute;
+    right: 5px;
+  }
+
+  &:hover .drag-handler {
+    display: inline-block;
+    // opacity: 1;
+  }
+  &:hover {
+    .sort-flag {
+      display: flex;
+    }
+    .filter-icon {
+      display: inline-block;
+    }
+  }
+
+  .cell-resize-handler {
+    position: absolute;
+    right: 0;
+    top: 30%;
+    height: 40%;
+    width: 5px;
+    border-right: 2px solid @globalColor_15;
+    cursor: ew-resize;
+    user-select: none;
+    touch-action: none;
+    z-index: 99999;
+
+    &:hover {
+      border-right: 5px solid @globalColor_15;
+      top: 0%;
+      height: 100%;
+      z-index: 99999;
+      cursor: ew-resize;
+    }
+  }
+
+  .cell-resize-handler::after {
+    content: '';
+    position: absolute;
+    right: 0;
+    top: 0;
+    bottom: 0;
+    width: 5px;
+    cursor: ew-resize;
+  }
+
+  .column-resizer.column-is-resizing {
+    height: 60%;
+    top: 20%;
+  }
+
+
+
+  
+
+}
+
+.table-thead-tr:nth-last-child(2) {
+  .table-max-header-cell-wrapper {
+    border-bottom: none !important;
+  }
+}
+
+.table-max-header-cell-wrapper {
+  font-weight: @global-table-max-header-font-weight;
+}
+
+.table-filter-tr {
+  border-top: 1px solid @tableColor2;
+
+  .table-filter-th {
+    text-align: center;
+    vertical-align: top;
+    padding: 6px 4px;
+
+    .custom-light-select:not(.custom-light-select-customize-input) .custom-light-select-selector {
+      border-radius: 2px;
+      background-color: @global-curd-input-background-color;
+      padding: 0 2px;
+    }
+
+    .custom-dark-select:not(.custom-dark-select-customize-input) .custom-dark-select-selector {
+      border-radius: 2px;
+      background-color: @global-curd-input-background-color;
+      padding: 0 2px;
+    }
+
+    .custom-light-input-number {
+      width: 100% !important;
+      border-radius: 2px;
+      background-color: @global-curd-input-background-color;
+    }
+
+    .custom-dark-input-number {
+      width: 100% !important;
+      border-radius: 2px;
+      background-color: @global-curd-input-background-color;
+    }
+
+    .custom-dark-select-single .custom-dark-select-selector .custom-dark-select-selection-search {
+      left: 2px;
+      right: 2px;
+    }
+
+    .custom-dark-select-single .custom-dark-select-clear {
+      background: transparent;
+    }
+
+    .custom-light-select-single .custom-light-select-selector .custom-light-select-selection-search {
+      left: 2px;
+      right: 2px;
+    }
+
+    .custom-dark-picker {
+      padding: 4px;
+      background: @global-curd-input-background-color;
+    }
+
+    .custom-dark-input-affix-wrapper,
+    .custom-dark-picker-input .custom-dark-picker-clear {
+      background: @global-curd-input-background-color;
+    }
+
+    .custom-light-picker {
+      padding: 4px;
+      background: @global-curd-input-background-color;
+    }
+
+    .custom-light-input-affix-wrapper,
+    .custom-light-input,
+    .custom-light-picker-input .custom-light-picker-clear {
+      background: @global-curd-input-background-color;
+    }
+  }
+}
+
+.column-resizing-divide-line {
+  height: 300px;
+  width: 2px;
+  position: fixed;
+  z-index: 99999;
+  // background-color: #000;
+  background-color: green;
+}
+.column-resizing-divide-line {
+  will-change: transform;
+  backface-visibility: hidden;
+  transform: translate3d(0, 0, 0);
+  contain: strict;
+  cursor: ew-resize;
+}

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

@@ -1,21 +1,4 @@
-import { ColumnResizeMode } from '@tanstack/react-table';
-import { MutableRefObject } from 'react';
-import { TableMaxColumnType } from '../type';
-import './index.less';
-type TableHeaderProps = {
-    table: any;
-    tableContentRef: MutableRefObject<HTMLDivElement> | null;
-    canFilter?: boolean;
-    enableFilters?: boolean;
-    canSorting?: boolean;
-    rowHeight?: number;
-    hasGroup?: boolean;
-    getHeaderCellProps?: (columns: TableMaxColumnType[]) => object;
-    columnResizeMode: ColumnResizeMode;
-    disableColumnDrag?: boolean;
-    headerRowNum: number;
-    manualFiltering: boolean;
-    getDynamicFilterOptionsFn?: Function;
-};
-declare const TableHeader: ({ tableContentRef, table, canFilter, enableFilters, canSorting, hasGroup, getHeaderCellProps, columnResizeMode, disableColumnDrag, rowHeight, headerRowNum, manualFiltering, getDynamicFilterOptionsFn }: TableHeaderProps) => import("react/jsx-runtime").JSX.Element;
+import { TableHeader } from './TableHeader';
+export { VirtualTableHeader } from './VirtualTableHeader';
+export { OriginalTableHeader } from './OriginalTableHeader';
 export default TableHeader;