slate 0.82.1 → 0.84.0

package/dist/index.js

@@ -3370,6 +3370,7 @@ var Operation = {
   }
 };
 
+// eslint-disable-next-line no-redeclare
 var Path = {
   /**
    * Get a list of ancestor paths for a given path.
@@ -3653,120 +3654,120 @@ var Path = {
    */
   transform: function transform(path, operation) {
     var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
-    return immer.produce(path, function (p) {
-      var _options$affinity = options.affinity,
-          affinity = _options$affinity === void 0 ? 'forward' : _options$affinity; // PERF: Exit early if the operation is guaranteed not to have an effect.
+    if (!path) return null; // PERF: use destructing instead of immer
 
-      if (!path || (path === null || path === void 0 ? void 0 : path.length) === 0) {
-        return;
-      }
+    var p = _toConsumableArray(path);
 
-      if (p === null) {
-        return null;
-      }
+    var _options$affinity = options.affinity,
+        affinity = _options$affinity === void 0 ? 'forward' : _options$affinity; // PERF: Exit early if the operation is guaranteed not to have an effect.
 
-      switch (operation.type) {
-        case 'insert_node':
-          {
-            var op = operation.path;
+    if (path.length === 0) {
+      return p;
+    }
 
-            if (Path.equals(op, p) || Path.endsBefore(op, p) || Path.isAncestor(op, p)) {
-              p[op.length - 1] += 1;
-            }
+    switch (operation.type) {
+      case 'insert_node':
+        {
+          var op = operation.path;
 
-            break;
+          if (Path.equals(op, p) || Path.endsBefore(op, p) || Path.isAncestor(op, p)) {
+            p[op.length - 1] += 1;
           }
 
-        case 'remove_node':
-          {
-            var _op = operation.path;
+          break;
+        }
 
-            if (Path.equals(_op, p) || Path.isAncestor(_op, p)) {
-              return null;
-            } else if (Path.endsBefore(_op, p)) {
-              p[_op.length - 1] -= 1;
-            }
+      case 'remove_node':
+        {
+          var _op = operation.path;
 
-            break;
+          if (Path.equals(_op, p) || Path.isAncestor(_op, p)) {
+            return null;
+          } else if (Path.endsBefore(_op, p)) {
+            p[_op.length - 1] -= 1;
           }
 
-        case 'merge_node':
-          {
-            var _op2 = operation.path,
-                position = operation.position;
-
-            if (Path.equals(_op2, p) || Path.endsBefore(_op2, p)) {
-              p[_op2.length - 1] -= 1;
-            } else if (Path.isAncestor(_op2, p)) {
-              p[_op2.length - 1] -= 1;
-              p[_op2.length] += position;
-            }
+          break;
+        }
 
-            break;
+      case 'merge_node':
+        {
+          var _op2 = operation.path,
+              position = operation.position;
+
+          if (Path.equals(_op2, p) || Path.endsBefore(_op2, p)) {
+            p[_op2.length - 1] -= 1;
+          } else if (Path.isAncestor(_op2, p)) {
+            p[_op2.length - 1] -= 1;
+            p[_op2.length] += position;
           }
 
-        case 'split_node':
-          {
-            var _op3 = operation.path,
-                _position = operation.position;
+          break;
+        }
 
-            if (Path.equals(_op3, p)) {
-              if (affinity === 'forward') {
-                p[p.length - 1] += 1;
-              } else if (affinity === 'backward') ; else {
-                return null;
-              }
-            } else if (Path.endsBefore(_op3, p)) {
-              p[_op3.length - 1] += 1;
-            } else if (Path.isAncestor(_op3, p) && path[_op3.length] >= _position) {
-              p[_op3.length - 1] += 1;
-              p[_op3.length] -= _position;
-            }
+      case 'split_node':
+        {
+          var _op3 = operation.path,
+              _position = operation.position;
 
-            break;
+          if (Path.equals(_op3, p)) {
+            if (affinity === 'forward') {
+              p[p.length - 1] += 1;
+            } else if (affinity === 'backward') ; else {
+              return null;
+            }
+          } else if (Path.endsBefore(_op3, p)) {
+            p[_op3.length - 1] += 1;
+          } else if (Path.isAncestor(_op3, p) && path[_op3.length] >= _position) {
+            p[_op3.length - 1] += 1;
+            p[_op3.length] -= _position;
           }
 
-        case 'move_node':
-          {
-            var _op4 = operation.path,
-                onp = operation.newPath; // If the old and new path are the same, it's a no-op.
-
-            if (Path.equals(_op4, onp)) {
-              return;
-            }
+          break;
+        }
 
-            if (Path.isAncestor(_op4, p) || Path.equals(_op4, p)) {
-              var copy = onp.slice();
+      case 'move_node':
+        {
+          var _op4 = operation.path,
+              onp = operation.newPath; // If the old and new path are the same, it's a no-op.
 
-              if (Path.endsBefore(_op4, onp) && _op4.length < onp.length) {
-                copy[_op4.length - 1] -= 1;
-              }
+          if (Path.equals(_op4, onp)) {
+            return p;
+          }
 
-              return copy.concat(p.slice(_op4.length));
-            } else if (Path.isSibling(_op4, onp) && (Path.isAncestor(onp, p) || Path.equals(onp, p))) {
-              if (Path.endsBefore(_op4, p)) {
-                p[_op4.length - 1] -= 1;
-              } else {
-                p[_op4.length - 1] += 1;
-              }
-            } else if (Path.endsBefore(onp, p) || Path.equals(onp, p) || Path.isAncestor(onp, p)) {
-              if (Path.endsBefore(_op4, p)) {
-                p[_op4.length - 1] -= 1;
-              }
+          if (Path.isAncestor(_op4, p) || Path.equals(_op4, p)) {
+            var copy = onp.slice();
 
-              p[onp.length - 1] += 1;
-            } else if (Path.endsBefore(_op4, p)) {
-              if (Path.equals(onp, p)) {
-                p[onp.length - 1] += 1;
-              }
+            if (Path.endsBefore(_op4, onp) && _op4.length < onp.length) {
+              copy[_op4.length - 1] -= 1;
+            }
 
+            return copy.concat(p.slice(_op4.length));
+          } else if (Path.isSibling(_op4, onp) && (Path.isAncestor(onp, p) || Path.equals(onp, p))) {
+            if (Path.endsBefore(_op4, p)) {
+              p[_op4.length - 1] -= 1;
+            } else {
+              p[_op4.length - 1] += 1;
+            }
+          } else if (Path.endsBefore(onp, p) || Path.equals(onp, p) || Path.isAncestor(onp, p)) {
+            if (Path.endsBefore(_op4, p)) {
               p[_op4.length - 1] -= 1;
             }
 
-            break;
+            p[onp.length - 1] += 1;
+          } else if (Path.endsBefore(_op4, p)) {
+            if (Path.equals(onp, p)) {
+              p[onp.length - 1] += 1;
+            }
+
+            p[_op4.length - 1] -= 1;
           }
-      }
-    });
+
+          break;
+        }
+    }
+
+    return p;
   }
 };
 
@@ -6439,15 +6440,15 @@ var TextTransforms = {
 
           var _entry = _slicedToArray(entry, 2),
               _node2 = _entry[0],
-              _path3 = _entry[1];
+              _path2 = _entry[1];
 
-          if (lastPath && Path.compare(_path3, lastPath) === 0) {
+          if (lastPath && Path.compare(_path2, lastPath) === 0) {
             continue;
           }
 
-          if (!voids && Editor.isVoid(editor, _node2) || !Path.isCommon(_path3, start.path) && !Path.isCommon(_path3, end.path)) {
+          if (!voids && Editor.isVoid(editor, _node2) || !Path.isCommon(_path2, start.path) && !Path.isCommon(_path2, end.path)) {
             matches.push(entry);
-            lastPath = _path3;
+            lastPath = _path2;
           }
         }
       } catch (err) {
@@ -6489,16 +6490,16 @@ var TextTransforms = {
         }
       }
 
-      for (var _i = 0, _pathRefs = pathRefs; _i < _pathRefs.length; _i++) {
-        var pathRef = _pathRefs[_i];
-
-        var _path = pathRef.unref();
-
-        Transforms.removeNodes(editor, {
-          at: _path,
+      pathRefs.reverse().map(function (r) {
+        return r.unref();
+      }).filter(function (r) {
+        return r !== null;
+      }).forEach(function (p) {
+        return Transforms.removeNodes(editor, {
+          at: p,
           voids: voids
         });
-      }
+      });
 
       if (!endVoid) {
         var _point2 = endRef.current;
@@ -6507,7 +6508,7 @@ var TextTransforms = {
             _Editor$leaf4 = _slicedToArray(_Editor$leaf3, 1),
             _node = _Editor$leaf4[0];
 
-        var _path2 = _point2.path;
+        var _path = _point2.path;
 
         var _offset = isSingleText ? start.offset : 0;
 
@@ -6516,7 +6517,7 @@ var TextTransforms = {
         if (_text.length > 0) {
           editor.apply({
             type: 'remove_text',
-            path: _path2,
+            path: _path,
             offset: _offset,
             text: _text
           });
@@ -6710,8 +6711,8 @@ var TextTransforms = {
       var starting = true;
       var hasBlocks = false;
 
-      for (var _i2 = 0, _matches = matches; _i2 < _matches.length; _i2++) {
-        var _matches$_i = _slicedToArray(_matches[_i2], 1),
+      for (var _i = 0, _matches = matches; _i < _matches.length; _i++) {
+        var _matches$_i = _slicedToArray(_matches[_i], 1),
             node = _matches$_i[0];
 
         if (Element.isElement(node) && !editor.isInline(node)) {