prosemirror-transform 1.6.0 → 1.7.0

package/CHANGELOG.md

@@ -1,3 +1,11 @@
+## 1.7.0 (2022-08-16)
+
+### New features
+
+The new `AttrStep` (and `Transform.setNodeAttribute`) can be used to set individual attributes on a node.
+
+`AddNodeMarkStep` and `RemoveNodeMarkStep` can now be used to add and remove marks on individual nodes. `Transform.addNodeMark`/`removeNodeMark` provide an interface to these in transform objects.
+
 ## 1.6.0 (2022-06-01)
 
 ### Bug fixes

package/dist/index.cjs

@@ -551,24 +551,154 @@ var RemoveMarkStep = function (_Step2) {
 
 Step.jsonID("removeMark", RemoveMarkStep);
 
-var ReplaceStep = function (_Step3) {
-  _inherits(ReplaceStep, _Step3);
+var AddNodeMarkStep = function (_Step3) {
+  _inherits(AddNodeMarkStep, _Step3);
 
-  var _super3 = _createSuper(ReplaceStep);
+  var _super3 = _createSuper(AddNodeMarkStep);
 
-  function ReplaceStep(from, to, slice) {
+  function AddNodeMarkStep(pos, mark) {
     var _this5;
 
+    _classCallCheck(this, AddNodeMarkStep);
+
+    _this5 = _super3.call(this);
+    _this5.pos = pos;
+    _this5.mark = mark;
+    return _this5;
+  }
+
+  _createClass(AddNodeMarkStep, [{
+    key: "apply",
+    value: function apply(doc) {
+      var node = doc.nodeAt(this.pos);
+      if (!node) return StepResult.fail("No node at mark step's position");
+      var updated = node.type.create(node.attrs, null, this.mark.addToSet(node.marks));
+      return StepResult.fromReplace(doc, this.pos, this.pos + 1, new prosemirrorModel.Slice(prosemirrorModel.Fragment.from(updated), 0, node.isLeaf ? 0 : 1));
+    }
+  }, {
+    key: "invert",
+    value: function invert(doc) {
+      var node = doc.nodeAt(this.pos);
+
+      if (node) {
+        var newSet = this.mark.addToSet(node.marks);
+
+        if (newSet.length == node.marks.length) {
+          for (var 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);
+    }
+  }, {
+    key: "map",
+    value: function map(mapping) {
+      var pos = mapping.mapResult(this.pos, 1);
+      return pos.deletedAfter ? null : new AddNodeMarkStep(pos.pos, this.mark);
+    }
+  }, {
+    key: "toJSON",
+    value: function toJSON() {
+      return {
+        stepType: "addNodeMark",
+        pos: this.pos,
+        mark: this.mark.toJSON()
+      };
+    }
+  }], [{
+    key: "fromJSON",
+    value: function 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));
+    }
+  }]);
+
+  return AddNodeMarkStep;
+}(Step);
+
+Step.jsonID("addNodeMark", AddNodeMarkStep);
+
+var RemoveNodeMarkStep = function (_Step4) {
+  _inherits(RemoveNodeMarkStep, _Step4);
+
+  var _super4 = _createSuper(RemoveNodeMarkStep);
+
+  function RemoveNodeMarkStep(pos, mark) {
+    var _this6;
+
+    _classCallCheck(this, RemoveNodeMarkStep);
+
+    _this6 = _super4.call(this);
+    _this6.pos = pos;
+    _this6.mark = mark;
+    return _this6;
+  }
+
+  _createClass(RemoveNodeMarkStep, [{
+    key: "apply",
+    value: function apply(doc) {
+      var node = doc.nodeAt(this.pos);
+      if (!node) return StepResult.fail("No node at mark step's position");
+      var updated = node.type.create(node.attrs, null, this.mark.removeFromSet(node.marks));
+      return StepResult.fromReplace(doc, this.pos, this.pos + 1, new prosemirrorModel.Slice(prosemirrorModel.Fragment.from(updated), 0, node.isLeaf ? 0 : 1));
+    }
+  }, {
+    key: "invert",
+    value: function invert(doc) {
+      var node = doc.nodeAt(this.pos);
+      if (!node || !this.mark.isInSet(node.marks)) return this;
+      return new AddNodeMarkStep(this.pos, this.mark);
+    }
+  }, {
+    key: "map",
+    value: function map(mapping) {
+      var pos = mapping.mapResult(this.pos, 1);
+      return pos.deletedAfter ? null : new RemoveNodeMarkStep(pos.pos, this.mark);
+    }
+  }, {
+    key: "toJSON",
+    value: function toJSON() {
+      return {
+        stepType: "removeNodeMark",
+        pos: this.pos,
+        mark: this.mark.toJSON()
+      };
+    }
+  }], [{
+    key: "fromJSON",
+    value: function 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));
+    }
+  }]);
+
+  return RemoveNodeMarkStep;
+}(Step);
+
+Step.jsonID("removeNodeMark", RemoveNodeMarkStep);
+
+var ReplaceStep = function (_Step5) {
+  _inherits(ReplaceStep, _Step5);
+
+  var _super5 = _createSuper(ReplaceStep);
+
+  function ReplaceStep(from, to, slice) {
+    var _this7;
+
     var structure = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : false;
 
     _classCallCheck(this, ReplaceStep);
 
-    _this5 = _super3.call(this);
-    _this5.from = from;
-    _this5.to = to;
-    _this5.slice = slice;
-    _this5.structure = structure;
-    return _this5;
+    _this7 = _super5.call(this);
+    _this7.from = from;
+    _this7.to = to;
+    _this7.slice = slice;
+    _this7.structure = structure;
+    return _this7;
   }
 
   _createClass(ReplaceStep, [{
@@ -636,27 +766,27 @@ var ReplaceStep = function (_Step3) {
 
 Step.jsonID("replace", ReplaceStep);
 
-var ReplaceAroundStep = function (_Step4) {
-  _inherits(ReplaceAroundStep, _Step4);
+var ReplaceAroundStep = function (_Step6) {
+  _inherits(ReplaceAroundStep, _Step6);
 
-  var _super4 = _createSuper(ReplaceAroundStep);
+  var _super6 = _createSuper(ReplaceAroundStep);
 
   function ReplaceAroundStep(from, to, gapFrom, gapTo, slice, insert) {
-    var _this6;
+    var _this8;
 
     var structure = arguments.length > 6 && arguments[6] !== undefined ? arguments[6] : false;
 
     _classCallCheck(this, ReplaceAroundStep);
 
-    _this6 = _super4.call(this);
-    _this6.from = from;
-    _this6.to = to;
-    _this6.gapFrom = gapFrom;
-    _this6.gapTo = gapTo;
-    _this6.slice = slice;
-    _this6.insert = insert;
-    _this6.structure = structure;
-    return _this6;
+    _this8 = _super6.call(this);
+    _this8.from = from;
+    _this8.to = to;
+    _this8.gapFrom = gapFrom;
+    _this8.gapTo = gapTo;
+    _this8.slice = slice;
+    _this8.insert = insert;
+    _this8.structure = structure;
+    return _this8;
   }
 
   _createClass(ReplaceAroundStep, [{
@@ -1600,15 +1730,86 @@ function coveredDepths($from, $to) {
   return result;
 }
 
+var AttrStep = function (_Step7) {
+  _inherits(AttrStep, _Step7);
+
+  var _super7 = _createSuper(AttrStep);
+
+  function AttrStep(pos, attr, value) {
+    var _this9;
+
+    _classCallCheck(this, AttrStep);
+
+    _this9 = _super7.call(this);
+    _this9.pos = pos;
+    _this9.attr = attr;
+    _this9.value = value;
+    return _this9;
+  }
+
+  _createClass(AttrStep, [{
+    key: "apply",
+    value: function apply(doc) {
+      var node = doc.nodeAt(this.pos);
+      if (!node) return StepResult.fail("No node at attribute step's position");
+      var attrs = Object.create(null);
+
+      for (var name in node.attrs) {
+        attrs[name] = node.attrs[name];
+      }
+
+      attrs[this.attr] = this.value;
+      var updated = node.type.create(attrs, null, node.marks);
+      return StepResult.fromReplace(doc, this.pos, this.pos + 1, new prosemirrorModel.Slice(prosemirrorModel.Fragment.from(updated), 0, node.isLeaf ? 0 : 1));
+    }
+  }, {
+    key: "getMap",
+    value: function getMap() {
+      return StepMap.empty;
+    }
+  }, {
+    key: "invert",
+    value: function invert(doc) {
+      return new AttrStep(this.pos, this.attr, doc.nodeAt(this.pos).attrs[this.attr]);
+    }
+  }, {
+    key: "map",
+    value: function map(mapping) {
+      var pos = mapping.mapResult(this.pos, 1);
+      return pos.deletedAfter ? null : new AttrStep(pos.pos, this.attr, this.value);
+    }
+  }, {
+    key: "toJSON",
+    value: function toJSON() {
+      return {
+        stepType: "attr",
+        pos: this.pos,
+        attr: this.attr,
+        value: this.value
+      };
+    }
+  }], [{
+    key: "fromJSON",
+    value: function 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);
+    }
+  }]);
+
+  return AttrStep;
+}(Step);
+
+Step.jsonID("attr", AttrStep);
+
 exports.TransformError = function (_Error) {
   _inherits(_class, _Error);
 
-  var _super5 = _createSuper(_class);
+  var _super8 = _createSuper(_class);
 
   function _class() {
     _classCallCheck(this, _class);
 
-    return _super5.apply(this, arguments);
+    return _super8.apply(this, arguments);
   }
 
   return _createClass(_class);
@@ -1756,6 +1957,31 @@ var Transform = function () {
       return this;
     }
   }, {
+    key: "setNodeAttribute",
+    value: function setNodeAttribute(pos, attr, value) {
+      this.step(new AttrStep(pos, attr, value));
+      return this;
+    }
+  }, {
+    key: "addNodeMark",
+    value: function addNodeMark(pos, mark) {
+      this.step(new AddNodeMarkStep(pos, mark));
+      return this;
+    }
+  }, {
+    key: "removeNodeMark",
+    value: function removeNodeMark(pos, mark) {
+      if (!(mark instanceof prosemirrorModel.Mark)) {
+        var 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;
+    }
+  }, {
     key: "split",
     value: function split(pos) {
       var depth = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 1;
@@ -1792,9 +2018,12 @@ var Transform = function () {
 }();
 
 exports.AddMarkStep = AddMarkStep;
+exports.AddNodeMarkStep = AddNodeMarkStep;
+exports.AttrStep = AttrStep;
 exports.MapResult = MapResult;
 exports.Mapping = Mapping;
 exports.RemoveMarkStep = RemoveMarkStep;
+exports.RemoveNodeMarkStep = RemoveNodeMarkStep;
 exports.ReplaceAroundStep = ReplaceAroundStep;
 exports.ReplaceStep = ReplaceStep;
 exports.Step = Step;

package/dist/index.d.ts

@@ -413,6 +413,19 @@ declare class Transform {
     */
     setNodeMarkup(pos: number, type?: NodeType | null, attrs?: Attrs | null, marks?: readonly Mark[]): this;
     /**
+    Set a single attribute on a given node to a new value.
+    */
+    setNodeAttribute(pos: number, attr: string, value: any): this;
+    /**
+    Add a mark to the node at position `pos`.
+    */
+    addNodeMark(pos: number, mark: Mark): this;
+    /**
+    Remove a mark (or a mark of the given type) from the node at
+    position `pos`.
+    */
+    removeNodeMark(pos: number, mark: Mark | MarkType): 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.
@@ -570,6 +583,64 @@ declare class RemoveMarkStep extends Step {
     merge(other: Step): Step | null;
     toJSON(): any;
 }
+/**
+Add a mark to a specific node.
+*/
+declare class AddNodeMarkStep extends Step {
+    /**
+    The position of the target node.
+    */
+    readonly pos: number;
+    /**
+    The mark to add.
+    */
+    readonly mark: Mark;
+    /**
+    Create a node mark step.
+    */
+    constructor(
+    /**
+    The position of the target node.
+    */
+    pos: number, 
+    /**
+    The mark to add.
+    */
+    mark: Mark);
+    apply(doc: Node): StepResult;
+    invert(doc: Node): Step;
+    map(mapping: Mappable): Step | null;
+    toJSON(): any;
+}
+/**
+Remove a mark from a specific node.
+*/
+declare class RemoveNodeMarkStep extends Step {
+    /**
+    The position of the target node.
+    */
+    readonly pos: number;
+    /**
+    The mark to remove.
+    */
+    readonly mark: Mark;
+    /**
+    Create a mark-removing step.
+    */
+    constructor(
+    /**
+    The position of the target node.
+    */
+    pos: number, 
+    /**
+    The mark to remove.
+    */
+    mark: Mark);
+    apply(doc: Node): StepResult;
+    invert(doc: Node): Step;
+    map(mapping: Mappable): Step | null;
+    toJSON(): any;
+}
 
 /**
 Replace a part of the document with a slice of new content.
@@ -694,6 +765,39 @@ declare class ReplaceAroundStep extends Step {
     toJSON(): any;
 }
 
+/**
+Update an attribute in a specific node.
+*/
+declare class AttrStep extends Step {
+    /**
+    The position of the target node.
+    */
+    readonly pos: number;
+    /**
+    The attribute to set.
+    */
+    readonly attr: string;
+    readonly value: any;
+    /**
+    Construct an attribute step.
+    */
+    constructor(
+    /**
+    The position of the target node.
+    */
+    pos: number, 
+    /**
+    The attribute to set.
+    */
+    attr: string, value: any);
+    apply(doc: Node): StepResult;
+    getMap(): StepMap;
+    invert(doc: Node): AttrStep;
+    map(mapping: Mappable): AttrStep | null;
+    toJSON(): any;
+    static fromJSON(schema: Schema, json: any): AttrStep;
+}
+
 /**
 ‘Fit’ a slice into a given position in the document, producing a
 [step](https://prosemirror.net/docs/ref/#transform.Step) that inserts it. Will return null if
@@ -702,4 +806,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, MapResult, Mappable, Mapping, RemoveMarkStep, ReplaceAroundStep, ReplaceStep, Step, StepMap, StepResult, Transform, canJoin, canSplit, dropPoint, findWrapping, insertPoint, joinPoint, liftTarget, replaceStep };
+export { AddMarkStep, AddNodeMarkStep, AttrStep, MapResult, Mappable, Mapping, RemoveMarkStep, RemoveNodeMarkStep, ReplaceAroundStep, ReplaceStep, Step, StepMap, StepResult, Transform, canJoin, canSplit, dropPoint, findWrapping, insertPoint, joinPoint, liftTarget, replaceStep };

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.
@@ -1565,6 +1672,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
 */
@@ -1767,6 +1929,36 @@ class Transform {
         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 +1998,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.0",
   "description": "ProseMirror document transformations",
   "type": "module",
   "main": "dist/index.cjs",