redux-signal/lib/selectors.js

A scalable solution for modals using React and Redux

'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.getModalByEventQueueId = exports.getModalEvents = exports.getSignal = exports.getHasVisibleModal = exports.getModal = undefined;

var _slicedToArray = function () { function sliceIterator(arr, i) { var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"]) _i["return"](); } finally { if (_d) throw _e; } } return _arr; } return function (arr, i) { if (Array.isArray(arr)) { return arr; } else if (Symbol.iterator in Object(arr)) { return sliceIterator(arr, i); } else { throw new TypeError("Invalid attempt to destructure non-iterable instance"); } }; }();

var _reselect = require('reselect');

var _lruMemoize = require('lru-memoize');

var _lruMemoize2 = _interopRequireDefault(_lruMemoize);

var _ModalStates = require('./constants/ModalStates');

var ModalStates = _interopRequireWildcard(_ModalStates);

function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } }

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

// TODO: make this configurable? 8 seems to be a reasonable default
var customSelectorCreator = (0, _reselect.createSelectorCreator)(function (s, n) {
  return (0, _lruMemoize2.default)(n)(s);
}, 8);

var getModal = exports.getModal = customSelectorCreator(function (instanceId) {
  return instanceId;
}, function (instanceId) {
  return (0, _reselect.createSelector)(function (state) {
    return state.signal.get('modals');
  }, function (modals) {
    var modalState = modals.get(instanceId);

    if (!modalState) {
      return {
        data: null,
        isBusy: false,
        isFirst: false,
        isVisible: false,
        state: null
      };
    }

    var firstVisibleModal = null;
    var _iteratorNormalCompletion = true;
    var _didIteratorError = false;
    var _iteratorError = undefined;

    try {
      for (var _iterator = modals.entries()[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
        var _step$value = _slicedToArray(_step.value, 2),
            key = _step$value[0],
            value = _step$value[1];

        if (value.get('state') === ModalStates.VISIBLE) {
          firstVisibleModal = key;
          break;
        }
      }
    } catch (err) {
      _didIteratorError = true;
      _iteratorError = err;
    } finally {
      try {
        if (!_iteratorNormalCompletion && _iterator.return) {
          _iterator.return();
        }
      } finally {
        if (_didIteratorError) {
          throw _iteratorError;
        }
      }
    }

    return {
      instanceId: instanceId,
      data: modalState.get('data'),
      isBusy: modalState.get('isBusy'),
      isFirst: firstVisibleModal === instanceId,
      isVisible: modalState.get('state') === ModalStates.VISIBLE,
      state: modalState.get('state')
    };
  });
});

var getHasVisibleModal = exports.getHasVisibleModal = (0, _reselect.createSelector)(function (state) {
  return state.signal.get('modals');
}, function (modals) {
  var _iteratorNormalCompletion2 = true;
  var _didIteratorError2 = false;
  var _iteratorError2 = undefined;

  try {
    for (var _iterator2 = modals.valueSeq()[Symbol.iterator](), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true) {
      var value = _step2.value;

      if (value.get('state') === ModalStates.VISIBLE) {
        return true;
      }
    }
  } catch (err) {
    _didIteratorError2 = true;
    _iteratorError2 = err;
  } finally {
    try {
      if (!_iteratorNormalCompletion2 && _iterator2.return) {
        _iterator2.return();
      }
    } finally {
      if (_didIteratorError2) {
        throw _iteratorError2;
      }
    }
  }

  return false;
});

var getSignal = exports.getSignal = (0, _reselect.createSelector)(function (state) {
  return state.signal.get('signal');
}, function (signal) {
  return signal.get('order').map(function (id) {
    return signal.getIn(['data', id]);
  });
});

var getModalEvents = exports.getModalEvents = (0, _reselect.createSelector)(function (eventQueueId) {
  return eventQueueId;
}, function (eventQueueId) {
  return (0, _reselect.createSelector)(function (state) {
    return state.signal.getIn(['signal', 'eventQueue']);
  }, function (eventQueue) {
    return eventQueue.get(eventQueueId);
  });
});

var getModalByEventQueueId = exports.getModalByEventQueueId = (0, _reselect.createSelector)(function (eventQueueId) {
  return eventQueueId;
}, function (eventQueueId) {
  return (0, _reselect.createSelector)(function (state) {
    return state.signal.getIn(['signal', 'data']);
  }, function (data) {
    if (!data) {
      return null;
    }

    var _iteratorNormalCompletion3 = true;
    var _didIteratorError3 = false;
    var _iteratorError3 = undefined;

    try {
      for (var _iterator3 = data.valueSeq()[Symbol.iterator](), _step3; !(_iteratorNormalCompletion3 = (_step3 = _iterator3.next()).done); _iteratorNormalCompletion3 = true) {
        var value = _step3.value;

        if (value.get('eventHandlerId') === eventQueueId) {
          return value;
        }
      }
    } catch (err) {
      _didIteratorError3 = true;
      _iteratorError3 = err;
    } finally {
      try {
        if (!_iteratorNormalCompletion3 && _iterator3.return) {
          _iterator3.return();
        }
      } finally {
        if (_didIteratorError3) {
          throw _iteratorError3;
        }
      }
    }

    return null;
  });
});