prosemirror-transform 1.10.5 → 1.12.0

package/CHANGELOG.md

@@ -1,3 +1,19 @@
+## 1.12.0 (2026-03-30)
+
+### Bug fixes
+
+Handle deletions that go from the beginning of one textblock to the beginning of another specially, deleting the selected textblocks entirely.
+
+### New features
+
+`ReplaceStep.MAP_BIAS` can now be adjusted to change the way insertion steps are mapped over other insertions at the same place. The default behavior remains the same for the sake of backwards compatibility.
+
+## 1.11.0 (2026-01-21)
+
+### New features
+
+The new `Tranform.changedRange` method gives you a document range that includes all changes made by the transform/transaction.
+
 ## 1.10.5 (2025-11-11)
 
 ### Bug fixes

package/dist/index.cjs

@@ -610,8 +610,8 @@ var ReplaceStep = function (_Step5) {
   }, {
     key: "map",
     value: function map(mapping) {
-      var from = mapping.mapResult(this.from, 1),
-        to = mapping.mapResult(this.to, -1);
+      var to = mapping.mapResult(this.to, -1);
+      var from = this.from == this.to && ReplaceStep.MAP_BIAS < 0 ? to : mapping.mapResult(this.from, 1);
       if (from.deletedAcross && to.deletedAcross) return null;
       return new ReplaceStep(from.pos, Math.max(from.pos, to.pos), this.slice, this.structure);
     }
@@ -650,6 +650,7 @@ var ReplaceStep = function (_Step5) {
   }]);
   return ReplaceStep;
 }(Step);
