prosemirror-transform 1.5.0-beta.1 → 1.7.0

package/CHANGELOG.md

@@ -1,3 +1,27 @@
+## 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
+
+Allow replace steps to be mapped through changes that delete content next to their start and end points, as long as no delete spans across those points.
+
+### New features
+
+`MapResult` objects now provide information about whether the tokens before, after, and around the position were deleted.
+
+## 1.5.0 (2022-05-30)
+
+### New features
+
+Include TypeScript type declarations.
+
 ## 1.4.2 (2022-04-05)
 
 ### Bug fixes

package/dist/index.cjs

@@ -22,12 +22,12 @@ function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Re
 
 function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
 
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
 function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
 
 function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
 
-function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
-
 Object.defineProperty(exports, '__esModule', {
   value: true
 });
@@ -49,16 +49,44 @@ function recoverOffset(value) {
   return (value - (value & lower16)) / factor16;
 }
 
-var MapResult = _createClass(function MapResult(pos) {
-  var deleted = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
-  var recover = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : null;
+var DEL_BEFORE = 1,
+    DEL_AFTER = 2,
+    DEL_ACROSS = 4,
+    DEL_SIDE = 8;
 
-  _classCallCheck(this, MapResult);
+var MapResult = function () {
+  function MapResult(pos, delInfo, recover) {
+    _classCallCheck(this, MapResult);
 
-  this.pos = pos;
-  this.deleted = deleted;
-  this.recover = recover;
-});
+    this.pos = pos;
+    this.delInfo = delInfo;
+    this.recover = recover;
+  }
+
+  _createClass(MapResult, [{
+    key: "deleted",
+    get: function get() {
+      return (this.delInfo & DEL_SIDE) > 0;
+    }
+  }, {
+    key: "deletedBefore",
+    get: function get() {
+      return (this.delInfo & (DEL_BEFORE | DEL_ACROSS)) > 0;
+    }
+  }, {
+    key: "deletedAfter",
+    get: function get() {
+      return (this.delInfo & (DEL_AFTER | DEL_ACROSS)) > 0;
+    }
+  }, {
+    key: "deletedAcross",
+    get: function get() {
+      return (this.delInfo & DEL_ACROSS) > 0;
+    }
+  }]);
+
+  return MapResult;
+}();
 
 var StepMap = function () {
   function StepMap(ranges) {
@@ -112,13 +140,15 @@ var StepMap = function () {
           var result = start + diff + (side < 0 ? 0 : newSize);
           if (simple) return result;
           var recover = pos == (assoc < 0 ? start : end) ? null : makeRecover(i / 3, pos - start);
-          return new MapResult(result, assoc < 0 ? pos != start : pos != end, recover);
+          var del = pos == start ? DEL_AFTER : pos == end ? DEL_BEFORE : DEL_ACROSS;
+          if (assoc < 0 ? pos != start : pos != end) del |= DEL_SIDE;
+          return new MapResult(result, del, recover);
         }
 
         diff += newSize - oldSize;
       }
 
-      return simple ? pos + diff : new MapResult(pos + diff);
+      return simple ? pos + diff : new MapResult(pos + diff, 0, null);
     }
   }, {
     key: "touches",
@@ -267,7 +297,7 @@ var Mapping = function () {
   }, {
     key: "_map",
     value: function _map(pos, assoc, simple) {
-      var deleted = false;
+      var delInfo = 0;
 
       for (var i = this.from; i < this.to; i++) {
         var map = this.maps[i],
@@ -283,11 +313,11 @@ var Mapping = function () {
           }
         }
 
-        if (result.deleted) deleted = true;
+        delInfo |= result.delInfo;
         pos = result.pos;
       }
 
-      return simple ? pos : new MapResult(pos, deleted);
+      return simple ? pos : new MapResult(pos, delInfo, null);
     }
   }]);
 
@@ -521,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, [{
@@ -562,7 +722,7 @@ var ReplaceStep = function (_Step3) {
     value: function map(mapping) {
       var from = mapping.mapResult(this.from, 1),
           to = mapping.mapResult(this.to, -1);
-      if (from.deleted && to.deleted) return null;
+      if (from.deletedAcross && to.deletedAcross) return null;
       return new ReplaceStep(from.pos, Math.max(from.pos, to.pos), this.slice);
     }
   }, {
@@ -606,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, [{
@@ -657,7 +817,7 @@ var ReplaceAroundStep = function (_Step4) {
           to = mapping.mapResult(this.to, -1);
       var gapFrom = mapping.map(this.gapFrom, -1),
           gapTo = mapping.map(this.gapTo, 1);
-      if (from.deleted && to.deleted || gapFrom < from.pos || gapTo > to.pos) return null;
+      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);
     }
   }, {
@@ -1570,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);
@@ -1726,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;
@@ -1762,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

@@ -32,10 +32,25 @@ declare class MapResult {
     */
     readonly pos: number;
     /**
-    Tells you whether the position was deleted, that is, whether
-    the step removed its surroundings from the document.
+    Tells you whether the position was deleted, that is, whether the
+    step removed the token on the side queried (via the `assoc`)
+    argument from the document.
     */
-    readonly deleted: boolean;
+    get deleted(): boolean;
+    /**
+    Tells you whether the token before the mapped position was deleted.
+    */
+    get deletedBefore(): boolean;
+    /**
+    True when the token after the mapped position was deleted.
+    */
+    get deletedAfter(): boolean;
+    /**
+    Tells whether any of the steps mapped through deletes across the
+    position (including both the token before and after the
+    position).
+    */
+    get deletedAcross(): boolean;
 }
 /**
 A map describing the deletions and insertions made by a step, which
@@ -398,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.
@@ -555,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.
@@ -679,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
@@ -687,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 };