@appbuckets/react-ui/RxTable/lib/useDataSorting.js

Just Another React UI Framework

'use strict';

var tslib = require('tslib');
var React = require('react');
var arraySort = require('array-sort');
var reactUiCore = require('@appbuckets/react-ui-core');
var areEqualStringArray = require('../../utils/areEqualStringArray.js');
require('clsx');

function _interopDefaultLegacy(e) {
  return e && typeof e === 'object' && 'default' in e ? e : { default: e };
}

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);
var arraySort__default = /*#__PURE__*/ _interopDefaultLegacy(arraySort);

/* --------
 * Hook definition
 * -------- */
function useDataSorting(config) {
  var data = config.data,
    defaultReverseSorting = config.defaultReverseSorting,
    defaultSort = config.defaultSort,
    onSortChange = config.onSortChange,
    reverseSorting = config.reverseSorting,
    sort = config.sort;
  // ----
  // Define internal State
  // ----
  var _a = tslib.__read(
      reactUiCore.useAutoControlledValue([], {
        defaultProp: defaultSort,
        prop: sort,
      }),
      2
    ),
    sorting = _a[0],
    trySetSorting = _a[1];
  var _b = tslib.__read(
      reactUiCore.useAutoControlledValue(false, {
        defaultProp: defaultReverseSorting,
        prop: reverseSorting,
      }),
      2
    ),
    isSortReversed = _b[0],
    trySetReverseSorting = _b[1];
  // ----
  // Handlers
  // ----
  var handleChangeSorting = React__namespace.useCallback(
    function (newSorting, reverse) {
      /** Check if sorting is changed */
      var isSortChanged = !areEqualStringArray(sorting, newSorting);
      var isReversingChanged = reverse !== isSortReversed;
      /** If no change, return */
      if (!isSortChanged && !isReversingChanged) {
        return;
      }
      /** Call user defined handler */
      if (onSortChange) {
        onSortChange(newSorting, reverse);
      }
      /** Try to set new Sorting */
      if (isSortChanged) {
        trySetSorting(newSorting);
      }
      if (reverse !== isSortReversed) {
        trySetReverseSorting(reverse);
      }
    },
    [onSortChange, isSortReversed, sorting, trySetReverseSorting, trySetSorting]
  );
  // ----
  // Memoized Sorted Data
  // ----
  var sortedData = React__namespace.useMemo(
    function () {
      if (sorting.length) {
        return arraySort__default['default'](data, sorting, {
          reverse: isSortReversed,
        });
      }
      return data;
    },
    [data, isSortReversed, sorting]
  );
  // ----
  // Return Data and handler
  // ----
  return {
    sortedData: sortedData,
    setSorting: handleChangeSorting,
    isSortReversed: isSortReversed,
    sorting: sorting,
  };
}

module.exports = useDataSorting;