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

React hooks toolbox

"use strict";

exports.__esModule = true;

var _regenerator = require("babel-runtime/regenerator");

var _regenerator2 = _interopRequireDefault(_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; };

exports.useAxios = useAxios;

var _react = require("react");

var _axios = require("axios");

var _axios2 = _interopRequireDefault(_axios);

var _reducer = require("./reducer");

var _actions = require("./actions");

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

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"); }); }; }

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 ? _axios2.default : _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 = (0, _react.useReducer)(_reducer.reducer, _reducer.init),
        state = _useReducer[0],
        dispatch = _useReducer[1];

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

    var cancelToken = (0, _react.useRef)();

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

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

    (0, _react.useEffect)(function () {
        if (!onlyDispatchIf) {
            return;
        }
        if (!innerTrigger && controlledFetch) {
            return;
        }
        var fetchData = function () {
            var _ref2 = _asyncToGenerator( /*#__PURE__*/_regenerator2.default.mark(function _callee() {
                var optionsObj, results;
                return _regenerator2.default.wrap(function _callee$(_context) {
                    while (1) {
                        switch (_context.prev = _context.next) {
                            case 0:
                                dispatch((0, _actions.fetch_start)());
                                if (cancelToken.current) {
                                    cancelToken.current.cancel();
                                }
                                cancelToken.current = _axios2.default.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((0, _actions.fetch_success)(results.data));
                                _context.next = 16;
                                break;

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

                                failedCb(_context.t0);
                                if (!_axios2.default.isCancel(_context.t0)) {
                                    dispatch((0, _actions.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());
        }
    });
}