@hsui/request/dist/request.umd.js

Hundsun frontend runtime request framework

(function (global, factory) {
  typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('@hsui/sdk')) :
  typeof define === 'function' && define.amd ? define(['exports', '@hsui/sdk'], factory) :
  (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.request = {}, global.huiSdk));
}(this, (function (exports, sdk) { 'use strict';

  function _defineProperty(obj, key, value) {
    if (key in obj) {
      Object.defineProperty(obj, key, {
        value: value,
        enumerable: true,
        configurable: true,
        writable: true
      });
    } else {
      obj[key] = value;
    }

    return obj;
  }

  function ownKeys(object, enumerableOnly) {
    var keys = Object.keys(object);

    if (Object.getOwnPropertySymbols) {
      var symbols = Object.getOwnPropertySymbols(object);
      enumerableOnly && (symbols = symbols.filter(function (sym) {
        return Object.getOwnPropertyDescriptor(object, sym).enumerable;
      })), keys.push.apply(keys, symbols);
    }

    return keys;
  }

  function _objectSpread2(target) {
    for (var i = 1; i < arguments.length; i++) {
      var source = null != arguments[i] ? arguments[i] : {};
      i % 2 ? ownKeys(Object(source), !0).forEach(function (key) {
        _defineProperty(target, key, source[key]);
      }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) {
        Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
      });
    }

    return target;
  }

  /**
   * Native extend
   */
  var extend = Object.assign;

  /**
   * Lodash noop
   */
  function noop() {
    // No operation performed.
  }

  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 _arrayWithoutHoles(arr) {
    if (Array.isArray(arr)) return _arrayLikeToArray(arr);
  }

  function _iterableToArray(iter) {
    if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
  }

  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 _nonIterableSpread() {
    throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
  }

  function _toConsumableArray(arr) {
    return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread();
  }

  function _classCallCheck(instance, Constructor) {
    if (!(instance instanceof Constructor)) {
      throw new TypeError("Cannot call a class as a function");
    }
  }

  function _defineProperties(target, props) {
    for (var i = 0; i < props.length; i++) {
      var descriptor = props[i];
      descriptor.enumerable = descriptor.enumerable || false;
      descriptor.configurable = true;
      if ("value" in descriptor) descriptor.writable = true;
      Object.defineProperty(target, descriptor.key, descriptor);
    }
  }

  function _createClass(Constructor, protoProps, staticProps) {
    if (protoProps) _defineProperties(Constructor.prototype, protoProps);
    if (staticProps) _defineProperties(Constructor, staticProps);
    Object.defineProperty(Constructor, "prototype", {
      writable: false
    });
    return Constructor;
  }

  /**
   * @class - MiddlewareManager
   * @classdesc - manager of middlewares
   */
  var MiddlewareManager = /*#__PURE__*/function () {
    function MiddlewareManager(type) {
      _classCallCheck(this, MiddlewareManager);
      this.type = type;
      this.middlewares = [];
      this.finalHook = noop;
    }
    _createClass(MiddlewareManager, [{
      key: "final",
      value: function final(hook) {
        this.finalHook = hook;
      }
    }, {
      key: "concat",
      value: function concat(middlewares) {
        this.middlewares = this.middlewares.concat(middlewares);
      }
    }, {
      key: "push",
      value: function push(middleware) {
        this.middlewares.push(middleware);
      }

      // just run and return nothing
    }, {
      key: "justRun",
      value: function justRun() {
        this.args = Array.prototype.slice.call(arguments);
        var _this = this;
        var fn = function fn(index) {
          if (index < this.middlewares.length) {
            this.middlewares[index].apply(null, [].concat(_toConsumableArray(this.args), [function () {
              fn.call(_this, ++index);
            }]));
          } else {
            this.finalHook.apply(null, this.args);
          }
        };
        fn.call(_this, 0);
      }

      // run middlewares and return a promise
    }, {
      key: "runAndReturn",
      value: function runAndReturn() {
        this.args = Array.prototype.slice.call(arguments);
        var _this = this;
        return new Promise(function (resolve, reject) {
          var fn = function fn(index) {
            if (index < this.middlewares.length) {
              try {
                this.middlewares[index].apply(null, [].concat(_toConsumableArray(this.args), [function () {
                  fn.call(_this, ++index);
                }]));
              } catch (error) {
                reject(error);
              }
            } else {
              // final hook should return a promise too
              this.finalHook.apply(null, this.args).then(resolve).catch(reject);
            }
          };
          fn.call(_this, 0);
        });
      }
    }]);
    return MiddlewareManager;
  }();

  var logger = sdk.createLogger();
  var log = function log() {
    for (var _len = arguments.length, content = new Array(_len), _key = 0; _key < _len; _key++) {
      content[_key] = arguments[_key];
    }
    return logger.info.apply(logger, content);
  };
  logger.levels.forEach(function (level) {
    log[level] = function () {
      for (var _len2 = arguments.length, content = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
        content[_key2] = arguments[_key2];
      }
      return logger[level].apply(logger, content);
    };
  });

  function final_(error, response) {
    if (error) {
      return Promise.reject(error);
    }
    return Promise.resolve(response);
  }

  /**
   * 合并全局配置和实例配置
   * @param {Object} defaultConfig 全局配置
   * @param {Object} config 实例配置
   * @returns 合并后的请求配置
   */
  function mergeConfig(defaultConfig, config) {
    var mergedConfig = _objectSpread2(_objectSpread2({}, defaultConfig), config);
    if (mergedConfig.shouldMergeHeaders) {
      var defaultHeaders = defaultConfig.headers;
      var configHeaders = config.headers;
      var mergedHeaders = _objectSpread2(_objectSpread2({}, defaultHeaders), configHeaders);
      mergedConfig.headers = mergedHeaders;
    }
    return mergedConfig;
  }

  /**
   * fetchPromise（调用fetch函数得到） 和 ajaxPromise(调用ajax函数得到) 关联对应
   * 其中，key 为 fetchPromise，value 为 ajaxPromise
   */
  var fetchMap = new WeakMap();
  function initFetch() {
    var _ref = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},
      _ref$defaultConfig = _ref.defaultConfig,
      defaultConfig = _ref$defaultConfig === void 0 ? {
        method: 'post',
        data: {},
        timeout: 5000,
        headers: {},
        withCredentials: false
      } : _ref$defaultConfig,
      _ref$beforeRequestSen = _ref.beforeRequestSendMiddlewares,
      beforeRequestSendMiddlewares = _ref$beforeRequestSen === void 0 ? [] : _ref$beforeRequestSen,
      _ref$afterRequestSend = _ref.afterRequestSendMiddlewares,
      afterRequestSendMiddlewares = _ref$afterRequestSend === void 0 ? [] : _ref$afterRequestSend;
    var beforeRequestSend = new MiddlewareManager('before-request-send');
    beforeRequestSend.concat(beforeRequestSendMiddlewares);
    var afterRequestSend = new MiddlewareManager('after-request-send');
    afterRequestSend.concat(afterRequestSendMiddlewares);
    afterRequestSend.final(final_);
    var ajaxPromise; // 存储 ajax 函数返回的 promise

    beforeRequestSend.final(function (config) {
      return new Promise(function (resolve, reject) {
        var error, response;
        ajaxPromise = sdk.ajax(config);
        ajaxPromise.then(function (res) {
          return response = res;
        }).catch(function (err) {
          return error = err;
        }).finally(function () {
          afterRequestSend.runAndReturn(error, response).then(resolve).catch(reject);
        });
      });
    });
    var fetch = function fetch(config) {
      log.debug('Fetch 实例初始化选项', mergeConfig(defaultConfig, config));
      var fetchPromise = beforeRequestSend.runAndReturn(mergeConfig(defaultConfig, config));
      fetchMap.set(fetchPromise, ajaxPromise);
      return fetchPromise;
    };
    fetch.get = function (url, config) {
      if (config) {
        extend(config, {
          url: url,
          method: 'get'
        });
      } else {
        config = {
          url: url,
          method: 'get'
        };
      }
      return fetch(config);
    };
    fetch.post = function (url, data, config) {
      if (config) {
        extend(config, {
          url: url,
          method: 'post',
          data: data
        });
      } else {
        config = {
          url: url,
          method: 'post',
          data: data
        };
      }
      return fetch(config);
    };
    fetch.cancel = function () {
      for (var _len = arguments.length, fetchPromises = new Array(_len), _key = 0; _key < _len; _key++) {
        fetchPromises[_key] = arguments[_key];
      }
      fetchPromises.forEach(function (fetchPromise, index) {
        var ajaxPromise = fetchMap.get(fetchPromise); // 根据传入的 fetchPromise，查找对应的 ajaxPromise
        var cancel = sdk.ajaxCancelMap.get(ajaxPromise); // 根据指定的 ajaxPromise，查找对应的取消函数
        cancel ? cancel() : log.debug("\u6CA1\u6709\u627E\u5230\u4E0B\u6807\u4E3A ".concat(index, " \u5BF9\u5E94\u7684 cancel \u51FD\u6570"));
      });
    };
    return fetch;
  }

  exports.initFetch = initFetch;

  Object.defineProperty(exports, '__esModule', { value: true });

})));