jsdiff unified patches: create, apply with fuzz, reverse and word diff: working versions (tested 2026-10-15)

{
  "name": "jsdiff-patch-apply",
  "private": true,
  "type": "module",
  "scripts": {
    "test": "node --import tsx --test test/*.test.ts"
  },
  "dependencies": {
    "diff": "9.0.0"
  },
  "devDependencies": {
    "@types/node": "26.6.5",
    "tsx": "4.23.15"
  }
}

import { createTwoFilesPatch, applyPatch, parsePatch, diffWords, diffLines, structuredPatch, reversePatch } from "diff";

export const makePatch = (name: string, before: string, after: string) =>
  createTwoFilesPatch(`a/${name}`, `b/${name}`, before, after, "", "", { context: 2 });

export function apply(source: string, patch: string, fuzzFactor = 0) {
  const out = applyPatch(source, patch, { fuzzFactor });
  return out === false ? null : out;
}

export function undo(patched: string, patch: string) {
  const [p] = parsePatch(patch);
  const out = applyPatch(patched, reversePatch(p));
  return out === false ? null : out;
}

export function stats(before: string, after: string) {
  let added = 0, removed = 0;
  for (const part of diffLines(before, after)) {
    if (part.added) added += part.count ?? 0;
    if (part.removed) removed += part.count ?? 0;
  }
  return { added, removed, hunks: structuredPatch("x", "x", before, after, "", "", { context: 2 }).hunks.length };
}

/** Inline word-level diff rendered with [-old-]{+new+} markers. */
export const wordDiff = (a: string, b: string) =>
  diffWords(a, b).map((p) => (p.added ? `{+${p.value}+}` : p.removed ? `[-${p.value}-]` : p.value)).join("");

import { test } from "node:test";
import assert from "node:assert/strict";
import { makePatch, apply, undo, stats, wordDiff } from "../src/patch.ts";

const before = ["line 1", "line 2", "line 3", "line 4", "line 5", "line 6", "line 7", "line 8", ""].join("\n");
const after = ["line 1", "line two", "line 3", "line 4", "line 5", "line 6", "line 7", "line 8", "line 9", ""].join("\n");

test("unified patch has headers and hunks", () => {
  const p = makePatch("notes.txt", before, after);
  assert.match(p, /^--- a\/notes\.txt/m);
  assert.match(p, /^\+\+\+ b\/notes\.txt/m);
  assert.match(p, /^-line 2$/m);
  assert.match(p, /^\+line two$/m);
  assert.equal((p.match(/^@@/gm) ?? []).length, 2);
});

test("patch applies and reverses", () => {
  const p = makePatch("notes.txt", before, after);
  const patched = apply(before, p);
  assert.equal(patched, after);
  assert.equal(undo(patched!, p), before);
});

test("conflicting source fails without fuzz, succeeds with fuzz", () => {
  const p = makePatch("notes.txt", before, after);
  // jsdiff rule: context lines right next to an insertion must match exactly, so drift a line further away
  const drifted = before.replace("line 4", "line FOUR");
  assert.equal(apply(drifted, p), null);
  const fuzzed = apply(drifted, p, 1);
  assert.ok(fuzzed?.includes("line two"));
  assert.ok(fuzzed?.includes("line FOUR"));
});

test("line stats", () => {
  assert.deepEqual(stats(before, after), { added: 2, removed: 1, hunks: 2 });
});

test("word diff markers", () => {
  assert.equal(wordDiff("wear safety glasses", "wear safety goggles"), "wear safety [-glasses-]{+goggles+}");
});