redux-act/dist/redux-act.js

An opinionated lib to create actions and reducers for Redux

(function(f){if(typeof exports==="object"&&typeof module!=="undefined"){module.exports=f()}else if(typeof define==="function"&&define.amd){define([],f)}else{var g;if(typeof window!=="undefined"){g=window}else if(typeof global!=="undefined"){g=global}else if(typeof self!=="undefined"){g=self}else{g=this}g.ReduxAct = f()}})(function(){var define,module,exports;return (function(){function r(e,n,t){function o(i,f){if(!n[i]){if(!e[i]){var c="function"==typeof require&&require;if(!f&&c)return c(i,!0);if(u)return u(i,!0);var a=new Error("Cannot find module '"+i+"'");throw a.code="MODULE_NOT_FOUND",a}var p=n[i]={exports:{}};e[i][0].call(p.exports,function(r){var n=e[i][1][r];return o(n||r)},p,p.exports,r,e,n,t)}return n[i].exports}for(var u="function"==typeof require&&require,i=0;i<t.length;i++)o(t[i]);return o}return r})()({1:[function(require,module,exports){
"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports["default"] = asError;

function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }

function asError(action) {
  if (_typeof(action) === 'object' && action !== null) {
    action.error = true;
  }

  return action;
}

;
},{}],2:[function(require,module,exports){
"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports["default"] = assignAll;

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

function assignAll(actions, stores) {
  if (Array.isArray(actions)) {
    return actions.map(function (action) {
      return action.assignTo(stores);
    });
  }

  return Object.keys(actions).reduce(function (assigns, action) {
    return _extends(assigns, _defineProperty({}, action, actions[action].assignTo(stores)));
  }, {});
}

;
},{}],3:[function(require,module,exports){
"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports["default"] = void 0;

var _createAction = _interopRequireDefault(require("./createAction"));

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

var _default = (0, _createAction["default"])('Batch', function () {
  for (var _len = arguments.length, actions = new Array(_len), _key = 0; _key < _len; _key++) {
    actions[_key] = arguments[_key];
  }

  if (actions.length === 1 && Array.isArray(actions[0])) {
    return actions[0];
  }

  return actions;
});

exports["default"] = _default;
},{"./createAction":5}],4:[function(require,module,exports){
"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports["default"] = bindAll;

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

function bindAll(actions, stores) {
  if (Array.isArray(actions)) {
    return actions.map(function (action) {
      return action.bindTo(stores);
    });
  }

  return Object.keys(actions).reduce(function (binds, action) {
    return _extends(binds, _defineProperty({}, action, actions[action].bindTo(stores)));
  }, {});
}

;
},{}],5:[function(require,module,exports){
"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports["default"] = createAction;

var _types = require("./types");

var id = 0;

var identity = function identity(arg) {
  return arg;
};

var normalize = function normalize(dispatchOrStore) {
  if (dispatchOrStore && typeof dispatchOrStore.dispatch === 'function') {
    return dispatchOrStore.dispatch;
  } else {
    return dispatchOrStore;
  }
};

var normalizeAll = function normalizeAll(dispatchOrStores) {
  if (Array.isArray(dispatchOrStores)) {
    return dispatchOrStores.map(normalize);
  } else {
    return normalize(dispatchOrStores);
  }
};

function createAction(description, payloadReducer, metaReducer) {
  if (typeof description === 'function') {
    metaReducer = payloadReducer;
    payloadReducer = description;
    description = undefined;
  }

  if (typeof payloadReducer !== 'function') {
    payloadReducer = identity;
  }

  if (typeof metaReducer !== 'function') {
    metaReducer = undefined;
  }

  var isSerializable = typeof description === 'string' && /^[0-9A-Z_]+$/.test(description);

  if (isSerializable) {
    (0, _types.check)(description);
    (0, _types.add)(description);
  } else {
    ++id;
  }

  var type = isSerializable ? description : "[".concat(id, "]").concat(description ? ' ' + description : '');
  var dispatchFunctions = undefined;

  function makeAction() {
    var payload = payloadReducer.apply(void 0, arguments);

    if (metaReducer) {
      return {
        type: type,
        payload: payload,
        error: payload instanceof Error,
        meta: metaReducer.apply(void 0, arguments)
      };
    }

    return {
      type: type,
      payload: payload,
      error: payload instanceof Error
    };
  }

  var makeAndDispatch = function makeAndDispatch(dispatchs, isError) {
    return function () {
      var payloadedAction = makeAction.apply(void 0, arguments);

      if (!payloadedAction.error) {
        payloadedAction.error = isError;
      }

      if (Array.isArray(dispatchs)) {
        return dispatchs.map(function (dispatch) {
          return dispatch(payloadedAction);
        });
      } else if (dispatchs) {
        return dispatchs(payloadedAction);
      } else {
        return payloadedAction;
      }
    };
  };

  function actionCreator() {
    return makeAndDispatch(dispatchFunctions, false).apply(void 0, arguments);
  }

  actionCreator.asError = function () {
    return makeAndDispatch(dispatchFunctions, true).apply(void 0, arguments);
  };

  actionCreator.getType = function () {
    return type;
  };

  actionCreator.toString = function () {
    return type;
  };

  actionCreator.raw = makeAction;

  actionCreator.assignTo = function (dispatchOrStores) {
    dispatchFunctions = normalizeAll(dispatchOrStores);
    return actionCreator;
  };

  actionCreator.assigned = function () {
    return !!dispatchFunctions;
  };

  actionCreator.bound = function () {
    return false;
  };

  actionCreator.dispatched = actionCreator.assigned;

  actionCreator.bindTo = function (dispatchOrStores) {
    var boundActionCreator = makeAndDispatch(normalizeAll(dispatchOrStores, false));
    boundActionCreator.asError = makeAndDispatch(normalizeAll(dispatchOrStores, true));
    boundActionCreator.raw = makeAction;
    boundActionCreator.getType = actionCreator.getType;
    boundActionCreator.toString = actionCreator.toString;

    boundActionCreator.assignTo = function () {
      return boundActionCreator;
    };

    boundActionCreator.bindTo = function () {
      return boundActionCreator;
    };

    boundActionCreator.assigned = function () {
      return false;
    };

    boundActionCreator.bound = function () {
      return true;
    };

    boundActionCreator.dispatched = boundActionCreator.bound;
    return boundActionCreator;
  };

  return actionCreator;
}

;
},{"./types":11}],6:[function(require,module,exports){
"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports["default"] = createReducer;

var _batch = _interopRequireDefault(require("./batch"));

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

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

function normalizeType(typeOrActionCreator) {
  if (typeOrActionCreator && typeOrActionCreator.getType) {
    return typeOrActionCreator.toString();
  }

  return typeOrActionCreator;
}

function createReducer() {
  var handlers = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
  var defaultState = arguments.length > 1 ? arguments[1] : undefined;
  var opts = {
    payload: true,
    fallback: null
  };

  var reducer = _extends(reduce, {
    has: has,
    on: on,
    off: off,
    options: options
  });

  function has(typeOrActionCreator) {
    return !!handlers[normalizeType(typeOrActionCreator)];
  }

  function on(typeOrActionCreator, handler) {
    if (Array.isArray(typeOrActionCreator)) {
      typeOrActionCreator.forEach(function (action) {
        on(action, handler);
      });
    } else {
      handlers[normalizeType(typeOrActionCreator)] = handler;
    }

    return reducer;
  }

  function off(typeOrActionCreator) {
    if (Array.isArray(typeOrActionCreator)) {
      typeOrActionCreator.forEach(off);
    } else {
      delete handlers[normalizeType(typeOrActionCreator)];
    }

    return reducer;
  }

  function options(newOpts) {
    Object.keys(newOpts).forEach(function (name) {
      return opts[name] = newOpts[name];
    });
    return reducer;
  }

  if (typeof handlers === 'function') {
    var factory = handlers;
    handlers = {};
    factory(on, off);
  }

  if (!has(_batch["default"])) {
    on(_batch["default"], function (state, payload) {
      if (opts.payload) {
        return payload.reduce(reduce, state);
      } else {
        return payload.payload.reduce(reduce, state);
      }
    });
  }

  function reduce() {
    var state = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : defaultState;
    var action = arguments.length > 1 ? arguments[1] : undefined;

    if (!action || typeof action.type !== 'string') {
      return state;
    }

    if (action.type.startsWith('@@redux/')) {
      return state;
    }

    var handler = handlers[action.type] || opts.fallback;

    if (handler) {
      if (opts.payload) {
        return handler(state, action.payload, action.meta);
      } else {
        return handler(state, action);
      }
    }

    return state;
  }

  ;
  return reducer;
}

;
},{"./batch":3}],7:[function(require,module,exports){
"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports["default"] = disbatch;

var _batch = _interopRequireDefault(require("./batch"));

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

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

function disbatch(store) {
  for (var _len = arguments.length, actions = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
    actions[_key - 1] = arguments[_key];
  }

  if (actions && actions.length > 0) {
    if (!store || typeof store !== 'function' && typeof store.dispatch !== 'function') {
      throw new TypeError('disbatch must take either a valid Redux store or a dispatch function as first parameter');
    }

    if (typeof store.dispatch === 'function') {
      store = store.dispatch;
    } // store is actually the dispatch function here


    return store(_batch["default"].apply(void 0, actions));
  } else {
    if (!store || typeof store.dispatch !== 'function') {
      throw new TypeError('disbatch must take a valid Redux store with a dispatch function as first parameter');
    }

    return _extends(store, {
      disbatch: disbatch.bind(undefined, store)
    });
  }
}
},{"./batch":3}],8:[function(require,module,exports){
"use strict";

function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }

Object.defineProperty(exports, "__esModule", {
  value: true
});
Object.defineProperty(exports, "createAction", {
  enumerable: true,
  get: function get() {
    return _createAction["default"];
  }
});
Object.defineProperty(exports, "createReducer", {
  enumerable: true,
  get: function get() {
    return _createReducer["default"];
  }
});
Object.defineProperty(exports, "assignAll", {
  enumerable: true,
  get: function get() {
    return _assignAll["default"];
  }
});
Object.defineProperty(exports, "bindAll", {
  enumerable: true,
  get: function get() {
    return _bindAll["default"];
  }
});
Object.defineProperty(exports, "batch", {
  enumerable: true,
  get: function get() {
    return _batch["default"];
  }
});
Object.defineProperty(exports, "disbatch", {
  enumerable: true,
  get: function get() {
    return _disbatch["default"];
  }
});
Object.defineProperty(exports, "loggers", {
  enumerable: true,
  get: function get() {
    return _loggers["default"];
  }
});
Object.defineProperty(exports, "asError", {
  enumerable: true,
  get: function get() {
    return _asError["default"];
  }
});
exports.types = void 0;

var _types = _interopRequireWildcard(require("./types"));

var _createAction = _interopRequireDefault(require("./createAction"));

var _createReducer = _interopRequireDefault(require("./createReducer"));

var _assignAll = _interopRequireDefault(require("./assignAll"));

var _bindAll = _interopRequireDefault(require("./bindAll"));

var _batch = _interopRequireDefault(require("./batch"));

var _disbatch = _interopRequireDefault(require("./disbatch"));

var _loggers = _interopRequireDefault(require("./loggers"));

var _asError = _interopRequireDefault(require("./asError"));

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

function _getRequireWildcardCache() { if (typeof WeakMap !== "function") return null; var cache = new WeakMap(); _getRequireWildcardCache = function _getRequireWildcardCache() { return cache; }; return cache; }

function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } if (obj === null || _typeof(obj) !== "object" && typeof obj !== "function") { return { "default": obj }; } var cache = _getRequireWildcardCache(); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj["default"] = obj; if (cache) { cache.set(obj, newObj); } return newObj; }

var types = _types;
exports.types = types;
},{"./asError":1,"./assignAll":2,"./batch":3,"./bindAll":4,"./createAction":5,"./createReducer":6,"./disbatch":7,"./loggers":9,"./types":11}],9:[function(require,module,exports){
"use strict";

function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports["default"] = void 0;

var reduxLogger = _interopRequireWildcard(require("./reduxLogger"));

function _getRequireWildcardCache() { if (typeof WeakMap !== "function") return null; var cache = new WeakMap(); _getRequireWildcardCache = function _getRequireWildcardCache() { return cache; }; return cache; }

function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } if (obj === null || _typeof(obj) !== "object" && typeof obj !== "function") { return { "default": obj }; } var cache = _getRequireWildcardCache(); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj["default"] = obj; if (cache) { cache.set(obj, newObj); } return newObj; }

