es-grid-template 1.7.23 → 1.7.25

package/lib/table-component/features/operator.js

@@ -0,0 +1,67 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.OperatorFeature = void 0;
+var _reactTable = require("@tanstack/react-table");
+// TypeScript setup for our new feature with all of the same type-safety as stock TanStack Table features
+
+// define types for our new feature's table options
+
+// Define types for our new feature's table APIs
+// export interface OperatorInstance {
+//   setDensity: (updater: Updater<OpetorState>) => void
+
+//   toggleDensity: (value?: OpetorState) => void
+// }
+
+// Use declaration merging to add our new feature APIs and state types to TanStack Table's existing types.
+
+const OperatorFeature = exports.OperatorFeature = {
+  // define the new feature's initial state
+  getInitialState: state => {
+    return {
+      operator: [],
+      ...state
+    };
+  },
+  // define the new feature's default options
+  getDefaultOptions: table => {
+    return {
+      enableOperator: true,
+      onColumnOperatorChange: (0, _reactTable.makeStateUpdater)('operator', table)
+    };
+  },
+  // if you need to add a default column definition...
+  // getDefaultColumnDef: <TData extends RowData>(): Partial<ColumnDef<TData>> => {
+  //   return { meta: {} } //use meta instead of directly adding to the columnDef to avoid typescript stuff that's hard to workaround
+  // },
+
+  // define the new feature's table instance methods
+
+  // if you need to add row instance APIs...
+  // createRow: <TData extends RowData>(row, table): void => {},
+  // if you need to add cell instance APIs...
+  // createCell: <TData extends RowData>(cell, column, row, table): void => {},
+  // if you need to add column instance APIs...
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  createColumn: (column, table) => {
+    column.getFilterOperator = () => {
+      return table.getState().operator?.find(op => op.id === column.id)?.operator ?? undefined;
+    };
+    column.setFilterOperator = updater => {
+      const safeUpdater = old => {
+        const others = old.filter(op => op.id !== column.id);
+        return [...others, {
+          id: column.id,
+          operator: updater
+        }];
+      };
+      return table.options.onColumnOperatorChange?.(safeUpdater);
+    };
+  }
+
+  // if you need to add header instance APIs...
+  // createHeader: <TData extends RowData>(header, table): void => {},
+};

package/lib/table-component/footer/TableFooter.d.ts

@@ -0,0 +1,13 @@
+import type { Column, Table } from "@tanstack/react-table";
+import type { Virtualizer } from "@tanstack/react-virtual";
+import React from "react";
+interface TableFooterProps<T> {
+    columnVirtualizer: Virtualizer<HTMLDivElement, HTMLTableCellElement>;
+    table: Table<T>;
+    virtualPaddingLeft: number | undefined;
+    virtualPaddingRight: number | undefined;
+    fixedLeftColumns: Column<T, unknown>[];
+    fixedRightColumns: Column<T, unknown>[];
+}
+declare const TableFooter: <RecordType extends object>({ columnVirtualizer, table, virtualPaddingLeft, virtualPaddingRight, ...rest }: TableFooterProps<RecordType>) => React.JSX.Element;
+export default TableFooter;

package/lib/table-component/footer/TableFooter.js

@@ -0,0 +1,42 @@
+"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 _TableFooterRow = _interopRequireDefault(require("./TableFooterRow"));
+var _useContext = require("../useContext");
+var _react = _interopRequireWildcard(require("react"));
+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 TableFooter = ({
+  columnVirtualizer,
+  table,
+  virtualPaddingLeft,
+  virtualPaddingRight,
+  ...rest
+}) => {
+  const {
+    prefix
+  } = (0, _react.useContext)(_useContext.TableContext);
+  return /*#__PURE__*/_react.default.createElement("tfoot", {
+    className: `${prefix}-grid-tfoot`,
+    style: {
+      display: "grid",
+      position: "sticky",
+      bottom: 0,
+      zIndex: 1
+    }
+  }, /*#__PURE__*/_react.default.createElement(_TableFooterRow.default, (0, _extends2.default)({
+    table: table,
+    columnVirtualizer: columnVirtualizer,
+    headerGroup: table.getHeaderGroups()[table.getHeaderGroups().length - 1]
+    // key={headerGroup.id}
+    ,
+    virtualPaddingLeft: virtualPaddingLeft,
+    virtualPaddingRight: virtualPaddingRight
+  }, rest)));
+};
+var _default = exports.default = TableFooter;

