pnpm add @mdxld/diff

import {
  // Text diffing
  diffLines, diffWords, diffChars,
  // Git-style patches
  createPatch, applyPatch, parsePatch,
  // 3-way merge
  merge3way, resolveConflict,
  // Object diffing
  diffObjects, diffJSON, diffArrays,
  // Utilities
  formatChanges, countChanges
} from '@mdxld/diff'
 
// Diff two documents
const changes = diffLines(oldContent, newContent)
 
// Create a patch
const patch = createPatch('document.md', oldContent, newContent)
 
// Apply a patch
const updated = applyPatch(oldContent, patch)

const changes = diffLines(oldContent, newContent)
 
for (const change of changes) {
  if (change.added) {
    console.log('+', change.value)
  } else if (change.removed) {
    console.log('-', change.value)
  }
}

const changes = diffWords('hello world', 'hello there')
// [
//   { value: 'hello ' },
//   { value: 'world', removed: true },
//   { value: 'there', added: true }
// ]

const changes = diffChars('hello', 'hallo')
// [
//   { value: 'h' },
//   { value: 'e', removed: true },
//   { value: 'a', added: true },
//   { value: 'llo' }
// ]

interface DiffOptions {
  ignoreWhitespace?: boolean  // Ignore leading/trailing whitespace
  ignoreCase?: boolean        // Case-insensitive comparison
  newlineIsToken?: boolean    // Treat newlines as separate tokens
}
 
const changes = diffLines(old, new, { ignoreWhitespace: true })

const patch = createPatch('document.md', oldContent, newContent)

--- document.md
+++ document.md
@@ -1,4 +1,4 @@
 # Hello World
 
-This is the old content.
+This is the new content.
 
 More text here.

interface PatchOptions {
  context?: number       // Context lines (default: 3)
  oldFileName?: string   // Original filename
  newFileName?: string   // New filename
  oldHeader?: string     // Header for old file
  newHeader?: string     // Header for new file
}
 
const patch = createPatch('doc.md', old, new, {
  context: 5,
  oldHeader: 'revision 1',
  newHeader: 'revision 2',
})

const newContent = applyPatch(oldContent, patch)
 
if (newContent === false) {
  console.error('Patch failed to apply cleanly')
}

const patches = parsePatch(patchString)
 
for (const patch of patches) {
  console.log(`${patch.oldFileName} → ${patch.newFileName}`)
  console.log(`${patch.hunks.length} hunks`)
 
  for (const hunk of patch.hunks) {
    console.log(`@@ -${hunk.oldStart},${hunk.oldLines} +${hunk.newStart},${hunk.newLines} @@`)
  }
}

const patch = structuredPatch('old.md', 'new.md', oldContent, newContent)
 
for (const hunk of patch.hunks) {
  for (const line of hunk.lines) {
    console.log(line)  // Lines prefixed with +, -, or space
  }
}

const reversed = reversePatch(patches)
const restored = applyPatch(newContent, reversed)

const base = `line 1
line 2
line 3`
 
const ours = `line 1
line 2 modified by us
line 3`
 
const theirs = `line 1
line 2
line 3 modified by them`
 
const result = merge3way(base, ours, theirs)
 
if (result.hasConflicts) {
  console.log('Conflicts found:', result.conflicts.length)
  console.log(result.merged)  // Contains conflict markers
} else {
  console.log('Clean merge:', result.merged)
}

<<<<<<< ours
line 2 modified by us
=======
line 2 modified by them
>>>>>>> theirs

// Choose our changes
const resolved = resolveConflict(mergedWithConflicts, 'ours')
 
// Choose their changes
const resolved = resolveConflict(mergedWithConflicts, 'theirs')
 
// Use the base version
const resolved = resolveConflict(mergedWithConflicts, 'base')

const diff = diffObjects(
  { name: 'John', age: 30, city: 'LA' },
  { name: 'John', age: 31, country: 'USA' }
)
 
// {
//   added: { country: 'USA' },
//   removed: { city: 'LA' },
//   modified: { age: { from: 30, to: 31 } },
//   unchanged: { name: 'John' },
//   hasChanges: true
// }

const patch = diffJSON(oldConfig, newConfig, {
  oldFileName: 'config.old.json',
  newFileName: 'config.new.json',
})

const diff = diffArrays(['a', 'b', 'c'], ['a', 'c', 'd'])
// {
//   added: [{ index: 2, value: 'd' }],
//   removed: [{ index: 1, value: 'b' }],
//   moved: [],
//   hasChanges: true
// }

const changes = diffLines(old, new)
console.log(formatChanges(changes))
// -old line
// +new line

const { additions, deletions } = countChanges(changes)
console.log(`+${additions} -${deletions}`)

if (canApplyPatch(content, patch)) {
  const result = applyPatch(content, patch)
}

const stats = getPatchStats(patch)
// { files: 2, additions: 10, deletions: 5, hunks: 3 }

import { createPatch, applyPatch } from '@mdxld/diff'
 
class DocumentHistory {
  private patches: string[] = []
  private baseContent: string
 
  constructor(initialContent: string) {
    this.baseContent = initialContent
  }
 
  save(newContent: string, currentContent: string) {
    const patch = createPatch('document.mdx', currentContent, newContent)
    this.patches.push(patch)
  }
 
  getVersion(index: number): string {
    let content = this.baseContent
    for (let i = 0; i <= index && i < this.patches.length; i++) {
      const result = applyPatch(content, this.patches[i])
      if (result !== false) content = result
    }
    return content
  }
 
  getDiff(fromIndex: number, toIndex: number): string {
    const from = this.getVersion(fromIndex)
    const to = this.getVersion(toIndex)
    return createPatch('document.mdx', from, to)
  }
}

import { merge3way, resolveConflict } from '@mdxld/diff'
 
async function mergeEdits(base: string, userA: string, userB: string) {
  const result = merge3way(base, userA, userB)
 
  if (result.hasConflicts) {
    // Show conflicts to user for manual resolution
    // Or auto-resolve with a strategy
    return resolveConflict(result.merged, 'theirs')
  }
 
  return result.merged
}

import { diffObjects, diffJSON } from '@mdxld/diff'
 
function compareConfigs(oldConfig: object, newConfig: object) {
  // Structured diff for programmatic use
  const structured = diffObjects(oldConfig, newConfig)
 
  if (structured.hasChanges) {
    console.log('Added keys:', Object.keys(structured.added))
    console.log('Removed keys:', Object.keys(structured.removed))
    console.log('Modified keys:', Object.keys(structured.modified))
  }
 
  // Unified diff for display
  const unified = diffJSON(oldConfig, newConfig)
  console.log(unified)
}

import { diffPaths, applyPaths, merge3wayObjects } from '@mdxld/diff'
import { toMarkdown, fromMarkdown } from '@mdxld/markdown'
 
// Load from database
const doc = await db.Document.get(id)
 
// Render for editing
const markdown = toMarkdown(doc)
 
// User edits...
const edited = await editor.edit(markdown)
 
// Extract and compare, leaf path by leaf path
const extracted = fromMarkdown(edited)
const changes = diffPaths(doc, extracted)
 
if (changes.hasChanges) {
  // Show what changed
  console.log('Changes:', changes.modified)
 
  // Save if approved: overlay the extracted paths onto the record
  await db.Document.update(id, applyPaths(doc, extracted))
}
 
// When the record ALSO changed since it was rendered, merge 3-way instead:
const current = await db.Document.get(id)
const { merged, conflicts } = merge3wayObjects(doc, current, applyPaths(doc, extracted))