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

Just Another React UI Framework

import { __assign } from 'tslib';
import * as React from 'react';
import useColumns from './lib/useColumns.js';
import useDataFiltering from './lib/useDataFiltering.js';
import useDataLoad from './lib/useDataLoad.js';
import useDataSelector from './lib/useDataSelector.js';
import useDataSorting from './lib/useDataSorting.js';

/* --------
 * 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.useMemo(
    function () {
      return userDefinedColumns.some(function (column) {
        return !!column.filter;
      });
    },
    [userDefinedColumns]
  );
  var hasFooterRow = React.useMemo(
    function () {
      return userDefinedColumns.some(function (column) {
        return !!column.footer;
      });
    },
    [userDefinedColumns]
  );
  var hasHeaderRow = React.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.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: __assign(__assign({}, dataSelector), {
      enabled: !!selectable && dataState.reloadCount > 0,
    }),
    sorting: {
      current: sorting,
      isReversed: isSortReversed,
      set: setSorting,
    },
    styles: styles !== null && styles !== void 0 ? styles : {},
  };
}

export { useRxTableFactory };