@createiq/htmldiff 1.1.0 → 1.2.0-beta.0

package/src/ThreeWayDiff.ts

@@ -0,0 +1,223 @@
+import Action from './Action'
+import type { AnalyzeResult } from './HtmlDiff'
+import type Operation from './Operation'
+import type { WrapMetadata } from './Utils'
+
+/**
+ * Composes diff(V1, V2) (CP's changes) and diff(V2, V3) (Me's changes)
+ * into a single attributed segment stream. The output is consumed by
+ * `HtmlDiff.executeThreeWay` for emission.
+ *
+ * V2 is the structural spine. Both pair-wise analyses must tokenise V2
+ * identically (`HtmlDiff.executeThreeWay` enforces this via the
+ * symmetric-projection decision), so V2-diff indices are stable across
+ * the two streams and we can fold them into a single per-V2-token
+ * attribution view, interleaved with off-spine CP-deletions (V1-side)
+ * and Me-insertions (V3-side).
+ */
+
+export type Author = 'cp' | 'me'
+
+/**
+ * Attribution assigned to each output segment. `reject` is its own kind
+ * (rather than a flavour of `del`) so exhaustive switching is safe — no
+ * property-presence narrowing required at use sites.
+ */
+export type Attribution =
+  | { kind: 'equal' }
+  | { kind: 'ins'; author: Author }
+  | { kind: 'del'; author: Author }
+  // Me deleting tokens that CP inserted = rejecting CP's proposal.
+  | { kind: 'reject'; by: 'me'; rejected: 'cp' }
+
+export interface Segment {
+  attr: Attribution
+  /** Tokens to emit. For Equal segments these are original V2 words
+   *  (including structural tags); for ins/del they are diff-space tokens. */
+  words: string[]
+}
+
+export function buildSegments(d1: AnalyzeResult, d2: AnalyzeResult): Segment[] {
+  const v2DiffLen = d1.newDiffWords.length
+  const fromV1 = buildOriginMap(d1.operations, v2DiffLen)
+  const toV3 = buildFateMap(d2.operations, v2DiffLen)
+  const cpDeletionsAt = collectDeletionsAtBoundary(d1)
+  const meInsertionsAt = collectInsertionsAtBoundary(d2)
+
+  // Inverse map V2-diff-index → V2-original-index. Identity when no projection.
+  const diffToOriginal: readonly number[] = d1.newContentToOriginal ?? Array.from({ length: v2DiffLen }, (_, i) => i)
+  const v2OriginalLen = d1.newOriginalWords.length
+
+  const segments: Segment[] = []
+  let originalCursor = 0
+
+  for (let i = 0; i < v2DiffLen; i++) {
+    // CP-deletions from V1 land BEFORE the V2 token at this boundary —
+    // they conceptually "preceded" V2[i] in V1's stream.
+    const cpDel = cpDeletionsAt.get(i)
+    if (cpDel?.length) appendSegment(segments, { kind: 'del', author: 'cp' }, cpDel)
+
+    const attr = combine(fromV1[i], toV3[i])
+    const origIdx = diffToOriginal[i]
+    const slice = d1.newOriginalWords.slice(originalCursor, origIdx + 1)
+    originalCursor = origIdx + 1
+
+    // Me-insertions at this boundary go BEFORE V2[i] for pure
+    // insertions, but AFTER V2[i] when V2[i] is itself a Me-deletion
+    // (i.e. a Me Replace). This mirrors the 2-way del-then-ins
+    // convention so a Replace reads as `<del>X</del><ins>Y</ins>`.
+    const meIns = meInsertionsAt.get(i)
+    const meInsAfterV2 = meIns?.length && isDeletion(attr)
+
+    if (meIns?.length && !meInsAfterV2) {
+      appendSegment(segments, { kind: 'ins', author: 'me' }, meIns)
+    }
+    appendSegment(segments, attr, slice)
+    if (meInsAfterV2) {
+      appendSegment(segments, { kind: 'ins', author: 'me' }, meIns)
+    }
+  }
+  // Tail-end interleavings (CP-del / Me-ins at boundary v2DiffLen — i.e.
+  // after every V2 token). Ordering doesn't matter since there's no
+  // V2 token to anchor around.
+  const tailCpDel = cpDeletionsAt.get(v2DiffLen)
+  if (tailCpDel?.length) appendSegment(segments, { kind: 'del', author: 'cp' }, tailCpDel)
+  const tailMeIns = meInsertionsAt.get(v2DiffLen)
+  if (tailMeIns?.length) appendSegment(segments, { kind: 'ins', author: 'me' }, tailMeIns)
+
+  // Trailing V2-original tokens (structural closing tags after the last
+  // content word). Emit as equal — there's no following segment to claim
+  // them, and attributing them to either author would be arbitrary.
+  if (originalCursor < v2OriginalLen) {
+    appendSegment(segments, { kind: 'equal' }, d1.newOriginalWords.slice(originalCursor))
+  }
+
+  return segments
+}
+
+// ────────────────────────────────────────────────────────────────────────────
+
+type V2Origin = 'preserved-from-v1' | 'inserted-by-cp' | 'replaced-into-by-cp'
+type V2Fate = 'preserved-to-v3' | 'deleted-by-me' | 'replaced-out-by-me'
+
+function buildOriginMap(ops: readonly Operation[], v2Len: number): V2Origin[] {
+  const out: V2Origin[] = new Array(v2Len).fill('preserved-from-v1')
+  for (const op of ops) {
+    const origin =
+      op.action === Action.Insert ? 'inserted-by-cp' : op.action === Action.Replace ? 'replaced-into-by-cp' : null
+    if (origin === null) continue
+    for (let i = op.startInNew; i < op.endInNew; i++) {
+      if (i >= 0 && i < v2Len) out[i] = origin
+    }
+  }
+  return out
+}
+
+function buildFateMap(ops: readonly Operation[], v2Len: number): V2Fate[] {
+  const out: V2Fate[] = new Array(v2Len).fill('preserved-to-v3')
+  for (const op of ops) {
+    const fate =
+      op.action === Action.Delete ? 'deleted-by-me' : op.action === Action.Replace ? 'replaced-out-by-me' : null
+    if (fate === null) continue
+    for (let i = op.startInOld; i < op.endInOld; i++) {
+      if (i >= 0 && i < v2Len) out[i] = fate
+    }
+  }
+  return out
+}
+
+function isDeletion(attr: Attribution): boolean {
+  return attr.kind === 'del' || attr.kind === 'reject'
+}
+
+function combine(origin: V2Origin, fate: V2Fate): Attribution {
+  const cpInserted = origin === 'inserted-by-cp' || origin === 'replaced-into-by-cp'
+  const meDeleted = fate === 'deleted-by-me' || fate === 'replaced-out-by-me'
+  if (!cpInserted && !meDeleted) return { kind: 'equal' }
+  if (cpInserted && !meDeleted) return { kind: 'ins', author: 'cp' }
+  if (!cpInserted && meDeleted) return { kind: 'del', author: 'me' }
+  return { kind: 'reject', by: 'me', rejected: 'cp' }
+}
+
+/**
+ * Map V2-diff-boundary → CP-deleted V1 tokens at that boundary. Includes
+ * both pure Delete ops and the V1-side of Replace ops (semantically a
+ * Delete+Insert; the Insert half is picked up by the V2-token walk).
+ */
+function collectDeletionsAtBoundary(d: AnalyzeResult): Map<number, string[]> {
+  const out = new Map<number, string[]>()
+  for (const op of d.operations) {
+    if (op.action !== Action.Delete && op.action !== Action.Replace) continue
+    const words = d.oldDiffWords.slice(op.startInOld, op.endInOld)
+    if (words.length === 0) continue
+    const existing = out.get(op.startInNew) ?? []
+    existing.push(...words)
+    out.set(op.startInNew, existing)
+  }
+  return out
+}
+
+function collectInsertionsAtBoundary(d: AnalyzeResult): Map<number, string[]> {
+  const out = new Map<number, string[]>()
+  for (const op of d.operations) {
+    if (op.action !== Action.Insert && op.action !== Action.Replace) continue
+    const words = d.newDiffWords.slice(op.startInNew, op.endInNew)
+    if (words.length === 0) continue
+    const existing = out.get(op.startInOld) ?? []
+    existing.push(...words)
+    out.set(op.startInOld, existing)
+  }
+  return out
+}
+
+function appendSegment(segments: Segment[], attr: Attribution, words: string[]) {
+  if (words.length === 0) return
+  const last = segments[segments.length - 1]
+  if (last && sameAttribution(last.attr, attr)) {
+    last.words.push(...words)
+    return
+  }
+  segments.push({ attr, words: [...words] })
+}
+
+function sameAttribution(a: Attribution, b: Attribution): boolean {
+  if (a.kind === 'equal' && b.kind === 'equal') return true
+  if (a.kind === 'ins' && b.kind === 'ins') return a.author === b.author
+  if (a.kind === 'del' && b.kind === 'del') return a.author === b.author
+  if (a.kind === 'reject' && b.kind === 'reject') return true
+  return false
+}
+
+/**
+ * Build the `WrapMetadata` for an attribution. Single source of truth
+ * for author-class / data-attr shape so the three emission paths
+ * (word-level, table-level full-row/cell, multi-table whole-table
+ * pre-wrap) stay consistent. A change here propagates to every author
+ * marker in the output.
+ */
+export function authorAttribution(author: Author, rejects?: Author): WrapMetadata {
+  const dataAttrs: Record<string, string> = { author }
+  if (rejects !== undefined) dataAttrs.rejects = rejects
+  const extraClasses = rejects !== undefined ? `${author} rejects-${rejects}` : author
+  return { extraClasses, dataAttrs }
+}
+
+/**
+ * Resolve a segment's attribution into the wrapper-tag, base CSS class,
+ * and `WrapMetadata` consumed by `Utils.wrapText` / `insertTag`. The
+ * caller is `HtmlDiff.executeThreeWay`'s emission loop.
+ */
+export function segmentEmissionShape(attr: Exclude<Attribution, { kind: 'equal' }>): {
+  tag: 'ins' | 'del'
+  baseClass: 'diffins' | 'diffdel'
+  metadata: WrapMetadata
+} {
+  switch (attr.kind) {
+    case 'ins':
+      return { tag: 'ins', baseClass: 'diffins', metadata: authorAttribution(attr.author) }
+    case 'del':
+      return { tag: 'del', baseClass: 'diffdel', metadata: authorAttribution(attr.author) }
+    case 'reject':
+      return { tag: 'del', baseClass: 'diffdel', metadata: authorAttribution(attr.by, attr.rejected) }
+  }
+}