prosemirror-transform 1.8.0 → 1.10.0

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,
@@ -836,4 +836,4 @@ would be a no-op (an empty slice over an empty range).
 */
 declare function replaceStep(doc: Node, from: number, to?: number, slice?: Slice): Step | null;
 
-export { AddMarkStep, AddNodeMarkStep, AttrStep, DocAttrStep, MapResult, Mappable, Mapping, RemoveMarkStep, RemoveNodeMarkStep, ReplaceAroundStep, ReplaceStep, Step, StepMap, StepResult, Transform, canJoin, canSplit, dropPoint, findWrapping, insertPoint, joinPoint, liftTarget, replaceStep };
+export { AddMarkStep, AddNodeMarkStep, AttrStep, DocAttrStep, MapResult, type Mappable, Mapping, RemoveMarkStep, RemoveNodeMarkStep, ReplaceAroundStep, ReplaceStep, Step, StepMap, StepResult, Transform, canJoin, canSplit, dropPoint, findWrapping, insertPoint, joinPoint, liftTarget, replaceStep };

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,
@@ -836,4 +836,4 @@ would be a no-op (an empty slice over an empty range).
 */
 declare function replaceStep(doc: Node, from: number, to?: number, slice?: Slice): Step | null;
 
-export { AddMarkStep, AddNodeMarkStep, AttrStep, DocAttrStep, MapResult, Mappable, Mapping, RemoveMarkStep, RemoveNodeMarkStep, ReplaceAroundStep, ReplaceStep, Step, StepMap, StepResult, Transform, canJoin, canSplit, dropPoint, findWrapping, insertPoint, joinPoint, liftTarget, replaceStep };
+export { AddMarkStep, AddNodeMarkStep, AttrStep, DocAttrStep, MapResult, type Mappable, Mapping, RemoveMarkStep, RemoveNodeMarkStep, ReplaceAroundStep, ReplaceStep, Step, StepMap, StepResult, Transform, canJoin, canSplit, dropPoint, findWrapping, insertPoint, joinPoint, liftTarget, replaceStep };

package/dist/index.js

@@ -824,7 +824,8 @@ class ReplaceAroundStep extends Step {
     }
     map(mapping) {
         let from = mapping.mapResult(this.from, 1), to = mapping.mapResult(this.to, -1);
-        let gapFrom = mapping.map(this.gapFrom, -1), gapTo = mapping.map(this.gapTo, 1);
+        let gapFrom = this.from == this.gapFrom ? from.pos : mapping.map(this.gapFrom, -1);
+        let gapTo = this.to == this.gapTo ? to.pos : mapping.map(this.gapTo, 1);
         if ((from.deletedAcross && to.deletedAcross) || gapFrom < from.pos || gapTo > to.pos)
             return null;
         return new ReplaceAroundStep(from.pos, to.pos, gapFrom, gapTo, this.slice, this.insert, this.structure);
@@ -936,7 +937,7 @@ function removeMark(tr, from, to, mark) {
     });
     matched.forEach(m => tr.step(new RemoveMarkStep(m.from, m.to, m.style)));
 }
-function clearIncompatible(tr, pos, parentType, match = parentType.contentMatch) {
+function clearIncompatible(tr, pos, parentType, match = parentType.contentMatch, clearNewlines = true) {
     let node = tr.doc.nodeAt(pos);
     let replSteps = [], cur = pos + 1;
     for (let i = 0; i < node.childCount; i++) {
@@ -950,7 +951,7 @@ function clearIncompatible(tr, pos, parentType, match = parentType.contentMatch)
             for (let j = 0; j < child.marks.length; j++)
                 if (!parentType.allowsMarkType(child.marks[j].type))
                     tr.step(new RemoveMarkStep(cur, end, child.marks[j]));
-            if (child.isText && !parentType.spec.code) {
+            if (clearNewlines && child.isText && parentType.whitespace != "pre") {
                 let m, newline = /\r?\n|\r/g, slice;
                 while (m = newline.exec(child.text)) {
                     if (!slice)
@@ -1074,16 +1075,49 @@ 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);
+                if (pre && !supportLinebreak)
+                    convertNewlines = false;
+                else if (!pre && supportLinebreak)
+                    convertNewlines = true;
+            }
             // Ensure all markup that isn't allowed in the new node type is cleared
-            tr.clearIncompatible(tr.mapping.slice(mapFrom).map(pos, 1), type);
+            if (convertNewlines === false)
+                replaceLinebreaks(tr, node, pos, mapFrom);
+            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;
         }
     });
 }
