bdn-pocket/es/selector/selector.js

pocket tools for managing redux and redux-saga

'use strict';

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

var _it = require('@stamp/it');

var _it2 = _interopRequireDefault(_it);

var _equals = require('ramda/src/equals');

var _equals2 = _interopRequireDefault(_equals);

var _pathOr = require('ramda/src/pathOr');

var _pathOr2 = _interopRequireDefault(_pathOr);

var _propOr = require('ramda/src/propOr');

var _propOr2 = _interopRequireDefault(_propOr);

var _make_req_messenger = require('../messenger/make_req_messenger');

var _make_req_messenger2 = _interopRequireDefault(_make_req_messenger);

var _selector_def = require('./selector_def');

var _selector_def2 = _interopRequireDefault(_selector_def);

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

var Selector = (0, _it2.default)(_selector_def2.default).methods({
  getPag: function getPag(pags, id) {
    var defaultState = _make_req_messenger2.default.compose.deepProperties.defaultState;

    if (pags === undefined) {
      throw new Error('\n          pags parameter is undefined -\n          expected an object indexed by id\n          ');
    }
    var getter = Array.isArray(id) ? _pathOr2.default : _propOr2.default;
    return getter(defaultState, id, pags);
  }
}).init(function (_ref, _ref2) {
  var reducer = _ref.reducer;
  var stamp = _ref2.stamp,
      instance = _ref2.instance;
  var PropTypes = stamp.compose.staticProperties.PropTypes;
  var getSubState = instance.getSubState;

  var isPropsCacheValid = (0, _selector_def.makeIsCacheValid)(_equals2.default);
  var boundReducer = reducer.bind(instance);
  var isSubStateCacheValid = (0, _selector_def.makeIsCacheValid)(function (r, l) {
    return r === l;
  });
  var lastResult = void 0;
  var lastPartialReducer = void 0;

  /**
   * propsReducer generate a partial reducer function
   * that is memoized (lastPartialReducer)
   * if props is sent, propsReducer execute the partial reducer
   * else it return the partial reducer
   */
  return function propsReducer(state, props) {
    var subStates = getSubState(state);
    // memoize partial reducer
    // this partial reducer will be reused in next call if args remains equal
    if (!isSubStateCacheValid(subStates)) {
      // invalidate props cache to ensure reducer to run next time
      isPropsCacheValid(undefined);
      lastPartialReducer = function lastPartialReducer() {
        var props = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};

        PropTypes(props);
        if (!isPropsCacheValid(props)) {
          lastResult = boundReducer(subStates, props, { instance: instance });
        }
        return lastResult;
      };
    }

    return props === undefined ? lastPartialReducer : lastPartialReducer(props);
  };
});

exports.default = Selector;