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(dispatch, action.vnode);
            break;
          case UPDATE_THUNK:
            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)) {
          dirty[action.meta.ephemeral.key] = true;
        }

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

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


  prepare(thunk, initialState(thunk));

  // If a component does not have a reducer, it does not
  // get any local state
  if (component.reducer) {
    component.shouldUpdate = component.shouldUpdate || shouldUpdate;
    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.state = state;
  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];
    }

    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)));
    };
  };
}

/**
 * Exports
 */

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