fix: TypeScript undefined issue

Author: ekaone

.github/workflows/release.yml

@@ -20,7 +20,7 @@ jobs:
       - name: Setup pnpm
         uses: pnpm/action-setup@v4
         with:
-          version: latest
+          version: 10
 
       - name: Setup Node.js
         uses: actions/setup-node@v4

src/diff-stats.ts

@@ -0,0 +1,22 @@
+import type { DiffLine, DiffStats } from "./types.js";
+
+/**
+ * Compute summary statistics from a DiffLine array.
+ *
+ * @param lines - Output from diff()
+ * @returns DiffStats — { added, removed, unchanged }
+ *
+ * @example
+ * const lines = diff(a, b);
+ * const stats = diffStats(lines);
+ * // { added: 2, removed: 1, unchanged: 5 }
+ */
+export function diffStats(lines: DiffLine[]): DiffStats {
+  return lines.reduce<DiffStats>(
+    (acc, line) => {
+      acc[line.type]++;
+      return acc;
+    },
+    { added: 0, removed: 0, unchanged: 0 },
+  );
+}

src/diff.ts

@@ -0,0 +1,62 @@
+import type { DiffLine } from "./types.js";
+
+function lcs(a: string[], b: string[]): number[][] {
+  const m = a.length;
+  const n = b.length;
+  const dp: number[][] = Array.from({ length: m + 1 }, () =>
+    new Array(n + 1).fill(0),
+  );
+  for (let i = 1; i <= m; i++) {
+    const row = dp[i]!;
+    const prevRow = dp[i - 1]!;
+    for (let j = 1; j <= n; j++) {
+      row[j] =
+        a[i - 1] === b[j - 1]
+          ? prevRow[j - 1]! + 1
+          : Math.max(prevRow[j]!, row[j - 1]!);
+    }
+  }
+  return dp;
+}
+
+/**
+ * Compute a line-by-line diff between two strings.
+ * Returns an array of DiffLine objects with type and content.
+ *
+ * @param a - Original string
+ * @param b - Modified string
+ * @returns DiffLine[]
+ *
+ * @example
+ * const lines = diff("hello\nworld", "hello\nearth");
+ * // [
+ * //   { type: "unchanged", content: "hello" },
+ * //   { type: "removed",  content: "world" },
+ * //   { type: "added",    content: "earth" },
+ * // ]
+ */
+export function diff(a: string, b: string): DiffLine[] {
+  const aLines = a === "" ? [] : a.split("\n");
+  const bLines = b === "" ? [] : b.split("\n");
+  const dp = lcs(aLines, bLines);
+
+  const result: DiffLine[] = [];
+  let i = aLines.length;
+  let j = bLines.length;
+
+  while (i > 0 || j > 0) {
+    if (i > 0 && j > 0 && aLines[i - 1] === bLines[j - 1]) {
+      result.unshift({ type: "unchanged", content: aLines[i - 1]! });
+      i--;
+      j--;
+    } else if (j > 0 && (i === 0 || dp[i]![j - 1]! >= dp[i - 1]![j]!)) {
+      result.unshift({ type: "added", content: bLines[j - 1]! });
+      j--;
+    } else {
+      result.unshift({ type: "removed", content: aLines[i - 1]! });
+      i--;
+    }
+  }
+
+  return result;
+}

src/format-diff.ts

@@ -0,0 +1,58 @@
+import type { DiffLine, DiffOptions } from "./types.js";
+
+interface Chunk {
+  start: number;
+  end: number;
+}
+
+/**
+ * Group a DiffLine array into chunks of changed lines
+ * surrounded by unchanged context lines.
+ *
+ * @param lines - Output from diff()
+ * @param options - DiffOptions (context: number of surrounding lines, default 3)
+ * @returns DiffLine[][] — array of chunks, each chunk is a DiffLine[]
+ *
+ * @example
+ * const lines = diff(a, b);
+ * const chunks = formatDiff(lines, { context: 3 });
+ * chunks.forEach(chunk => chunk.forEach(line => console.log(line)));
+ */
+export function formatDiff(
+  lines: DiffLine[],
+  options: DiffOptions = {},
+): DiffLine[][] {
+  const context = options.context ?? 3;
+
+  if (context < 0) {
+    throw new RangeError("context must be >= 0");
+  }
+
+  const chunks: Chunk[] = [];
+
+  for (let i = 0; i < lines.length; i++) {
+    if (lines[i]!.type !== "unchanged") {
+      const start = Math.max(0, i - context);
+      const end = Math.min(lines.length - 1, i + context);
+      chunks.push({ start, end });
+    }
+  }
+
+  // merge overlapping / adjacent chunks
+  const merged: Chunk[] = [];
+  for (const chunk of chunks) {
+    if (
+      merged.length > 0 &&
+      chunk.start <= merged[merged.length - 1]!.end + 1
+    ) {
+      merged[merged.length - 1]!.end = Math.max(
+        merged[merged.length - 1]!.end!,
+        chunk.end,
+      );
+    } else {
+      merged.push({ ...chunk });
+    }
+  }
+
+  return merged.map(({ start, end }) => lines.slice(start, end + 1));
+}

src/index.ts

@@ -5,3 +5,8 @@
  * @website https://prasetia.me
  * @license MIT
  */
+
+export { diff } from "./diff.js";
+export { formatDiff } from "./format-diff.js";
+export { diffStats } from "./diff-stats.js";
+export type { DiffLine, DiffType, DiffOptions, DiffStats } from "./types.js";

src/types.ts

@@ -1,3 +1,16 @@
-/**
- * Configuration options.
- */
+export type DiffType = "added" | "removed" | "unchanged";
+
+export interface DiffLine {
+  type: DiffType;
+  content: string;
+}
+
+export interface DiffOptions {
+  context?: number;
+}
+
+export interface DiffStats {
+  added: number;
+  removed: number;
+  unchanged: number;
+}

