@rematch/loading/dist/loading.esm.js

Loading indicator plugin for Rematch

function _extends() {
  _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;
  };

  return _extends.apply(this, arguments);
}

var createLoadingAction = function createLoadingAction(converter, i, cntState) {
  return function (state, payload) {
    var _extends2, _extends3, _extends4;

    var _ref = payload || {
      name: '',
      action: ''
    },
        name = _ref.name,
        action = _ref.action,
        detailedPayload = _ref.detailedPayload;

    cntState.global += i;
    cntState.models[name] += i;
    cntState.effects[name][action] += i;
    return _extends({}, state, {
      global: converter(cntState.global, detailedPayload),
      models: _extends({}, state.models, (_extends2 = {}, _extends2[name] = converter(cntState.models[name], detailedPayload), _extends2)),
      effects: _extends({}, state.effects, (_extends4 = {}, _extends4[name] = _extends({}, state.effects[name], (_extends3 = {}, _extends3[action] = converter(cntState.effects[name][action], detailedPayload), _extends3)), _extends4))
    });
  };
};

var validateConfig = function validateConfig(config) {
  if (process.env.NODE_ENV !== 'production') {
    if (config.name && typeof config.name !== 'string') {
      throw new Error('loading plugin config name must be a string');
    }

    if (config.asNumber && typeof config.asNumber !== 'boolean') {
      throw new Error('loading plugin config asNumber must be a boolean');
    }

    if (config.asNumber) {
      console.warn(['@rematch/loading deprecation warning:', '\n', '"asNumber" property from @rematch/loading is deprecated, consider replacing "asNumber" to "type": "number".', '\n', 'In future Rematch versions, "asNumber" will be removed.'].join(' '));
    }

    if (config.whitelist && !Array.isArray(config.whitelist)) {
      throw new Error('loading plugin config whitelist must be an array of strings');
    }

    if (config.blacklist && !Array.isArray(config.blacklist)) {
      throw new Error('loading plugin config blacklist must be an array of strings');
    }

    if (config.whitelist && config.blacklist) {
      throw new Error('loading plugin config cannot have both a whitelist & a blacklist');
    }
  }
};

function assignExtraPayload(insert, error, success) {
  return insert ? {
    error: error,
    success: success
  } : null;
}

var index = (function (config) {
  if (config === void 0) {
    config = {};
  }

  validateConfig(config);
  var loadingModelName = config.name || 'loading';

  if (config.asNumber) {
    config.type = 'number';
  }

  var isAsNumber = config.type === 'number';
  var isAsDetailed = config.type === 'full';

  var converter = function converter(cnt, detailedPayload) {
    if (isAsNumber) return cnt;

    if (isAsDetailed && detailedPayload) {
      return _extends({}, detailedPayload, {
        loading: cnt > 0
      });
    }

    if (isAsDetailed) {
      return {
        loading: cnt > 0,
        success: false,
        error: false
      };
    }

    return cnt > 0;
  };

  var loadingInitialState = {
    global: converter(0),
    models: {},
    effects: {}
  };
  var cntState = {
    global: 0,
    models: {},
    effects: {}
  };
  var loading = {
    name: loadingModelName,
    reducers: {
      hide: createLoadingAction(converter, -1, cntState),
      show: createLoadingAction(converter, 1, cntState)
    },
    state: loadingInitialState
  };
  var initialLoadingValue = converter(0);
  return {
    config: {
      models: {
        loading: loading
      }
    },
    onModel: function onModel(_ref2, rematch) {
      var name = _ref2.name;

      if (name === loadingModelName) {
        return;
      }

      cntState.models[name] = 0;
      cntState.effects[name] = {};
      loadingInitialState.models[name] = initialLoadingValue;
      loadingInitialState.effects[name] = {};
      var modelActions = rematch.dispatch[name];
      Object.keys(modelActions).forEach(function (action) {
        if (rematch.dispatch[name][action].isEffect === false) {
          return;
        }

        cntState.effects[name][action] = 0;
        loadingInitialState.effects[name][action] = initialLoadingValue;
        var actionType = name + "/" + action;

        if (config.whitelist && !config.whitelist.includes(actionType)) {
          return;
        }

        if (config.blacklist && config.blacklist.includes(actionType)) {
          return;
        }

        var origEffect = rematch.dispatch[name][action];

        var effectWrapper = function effectWrapper() {
          try {
            rematch.dispatch[loadingModelName].show({
              name: name,
              action: action,
              detailedPayload: assignExtraPayload(isAsDetailed, false, false)
            });
            var effectResult = origEffect.apply(void 0, arguments);

            if (effectResult != null && effectResult.then) {
              return effectResult.then(function (r) {
                rematch.dispatch[loadingModelName].hide({
                  name: name,
                  action: action,
                  detailedPayload: assignExtraPayload(isAsDetailed, false, true)
                });
                return r;
              })["catch"](function (err) {
                rematch.dispatch[loadingModelName].hide({
                  name: name,
                  action: action,
                  detailedPayload: assignExtraPayload(isAsDetailed, err, false)
                });
                throw err;
              });
            }

            rematch.dispatch[loadingModelName].hide({
              name: name,
              action: action,
              detailedPayload: assignExtraPayload(isAsDetailed, false, true)
            });
            return effectResult;
          } catch (error) {
            rematch.dispatch[loadingModelName].hide({
              name: name,
              action: action,
              detailedPayload: assignExtraPayload(isAsDetailed, error, false)
            });
            throw error;
          }
        };

        effectWrapper.isEffect = true;
        rematch.dispatch[name][action] = effectWrapper;
      });
    }
  };
});

export { index as default };
//# sourceMappingURL=loading.esm.js.map