es-grid-template 1.8.71 → 1.8.72

package/es/group-component/header/TableHeadCell2.js

@@ -0,0 +1,321 @@
+import { flexRender } from '@tanstack/react-table';
+import React, { useContext } from 'react';
+import { Button, Space } from 'antd';
+import { ArrowDown, ArrowUp, FilterFill, SortCancel } from 'becoxy-icons';
+import classNames from 'classnames';
+import { Checkbox, Dropdown, Select } from 'rc-master-ui';
+import { excludeItems, extendsObject, getCommonPinningStyles, getDefaultOperator, getTypeFilter, removeDuplicatesByKey } from "../hook/utils";
+import { TableContext } from "../useContext";
+import { renderFilter } from "./renderFilter";
+import ReactDOMServer from 'react-dom/server';
+import { booleanOperator, nonActionColumn, numberOperator, stringOperator, translateOption } from "../../grid-component/hooks";
+const TableHeadCell2 = props => {
+  const {
+    column,
+    header,
+    getPopupContainer,
+    table,
+    depth,
+    colSpan,
+    rowSpan
+  } = props;
+  const {
+    t,
+    prefix,
+    setSorterChange,
+    setFilterChange,
+    wrapSettings,
+    selectionSettings,
+    isSelectionChange,
+    setIsSelectionChange,
+    id,
+    locale,
+    format,
+    dataSourceFilter
+  } = useContext(TableContext);
+  const isPinned = column.getIsPinned();
+  const isLastLeftPinnedColumn = isPinned === 'left' && column.getIsLastColumn('left');
+  const isFirstRightPinnedColumn = isPinned === 'right' && column.getIsFirstColumn('right');
+  const [selectedKeys, setSelectedKeys] = React.useState([]);
+  const [visible, setVisible] = React.useState(false);
+  const {
+    filterIcon
+  } = column.columnDef.meta ?? {};
+  const originalColumn = column.columnDef.meta ?? {};
+  const cellStyles = typeof originalColumn.onCellHeaderStyles === 'function' ? originalColumn.onCellHeaderStyles(header) : originalColumn.onCellHeaderStyles;
+  const filtered = (column.getFilterValue() ?? []).length > 0;
+  const cellContent = flexRender(column.columnDef.header, header.getContext());
+  const html = ReactDOMServer.renderToStaticMarkup( /*#__PURE__*/React.createElement(React.Fragment, null, cellContent));
+  const hasValue = html.trim().length > 0;
+  const style = {
+    transition: 'width transform 0.2s ease-in-out',
+    whiteSpace: 'nowrap',
+    ...cellStyles
+  };
+  const getDropdownTrigger = () => {
+    let iconFilter;
+    if (typeof filterIcon === 'function') {
+      iconFilter = filterIcon(filtered);
+    } else if (filterIcon) {
+      iconFilter = filterIcon;
+    } else {
+      iconFilter = /*#__PURE__*/React.createElement(FilterFill, {
+        style: {
+          color: filtered ? '#E3165B' : '#283046'
+        },
+        fontSize: 12
+      });
+    }
+    return /*#__PURE__*/React.createElement("span", {
+      role: "button",
+      tabIndex: -1,
+      className: classNames(`${prefix}-trigger`, {
+        active: filtered
+      }),
+      onClick: e => {
+        e.stopPropagation();
+      }
+    }, iconFilter);
+  };
+  const triggerVisible = newVisible => {
+    setVisible(newVisible);
+  };
+  const onVisibleChange = (newVisible, info) => {
+    if (info.source === 'trigger') {
+      if (newVisible) {
+        const filterValue = column.getFilterValue() ?? [];
+        const operatorValue = column.getFilterOperator() ?? getDefaultOperator(column.columnDef?.meta ?? {});
+        setSelectedKeys(filterValue);
+        column.setFilterOperator?.(operatorValue);
+        setTimeout(() => {
+          const inputFilter = document.querySelector('.filter-input');
+          if (inputFilter) {
+            inputFilter.focus();
+          }
+        }, 200);
+      } else {}
+      triggerVisible(newVisible);
+    }
+  };
+  const doFilter = type => {
+    if (type) {
+      column.setFilterValue(!originalColumn.typeFilter || originalColumn.typeFilter === 'Text' ? selectedKeys.length === 0 ? [''] : selectedKeys : selectedKeys);
+    } else {
+      column.setFilterValue(undefined);
+      setSelectedKeys([]);
+    }
+    setFilterChange(true);
+    triggerVisible(false);
+    setTimeout(() => {
+      setFilterChange(false);
+    }, 10);
+  };
+  const mergedDropdownProps = extendsObject({
+    trigger: ['click'],
+    placement: 'bottomRight',
+    // placement: direction === 'rtl' ? 'bottomLeft' : 'bottomRight',
+    children: getDropdownTrigger(),
+    getPopupContainer
+  }, {
+    // ...filterDropdownProps,
+    // rootClassName: classNames(rootClassName, filterDropdownProps.rootClassName),
+    open: visible,
+    onOpenChange: onVisibleChange,
+    destroyPopupOnHide: true,
+    dropdownRender: () => {
+      const type = getTypeFilter(originalColumn);
+      const operatorValue = column.getFilterOperator() ?? getDefaultOperator(originalColumn);
+      const operatorOptions = ['Checkbox', 'Dropdown', 'DropTree', 'CheckboxDropdown'].includes(type) ? booleanOperator : !type || type === 'Text' ? stringOperator : numberOperator;
+      return /*#__PURE__*/React.createElement("div", {
+        // className='ui-rc-table-filter-dropdown'
+
+        className: classNames(`${prefix}-grid-filter-dropdown`, {}),
+        style: {}
+      }, /*#__PURE__*/React.createElement("div", {
+        style: {
+          minWidth: 275,
+          padding: '8px'
+        }
+      }, /*#__PURE__*/React.createElement("div", null), column.columnDef?.meta?.hideOperator === true && column.columnDef?.meta?.typeFilter !== 'DateRange' && column.columnDef?.meta?.typeFilter !== 'NumberRange' && /*#__PURE__*/React.createElement("div", {
+        className: 'mb-1'
+      }, /*#__PURE__*/React.createElement(Select, {
+        options: translateOption(operatorOptions, t),
+        style: {
+          width: '100%',
+          marginBottom: 8
+        },
+        value: operatorValue,
+        onChange: val => {
+          column.setFilterOperator(val);
+        }
+      })), /*#__PURE__*/React.createElement("div", {
+        style: {
+          marginBottom: 8
+        }
+      }, renderFilter({
+        column: column.columnDef,
+        selectedKeys,
+        setSelectedKeys,
+        doFilter,
+        format,
+        dataSourceFilter
+
+        // selectedKeys: (column.getFilterValue() ?? []) as string[],
+        // setSelectedKeys: column.setFilterValue,
+      })), /*#__PURE__*/React.createElement(Space, {
+        style: {
+          justifyContent: 'end',
+          width: '100%'
+        }
+      }, /*#__PURE__*/React.createElement(Button, {
+        type: "primary",
+        onClick: () => {
+          // column.setFilterValue(selectedKeys)
+
+          doFilter(true);
+        },
+        size: "small",
+        style: {
+          width: 90
+        }
+      }, t ? t('Filter') : 'Filter'), /*#__PURE__*/React.createElement(Button, {
+        type: "link",
+        size: "small",
+        onClick: () => {
+          // column.setFilterValue([])
+          // column.setFilterOperator('')
+
+          setSelectedKeys([]);
+          doFilter(false);
+        }
+      }, t ? t('Clear') : 'Clear'))));
+
+      // if (typeof filterDropdownProps?.dropdownRender === 'function') {
+      //   return filterDropdownProps.dropdownRender(dropdownContent);
+      // }
+      // return dropdownContent;
+    }
+  });
+  return /*#__PURE__*/React.createElement("div", {
+    // ref={setNodeRef}
+    className: classNames(`${prefix}-grid-cell`, {
+      [`${prefix}-grid-cell-ellipsis`]: !wrapSettings || !(wrapSettings && (wrapSettings.wrapMode === 'Both' || wrapSettings.wrapMode === 'Header')),
+      [`${prefix}-grid-cell-wrap`]: wrapSettings && (wrapSettings.wrapMode === 'Both' || wrapSettings.wrapMode === 'Header'),
+      [`${prefix}-grid-cell-fix-left-last`]: isLastLeftPinnedColumn,
+      [`${prefix}-grid-cell-fix-right-first`]: isFirstRightPinnedColumn,
+      [`${prefix}-grid-cell-text-center`]: (originalColumn?.headerTextAlign ?? originalColumn?.textAlign) === 'center',
+      [`${prefix}-grid-cell-text-right`]: (originalColumn?.headerTextAlign ?? originalColumn.textAlign) === 'right'
+    }),
+    key: column.id,
+    style: {
+      ...style,
+      minWidth: column.getSize(),
+      gridRow: `${depth + 1} / span ${rowSpan}`,
+      gridColumn: `span ${colSpan}`,
+      ...getCommonPinningStyles(column),
+      width: 'auto'
+    },
+    "data-tooltip-id": `${id}-tooltip-content`,
+    "data-tooltip-delay-show": 500,
+    "data-tooltip-html": !hasValue ? '' : ReactDOMServer.renderToStaticMarkup( /*#__PURE__*/React.createElement("div", null, cellContent))
+  }, /*#__PURE__*/React.createElement("div", {
+    className: classNames('', {
+      [`${prefix}-grid-filter-column`]: column.id !== 'selection_column',
+      [`${prefix}-grid-selection-column`]: column.id === 'selection_column'
+    })
+  }, column.id === 'selection_column' && selectionSettings && selectionSettings.hideSelectAll !== true && selectionSettings.type !== 'single' && selectionSettings.mode !== 'radio' && /*#__PURE__*/React.createElement(Checkbox, {
+    checked: table.getIsAllRowsSelected(),
+    indeterminate: table.getIsSomePageRowsSelected(),
+    onChange: e => {
+      table.getToggleAllRowsSelectedHandler()(e);
+      const prevSelected = isSelectionChange?.rowsData ?? [];
+      const allRowsInPage = table.getRowModel().flatRows;
+      if (table.getIsAllRowsSelected()) {
+        const cc = excludeItems(prevSelected, allRowsInPage);
+        setIsSelectionChange({
+          isChange: true,
+          type: 'all',
+          rowData: {},
+          rowsData: cc
+        });
+      } else {
+        const abc = [...prevSelected, ...allRowsInPage];
+        const newSeletedRows = removeDuplicatesByKey(abc, 'id');
+        setIsSelectionChange({
+          isChange: true,
+          type: 'all',
+          rowData: {},
+          rowsData: newSeletedRows
+        });
+      }
+    }
+  }), column.id !== 'selection_column' && /*#__PURE__*/React.createElement("span", {
+    className: "ui-rc-table-column-title",
+    style: {
+      flex: 1
+    }
+  }, /*#__PURE__*/React.createElement("div", {
+    className: classNames('', {
+      [`${prefix}-grid-cell-ellipsis`]: !wrapSettings || !(wrapSettings && (wrapSettings.wrapMode === 'Both' || wrapSettings.wrapMode === 'Header')),
+      [`${prefix}-grid-cell-text-wrap`]: wrapSettings && (wrapSettings.wrapMode === 'Both' || wrapSettings.wrapMode === 'Header')
+    })
+  }, cellContent)), !nonActionColumn.includes(column.id) && column.columns.length < 1 && /*#__PURE__*/React.createElement("span", {
+    className: "ui-rc-header-trigger"
+  }, column.getCanSort() && /*#__PURE__*/React.createElement("div", {
+    style: {
+      marginInlineEnd: 6,
+      cursor: 'pointer'
+    },
+    onClick: e => {
+      setSorterChange(true);
+      const toggleSortingHandler = column.getToggleSortingHandler();
+      if (typeof toggleSortingHandler === 'function') {
+        toggleSortingHandler(e);
+      }
+    }
+  }, column.getIsSorted() ? column.getIsSorted() === 'asc' ? /*#__PURE__*/React.createElement(ArrowUp, {
+    fontSize: 15,
+    color: '#000'
+    // data-tooltip-id={`${id}-tooltip-header-trigger`}
+    ,
+    "data-tooltip-id": `${id}-tooltip-content`
+    // data-tooltip-content='Nhấp để sắp xếp giảm dần'
+    ,
+    "data-tooltip-content": locale?.triggerDesc ?? 'Click to sort descending'
+  }) : /*#__PURE__*/React.createElement(ArrowDown, {
+    fontSize: 15,
+    color: '#000',
+    "data-tooltip-id": `${id}-tooltip-content`
+    // data-tooltip-id={`${id}-tooltip-header-trigger`}
+    // data-tooltip-content='Nhấp để hủy sắp xếp'
+    ,
+    "data-tooltip-content": locale?.cancelSort ?? 'Click to cancel sorting'
+  }) : /*#__PURE__*/React.createElement(SortCancel
+  // data-tooltip-id={`${id}-tooltip-header-trigger`}
+  , {
+    "data-tooltip-id": `${id}-tooltip-content`
+    // data-tooltip-content='Nhấp để sắp xếp tăng dần'
+    ,
+    "data-tooltip-content": locale?.triggerAsc ?? 'Click to sort ascending',
+    fontSize: 15,
+    style: {
+      display: 'flex'
+    },
+    className: classNames(`ui-rc-table-column-sorter-cancel`, {
+      active: true
+    })
+  })), column.getCanFilter() && /*#__PURE__*/React.createElement("span", null, /*#__PURE__*/React.createElement(Dropdown, mergedDropdownProps)))), column.getCanResize() && /*#__PURE__*/React.createElement("div", {
+    onDoubleClick: () => column.resetSize(),
+    onMouseDown: header.getResizeHandler(),
+    onTouchStart: header.getResizeHandler(),
+    // onMouseUp: () => {
+    //   requestAnimationFrame(() => {
+    //     columnVirtualizer.measure()
+    //     // rowHeaderVirtualizer.measure()
+    //   })
+    // },
+
+    className: `resizer ${column.getIsResizing() ? 'isResizing' : ''}`
+  }));
+};
+export default TableHeadCell2;

