slate 0.47.4 → 0.47.8

package/lib/slate.js

@@ -615,7 +615,7 @@ function transform(path, operation) {
       p = operation.path;
 
 
-  if (type === 'add_mark' || type === 'insert_text' || type === 'remove_mark' || type === 'remove_text' || type === 'set_mark' || type === 'set_node' || type === 'set_selection' || type === 'set_value' || path.size === 0) {
+  if (type === 'add_mark' || type === 'insert_text' || type === 'remove_mark' || type === 'remove_text' || type === 'set_mark' || type === 'set_node' || type === 'set_selection' || type === 'set_value' || type === 'add_annotation' || type === 'remove_annotation' || type === 'set_annotation' || path.size === 0) {
     return immutable.List([path]);
   }
 
@@ -2763,7 +2763,7 @@ var Text = function (_Record) {
                 }
 
                 // If the range starts after the leaf, or ends before it, continue.
-                if (start.offset > offset + length || end.offset <= offset) {
+                if (start.offset > offset + length || end.offset < offset || end.offset === offset && offset !== 0) {
                   next.push(leaf);
                   continue;
                 }
@@ -3479,10 +3479,14 @@ var Value = function (_Record) {
       annotation = Annotation.create(annotation);
       var value = this;
       var _value = value,
-          annotations = _value.annotations;
+          annotations = _value.annotations,
+          document = _value.document;
       var _annotation = annotation,
           key = _annotation.key;
 
+      annotation = annotation.updatePoints(function (point) {
+        return point.normalize(document);
+      });
       annotations = annotations.set(key, annotation);
       value = value.set('annotations', annotations);
       return value;
@@ -3715,16 +3719,16 @@ var Value = function (_Record) {
 
       value = value.mapRanges(function (range) {
         var _range = range,
-            start = _range.start,
-            end = _range.end;
+            anchor = _range.anchor,
+            focus = _range.focus;
 
 
-        if (node.hasNode(start.key)) {
-          range = prev ? range.moveStartTo(prev.key, prev.text.length) : next ? range.moveStartTo(next.key, 0) : range.unset();
+        if (node.hasNode(anchor.key)) {
+          range = prev ? range.moveAnchorTo(prev.key, prev.text.length) : next ? range.moveAnchorTo(next.key, 0) : range.unset();
         }
 
-        if (node.hasNode(end.key)) {
-          range = prev ? range.moveEndTo(prev.key, prev.text.length) : next ? range.moveEndTo(next.key, 0) : range.unset();
+        if (node.hasNode(focus.key)) {
+          range = prev ? range.moveFocusTo(prev.key, prev.text.length) : next ? range.moveFocusTo(next.key, 0) : range.unset();
         }
 
         range = range.updatePoints(function (point) {
@@ -3924,18 +3928,18 @@ var Value = function (_Record) {
       value = value.mapRanges(function (range) {
         var next = newDocument.getNextText(node.key);
         var _range2 = range,
-            start = _range2.start,
-            end = _range2.end;
+            anchor = _range2.anchor,
+            focus = _range2.focus;
 
-        // If the start was after the split, move it to the next node.
+        // If the anchor was after the split, move it to the next node.
 
-        if (node.key === start.key && position <= start.offset) {
-          range = range.moveStartTo(next.key, start.offset - position);
+        if (node.key === anchor.key && position <= anchor.offset) {
+          range = range.moveAnchorTo(next.key, anchor.offset - position);
         }
 
-        // If the end was after the split, move it to the next node.
-        if (node.key === end.key && position <= end.offset) {
-          range = range.moveEndTo(next.key, end.offset - position);
+        // If the focus was after the split, move it to the next node.
+        if (node.key === focus.key && position <= focus.offset) {
+          range = range.moveFocusTo(next.key, focus.offset - position);
         }
 
         range = range.updatePoints(function (point) {
@@ -4374,7 +4378,7 @@ var Value = function (_Record) {
 
       if (isPlainObject(a)) {
         var p = {};
-        if ('annotations' in a) p.annotations = Annotation.createList(a.annotations);
+        if ('annotations' in a) p.annotations = Annotation.createMap(a.annotations);
         if ('data' in a) p.data = Data.create(a.data);
         return p;
       }
@@ -5835,7 +5839,7 @@ Commands$1.deleteBackwardAtRange = function (editor, range) {
 
   // If the focus offset is farther than the number of characters to delete,
   // just remove the characters backwards inside the current node.
-  if (n < focus.offset) {
+  if (n <= focus.offset) {
     range = range.moveFocusBackward(n);
     editor.deleteAtRange(range);
     return;
@@ -6211,7 +6215,7 @@ Commands$1.insertFragmentAtRange = function (editor, range, fragment) {
 
     // Regenerate the keys for all of the fragments nodes, so that they're
     // guaranteed not to collide with the existing keys in the document. Otherwise
-    // they will be rengerated automatically and we won't have an easy way to
+    // they will be regenerated automatically and we won't have an easy way to
     // reference them.
     fragment = fragment.mapDescendants(function (child) {
       return child.regenerateKey();
@@ -7020,6 +7024,63 @@ Commands$2.addMarksByPath = function (editor, path, offset, length, marks) {
   });
 };
 
+/**
+ * Sets specific set of marks on the path
+ * @param {Editor} editor
+ * @param {Array} path
+ * @param {Number} offset
+ * @param {Number} length
+ * @param {Array<Object|Mark>} marks
+ */
+
+Commands$2.replaceMarksByPath = function (editor, path, offset, length, marks) {
+  var marksSet = Mark.createSet(marks);
+
+  var value = editor.value;
+  var document = value.document;
+
+  var node = document.assertNode(path);
+
+  if (node.marks.equals(marksSet)) {
+    return;
+  }
+
+  editor.withoutNormalizing(function () {
+    // If it ends before the end of the node, we'll need to split to create a new
+    // text with different marks.
+    if (offset + length < node.text.length) {
+      editor.splitNodeByPath(path, offset + length);
+    }
+
+    // Same thing if it starts after the start. But in that case, we need to
+    // update our path and offset to point to the new start.
+    if (offset > 0) {
+      editor.splitNodeByPath(path, offset);
+      path = PathUtils.increment(path);
+      offset = 0;
+    }
+
+    var marksToApply = marksSet.subtract(node.marks);
+    var marksToRemove = node.marks.subtract(marksSet);
+
+    marksToRemove.forEach(function (mark) {
+      editor.applyOperation({
+        type: 'remove_mark',
+        path: path,
+        mark: Mark.create(mark)
+      });
+    });
+
+    marksToApply.forEach(function (mark) {
+      editor.applyOperation({
+        type: 'add_mark',
+        path: path,
+        mark: Mark.create(mark)
+      });
+    });
+  });
+};
+
 /**
  * Insert a `fragment` at `index` in a node by `path`.
  *
@@ -7063,7 +7124,6 @@ Commands$2.insertNodeByPath = function (editor, path, index, node) {
  */
 
 Commands$2.insertTextByPath = function (editor, path, offset, text, marks) {
-  marks = Mark.createSet(marks);
   var value = editor.value;
   var annotations = value.annotations,
       document = value.document;
@@ -7117,8 +7177,8 @@ Commands$2.insertTextByPath = function (editor, path, offset, text, marks) {
       text: text
     });
 
-    if (marks.size) {
-      editor.addMarksByPath(path, offset, text.length, marks);
+    if (marks) {
+      editor.replaceMarksByPath(path, offset, text.length, marks);
     }
   });
 };
@@ -7213,6 +7273,10 @@ Commands$2.removeMarksByPath = function (editor, path, offset, length, marks) {
 
   var node = document.assertNode(path);
 
+  if (marks.intersect(node.marks).isEmpty()) {
+    return;
+  }
+
   editor.withoutNormalizing(function () {
     // If it ends before the end of the node, we'll need to split to create a new
     // text with different marks.
@@ -7769,7 +7833,7 @@ Commands$2.wrapNodeByPath = function (editor, path, node) {
  * Mix in `*ByKey` variants.
  */
 
-var COMMANDS = ['addMark', 'insertFragment', 'insertNode', 'insertText', 'mergeNode', 'removeAllMarks', 'removeMark', 'removeNode', 'removeText', 'replaceNode', 'replaceText', 'setMark', 'setNode', 'setText', 'splitNode', 'unwrapBlock', 'unwrapChildren', 'unwrapInline', 'unwrapNode', 'wrapBlock', 'wrapInline', 'wrapNode'];
+var COMMANDS = ['addMark', 'insertFragment', 'insertNode', 'insertText', 'mergeNode', 'removeAllMarks', 'removeMark', 'removeNode', 'removeText', 'replaceMarks', 'replaceNode', 'replaceText', 'setMark', 'setNode', 'setText', 'splitNode', 'unwrapBlock', 'unwrapChildren', 'unwrapInline', 'unwrapNode', 'wrapBlock', 'wrapInline', 'wrapNode'];
 
 var _loop = function _loop(method) {
   Commands$2[method + 'ByKey'] = function (editor, key) {
@@ -7862,7 +7926,7 @@ Commands$3.save = function (editor, operation) {
       save = _editor$tmp.save,
       merge = _editor$tmp.merge;
 
-  if (save === false) return;
+  if (save === false || !isValidOperation(operation)) return;
 
   var undos = data.get('undos') || immutable.List();
   var lastBatch = undos.last();
@@ -7923,13 +7987,13 @@ Commands$3.redo = function (editor) {
       batch.forEach(function (op) {
         var _op = op,
             type = _op.type,
-            properties = _op.properties;
+            newProperties = _op.newProperties;
 
         // When the operation mutates the selection, omit its `isFocused` value to
         // prevent the editor focus from changing during redoing.
 
         if (type === 'set_selection') {
-          op = op.set('properties', omit(properties, 'isFocused'));
+          op = op.set('newProperties', omit(newProperties, 'isFocused'));
         }
 
         editor.applyOperation(op);
@@ -7967,13 +8031,13 @@ Commands$3.undo = function (editor) {
       }).forEach(function (inverse) {
         var _inverse = inverse,
             type = _inverse.type,
-            properties = _inverse.properties;
+            newProperties = _inverse.newProperties;
 
         // When the operation mutates the selection, omit its `isFocused` value to
         // prevent the editor focus from changing during undoing.
 
         if (type === 'set_selection') {
-          inverse = inverse.set('properties', omit(properties, 'isFocused'));
+          inverse = inverse.set('newProperties', omit(newProperties, 'isFocused'));
         }
 
         editor.applyOperation(inverse);
@@ -8034,6 +8098,28 @@ function shouldMerge(o, p) {
   return merge;
 }
 
+/**
+ * Check weather an operation needs to be saved to the history
+ * @param {Object} o - operation
+ * @returns {Boolean}
+ */
+
+function isValidOperation(o) {
+  if (o.type === 'set_selection') {
+    var _o$newProperties = o.newProperties,
+        isFocused = _o$newProperties.isFocused,
+        anchor = _o$newProperties.anchor,
+        focus = _o$newProperties.focus;
+
+    // this is blur/focus operation, dont need to store it into the history
+
+    if (isFocused !== undefined && !anchor && !focus) {
+      return false;
+    }
+  }
+  return true;
+}
+
 var Commands$4 = {};
 
 Commands$4.blur = function (editor) {
@@ -9065,6 +9151,20 @@ Commands$5.setAnnotation = function (editor, annotation, newProperties) {
   });
 };
 
+Commands$5.setAnnotations = function (editor) {
+  var annotations = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [];
+  var value = editor.value;
+
+  var newProperties = Value.createProperties({ annotations: annotations });
+  var prevProperties = pick(value, Object.keys(newProperties));
+
+  editor.applyOperation({
+    type: 'set_value',
+    properties: prevProperties,
+    newProperties: newProperties
+  });
+};
+
 /**
  * A plugin that adds a set of queries to the editor.
  *
@@ -10154,27 +10254,14 @@ Commands$6.insertFragment = function (editor, fragment) {
   var _value = value,
       document = _value.document,
       selection = _value.selection;
-  var start = selection.start,
-      end = selection.end;
-  var _value2 = value,
-      startText = _value2.startText,
-      endText = _value2.endText,
-      startInline = _value2.startInline;
-
-  var lastText = fragment.getLastText();
-  var lastInline = fragment.getClosestInline(lastText.key);
-  var lastBlock = fragment.getClosestBlock(lastText.key);
-  var firstChild = fragment.nodes.first();
-  var lastChild = fragment.nodes.last();
+  var start = selection.start;
+
   var keys = Array.from(document.texts(), function (_ref) {
     var _ref2 = slicedToArray(_ref, 1),
         text = _ref2[0];
 
     return text.key;
   });
-  var isAppending = !startInline || start.isAtStartOfNode(startText) || end.isAtStartOfNode(startText) || start.isAtEndOfNode(endText) || end.isAtEndOfNode(endText);
-
-  var isInserting = firstChild.hasBlockChildren() || lastChild.hasBlockChildren();
 
   editor.insertFragmentAtRange(selection, fragment);
   value = editor.value;
@@ -10183,25 +10270,28 @@ Commands$6.insertFragment = function (editor, fragment) {
   var newTexts = document.getTexts().filter(function (n) {
     return !keys.includes(n.key);
   });
-  var newText = isAppending ? newTexts.last() : newTexts.takeLast(2).first();
-
-  if (newText && (lastInline || isInserting)) {
-    editor.moveToEndOfNode(newText);
-  } else if (newText) {
-    // The position within the last text node needs to be calculated. This is the length
-    // of all text nodes within the last block, but if the last block contains inline nodes,
-    // these have to be skipped.
-    var nodes = lastBlock.nodes;
-
-    var lastIndex = nodes.findLastIndex(function (node) {
-      return node && node.object === 'inline';
-    });
-    var remainingTexts = nodes.takeLast(nodes.size - lastIndex - 1);
-    var remainingTextLength = remainingTexts.reduce(function (acc, val) {
-      return acc + val.text.length;
-    }, 0);
-    editor.moveToStartOfNode(newText).moveForward(remainingTextLength);
+  if (newTexts.size === 0) return;
+  var fragmentLength = fragment.text.length;
+
+  // Either startText is still here, or we want the first un-previously known text
+  var startText = document.getNode(start.key) || newTexts.first();
+  // We want the last un-previously known text
+  var endText = newTexts.last() || startText;
+
+  if (startText === endText) {
+    editor.moveTo(endText.key, fragmentLength);
+    return;
   }
+
+  // Everything will be calculated relative to the first common ancestor to optimize speed
+  var parent = document.getCommonAncestor(startText.key, endText.key);
+
+  var startOffset = parent.getOffset(startText.key) + (start.key === startText.key ? start.offset : 0);
+
+  // endText might not be the last un-previously known text node, so we precisely pick it by offset
+  endText = parent.getTextAtOffset(startOffset + fragmentLength - 1) || endText;
+
+  editor.moveTo(endText.key, startOffset + fragmentLength - parent.getOffset(endText.key));
 };
 
 /**
@@ -10764,14 +10854,27 @@ var Editor = function () {
 
       // Get the paths of the affected nodes, and mark them as dirty.
       var newDirtyPaths = getDirtyPaths(operation);
-      var dirty = this.tmp.dirty.reduce(function (memo, path) {
+
+      var dirty = this.tmp.dirty.map(function (path) {
         path = PathUtils.create(path);
         var transformed = PathUtils.transform(path, operation);
-        memo = memo.concat(transformed.toArray());
-        return memo;
-      }, newDirtyPaths);
+        return transformed.toArray();
+      });
 
-      this.tmp.dirty = dirty;
+      var pathIndex = {};
+      var dirtyPaths = Array.prototype.concat.apply(newDirtyPaths, dirty);
+      this.tmp.dirty = [];
+
+      // PERF: De-dupe the paths so we don't do extra normalization.
+      dirtyPaths.forEach(function (dirtyPath) {
+        var key = dirtyPath.join(',');
+
+        if (!pathIndex[key]) {
+          _this.tmp.dirty.push(dirtyPath);
+        }
+
+        pathIndex[key] = true;
+      });
 
       // If we're not already, queue the flushing process on the next tick.
       if (!this.tmp.flushing) {