@livelybone/use-async-data/lib/es/index.js

A react hook for deal data that generated asynchronously

/**
 * Bundle of @livelybone/use-async-data
 * Generated: 2020-07-29
 * Version: 2.2.2
 * License: MIT
 * Author: 2631541504@qq.com
 */

import { useState, useRef, useCallback } from 'react';
import useMounted from '@livelybone/use-mounted';

function _slicedToArray(arr, i) {
  return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest();
}

function _arrayWithHoles(arr) {
  if (Array.isArray(arr)) return arr;
}

function _iterableToArrayLimit(arr, i) {
  if (typeof Symbol === "undefined" || !(Symbol.iterator in Object(arr))) return;
  var _arr = [];
  var _n = true;
  var _d = false;
  var _e = undefined;

  try {
    for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) {
      _arr.push(_s.value);

      if (i && _arr.length === i) break;
    }
  } catch (err) {
    _d = true;
    _e = err;
  } finally {
    try {
      if (!_n && _i["return"] != null) _i["return"]();
    } finally {
      if (_d) throw _e;
    }
  }

  return _arr;
}

function _unsupportedIterableToArray(o, minLen) {
  if (!o) return;
  if (typeof o === "string") return _arrayLikeToArray(o, minLen);
  var n = Object.prototype.toString.call(o).slice(8, -1);
  if (n === "Object" && o.constructor) n = o.constructor.name;
  if (n === "Map" || n === "Set") return Array.from(o);
  if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen);
}

function _arrayLikeToArray(arr, len) {
  if (len == null || len > arr.length) len = arr.length;

  for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i];

  return arr2;
}

function _nonIterableRest() {
  throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
}

function useAsyncData(api, initialValue, errorCb, dealFn) {
  var _useState = useState(initialValue),
      _useState2 = _slicedToArray(_useState, 2),
      data = _useState2[0],
      setData = _useState2[1];

  var _useState3 = useState(false),
      _useState4 = _slicedToArray(_useState3, 2),
      isFetching = _useState4[0],
      setIsFetching = _useState4[1];

  var mountInfo = useMounted();
  var callbacks = useRef({
    api: api
  });
  callbacks.current.api = api;

  callbacks.current.dealFn = dealFn && function (res) {
    return dealFn(res, data);
  };

  var getData = useCallback(function () {
    var _callbacks$current = callbacks.current,
        $api = _callbacks$current.api,
        $dealFn = _callbacks$current.dealFn;
    setIsFetching(true);
    return Promise.resolve($api.apply(void 0, arguments)).then(function (res) {
      return $dealFn ? $dealFn(res) : res;
    }).then(function (res) {
      if (!mountInfo.current.unmounted) {
        setIsFetching(false);
        setData(res);
      }

      return res;
    }).catch(function (e) {
      if (!mountInfo.current.unmounted) {
        setIsFetching(false);
      }

      return Promise.resolve(errorCb(e)).then(function (shouldResetData) {
        if (!shouldResetData) return data;

        if (!mountInfo.current.unmounted) {
          setData(initialValue);
        }

        return typeof initialValue === 'function' ? initialValue() : initialValue;
      });
    });
  }, []);
  return [data, getData, isFetching, setData];
}

export default useAsyncData;