nishant-design-system/lib/components/Table/StaticTable.js

Sense UI components library

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.BasicTableBody = exports.BasicTable = void 0;
exports.StaticTable = StaticTable;
var React = _interopRequireWildcard(require("react"));
var _get = _interopRequireDefault(require("lodash/get"));
var _xor = _interopRequireDefault(require("lodash/xor"));
var _classify = require("../../utils/classify");
var _makeClassNameComponent = require("../../utils/makeClassNameComponent");
var _DefaultRow = require("./DefaultRow");
var _DefaultTableHeader = require("./DefaultTableHeader");
var _TableModule = _interopRequireDefault(require("./Table.module.css"));
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }

const BasicTable = (0, _makeClassNameComponent.makeClassNameComponent)(_TableModule.default.defaultTable, 'table');
exports.BasicTable = BasicTable;
const BasicTableBody = (0, _makeClassNameComponent.makeClassNameComponent)(_TableModule.default.defaultTableBody, 'tbody');

/**
 * A Static Default Table.
 *
 * Our
 */
exports.BasicTableBody = BasicTableBody;
function StaticTable(props) {
  const {
    classNames,
    className,
    Row,
    entries,
    extras,
    rowKeys,
    headers,
    showHeader = true,
    tableHeaderClassName,
    sortable,
    // eslint-disable-next-line unused-imports/no-unused-vars
    defaultSortKey,
    // eslint-disable-next-line unused-imports/no-unused-vars
    defaultSortDirection = 'original',
    // eslint-disable-next-line unused-imports/no-unused-vars
    onSort,
    handleSortClick,
    sortKey,
    sortDirection,
    selectedKeys,
    onSelect,
    isLoading,
    idName = 'id',
    emptyText,
    disabled,
    customLoader,
    borderRadius
  } = props;

  // this is a fallback and honestly probably doesn't need the
  // memo'ing
  const mappedKeys = React.useMemo(() => rowKeys ?? entries.map(e => (0, _get.default)(e, idName)), [entries, idName, rowKeys]);

  /**
   * this function is also used to decide weather to show checkbox in header or not. so it's value is undefined incase selectedKeys is not there.
   */

  const handleHeaderCheckboxClick = selectedKeys ? _ref => {
    let {
      checked
    } = _ref;
    let selectedRowIds = [];
    if (selectedKeys) {
      if (checked === true) {
        selectedRowIds = entries.map(singleRowObj => (0, _get.default)(singleRowObj, idName));
      }
      onSelect?.(selectedRowIds);
    }
  } : undefined;
  return /*#__PURE__*/React.createElement("div", {
    className: (0, _classify.classify)(_TableModule.default.tableContainer, classNames?.wrapper),
    "data-id": "table-wrap",
    style: {
      '--border-radius': borderRadius
    }
  }, /*#__PURE__*/React.createElement(BasicTable, {
    "data-id": "basic-table",
    className: (0, _classify.classify)(className, classNames?.table)
  }, showHeader && /*#__PURE__*/React.createElement(_DefaultTableHeader.DefaultTableHeader, {
    className: (0, _classify.classify)(tableHeaderClassName, classNames?.tableHeader),
    sortable: sortable,
    columns: headers,
    handleSortClick: handleSortClick,
    sortKey: sortKey,
    sortDirection: sortDirection,
    disabled: disabled,
    handleCheckboxClick: handleHeaderCheckboxClick,
    checked: selectedKeys == null || selectedKeys.length === 0 ? 'false' : selectedKeys.length < entries.length ? 'mixed' : 'true'
  }), /*#__PURE__*/React.createElement(BasicTableBody, {
    className: classNames?.tableBody
  }, isLoading || !entries.length ? /*#__PURE__*/React.createElement(_DefaultRow.EmptyRow, {
    isLoading: isLoading,
    emptyText: emptyText,
    headersLength: handleHeaderCheckboxClick ? headers.length + 1 : headers.length,
    customLoader: customLoader
  }) : mappedKeys.map(key => {
    const data = entries.find(e => (0, _get.default)(e, idName) === key);
    if (data == null) {
      return null;
    }
    data;
    const selected = selectedKeys?.includes((0, _get.default)(data, idName)) ?? undefined;
    return Row ? /*#__PURE__*/React.createElement(Row, {
      key: key,
      data: data,
      headers: headers
      // extras and rowKeys are both 'optional'
      ,
      extras: extras,
      sortedKeys: rowKeys ?? mappedKeys,
      selected: selected,
      disabled: disabled
    }) : /*#__PURE__*/React.createElement(_DefaultRow.DefaultRow, {
      key: key,
      data: data,
      extras: extras,
      headers: headers,
      selected: selected,
      onSelect: selectedKeys != null ? _v => onSelect?.((0, _xor.default)(selectedKeys ?? [], [key])) : undefined,
      disabled: disabled
    });
  }))));
}