es-grid-template 1.8.71 → 1.8.73

package/lib/group-component/ColumnsGroup/ColumnsGroup.js

@@ -0,0 +1,241 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.ColumnsGroup = void 0;
+var _becoxyIcons = require("becoxy-icons");
+var _react = _interopRequireWildcard(require("react"));
+var _antd = require("antd");
+var _rcMasterUi = require("rc-master-ui");
+var _styledComponents = _interopRequireDefault(require("styled-components"));
+var _hooks = require("../../grid-component/hooks");
+function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function (e) { return e ? t : r; })(e); }
+function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != typeof e && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && Object.prototype.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
+// import {
+//   // groupArrayByColumns,
+//   // ungroupArray,
+//   // useOnClickOutside
+// } from "../../hooks"
+
+// import {SettingOutlined} from "@ant-design/icons";
+
+const BoxAction = _styledComponents.default.div.withConfig({
+  displayName: "BoxAction",
+  componentId: "es-grid-template__sc-9e0ekv-0"
+})(["padding-top:.75rem;display:flex;justify-content:end;gap:10px;.btn-action{background:none !important;border:none !important;&.btn-action-submit{color:#df4318;&:disabled{background-color:#f0f0f0 !important;}&:hover{color:#df4318 !important;}}&:hover{background-color:#f0f0f0 !important;}}"]);
+const ColumnsGroup = props => {
+  const {
+    columns,
+    columnsGrouped,
+    onSubmit,
+    unClearableLevel,
+    defaultGroupColumns,
+    t
+  } = props;
+  const menuRef = (0, _react.useRef)();
+  const [tempGroup, setTempGroup] = (0, _react.useState)([]);
+  const [clicked, setClicked] = (0, _react.useState)(false);
+  const rsCol = _react.default.useMemo(() => {
+    return columns.filter(it => it.visible !== false && !tempGroup.includes(it.field) && it.field !== '#' && it.field !== 'selection_column' && it.field !== 'command');
+  }, [columns, tempGroup]);
+  const options = _react.default.useMemo(() => {
+    return rsCol.map(it => ({
+      ...it,
+      value: it.field,
+      label: t ? t(it?.columnGroupText ?? it?.headerText) : it?.columnGroupText ?? it?.headerText
+    }));
+  }, [rsCol, t]);
+
+  // React.useEffect(() => {
+  //   if(columnsGrouped) {
+  //     setTempGroup([...columnsGrouped])
+  //   }
+  //
+  // }, [!!columnsGrouped])
+
+  const onChangeGroupColumns = (option, index) => {
+    // if (option) {
+    //   tempGroup[index] = option
+    // } else {
+    //   tempGroup.splice(index, 1)
+    // }
+    // setTempGroup([...tempGroup])
+
+    const cloneTemp = [...tempGroup];
+    if (option) {
+      cloneTemp[index] = option;
+    } else {
+      cloneTemp.splice(index, 1);
+    }
+    setTempGroup([...cloneTemp]);
+  };
+  const handleGroup = () => {
+    // setColumnsGrouped([...tempGroup])
+    setClicked(false);
+    // const dt = ungroupArray(dataSource)
+
+    // const rs = groupArrayByColumns(dt, [...tempGroup])
+
+    // setResource([...rs])
+    onSubmit([...tempGroup]);
+  };
+  const handleClear = () => {
+    // setColumnsGrouped([])
+    setTempGroup(defaultGroupColumns ? defaultGroupColumns : []);
+    // setIsOpen(false)
+    setClicked(false);
+    // const dt = ungroupArray(dataSource)
+
+    // const rs = groupArrayByColumns(dt, [])
+
+    // setResource([...rs])
+    onSubmit(defaultGroupColumns ? defaultGroupColumns : []);
+  };
+  const handleClickChange = open => {
+    setClicked(open);
+    if (open) {
+      if (columnsGrouped) {
+        setTempGroup([...columnsGrouped]);
+      }
+    }
+    if (!open) {
+      setTempGroup([]);
+    }
+  };
+  return /*#__PURE__*/_react.default.createElement(_react.default.Fragment, null, /*#__PURE__*/_react.default.createElement(_antd.Popover, {
+    placement: 'bottomLeft',
+    content: /*#__PURE__*/_react.default.createElement("div", {
+      style: {
+        minWidth: 250
+      }
+    }, /*#__PURE__*/_react.default.createElement("div", {
+      ref: menuRef,
+      style: {
+        position: 'relative'
+      }
+    }, /*#__PURE__*/_react.default.createElement("p", {
+      className: 'fw-bold'
+    }, "Nh\xF3m d\u1EEF li\u1EC7u theo c\u1ED9t"), /*#__PURE__*/_react.default.createElement("div", {
+      className: 'mb-1',
+      style: {
+        marginBottom: '1rem'
+      }
+    }, /*#__PURE__*/_react.default.createElement("p", {
+      className: 'm-0',
+      style: {
+        margin: 0
+      }
+    }, "M\u1EE9c 1"), /*#__PURE__*/_react.default.createElement(_rcMasterUi.Select, {
+      style: {
+        width: '100%'
+      },
+      showSearch: true
+      // labelInValue={true}
+      // options={columns.filter((it: any) => !tempGroup.includes(it.field))}
+      // options={columns && columns.length > 0 ? options : []}
+      ,
+      options: options,
+      value: tempGroup?.[0],
+      onChange: val => onChangeGroupColumns(val, 0),
+      allowClear: !tempGroup?.[1] && !(unClearableLevel && unClearableLevel - 1 >= 0)
+      // fieldNames={{
+      //   value: 'field',
+      //   label: 'headerText'
+      // }}
+      ,
+      labelRender: labelProps => {
+        const it = columns.find(col => col.field === labelProps.value);
+        return t ? t(it?.columnGroupText ?? it?.headerText) : it?.columnGroupText ?? it?.headerText;
+      },
+      filterOption: _hooks.customFilterOption
+      // hideSelectedOptions
+    })), /*#__PURE__*/_react.default.createElement("div", {
+      className: 'mb-1',
+      style: {
+        marginBottom: '1rem'
+      }
+    }, /*#__PURE__*/_react.default.createElement("p", {
+      className: 'm-0',
+      style: {
+        margin: 0
+      }
+    }, "M\u1EE9c 2"), /*#__PURE__*/_react.default.createElement(_rcMasterUi.Select, {
+      showSearch: true,
+      style: {
+        width: '100%'
+      },
+      options: options,
+      value: tempGroup?.[1],
+      onChange: val => onChangeGroupColumns(val, 1),
+      allowClear: !tempGroup?.[2] && !(unClearableLevel && unClearableLevel - 2 >= 0)
+      // hideSelectedOptions
+      // fieldNames={{
+      //   value: 'field',
+      //   label: 'headerText'
+      // }}
+      ,
+      labelRender: labelProps => {
+        const it = columns.find(col => col.field === labelProps.value);
+        return t ? t(it?.columnGroupText ?? it?.headerText) : it?.columnGroupText ?? it?.headerText;
+      },
+      filterOption: _hooks.customFilterOption
+    })), /*#__PURE__*/_react.default.createElement("div", {
+      className: 'mb-1',
+      style: {
+        marginBottom: '1rem'
+      }
+    }, /*#__PURE__*/_react.default.createElement("p", {
+      className: 'm-0',
+      style: {
+        margin: 0
+      }
+    }, "M\u1EE9c 3"), /*#__PURE__*/_react.default.createElement(_rcMasterUi.Select, {
+      style: {
+        width: '100%'
+      },
+      options: options,
+      showSearch: true,
+      value: tempGroup?.[2],
+      onChange: val => onChangeGroupColumns(val, 2),
+      allowClear: !!tempGroup?.[2] && !(unClearableLevel && unClearableLevel - 3 >= 0)
+      // fieldNames={{
+      //   value: 'field',
+      //   label: 'headerText'
+      // }}
+      ,
+      labelRender: labelProps => {
+        const it = columns.find(col => col.field === labelProps.value);
+        return t ? t(it?.columnGroupText ?? it?.headerText) : it?.columnGroupText ?? it?.headerText;
+      },
+      filterOption: _hooks.customFilterOption
+    }))), /*#__PURE__*/_react.default.createElement(BoxAction, {
+      className: 'px-1'
+    }, /*#__PURE__*/_react.default.createElement(_antd.Button
+    // className={classnames('btn-action btn-action-submit', {
+    //   // disable: !columns.find((item) => item.visible !== false || item.visible)
+    // })}
+    , {
+      onClick: handleGroup
+      // disabled={!columns.find((item) => item.visible !== false || item.visible)}
+    }, t ? t('Thực hiện') : 'Thực hiện'), /*#__PURE__*/_react.default.createElement(_antd.Button, {
+      className: 'btn-action btn-action-cancel',
+      onClick: handleClear
+    }, t ? t('Clear') : 'Clear'))),
+    trigger: "click",
+    open: clicked,
+    onOpenChange: handleClickChange,
+    arrow: false
+  }, /*#__PURE__*/_react.default.createElement(_antd.Tooltip, {
+    arrow: false,
+    title: 'Nhóm dữ liệu'
+  }, /*#__PURE__*/_react.default.createElement(_becoxyIcons.Group, {
+    fontSize: 18,
+    color: "#555555",
+    style: {
+      cursor: 'pointer'
+    }
+  }))));
+};
+exports.ColumnsGroup = ColumnsGroup;

