@appbuckets/react-ui/RxTable/RxTable.factory.js

Just Another React UI Framework

'use strict';

Object.defineProperty(exports, '__esModule', { value: true });

var tslib = require('tslib');
var React = require('react');
var useColumns = require('./lib/useColumns.js');
var useDataFiltering = require('./lib/useDataFiltering.js');
var useDataLoad = require('./lib/useDataLoad.js');
var useDataSelector = require('./lib/useDataSelector.js');
var useDataSorting = require('./lib/useDataSorting.js');

function _interopNamespace(e) {
  if (e && e.__esModule) return e;
  var n = Object.create(null);
  if (e) {
    Object.keys(e).forEach(function (k) {
      if (k !== 'default') {
        var d = Object.getOwnPropertyDescriptor(e, k);
        Object.defineProperty(
          n,
          k,
          d.get
            ? d
            : {
                enumerable: true,
                get: function () {
                  return e[k];
                },
              }
        );
      }
    });
  }
  n['default'] = e;
  return Object.freeze(n);
}

var React__namespace = /*#__PURE__*/ _interopNamespace(React);

/* --------
 * Hook Definition
 * -------- */
function useRxTableFactory(config) {
  // ----
  // Code Destructuring
  // ----
  var classes = config.classes,
    userDefinedColumns = config.columns,
    data = config.data,
    defaultData = config.defaultData,
    defaultLoading = config.defaultLoading,
    userDefinedDefaultReverseSorting = config.defaultReverseSorting,
    userDefinedDefaultSelectedData = config.defaultSelectedData,
    userDefinedDefaultSort = config.defaultSort,
    filterLogic = config.filterLogic,
    userDefinedGetRowKey = config.getRowKey,
    isVirtualized = config.isVirtualized,
    onRowClick = config.onRowClick,
    onSelectedDataChange = config.onSelectedDataChange,
    onSortChange = config.onSortChange,
    reloadDependency = config.reloadDependency,
    reloadSilently = config.reloadSilently,
    userDefinedReverseSorting = config.reverseSorting,
    selectable = config.selectable,
    selectColumnProps = config.selectColumnProps,
    userDefinedSort = config.sort,
    styles = config.styles,
    width = config.width;
  // ----
  // Checker Builder
  // ----
  var hasFilterRow = React__namespace.useMemo(
    function () {
      return userDefinedColumns.some(function (column) {
        return !!column.filter;
      });
    },
    [userDefinedColumns]
  );
  var hasFooterRow = React__namespace.useMemo(
    function () {
      return userDefinedColumns.some(function (column) {
        return !!column.footer;
      });
    },
    [userDefinedColumns]
  );
  var hasHeaderRow = React__namespace.useMemo(
    function () {
      return userDefinedColumns.some(function (column) {
        return !!column.header;
      });
    },
    [userDefinedColumns]
  );
  // ----
  // Compute effective column and table widths
  // ----
  var _a = useColumns({
      columns: userDefinedColumns,
      selectable: selectable,
      selectColumnProps: selectColumnProps,
      width: width,
    }),
    columns = _a.columns,
    columnsWidth = _a.columnsWidth,
    effectiveTableWidth = _a.effectiveTableWidth,
    getWidth = _a.getWidth,
    totalColumnsWidth = _a.totalColumnsWidth;
  // ----
  // Data Management and Load
  // ----
  var dataState = useDataLoad({
    data: data,
    defaultData: defaultData,
    defaultLoading: defaultLoading,
    reloadDependency: reloadDependency,
    reloadSilently: reloadSilently,
  });
  // ----
  // Data Filtering
  // ----
  var _b = useDataFiltering(hasFilterRow, {
      columns: columns,
      data: dataState.data,
      filterLogic: filterLogic,
    }),
    filteredData = _b.filteredData,
    filters = _b.filters,
    setFilter = _b.setFilter;
  // ----
  // Enable Data Selector Hook
  // ----
  var dataSelector = useDataSelector({
    allData: dataState.data,
    filteredData: filteredData,
    defaultSelectedData: userDefinedDefaultSelectedData,
    selectable: !!selectable && dataState.reloadCount > 0,
    getRowKey: userDefinedGetRowKey,
    onSelectedDataChange: onSelectedDataChange,
  });
  // ----
  // Sorting Controller
  // ----
  var _c = useDataSorting({
      data: filteredData,
      defaultReverseSorting: userDefinedDefaultReverseSorting,
      defaultSort: userDefinedDefaultSort,
      onSortChange: onSortChange,
      reverseSorting: userDefinedReverseSorting,
      sort: userDefinedSort,
    }),
    isSortReversed = _c.isSortReversed,
    setSorting = _c.setSorting,
    sorting = _c.sorting,
    sortedData = _c.sortedData;
  // ----
  // Internal Handlers
  // ----
  var handleRowClick = React__namespace.useCallback(
    function (index) {
      if (onRowClick) {
        onRowClick(sortedData[index], index, sortedData);
      }
    },
    [onRowClick, sortedData]
  );
  return {
    data: dataState.data,
    tableData: sortedData,
    dataState: {
      error: dataState.error,
      isLoading: dataState.loading,
    },
    classes: classes !== null && classes !== void 0 ? classes : {},
    columns: {
      current: columns,
      getWidth: getWidth,
      width: columnsWidth,
    },
    filter: {
      current: filters,
      set: setFilter,
    },
    interaction: {
      isRowClickEnabled: typeof onRowClick === 'function',
      handleRowClick: handleRowClick,
    },
    layout: {
      effectiveTableWidth: effectiveTableWidth,
      hasFilterRow: hasFilterRow,
      hasFooterRow: hasFooterRow,
      hasHeaderRow: hasHeaderRow,
      isVirtualized: !!isVirtualized,
      totalColumnsWidth: totalColumnsWidth,
    },
    selection: tslib.__assign(tslib.__assign({}, dataSelector), {
      enabled: !!selectable && dataState.reloadCount > 0,
    }),
    sorting: {
      current: sorting,
      isReversed: isSortReversed,
      set: setSorting,
    },
    styles: styles !== null && styles !== void 0 ? styles : {},
  };
}

exports.useRxTableFactory = useRxTableFactory;