prosemirror-transform 1.10.0 → 1.10.2

package/CHANGELOG.md

@@ -1,3 +1,17 @@
+## 1.10.2 (2024-10-11)
+
+### Bug fixes
+
+Allow `Transform.join` to clear incompatible inline content from the node after the join.
+
+## 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

package/dist/index.cjs

@@ -1034,8 +1034,21 @@ function canJoin(doc, pos) {
     index = $pos.index();
   return joinable($pos.nodeBefore, $pos.nodeAfter) && $pos.parent.canReplace(index, index + 1);
 }
+function canAppendWithSubstitutedLinebreaks(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 && canAppendWithSubstitutedLinebreaks(a, b));
 }
 function joinPoint(doc, pos) {
   var dir = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : -1;
@@ -1061,8 +1074,29 @@ 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;
+  var $before = tr.doc.resolve(pos - depth),
+    beforeType = $before.node().type;
+  if (linebreakReplacement && beforeType.inlineContent) {
+    var pre = beforeType.whitespace == "pre";
+    var supportLinebreak = !!beforeType.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);
+  }
+  if (beforeType.inlineContent) _clearIncompatible(tr, pos + depth - 1, beforeType, $before.node().contentMatchAt($before.index()), convertNewlines == null);
+  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);
@@ -1475,7 +1509,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.js

@@ -1183,8 +1183,24 @@ function canJoin(doc, pos) {
     return joinable($pos.nodeBefore, $pos.nodeAfter) &&
         $pos.parent.canReplace(index, index + 1);
 }
+function canAppendWithSubstitutedLinebreaks(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 && canAppendWithSubstitutedLinebreaks(a, b));
 }
 /**
 Find an ancestor of the given position that can be joined to the
@@ -1217,8 +1233,31 @@ 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;
+    let $before = tr.doc.resolve(pos - depth), beforeType = $before.node().type;
+    if (linebreakReplacement && beforeType.inlineContent) {
+        let pre = beforeType.whitespace == "pre";
+        let supportLinebreak = !!beforeType.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);
+    }
+    if (beforeType.inlineContent)
+        clearIncompatible(tr, pos + depth - 1, beforeType, $before.node().contentMatchAt($before.index()), convertNewlines == null);
+    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
@@ -1702,7 +1741,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.10.0",
+  "version": "1.10.2",
   "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

@@ -132,7 +132,7 @@ export function setBlockType(tr: Transform, from: number, to: number,
       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(attrsHere, 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
     }
@@ -226,8 +226,22 @@ export function canJoin(doc: Node, pos: number): boolean {
     $pos.parent.canReplace(index, index + 1)
 }
 
+function canAppendWithSubstitutedLinebreaks(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 && canAppendWithSubstitutedLinebreaks(a, b))
 }
 
 /// Find an ancestor of the given position that can be joined to the
@@ -256,8 +270,30 @@ 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
+  let $before = tr.doc.resolve(pos - depth), beforeType = $before.node().type
+  if (linebreakReplacement && beforeType.inlineContent) {
+    let pre = beforeType.whitespace == "pre"
+    let supportLinebreak = !!beforeType.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)
+  }
+  if (beforeType.inlineContent)
+    clearIncompatible(tr, pos + depth - 1, beforeType,
+                      $before.node().contentMatchAt($before.index()), convertNewlines == null)
+  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