@hsui/request/dist/request.esm.js

Hundsun frontend runtime request framework

import _objectSpread from '@babel/runtime/helpers/esm/objectSpread2';
import { createLogger, ajax, ajaxCancelMap } from '@hsui/sdk';
import _toConsumableArray from '@babel/runtime/helpers/esm/toConsumableArray';
import _classCallCheck from '@babel/runtime/helpers/esm/classCallCheck';
import _createClass from '@babel/runtime/helpers/esm/createClass';

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

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

/**
 * @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 = 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 = _objectSpread(_objectSpread({}, defaultConfig), config);
  if (mergedConfig.shouldMergeHeaders) {
    var defaultHeaders = defaultConfig.headers;
    var configHeaders = config.headers;
    var mergedHeaders = _objectSpread(_objectSpread({}, 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 = 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 = 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;
}

export { initFetch };