prosemirror-transform 1.9.0 → 1.10.1

package/CHANGELOG.md

@@ -1,3 +1,17 @@
+## 1.10.1 (2024-10-10)
+
+### Bug fixes
+
+Fix an issue where a `deleteRange` heuristic could produce unexpected deletion shapes.
+
+Make `Transform.join` convert between newlines and line break replacement nodes when necessary.
+
+## 1.10.0 (2024-08-13)
+
+### New features
+
+`setBlockType` can now take a function that computes attributes for the new nodes, instead of a static attribute object.
+
 ## 1.9.0 (2024-05-06)
 
 ### Bug fixes

package/dist/index.cjs

@@ -942,7 +942,8 @@ function _setBlockType(tr, from, to, type, attrs) {
   if (!type.isTextblock) throw new RangeError("Type given to setBlockType should be a textblock");
   var mapFrom = tr.steps.length;
   tr.doc.nodesBetween(from, to, function (node, pos) {
-    if (node.isTextblock && !node.hasMarkup(type, attrs) && canChangeType(tr.doc, tr.mapping.slice(mapFrom).map(pos), type)) {
+    var attrsHere = typeof attrs == "function" ? attrs(node) : attrs;
+    if (node.isTextblock && !node.hasMarkup(type, attrsHere) && canChangeType(tr.doc, tr.mapping.slice(mapFrom).map(pos), type)) {
       var convertNewlines = null;
       if (type.schema.linebreakReplacement) {
         var pre = type.whitespace == "pre",
@@ -954,7 +955,7 @@ function _setBlockType(tr, from, to, type, attrs) {
       var mapping = tr.mapping.slice(mapFrom);
       var startM = mapping.map(pos, 1),
         endM = mapping.map(pos + node.nodeSize, 1);
-      tr.step(new ReplaceAroundStep(startM, endM, startM + 1, endM - 1, new prosemirrorModel.Slice(prosemirrorModel.Fragment.from(type.create(attrs, null, node.marks)), 0, 0), 1, true));
+      tr.step(new ReplaceAroundStep(startM, endM, startM + 1, endM - 1, new prosemirrorModel.Slice(prosemirrorModel.Fragment.from(type.create(attrsHere, null, node.marks)), 0, 0), 1, true));
       if (convertNewlines === true) replaceNewlines(tr, node, pos, mapFrom);
       return false;
     }
@@ -1033,8 +1034,21 @@ function canJoin(doc, pos) {
     index = $pos.index();
   return joinable($pos.nodeBefore, $pos.nodeAfter) && $pos.parent.canReplace(index, index + 1);
 }
+function canAppendWithSubstitutedLinebeaks(a, b) {
+  if (!b.content.size) a.type.compatibleContent(b.type);
+  var match = a.contentMatchAt(a.childCount);
+  var linebreakReplacement = a.type.schema.linebreakReplacement;
+  for (var i = 0; i < b.childCount; i++) {
+    var child = b.child(i);
+    var type = child.type == linebreakReplacement ? a.type.schema.nodes.text : child.type;
+    match = match.matchType(type);
+    if (!match) return false;
+    if (!a.type.allowsMarks(child.marks)) return false;
+  }
+  return match.validEnd;
+}
 function joinable(a, b) {
-  return !!(a && b && !a.isLeaf && a.canAppend(b));
+  return !!(a && b && !a.isLeaf && canAppendWithSubstitutedLinebeaks(a, b));
 }
 function joinPoint(doc, pos) {
   var dir = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : -1;
@@ -1060,8 +1074,27 @@ function joinPoint(doc, pos) {
   }
 }
 function _join(tr, pos, depth) {
-  var step = new ReplaceStep(pos - depth, pos + depth, prosemirrorModel.Slice.empty, true);
-  tr.step(step);
+  var convertNewlines = null;
+  var linebreakReplacement = tr.doc.type.schema.linebreakReplacement;
+  if (linebreakReplacement) {
+    var before = tr.doc.resolve(pos - depth).node().type;
+    var pre = before.whitespace == "pre";
+    var supportLinebreak = !!before.contentMatch.matchType(linebreakReplacement);
+    if (pre && !supportLinebreak) convertNewlines = false;else if (!pre && supportLinebreak) convertNewlines = true;
+  }
+  var mapFrom = tr.steps.length;
+  if (convertNewlines === false) {
+    var $after = tr.doc.resolve(pos + depth);
+    replaceLinebreaks(tr, $after.node(), $after.before(), mapFrom);
+  }
+  var mapping = tr.mapping.slice(mapFrom),
+    start = mapping.map(pos - depth);
+  tr.step(new ReplaceStep(start, mapping.map(pos + depth, -1), prosemirrorModel.Slice.empty, true));
+  if (convertNewlines === true) {
+    var $full = tr.doc.resolve(start);
+    replaceNewlines(tr, $full.node(), $full.before(), tr.steps.length);
+  }
+  return tr;
 }
 function insertPoint(doc, pos, nodeType) {
   var $pos = doc.resolve(pos);
@@ -1474,7 +1507,7 @@ function _deleteRange(tr, from, to) {
     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) return tr["delete"]($from.before(d), to);
+    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);
   }
   tr["delete"](from, to);
 }

package/dist/index.d.cts

@@ -406,7 +406,7 @@ declare class Transform {
     Set the type of all textblocks (partly) between `from` and `to` to
     the given node type with the given attributes.
     */
-    setBlockType(from: number, to: number | undefined, type: NodeType, attrs?: Attrs | null): this;
+    setBlockType(from: number, to: number | undefined, type: NodeType, attrs?: Attrs | null | ((oldNode: Node) => Attrs)): this;
     /**
     Change the type, attributes, and/or marks of the node at `pos`.
     When `type` isn't given, the existing node type is preserved,

package/dist/index.d.ts

@@ -406,7 +406,7 @@ declare class Transform {
     Set the type of all textblocks (partly) between `from` and `to` to
     the given node type with the given attributes.
     */
-    setBlockType(from: number, to: number | undefined, type: NodeType, attrs?: Attrs | null): this;
+    setBlockType(from: number, to: number | undefined, type: NodeType, attrs?: Attrs | null | ((oldNode: Node) => Attrs)): this;
     /**
     Change the type, attributes, and/or marks of the node at `pos`.
     When `type` isn't given, the existing node type is preserved,

package/dist/index.js

@@ -1075,7 +1075,9 @@ function setBlockType(tr, from, to, type, attrs) {
         throw new RangeError("Type given to setBlockType should be a textblock");
     let mapFrom = tr.steps.length;
     tr.doc.nodesBetween(from, to, (node, pos) => {
-        if (node.isTextblock && !node.hasMarkup(type, attrs) && canChangeType(tr.doc, tr.mapping.slice(mapFrom).map(pos), type)) {
+        let attrsHere = typeof attrs == "function" ? attrs(node) : attrs;
+        if (node.isTextblock && !node.hasMarkup(type, attrsHere) &&
+            canChangeType(tr.doc, tr.mapping.slice(mapFrom).map(pos), type)) {
             let convertNewlines = null;
             if (type.schema.linebreakReplacement) {
                 let pre = type.whitespace == "pre", supportLinebreak = !!type.contentMatch.matchType(type.schema.linebreakReplacement);
@@ -1090,7 +1092,7 @@ function setBlockType(tr, from, to, type, attrs) {
             clearIncompatible(tr, tr.mapping.slice(mapFrom).map(pos, 1), type, undefined, convertNewlines === null);
             let mapping = tr.mapping.slice(mapFrom);
             let startM = mapping.map(pos, 1), endM = mapping.map(pos + node.nodeSize, 1);
-            tr.step(new ReplaceAroundStep(startM, endM, startM + 1, endM - 1, new Slice(Fragment.from(type.create(attrs, null, node.marks)), 0, 0), 1, true));
+            tr.step(new ReplaceAroundStep(startM, endM, startM + 1, endM - 1, new Slice(Fragment.from(type.create(attrsHere, null, node.marks)), 0, 0), 1, true));
             if (convertNewlines === true)
                 replaceNewlines(tr, node, pos, mapFrom);
             return false;
@@ -1181,8 +1183,24 @@ function canJoin(doc, pos) {
     return joinable($pos.nodeBefore, $pos.nodeAfter) &&
         $pos.parent.canReplace(index, index + 1);
 }
+function canAppendWithSubstitutedLinebeaks(a, b) {
+    if (!b.content.size)
+        a.type.compatibleContent(b.type);
+    let match = a.contentMatchAt(a.childCount);
+    let { linebreakReplacement } = a.type.schema;
+    for (let i = 0; i < b.childCount; i++) {
+        let child = b.child(i);
+        let type = child.type == linebreakReplacement ? a.type.schema.nodes.text : child.type;
+        match = match.matchType(type);
+        if (!match)
+            return false;
+        if (!a.type.allowsMarks(child.marks))
+            return false;
+    }
+    return match.validEnd;
+}
 function joinable(a, b) {
-    return !!(a && b && !a.isLeaf && a.canAppend(b));
+    return !!(a && b && !a.isLeaf && canAppendWithSubstitutedLinebeaks(a, b));
 }
 /**
 Find an ancestor of the given position that can be joined to the
@@ -1215,8 +1233,29 @@ function joinPoint(doc, pos, dir = -1) {
     }
 }
 function join(tr, pos, depth) {
-    let step = new ReplaceStep(pos - depth, pos + depth, Slice.empty, true);
-    tr.step(step);
+    let convertNewlines = null;
+    let { linebreakReplacement } = tr.doc.type.schema;
+    if (linebreakReplacement) {
+        let before = tr.doc.resolve(pos - depth).node().type;
+        let pre = before.whitespace == "pre";
+        let supportLinebreak = !!before.contentMatch.matchType(linebreakReplacement);
+        if (pre && !supportLinebreak)
+            convertNewlines = false;
+        else if (!pre && supportLinebreak)
+            convertNewlines = true;
+    }
+    let mapFrom = tr.steps.length;
+    if (convertNewlines === false) {
+        let $after = tr.doc.resolve(pos + depth);
+        replaceLinebreaks(tr, $after.node(), $after.before(), mapFrom);
+    }
+    let mapping = tr.mapping.slice(mapFrom), start = mapping.map(pos - depth);
+    tr.step(new ReplaceStep(start, mapping.map(pos + depth, -1), Slice.empty, true));
+    if (convertNewlines === true) {
+        let $full = tr.doc.resolve(start);
+        replaceNewlines(tr, $full.node(), $full.before(), tr.steps.length);
+    }
+    return tr;
 }
 /**
 Try to find a point where a node of the given type can be inserted
@@ -1700,7 +1739,8 @@ function deleteRange(tr, from, to) {
             return tr.delete($from.before(depth), $to.after(depth));
     }
     for (let 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)
+        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);
     }
     tr.delete(from, to);

package/package.json

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

package/src/replace.ts

@@ -434,7 +434,8 @@ export function deleteRange(tr: Transform, from: number, to: number) {
       return tr.delete($from.before(depth), $to.after(depth))
   }
   for (let 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)
+    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)
   }
   tr.delete(from, to)

package/src/structure.ts

@@ -112,11 +112,14 @@ export function wrap(tr: Transform, range: NodeRange, wrappers: readonly {type:
   tr.step(new ReplaceAroundStep(start, end, start, end, new Slice(content, 0, 0), wrappers.length, true))
 }
 
-export function setBlockType(tr: Transform, from: number, to: number, type: NodeType, attrs: Attrs | null) {
+export function setBlockType(tr: Transform, from: number, to: number,
+                             type: NodeType, attrs: Attrs | null | ((oldNode: Node) => Attrs)) {
   if (!type.isTextblock) throw new RangeError("Type given to setBlockType should be a textblock")
   let mapFrom = tr.steps.length
   tr.doc.nodesBetween(from, to, (node, pos) => {
-    if (node.isTextblock && !node.hasMarkup(type, attrs) && canChangeType(tr.doc, tr.mapping.slice(mapFrom).map(pos), type)) {
+    let attrsHere = typeof attrs == "function" ? attrs(node) : attrs
+    if (node.isTextblock && !node.hasMarkup(type, attrsHere) &&
+        canChangeType(tr.doc, tr.mapping.slice(mapFrom).map(pos), type)) {
       let convertNewlines = null
       if (type.schema.linebreakReplacement) {
         let pre = type.whitespace == "pre", supportLinebreak = !!type.contentMatch.matchType(type.schema.linebreakReplacement)
@@ -129,7 +132,7 @@ export function setBlockType(tr: Transform, from: number, to: number, type: Node
       let mapping = tr.mapping.slice(mapFrom)
       let startM = mapping.map(pos, 1), endM = mapping.map(pos + node.nodeSize, 1)
       tr.step(new ReplaceAroundStep(startM, endM, startM + 1, endM - 1,
-                                      new Slice(Fragment.from(type.create(attrs, null, node.marks)), 0, 0), 1, true))
+                                    new Slice(Fragment.from(type.create(attrsHere, null, node.marks)), 0, 0), 1, true))
       if (convertNewlines === true) replaceNewlines(tr, node, pos, mapFrom)
       return false
     }
@@ -223,8 +226,22 @@ export function canJoin(doc: Node, pos: number): boolean {
     $pos.parent.canReplace(index, index + 1)
 }
 
+function canAppendWithSubstitutedLinebeaks(a: Node, b: Node) {
+  if (!b.content.size) a.type.compatibleContent(b.type)
+  let match: ContentMatch | null = a.contentMatchAt(a.childCount)
+  let {linebreakReplacement} = a.type.schema
+  for (let i = 0; i < b.childCount; i++) {
+    let child = b.child(i)
+    let type = child.type == linebreakReplacement ? a.type.schema.nodes.text : child.type
+    match = match.matchType(type)
+    if (!match) return false
+    if (!a.type.allowsMarks(child.marks)) return false
+  }
+  return match.validEnd
+}
+
 function joinable(a: Node | null, b: Node | null) {
-  return !!(a && b && !a.isLeaf && a.canAppend(b))
+  return !!(a && b && !a.isLeaf && canAppendWithSubstitutedLinebeaks(a, b))
 }
 
 /// Find an ancestor of the given position that can be joined to the
@@ -253,8 +270,27 @@ export function joinPoint(doc: Node, pos: number, dir = -1) {
 }
 
 export function join(tr: Transform, pos: number, depth: number) {
-  let step = new ReplaceStep(pos - depth, pos + depth, Slice.empty, true)
-  tr.step(step)
+  let convertNewlines = null
+  let {linebreakReplacement} = tr.doc.type.schema
+  if (linebreakReplacement) {
+    let before = tr.doc.resolve(pos - depth).node().type
+    let pre = before.whitespace == "pre"
+    let supportLinebreak = !!before.contentMatch.matchType(linebreakReplacement)
+    if (pre && !supportLinebreak) convertNewlines = false
+    else if (!pre && supportLinebreak) convertNewlines = true
+  }
+  let mapFrom = tr.steps.length
+  if (convertNewlines === false) {
+    let $after = tr.doc.resolve(pos + depth)
+    replaceLinebreaks(tr, $after.node(), $after.before(), mapFrom)
+  }
+  let mapping = tr.mapping.slice(mapFrom), start = mapping.map(pos - depth)
+  tr.step(new ReplaceStep(start, mapping.map(pos + depth, - 1), Slice.empty, true))
+  if (convertNewlines === true) {
+    let $full = tr.doc.resolve(start)
+    replaceNewlines(tr, $full.node(), $full.before(), tr.steps.length)
+  }
+  return tr
 }
 
 /// Try to find a point where a node of the given type can be inserted

package/src/transform.ts

@@ -166,7 +166,7 @@ export class Transform {
 
   /// Set the type of all textblocks (partly) between `from` and `to` to
   /// the given node type with the given attributes.
-  setBlockType(from: number, to = from, type: NodeType, attrs: Attrs | null = null): this {
+  setBlockType(from: number, to = from, type: NodeType, attrs: Attrs | null | ((oldNode: Node) => Attrs) = null): this {
     setBlockType(this, from, to, type, attrs)
     return this
   }