redux-reorder/lib/reducer.js

Higher-order reducer that tracks order fluctuation within iterable state

'use strict';

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

var _typeof2 = require('babel-runtime/helpers/typeof');

var _typeof3 = _interopRequireDefault(_typeof2);

var _from = require('babel-runtime/core-js/array/from');

var _from2 = _interopRequireDefault(_from);

exports.default = grokReorders;

var _isEqual = require('lodash/isEqual');

var _isEqual2 = _interopRequireDefault(_isEqual);

var _iterall = require('iterall');

var _actions = require('./actions');

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

// @TODO: create a better abstraction / heuristic than `step`?
function grokReorders(reducer) {
  var _ref = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {},
      _ref$step = _ref.step,
      step = _ref$step === undefined ? 1 : _ref$step,
      reorderType = _ref.reorderType;

  var initialState = {
    iterable: reducer(undefined, {}),
    fluctuationMap: []
  };
  var calls = 0;
  var fluctuationMap = [];
  var prevIterableAsArray = (0, _from2.default)(initialState.iterable);
  return function () {
    var state = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : initialState;
    var action = arguments[1];

    var nextIterable = reducer(state.iterable, action);
    if (!(0, _iterall.isIterable)(nextIterable)) {
      throw new TypeError('grokReorders expects a reducer that returns iterable state.\n        Instead got ' + (typeof nextIterable === 'undefined' ? 'undefined' : (0, _typeof3.default)(nextIterable)) + '.');
    }
    var nextIterableAsArray = (0, _from2.default)(nextIterable);
    switch (action.type) {
      case _actions.INITIALIZE_REORDERS:
        calls = 0;
        return { iterable: nextIterable, fluctuationMap: [] };
      case reorderType:
        // If enough fluctuation has 'accumulated', represent this fluctuation
        // and store the new iterable state.
        // @TODO: prove you will never need >= here
        if (++calls === step) {
          fluctuationMap = nextIterableAsArray.map(function (x, i) {
            var prevIndex = prevIterableAsArray.findIndex(function (y) {
              return (0, _isEqual2.default)(y, x);
            });
            return prevIndex !== -1 ? prevIndex - i : 0;
          });
          calls = 0;
          prevIterableAsArray = nextIterableAsArray;
        }
        return { iterable: nextIterable, fluctuationMap: fluctuationMap };
      default:
        return state;
    }
  };
}