slate 0.101.5 → 0.102.0

package/dist/core/apply.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"apply.d.ts","sourceRoot":"","sources":["../../../../packages/slate/src/core/apply.ts"],"names":[],"mappings":"AAMA,OAAO,EAAE,kBAAkB,EAAE,MAAM,gBAAgB,CAAA;AACnD,OAAO,EAAE,MAAM,EAAE,MAAM,sBAAsB,CAAA;AAE7C,eAAO,MAAM,KAAK,EAAE,kBAAkB,CAAC,MAAM,CAAC,OAAO,CAAC,CAoErD,CAAA"}
+{"version":3,"file":"apply.d.ts","sourceRoot":"","sources":["../../../../packages/slate/src/core/apply.ts"],"names":[],"mappings":"AAMA,OAAO,EAAE,kBAAkB,EAAE,MAAM,gBAAgB,CAAA;AACnD,OAAO,EAAE,MAAM,EAAE,MAAM,sBAAsB,CAAA;AAI7C,eAAO,MAAM,KAAK,EAAE,kBAAkB,CAAC,MAAM,CAAC,OAAO,CAAC,CAyCrD,CAAA"}

package/dist/core/batch-dirty-paths.d.ts

@@ -0,0 +1,4 @@
+import { Editor } from '../interfaces/editor';
+export declare const isBatchingDirtyPaths: (editor: Editor) => boolean;
+export declare const batchDirtyPaths: (editor: Editor, fn: () => void, update: () => void) => void;
+//# sourceMappingURL=batch-dirty-paths.d.ts.map

package/dist/core/batch-dirty-paths.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"batch-dirty-paths.d.ts","sourceRoot":"","sources":["../../../../packages/slate/src/core/batch-dirty-paths.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,MAAM,EAAE,MAAM,sBAAsB,CAAA;AAI7C,eAAO,MAAM,oBAAoB,WAAY,MAAM,YAElD,CAAA;AAED,eAAO,MAAM,eAAe,WAClB,MAAM,MACV,MAAM,IAAI,UACN,MAAM,IAAI,SAUnB,CAAA"}

package/dist/core/update-dirty-paths.d.ts

@@ -0,0 +1,10 @@
+import { Path } from '../interfaces/path';
+import { Editor } from '../interfaces/editor';
+/**
+ * update editor dirty paths
+ *
+ * @param newDirtyPaths: Path[]; new dirty paths
+ * @param transform: (p: Path) => Path | null; how to transform existing dirty paths
+ */
+export declare function updateDirtyPaths(editor: Editor, newDirtyPaths: Path[], transform?: (p: Path) => Path | null): void;
+//# sourceMappingURL=update-dirty-paths.d.ts.map

package/dist/core/update-dirty-paths.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"update-dirty-paths.d.ts","sourceRoot":"","sources":["../../../../packages/slate/src/core/update-dirty-paths.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,IAAI,EAAE,MAAM,oBAAoB,CAAA;AACzC,OAAO,EAAE,MAAM,EAAE,MAAM,sBAAsB,CAAA;AAE7C;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAC9B,MAAM,EAAE,MAAM,EACd,aAAa,EAAE,IAAI,EAAE,EACrB,SAAS,CAAC,EAAE,CAAC,CAAC,EAAE,IAAI,KAAK,IAAI,GAAG,IAAI,QAoCrC"}

package/dist/index.es.js

