prosemirror-transform 1.4.0 → 1.5.0-beta.1

package/package.json

@@ -1,9 +1,16 @@
 {
   "name": "prosemirror-transform",
-  "version": "1.4.0",
+  "version": "1.5.0-beta.1",
   "description": "ProseMirror document transformations",
-  "main": "dist/index.js",
-  "module": "dist/index.es.js",
+  "type": "module",
+  "main": "dist/index.cjs",
+  "module": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    "import": "./dist/index.js",
+    "require": "./dist/index.cjs"
+  },
+  "sideEffects": false,
   "license": "MIT",
   "maintainers": [
     {
@@ -20,16 +27,11 @@
     "prosemirror-model": "^1.0.0"
   },
   "devDependencies": {
-    "mocha": "^9.1.2",
-    "ist": "^1.0.0",
-    "prosemirror-test-builder": "^1.0.0",
-    "rollup": "^2.26.3",
-    "@rollup/plugin-buble": "^0.21.3"
+    "@prosemirror/buildhelper": "^0.1.5",
+    "prosemirror-test-builder": "^1.0.0"
   },
   "scripts": {
-    "test": "mocha test/test-*.js",
-    "build": "rollup -c",
-    "watch": "rollup -c -w",
-    "prepare": "npm run build"
+    "test": "pm-runtests",
+    "prepare": "pm-buildhelper src/index.ts"
   }
 }

package/src/{index.js → index.ts}

@@ -1,7 +1,9 @@
-export {Transform, TransformError} from "./transform"
+export {Transform} from "./transform"
+/// @internal
+export {TransformError} from "./transform"
 export {Step, StepResult} from "./step"
 export {joinPoint, canJoin, canSplit, insertPoint, dropPoint, liftTarget, findWrapping} from "./structure"
-export {StepMap, MapResult, Mapping} from "./map"
+export {StepMap, MapResult, Mapping, Mappable} from "./map"
 export {AddMarkStep, RemoveMarkStep} from "./mark_step"
 export {ReplaceStep, ReplaceAroundStep} from "./replace_step"
 import "./mark"

package/src/map.ts

