choerodon-ui/pro/es/_util/PromiseMerger.js

An enterprise-class UI design language and React-based implementation

import _toConsumableArray from "@babel/runtime/helpers/toConsumableArray";
import _classCallCheck from "@babel/runtime/helpers/classCallCheck";
import _createClass from "@babel/runtime/helpers/createClass";
import { __decorate } from "tslib";
import { action, toJS } from 'mobx';
import Cache, { refreshCacheOptions } from './Cache';
var KEY = Symbol('KEY');

var PromiseMerger =
/*#__PURE__*/
function () {
  function PromiseMerger(callback, config) {
    var timeout = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 200;

    _classCallCheck(this, PromiseMerger);

    this.timeout = timeout;
    this.promiseMap = new Map();
    this.cache = new Cache(toJS(config));
    this.callback = callback;
    this.reaction = refreshCacheOptions(this.cache);
  }

  _createClass(PromiseMerger, [{
    key: "dispose",
    value: function dispose() {
      this.reaction();
    }
  }, {
    key: "add",
    value: function add(code, getBatchKey, args) {
      var _this = this;

      var cache = this.cache,
          promiseMap = this.promiseMap;
      var item = cache.get(code);

      if (item) {
        return Promise.resolve(item);
      }

      var batchKey = getBatchKey ? getBatchKey(KEY) : KEY;
      return new Promise(function (resolve, reject) {
        var promiseList = promiseMap.get(batchKey) || new Map();
        promiseMap.set(batchKey, promiseList);
        var promise = promiseList.get(code);

        var resolveCallback = function resolveCallback() {
          resolve(cache.get(code));
        };

        if (promise) {
          promise.resolves.push(resolveCallback);
          promise.rejects.push(reject);
        } else {
          if (_this.waitID) {
            clearTimeout(_this.waitID);
          }

          promise = {
            resolves: [resolveCallback],
            rejects: [reject]
          };
          promiseList.set(code, promise);
          _this.waitID = setTimeout(function () {
            var codeList = _toConsumableArray(promiseList.keys());

            if (process.env.LOGGER_LEVEL === 'info') {
              // eslint-disable-next-line no-console
              console.info("batch request: ".concat(codeList));
            }

            _this.callback(codeList, args).then(function (res) {
              codeList.forEach(function (key) {
                var value = promiseList.get(key);
                var data = res[key];

                _this.cache.set(key, data);

                promiseList["delete"](key);

                var _ref = value || {},
                    _ref$resolves = _ref.resolves,
                    resolves = _ref$resolves === void 0 ? [] : _ref$resolves;

                resolves.forEach(function (r) {
                  return r(data);
                });
              });
            })["catch"](function (error) {
              codeList.forEach(function (key) {
                var value = promiseList.get(key);
                promiseList["delete"](key);

                var _ref2 = value || {},
                    _ref2$rejects = _ref2.rejects,
                    rejects = _ref2$rejects === void 0 ? [] : _ref2$rejects;

                rejects.forEach(function (r) {
                  return r(error);
                });
              });
            });
          }, _this.timeout);
        }
      });
    }
  }]);

  return PromiseMerger;
}();

export { PromiseMerger as default };

__decorate([action], PromiseMerger.prototype, "add", null);
//# sourceMappingURL=PromiseMerger.js.map