@graffy/common/graph/sieve.js

Common libraries that used by various Graffy modules.

"use strict";

var _interopRequireDefault = require("@babel/runtime-corejs3/helpers/interopRequireDefault");

exports.__esModule = true;
exports["default"] = sieve;
exports.insertRange = insertRange;
exports.insertNode = insertNode;

var _extends2 = _interopRequireDefault(require("@babel/runtime-corejs3/helpers/extends"));

var _filter = _interopRequireDefault(require("@babel/runtime-corejs3/core-js-stable/instance/filter"));

var _concat = _interopRequireDefault(require("@babel/runtime-corejs3/core-js-stable/instance/concat"));

var _splice = _interopRequireDefault(require("@babel/runtime-corejs3/core-js-stable/instance/splice"));

var _getIterator2 = _interopRequireDefault(require("@babel/runtime-corejs3/core-js/get-iterator"));

var _isArray2 = _interopRequireDefault(require("@babel/runtime-corejs3/core-js-stable/array/is-array"));

var _node = require("../node");

var _step = require("./step");

function sieve(current, changes, result) {
  if (result === void 0) {
    result = [];
  }

  var index = 0;

  for (var _iterator = changes, _isArray = (0, _isArray2["default"])(_iterator), _i = 0, _iterator = _isArray ? _iterator : (0, _getIterator2["default"])(_iterator);;) {
    var _ref;

    if (_isArray) {
      if (_i >= _iterator.length) break;
      _ref = _iterator[_i++];
    } else {
      _i = _iterator.next();
      if (_i.done) break;
      _ref = _i.value;
    }

    var change = _ref;
    index = (0, _node.isRange)(change) ? insertRange(current, change, result, index) : insertNode(current, change, result, index);
  }

  return result;
}

function insertRange(current, change, result, start) {
  var _spliceInstanceProper, _context;

  if (start === void 0) {
    start = 0;
  }

  var key = change.key,
      end = change.end;
  var keyIx = (0, _node.getIndex)(current, key, start);
  var endIx = (0, _node.getLastIndex)(current, end, keyIx);

  if (keyIx === endIx && !(current[keyIx] && current[keyIx].key <= key && current[keyIx].end >= end)) {
    // This range does not overlap with any existing data. Ignore it.
    return keyIx;
  } // TODO: Extract the parts of result that are relevant.


  result.push(change); // If current contains nodes that are newer than this range, keep them.
  // We do this by merging them back into insertions first.

  var insertions = [change];

  for (var i = keyIx; i < endIx; i++) {
    var node = current[i];

    if ((0, _node.isRange)(node)) {
      insertions.push.apply(insertions, mergeRanges(insertions.pop(), node));
    } else {
      insertNode(insertions, node, [], insertions.length - 1);
    }
  }

  (_spliceInstanceProper = (0, _splice["default"])(current)).call.apply(_spliceInstanceProper, (0, _concat["default"])(_context = [current, keyIx, endIx - keyIx]).call(_context, insertions));

  return keyIx + insertions.length;
}

function mergeRanges(base, node) {
  var _context2;

  // assertVersion(node, base.version);
  // eslint-disable-next-line no-param-reassign
  if (node.version < base.version) {
    var _ref2 = [base, node];
    node = _ref2[0];
    base = _ref2[1];
  } // Ensure node is newer than base


  return (0, _filter["default"])(_context2 = [base.key < node.key && (0, _extends2["default"])({}, base, {
    end: (0, _step.keyBefore)(node.key)
  }), node, base.end > node.end && (0, _extends2["default"])({}, base, {
    key: (0, _step.keyAfter)(node.end)
  })]).call(_context2, Boolean);
}

function insertNode(current, change, result, start) {
  if (start === void 0) {
    start = 0;
  }

  var key = change.key;
  var index = (0, _node.getIndex)(current, key, start);
  var node = current[index];

  if (node && node.key <= key) {
    // This change overlaps with something that exists.
    return (0, _node.isRange)(node) ? insertNodeIntoRange(current, index, change, result) : updateNode(current, index, change, result);
  } else {
    // This change does not overlap with any existing knowledge. Skip it
    // current.splice(index, 0, change);
    return index;
  }
}

function insertNodeIntoRange(current, index, change, result) {
  var _context3, _spliceInstanceProper2, _context4;

  var key = change.key;
  var range = current[index];
  var newChange = getNewer(change, range);
  if (!newChange) return;
  result.push(newChange);
  var insertions = (0, _filter["default"])(_context3 = [range.key < key && (0, _extends2["default"])({}, range, {
    end: (0, _step.keyBefore)(key)
  }), newChange, range.end > key && (0, _extends2["default"])({}, range, {
    key: (0, _step.keyAfter)(key)
  })]).call(_context3, Boolean);

  (_spliceInstanceProper2 = (0, _splice["default"])(current)).call.apply(_spliceInstanceProper2, (0, _concat["default"])(_context4 = [current, index, 1]).call(_context4, insertions));

  return index + insertions.length;
}

function updateNode(current, index, change, result) {
  var node = current[index];

  if ((0, _node.isBranch)(change) && (0, _node.isBranch)(node)) {
    // Both are branches: Recursively merge children.
    var nextResult = [];
    node.version = change.version;
    sieve(node.children, change.children, nextResult);
    if (nextResult.length) result.push((0, _extends2["default"])({}, change, {
      children: nextResult
    }));
  } else if ((0, _node.isBranch)(node)) {
    // Current node is a branch but the change is a leaf; if the branch
    // has newer children, ignore the change and keep only those children;
    // Otherwise, discard the branch and keep the change.
    var newNode = getNewer(node, change);
    current[index] = newNode || change;
    if (!newNode) result.push(change); // TODO: In the case of partial removal, what should result be?
  } else {
    // Current node is a leaf. Replace with the change if it is newer.
    var newChange = getNewer(change, node);

    if (newChange) {
      current[index] = newChange; // console.log(current);

      if (change.value !== node.value || change.path !== node.path) {
        result.push(newChange);
      }
    }
  }

  return index + 1;
}

function getNewer(node, base) {
  if ((0, _node.isBranch)(node)) {
    var _context5;

    var children = (0, _filter["default"])(_context5 = node.children).call(_context5, function (child) {
      return getNewer(child, base);
    });
    return children.length && (0, _extends2["default"])({}, node, {
      children: children
    });
  } else {
    // assertVersion(node, version);
    return node.version >= base.version ? node : null;
  }
} // function assertVersion(node, version) {
//   // if (node.version === version) {
//   //   throw Error('merge.version_collision ' + [node.key, version].join(' '));
//   // }
// }