@startsimpli/ui 0.4.141 → 0.4.143

package/src/components/track-changes/__tests__/extension.test.ts

@@ -0,0 +1,350 @@
+/**
+ * The CodeMirror state layer, tested headless on EditorState (bd startsim-sjuai).
+ *
+ * What must hold: the editor never rewrites the stored string (CRLF, tabs,
+ * emoji, a trailing newline survive byte for byte); decorations sit on the
+ * right characters after local edits and after the stored value moves under
+ * the editor; text typed locally is never credited to the span it was typed
+ * into; and in suggesting mode the document is the PROPOSED copy, with the
+ * base untouched and every local change visible as an insert or a delete.
+ */
+import { EditorSelection, EditorState } from '@codemirror/state'
+
+import {
+  activeMarkOf,
+  enterSuggesting,
+  leaveSuggesting,
+  marksOf,
+  moveToMark,
+  proposedText,
+  rebaseOnto,
+  setAnnotations,
+  trackChanges,
+  trackingOf,
+} from '../extension'
+import type { BlameSpan, CommentThread, Suggestion, TrackActor } from '../types'
+
+const ada: TrackActor = { sub: 'ada', label: 'ada@x.io', kind: 'person', kindSource: 'claim' }
+const bo: TrackActor = { sub: 'bo', label: 'bo@x.io', kind: 'person', kindSource: 'claim' }
+const bot: TrackActor = { sub: 'svc', label: 'svc:n8n', kind: 'machine', kindSource: 'claim' }
+
+function span(from: number, to: number, author: TrackActor | null, reason?: string): BlameSpan {
+  return {
+    id: `blame:${from}`,
+    from,
+    to,
+    author,
+    unknownReason: author ? null : (reason ?? 'before history began'),
+    reason: author ? null : 'before_history',
+    version: 1,
+    at: null,
+    via: author ? 'edit' : 'unknown',
+    acceptedBy: null,
+    restoredFrom: null,
+  }
+}
+
+function suggestion(id: string, text: string, quote: string, replacement: string, author: TrackActor, at?: number): Suggestion {
+  const from = at ?? text.indexOf(quote)
+  return {
+    id,
+    setId: 'set',
+    from,
+    to: from + quote.length,
+    quote,
+    replacement,
+    status: 'open',
+    anchorState: 'mapped',
+    author,
+    createdAt: null,
+  }
+}
+
+function make(doc: string) {
+  return EditorState.create({ doc, extensions: [trackChanges()] })
+}
+
+const type = (s: EditorState, from: number, to: number, insert: string) =>
+  s.update({ changes: { from, to, insert }, userEvent: 'input.type' }).state
+
+const text = (s: EditorState, m: { from: number; to: number }) => s.sliceDoc(m.from, m.to)
+
+describe('the stored string is never rewritten', () => {
+  it.each([
+    ['CRLF', 'line one\r\nline two\r\n'],
+    ['lone CR', 'a\rb'],
+    ['tabs and trailing spaces', '\tindented  \n  two\t\n'],
+    ['emoji and CJK', '🚀 launch 中文博客 ✅\n'],
+    ['nbsp and zero-width', 'a b​c'],
+    ['no trailing newline', '# Title\n\nbody'],
+  ])('%s survives load and an edit that is undone by hand', (_, value) => {
+    let s = make(value)
+    expect(s.doc.toString()).toBe(value)
+    s = type(s, s.doc.length, s.doc.length, 'X')
+    s = type(s, s.doc.length - 1, s.doc.length, '')
+    expect(s.doc.toString()).toBe(value)
+  })
+})
+
+describe('decorations follow edits (editing mode)', () => {
+  const value = 'Ada wrote this. Bo wrote that.'
+  const annotations = {
+    blame: [span(0, 15, ada), span(15, 30, bo)],
+    suggestions: [suggestion('s1', value, 'that', 'this', bo)],
+    threads: [] as CommentThread[],
+  }
+
+  function loaded() {
+    return make(value).update({ effects: setAnnotations.of({ ...annotations, currentActorSub: 'ada' }) }).state
+  }
+
+  it('places blame and suggestion marks on their characters', () => {
+    const s = loaded()
+    const marks = marksOf(s)
+    const blame = marks.filter((m) => m.kind === 'blame')
+    expect(blame.map((m) => text(s, m))).toEqual(['Ada wrote this.', ' Bo wrote that.'])
+    const sug = marks.find((m) => m.kind === 'suggestion')!
+    expect(text(s, sug)).toBe('that')
+  })
+
+  it('shifts every mark when text is inserted before them', () => {
+    const s = type(loaded(), 0, 0, 'Note: ')
+    const marks = marksOf(s)
+    expect(marks.filter((m) => m.kind === 'blame').map((m) => text(s, m))).toEqual(['Ada wrote this.', ' Bo wrote that.'])
+    expect(text(s, marks.find((m) => m.kind === 'suggestion')!)).toBe('that')
+  })
+
+  it('does not credit text typed inside a span to that span’s author', () => {
+    const at = value.indexOf('this')
+    const s = type(loaded(), at, at, 'all of ')
+    const blame = marksOf(s).filter((m) => m.kind === 'blame')
+    expect(blame.map((m) => text(s, m))).toEqual(['Ada wrote ', 'this.', ' Bo wrote that.'])
+    expect(blame.every((m) => !text(s, m).includes('all of'))).toBe(true)
+  })
+
+  it('shrinks a span when part of it is deleted and drops a suggestion whose text is gone', () => {
+    const at = value.indexOf(' that')
+    const s = type(loaded(), at, at + 5, '')
+    const marks = marksOf(s)
+    expect(marks.filter((m) => m.kind === 'blame').map((m) => text(s, m))).toEqual(['Ada wrote this.', ' Bo wrote.'])
+    expect(marks.find((m) => m.kind === 'suggestion')).toBeUndefined()
+  })
+
+  it('moves marks when the stored value changes under the editor, keeping a local unsaved edit', () => {
+    let s = loaded()
+    s = type(s, s.doc.length, s.doc.length, ' Mine.') // unsaved local edit
+    const next = 'Intro. Ada wrote this. Bo wrote that.'
+    s = s.update(rebaseOnto(s, next)!).state
+    expect(s.doc.toString()).toBe('Intro. Ada wrote this. Bo wrote that. Mine.')
+    expect(trackingOf(s).base.toString()).toBe(next)
+    // New annotations arrive in the NEW value's coordinates.
+    s = s.update({
+      effects: setAnnotations.of({
+        blame: [span(0, 7, bot), span(7, 22, ada), span(22, 37, bo)],
+        suggestions: [],
+        threads: [],
+        currentActorSub: 'ada',
+      }),
+    }).state
+    expect(marksOf(s).filter((m) => m.kind === 'blame').map((m) => text(s, m))).toEqual([
+      'Intro. ',
+      'Ada wrote this.',
+      ' Bo wrote that.',
+    ])
+  })
+
+  it('treats the host echoing the editor’s own text as a save, not an external change', () => {
+    let s = loaded()
+    s = type(s, s.doc.length, s.doc.length, ' Mine.')
+    const saved = s.doc.toString()
+    s = s.update(rebaseOnto(s, saved) ?? {}).state
+    expect(s.doc.toString()).toBe(saved)
+    expect(trackingOf(s).changes.empty).toBe(true)
+  })
+
+  it('marks an unknown span with its reason, and a machine span as a machine', () => {
+    const s = make('old text new text').update({
+      effects: setAnnotations.of({
+        blame: [span(0, 9, null, 'before history began 2026-10-06'), span(9, 17, bot)],
+        suggestions: [],
+        threads: [],
+        currentActorSub: null,
+      }),
+    }).state
+    const [unknown, machine] = marksOf(s)
+    expect(unknown.description).toBe('Author unknown: before history began 2026-10-06')
+    expect(unknown.actorKind).toBe('unknown')
+    expect(machine.description).toMatch(/^Written by svc:n8n \(machine\)/)
+    expect(machine.actorKind).toBe('machine')
+  })
+
+  it('hides a kind of mark when asked, so whwxd.3 can build show/hide over it', () => {
+    const s = loaded().update({
+      effects: setAnnotations.of({ ...annotations, currentActorSub: 'ada', show: { blame: false } }),
+    }).state
+    expect(marksOf(s).some((m) => m.kind === 'blame')).toBe(false)
+    expect(marksOf(s).some((m) => m.kind === 'suggestion')).toBe(true)
+  })
+})
+
+describe('suggesting mode', () => {
+  const value = 'The quick brown fox jumps.'
+
+  function suggesting(own: Suggestion[] = [], others: Suggestion[] = []) {
+    let s = make(value).update({
+      effects: setAnnotations.of({ blame: [], suggestions: [...own, ...others], threads: [], currentActorSub: 'ada' }),
+    }).state
+    for (const spec of enterSuggesting(s)) s = s.update(spec).state
+    return s
+  }
+
+  it('keeps the base untouched and shows a typed insert as an insert', () => {
+    let s = suggesting()
+    const at = value.indexOf('fox')
+    s = type(s, at, at, 'red ')
+    expect(trackingOf(s).base.toString()).toBe(value)
+    expect(proposedText(s)).toBe('The quick brown red fox jumps.')
+    const local = marksOf(s).filter((m) => m.kind === 'local')
+    expect(local).toHaveLength(1)
+    expect(text(s, local[0])).toBe('red ')
+    expect(local[0].description).toBe('Your suggestion: insert “red”')
+  })
+
+  it('shows a deletion as struck base text that is no longer in the document', () => {
+    let s = suggesting()
+    const at = value.indexOf('quick ')
+    s = type(s, at, at + 6, '')
+    const [del] = marksOf(s).filter((m) => m.kind === 'local')
+    expect(del.deleted).toBe('quick ')
+    expect(del.from).toBe(del.to)
+    expect(del.description).toBe('Your suggestion: delete “quick”')
+    expect(proposedText(s)).toBe('The brown fox jumps.')
+  })
+
+  it('starts from the author’s own open suggestions, so a re-post does not drop them', () => {
+    const mine = suggestion('m1', value, 'quick', 'slow', ada)
+    const s = suggesting([mine])
+    expect(proposedText(s)).toBe('The slow brown fox jumps.')
+    // Shown as the author's local change, not twice.
+    expect(marksOf(s).filter((m) => m.kind === 'suggestion')).toHaveLength(0)
+    expect(marksOf(s).filter((m) => m.kind === 'local')).toHaveLength(1)
+  })
+
+  it('maps another reviewer’s suggestion through the local proposal', () => {
+    const theirs = suggestion('t1', value, 'jumps', 'leaps', bo)
+    let s = suggesting([], [theirs])
+    s = type(s, 0, 0, 'Look: ')
+    const m = marksOf(s).find((x) => x.kind === 'suggestion')!
+    expect(text(s, m)).toBe('jumps')
+    expect(m.description).toBe('Suggestion by bo@x.io: replace “jumps” with “leaps”')
+  })
+
+  it('keeps the proposal when the base moves underneath it', () => {
+    let s = suggesting()
+    const at = value.indexOf('fox')
+    s = type(s, at, at + 3, 'cat')
+    s = s.update(rebaseOnto(s, 'Today: The quick brown fox jumps.')!).state
+    expect(trackingOf(s).base.toString()).toBe('Today: The quick brown fox jumps.')
+    expect(proposedText(s)).toBe('Today: The quick brown cat jumps.')
+  })
+
+  it('returns to the base text, untouched, when leaving', () => {
+    let s = suggesting()
+    s = type(s, 0, 3, 'A')
+    s = s.update(leaveSuggesting(s)).state
+    expect(s.doc.toString()).toBe(value)
+    expect(trackingOf(s).changes.empty).toBe(true)
+  })
+})
+
+describe('keyboard navigation between marks', () => {
+  const value = 'One two three four.'
+
+  it('moves to the next and previous change and reports it as active', () => {
+    let s = make(value).update({
+      effects: setAnnotations.of({
+        blame: [],
+        suggestions: [suggestion('s1', value, 'two', '2', bo), suggestion('s2', value, 'four', '4', bo)],
+        threads: [
+          {
+            id: 't1',
+            from: value.indexOf('three'),
+            to: value.indexOf('three') + 5,
+            quote: 'three',
+            anchorState: 'mapped',
+            resolved: false,
+            redacted: false,
+            comments: [{ id: 'c', body: 'really?', deleted: false, author: ada, createdAt: null }],
+          },
+        ],
+        currentActorSub: null,
+      }),
+    }).state
+    const order: string[] = []
+    for (let i = 0; i < 3; i++) {
+      s = s.update(moveToMark(s, 1)!).state
+      order.push(activeMarkOf(s)!.id)
+    }
+    expect(order).toEqual(['s1', 't1', 's2'])
+    expect(text(s, s.selection.main)).toBe('four')
+    s = s.update(moveToMark(s, -1)!).state
+    expect(activeMarkOf(s)!.description).toBe('Comment by ada@x.io: “really?”')
+    // Wraps.
+    s = s.update(moveToMark(s, 1)!).state
+    s = s.update(moveToMark(s, 1)!).state
+    expect(activeMarkOf(s)!.id).toBe('s1')
+  })
+
+  it('reports the mark under the cursor as active when the cursor is moved by hand', () => {
+    let s = make(value).update({
+      effects: setAnnotations.of({
+        blame: [span(0, 19, ada)],
+        suggestions: [suggestion('s1', value, 'two', '2', bo)],
+        threads: [],
+        currentActorSub: null,
+      }),
+    }).state
+    s = s.update({ selection: EditorSelection.cursor(value.indexOf('two') + 1) }).state
+    // The suggestion wins over the blame span it sits inside.
+    expect(activeMarkOf(s)!.id).toBe('s1')
+    s = s.update({ selection: EditorSelection.cursor(1) }).state
+    expect(activeMarkOf(s)!.kind).toBe('blame')
+  })
+
+  it('returns null when there is nothing to move to', () => {
+    expect(moveToMark(make('plain'), 1)).toBeNull()
+  })
+})
+
+describe('the invariant: CHANGES applied to BASE is always the document', () => {
+  it('holds across random local edits and external rebases, in both modes', () => {
+    let seed = 11
+    const rnd = () => ((seed = (seed * 1103515245 + 12345) & 0x7fffffff) / 0x7fffffff)
+    const pieces = ['word ', 'other ', '🚀', '中文', '\r\n', '\n', 'x', ', ']
+    const gen = () => Array.from({ length: 1 + Math.floor(rnd() * 4) }, () => pieces[Math.floor(rnd() * pieces.length)]).join('')
+    const randomEdit = (doc: string) => {
+      const a = Math.floor(rnd() * (doc.length + 1))
+      const b = Math.min(doc.length, a + Math.floor(rnd() * 6))
+      return { from: a, to: b, insert: rnd() < 0.3 ? '' : gen() }
+    }
+    for (let round = 0; round < 60; round++) {
+      let s = make('start ' + gen() + ' end')
+      if (round % 2) for (const spec of enterSuggesting(s)) s = s.update(spec).state
+      for (let step = 0; step < 15; step++) {
+        if (rnd() < 0.7) {
+          s = s.update({ changes: randomEdit(s.doc.toString()), userEvent: 'input.type' }).state
+        } else {
+          const base = trackingOf(s).base.toString()
+          const e = randomEdit(base)
+          const next = base.slice(0, e.from) + e.insert + base.slice(e.to)
+          const spec = rebaseOnto(s, next)
+          if (spec) s = s.update(spec).state
+          expect(trackingOf(s).base.toString()).toBe(next)
+        }
+        const { base, changes } = trackingOf(s)
+        expect(changes.apply(base).toString()).toBe(s.doc.toString())
+        marksOf(s) // never throws
+      }
+    }
+  })
+})