package/lib/group-component/ColumnsGroup/index.d.ts

@@ -0,0 +1 @@
+export * from './ColumnsGroup';

package/lib/group-component/ColumnsGroup/index.js

@@ -0,0 +1,16 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var _ColumnsGroup = require("./ColumnsGroup");
+Object.keys(_ColumnsGroup).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _ColumnsGroup[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _ColumnsGroup[key];
+    }
+  });
+});

package/lib/group-component/ContextMenu.d.ts

@@ -0,0 +1,19 @@
+import * as React from "react";
+import type { ContextInfo, ContextMenuItem } from "./../grid-component/type";
+export declare const findItemByKey: (array: any[], key: string, value: any) => any;
+type Props<RecordType> = {
+    rowData: RecordType | null;
+    contextMenuItems: ContextMenuItem[];
+    contextMenuClick?: (args: ContextInfo<RecordType>) => void;
+    open: boolean;
+    menuRef?: any;
+    setOpen: (open: boolean) => void;
+    pos: {
+        x: number | undefined;
+        y: number | undefined;
+        viewportWidth: number;
+        viewportHeight: number;
+    };
+};
+declare const ContextMenu: <RecordType extends object>(props: Props<RecordType>) => React.JSX.Element;
+export default ContextMenu;

package/lib/group-component/ContextMenu.js

