virtex-local/lib/index.js

'use strict';

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

var _reduxEphemeral = require('redux-ephemeral');

var _reduxEphemeral2 = _interopRequireDefault(_reduxEphemeral);

var _objectEqual = require('@f/object-equal');

var _objectEqual2 = _interopRequireDefault(_objectEqual);

var _arrayEqual = require('@f/array-equal');

var _arrayEqual2 = _interopRequireDefault(_arrayEqual);

var _getProp = require('@f/get-prop');

var _getProp2 = _interopRequireDefault(_getProp);

var _virtex = require('virtex');

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

/**
 * Constants
 */

var _actions$types = _virtex.actions.types; /**
                                             * Imports
                                             */

var CREATE_THUNK = _actions$types.CREATE_THUNK;
var UPDATE_THUNK = _actions$types.UPDATE_THUNK;
var DESTROY_THUNK = _actions$types.DESTROY_THUNK;

/**
 * Provide local state to virtex components
 */

function local(prop) {
  var dirty = arguments.length <= 1 || arguments[1] === undefined ? {} : arguments[1];

  return function (_ref) {
    var getState = _ref.getState;
    var dispatch = _ref.dispatch;

    var state = function state() {
      return (0, _getProp2.default)(prop, getState());
    };

    return function (next) {
      return function (action) {
        switch (action.type) {
          case CREATE_THUNK:
            delete dirty[action.vnode.path];
            create(state, dispatch, action.vnode);
            break;
          case UPDATE_THUNK:
            // Prevent the clearing of dirtiness
            // / updating of state if we're just
            // rendering a cached node
            if (!action.vnode.vnode) {
              delete dirty[action.vnode.path];
              update(state, action.vnode, action.prev);
            }
            break;
          case DESTROY_THUNK:
            delete dirty[action.vnode.path];
            destroy(dispatch, action.vnode);
            break;
        }

        if ((0, _reduxEphemeral.isEphemeral)(action)) {
          var prevState = getState();
          var result = next(action);
          var nextState = getState();

          if (prevState !== nextState) {
            dirty[action.meta.ephemeral.key] = true;
          }

          return result;
        }

        return next(action);
      };
    };
  };
}

function create(getState, dispatch, thunk) {
  var component = thunk.type;
  var _component$initialSta = component.initialState;
  var initialState = _component$initialSta === undefined ? function () {
    return {};
  } : _component$initialSta;


  var priorState = (0, _reduxEphemeral.lookup)(getState(), thunk.path);
  prepare(thunk, priorState || initialState);

  // If a component does not have a reducer, it does not
  // get any local state
  if (component.reducer && !priorState) {
    dispatch((0, _reduxEphemeral.createEphemeral)(thunk.path, thunk.state));
  }
}

function update(getState, thunk, prev) {
  prepare(thunk, (0, _reduxEphemeral.lookup)(getState(), thunk.path));
}

function destroy(dispatch, thunk) {
  thunk.type.reducer && dispatch((0, _reduxEphemeral.destroyEphemeral)(thunk.path));
}

function shouldUpdate(prev, next) {
  return prev.state !== next.state || !(0, _arrayEqual2.default)(prev.children, next.children) || !(0, _objectEqual2.default)(prev.props, next.props);
}

function prepare(thunk, state) {
  thunk.type.shouldUpdate = thunk.type.shouldUpdate || shouldUpdate;
  thunk.local = function (fn) {
    for (var _len = arguments.length, outerArgs = Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
      outerArgs[_key - 1] = arguments[_key];
    }

    if (typeof fn !== 'function') throw new Error('virtex-local: non-function passed to `local()`. Did you pass the wrong handler?');
    return function () {
      for (var _len2 = arguments.length, innerArgs = Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
        innerArgs[_key2] = arguments[_key2];
      }

      return (0, _reduxEphemeral.toEphemeral)(thunk.path, thunk.type.reducer, fn.apply(thunk, outerArgs.concat(innerArgs)));
    };
  };

  thunk.state = typeof state === 'function' ? state(thunk) : state;
}

/**
 * Exports
 */

exports.default = local;
exports.mount = _reduxEphemeral2.default;