package/lib/table-component/footer/TableFooterCell.d.ts

@@ -0,0 +1,10 @@
+import type { Header } from "@tanstack/react-table";
+import type { VirtualItem, Virtualizer } from "@tanstack/react-virtual";
+import React from "react";
+interface TableFooterCellProps<T> {
+    columnVirtualizer?: Virtualizer<HTMLDivElement, HTMLTableCellElement>;
+    header: Header<T, unknown>;
+    column: VirtualItem;
+}
+declare const TableFooterCell: <RecordType extends object>({ header }: TableFooterCellProps<RecordType>) => React.JSX.Element;
+export default TableFooterCell;

package/lib/table-component/footer/TableFooterCell.js

@@ -0,0 +1,76 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _react = _interopRequireWildcard(require("react"));
+var _utils = require("../hook/utils");
+var _useContext = require("../useContext");
+var _classnames = _interopRequireDefault(require("classnames"));
+var _hooks = require("../../grid-component/hooks");
+var _reactNumericComponent = require("react-numeric-component");
+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 type { Person } from "../makeData";
+
+// import type { Person } from "../../tanstack-table/makeData";
+
+const TableFooterCell = ({
+  header
+}) => {
+  const isPinned = header.column.getIsPinned();
+  const isLastLeftPinnedColumn = isPinned === 'left' && header.column.getIsLastColumn('left');
+  const isFirstRightPinnedColumn = isPinned === 'right' && header.column.getIsFirstColumn('right');
+  const {
+    prefix,
+    format,
+    dataSource
+  } = (0, _react.useContext)(_useContext.TableContext);
+  const col = header.column.columnDef.meta ?? {};
+  const colFormat = typeof col.format === 'function' ? col.format({}) : col.format;
+  const cellFormat = (0, _utils.getFormat)(colFormat, format);
+  const thousandSeparator = cellFormat?.thousandSeparator;
+  const decimalSeparator = cellFormat?.decimalSeparator;
+
+  // const dec = (col.format?.decimalScale || col.format?.decimalScale === 0) ? col.format?.decimalScale : format?.decimalScale
+  const dec = cellFormat?.decimalScale;
+
+  // const sumValue = col.type === 'number' ? sumDataByField(filterDataByColumns4(dataSource, filterStates) as any[], col?.key as string) : 0
+  const sumValue = col.type === 'number' ? (0, _hooks.sumByField)(dataSource, col?.field) : 0;
+  const value = !(0, _utils.isEmpty)(sumValue) ? dec || dec === 0 ? parseFloat(Number(sumValue).toFixed(dec)).toString() : sumValue.toString() : '0';
+  const cellValue = col.type === 'number' && col.isSummary !== false ? value : '';
+  const numberValue = Number(value);
+  const numericFormatProps = {
+    thousandSeparator: (0, _utils.checkThousandSeparator)(thousandSeparator, decimalSeparator),
+    decimalSeparator: (0, _utils.checkDecimalSeparator)(thousandSeparator, decimalSeparator),
+    allowNegative: cellFormat?.allowNegative ?? false,
+    prefix: cellFormat?.prefix,
+    suffix: cellFormat?.suffix,
+    decimalScale: dec,
+    fixedDecimalScale: cellFormat?.fixedDecimalScale ?? false
+  };
+  return /*#__PURE__*/_react.default.createElement("td", {
+    // ref={el => {
+    //   if (el) columnVirtualizer.measureElement(el)
+    // }}
+    // data-index={header.id}
+
+    className: (0, _classnames.default)(`${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
+    }),
+    key: header.id,
+    colSpan: header.colSpan,
+    style: {
+      display: 'flex',
+      ...(0, _utils.getCommonPinningStyles)(header.column),
+      width: header?.getSize() ?? header.column.getSize(),
+      backgroundColor: "#fafafa"
+    }
+  }, header.column.id !== "id" && header.column.id !== "selection_column" ? /*#__PURE__*/_react.default.createElement("span", null, col.summaryTemplate ? col.summaryTemplate(numberValue, col.field) : (0, _reactNumericComponent.numericFormatter)(cellValue, numericFormatProps)) : '');
+};
+var _default = exports.default = TableFooterCell;

package/lib/table-component/footer/TableFooterRow.d.ts

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

package/lib/table-component/footer/TableFooterRow.js

@@ -0,0 +1,81 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _TableFooterCell = _interopRequireDefault(require("./TableFooterCell"));
+var _react = _interopRequireDefault(require("react"));
+// import type { Person } from "../makeData";
+
+// import type { Person } from "../../tanstack-table/makeData";
+// import TableHeadCell from "./TableHeadCell";
+
+const TableFooterRow = ({
+  table,
+  // columnVirtualizer,
+  headerGroup,
+  virtualPaddingLeft,
+  virtualPaddingRight,
+  fixedLeftColumns,
+  fixedRightColumns,
+  // virtualColumns,
+  columnVirtualizer
+}) => {
+  const virtualColumns = columnVirtualizer.getVirtualItems();
+  return /*#__PURE__*/_react.default.createElement("tr", {
+    // data-index={headerGroup.id}
+    key: headerGroup.id,
+    style: {
+      display: "flex",
+      width: "100%",
+      borderBottom: "1px solid #e0e0e0",
+      borderTop: "1px solid #e0e0e0",
+      height: 37
+    }
+  }, fixedLeftColumns.length > 0 ? fixedLeftColumns.map(column => {
+    return /*#__PURE__*/_react.default.createElement(_TableFooterCell.default, {
+      columnVirtualizer: columnVirtualizer,
+      key: column.id,
+      header: headerGroup.headers.find(h => h.column.id === column.id),
+      column: column
+    });
+  }) : null, virtualPaddingLeft ? /*#__PURE__*/_react.default.createElement("td", {
+    className: "",
+    style: {
+      display: "flex",
+      width: virtualPaddingLeft
+    }
+  }) : null, virtualColumns.map(virtualColumn => {
+    const header = headerGroup.headers[virtualColumn.index];
+    const isFixed = table.getState().columnPinning.left?.includes(header.column.id) || table.getState().columnPinning.right?.includes(header.column.id);
+    // const isFixed = table.getState().columnPinning.left?.includes(header.column.id)
+
+    if (header && !isFixed) {
+      return /*#__PURE__*/_react.default.createElement(_TableFooterCell.default, {
+        key: header.id,
+        header: header,
+        column: virtualColumn,
+        columnVirtualizer: columnVirtualizer
+      });
+    }
+    return null;
+  }),
+  //fake empty column to the right for virtualization scroll padding
+  fixedRightColumns.length > 0 ? fixedRightColumns.map(column => /*#__PURE__*/_react.default.createElement(_TableFooterCell.default, {
+    key: column.id,
+    header: headerGroup.headers.find(h => h.column.id === column.id),
+    column: column
+  })) : null, virtualPaddingRight ?
+  /*#__PURE__*/
+  //fake empty column to the right for virtualization scroll padding
+  _react.default.createElement("td", {
+    className: "",
+    style: {
+      display: "flex",
+      width: virtualPaddingRight
+    }
+  }) : null);
+};
+var _default = exports.default = TableFooterRow;

package/lib/table-component/header/TableHead.d.ts

@@ -0,0 +1,14 @@
+import type { Column, Table } from '@tanstack/react-table';
+import { type Virtualizer } from '@tanstack/react-virtual';
+import React from 'react';
+interface TableHeadProps<T> {
+    tableContainerRef: React.RefObject<HTMLDivElement>;
+    columnVirtualizer: Virtualizer<HTMLDivElement, HTMLTableCellElement>;
+    table: Table<T>;
+    virtualPaddingLeft: number | undefined;
+    virtualPaddingRight: number | undefined;
+    fixedLeftColumns: Column<T, unknown>[];
+    fixedRightColumns: Column<T, unknown>[];
+}
+declare const TableHead: <RecordType extends object>({ tableContainerRef, columnVirtualizer, table, virtualPaddingLeft, virtualPaddingRight, fixedLeftColumns, fixedRightColumns }: TableHeadProps<RecordType>) => React.JSX.Element;
+export default TableHead;

package/lib/table-component/header/TableHead.js

@@ -0,0 +1,69 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _reactVirtual = require("@tanstack/react-virtual");
+var _react = _interopRequireWildcard(require("react"));
+var _useContext = require("../useContext");
+var _TableHeadRow = _interopRequireDefault(require("./TableHeadRow"));
+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 TableHead = ({
+  tableContainerRef,
+  columnVirtualizer,
+  table,
+  virtualPaddingLeft,
+  virtualPaddingRight,
+  fixedLeftColumns,
+  fixedRightColumns
+}) => {
+  const {
+    prefix
+  } = (0, _react.useContext)(_useContext.TableContext);
+  const rowVirtualizer = (0, _reactVirtual.useVirtualizer)({
+    count: table.getHeaderGroups().length,
+    estimateSize: () => 34,
+    //estimate row height for accurate scrollbar dragging
+    getScrollElement: () => tableContainerRef.current,
+    //measure dynamic row height, except in firefox because it measures table border height incorrectly
+    measureElement: typeof window !== 'undefined' && navigator.userAgent.indexOf('Firefox') === -1 ? element => element?.getBoundingClientRect().height : undefined,
+    overscan: 5
+  });
+  const virtualRows = rowVirtualizer.getVirtualItems();
+
+  // const columnSizingState = table.getState().columnSizing
+
+  // React.useEffect(() => {
+  //   requestAnimationFrame(() => {
+  //     rowVirtualizer.measure()
+  //   })
+  // }, [columnSizingState, rowVirtualizer])
+
+  return /*#__PURE__*/_react.default.createElement("thead", {
+    className: `${prefix}-grid-thead`,
+    style: {
+      display: 'grid',
+      position: 'sticky',
+      top: 0,
+      zIndex: 1
+    }
+  }, virtualRows.map(virtualRow => {
+    const headerGroup = table.getHeaderGroups()[virtualRow.index];
+    return /*#__PURE__*/_react.default.createElement(_TableHeadRow.default, {
+      table: table,
+      columnVirtualizer: columnVirtualizer,
+      rowHeaderVirtualizer: rowVirtualizer,
+      headerGroup: headerGroup,
+      key: headerGroup.id,
+      virtualPaddingLeft: virtualPaddingLeft,
+      virtualPaddingRight: virtualPaddingRight,
+      fixedLeftColumns: fixedLeftColumns,
+      fixedRightColumns: fixedRightColumns,
+      rowHeaderVirtual: virtualRow
+    });
+  }));
+};
+var _default = exports.default = TableHead;

package/lib/table-component/header/TableHeadCell.d.ts

@@ -0,0 +1,14 @@
+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>;
+    header: Header<T, unknown>;
+    getPopupContainer?: (triggerNode: HTMLElement) => HTMLElement;
+    columnVirtualizer: Virtualizer<HTMLDivElement, HTMLTableCellElement>;
+    rowHeaderVirtualizer: Virtualizer<HTMLDivElement, HTMLTableRowElement>;
+}
+declare const TableHeadCell: <RecordType extends object>(props: TableHeadCellProps<RecordType>) => React.JSX.Element;
+export default TableHeadCell;