@@ -0,0 +1,83 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.findItemByKey = exports.default = void 0;
+var React = _interopRequireWildcard(require("react"));
+var _antd = require("antd");
+function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function (e) { return e ? t : r; })(e); }
+function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != typeof e && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && Object.prototype.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
+const findItemByKey = (array, key, value) => {
+  for (let i = 0; i < array.length; i++) {
+    const item = array[i];
+    if (item[key] === value) {
+      return item;
+    }
+    if (item.children && item.children.length > 0) {
+      const foundInChildren = findItemByKey(item.children, key, value);
+      if (foundInChildren) {
+        return foundInChildren;
+      }
+    }
+  }
+  return null;
+};
+exports.findItemByKey = findItemByKey;
+const ContextMenu = props => {
+  const {
+    menuRef,
+    open,
+    setOpen,
+    pos,
+    contextMenuClick,
+    contextMenuItems,
+    rowData
+  } = props;
+  return /*#__PURE__*/React.createElement(_antd.Dropdown, {
+    placement: 'topRight',
+    open: open,
+    overlayClassName: 'be-popup-container',
+    overlayStyle: {
+      left: `${pos.x}px`,
+      top: `${pos.y}px`
+    },
+    dropdownRender: () => {
+      return /*#__PURE__*/React.createElement("div", {
+        ref: menuRef
+      }, /*#__PURE__*/React.createElement(_antd.Menu, {
+        items: contextMenuItems,
+        style: {
+          minWidth: 200,
+          maxHeight: pos.viewportHeight - 20,
+          width: 'fit-content'
+        },
+        rootClassName: 'popup-context-menu'
+        // rootClassName={'be-popup-container'}
+        ,
+
+        onClick: e => {
+          setOpen(false);
+          contextMenuClick?.({
+            rowInfo: {
+              rowData
+            },
+            event: e.domEvent,
+            item: {
+              ...findItemByKey(contextMenuItems, 'key', e.key),
+              id: e.key
+            }
+          });
+
+          // if (!open) {
+          //   document.addEventListener(`click`, function onClickOutside() {
+          //     setOpen(false);
+          //     document.removeEventListener(`click`, onClickOutside);
+          //   });
+          // }
+        }
+      }));
+    }
+  }, /*#__PURE__*/React.createElement(React.Fragment, null));
+};
+var _default = exports.default = ContextMenu;

