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

Just Another React UI Framework

'use strict';

var tslib = require('tslib');
var React = require('react');

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 useDataLoad(config) {
  var _this = this;
  var data = config.data,
    defaultData = config.defaultData,
    defaultLoading = config.defaultLoading,
    reloadDependency = config.reloadDependency,
    reloadSilently = config.reloadSilently;
  // ----
  // Build internal state
  // ----
  var _a = tslib.__read(
      React__namespace.useState({
        data: Array.isArray(data)
          ? data
          : defaultData !== null && defaultData !== void 0
          ? defaultData
          : [],
        error: null,
        loading:
          defaultLoading !== null && defaultLoading !== void 0
            ? defaultLoading
            : typeof data === 'function',
        lastReloadTimeStamp: 0,
        reloadCount: 0,
      }),
      2
    ),
    dataState = _a[0],
    setDataState = _a[1];
  // ----
  // Build the Load Data Function
  // ----
  var loadData = React__namespace.useCallback(
    function () {
      return tslib.__awaiter(_this, void 0, void 0, function () {
        var result_1, error_1;
        return tslib.__generator(this, function (_a) {
          switch (_a.label) {
            case 0:
              /**
               * If data is a plain a plain
               * array object then there is no
               * need to wait for data load
               */
              if (Array.isArray(data)) {
                setDataState(function (curr) {
                  return {
                    data: data,
                    loading: false,
                    error: null,
                    lastReloadTimeStamp: Date.now(),
                    reloadCount: curr.reloadCount + 1,
                  };
                });
                return [2 /*return*/];
              }
              /**
               * If data loading is a function then
               * must set the loading state and wait
               * for data load.
               * Data load is typical async than must
               * set the loading state if the reload
               * is not silent. A silent reload will
               * reload table data without changing loading state
               */
              if (!dataState.loading && !reloadSilently) {
                setDataState(function (curr) {
                  return tslib.__assign(tslib.__assign({}, curr), {
                    loading: true,
                  });
                });
              }
              _a.label = 1;
            case 1:
              _a.trys.push([1, 3, , 4]);
              return [4 /*yield*/, data(Date.now())];
            case 2:
              result_1 = _a.sent();
              setDataState(function (curr) {
                return {
                  data: result_1,
                  loading: false,
                  error: null,
                  lastReloadTimeStamp: Date.now(),
                  reloadCount: curr.reloadCount + 1,
                };
              });
              return [3 /*break*/, 4];
            case 3:
              error_1 = _a.sent();
              setDataState(function (curr) {
                return {
                  data: [],
                  loading: false,
                  error: error_1,
                  lastReloadTimeStamp: Date.now(),
                  reloadCount: curr.reloadCount + 1,
                };
              });
              return [3 /*break*/, 4];
            case 4:
              return [2 /*return*/];
          }
        });
      });
    },
    [data, dataState.loading, reloadSilently]
  );
  // ----
  // Build the Load/Reload of Data
  // ----
  React__namespace.useEffect(
    function () {
      loadData();
    },
    [loadData, reloadDependency]
  );
  // ----
  // Return the Data State
  // ----
  return dataState;
}

module.exports = useDataLoad;