package/es/group-component/header/TableHeadGroupCell.d.ts

@@ -0,0 +1,17 @@
+import type { Table } from '@tanstack/react-table';
+import { type Header } from '@tanstack/react-table';
+import React from 'react';
+import type { Virtualizer } from '@tanstack/react-virtual';
+interface TableHeadCellProps<T> {
+    t?: any;
+    table: Table<T>;
+    column: any;
+    header: Header<T, unknown>;
+    getPopupContainer?: (triggerNode: HTMLElement) => HTMLElement;
+    columnVirtualizer: Virtualizer<HTMLDivElement, HTMLTableCellElement>;
+    colSpan: number;
+    rowSpan: number;
+    depth: number;
+}
+declare const TableHeadGroupCell: <RecordType extends object>(props: TableHeadCellProps<RecordType>) => React.JSX.Element;
+export default TableHeadGroupCell;

package/es/group-component/header/TableHeadGroupCell.js

@@ -0,0 +1,94 @@
+import { flexRender } from '@tanstack/react-table';
+import React, { useContext } from 'react';
+import classNames from 'classnames';
+import { Checkbox } from 'rc-master-ui';
+import { getCommonPinningStyles2 } from "../hook/utils";
+import { TableContext } from "../useContext";
+import ReactDOMServer from 'react-dom/server';
+const TableHeadGroupCell = props => {
+  const {
+    column,
+    header,
+    table,
+    depth,
+    colSpan,
+    rowSpan
+  } = props;
+  const {
+    prefix,
+    wrapSettings,
+    selectionSettings,
+    setIsSelectionChange,
+    id
+  } = useContext(TableContext);
+  const isPinned = column.getIsPinned();
+  const isLastLeftPinnedColumn = isPinned === 'left' && column.getIsLastColumn('left');
+  const isFirstRightPinnedColumn = isPinned === 'right' && column.getIsFirstColumn('right');
+  const originalColumn = column.columnDef.meta ?? {};
+  const cellStyles = typeof originalColumn.onCellHeaderStyles === 'function' ? originalColumn.onCellHeaderStyles(header) : originalColumn.onCellHeaderStyles;
+  const cellContent = flexRender(column.columnDef.header, header.getContext());
+  const html = ReactDOMServer.renderToStaticMarkup( /*#__PURE__*/React.createElement(React.Fragment, null, cellContent));
+  const hasValue = html.trim().length > 0;
+  const style = {
+    transition: 'width transform 0.2s ease-in-out',
+    whiteSpace: 'nowrap',
+    ...cellStyles
+  };
+  return /*#__PURE__*/React.createElement("div", {
+    // ref={setNodeRef}
+    className: classNames(`${prefix}-grid-cell`, {
+      [`${prefix}-grid-cell-ellipsis`]: !wrapSettings || !(wrapSettings && (wrapSettings.wrapMode === 'Both' || wrapSettings.wrapMode === 'Header')),
+      [`${prefix}-grid-cell-wrap`]: wrapSettings && (wrapSettings.wrapMode === 'Both' || wrapSettings.wrapMode === 'Header'),
+      [`${prefix}-grid-cell-fix-left-last`]: isLastLeftPinnedColumn,
+      [`${prefix}-grid-cell-fix-right-first`]: isFirstRightPinnedColumn,
+      [`${prefix}-grid-cell-text-center`]: (originalColumn?.headerTextAlign ?? originalColumn?.textAlign) === 'center',
+      [`${prefix}-grid-cell-text-right`]: (originalColumn?.headerTextAlign ?? originalColumn.textAlign) === 'right'
+    }),
+    "data-col-span": colSpan,
+    key: header.id,
+    style: {
+      minWidth: column.getSize(),
+      flex: 1,
+      gridRow: `${depth + 1} / span ${rowSpan}`,
+      gridColumn: `span ${colSpan}`,
+      ...getCommonPinningStyles2(header),
+      width: 'auto',
+      ...style
+    },
+    "data-tooltip-id": `${id}-tooltip-content`,
+    "data-tooltip-html": !hasValue ? '' : ReactDOMServer.renderToStaticMarkup( /*#__PURE__*/React.createElement("div", null, cellContent))
+  }, /*#__PURE__*/React.createElement("div", {
+    className: classNames('', {
+      [`${prefix}-grid-filter-column`]: column.id !== 'selection_column',
+      [`${prefix}-grid-selection-column`]: column.id === 'selection_column'
+    })
+  }, column.id === 'selection_column' && selectionSettings && selectionSettings.hideSelectAll !== false && selectionSettings.type !== 'single' && selectionSettings.mode !== 'radio' && /*#__PURE__*/React.createElement(Checkbox, {
+    checked: table.getIsAllRowsSelected(),
+    indeterminate: table.getIsSomeRowsSelected(),
+    onChange: e => {
+      setIsSelectionChange({
+        isChange: true,
+        type: 'all',
+        rowData: {},
+        rowsData: []
+      });
+      table.getToggleAllRowsSelectedHandler()(e);
+    }
+  }), column.id !== 'selection_column' && /*#__PURE__*/React.createElement("span", {
+    className: "ui-rc-table-column-title",
+    style: {
+      flex: 1
+    }
+  }, /*#__PURE__*/React.createElement("div", {
+    className: classNames('', {
+      [`${prefix}-grid-cell-ellipsis`]: !wrapSettings || !(wrapSettings && (wrapSettings.wrapMode === 'Both' || wrapSettings.wrapMode === 'Header')),
+      [`${prefix}-grid-cell-text-wrap`]: wrapSettings && (wrapSettings.wrapMode === 'Both' || wrapSettings.wrapMode === 'Header')
+    })
+  }, cellContent))), column.getCanResize() && /*#__PURE__*/React.createElement("div", {
+    onDoubleClick: () => column.resetSize(),
+    onMouseDown: header.getResizeHandler(),
+    onTouchStart: header.getResizeHandler(),
+    className: `resizer ${column.getIsResizing() ? 'isResizing' : ''}`
+  }));
+};
+export default TableHeadGroupCell;

