action-store/lib/store.js

Action store a la redux

'use strict';

/**
 * Module dependencies
 */

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

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

var _redux = require('redux');

var _engine = require('./engine');

var _engine2 = _interopRequireDefault(_engine);

var _eventemitter = require('eventemitter3');

var _eventemitter2 = _interopRequireDefault(_eventemitter);

var _resolve = require('./resolve');

var _resolve2 = _interopRequireDefault(_resolve);

var _freeze = require('./freeze');

var _freeze2 = _interopRequireDefault(_freeze);

var _update = require('./update');

var _update2 = _interopRequireDefault(_update);

var _isobj = require('isobj');

var _isobj2 = _interopRequireDefault(_isobj);

var _lodash = require('lodash');

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

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 _toConsumableArray(arr) { if (Array.isArray(arr)) { for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) { arr2[i] = arr[i]; } return arr2; } else { return Array.from(arr); } }

/**
 * Module constants.
 */

var isArray = Array.isArray;

/**
 * Initialize `ActionStore`
 *
 * @param {Function} root reducer
 * @param {Array} middlewares
 * @param {Object} options
 * @return {Object} action-store
 */

exports.default = function (reduce, initialState, middlewares, options) {

  var engine = (0, _engine2.default)();
  var emitter = new _eventemitter2.default();
  var emit = function emit() {
    return emitter.emit.apply(emitter, arguments);
  };

  if ('function' === typeof initialState) {
    options = middlewares;
    middlewares = [initialState];
    initialState = undefined;
  }

  if (isArray(initialState) && 'function' === typeof initialState[0]) {
    options = middlewares;
    middlewares = initialState;
    initialState = undefined;
  }

  if ((0, _isobj2.default)(middlewares)) {
    options = middlewares;
    middlewares = undefined;
  }

  options = options || {};
  reduce = reduce || identity;
  middlewares = middlewares || [];
  options = _extends({ engine: engine }, options, { dispatch: dispatch, emit: emit });
  middlewares = [(0, _resolve2.default)(options)].concat(_toConsumableArray(middlewares));

  // create our redux client
  var store = (0, _redux.createStore)(reducer, {}, _redux.applyMiddleware.apply(undefined, _toConsumableArray(middlewares)));

  /**
   * Custom reducer for applying updates.
   *
   * @param {Mixed} state
   * @param {Object} action
   * @return {Mixed} state
   * @api private
   */

  function reducer(state, action) {
    var _ref = action.payload || {};

    var id = _ref.id;

    if (!id) return state;
    var currentState = state[id] || initialState;
    var newState = (0, _update2.default)(currentState, reduce(currentState, action));
    return null !== newState ? _extends({}, state, _defineProperty({}, id, newState)) : (0, _lodash.omit)(state, id);
  }

  /**
   * Dispatch actions to store.
   *
   * @param {Mixed} action
   * @return {Object} action
   * @api public
   */

  function dispatch() {
    for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) {
      args[_key] = arguments[_key];
    }

    var actions = isArray(this) ? [].concat(_toConsumableArray(this)) : args;
    return store.dispatch(actions);
  }

  /**
   * Get the current state.
   *
   * @param {String} id
   * @return {Mixed}
   * @api public
   */

  function getState(id) {
    var state = store.getState();
    return (0, _freeze2.default)(id ? state[id] : state);
  }

  /**
   * Subscribe to state changes.
   *
   * @param {String} type
   * @param {Function} fn
   * @return {Object}
   * @api public
   */

  function subscribe(type, fn) {
    if ('function' === typeof type) {
      fn = type;
      type = 'event';
    }
    emitter.on(type, fn);
    return function () {
      return emitter.off(type, fn);
    };
  }

  // return api public methods.
  return { dispatch: dispatch, getState: getState, subscribe: subscribe };
};

/**
 * Identity function that
 * just builds on an action's payload
 *
 * @param {Mixed} state
 * @param {Object} action
 * @return {Mixed} payload
 * @api private
 */

function identity(state, action) {
  return action.payload;
}