fluorine-orchestra/lib/util/createReducerForStore.js

A data orchestration layer for Fluorine

'use strict';

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

var _keys = require('babel-runtime/core-js/object/keys');

var _keys2 = _interopRequireDefault(_keys);

exports.default = createReducerForStore;

var _invariant = require('invariant');

var _invariant2 = _interopRequireDefault(_invariant);

var _Store = require('../Store');

var _toMap = require('./toMap');

var _toMap2 = _interopRequireDefault(_toMap);

var _immutable = require('immutable');

var _StoreConstants = require('../constants/StoreConstants');

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

function createReducerForStore(store) {
  (0, _invariant2.default)(store && _Store.Store.isStore(store), 'Reducer: `store` is expected to be an Orchestra.Store.');

  var identifier = store.getIdentifier();
  var pre = store.getPre();
  var initial = store.createCollection();

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

    if (identifier !== action.identifier) {
      return state;
    }

    var type = action.type;
    var payload = action.payload;
    var groupId = action.groupId;
    var selector = action.selector;

    function _ref(x) {
      var item = pre(selector(x));
      return item ? item : x;
    }

    switch (type) {
      case _StoreConstants.STORE_INSERT:
        {
          var _ret = function () {
            if (_immutable.Map.isMap(payload)) {
              var item = pre(payload);
              if (!item) {
                return {
                  v: state
                };
              }

              var id = item.get('id');
              var _res = state.set(id, item);

              return {
                v: groupId ? _res.addIdToGroup(groupId, id) : _res
              };
            }

            // Deduping the incoming data by ids, since Immutable has a bug where keys
            // have to be unique while using mutable data.
            var track = {};

            var res = state.asMutable();

            payload.forEach(function (value) {
              var item = pre(value);
              if (!item) {
                return state;
              }

              var id = item.get('id');
              if (!track[id]) {
                track[id] = true;
                res.set(id, item);
              }
            });

            res = res.asImmutable();

            return {
              v: groupId ? res.addIdsToGroup(groupId, new _immutable.Set((0, _keys2.default)(track))) : res
            };
          }();

          if (typeof _ret === "object") return _ret.v;
        }

      case _StoreConstants.STORE_REMOVE:
        {
          if (!payload) {
            return state;
          } else if (_immutable.Map.isMap(payload)) {
            var id = payload.get('id');
            return state.delete(id);
          }

          return state.delete(payload);
        }

      case _StoreConstants.STORE_FILTER:
        {
          if (typeof selector !== 'function') {
            return state;
          }

          return state.filter(selector);
        }

      case _StoreConstants.STORE_UPDATE:
        {
          if (typeof selector !== 'function') {
            return state;
          }

          return state.map(_ref);
        }

      default:
        return state;
    }
  };
}