Latest updates from IceHrmPro

web/node_modules/rc-table/es/Header/FixedHeader.d.ts

@@ -0,0 +1,9 @@
+/// <reference types="react" />
+import { HeaderProps } from './Header';
+export interface FixedHeaderProps<RecordType> extends HeaderProps<RecordType> {
+    colWidths: number[];
+    columCount: number;
+    direction: 'ltr' | 'rtl';
+}
+declare function FixedHeader<RecordType>({ columns, flattenColumns, colWidths, columCount, stickyOffsets, direction, ...props }: FixedHeaderProps<RecordType>): JSX.Element;
+export default FixedHeader;

web/node_modules/rc-table/es/Header/FixedHeader.js

@@ -0,0 +1,94 @@
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+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 _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(n); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+
+function _iterableToArray(iter) { if (typeof Symbol !== "undefined" && Symbol.iterator in Object(iter)) return Array.from(iter); }
+
+function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) return _arrayLikeToArray(arr); }
+
+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 _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; }
+
+function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; }
+
+import * as React from 'react';
+import Header from './Header';
+import ColGroup from '../ColGroup';
+import TableContext from '../context/TableContext';
+
+function FixedHeader(_ref) {
+  var columns = _ref.columns,
+      flattenColumns = _ref.flattenColumns,
+      colWidths = _ref.colWidths,
+      columCount = _ref.columCount,
+      stickyOffsets = _ref.stickyOffsets,
+      direction = _ref.direction,
+      props = _objectWithoutProperties(_ref, ["columns", "flattenColumns", "colWidths", "columCount", "stickyOffsets", "direction"]);
+
+  var _React$useContext = React.useContext(TableContext),
+      prefixCls = _React$useContext.prefixCls,
+      scrollbarSize = _React$useContext.scrollbarSize; // Add scrollbar column
+
+
+  var lastColumn = flattenColumns[flattenColumns.length - 1];
+  var ScrollBarColumn = {
+    fixed: lastColumn ? lastColumn.fixed : null,
+    onHeaderCell: function onHeaderCell() {
+      return {
+        className: "".concat(prefixCls, "-cell-scrollbar")
+      };
+    }
+  };
+  var columnsWithScrollbar = React.useMemo(function () {
+    return scrollbarSize ? [].concat(_toConsumableArray(columns), [ScrollBarColumn]) : columns;
+  }, [scrollbarSize, columns]);
+  var flattenColumnsWithScrollbar = React.useMemo(function () {
+    return scrollbarSize ? [].concat(_toConsumableArray(flattenColumns), [ScrollBarColumn]) : flattenColumns;
+  }, [scrollbarSize, flattenColumns]); // Calculate the sticky offsets
+
+  var headerStickyOffsets = React.useMemo(function () {
+    var right = stickyOffsets.right,
+        left = stickyOffsets.left;
+    return _objectSpread({}, stickyOffsets, {
+      left: direction === 'rtl' ? [].concat(_toConsumableArray(left.map(function (width) {
+        return width + scrollbarSize;
+      })), [0]) : left,
+      right: direction === 'rtl' ? right : [].concat(_toConsumableArray(right.map(function (width) {
+        return width + scrollbarSize;
+      })), [0])
+    });
+  }, [scrollbarSize, stickyOffsets]);
+  var cloneWidths = [];
+
+  for (var i = 0; i < columCount; i += 1) {
+    cloneWidths[i] = colWidths[i];
+  }
+
+  var columnWidthsReady = !colWidths.every(function (width) {
+    return !width;
+  });
+  return React.createElement("table", {
+    style: {
+      tableLayout: 'fixed',
+      visibility: columnWidthsReady ? null : 'hidden'
+    }
+  }, React.createElement(ColGroup, {
+    colWidths: [].concat(_toConsumableArray(colWidths), [scrollbarSize]),
+    columCount: columCount + 1
+  }), React.createElement(Header, Object.assign({}, props, {
+    stickyOffsets: headerStickyOffsets,
+    columns: columnsWithScrollbar,
+    flattenColumns: flattenColumnsWithScrollbar
+  })));
+}
+
+export default FixedHeader;

web/node_modules/rc-table/es/Header/Header.d.ts

@@ -0,0 +1,10 @@
+import * as React from 'react';
+import { ColumnsType, StickyOffsets, ColumnType, GetComponentProps } from '../interface';
+export interface HeaderProps<RecordType> {
+    columns: ColumnsType<RecordType>;
+    flattenColumns: ColumnType<RecordType>[];
+    stickyOffsets: StickyOffsets;
+    onHeaderRow: GetComponentProps<ColumnType<RecordType>[]>;
+}
+declare function Header<RecordType>({ stickyOffsets, columns, flattenColumns, onHeaderRow, }: HeaderProps<RecordType>): React.ReactElement;
+export default Header;

web/node_modules/rc-table/es/Header/Header.js