tests/index.test.ts

@@ -0,0 +1,145 @@
+import { describe, it, expect } from "vitest";
+import { diff, formatDiff, diffStats } from "../src/index.js";
+
+// ── diff() ────────────────────────────────────────────────────────────────────
+
+describe("diff()", () => {
+  it("returns empty array for identical strings", () => {
+    const lines = diff("hello\nworld", "hello\nworld");
+    expect(lines.every((l) => l.type === "unchanged")).toBe(true);
+  });
+
+  it("detects added lines", () => {
+    const lines = diff("hello", "hello\nworld");
+    expect(lines).toContainEqual({ type: "added", content: "world" });
+  });
+
+  it("detects removed lines", () => {
+    const lines = diff("hello\nworld", "hello");
+    expect(lines).toContainEqual({ type: "removed", content: "world" });
+  });
+
+  it("detects changed lines as remove + add", () => {
+    const lines = diff("hello\nworld", "hello\nearth");
+    expect(lines).toContainEqual({ type: "removed", content: "world" });
+    expect(lines).toContainEqual({ type: "added", content: "earth" });
+  });
+
+  it("handles empty original string", () => {
+    const lines = diff("", "hello\nworld");
+    expect(lines.every((l) => l.type === "added")).toBe(true);
+  });
+
+  it("handles empty modified string", () => {
+    const lines = diff("hello\nworld", "");
+    expect(lines.every((l) => l.type === "removed")).toBe(true);
+  });
+
+  it("handles both empty strings", () => {
+    const lines = diff("", "");
+    expect(lines).toEqual([]);
+  });
+
+  it("preserves line order", () => {
+    const lines = diff("a\nb\nc", "a\nx\nc");
+    expect(lines[0]).toEqual({ type: "unchanged", content: "a" });
+    expect(lines[lines.length - 1]).toEqual({
+      type: "unchanged",
+      content: "c",
+    });
+  });
+
+  it("handles single line change", () => {
+    const lines = diff("foo", "bar");
+    expect(lines).toContainEqual({ type: "removed", content: "foo" });
+    expect(lines).toContainEqual({ type: "added", content: "bar" });
+  });
+
+  it("handles multiline with multiple changes", () => {
+    const a = "a\nb\nc\nd\ne";
+    const b = "a\nB\nc\nD\ne";
+    const lines = diff(a, b);
+    const changed = lines.filter((l) => l.type !== "unchanged");
+    expect(changed.length).toBe(4);
+  });
+});
+
+// ── formatDiff() ──────────────────────────────────────────────────────────────
+
+describe("formatDiff()", () => {
+  it("returns empty array when no changes", () => {
+    const lines = diff("hello\nworld", "hello\nworld");
+    expect(formatDiff(lines)).toEqual([]);
+  });
+
+  it("returns one chunk for a single change", () => {
+    const lines = diff("a\nb\nc", "a\nx\nc");
+    const chunks = formatDiff(lines, { context: 1 });
+    expect(chunks.length).toBe(1);
+  });
+
+  it("respects context: 0", () => {
+    const lines = diff("a\nb\nc", "a\nx\nc");
+    const chunks = formatDiff(lines, { context: 0 });
+    expect(chunks[0].every((l) => l.type !== "unchanged")).toBe(true);
+  });
+
+  it("merges adjacent chunks", () => {
+    const a = "1\n2\n3\n4\n5";
+    const b = "1\nX\n3\nX\n5";
+    const chunks = formatDiff(diff(a, b), { context: 0 });
+    // both changes are close — with context 1 they should merge
+    const chunksCtx1 = formatDiff(diff(a, b), { context: 1 });
+    expect(chunksCtx1.length).toBeLessThanOrEqual(chunks.length);
+  });
+
+  it("uses default context of 3", () => {
+    const lines = diff("a\nb\nc\nd\ne\nf\ng", "a\nb\nc\nX\ne\nf\ng");
+    const chunks = formatDiff(lines);
+    // should include 3 lines of context around the change
+    expect(chunks[0].length).toBeGreaterThanOrEqual(3);
+  });
+
+  it("throws on negative context", () => {
+    const lines = diff("a", "b");
+    expect(() => formatDiff(lines, { context: -1 })).toThrow(RangeError);
+  });
+
+  it("does not exceed array bounds with large context", () => {
+    const lines = diff("a\nb", "a\nx");
+    expect(() => formatDiff(lines, { context: 100 })).not.toThrow();
+  });
+});
+
+// ── diffStats() ───────────────────────────────────────────────────────────────
+
+describe("diffStats()", () => {
+  it("returns all unchanged for identical strings", () => {
+    const stats = diffStats(diff("hello\nworld", "hello\nworld"));
+    expect(stats.added).toBe(0);
+    expect(stats.removed).toBe(0);
+    expect(stats.unchanged).toBe(2);
+  });
+
+  it("counts added lines correctly", () => {
+    const stats = diffStats(diff("a", "a\nb\nc"));
+    expect(stats.added).toBe(2);
+  });
+
+  it("counts removed lines correctly", () => {
+    const stats = diffStats(diff("a\nb\nc", "a"));
+    expect(stats.removed).toBe(2);
+  });
+
+  it("counts mixed changes correctly", () => {
+    const stats = diffStats(diff("a\nb\nc", "a\nx\nc"));
+    expect(stats.added).toBe(1);
+    expect(stats.removed).toBe(1);
+    expect(stats.unchanged).toBe(2);
+  });
+
+  it("returns zeros for empty input", () => {
+    const stats = diffStats([]);
+    expect(stats).toEqual({ added: 0, removed: 0, unchanged: 0 });
+  });
+});