virtex/lib/update.js

Small, focused virtual dom library.

'use strict';

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

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

var _util = require('./util');

var _dift = require('dift');

var _dift2 = _interopRequireDefault(_dift);

var _foreach = require('@f/foreach');

var _foreach2 = _interopRequireDefault(_foreach);

var _create2 = require('./create');

var _create3 = _interopRequireDefault(_create2);

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

function update(effect) {
  var create = (0, _create3.default)(effect);
  return function (prev, next) {
    var path = arguments.length <= 2 || arguments[2] === undefined ? 'a' : arguments[2];
    return updateRecursive(prev, next, path);
  };

  function updateRecursive(prev, next, path) {
    next.path = path;

    if (!(0, _util.isSameNode)(prev, next)) {
      unrenderThunks(prev);

      while ((0, _util.isThunk)(prev)) {
        prev = effect((0, _actions.updateThunk)(prev));
      }

      next = create(next, path);
      effect((0, _actions.replaceNode)(next, prev));
    } else if ((0, _util.isThunk)(next)) {
      next = effect((0, _actions.updateThunk)(next, prev));
      prev = effect((0, _actions.updateThunk)(prev));

      if (!next) {
        throw new Error('Component returned null/undefined. Components must return valid virtual nodes.');
      }

      return updateRecursive(prev, next, (0, _util.createPath)(next, path, 0));
    } else if (prev !== next) {
      (function () {

        var children = new Array(next.children.length);
        (0, _dift2.default)(prev.children, next.children, function (type, pItem, nItem, pos) {
          switch (type) {
            case _dift.UPDATE:
              children[pos] = updateRecursive(pItem, nItem, (0, _util.createPath)(nItem, path, pos));
              return;
            case _dift.CREATE:
              children[pos] = create(nItem, (0, _util.createPath)(nItem, path, pos));
              return effect((0, _actions.insertNode)(prev, children[pos], pos));
            case _dift.MOVE:
              children[pos] = updateRecursive(pItem, nItem, (0, _util.createPath)(nItem, path, pos));
              return effect((0, _actions.insertNode)(prev, children[pos], pos));
            case _dift.REMOVE:
              return effect((0, _actions.removeNode)(unrenderThunks(pItem)));
          }
        }, _util.getKey);

        effect((0, _actions.updateNode)(next, prev, children));
      })();
    }

    return next;
  }

  function unrenderThunks(vnode) {
    if ((0, _util.isThunk)(vnode)) {
      var child = unrenderThunks(effect((0, _actions.updateThunk)(vnode)));
      effect((0, _actions.destroyThunk)(vnode));
      return child;
    } else {
      (0, _foreach2.default)(unrenderThunks, vnode.children);
      return vnode;
    }
  }
}

exports.default = update;