+ReplaceStep.MAP_BIAS = 1;
 Step.jsonID("replace", ReplaceStep);
 var ReplaceAroundStep = function (_Step6) {
   _inherits(ReplaceAroundStep, _Step6);
@@ -1507,6 +1508,18 @@ function _replaceRangeWith(tr, from, to, node) {
 function _deleteRange(tr, from, to) {
   var $from = tr.doc.resolve(from),
     $to = tr.doc.resolve(to);
+  if ($from.parent.isTextblock && $to.parent.isTextblock && $from.start() != $to.start() && $from.parentOffset == 0 && $to.parentOffset == 0) {
+    var shared = $from.sharedDepth(to),
+      isolated = false;
+    for (var d = $from.depth; d > shared; d--) if ($from.node(d).type.spec.isolating) isolated = true;
+    for (var _d4 = $to.depth; _d4 > shared; _d4--) if ($to.node(_d4).type.spec.isolating) isolated = true;
+    if (!isolated) {
+      for (var _d5 = $from.depth; _d5 > 0 && from == $from.start(_d5); _d5--) from = $from.before(_d5);
+      for (var _d6 = $to.depth; _d6 > 0 && to == $to.start(_d6); _d6--) to = $to.before(_d6);
+      $from = tr.doc.resolve(from);
+      $to = tr.doc.resolve(to);
+    }
+  }
   var covered = coveredDepths($from, $to);
   for (var i = 0; i < covered.length; i++) {
     var depth = covered[i],
@@ -1514,8 +1527,8 @@ function _deleteRange(tr, from, to) {
     if (last && depth == 0 || $from.node(depth).type.contentMatch.validEnd) return tr["delete"]($from.start(depth), $to.end(depth));
     if (depth > 0 && (last || $from.node(depth - 1).canReplace($from.index(depth - 1), $to.indexAfter(depth - 1)))) return tr["delete"]($from.before(depth), $to.after(depth));
   }
-  for (var d = 1; d <= $from.depth && d <= $to.depth; d++) {
-    if (from - $from.start(d) == $from.depth - d && to > $from.end(d) && $to.end(d) - to != $to.depth - d && $from.start(d - 1) == $to.start(d - 1) && $from.node(d - 1).canReplace($from.index(d - 1), $to.index(d - 1))) return tr["delete"]($from.before(d), to);
+  for (var _d7 = 1; _d7 <= $from.depth && _d7 <= $to.depth; _d7++) {
+    if (from - $from.start(_d7) == $from.depth - _d7 && to > $from.end(_d7) && $to.end(_d7) - to != $to.depth - _d7 && $from.start(_d7 - 1) == $to.start(_d7 - 1) && $from.node(_d7 - 1).canReplace($from.index(_d7 - 1), $to.index(_d7 - 1))) return tr["delete"]($from.before(_d7), to);
   }
   tr["delete"](from, to);
 }
@@ -1691,6 +1704,27 @@ var Transform = function () {
     get: function get() {
       return this.steps.length > 0;
     }
+  }, {
+    key: "changedRange",
+    value: function changedRange() {
+      var from = 1e9,
+        to = -1e9;
+      for (var i = 0; i < this.mapping.maps.length; i++) {
+        var map = this.mapping.maps[i];
+        if (i) {
+          from = map.map(from, 1);
+          to = map.map(to, -1);
+        }
+        map.forEach(function (_f, _t, fromB, toB) {
+          from = Math.min(from, fromB);
+          to = Math.max(to, toB);
+        });
+      }
+      return from == 1e9 ? null : {
+        from: from,
+        to: to
+      };
+    }
   }, {
     key: "addStep",
     value: function addStep(step, doc) {

package/dist/index.d.cts

@@ -326,6 +326,16 @@ declare class Transform {
     */
     get docChanged(): boolean;
     /**
+    Return a single range, in post-transform document positions,
+    that covers all content changed by this transform. Returns null
+    if no replacements are made. Note that this will ignore changes
+    that add/remove marks without replacing the underlying content.
+    */
+    changedRange(): {
+        from: number;
+        to: number;
+    } | null;
+    /**
     Replace the part of the document between `from` and `to` with the
     given `slice`.
     */
@@ -694,6 +704,15 @@ declare class ReplaceStep extends Step {
     map(mapping: Mappable): ReplaceStep | null;
     merge(other: Step): ReplaceStep | null;
     toJSON(): any;
+    /**
+    By default, for backwards compatibility, an inserting step
+    mapped over an insertion at that same position fill move after
+    the inserted content. In a collaborative editing situation, that
+    can make redone insertions appear in unexpected places. You can
+    set this to -1 to make such mapping keep the step before the
+    insertion instead.
+    */
+    static MAP_BIAS: -1 | 1;
 }
 /**
 Replace a part of the document with a slice of content, but

package/dist/index.d.ts

@@ -326,6 +326,16 @@ declare class Transform {
     */
     get docChanged(): boolean;
     /**
+    Return a single range, in post-transform document positions,
+    that covers all content changed by this transform. Returns null
+    if no replacements are made. Note that this will ignore changes
+    that add/remove marks without replacing the underlying content.
+    */
+    changedRange(): {
+        from: number;
+        to: number;
+    } | null;
+    /**
     Replace the part of the document between `from` and `to` with the
     given `slice`.
     */
@@ -694,6 +704,15 @@ declare class ReplaceStep extends Step {
     map(mapping: Mappable): ReplaceStep | null;
     merge(other: Step): ReplaceStep | null;
     toJSON(): any;
+    /**
+    By default, for backwards compatibility, an inserting step
+    mapped over an insertion at that same position fill move after
+    the inserted content. In a collaborative editing situation, that
+    can make redone insertions appear in unexpected places. You can
+    set this to -1 to make such mapping keep the step before the
+    insertion instead.
+    */
+    static MAP_BIAS: -1 | 1;
 }
 /**
 Replace a part of the document with a slice of content, but

package/dist/index.js

@@ -711,7 +711,8 @@ class ReplaceStep extends Step {
         return new ReplaceStep(this.from, this.from + this.slice.size, doc.slice(this.from, this.to));
     }
     map(mapping) {
-        let from = mapping.mapResult(this.from, 1), to = mapping.mapResult(this.to, -1);
+        let to = mapping.mapResult(this.to, -1);
+        let from = this.from == this.to && ReplaceStep.MAP_BIAS < 0 ? to : mapping.mapResult(this.from, 1);
         if (from.deletedAcross && to.deletedAcross)
             return null;
         return new ReplaceStep(from.pos, Math.max(from.pos, to.pos), this.slice, this.structure);
@@ -750,6 +751,15 @@ class ReplaceStep extends Step {
         return new ReplaceStep(json.from, json.to, Slice.fromJSON(schema, json.slice), !!json.structure);
     }
 }
+/**
+By default, for backwards compatibility, an inserting step
+mapped over an insertion at that same position fill move after
+the inserted content. In a collaborative editing situation, that
+can make redone insertions appear in unexpected places. You can
+set this to -1 to make such mapping keep the step before the
+insertion instead.
+*/
+ReplaceStep.MAP_BIAS = 1;
 Step.jsonID("replace", ReplaceStep);
 /**
 Replace a part of the document with a slice of content, but
@@ -1736,6 +1746,26 @@ function replaceRangeWith(tr, from, to, node) {
 }
 function deleteRange(tr, from, to) {
     let $from = tr.doc.resolve(from), $to = tr.doc.resolve(to);
+    // When the deleted range spans from the start of one textblock to
+    // the start of another one, move out of the start of both blocks.
+    if ($from.parent.isTextblock && $to.parent.isTextblock && $from.start() != $to.start() &&
+        $from.parentOffset == 0 && $to.parentOffset == 0) {
+        let shared = $from.sharedDepth(to), isolated = false;
+        for (let d = $from.depth; d > shared; d--)
+            if ($from.node(d).type.spec.isolating)
+                isolated = true;
+        for (let d = $to.depth; d > shared; d--)
+            if ($to.node(d).type.spec.isolating)
+                isolated = true;
+        if (!isolated) {
+            for (let d = $from.depth; d > 0 && from == $from.start(d); d--)
+                from = $from.before(d);
+            for (let d = $to.depth; d > 0 && to == $to.start(d); d--)
+                to = $to.before(d);
+            $from = tr.doc.resolve(from);
+            $to = tr.doc.resolve(to);
+        }
+    }
     let covered = coveredDepths($from, $to);
     for (let i = 0; i < covered.length; i++) {
         let depth = covered[i], last = i == covered.length - 1;
@@ -1946,6 +1976,27 @@ class Transform {
         return this.steps.length > 0;
     }
     /**
+    Return a single range, in post-transform document positions,
+    that covers all content changed by this transform. Returns null
+    if no replacements are made. Note that this will ignore changes
+    that add/remove marks without replacing the underlying content.
+    */
+    changedRange() {
+        let from = 1e9, to = -1e9;
+        for (let i = 0; i < this.mapping.maps.length; i++) {
+            let map = this.mapping.maps[i];
+            if (i) {
+                from = map.map(from, 1);
+                to = map.map(to, -1);
+            }
+            map.forEach((_f, _t, fromB, toB) => {
+                from = Math.min(from, fromB);
+                to = Math.max(to, toB);
+            });
+        }
+        return from == 1e9 ? null : { from, to };
+    }
+    /**
     @internal
     */
     addStep(step, doc) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "prosemirror-transform",
-  "version": "1.10.5",
+  "version": "1.12.0",
   "description": "ProseMirror document transformations",
   "type": "module",
   "main": "dist/index.cjs",

package/src/replace.ts

@@ -425,6 +425,22 @@ export function replaceRangeWith(tr: Transform, from: number, to: number, node:
 
 export function deleteRange(tr: Transform, from: number, to: number) {
   let $from = tr.doc.resolve(from), $to = tr.doc.resolve(to)
+
+  // When the deleted range spans from the start of one textblock to
+  // the start of another one, move out of the start of both blocks.
+  if ($from.parent.isTextblock && $to.parent.isTextblock && $from.start() != $to.start() &&
+      $from.parentOffset == 0 && $to.parentOffset == 0) {
+    let shared = $from.sharedDepth(to), isolated = false
+    for (let d = $from.depth; d > shared; d--) if ($from.node(d).type.spec.isolating) isolated = true
+    for (let d = $to.depth; d > shared; d--) if ($to.node(d).type.spec.isolating) isolated = true
+    if (!isolated) {
+      for (let d = $from.depth; d > 0 && from == $from.start(d); d--) from = $from.before(d)
+      for (let d = $to.depth; d > 0 && to == $to.start(d); d--) to = $to.before(d)
+      $from = tr.doc.resolve(from)
+      $to = tr.doc.resolve(to)
+    }
+  }
+
   let covered = coveredDepths($from, $to)
   for (let i = 0; i < covered.length; i++) {
     let depth = covered[i], last = i == covered.length - 1

package/src/replace_step.ts

@@ -40,7 +40,8 @@ export class ReplaceStep extends Step {
   }
 
   map(mapping: Mappable) {
-    let from = mapping.mapResult(this.from, 1), to = mapping.mapResult(this.to, -1)
+    let to = mapping.mapResult(this.to, -1)
+    let from = this.from == this.to && ReplaceStep.MAP_BIAS < 0 ? to : mapping.mapResult(this.from, 1)
     if (from.deletedAcross && to.deletedAcross) return null
     return new ReplaceStep(from.pos, Math.max(from.pos, to.pos), this.slice, this.structure)
   }
@@ -74,6 +75,14 @@ export class ReplaceStep extends Step {
       throw new RangeError("Invalid input for ReplaceStep.fromJSON")
     return new ReplaceStep(json.from, json.to, Slice.fromJSON(schema, json.slice), !!json.structure)
   }
+
+  /// By default, for backwards compatibility, an inserting step
+  /// mapped over an insertion at that same position fill move after
+  /// the inserted content. In a collaborative editing situation, that
+  /// can make redone insertions appear in unexpected places. You can
+  /// set this to -1 to make such mapping keep the step before the
+  /// insertion instead.
+  static MAP_BIAS: -1 | 1 = 1
 }
 
 Step.jsonID("replace", ReplaceStep)

package/src/transform.ts

@@ -1,5 +1,4 @@
 import {Node, NodeType, Mark, MarkType, ContentMatch, Slice, Fragment, NodeRange, Attrs} from "prosemirror-model"
-
 import {Mapping} from "./map"
 import {Step} from "./step"
 import {addMark, removeMark, clearIncompatible} from "./mark"
@@ -66,6 +65,26 @@ export class Transform {
     return this.steps.length > 0
   }
 
+  /// Return a single range, in post-transform document positions,
+  /// that covers all content changed by this transform. Returns null
+  /// if no replacements are made. Note that this will ignore changes
+  /// that add/remove marks without replacing the underlying content.
+  changedRange() {
+    let from = 1e9, to = -1e9
+    for (let i = 0; i < this.mapping.maps.length; i++) {
+      let map = this.mapping.maps[i]
+      if (i) {
+        from = map.map(from, 1)
+        to = map.map(to, -1)
+      }
+      map.forEach((_f, _t, fromB, toB) => {
+        from = Math.min(from, fromB)
+        to = Math.max(to, toB)
+      })
+    }
+    return from == 1e9 ? null : {from, to}
+  }
+
   /// @internal
   addStep(step: Step, doc: Node) {
     this.docs.push(this.doc)
@@ -206,7 +225,7 @@ export class Transform {
     if (mark instanceof Mark) {
       if (mark.isInSet(node.marks)) this.step(new RemoveNodeMarkStep(pos, mark))
     } else {
-      let set = node.marks, found, steps: Step[] = []
+      let set = node.marks, found: Mark | undefined, steps: Step[] = []
       while (found = mark.isInSet(set)) {
         steps.push(new RemoveNodeMarkStep(pos, found))
         set = found.removeFromSet(set)