+function replaceNewlines(tr, node, pos, mapFrom) {
+    node.forEach((child, offset) => {
+        if (child.isText) {
+            let m, newline = /\r?\n|\r/g;
+            while (m = newline.exec(child.text)) {
+                let start = tr.mapping.slice(mapFrom).map(pos + 1 + offset + m.index);
+                tr.replaceWith(start, start + 1, node.type.schema.linebreakReplacement.create());
+            }
+        }
+    });
+}
+function replaceLinebreaks(tr, node, pos, mapFrom) {
+    node.forEach((child, offset) => {
+        if (child.type == child.type.schema.linebreakReplacement) {
+            let start = tr.mapping.slice(mapFrom).map(pos + 1 + offset);
+            tr.replaceWith(start, start + 1, node.type.schema.text("\n"));
+        }
+    });
+}
 function canChangeType(doc, pos, type) {
     let $pos = doc.resolve(pos), index = $pos.index();
     return $pos.parent.canReplaceWith(index, index + 1, type);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "prosemirror-transform",
-  "version": "1.8.0",
+  "version": "1.10.0",
   "description": "ProseMirror document transformations",
   "type": "module",
   "main": "dist/index.cjs",
@@ -24,7 +24,7 @@
     "url": "git://github.com/prosemirror/prosemirror-transform.git"
   },
   "dependencies": {
-    "prosemirror-model": "^1.0.0"
+    "prosemirror-model": "^1.21.0"
   },
   "devDependencies": {
     "@prosemirror/buildhelper": "^0.1.5",

package/src/mark.ts

@@ -72,7 +72,9 @@ export function removeMark(tr: Transform, from: number, to: number, mark?: Mark
   matched.forEach(m => tr.step(new RemoveMarkStep(m.from, m.to, m.style)))
 }
 
-export function clearIncompatible(tr: Transform, pos: number, parentType: NodeType, match = parentType.contentMatch) {
+export function clearIncompatible(tr: Transform, pos: number, parentType: NodeType,
+                                  match = parentType.contentMatch,
+                                  clearNewlines = true) {
   let node = tr.doc.nodeAt(pos)!
   let replSteps: Step[] = [], cur = pos + 1
   for (let i = 0; i < node.childCount; i++) {
@@ -85,7 +87,7 @@ export function clearIncompatible(tr: Transform, pos: number, parentType: NodeTy
       for (let j = 0; j < child.marks.length; j++) if (!parentType.allowsMarkType(child.marks[j].type))
         tr.step(new RemoveMarkStep(cur, end, child.marks[j]))
 
-      if (child.isText && !parentType.spec.code) {
+      if (clearNewlines && child.isText && parentType.whitespace != "pre") {
         let m, newline = /\r?\n|\r/g, slice
         while (m = newline.exec(child.text!)) {
           if (!slice) slice = new Slice(Fragment.from(parentType.schema.text(" ", parentType.allowedMarks(child.marks))),

package/src/replace_step.ts

@@ -134,7 +134,8 @@ export class ReplaceAroundStep extends Step {
 
   map(mapping: Mappable) {
     let from = mapping.mapResult(this.from, 1), to = mapping.mapResult(this.to, -1)
-    let gapFrom = mapping.map(this.gapFrom, -1), gapTo = mapping.map(this.gapTo, 1)
+    let gapFrom = this.from == this.gapFrom ? from.pos : mapping.map(this.gapFrom, -1)
+    let gapTo = this.to == this.gapTo ? to.pos : mapping.map(this.gapTo, 1)
     if ((from.deletedAcross && to.deletedAcross) || gapFrom < from.pos || gapTo > to.pos) return null
     return new ReplaceAroundStep(from.pos, to.pos, gapFrom, gapTo, this.slice, this.insert, this.structure)
   }

package/src/structure.ts

@@ -2,6 +2,7 @@ import {Slice, Fragment, NodeRange, NodeType, Node, Mark, Attrs, ContentMatch} f
 
 import {Transform} from "./transform"
 import {ReplaceStep, ReplaceAroundStep} from "./replace_step"
+import {clearIncompatible} from "./mark"
 
 function canCut(node: Node, start: number, end: number) {
   return (start == 0 || node.canReplace(start, node.childCount)) &&
@@ -111,22 +112,54 @@ 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)
+        if (pre && !supportLinebreak) convertNewlines = false
+        else if (!pre && supportLinebreak) convertNewlines = true
+      }
       // Ensure all markup that isn't allowed in the new node type is cleared
-      tr.clearIncompatible(tr.mapping.slice(mapFrom).map(pos, 1), type)
+      if (convertNewlines === false) replaceLinebreaks(tr, node, pos, mapFrom)
+      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))
+                                      new Slice(Fragment.from(type.create(attrsHere, null, node.marks)), 0, 0), 1, true))
+      if (convertNewlines === true) replaceNewlines(tr, node, pos, mapFrom)
       return false
     }
   })
 }
 
+function replaceNewlines(tr: Transform, node: Node, pos: number, mapFrom: number) {
+  node.forEach((child, offset) => {
+    if (child.isText) {
+      let m, newline = /\r?\n|\r/g
+      while (m = newline.exec(child.text!)) {
+        let start = tr.mapping.slice(mapFrom).map(pos + 1 + offset + m.index)
+        tr.replaceWith(start, start + 1, node.type.schema.linebreakReplacement!.create())
+      }
+    }
+  })
+}
+
+function replaceLinebreaks(tr: Transform, node: Node, pos: number, mapFrom: number) {
+  node.forEach((child, offset) => {
+    if (child.type == child.type.schema.linebreakReplacement) {
+      let start = tr.mapping.slice(mapFrom).map(pos + 1 + offset)
+      tr.replaceWith(start, start + 1, node.type.schema.text("\n"))
+    }
+  })
+}
+
 function canChangeType(doc: Node, pos: number, type: NodeType) {
   let $pos = doc.resolve(pos), index = $pos.index()
   return $pos.parent.canReplaceWith(index, index + 1, type)

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
   }