@@ -0,0 +1,102 @@
+import * as React from 'react';
+import HeaderRow from './HeaderRow';
+import TableContext from '../context/TableContext';
+
+function parseHeaderRows(rootColumns) {
+  var rows = [];
+
+  function fillRowCells(columns, colIndex) {
+    var rowIndex = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 0;
+    // Init rows
+    rows[rowIndex] = rows[rowIndex] || [];
+    var currentColIndex = colIndex;
+    var colSpans = columns.map(function (column) {
+      var cell = {
+        key: column.key,
+        className: column.className || '',
+        children: column.title,
+        column: column,
+        colStart: currentColIndex
+      };
+      var colSpan = 1;
+      var subColumns = column.children;
+
+      if (subColumns && subColumns.length > 0) {
+        colSpan = fillRowCells(subColumns, currentColIndex, rowIndex + 1).reduce(function (total, count) {
+          return total + count;
+        }, 0);
+        cell.hasSubColumns = true;
+      }
+
+      if ('colSpan' in column) {
+        colSpan = column.colSpan;
+      }
+
+      if ('rowSpan' in column) {
+        cell.rowSpan = column.rowSpan;
+      }
+
+      cell.colSpan = colSpan;
+      cell.colEnd = cell.colStart + colSpan - 1;
+      rows[rowIndex].push(cell);
+      currentColIndex += colSpan;
+      return colSpan;
+    });
+    return colSpans;
+  } // Generate `rows` cell data
+
+
+  fillRowCells(rootColumns, 0); // Handle `rowSpan`
+
+  var rowCount = rows.length;
+
+  var _loop = function _loop(rowIndex) {
+    rows[rowIndex].forEach(function (cell) {
+      if (!('rowSpan' in cell) && !cell.hasSubColumns) {
+        // eslint-disable-next-line no-param-reassign
+        cell.rowSpan = rowCount - rowIndex;
+      }
+    });
+  };
+
+  for (var rowIndex = 0; rowIndex < rowCount; rowIndex += 1) {
+    _loop(rowIndex);
+  }
+
+  return rows;
+}
+
+function Header(_ref) {
+  var stickyOffsets = _ref.stickyOffsets,
+      columns = _ref.columns,
+      flattenColumns = _ref.flattenColumns,
+      onHeaderRow = _ref.onHeaderRow;
+
+  var _React$useContext = React.useContext(TableContext),
+      prefixCls = _React$useContext.prefixCls,
+      getComponent = _React$useContext.getComponent;
+
+  var rows = React.useMemo(function () {
+    return parseHeaderRows(columns);
+  }, [columns]);
+  var WrapperComponent = getComponent(['header', 'wrapper'], 'thead');
+  var trComponent = getComponent(['header', 'row'], 'tr');
+  var thComponent = getComponent(['header', 'cell'], 'th');
+  return React.createElement(WrapperComponent, {
+    className: "".concat(prefixCls, "-thead")
+  }, rows.map(function (row, rowIndex) {
+    var rowNode = React.createElement(HeaderRow, {
+      key: rowIndex,
+      flattenColumns: flattenColumns,
+      cells: row,
+      stickyOffsets: stickyOffsets,
+      rowComponent: trComponent,
+      cellComponent: thComponent,
+      onHeaderRow: onHeaderRow,
+      index: rowIndex
+    });
+    return rowNode;
+  }));
+}
+
+export default Header;

web/node_modules/rc-table/es/Header/HeaderRow.d.ts

@@ -0,0 +1,16 @@
+/// <reference types="react" />
+import { CellType, StickyOffsets, ColumnType, CustomizeComponent, GetComponentProps } from '../interface';
+export interface RowProps<RecordType> {
+    cells: CellType<RecordType>[];
+    stickyOffsets: StickyOffsets;
+    flattenColumns: ColumnType<RecordType>[];
+    rowComponent: CustomizeComponent;
+    cellComponent: CustomizeComponent;
+    onHeaderRow: GetComponentProps<ColumnType<RecordType>[]>;
+    index: number;
+}
+declare function HeaderRow<RecordType>({ cells, stickyOffsets, flattenColumns, rowComponent: RowComponent, cellComponent: CellComponent, onHeaderRow, index, }: RowProps<RecordType>): JSX.Element;
+declare namespace HeaderRow {
+    var displayName: string;
+}
+export default HeaderRow;

web/node_modules/rc-table/es/Header/HeaderRow.js

@@ -0,0 +1,53 @@
+import * as React from 'react';
+import Cell from '../Cell';
+import TableContext from '../context/TableContext';
+import { getCellFixedInfo } from '../utils/fixUtil';
+import { getColumnsKey } from '../utils/valueUtil';
+
+function HeaderRow(_ref) {
+  var cells = _ref.cells,
+      stickyOffsets = _ref.stickyOffsets,
+      flattenColumns = _ref.flattenColumns,
+      RowComponent = _ref.rowComponent,
+      CellComponent = _ref.cellComponent,
+      onHeaderRow = _ref.onHeaderRow,
+      index = _ref.index;
+
+  var _React$useContext = React.useContext(TableContext),
+      prefixCls = _React$useContext.prefixCls,
+      direction = _React$useContext.direction;
+
+  var rowProps;
+
+  if (onHeaderRow) {
+    rowProps = onHeaderRow(cells.map(function (cell) {
+      return cell.column;
+    }), index);
+  }
+
+  var columnsKey = getColumnsKey(cells.map(function (cell) {
+    return cell.column;
+  }));
+  return React.createElement(RowComponent, Object.assign({}, rowProps), cells.map(function (cell, cellIndex) {
+    var column = cell.column;
+    var fixedInfo = getCellFixedInfo(cell.colStart, cell.colEnd, flattenColumns, stickyOffsets, direction);
+    var additionalProps;
+
+    if (column && column.onHeaderCell) {
+      additionalProps = cell.column.onHeaderCell(column);
+    }
+
+    return React.createElement(Cell, Object.assign({}, cell, {
+      ellipsis: column.ellipsis,
+      align: column.align,
+      component: CellComponent,
+      prefixCls: prefixCls,
+      key: columnsKey[cellIndex]
+    }, fixedInfo, {
+      additionalProps: additionalProps
+    }));
+  }));
+}
+
+HeaderRow.displayName = 'HeaderRow';
+export default HeaderRow;