var _default = {
  reduxLogger: reduxLogger
};
exports["default"] = _default;
},{"./reduxLogger":10}],10:[function(require,module,exports){
"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.actionTransformer = actionTransformer;
exports.logger = void 0;

var _batch = _interopRequireDefault(require("../batch"));

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

var batchType = _batch["default"].getType();

function actionTransformer(action) {
  if (action && action.type === batchType) {
    action.payload.type = batchType;
    return action.payload;
  }

  return action;
}

var logger = {};
exports.logger = logger;

var _loop = function _loop(level) {
  if (typeof console[level] === 'function') {
    logger[level] = function levelFn() {
      for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
        args[_key] = arguments[_key];
      }

      var lastArg = args.pop();

      if (Array.isArray(lastArg) && lastArg.type === batchType) {
        lastArg.forEach(function (action) {
          console[level].apply(console, [].concat(args, [action]));
        });
      } else {
        args.push(lastArg);
        console[level].apply(console, args);
      }
    };
  }
};

for (var level in console) {
  _loop(level);
}
},{"../batch":3}],11:[function(require,module,exports){
"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.add = add;
exports.remove = remove;
exports.has = has;
exports.check = check;
exports.all = all;
exports.clear = clear;
exports.enableChecking = enableChecking;
exports.disableChecking = disableChecking;
var types = {};
var config = {
  checkExisting: true
};

function add(name) {
  types[name] = true;
}

function remove(name) {
  types[name] = false;
}

function has(name) {
  return !!types[name];
}

function check(name) {
  if (config.checkExisting && has(name)) {
    throw new TypeError("Duplicate action type: ".concat(name));
  }
}

function all() {
  return Object.keys(types).filter(has);
}

function clear() {
  all().forEach(remove);
}

function enableChecking() {
  config.checkExisting = true;
}

function disableChecking() {
  config.checkExisting = false;
}
},{}]},{},[8])(8)
});