package/lib/group-component/InternalTable.d.ts

@@ -0,0 +1,8 @@
+import React from 'react';
+import 'react-resizable/css/styles.css';
+import 'dayjs/locale/es';
+import 'dayjs/locale/vi';
+import './style.scss';
+import type { TableProps } from './../grid-component/type';
+declare const InternalTable: <RecordType extends object>(props: TableProps<RecordType>) => React.JSX.Element;
+export default InternalTable;

package/lib/group-component/InternalTable.js

@@ -0,0 +1,233 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _extends2 = _interopRequireDefault(require("@babel/runtime/helpers/extends"));
+var _customParseFormat = _interopRequireDefault(require("dayjs/plugin/customParseFormat"));
+var _react = _interopRequireWildcard(require("react"));
+require("react-resizable/css/styles.css");
+var _dayjs = _interopRequireDefault(require("dayjs"));
+require("dayjs/locale/es");
+require("dayjs/locale/vi");
+require("./style.scss");
+var _faker = require("@faker-js/faker");
+var _useMergedState = _interopRequireDefault(require("rc-util/lib/hooks/useMergedState"));
+var _Grid = _interopRequireDefault(require("./table/Grid"));
+var _utils = require("./hook/utils");
+var _useColumns = require("./hook/useColumns");
+var _convert = require("./hook/convert");
+var _hooks = require("../grid-component/hooks");
+var _utils2 = require("../table-virtuoso/hook/utils");
+function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function (e) { return e ? t : r; })(e); }
+function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != typeof e && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && Object.prototype.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
+_dayjs.default.extend(_customParseFormat.default);
+const InternalTable = props => {
+  const {
+    t,
+    columns: propsColumns,
+    // columns,
+    lang,
+    locale,
+    dataSource,
+    editAble,
+    format,
+    groupAble,
+    groupSetting,
+    groupColumns,
+    selectionSettings,
+    expandable,
+    onChooseColumns,
+    // contextMenuClick,
+    // contextMenuOpen,
+    height,
+    ...rest
+  } = props;
+  const id = _react.default.useMemo(() => {
+    return _faker.faker.string.alpha(20);
+  }, []);
+  const {
+    defaultExpandedRowKeys,
+    defaultExpandAllRows
+  } = expandable || {};
+  const rowKey = 'rowId';
+  const prefix = 'ui-rc';
+  const getWindowSize = () => {
+    const {
+      innerWidth,
+      innerHeight
+    } = window;
+    return {
+      innerWidth,
+      innerHeight
+    };
+  };
+  const [windowSize, setWindowSize] = (0, _react.useState)(getWindowSize());
+  _react.default.useEffect(() => {
+    const handleWindowResize = () => {
+      setWindowSize(getWindowSize());
+    };
+    window.addEventListener('resize', handleWindowResize);
+    return () => {
+      window.removeEventListener('resize', handleWindowResize);
+    };
+  }, []);
+  const [filterStates, setFilterState] = _react.default.useState(null);
+  const [sorterStates, setSorterStates] = _react.default.useState([]);
+  const [isFullScreen, setIsFullScreen] = _react.default.useState(false);
+  const [columns, setColumns] = _react.default.useState([]);
+  _react.default.useEffect(() => {
+    // setColumns(propsColumns as any)
+
+    setColumns((0, _utils.updateWidthsByOther)(propsColumns, columns));
+  }, [propsColumns]);
+  const originData = _react.default.useMemo(() => {
+    return (0, _utils.addRowIdArray)(dataSource);
+  }, [dataSource]);
+  const [expanded, setExpanded] = _react.default.useState({});
+  const [columnPinning, setColumnPinning] = _react.default.useState({});
+  const [columnVisibility, setColumnVisibility] = _react.default.useState({});
+  const convertData = _react.default.useMemo(() => {
+    if (groupAble && groupSetting?.client !== false) {
+      return (0, _utils2.groupArrayByColumns)(originData, groupColumns);
+    }
+    return originData;
+  }, [originData, groupAble, groupColumns, groupSetting?.client]);
+  const mergedColumns = _react.default.useMemo(() => {
+    return (0, _useColumns.convertToTanStackColumns)({
+      t,
+      columns,
+      format,
+      editAble
+    });
+
+    // return convertToTanStackColumns<RecordType>(columns)
+  }, [t, columns, format, editAble, groupColumns]);
+  const isDataTree = _react.default.useMemo(() => {
+    return (0, _utils.isTreeArray)(convertData);
+  }, [convertData]);
+
+  // const isDataOriginTree = React.useMemo(() => {
+
+  //   return isTreeArray(originData)
+
+  // }, [originData])
+
+  // const columnPinning = React.useMemo(() => {
+  //   return {
+  //     left: groupColumns ? [...getFixedFields(columns, 'left'), ...groupColumns] : getFixedFields(columns, 'left'),
+  //     right: getFixedFields(columns, 'right')
+  //   }
+  // }, [columns, groupColumns])
+
+  _react.default.useEffect(() => {
+    const abc = {
+      // left: groupColumns ? [...getFixedFields(columns, 'left'), ...groupColumns] : getFixedFields(columns, 'left'),
+      left: (0, _utils.getFixedFields)(columns, 'left'),
+      right: (0, _utils.getFixedFields)(columns, 'right')
+    };
+    setColumnPinning(abc);
+  }, [columns]);
+
+  // ========================= Keys =========================
+  const [mergedFilterKeys, setMergedFilterKeys] = (0, _useMergedState.default)((0, _utils.getAllRowKey)(convertData), {
+    value: undefined
+  });
+  _react.default.useEffect(() => {
+    if (defaultExpandAllRows) {
+      const allKeys = (0, _utils.findAllChildrenKeys2)(convertData, rowKey, 'children');
+      setExpanded((0, _utils.convertToObjTrue)(allKeys));
+    } else {
+      if (defaultExpandedRowKeys) {
+        setExpanded((0, _utils.convertToObjTrue)(defaultExpandedRowKeys ?? []));
+      }
+    }
+  }, [defaultExpandAllRows, convertData, defaultExpandedRowKeys]);
+
+  // ========================= Keys =========================
+
+  const {
+    selectedRowKeys,
+    defaultSelectedRowKeys
+  } = selectionSettings ?? {};
+  const [mergedSelectedKeys] = (0, _useMergedState.default)(selectedRowKeys || defaultSelectedRowKeys || [], {
+    value: selectedRowKeys
+  });
+  const mergedData = _react.default.useMemo(() => {
+    return (0, _utils.filterDataByColumns)(convertData, filterStates, sorterStates, mergedFilterKeys);
+  }, [convertData, filterStates, mergedFilterKeys, sorterStates]);
+  _react.default.useEffect(() => {
+    const a = (0, _utils.getInvisibleColumns)(columns);
+
+    // const bcd = convertToObj(groupColumns)
+
+    setColumnVisibility({
+      ...a
+    });
+  }, [columns]);
+  const [columnsHiddenKeys, setColumnsHiddenKeys] = (0, _useMergedState.default)(undefined, {
+    value: undefined
+  });
+  const triggerChangeColumns = (cols, keys, type) => {
+    if (type === 'cellClick') {
+      setColumns(cols);
+    } else {
+      const aa = (0, _utils.flatColumns2)(columns).map(it => it.field);
+      const rsss = (0, _utils.getDiffent2Array)(aa, keys);
+      setColumnsHiddenKeys(rsss);
+      onChooseColumns?.({
+        showColumns: (0, _hooks.removeInvisibleColumns)([...cols]),
+        columns: [...cols],
+        flattenColumns: (0, _utils.convertFlatColumn1)([...cols])
+      });
+    }
+  };
+  return /*#__PURE__*/_react.default.createElement(_react.Fragment, null, /*#__PURE__*/_react.default.createElement(_Grid.default, (0, _extends2.default)({}, rest, {
+    t: t,
+    id: id,
+    prefix: prefix
+
+    // originData={convertData}
+    ,
+    originData: originData,
+    dataSource: mergedData,
+    locale: locale,
+    format: format
+    // columns={columns111 as any}
+    ,
+    columns: (0, _convert.convertColumns)(mergedColumns),
+    propsColumns: columns,
+    rowKey: rowKey,
+    groupSetting: groupSetting,
+    groupAble: groupAble,
+    groupColumns: groupColumns,
+    columnPinning: columnPinning,
+    setColumnPinning: setColumnPinning,
+    columnHidden: columnsHiddenKeys ? (0, _utils.convertToObj)(columnsHiddenKeys) : columnVisibility,
+    triggerFilter: setFilterState,
+    triggerSorter: setSorterStates,
+    setMergedFilterKeys: setMergedFilterKeys,
+    mergedFilterKeys: mergedFilterKeys,
+    expanded: expanded,
+    editAble: isFullScreen ? false : editAble,
+    triggerChangeColumns: triggerChangeColumns
+    // triggerGroupColumns={triggerGroupColumns}
+    ,
+
+    setExpanded: setExpanded,
+    isFullScreen: isFullScreen,
+    setIsFullScreen: setIsFullScreen,
+    windowSize: windowSize,
+    height: height,
+    isDataTree: isDataTree,
+    selectionSettings: selectionSettings,
+    mergedSelectedKeys: mergedSelectedKeys,
+    expandable: expandable,
+    setColumns: setColumns,
+    columnVisibility: columnVisibility,
+    setColumnVisibility: setColumnVisibility
+  })));
+};
+var _default = exports.default = InternalTable;

