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

Just Another React UI Framework

import { __read, __awaiter, __generator, __assign } from 'tslib';
import * as React from '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 = __read(
      React.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.useCallback(
    function () {
      return __awaiter(_this, void 0, void 0, function () {
        var result_1, error_1;
        return __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 __assign(__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.useEffect(
    function () {
      loadData();
    },
    [loadData, reloadDependency]
  );
  // ----
  // Return the Data State
  // ----
  return dataState;
}

export { useDataLoad as default };