@@ -0,0 +1,256 @@
+/// There are several things that positions can be mapped through.
+/// Such objects conform to this interface.
+export interface Mappable {
+  /// Map a position through this object. When given, `assoc` (should
+  /// be -1 or 1, defaults to 1) determines with which side the
+  /// position is associated, which determines in which direction to
+  /// move when a chunk of content is inserted at the mapped position.
+  map: (pos: number, assoc?: number) => number
+
+  /// Map a position, and return an object containing additional
+  /// information about the mapping. The result's `deleted` field tells
+  /// you whether the position was deleted (completely enclosed in a
+  /// replaced range) during the mapping. When content on only one side
+  /// is deleted, the position itself is only considered deleted when
+  /// `assoc` points in the direction of the deleted content.
+  mapResult: (pos: number, assoc?: number) => MapResult
+}
+
+// Recovery values encode a range index and an offset. They are
+// represented as numbers, because tons of them will be created when
+// mapping, for example, a large number of decorations. The number's
+// lower 16 bits provide the index, the remaining bits the offset.
+//
+// Note: We intentionally don't use bit shift operators to en- and
+// decode these, since those clip to 32 bits, which we might in rare
+// cases want to overflow. A 64-bit float can represent 48-bit
+// integers precisely.
+
+const lower16 = 0xffff
+const factor16 = Math.pow(2, 16)
+
+function makeRecover(index: number, offset: number) { return index + offset * factor16 }
+function recoverIndex(value: number) { return value & lower16 }
+function recoverOffset(value: number) { return (value - (value & lower16)) / factor16 }
+
+/// An object representing a mapped position with extra
+/// information.
+export class MapResult {
+  /// @internal
+  constructor(
+    /// The mapped version of the position.
+    readonly pos: number,
+    /// Tells you whether the position was deleted, that is, whether
+    /// the step removed its surroundings from the document.
+    readonly deleted: boolean = false,
+    /// @internal
+    readonly recover: number | null = null
+  ) {}
+}
+
+/// A map describing the deletions and insertions made by a step, which
+/// can be used to find the correspondence between positions in the
+/// pre-step version of a document and the same position in the
+/// post-step version.
+export class StepMap implements Mappable {
+  /// Create a position map. The modifications to the document are
+  /// represented as an array of numbers, in which each group of three
+  /// represents a modified chunk as `[start, oldSize, newSize]`.
+  constructor(
+    /// @internal
+    readonly ranges: readonly number[],
+    /// @internal
+    readonly inverted = false
+  ) {
+    if (!ranges.length && StepMap.empty) return StepMap.empty
+  }
+
+  /// @internal
+  recover(value: number) {
+    let diff = 0, index = recoverIndex(value)
+    if (!this.inverted) for (let i = 0; i < index; i++)
+      diff += this.ranges[i * 3 + 2] - this.ranges[i * 3 + 1]
+    return this.ranges[index * 3] + diff + recoverOffset(value)
+  }
+
+  mapResult(pos: number, assoc = 1): MapResult { return this._map(pos, assoc, false) as MapResult }
+
+  map(pos: number, assoc = 1): number { return this._map(pos, assoc, true) as number }
+
+  /// @internal
+  _map(pos: number, assoc: number, simple: boolean) {
+    let diff = 0, oldIndex = this.inverted ? 2 : 1, newIndex = this.inverted ? 1 : 2
+    for (let i = 0; i < this.ranges.length; i += 3) {
+      let start = this.ranges[i] - (this.inverted ? diff : 0)
+      if (start > pos) break
+      let oldSize = this.ranges[i + oldIndex], newSize = this.ranges[i + newIndex], end = start + oldSize
+      if (pos <= end) {
+        let side = !oldSize ? assoc : pos == start ? -1 : pos == end ? 1 : assoc
+        let result = start + diff + (side < 0 ? 0 : newSize)
+        if (simple) return result
+        let recover = pos == (assoc < 0 ? start : end) ? null : makeRecover(i / 3, pos - start)
+        return new MapResult(result, assoc < 0 ? pos != start : pos != end, recover)
+      }
+      diff += newSize - oldSize
+    }
+    return simple ? pos + diff : new MapResult(pos + diff)
+  }
+
+  /// @internal
+  touches(pos: number, recover: number) {
+    let diff = 0, index = recoverIndex(recover)
+    let oldIndex = this.inverted ? 2 : 1, newIndex = this.inverted ? 1 : 2
+    for (let i = 0; i < this.ranges.length; i += 3) {
+      let start = this.ranges[i] - (this.inverted ? diff : 0)
+      if (start > pos) break
+      let oldSize = this.ranges[i + oldIndex], end = start + oldSize
+      if (pos <= end && i == index * 3) return true
+      diff += this.ranges[i + newIndex] - oldSize
+    }
+    return false
+  }
+
+  /// Calls the given function on each of the changed ranges included in
+  /// this map.
+  forEach(f: (oldStart: number, oldEnd: number, newStart: number, newEnd: number) => void) {
+    let oldIndex = this.inverted ? 2 : 1, newIndex = this.inverted ? 1 : 2
+    for (let i = 0, diff = 0; i < this.ranges.length; i += 3) {
+      let start = this.ranges[i], oldStart = start - (this.inverted ? diff : 0), newStart = start + (this.inverted ? 0 : diff)
+      let oldSize = this.ranges[i + oldIndex], newSize = this.ranges[i + newIndex]
+      f(oldStart, oldStart + oldSize, newStart, newStart + newSize)
+      diff += newSize - oldSize
+    }
+  }
+
+  /// Create an inverted version of this map. The result can be used to
+  /// map positions in the post-step document to the pre-step document.
+  invert() {
+    return new StepMap(this.ranges, !this.inverted)
+  }
+
+  /// @internal
+  toString() {
+    return (this.inverted ? "-" : "") + JSON.stringify(this.ranges)
+  }
+
+  /// Create a map that moves all positions by offset `n` (which may be
+  /// negative). This can be useful when applying steps meant for a
+  /// sub-document to a larger document, or vice-versa.
+  static offset(n: number) {
+    return n == 0 ? StepMap.empty : new StepMap(n < 0 ? [0, -n, 0] : [0, 0, n])
+  }
+
+  /// A StepMap that contains no changed ranges.
+  static empty = new StepMap([])
+}
+
+/// A mapping represents a pipeline of zero or more [step
+/// maps](#transform.StepMap). It has special provisions for losslessly
+/// handling mapping positions through a series of steps in which some
+/// steps are inverted versions of earlier steps. (This comes up when
+/// ‘[rebasing](/docs/guide/#transform.rebasing)’ steps for
+/// collaboration or history management.)
+export class Mapping implements Mappable {
+  /// Create a new mapping with the given position maps.
+  constructor(
+    /// The step maps in this mapping.
+    readonly maps: StepMap[] = [],
+    /// @internal
+    public mirror?: number[],
+    /// The starting position in the `maps` array, used when `map` or
+    /// `mapResult` is called.
+    public from = 0,
+    /// The end position in the `maps` array.
+    public to = maps.length
+  ) {}
+
+  /// Create a mapping that maps only through a part of this one.
+  slice(from = 0, to = this.maps.length) {
+    return new Mapping(this.maps, this.mirror, from, to)
+  }
+
+  /// @internal
+  copy() {
+    return new Mapping(this.maps.slice(), this.mirror && this.mirror.slice(), this.from, this.to)
+  }
+
+  /// Add a step map to the end of this mapping. If `mirrors` is
+  /// given, it should be the index of the step map that is the mirror
+  /// image of this one.
+  appendMap(map: StepMap, mirrors?: number) {
+    this.to = this.maps.push(map)
+    if (mirrors != null) this.setMirror(this.maps.length - 1, mirrors)
+  }
+
+  /// Add all the step maps in a given mapping to this one (preserving
+  /// mirroring information).
+  appendMapping(mapping: Mapping) {
+    for (let i = 0, startSize = this.maps.length; i < mapping.maps.length; i++) {
+      let mirr = mapping.getMirror(i)
+      this.appendMap(mapping.maps[i], mirr != null && mirr < i ? startSize + mirr : undefined)
+    }
+  }
+
+  /// Finds the offset of the step map that mirrors the map at the
+  /// given offset, in this mapping (as per the second argument to
+  /// `appendMap`).
+  getMirror(n: number): number | undefined {
+    if (this.mirror) for (let i = 0; i < this.mirror.length; i++)
+      if (this.mirror[i] == n) return this.mirror[i + (i % 2 ? -1 : 1)]
+  }
+
+  /// @internal
+  setMirror(n: number, m: number) {
+    if (!this.mirror) this.mirror = []
+    this.mirror.push(n, m)
+  }
+
+  /// Append the inverse of the given mapping to this one.
+  appendMappingInverted(mapping: Mapping) {
+    for (let i = mapping.maps.length - 1, totalSize = this.maps.length + mapping.maps.length; i >= 0; i--) {
+      let mirr = mapping.getMirror(i)
+      this.appendMap(mapping.maps[i].invert(), mirr != null && mirr > i ? totalSize - mirr - 1 : undefined)
+    }
+  }
+
+  /// Create an inverted version of this mapping.
+  invert() {
+    let inverse = new Mapping
+    inverse.appendMappingInverted(this)
+    return inverse
+  }
+
+  /// Map a position through this mapping.
+  map(pos: number, assoc = 1) {
+    if (this.mirror) return this._map(pos, assoc, true) as number
+    for (let i = this.from; i < this.to; i++)
+      pos = this.maps[i].map(pos, assoc)
+    return pos
+  }
+
+  /// Map a position through this mapping, returning a mapping
+  /// result.
+  mapResult(pos: number, assoc = 1) { return this._map(pos, assoc, false) as MapResult }
+
+  /// @internal
+  _map(pos: number, assoc: number, simple: boolean) {
+    let deleted = false
+
+    for (let i = this.from; i < this.to; i++) {
+      let map = this.maps[i], result = map.mapResult(pos, assoc)
+      if (result.recover != null) {
+        let corr = this.getMirror(i)
+        if (corr != null && corr > i && corr < this.to) {
+          i = corr
+          pos = this.maps[corr].recover(result.recover)
+          continue
+        }
+      }
+
+      if (result.deleted) deleted = true
+      pos = result.pos
+    }
+
+    return simple ? pos : new MapResult(pos, deleted)
+  }
+}