package/es/group-component/header/TableHeadRow.d.ts

@@ -0,0 +1,15 @@
+import type { Column } from '@tanstack/react-table';
+import { type HeaderGroup, type Table } from '@tanstack/react-table';
+import React from 'react';
+import type { Virtualizer } from '@tanstack/react-virtual';
+interface TableHeadRowProps<T> {
+    headerGroup: HeaderGroup<T>;
+    table: Table<T>;
+    columnVirtualizer: Virtualizer<HTMLDivElement, HTMLTableCellElement>;
+    virtualPaddingLeft: number | undefined;
+    virtualPaddingRight: number | undefined;
+    fixedLeftColumns: Column<T, unknown>[];
+    fixedRightColumns: Column<T, unknown>[];
+}
+declare const TableHeadRow: ({ table, headerGroup, columnVirtualizer, }: TableHeadRowProps<any>) => React.JSX.Element;
+export default TableHeadRow;

package/es/group-component/header/TableHeadRow.js

@@ -0,0 +1,52 @@
+import { horizontalListSortingStrategy, SortableContext } from '@dnd-kit/sortable';
+import React from 'react';
+import { TableContext } from "../useContext";
+import TableHeadCell from "./TableHeadCell";
+const TableHeadRow = ({
+  table,
+  headerGroup,
+  columnVirtualizer
+}) => {
+  const {
+    prefix,
+    onRowHeaderStyles
+  } = React.useContext(TableContext);
+  const columnOrder = table.getState().columnOrder;
+  const rowStyles = typeof onRowHeaderStyles === 'function' ? onRowHeaderStyles() : onRowHeaderStyles;
+  return /*#__PURE__*/React.createElement("div", {
+    key: headerGroup.id
+    // ref={el => {
+    //   if (el) rowHeaderVirtualizer.measureElement(el)
+    // }}
+    ,
+
+    "data-index": headerGroup.id,
+    className: `${prefix}-grid-row ${prefix}-grid-header`,
+    style: {
+      ...rowStyles,
+      width: '100%'
+    }
+  }, /*#__PURE__*/React.createElement(SortableContext, {
+    items: columnOrder,
+    strategy: horizontalListSortingStrategy
+  }, headerGroup.headers.map(header => {
+    const columnRelativeDepth = header.depth - header.column.depth;
+    if (columnRelativeDepth > 1) {
+      return null;
+    }
+    let rowSpan = 1;
+    if (header.isPlaceholder) {
+      const leafs = header.getLeafHeaders();
+      rowSpan = leafs[leafs.length - 1].depth - header.depth;
+    }
+    return /*#__PURE__*/React.createElement(TableHeadCell, {
+      key: header.id,
+      header: header,
+      table: table,
+      columnVirtualizer: columnVirtualizer,
+      colSpan: header.colSpan,
+      rowSpan: rowSpan
+    });
+  })));
+};
+export default TableHeadRow;

package/es/group-component/header/renderFilter.d.ts

@@ -0,0 +1,20 @@
+import type { ColumnDef } from "@tanstack/react-table";
+import React from "react";
+import type { IFormat } from "../../grid-component/type";
+type RenderFilterProps<RecordType> = {
+    column: ColumnDef<RecordType, unknown>;
+    selectedKeys: any[];
+    setSelectedKeys: (keys: any[]) => void;
+    t?: any;
+    locale?: any;
+    dataSourceFilter?: {
+        key: string;
+        data: any[];
+    }[];
+    format?: IFormat;
+    buddhistLocale?: any;
+    dateRangeLocale?: any;
+    doFilter?: (type: boolean) => void;
+};
+export declare const renderFilter: <RecordType>(args: RenderFilterProps<RecordType>) => React.JSX.Element;
+export {};