package/lib/group-component/TableContainer.d.ts

@@ -0,0 +1,49 @@
+import type { Dispatch, SetStateAction } from 'react';
+import React from 'react';
+import type { ColumnDef, ColumnSizingInfoState, ColumnSizingState, Table } from '@tanstack/react-table';
+import type { ColumnsTable, TableProps } from './../grid-component/type';
+type TableContainerProps<T> = Omit<TableProps<T>, 'columns'> & {
+    table: Table<T>;
+    prefix: string;
+    id: string;
+    rowKey: any;
+    originData: T[];
+    isSelectionChange?: {
+        isChange: boolean;
+        type: string;
+        rowData: T;
+        rowsData: T[];
+    };
+    setIsSelectionChange: Dispatch<SetStateAction<{
+        isChange: boolean;
+        type: string;
+        rowData: T;
+        rowsData: T[];
+    }>>;
+    setSorterChange: Dispatch<SetStateAction<boolean>>;
+    setFilterChange: Dispatch<SetStateAction<boolean>>;
+    onContextMenu?: (data: T) => (event: any) => void;
+    windowSize: {
+        innerHeight: number;
+        innerWidth: number;
+    };
+    triggerPaste?: (pastedRows: T[], pastedColumnsArray: string[], newData: T[], copyRows: T[]) => void;
+    mergedFilterKeys?: any;
+    setMergedFilterKeys?: any;
+    setExpanded?: any;
+    expanded?: any;
+    columns: ColumnDef<T>[];
+    propsColumns: ColumnsTable;
+    triggerChangeColumns: any;
+    columnHidden: any;
+    isFullScreen: boolean;
+    setIsFullScreen: Dispatch<SetStateAction<boolean>>;
+    isDataTree: boolean;
+    setColumnSizing: Dispatch<SetStateAction<any>>;
+    setColumns: Dispatch<SetStateAction<any>>;
+    columnSizingInfo: ColumnSizingInfoState;
+    columnSizing: ColumnSizingState;
+    triggerGroupColumns?: (groupedColumns: string[]) => void;
+};
+declare const TableContainer: <RecordType extends object>(props: TableContainerProps<RecordType>) => React.JSX.Element;
+export default TableContainer;