react-hooks-toolbox/es/useAxios/index.js

React hooks toolbox

import _regeneratorRuntime from "babel-runtime/regenerator";

var _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };

function _asyncToGenerator(fn) { return function () { var gen = fn.apply(this, arguments); return new Promise(function (resolve, reject) { function step(key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { return Promise.resolve(value).then(function (value) { step("next", value); }, function (err) { step("throw", err); }); } } return step("next"); }); }; }

import { useReducer, useEffect, useRef, useState } from "react";
import axios from "axios";

import { init, reducer } from "./reducer";
import { fetch_start, fetch_success, fetch_failure } from "./actions";

export function useAxios(_ref) {
    var _this = this;

    var url = _ref.url,
        method = _ref.method,
        _ref$options = _ref.options,
        options = _ref$options === undefined ? {} : _ref$options,
        _ref$controlledFetch = _ref.controlledFetch,
        controlledFetch = _ref$controlledFetch === undefined ? false : _ref$controlledFetch,
        _ref$axiosInstance = _ref.axiosInstance,
        axiosInstance = _ref$axiosInstance === undefined ? axios : _ref$axiosInstance,
        _ref$successCb = _ref.successCb,
        successCb = _ref$successCb === undefined ? function () {} : _ref$successCb,
        _ref$failedCb = _ref.failedCb,
        failedCb = _ref$failedCb === undefined ? function () {} : _ref$failedCb,
        _ref$onlyDispatchIf = _ref.onlyDispatchIf,
        onlyDispatchIf = _ref$onlyDispatchIf === undefined ? true : _ref$onlyDispatchIf;

    var _useReducer = useReducer(reducer, init),
        state = _useReducer[0],
        dispatch = _useReducer[1];

    var _useState = useState(null),
        innerTrigger = _useState[0],
        setInnerTrigger = _useState[1];

    var cancelToken = useRef();

    var optionsString = void 0;
    try {
        optionsString = JSON.stringify(options);
    } catch (err) {}

    var deps = controlledFetch ? [innerTrigger] : [method, optionsString, url, onlyDispatchIf];

    useEffect(function () {
        if (!onlyDispatchIf) {
            return;
        }
        if (!innerTrigger && controlledFetch) {
            return;
        }
        var fetchData = function () {
            var _ref2 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee() {
                var optionsObj, results;
                return _regeneratorRuntime.wrap(function _callee$(_context) {
                    while (1) {
                        switch (_context.prev = _context.next) {
                            case 0:
                                dispatch(fetch_start());
                                if (cancelToken.current) {
                                    cancelToken.current.cancel();
                                }
                                cancelToken.current = axios.CancelToken.source();
                                _context.prev = 3;
                                optionsObj = JSON.parse(optionsString);
                                _context.next = 7;
                                return axiosInstance.request(_extends({
                                    url: url,
                                    method: method,
                                    cancelToken: cancelToken.current.token
                                }, optionsObj));

                            case 7:
                                results = _context.sent;

                                successCb(results.data);
                                dispatch(fetch_success(results.data));
                                _context.next = 16;
                                break;

                            case 12:
                                _context.prev = 12;
                                _context.t0 = _context["catch"](3);

                                failedCb(_context.t0);
                                if (!axios.isCancel(_context.t0)) {
                                    dispatch(fetch_failure(_context.t0));
                                }

                            case 16:
                            case "end":
                                return _context.stop();
                        }
                    }
                }, _callee, _this, [[3, 12]]);
            }));

            return function fetchData() {
                return _ref2.apply(this, arguments);
            };
        }();
        fetchData();
        return function cleanup() {
            if (cancelToken.current) {
                cancelToken.current.cancel();
            }
        };
        // eslint-disable-next-line react-hooks/exhaustive-deps
    }, deps);

    return _extends({}, state, {
        dispatchFetch: function dispatchFetch() {
            setInnerTrigger(+new Date());
        }
    });
}