prosemirror-changeset 2.1.1 → 2.2.0

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

@@ -1,31 +1,34 @@
+import {Node} from "prosemirror-model"
+import {StepMap} from "prosemirror-transform"
 import {computeDiff} from "./diff"
 import {Change, Span} from "./change"
 export {Change, Span}
 export {simplifyChanges} from "./simplify"
 
-// ::- A change set tracks the changes to a document from a given
-// point in the past. It condenses a number of step maps down to a
-// flat sequence of replacements, and simplifies replacments that
-// partially undo themselves by comparing their content.
-export class ChangeSet {
-  constructor(config, changes) {
-    this.config = config
-    // :: [Change] Replaced regions.
-    this.changes = changes
-  }
-
-  // :: (Node, [StepMap], union<[any], any>) → ChangeSet
-  // Computes a new changeset by adding the given step maps and
-  // metadata (either as an array, per-map, or as a single value to be
-  // associated with all maps) to the current set. Will not mutate the
-  // old set.
-  //
-  // Note that due to simplification that happens after each add,
-  // incrementally adding steps might create a different final set
-  // than adding all those changes at once, since different document
-  // tokens might be matched during simplification depending on the
-  // boundaries of the current changed ranges.
-  addSteps(newDoc, maps, data) {
+/// A change set tracks the changes to a document from a given point
+/// in the past. It condenses a number of step maps down to a flat
+/// sequence of replacements, and simplifies replacments that
+/// partially undo themselves by comparing their content.
+export class ChangeSet<Data = any> {
+  /// @internal
+  constructor(
+    /// @internal
+    readonly config: {doc: Node, combine: (dataA: Data, dataB: Data) => Data},
+    /// Replaced regions.
+    readonly changes: readonly Change<Data>[]
+  ) {}
+
+  /// Computes a new changeset by adding the given step maps and
+  /// metadata (either as an array, per-map, or as a single value to be
+  /// associated with all maps) to the current set. Will not mutate the
+  /// old set.
+  ///
+  /// Note that due to simplification that happens after each add,
+  /// incrementally adding steps might create a different final set
+  /// than adding all those changes at once, since different document
+  /// tokens might be matched during simplification depending on the
+  /// boundaries of the current changed ranges.
+  addSteps(newDoc: Node, maps: readonly StepMap[], data: Data | readonly Data[]): ChangeSet<Data> {
     // This works by inspecting the position maps for the changes,
     // which indicate what parts of the document were replaced by new
     // content, and the size of that new content. It uses these to
@@ -40,7 +43,7 @@ export class ChangeSet {
     // a diff to try to minimize the change by dropping matching
     // pieces of the old and new document from the change.
 
-    let stepChanges = []
+    let stepChanges: Change<Data>[] = []
     // Add spans for new steps.
     for (let i = 0; i < maps.length; i++) {
       let d = Array.isArray(data) ? data[i] : data
@@ -58,10 +61,11 @@ export class ChangeSet {
 
     let newChanges = mergeAll(stepChanges, this.config.combine)
     let changes = Change.merge(this.changes, newChanges, this.config.combine)
+    let updated: Change<Data>[] = changes as Change<Data>[]
 
     // Minimize changes when possible
-    for (let i = 0; i < changes.length; i++) {
-      let change = changes[i]
+    for (let i = 0; i < updated.length; i++) {
+      let change = updated[i]
       if (change.fromA == change.toA || change.fromB == change.toB ||
           // Only look at changes that touch newly added changed ranges
           !newChanges.some(r => r.toB > change.fromB && r.fromB < change.toB)) continue
@@ -71,48 +75,48 @@ export class ChangeSet {
       if (diff.length == 1 && diff[0].fromB == 0 && diff[0].toB == change.toB - change.fromB)
         continue
 
+      if (updated == changes) updated = changes.slice()
       if (diff.length == 1) {
-        changes[i] = diff[0]
+        updated[i] = diff[0]
       } else {
-        changes.splice(i, 1, ...diff)
+        updated.splice(i, 1, ...diff)
         i += diff.length - 1
       }
     }
 
-    return new ChangeSet(this.config, changes)
+    return new ChangeSet(this.config, updated)
   }
 
-  // :: Node
-  // The starting document of the change set.
-  get startDoc() { return this.config.doc }
-
-  // :: (f: (range: Change) → any) → ChangeSet
-  // Map the span's data values in the given set through a function
-  // and construct a new set with the resulting data.
-  map(f) {
-    return new ChangeSet(this.config, this.changes.map(change => {
-      let data = f(change)
-      return data === change.data ? change :
-        new Change(change.fromA, change.toA, change.fromB, change.toB, data)
+  /// The starting document of the change set.
+  get startDoc(): Node { return this.config.doc }
+
+  /// Map the span's data values in the given set through a function
+  /// and construct a new set with the resulting data.
+  map(f: (range: Span<Data>) => Data): ChangeSet<Data> {
+    let mapSpan = (span: Span<Data>) => {
+      let newData = f(span)
+      return newData === span.data ? span : new Span(span.length, newData)
+    }
+    return new ChangeSet(this.config, this.changes.map((ch: Change<Data>) => {
+      return new Change(ch.fromA, ch.toA, ch.fromB, ch.toB, ch.deleted.map(mapSpan), ch.inserted.map(mapSpan))
     }))
   }
 
-  // :: (ChangeSet, ?[StepMap]) → ?{from: number, to: number}
-  // Compare two changesets and return the range in which they are
-  // changed, if any. If the document changed between the maps, pass
-  // the maps for the steps that changed it as second argument, and
-  // make sure the method is called on the old set and passed the new
-  // set. The returned positions will be in new document coordinates.
-  changedRange(b, maps) {
+  /// Compare two changesets and return the range in which they are
+  /// changed, if any. If the document changed between the maps, pass
+  /// the maps for the steps that changed it as second argument, and
+  /// make sure the method is called on the old set and passed the new
+  /// set. The returned positions will be in new document coordinates.
+  changedRange(b: ChangeSet, maps?: readonly StepMap[]): {from: number, to: number} | null {
     if (b == this) return null
     let touched = maps && touchedRange(maps)
     let moved = touched ? (touched.toB - touched.fromB) - (touched.toA - touched.fromA) : 0
-    function map(p) {
+    function map(p: number) {
       return !touched || p <= touched.fromA ? p : p + moved
     }
 
     let from = touched ? touched.fromB : 2e8, to = touched ? touched.toB : -2e8
-    function add(start, end = start) {
+    function add(start: number, end = start) {
       from = Math.min(start, from); to = Math.max(end, to)
     }
 
@@ -127,29 +131,31 @@ export class ChangeSet {
     return from <= to ? {from, to} : null
   }
 
-  // :: (Node, ?(a: any, b: any) → any) → ChangeSet
-  // Create a changeset with the given base object and configuration.
-  // The `combine` function is used to compare and combine metadata—it
-  // should return null when metadata isn't compatible, and a combined
-  // version for a merged range when it is.
-  static create(doc, combine = (a, b) => a === b ? a : null) {
-    return new ChangeSet({combine, doc}, [], [])
+  /// Create a changeset with the given base object and configuration.
+  /// The `combine` function is used to compare and combine metadata—it
+  /// should return null when metadata isn't compatible, and a combined
+  /// version for a merged range when it is.
+  static create<Data = any>(doc: Node, combine: (dataA: Data, dataB: Data) => Data = (a, b) => a === b ? a : null as any) {
+    return new ChangeSet({combine, doc}, [])
   }
-}
 
-// Exported for testing
-ChangeSet.computeDiff = computeDiff
+  /// Exported for testing @internal
+  static computeDiff = computeDiff
+}
 
-// : ([[Change]], (any, any) → any, number, number) → [Change]
 // Divide-and-conquer approach to merging a series of ranges.
-function mergeAll(ranges, combine, start = 0, end = ranges.length) {
+function mergeAll<Data>(
+  ranges: readonly Change<Data>[],
+  combine: (dA: Data, dB: Data) => Data,
+  start = 0, end = ranges.length
+): readonly Change<Data>[] {
   if (end == start + 1) return [ranges[start]]
   let mid = (start + end) >> 1
   return Change.merge(mergeAll(ranges, combine, start, mid),
                       mergeAll(ranges, combine, mid, end), combine)
 }
 
-function endRange(maps) {
+function endRange(maps: readonly StepMap[]) {
   let from = 2e8, to = -2e8
   for (let i = 0; i < maps.length; i++) {
     let map = maps[i]
@@ -165,19 +171,19 @@ function endRange(maps) {
   return from == 2e8 ? null : {from, to}
 }
 
-function touchedRange(maps) {
+function touchedRange(maps: readonly StepMap[]) {
   let b = endRange(maps)
   if (!b) return null
-  let a = endRange(maps.map(m => m.invert()).reverse())
+  let a = endRange(maps.map(m => m.invert()).reverse())!
   return {fromA: a.from, toA: a.to, fromB: b.from, toB: b.to}
 }
 
-function sameRanges(a, b, map) {
+function sameRanges<Data>(a: Change<Data>, b: Change<Data>, map: (pos: number) => number) {
   return map(a.fromB) == b.fromB && map(a.toB) == b.toB &&
     sameSpans(a.deleted, b.deleted) && sameSpans(a.inserted, b.inserted)
 }
 
-function sameSpans(a, b) {
+function sameSpans<Data>(a: readonly Span<Data>[], b: readonly Span<Data>[]) {
   if (a.length != b.length) return false
   for (let i = 0; i < a.length; i++)
     if (a[i].length != b[i].length || a[i].data !== b[i].data) return false

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

@@ -1,13 +1,16 @@
+import {Fragment} from "prosemirror-model"
+import {Change} from "./change"
+
 // Convert the given range of a fragment to tokens, where node open
 // tokens are encoded as strings holding the node name, characters as
 // their character code, and node close tokens as -1.
-function tokens(frag, start, end, target) {
+function tokens(frag: Fragment, start: number, end: number, target: (number | string)[]) {
   for (let i = 0, off = 0; i < frag.childCount; i++) {
     let child = frag.child(i), endOff = off + child.nodeSize
     let from = Math.max(off, start), to = Math.min(endOff, end)
     if (from < to) {
       if (child.isText) {
-        for (let j = from; j < to; j++) target.push(child.text.charCodeAt(j - off))
+        for (let j = from; j < to; j++) target.push(child.text!.charCodeAt(j - off))
       } else if (child.isLeaf) {
         target.push(child.type.name)
       } else {
@@ -31,12 +34,11 @@ const MAX_DIFF_SIZE = 5000
 // idea is to make it higher in bigger replacements, so that you don't
 // get a diff soup of coincidentally identical letters when replacing
 // a paragraph.
-function minUnchanged(sizeA, sizeB) {
+function minUnchanged(sizeA: number, sizeB: number) {
   return Math.min(15, Math.max(2, Math.floor(Math.max(sizeA, sizeB) / 10)))
 }
 
-// : (Fragment, Fragment, Change) → [Change]
-export function computeDiff(fragA, fragB, range) {
+export function computeDiff(fragA: Fragment, fragB: Fragment, range: Change) {
   let tokA = tokens(fragA, range.fromA, range.toA, [])
   let tokB = tokens(fragB, range.fromB, range.toB, [])
 
@@ -56,8 +58,8 @@ export function computeDiff(fragA, fragB, range) {
 
   let lenA = endA - start, lenB = endB - start
   let max = Math.min(MAX_DIFF_SIZE, lenA + lenB), off = max + 1
-  let history = []
-  let frontier = []
+  let history: number[][] = []
+  let frontier: number[] = []
   for (let len = off * 2, i = 0; i < len; i++) frontier[i] = -1
 
   for (let size = 0; size <= max; size++) {
@@ -73,7 +75,7 @@ export function computeDiff(fragA, fragB, range) {
         // Used to add steps to a diff one at a time, back to front, merging
         // ones that are less than minSpan tokens apart
         let fromA = -1, toA = -1, fromB = -1, toB = -1
-        let add = (fA, tA, fB, tB) => {
+        let add = (fA: number, tA: number, fB: number, tB: number) => {
           if (fromA > -1 && fromA < tA + minSpan) {
             fromA = fA; fromB = fB
           } else {

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

@@ -1,6 +1,7 @@
+import {Fragment, Node} from "prosemirror-model"
 import {Span, Change} from "./change"
 
-let letter
+let letter: RegExp | undefined
 // If the runtime support unicode properties in regexps, that's a good
 // source of info on whether something is a letter.
 try { letter = new RegExp("[\\p{Alphabetic}_]", "u") } catch(_) {}
@@ -9,7 +10,7 @@ try { letter = new RegExp("[\\p{Alphabetic}_]", "u") } catch(_) {}
 // or if it is part of these common single-case scripts.
 const nonASCIISingleCaseWordChar = /[\u00df\u0587\u0590-\u05f4\u0600-\u06ff\u3040-\u309f\u30a0-\u30ff\u3400-\u4db5\u4e00-\u9fcc\uac00-\ud7af]/
 
-function isLetter(code) {
+function isLetter(code: number) {
   if (code < 128)
     return code >= 48 && code <= 57 || code >= 65 && code <= 90 || code >= 79 && code <= 122
   let ch = String.fromCharCode(code)
@@ -20,15 +21,15 @@ function isLetter(code) {
 // Convert a range of document into a string, so that we can easily
 // access characters at a given position. Treat non-text tokens as
 // spaces so that they aren't considered part of a word.
-function getText(frag, start, end) {
+function getText(frag: Fragment, start: number, end: number) {
   let out = ""
-  function convert(frag, start, end) {
+  function convert(frag: Fragment, start: number, end: number) {
     for (let i = 0, off = 0; i < frag.childCount; i++) {
       let child = frag.child(i), endOff = off + child.nodeSize
       let from = Math.max(off, start), to = Math.min(endOff, end)
       if (from < to) {
         if (child.isText) {
-          out += child.text.slice(Math.max(0, start - off), Math.min(child.text.length, end - off))
+          out += child.text!.slice(Math.max(0, start - off), Math.min(child.text!.length, end - off))
         } else if (child.isLeaf) {
           out += " "
         } else {
@@ -48,15 +49,14 @@ function getText(frag, start, end) {
 // candidates for merging.
 const MAX_SIMPLIFY_DISTANCE = 30
 
-// :: ([Change], Node) → [Change]
-// Simplifies a set of changes for presentation. This makes the
-// assumption that having both insertions and deletions within a word
-// is confusing, and, when such changes occur without a word boundary
-// between them, they should be expanded to cover the entire set of
-// words (in the new document) they touch. An exception is made for
-// single-character replacements.
-export function simplifyChanges(changes, doc) {
-  let result = []
+/// Simplifies a set of changes for presentation. This makes the
+/// assumption that having both insertions and deletions within a word
+/// is confusing, and, when such changes occur without a word boundary
+/// between them, they should be expanded to cover the entire set of
+/// words (in the new document) they touch. An exception is made for
+/// single-character replacements.
+export function simplifyChanges(changes: readonly Change[], doc: Node) {
+  let result: Change[] = []
   for (let i = 0; i < changes.length; i++) {
     let end = changes[i].toB, start = i
     while (i < changes.length - 1 && changes[i + 1].fromB <= end + MAX_SIMPLIFY_DISTANCE)
@@ -66,7 +66,7 @@ export function simplifyChanges(changes, doc) {
   return result
 }
 
-function simplifyAdjacentChanges(changes, from, to, doc, target) {
+function simplifyAdjacentChanges(changes: readonly Change[], from: number, to: number, doc: Node, target: Change[]) {
   let start = Math.max(0, changes[from].fromB - MAX_SIMPLIFY_DISTANCE)
   let end = Math.min(doc.content.size, changes[to - 1].toB + MAX_SIMPLIFY_DISTANCE)
   let text = getText(doc.content, start, end)
@@ -107,9 +107,9 @@ function simplifyAdjacentChanges(changes, from, to, doc, target) {
   return changes
 }
 
-function combine(a, b) { return a === b ? a : null }
+function combine<T>(a: T, b: T): T { return a === b ? a : null as any }
 
-function fillChange(changes, fromB, toB) {
+function fillChange(changes: readonly Change[], fromB: number, toB: number) {
   let fromA = changes[0].fromA - (changes[0].fromB - fromB)
   let last = changes[changes.length - 1]
   let toA = last.toA + (toB - last.toB)

package/test/{test-changed-range.js → test-changed-range.ts}

@@ -1,10 +1,11 @@
-const ist = require("ist")
-const {schema, doc, p} = require("prosemirror-test-builder")
-const {Transform} = require("prosemirror-transform")
+import ist from "ist"
+import {schema, doc, p} from "prosemirror-test-builder"
+import {Transform} from "prosemirror-transform"
+import {Node} from "prosemirror-model"
 
-const {ChangeSet} = require("..")
+import {ChangeSet} from "prosemirror-changeset"
 
-function mk(doc, change) {
+function mk(doc: Node, change: (tr: Transform) => Transform): {doc0: Node, tr: Transform, data: any[], set0: ChangeSet, set: ChangeSet} {
   let tr = change(new Transform(doc))
   let data = new Array(tr.steps.length).fill("a")
   let set0 = ChangeSet.create(doc)
@@ -12,7 +13,7 @@ function mk(doc, change) {
           set: set0.addSteps(tr.doc, tr.mapping.maps, data)}
 }
 
-function same(a, b) {
+function same(a: any, b: any) {
   ist(JSON.stringify(a), JSON.stringify(b))
 }
 
@@ -42,6 +43,6 @@ describe("ChangeSet.changedRange", () => {
 
   it("detects changes in deletions", () => {
     let {set} = mk(doc(p("abc")), tr => tr.delete(2, 3))
-    same(set.changedRange(set.map(() => "b", () => "b")), {from: 2, to: 2})
+    same(set.changedRange(set.map(() => "b")), {from: 2, to: 2})
   })
 })

package/test/{test-changes.js → test-changes.ts}

@@ -1,8 +1,9 @@
-const ist = require("ist")
-const {schema, doc, p, blockquote, h1} = require("prosemirror-test-builder")
-const {Transform} = require("prosemirror-transform")
+import ist from "ist"
+import {schema, doc, p, blockquote, h1} from "prosemirror-test-builder"
+import {Transform} from "prosemirror-transform"
+import {Node} from "prosemirror-model"
 
-const {ChangeSet} = require("..")
+import {ChangeSet} from "prosemirror-changeset"
 
 describe("ChangeSet", () => {
   it("finds a single insertion",
@@ -181,11 +182,12 @@ describe("ChangeSet", () => {
 
   it("correctly handles steps with multiple map entries", find(doc(p()), [
     tr => tr.replaceWith(1, 1, t("ab")),
-    tr => tr.wrap(tr.doc.resolve(1).blockRange(), [{type: schema.nodes.blockquote}])
+    tr => tr.wrap(tr.doc.resolve(1).blockRange()!, [{type: schema.nodes.blockquote}])
   ], [[0, 0, 0, 1], [1, 1, 2, 4], [2, 2, 5, 6]]))
 })
 
-function find(doc, build, changes, sep) {
+function find(doc: Node, build: ((tr: Transform) => void) | ((tr: Transform) => void)[],
+              changes: any[], sep?: number[] | boolean) {
   return () => {
     let set = ChangeSet.create(doc), curDoc = doc
     if (!Array.isArray(build)) build = [build]
@@ -198,7 +200,7 @@ function find(doc, build, changes, sep) {
 
     let owner = sep && changes.length && changes[0].length > 4
     ist(JSON.stringify(set.changes.map(ch => {
-      let range = [ch.fromA, ch.toA, ch.fromB, ch.toB]
+      let range: any[] = [ch.fromA, ch.toA, ch.fromB, ch.toB]
       if (owner) range.push(ch.deleted.map(d => [d.length, d.data]),
                             ch.inserted.map(d => [d.length, d.data]))
       return range
@@ -206,4 +208,4 @@ function find(doc, build, changes, sep) {
   }
 }
 
-function t(str) { return schema.text(str) }
+function t(str: string) { return schema.text(str) }

package/test/{test-diff.js → test-diff.ts}

@@ -1,10 +1,11 @@
-const ist = require("ist")
-const {doc, p, em, strong, h1, h2} = require("prosemirror-test-builder")
-
-const {Span, Change, ChangeSet: {computeDiff}} = require("..")
+import ist from "ist"
+import {doc, p, em, strong, h1, h2} from "prosemirror-test-builder"
+import {Node} from "prosemirror-model"
+import {Span, Change, ChangeSet} from "prosemirror-changeset"
+const {computeDiff} = ChangeSet
 
 describe("computeDiff", () => {
-  function test(doc1, doc2, ...ranges) {
+  function test(doc1: Node, doc2: Node, ...ranges: number[][]) {
     let diff = computeDiff(doc1.content, doc2.content,
                            new Change(0, doc1.content.size, 0, doc2.content.size,
                                       [new Span(doc1.content.size, 0)],

package/test/{test-merge.js → test-merge.ts}

@@ -1,5 +1,5 @@
-const ist = require("ist")
-const {Change, Span} = require("..")
+import ist from "ist"
+import {Change, Span} from "prosemirror-changeset"
 
 describe("mergeChanges", () => {
   it("can merge simple insertions", () => test(
@@ -43,13 +43,13 @@ describe("mergeChanges", () => {
   ))
 })
 
-function range(array, author = 0) {
+function range(array: number[], author = 0) {
   let [fromA, toA] = array
   let [fromB, toB] = array.length > 2 ? array.slice(2) : array
   return new Change(fromA, toA, fromB, toB, [new Span(toA - fromA, author)], [new Span(toB - fromB, author)])
 }
 
-function test(changeA, changeB, expected) {
+function test(changeA: number[][], changeB: number[][], expected: number[][]) {
   const result = Change.merge(changeA.map(range), changeB.map(range), a => a)
     .map(r => [r.fromA, r.toA, r.fromB, r.toB])
   ist(JSON.stringify(result), JSON.stringify(expected))

package/test/{test-simplify.js → test-simplify.ts}

@@ -1,6 +1,7 @@
-const ist = require("ist")
-const {doc, p, img} = require("prosemirror-test-builder")
-const {simplifyChanges, Change, Span} = require("..")
+import ist from "ist"
+import {doc, p, img} from "prosemirror-test-builder"
+import {Node} from "prosemirror-model"
+import {simplifyChanges, Change, Span} from "prosemirror-changeset"
 
 describe("simplifyChanges", () => {
   it("doesn't change insertion-only changes", () => test(
@@ -25,7 +26,7 @@ describe("simplifyChanges", () => {
     [[7, 10]], doc(p("one two ----- four")), [[5, 10]]))
 
   it("treats leaf nodes as non-words", () => test(
-    [[2, 3], [6, 7]], doc(p("one", img, "two")), [[2, 3], [6, 7]]))
+    [[2, 3], [6, 7]], doc(p("one", img(), "two")), [[2, 3], [6, 7]]))
 
   it("treats node boundaries as non-words", () => test(
     [[2, 3], [7, 8]], doc(p("one"), p("two")), [[2, 3], [7, 8]]))
@@ -55,13 +56,13 @@ describe("simplifyChanges", () => {
   })
 })
 
-function range(array, author = 0) {
+function range(array: number[], author = 0) {
   let [fromA, toA] = array
   let [fromB, toB] = array.length > 2 ? array.slice(2) : array
   return new Change(fromA, toA, fromB, toB, [new Span(toA - fromA, author)], [new Span(toB - fromB, author)])
 }
 
-function test(changes, doc, result) {
+function test(changes: number[][], doc: Node, result: number[][]) {
   let ranges = changes.map(range)
   ist(JSON.stringify(simplifyChanges(ranges, doc).map((r, i) => {
     if (result[i] && result[i].length > 2) return [r.fromA, r.toA, r.fromB, r.toB]