prosemirror-transform 1.6.0 → 1.7.1

package/dist/index.js

@@ -1,4 +1,4 @@
-import { ReplaceError, Slice, Fragment, MarkType } from 'prosemirror-model';
+import { ReplaceError, Slice, Fragment, MarkType, Mark } from 'prosemirror-model';
 
 // Recovery values encode a range index and an offset. They are
 // represented as numbers, because tons of them will be created when
@@ -555,6 +555,113 @@ class RemoveMarkStep extends Step {
     }
 }
 Step.jsonID("removeMark", RemoveMarkStep);
+/**
+Add a mark to a specific node.
+*/
+class AddNodeMarkStep extends Step {
+    /**
+    Create a node mark step.
+    */
+    constructor(
+    /**
+    The position of the target node.
+    */
+    pos, 
+    /**
+    The mark to add.
+    */
+    mark) {
+        super();
+        this.pos = pos;
+        this.mark = mark;
+    }
+    apply(doc) {
+        let node = doc.nodeAt(this.pos);
+        if (!node)
+            return StepResult.fail("No node at mark step's position");
+        let updated = node.type.create(node.attrs, null, this.mark.addToSet(node.marks));
+        return StepResult.fromReplace(doc, this.pos, this.pos + 1, new Slice(Fragment.from(updated), 0, node.isLeaf ? 0 : 1));
+    }
+    invert(doc) {
+        let node = doc.nodeAt(this.pos);
+        if (node) {
+            let newSet = this.mark.addToSet(node.marks);
+            if (newSet.length == node.marks.length) {
+                for (let i = 0; i < node.marks.length; i++)
+                    if (!node.marks[i].isInSet(newSet))
+                        return new AddNodeMarkStep(this.pos, node.marks[i]);
+                return new AddNodeMarkStep(this.pos, this.mark);
+            }
+        }
+        return new RemoveNodeMarkStep(this.pos, this.mark);
+    }
+    map(mapping) {
+        let pos = mapping.mapResult(this.pos, 1);
+        return pos.deletedAfter ? null : new AddNodeMarkStep(pos.pos, this.mark);
+    }
+    toJSON() {
+        return { stepType: "addNodeMark", pos: this.pos, mark: this.mark.toJSON() };
+    }
+    /**
+    @internal
+    */
+    static fromJSON(schema, json) {
+        if (typeof json.pos != "number")
+            throw new RangeError("Invalid input for AddNodeMarkStep.fromJSON");
+        return new AddNodeMarkStep(json.pos, schema.markFromJSON(json.mark));
+    }
+}
+Step.jsonID("addNodeMark", AddNodeMarkStep);
+/**
+Remove a mark from a specific node.
+*/
+class RemoveNodeMarkStep extends Step {
+    /**
+    Create a mark-removing step.
+    */
+    constructor(
+    /**
+    The position of the target node.
+    */
+    pos, 
+    /**
+    The mark to remove.
+    */
+    mark) {
+        super();
+        this.pos = pos;
+        this.mark = mark;
+    }
+    apply(doc) {
+        let node = doc.nodeAt(this.pos);
+        if (!node)
+            return StepResult.fail("No node at mark step's position");
+        let updated = node.type.create(node.attrs, null, this.mark.removeFromSet(node.marks));
+        return StepResult.fromReplace(doc, this.pos, this.pos + 1, new Slice(Fragment.from(updated), 0, node.isLeaf ? 0 : 1));
+    }
+    invert(doc) {
+        let node = doc.nodeAt(this.pos);
+        if (!node || !this.mark.isInSet(node.marks))
+            return this;
+        return new AddNodeMarkStep(this.pos, this.mark);
+    }
+    map(mapping) {
+        let pos = mapping.mapResult(this.pos, 1);
+        return pos.deletedAfter ? null : new RemoveNodeMarkStep(pos.pos, this.mark);
+    }
+    toJSON() {
+        return { stepType: "removeNodeMark", pos: this.pos, mark: this.mark.toJSON() };
+    }
+    /**
+    @internal
+    */
+    static fromJSON(schema, json) {
+        if (typeof json.pos != "number")
+            throw new RangeError("Invalid input for RemoveNodeMarkStep.fromJSON");
+        return new RemoveNodeMarkStep(json.pos, schema.markFromJSON(json.mark));
+    }
+}
+Step.jsonID("removeNodeMark", RemoveNodeMarkStep);
 
 /**
 Replace a part of the document with a slice of new content.
@@ -1225,10 +1332,21 @@ class Fitter {
     // content that can be moved somewhere on the frontier. Returns two
     // depths, one for the slice and one for the frontier.
     findFittable() {
+        let startDepth = this.unplaced.openStart;
+        for (let cur = this.unplaced.content, d = 0, openEnd = this.unplaced.openEnd; d < startDepth; d++) {
+            let node = cur.firstChild;
+            if (cur.childCount > 1)
+                openEnd = 0;
+            if (node.type.spec.isolating && openEnd <= d) {
+                startDepth = d;
+                break;
+            }
+            cur = node.content;
+        }
         // Only try wrapping nodes (pass 2) after finding a place without
         // wrapping failed.
         for (let pass = 1; pass <= 2; pass++) {
-            for (let sliceDepth = this.unplaced.openStart; sliceDepth >= 0; sliceDepth--) {
+            for (let sliceDepth = pass == 1 ? startDepth : this.unplaced.openStart; sliceDepth >= 0; sliceDepth--) {
                 let fragment, parent = null;
                 if (sliceDepth) {
                     parent = contentAt(this.unplaced.content, sliceDepth - 1).firstChild;
@@ -1565,6 +1683,61 @@ function coveredDepths($from, $to) {
     return result;
 }
 
+/**
+Update an attribute in a specific node.
+*/
+class AttrStep extends Step {
+    /**
+    Construct an attribute step.
+    */
+    constructor(
+    /**
+    The position of the target node.
+    */
+    pos, 
+    /**
+    The attribute to set.
+    */
+    attr, 
+    // The attribute's new value.
+    value) {
+        super();
+        this.pos = pos;
+        this.attr = attr;
+        this.value = value;
+    }
+    apply(doc) {
+        let node = doc.nodeAt(this.pos);
+        if (!node)
+            return StepResult.fail("No node at attribute step's position");
+        let attrs = Object.create(null);
+        for (let name in node.attrs)
+            attrs[name] = node.attrs[name];
+        attrs[this.attr] = this.value;
+        let updated = node.type.create(attrs, null, node.marks);
+        return StepResult.fromReplace(doc, this.pos, this.pos + 1, new Slice(Fragment.from(updated), 0, node.isLeaf ? 0 : 1));
+    }
+    getMap() {
+        return StepMap.empty;
+    }
+    invert(doc) {
+        return new AttrStep(this.pos, this.attr, doc.nodeAt(this.pos).attrs[this.attr]);
+    }
+    map(mapping) {
+        let pos = mapping.mapResult(this.pos, 1);
+        return pos.deletedAfter ? null : new AttrStep(pos.pos, this.attr, this.value);
+    }
+    toJSON() {
+        return { stepType: "attr", pos: this.pos, attr: this.attr, value: this.value };
+    }
+    static fromJSON(schema, json) {
+        if (typeof json.pos != "number" || typeof json.attr != "string")
+            throw new RangeError("Invalid input for AttrStep.fromJSON");
+        return new AttrStep(json.pos, json.attr, json.value);
+    }
+}
+Step.jsonID("attr", AttrStep);
+
 /**
 @internal
 */