@@ -2182,16 +2182,29 @@ function ownKeys$9(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymb
 function _objectSpread$9(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys$9(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys$9(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
 var Transforms = _objectSpread$9(_objectSpread$9(_objectSpread$9(_objectSpread$9({}, GeneralTransforms), NodeTransforms), SelectionTransforms), TextTransforms);
 
-var apply = (editor, op) => {
-  for (var ref of Editor.pathRefs(editor)) {
-    PathRef.transform(ref, op);
-  }
-  for (var _ref of Editor.pointRefs(editor)) {
-    PointRef.transform(_ref, op);
-  }
-  for (var _ref2 of Editor.rangeRefs(editor)) {
-    RangeRef.transform(_ref2, op);
+// perf
+var BATCHING_DIRTY_PATHS = new WeakMap();
+var isBatchingDirtyPaths = editor => {
+  return BATCHING_DIRTY_PATHS.get(editor) || false;
+};
+var batchDirtyPaths = (editor, fn, update) => {
+  var value = BATCHING_DIRTY_PATHS.get(editor) || false;
+  BATCHING_DIRTY_PATHS.set(editor, true);
+  try {
+    fn();
+    update();
+  } finally {
+    BATCHING_DIRTY_PATHS.set(editor, value);
   }
+};
+
+/**
+ * update editor dirty paths
+ *
+ * @param newDirtyPaths: Path[]; new dirty paths
+ * @param transform: (p: Path) => Path | null; how to transform existing dirty paths
+ */
+function updateDirtyPaths(editor, newDirtyPaths, transform) {
   var oldDirtyPaths = DIRTY_PATHS.get(editor) || [];
   var oldDirtyPathKeys = DIRTY_PATH_KEYS.get(editor) || new Set();
   var dirtyPaths;
@@ -2205,23 +2218,39 @@ var apply = (editor, op) => {
       }
     }
   };
-  if (Path.operationCanTransformPath(op)) {
+  if (transform) {
     dirtyPaths = [];
     dirtyPathKeys = new Set();
     for (var path of oldDirtyPaths) {
-      var newPath = Path.transform(path, op);
+      var newPath = transform(path);
       add(newPath);
     }
   } else {
     dirtyPaths = oldDirtyPaths;
     dirtyPathKeys = oldDirtyPathKeys;
   }
-  var newDirtyPaths = editor.getDirtyPaths(op);
   for (var _path of newDirtyPaths) {
     add(_path);
   }
   DIRTY_PATHS.set(editor, dirtyPaths);
   DIRTY_PATH_KEYS.set(editor, dirtyPathKeys);
+}
+
+var apply = (editor, op) => {
+  for (var ref of Editor.pathRefs(editor)) {
+    PathRef.transform(ref, op);
+  }
+  for (var _ref of Editor.pointRefs(editor)) {
+    PointRef.transform(_ref, op);
+  }
+  for (var _ref2 of Editor.rangeRefs(editor)) {
+    RangeRef.transform(_ref2, op);
+  }
+  // update dirty paths
+  if (!isBatchingDirtyPaths(editor)) {
+    var transform = Path.operationCanTransformPath(op) ? p => Path.transform(p, op) : undefined;
+    updateDirtyPaths(editor, editor.getDirtyPaths(op), transform);
+  }
   Transforms.transform(editor, op);
   editor.operations.push(op);
   Editor.normalize(editor, {
@@ -3816,7 +3845,8 @@ var insertFragment = function insertFragment(editor, fragment) {
       voids = false
     } = options;
     var {
-      at = getDefaultInsertLocation(editor)
+      at = getDefaultInsertLocation(editor),
+      batchDirty = true
     } = options;
     if (!fragment.length) {
       return;
@@ -3951,7 +3981,8 @@ var insertFragment = function insertFragment(editor, fragment) {
       at: startRef.current,
       match: n => Text.isText(n) || Editor.isInline(editor, n),
       mode: 'highest',
-      voids
+      voids,
+      batchDirty
     });
     if (isBlockEmpty && !starts.length && middles.length && !ends.length) {
       Transforms.delete(editor, {
@@ -3963,13 +3994,15 @@ var insertFragment = function insertFragment(editor, fragment) {
       at: middleRef.current,
       match: n => Element.isElement(n) && Editor.isBlock(editor, n),
       mode: 'lowest',
-      voids
+      voids,
+      batchDirty
     });
     Transforms.insertNodes(editor, ends, {
       at: endRef.current,
       match: n => Text.isText(n) || Editor.isInline(editor, n),
       mode: 'highest',
-      voids
+      voids,
+      batchDirty
     });
     if (!options.at) {
       var path;
@@ -4152,7 +4185,8 @@ var insertNodes = function insertNodes(editor, nodes) {
     var {
       hanging = false,
       voids = false,
-      mode = 'lowest'
+      mode = 'lowest',
+      batchDirty = true
     } = options;
     var {
       at,
@@ -4231,15 +4265,60 @@ var insertNodes = function insertNodes(editor, nodes) {
     })) {
       return;
     }
-    for (var _node of nodes) {
-      var _path = parentPath.concat(index);
-      index++;
-      editor.apply({
-        type: 'insert_node',
-        path: _path,
-        node: _node
+    if (batchDirty) {
+      // PERF: batch update dirty paths
+      // batched ops used to transform existing dirty paths
+      var batchedOps = [];
+      var newDirtyPaths = Path.levels(parentPath);
+      batchDirtyPaths(editor, () => {
+        var _loop = function _loop() {
+          var path = parentPath.concat(index);
+          index++;
+          var op = {
+            type: 'insert_node',
+            path,
+            node: _node
+          };
+          editor.apply(op);
+          at = Path.next(at);
+          batchedOps.push(op);
+          if (!Text.isText) {
+            newDirtyPaths.push(path);
+          } else {
+            newDirtyPaths.push(...Array.from(Node.nodes(_node), _ref => {
+              var [, p] = _ref;
+              return path.concat(p);
+            }));
+          }
+        };
+        for (var _node of nodes) {
+          _loop();
+        }
+      }, () => {
+        updateDirtyPaths(editor, newDirtyPaths, p => {
+          var newPath = p;
+          for (var op of batchedOps) {
+            if (Path.operationCanTransformPath(op)) {
+              newPath = Path.transform(newPath, op);
+              if (!newPath) {
+                return null;
+              }
+            }
+          }
+          return newPath;
+        });
       });
-      at = Path.next(at);
+    } else {
+      for (var _node2 of nodes) {
+        var _path = parentPath.concat(index);
+        index++;
+        editor.apply({
+          type: 'insert_node',
+          path: _path,
+          node: _node2
+        });
+        at = Path.next(at);
+      }
     }
     at = Path.previous(at);
     if (select) {