package/src/{mark.js → mark.ts}

@@ -1,49 +1,43 @@
-import {MarkType, Slice, Fragment} from "prosemirror-model"
+import {Mark, MarkType, Slice, Fragment, NodeType} from "prosemirror-model"
 
+import {Step} from "./step"
 import {Transform} from "./transform"
 import {AddMarkStep, RemoveMarkStep} from "./mark_step"
 import {ReplaceStep} from "./replace_step"
 
-// :: (number, number, Mark) → this
-// Add the given mark to the inline content between `from` and `to`.
-Transform.prototype.addMark = function(from, to, mark) {
-  let removed = [], added = [], removing = null, adding = null
-  this.doc.nodesBetween(from, to, (node, pos, parent) => {
+export function addMark(tr: Transform, from: number, to: number, mark: Mark) {
+  let removed: Step[] = [], added: Step[] = []
+  let removing: RemoveMarkStep | undefined, adding: AddMarkStep | undefined
+  tr.doc.nodesBetween(from, to, (node, pos, parent) => {
     if (!node.isInline) return
     let marks = node.marks
-    if (!mark.isInSet(marks) && parent.type.allowsMarkType(mark.type)) {
+    if (!mark.isInSet(marks) && parent!.type.allowsMarkType(mark.type)) {
       let start = Math.max(pos, from), end = Math.min(pos + node.nodeSize, to)
       let newSet = mark.addToSet(marks)
 
       for (let i = 0; i < marks.length; i++) {
         if (!marks[i].isInSet(newSet)) {
           if (removing && removing.to == start && removing.mark.eq(marks[i]))
-            removing.to = end
+            (removing as any).to = end
           else
             removed.push(removing = new RemoveMarkStep(start, end, marks[i]))
         }
       }
 
       if (adding && adding.to == start)
-        adding.to = end
+        (adding as any).to = end
       else
         added.push(adding = new AddMarkStep(start, end, mark))
     }
   })
 
-  removed.forEach(s => this.step(s))
-  added.forEach(s => this.step(s))
-  return this
+  removed.forEach(s => tr.step(s))
+  added.forEach(s => tr.step(s))
 }
 
-// :: (number, number, ?union<Mark, MarkType>) → this
-// Remove marks from inline nodes between `from` and `to`. When `mark`
-// is a single mark, remove precisely that mark. When it is a mark type,
-// remove all marks of that type. When it is null, remove all marks of
-// any type.
-Transform.prototype.removeMark = function(from, to, mark = null) {
-  let matched = [], step = 0
-  this.doc.nodesBetween(from, to, (node, pos) => {
+export function removeMark(tr: Transform, from: number, to: number, mark?: Mark | MarkType | null) {
+  let matched: {style: Mark, from: number, to: number, step: number}[] = [], step = 0
+  tr.doc.nodesBetween(from, to, (node, pos) => {
     if (!node.isInline) return
     step++
     let toRemove = null
@@ -75,34 +69,27 @@ Transform.prototype.removeMark = function(from, to, mark = null) {
       }
     }
   })
-  matched.forEach(m => this.step(new RemoveMarkStep(m.from, m.to, m.style)))
-  return this
+  matched.forEach(m => tr.step(new RemoveMarkStep(m.from, m.to, m.style)))
 }
 
-// :: (number, NodeType, ?ContentMatch) → this
-// Removes all marks and nodes from the content of the node at `pos`
-// that don't match the given new parent node type. Accepts an
-// optional starting [content match](#model.ContentMatch) as third
-// argument.
-Transform.prototype.clearIncompatible = function(pos, parentType, match = parentType.contentMatch) {
-  let node = this.doc.nodeAt(pos)
-  let delSteps = [], cur = pos + 1
+export function clearIncompatible(tr: Transform, pos: number, parentType: NodeType, match = parentType.contentMatch) {
+  let node = tr.doc.nodeAt(pos)!
+  let delSteps: Step[] = [], cur = pos + 1
   for (let i = 0; i < node.childCount; i++) {
     let child = node.child(i), end = cur + child.nodeSize
-    let allowed = match.matchType(child.type, child.attrs)
+    let allowed = match.matchType(child.type)
     if (!allowed) {
       delSteps.push(new ReplaceStep(cur, end, Slice.empty))
     } else {
       match = allowed
       for (let j = 0; j < child.marks.length; j++) if (!parentType.allowsMarkType(child.marks[j].type))
-        this.step(new RemoveMarkStep(cur, end, child.marks[j]))
+        tr.step(new RemoveMarkStep(cur, end, child.marks[j]))
     }
     cur = end
   }
   if (!match.validEnd) {
     let fill = match.fillBefore(Fragment.empty, true)
-    this.replace(cur, cur, new Slice(fill, 0, 0))
+    tr.replace(cur, cur, new Slice(fill!, 0, 0))
   }
-  for (let i = delSteps.length - 1; i >= 0; i--) this.step(delSteps[i])
-  return this
+  for (let i = delSteps.length - 1; i >= 0; i--) tr.step(delSteps[i])
 }

package/src/{mark_step.js → mark_step.ts}

@@ -1,7 +1,8 @@
-import {Fragment, Slice} from "prosemirror-model"
+import {Fragment, Slice, Node, Mark, Schema} from "prosemirror-model"
 import {Step, StepResult} from "./step"
+import {Mappable} from "./map"
 
-function mapFragment(fragment, f, parent) {
+function mapFragment(fragment: Fragment, f: (child: Node, parent: Node, i: number) => Node, parent: Node): Fragment {
   let mapped = []
   for (let i = 0; i < fragment.childCount; i++) {
     let child = fragment.child(i)
@@ -12,23 +13,21 @@ function mapFragment(fragment, f, parent) {
   return Fragment.fromArray(mapped)
 }
 
-// ::- Add a mark to all inline content between two positions.
+/// Add a mark to all inline content between two positions.
 export class AddMarkStep extends Step {
-  // :: (number, number, Mark)
-  constructor(from, to, mark) {
+  /// Create a mark step.
+  constructor(
+    /// The start of the marked range.
+    readonly from: number,
+    /// The end of the marked range.
+    readonly to: number,
+    /// The mark to add.
+    readonly mark: Mark
+  ) {
     super()
-    // :: number
-    // The start of the marked range.
-    this.from = from
-    // :: number
-    // The end of the marked range.
-    this.to = to
-    // :: Mark
-    // The mark to add.
-    this.mark = mark
   }
 
-  apply(doc) {
+  apply(doc: Node) {
     let oldSlice = doc.slice(this.from, this.to), $from = doc.resolve(this.from)
     let parent = $from.node($from.sharedDepth(this.to))
     let slice = new Slice(mapFragment(oldSlice.content, (node, parent) => {
@@ -38,30 +37,32 @@ export class AddMarkStep extends Step {
     return StepResult.fromReplace(doc, this.from, this.to, slice)
   }
 
-  invert() {
+  invert(): Step {
     return new RemoveMarkStep(this.from, this.to, this.mark)
   }
 
-  map(mapping) {
+  map(mapping: Mappable): Step | null {
     let from = mapping.mapResult(this.from, 1), to = mapping.mapResult(this.to, -1)
     if (from.deleted && to.deleted || from.pos >= to.pos) return null
     return new AddMarkStep(from.pos, to.pos, this.mark)
   }
 
-  merge(other) {
+  merge(other: Step): Step | null {
     if (other instanceof AddMarkStep &&
         other.mark.eq(this.mark) &&
         this.from <= other.to && this.to >= other.from)
       return new AddMarkStep(Math.min(this.from, other.from),
                              Math.max(this.to, other.to), this.mark)
+    return null
   }
 
-  toJSON() {
+  toJSON(): any {
     return {stepType: "addMark", mark: this.mark.toJSON(),
             from: this.from, to: this.to}
   }
 
-  static fromJSON(schema, json) {
+  /// @internal
+  static fromJSON(schema: Schema, json: any) {
     if (typeof json.from != "number" || typeof json.to != "number")
       throw new RangeError("Invalid input for AddMarkStep.fromJSON")
     return new AddMarkStep(json.from, json.to, schema.markFromJSON(json.mark))
@@ -70,54 +71,54 @@ export class AddMarkStep extends Step {
 
 Step.jsonID("addMark", AddMarkStep)
 
-// ::- Remove a mark from all inline content between two positions.
+/// Remove a mark from all inline content between two positions.
 export class RemoveMarkStep extends Step {
-  // :: (number, number, Mark)
-  constructor(from, to, mark) {
+  /// Create a mark-removing step.
+  constructor(
+    /// The start of the unmarked range.
+    readonly from: number,
+    /// The end of the unmarked range.
+    readonly to: number,
+    /// The mark to remove.
+    readonly mark: Mark
+  ) {
     super()
-    // :: number
-    // The start of the unmarked range.
-    this.from = from
-    // :: number
-    // The end of the unmarked range.
-    this.to = to
-    // :: Mark
-    // The mark to remove.
-    this.mark = mark
   }
 
-  apply(doc) {
+  apply(doc: Node) {
     let oldSlice = doc.slice(this.from, this.to)
     let slice = new Slice(mapFragment(oldSlice.content, node => {
       return node.mark(this.mark.removeFromSet(node.marks))
-    }), oldSlice.openStart, oldSlice.openEnd)
+    }, doc), oldSlice.openStart, oldSlice.openEnd)
     return StepResult.fromReplace(doc, this.from, this.to, slice)
   }
 
-  invert() {
+  invert(): Step {
     return new AddMarkStep(this.from, this.to, this.mark)
   }
 
-  map(mapping) {
+  map(mapping: Mappable): Step | null {
     let from = mapping.mapResult(this.from, 1), to = mapping.mapResult(this.to, -1)
     if (from.deleted && to.deleted || from.pos >= to.pos) return null
     return new RemoveMarkStep(from.pos, to.pos, this.mark)
   }
 
-  merge(other) {
+  merge(other: Step): Step | null {
     if (other instanceof RemoveMarkStep &&
         other.mark.eq(this.mark) &&
         this.from <= other.to && this.to >= other.from)
       return new RemoveMarkStep(Math.min(this.from, other.from),
                                 Math.max(this.to, other.to), this.mark)
+    return null
   }
 
-  toJSON() {
+  toJSON(): any {
     return {stepType: "removeMark", mark: this.mark.toJSON(),
             from: this.from, to: this.to}
   }
 
-  static fromJSON(schema, json) {
+  /// @internal
+  static fromJSON(schema: Schema, json: any) {
     if (typeof json.from != "number" || typeof json.to != "number")
       throw new RangeError("Invalid input for RemoveMarkStep.fromJSON")
     return new RemoveMarkStep(json.from, json.to, schema.markFromJSON(json.mark))