@@ -1762,11 +1935,41 @@ class Transform {
     Change the type, attributes, and/or marks of the node at `pos`.
     When `type` isn't given, the existing node type is preserved,
     */
-    setNodeMarkup(pos, type, attrs = null, marks = []) {
+    setNodeMarkup(pos, type, attrs = null, marks) {
         setNodeMarkup(this, pos, type, attrs, marks);
         return this;
     }
     /**
+    Set a single attribute on a given node to a new value.
+    */
+    setNodeAttribute(pos, attr, value) {
+        this.step(new AttrStep(pos, attr, value));
+        return this;
+    }
+    /**
+    Add a mark to the node at position `pos`.
+    */
+    addNodeMark(pos, mark) {
+        this.step(new AddNodeMarkStep(pos, mark));
+        return this;
+    }
+    /**
+    Remove a mark (or a mark of the given type) from the node at
+    position `pos`.
+    */
+    removeNodeMark(pos, mark) {
+        if (!(mark instanceof Mark)) {
+            let node = this.doc.nodeAt(pos);
+            if (!node)
+                throw new RangeError("No node at position " + pos);
+            mark = mark.isInSet(node.marks);
+            if (!mark)
+                return this;
+        }
+        this.step(new RemoveNodeMarkStep(pos, mark));
+        return this;
+    }
+    /**
     Split the node at the given position, and optionally, if `depth` is
     greater than one, any number of nodes above that. By default, the
     parts split off will inherit the node type of the original node.
@@ -1806,4 +2009,4 @@ class Transform {
     }
 }
 
-export { AddMarkStep, MapResult, Mapping, RemoveMarkStep, ReplaceAroundStep, ReplaceStep, Step, StepMap, StepResult, Transform, TransformError, canJoin, canSplit, dropPoint, findWrapping, insertPoint, joinPoint, liftTarget, replaceStep };
+export { AddMarkStep, AddNodeMarkStep, AttrStep, MapResult, Mapping, RemoveMarkStep, RemoveNodeMarkStep, ReplaceAroundStep, ReplaceStep, Step, StepMap, StepResult, Transform, TransformError, canJoin, canSplit, dropPoint, findWrapping, insertPoint, joinPoint, liftTarget, replaceStep };

package/package.json

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

package/src/README.md

@@ -20,6 +20,9 @@ called a [`Transform`](#transform.Transform).
 @ReplaceAroundStep
 @AddMarkStep
 @RemoveMarkStep
+@AddNodeMarkStep
+@RemoveNodeMarkStep
+@AttrStep
 
 ### Position Mapping
 

package/src/attr_step.ts

@@ -0,0 +1,53 @@
+import {Fragment, Slice, Node, Schema} from "prosemirror-model"
+import {Step, StepResult} from "./step"
+import {StepMap, Mappable} from "./map"
+
+/// Update an attribute in a specific node.
+export class AttrStep extends Step {
+  /// Construct an attribute step.
+  constructor(
+    /// The position of the target node.
+    readonly pos: number,
+    /// The attribute to set.
+    readonly attr: string,
+    // The attribute's new value.
+    readonly value: any
+  ) {
+    super()
+  }
+
+  apply(doc: Node) {
+    let node = doc.nodeAt(this.pos)
+    if (!node) return StepResult.fail("No node at attribute step's position")
+    let attrs = Object.create(null)
+    for (let name in node.attrs) attrs[name] = node.attrs[name]
+    attrs[this.attr] = this.value
+    let updated = node.type.create(attrs, null, node.marks)
+    return StepResult.fromReplace(doc, this.pos, this.pos + 1, new Slice(Fragment.from(updated), 0, node.isLeaf ? 0 : 1))
+  }
+
+  getMap() {
+    return StepMap.empty
+  }
+
+  invert(doc: Node) {
+    return new AttrStep(this.pos, this.attr, doc.nodeAt(this.pos)!.attrs[this.attr])
+  }
+
+  map(mapping: Mappable) {
+    let pos = mapping.mapResult(this.pos, 1)
+    return pos.deletedAfter ? null : new AttrStep(pos.pos, this.attr, this.value)
+  }
+
+  toJSON(): any {
+    return {stepType: "attr", pos: this.pos, attr: this.attr, value: this.value}
+  }
+
+  static fromJSON(schema: Schema, json: any) {
+    if (typeof json.pos != "number" || typeof json.attr != "string")
+      throw new RangeError("Invalid input for AttrStep.fromJSON")
+    return new AttrStep(json.pos, json.attr, json.value)
+  }
+}
+
+Step.jsonID("attr", AttrStep)

package/src/index.ts

@@ -4,7 +4,8 @@ export {TransformError} from "./transform"
 export {Step, StepResult} from "./step"
 export {joinPoint, canJoin, canSplit, insertPoint, dropPoint, liftTarget, findWrapping} from "./structure"
 export {StepMap, MapResult, Mapping, Mappable} from "./map"
-export {AddMarkStep, RemoveMarkStep} from "./mark_step"
+export {AddMarkStep, RemoveMarkStep, AddNodeMarkStep, RemoveNodeMarkStep} from "./mark_step"
 export {ReplaceStep, ReplaceAroundStep} from "./replace_step"
+export {AttrStep} from "./attr_step"
 import "./mark"
 export {replaceStep} from "./replace"

package/src/mark_step.ts

@@ -126,3 +126,99 @@ export class RemoveMarkStep extends Step {
 }
 
 Step.jsonID("removeMark", RemoveMarkStep)
+
+/// Add a mark to a specific node.
+export class AddNodeMarkStep extends Step {
+  /// Create a node mark step.
+  constructor(
+    /// The position of the target node.
+    readonly pos: number,
+    /// The mark to add.
+    readonly mark: Mark
+  ) {
+    super()
+  }
+
+  apply(doc: Node) {
+    let node = doc.nodeAt(this.pos)
+    if (!node) return StepResult.fail("No node at mark step's position")
+    let updated = node.type.create(node.attrs, null, this.mark.addToSet(node.marks))
+    return StepResult.fromReplace(doc, this.pos, this.pos + 1, new Slice(Fragment.from(updated), 0, node.isLeaf ? 0 : 1))
+  }
+
+  invert(doc: Node): Step {
+    let node = doc.nodeAt(this.pos)
+    if (node) {
+      let newSet = this.mark.addToSet(node.marks)
+      if (newSet.length == node.marks.length) {
+        for (let i = 0; i < node.marks.length; i++)
+          if (!node.marks[i].isInSet(newSet))
+            return new AddNodeMarkStep(this.pos, node.marks[i])
+        return new AddNodeMarkStep(this.pos, this.mark)
+      }
+    }
+    return new RemoveNodeMarkStep(this.pos, this.mark)
+  }
+
+  map(mapping: Mappable): Step | null {
+    let pos = mapping.mapResult(this.pos, 1)
+    return pos.deletedAfter ? null : new AddNodeMarkStep(pos.pos, this.mark)
+  }
+
+  toJSON(): any {
+    return {stepType: "addNodeMark", pos: this.pos, mark: this.mark.toJSON()}
+  }
+
+  /// @internal
+  static fromJSON(schema: Schema, json: any) {
+    if (typeof json.pos != "number")
+      throw new RangeError("Invalid input for AddNodeMarkStep.fromJSON")
+    return new AddNodeMarkStep(json.pos, schema.markFromJSON(json.mark))
+  }
+}
+
+Step.jsonID("addNodeMark", AddNodeMarkStep)
+
+/// Remove a mark from a specific node.
+export class RemoveNodeMarkStep extends Step {
+  /// Create a mark-removing step.
+  constructor(
+    /// The position of the target node.
+    readonly pos: number,
+    /// The mark to remove.
+    readonly mark: Mark
+  ) {
+    super()
+  }
+
+  apply(doc: Node) {
+    let node = doc.nodeAt(this.pos)
+    if (!node) return StepResult.fail("No node at mark step's position")
+    let updated = node.type.create(node.attrs, null, this.mark.removeFromSet(node.marks))
+    return StepResult.fromReplace(doc, this.pos, this.pos + 1, new Slice(Fragment.from(updated), 0, node.isLeaf ? 0 : 1))
+  }
+
+  invert(doc: Node): Step {
+    let node = doc.nodeAt(this.pos)
+    if (!node || !this.mark.isInSet(node.marks)) return this
+    return new AddNodeMarkStep(this.pos, this.mark)
+  }
+
+  map(mapping: Mappable): Step | null {
+    let pos = mapping.mapResult(this.pos, 1)
+    return pos.deletedAfter ? null : new RemoveNodeMarkStep(pos.pos, this.mark)
+  }
+
+  toJSON(): any {
+    return {stepType: "removeNodeMark", pos: this.pos, mark: this.mark.toJSON()}
+  }
+
+  /// @internal
+  static fromJSON(schema: Schema, json: any) {
+    if (typeof json.pos != "number")
+      throw new RangeError("Invalid input for RemoveNodeMarkStep.fromJSON")
+    return new RemoveNodeMarkStep(json.pos, schema.markFromJSON(json.mark))
+  }
+}
+
+Step.jsonID("removeNodeMark", RemoveNodeMarkStep)

package/src/replace.ts

@@ -110,10 +110,21 @@ class Fitter {
   // content that can be moved somewhere on the frontier. Returns two
   // depths, one for the slice and one for the frontier.
   findFittable(): Fittable | undefined {
+    let startDepth = this.unplaced.openStart
+    for (let cur = this.unplaced.content, d = 0, openEnd = this.unplaced.openEnd; d < startDepth; d++) {
+      let node = cur.firstChild!
+      if (cur.childCount > 1) openEnd = 0
+      if (node.type.spec.isolating && openEnd <= d) {
+        startDepth = d
+        break
+      }
+      cur = node.content
+    }
+
     // Only try wrapping nodes (pass 2) after finding a place without
     // wrapping failed.
     for (let pass = 1; pass <= 2; pass++) {
-      for (let sliceDepth = this.unplaced.openStart; sliceDepth >= 0; sliceDepth--) {
+      for (let sliceDepth = pass == 1 ? startDepth : this.unplaced.openStart; sliceDepth >= 0; sliceDepth--) {
         let fragment, parent = null
         if (sliceDepth) {
           parent = contentAt(this.unplaced.content, sliceDepth - 1).firstChild

package/src/structure.ts

@@ -135,7 +135,7 @@ function canChangeType(doc: Node, pos: number, type: NodeType) {
 /// Change the type, attributes, and/or marks of the node at `pos`.
 /// When `type` isn't given, the existing node type is preserved,
 export function setNodeMarkup(tr: Transform, pos: number, type: NodeType | undefined | null,
-                              attrs: Attrs | null, marks: readonly Mark[]) {
+                              attrs: Attrs | null, marks: readonly Mark[] | undefined) {
   let node = tr.doc.nodeAt(pos)
   if (!node) throw new RangeError("No node at given position")
   if (!type) type = node.type

package/src/transform.ts

@@ -5,6 +5,8 @@ import {Step} from "./step"
 import {addMark, removeMark, clearIncompatible} from "./mark"
 import {replaceStep, replaceRange, replaceRangeWith, deleteRange} from "./replace"
 import {lift, wrap, setBlockType, setNodeMarkup, split, join} from "./structure"
+import {AttrStep} from "./attr_step"
+import {AddNodeMarkStep, RemoveNodeMarkStep} from "./mark_step"
 
 /// @internal
 export let TransformError = class extends Error {}
@@ -171,11 +173,36 @@ export class Transform {
 
   /// Change the type, attributes, and/or marks of the node at `pos`.
   /// When `type` isn't given, the existing node type is preserved,
-  setNodeMarkup(pos: number, type?: NodeType | null, attrs: Attrs | null = null, marks: readonly Mark[] = []): this {
+  setNodeMarkup(pos: number, type?: NodeType | null, attrs: Attrs | null = null, marks?: readonly Mark[]): this {
     setNodeMarkup(this, pos, type, attrs, marks)
     return this
   }
 
+  /// Set a single attribute on a given node to a new value.
+  setNodeAttribute(pos: number, attr: string, value: any): this {
+    this.step(new AttrStep(pos, attr, value))
+    return this
+  }
+
+  /// Add a mark to the node at position `pos`.
+  addNodeMark(pos: number, mark: Mark): this {
+    this.step(new AddNodeMarkStep(pos, mark))
+    return this
+  }
+
+  /// Remove a mark (or a mark of the given type) from the node at
+  /// position `pos`.
+  removeNodeMark(pos: number, mark: Mark | MarkType): this {
+    if (!(mark instanceof Mark)) {
+      let node = this.doc.nodeAt(pos)
+      if (!node) throw new RangeError("No node at position " + pos)
+      mark = mark.isInSet(node.marks)!
+      if (!mark) return this
+    }
+    this.step(new RemoveNodeMarkStep(pos, mark))
+    return this
+  }
+
   /// Split the node at the given position, and optionally, if `depth` is
   /// greater than one, any number of nodes above that. By default, the
   /// parts split off will inherit the node type of the original node.