@cfbender/cesium 0.5.1 → 0.6.0

package/src/render/blocks/diff/myers.ts

@@ -0,0 +1,221 @@
+// Myers O(ND) line-level diff algorithm.
+// src/render/blocks/diff/myers.ts
+//
+// Re-implemented from scratch — no external dependencies.
+// Reference: "An O(ND) Difference Algorithm and Its Variations" — Eugene W. Myers (1986).
+//
+// Implementation follows the standard "trace + backtrack" pattern from:
+// https://blog.jcoglan.com/2017/02/12/the-myers-diff-algorithm-part-1/
+
+import type { DiffLine } from "./parse-unified.ts";
+
+export type { DiffLine };
+
+/**
+ * Split a string into lines, trimming a single trailing empty element when the
+ * input ends with "\n" (so clean files don't produce a phantom blank final line).
+ */
+function splitLines(text: string): string[] {
+  if (text === "") return [];
+  const lines = text.split("\n");
+  // Trim trailing phantom empty line produced by a trailing newline
+  if (lines.length > 0 && lines[lines.length - 1] === "") {
+    lines.pop();
+  }
+  return lines;
+}
+
+// ─── Myers forward pass ───────────────────────────────────────────────────────
+
+/**
+ * Run the Myers forward pass and return the trace (one v[] snapshot per d).
+ * v[k + offset] = furthest row reached on diagonal k at this step.
+ */
+function myersTrace(a: string[], b: string[]): number[][] {
+  const N = a.length;
+  const M = b.length;
+  const MAX = N + M;
+  const offset = MAX;
+
+  const v: number[] = Array.from({ length: 2 * MAX + 2 }, () => 0);
+  v[offset + 1] = 0;
+
+  const trace: number[][] = [];
+
+  for (let d = 0; d <= MAX; d++) {
+    for (let k = -d; k <= d; k += 2) {
+      const ki = k + offset;
+      const vKm1 = v[ki - 1] ?? 0;
+      const vKp1 = v[ki + 1] ?? 0;
+
+      let x: number;
+      if (k === -d || (k !== d && vKm1 < vKp1)) {
+        x = vKp1; // down: insert
+      } else {
+        x = vKm1 + 1; // right: delete
+      }
+
+      let y = x - k;
+
+      // Follow the diagonal (matches)
+      while (x < N && y < M && a[x] === b[y]) {
+        x++;
+        y++;
+      }
+
+      v[ki] = x;
+
+      if (x >= N && y >= M) {
+        trace.push(v.slice());
+        return trace;
+      }
+    }
+
+    trace.push(v.slice());
+  }
+
+  return trace;
+}
+
+// ─── Myers backtrack ──────────────────────────────────────────────────────────
+
+type Edit =
+  | { op: "keep"; aIdx: number; bIdx: number }
+  | { op: "delete"; aIdx: number }
+  | { op: "insert"; bIdx: number };
+
+/**
+ * Backtrack through the trace to produce the edit script.
+ * Reconstructs the path from (N, M) back to (0, 0).
+ */
+function backtrack(a: string[], b: string[], trace: number[][]): Edit[] {
+  const MAX = a.length + b.length;
+  const offset = MAX;
+  const edits: Edit[] = [];
+
+  let x = a.length;
+  let y = b.length;
+
+  // Walk backwards through d steps
+  for (let d = trace.length - 1; d > 0; d--) {
+    const vPrev = trace[d - 1] ?? [];
+    const k = x - y;
+    const ki = k + offset;
+
+    const vPrevKm1 = vPrev[ki - 1] ?? 0;
+    const vPrevKp1 = vPrev[ki + 1] ?? 0;
+
+    // Determine which diagonal we came from
+    let prevK: number;
+    if (k === -d || (k !== d && vPrevKm1 < vPrevKp1)) {
+      prevK = k + 1; // came via down (insert)
+    } else {
+      prevK = k - 1; // came via right (delete)
+    }
+
+    const prevX = vPrev[prevK + offset] ?? 0;
+    const prevY = prevX - prevK;
+
+    // Retrace the snake (diagonal matches) from (prevX, prevY) to (x, y)
+    // but skip the single edit step itself.
+    // After the edit step, we were at:
+    //   insert: (prevX, prevY + 1)
+    //   delete: (prevX + 1, prevY)
+    if (prevK === k + 1) {
+      // insert: moved down, x stays same, y += 1
+      const snakeX = prevX;
+      // snake goes from (snakeX, prevY+1) to (x, y)
+      for (let sx = x - 1; sx >= snakeX; sx--) {
+        const sy = sx - k;
+        edits.push({ op: "keep", aIdx: sx, bIdx: sy });
+      }
+      edits.push({ op: "insert", bIdx: prevY });
+    } else {
+      // delete: moved right, x += 1, y stays same
+      const snakeX = prevX + 1;
+      // snake goes from (snakeX, prevY) to (x, y)
+      for (let sx = x - 1; sx >= snakeX; sx--) {
+        const sy = sx - k;
+        edits.push({ op: "keep", aIdx: sx, bIdx: sy });
+      }
+      edits.push({ op: "delete", aIdx: prevX });
+    }
+
+    x = prevX;
+    y = prevY;
+  }
+
+  // Remaining snake at d=0: (0,0) to (x,y)
+  for (let sx = x - 1; sx >= 0; sx--) {
+    const sy = sx; // k=0 at the start
+    edits.push({ op: "keep", aIdx: sx, bIdx: sy });
+  }
+
+  edits.reverse();
+  return edits;
+}
+
+function myersDiff(a: string[], b: string[]): Edit[] {
+  if (a.length === 0 && b.length === 0) return [];
+  if (a.length === 0) return b.map((_, i) => ({ op: "insert" as const, bIdx: i }));
+  if (b.length === 0) return a.map((_, i) => ({ op: "delete" as const, aIdx: i }));
+
+  const trace = myersTrace(a, b);
+  return backtrack(a, b, trace);
+}
+
+// ─── Public API ───────────────────────────────────────────────────────────────
+
+/**
+ * Compute a line-level diff between two text strings.
+ * Returns a flat DiffLine[] with 1-indexed line numbers per side.
+ * No hunk-sep entries — single contiguous diff.
+ */
+export function diffLines(before: string, after: string): DiffLine[] {
+  const aLines = splitLines(before);
+  const bLines = splitLines(after);
+
+  const edits = myersDiff(aLines, bLines);
+
+  let beforeLine = 1;
+  let afterLine = 1;
+
+  return edits.map((edit): DiffLine => {
+    switch (edit.op) {
+      case "keep": {
+        const text = aLines[edit.aIdx] ?? "";
+        const entry: DiffLine = {
+          kind: "context",
+          text,
+          beforeLineNum: beforeLine,
+          afterLineNum: afterLine,
+        };
+        beforeLine++;
+        afterLine++;
+        return entry;
+      }
+      case "delete": {
+        const text = aLines[edit.aIdx] ?? "";
+        const entry: DiffLine = {
+          kind: "remove",
+          text,
+          beforeLineNum: beforeLine,
+          afterLineNum: null,
+        };
+        beforeLine++;
+        return entry;
+      }
+      case "insert": {
+        const text = bLines[edit.bIdx] ?? "";
+        const entry: DiffLine = {
+          kind: "add",
+          text,
+          beforeLineNum: null,
+          afterLineNum: afterLine,
+        };
+        afterLine++;
+        return entry;
+      }
+    }
+  });
+}

package/src/render/blocks/diff/parse-unified.ts

@@ -0,0 +1,101 @@
+// Unified diff parser — converts a unified patch string to a DiffEntry[].
+// src/render/blocks/diff/parse-unified.ts
+
+export type DiffLine = {
+  kind: "context" | "add" | "remove";
+  text: string; // raw text, no leading +/- prefix
+  beforeLineNum: number | null; // 1-indexed line in "before" file, null for adds
+  afterLineNum: number | null; // 1-indexed line in "after" file, null for removes
+};
+
+export type DiffEntry = DiffLine | { kind: "hunk-sep"; oldStart: number; newStart: number };
+
+// Matches: @@ -<oldStart>[,<oldLines>] +<newStart>[,<newLines>] @@
+const HUNK_HEADER = /^@@ -(\d+)(?:,(\d+))? \+(\d+)(?:,(\d+))? @@/;
+
+/**
+ * Parse a unified diff patch string into a DiffEntry[].
+ * Returns null if no hunk header is found (caller falls back to plaintext).
+ */
+export function parseUnifiedDiff(patch: string): DiffEntry[] | null {
+  const lines = patch.split("\n");
+  const result: DiffEntry[] = [];
+  let foundHunk = false;
+  let firstHunk = true;
+
+  // Counters for current hunk position
+  let beforeLine = 0;
+  let afterLine = 0;
+
+  for (const line of lines) {
+    // Skip file header lines (--- / +++ at the very top)
+    if (line.startsWith("--- ") || line.startsWith("+++ ")) {
+      continue;
+    }
+
+    // Check for hunk header
+    const hunkMatch = HUNK_HEADER.exec(line);
+    if (hunkMatch !== null) {
+      const oldStart = parseInt(hunkMatch[1] ?? "1", 10);
+      const newStart = parseInt(hunkMatch[3] ?? "1", 10);
+
+      if (!firstHunk) {
+        // Emit hunk separator between hunks
+        result.push({ kind: "hunk-sep", oldStart, newStart });
+      }
+      firstHunk = false;
+      foundHunk = true;
+
+      beforeLine = oldStart;
+      afterLine = newStart;
+      continue;
+    }
+
+    if (!foundHunk) {
+      // Haven't seen a hunk header yet — skip pre-header lines
+      continue;
+    }
+
+    // Skip "" markers
+    if (line.startsWith("\\")) {
+      continue;
+    }
+
+    const prefix = line[0];
+    const text = line.slice(1);
+
+    if (prefix === " ") {
+      // Context line — appears on both sides
+      result.push({
+        kind: "context",
+        text,
+        beforeLineNum: beforeLine,
+        afterLineNum: afterLine,
+      });
+      beforeLine++;
+      afterLine++;
+    } else if (prefix === "-") {
+      // Removed line — only in "before"
+      result.push({
+        kind: "remove",
+        text,
+        beforeLineNum: beforeLine,
+        afterLineNum: null,
+      });
+      beforeLine++;
+    } else if (prefix === "+") {
+      // Added line — only in "after"
+      result.push({
+        kind: "add",
+        text,
+        beforeLineNum: null,
+        afterLineNum: afterLine,
+      });
+      afterLine++;
+    }
+    // Any other prefix: skip (e.g. empty lines after hunk body)
+  }
+
+  if (!foundHunk) return null;
+  return result;
+}

package/src/render/blocks/highlight.ts

@@ -13,11 +13,7 @@ import { THEME_PRESETS, isThemePresetName } from "../../render/theme.ts";
 
 // ─── Highlight theme type ─────────────────────────────────────────────────────
 
-export type HighlightTheme =
-  | "claret-dark"
-  | "claret-light"
-  | "vitesse-dark"
-  | "vitesse-light";
+export type HighlightTheme = "claret-dark" | "claret-light" | "vitesse-dark" | "vitesse-light";
 
 // ─── Supported languages ─────────────────────────────────────────────────────
 
@@ -88,12 +84,13 @@ export function resolveHighlightTheme(cesiumThemeName: string | undefined): High
  */
 function isHexDark(hex: string): boolean {
   const clean = hex.replace("#", "");
-  const full = clean.length === 3
-    ? clean
-        .split("")
-        .map((c) => c + c)
-        .join("")
-    : clean;
+  const full =
+    clean.length === 3
+      ? clean
+          .split("")
+          .map((c) => c + c)
+          .join("")
+      : clean;
   const r = parseInt(full.slice(0, 2), 16);
   const g = parseInt(full.slice(2, 4), 16);
   const b = parseInt(full.slice(4, 6), 16);

package/src/render/blocks/markdown.ts

@@ -11,8 +11,7 @@ import { escapeHtml, escapeAttr } from "./escape.ts";
 
 // ─── Safelist placeholder pass ───────────────────────────────────────────────
 
-const SAFELIST_RE =
-  /<(kbd)>(.*?)<\/kbd>|<span\s+class="(pill|tag)">(.*?)<\/span>/gi;
+const SAFELIST_RE = /<(kbd)>(.*?)<\/kbd>|<span\s+class="(pill|tag)">(.*?)<\/span>/gi;
 
 function extractSafelist(input: string): { text: string; map: Map<string, string> } {
   const map = new Map<string, string>();
@@ -72,7 +71,10 @@ function renderInline(text: string): string {
   // **bold**
   working = working.replace(/\*\*(.+?)\*\*/g, (_m, inner: string) => `<strong>${inner}</strong>`);
   // *italic* (not preceded by another *)
-  working = working.replace(/(?<!\*)\*(?!\*)(.+?)(?<!\*)\*(?!\*)/g, (_m, inner: string) => `<em>${inner}</em>`);
+  working = working.replace(
+    /(?<!\*)\*(?!\*)(.+?)(?<!\*)\*(?!\*)/g,
+    (_m, inner: string) => `<em>${inner}</em>`,
+  );
   // [text](href) — only relative/anchor hrefs; external → plain text
   working = working.replace(/\[([^\]]+)\]\(([^)]+)\)/g, (_m, linkText: string, href: string) => {
     if (RELATIVE_HREF_RE.test(href)) {
@@ -159,7 +161,11 @@ export function renderMarkdown(md: string): string {
     // Bullet list
     if (isBullet(line)) {
       const items: string[] = [];
-      while (i < lines.length && (isBullet(lines[i] ?? "") || (!isBlank(lines[i] ?? "") && /^[ \t]{2,}/.test(lines[i] ?? "")))) {
+      while (
+        i < lines.length &&
+        (isBullet(lines[i] ?? "") ||
+          (!isBlank(lines[i] ?? "") && /^[ \t]{2,}/.test(lines[i] ?? "")))
+      ) {
         const cur = lines[i] ?? "";
         if (isBullet(cur)) {
           items.push(renderInline(applyHardBreak(getBulletContent(cur))));
@@ -173,7 +179,11 @@ export function renderMarkdown(md: string): string {
     // Ordered list
     if (isOrdered(line)) {
       const items: string[] = [];
-      while (i < lines.length && (isOrdered(lines[i] ?? "") || (!isBlank(lines[i] ?? "") && /^[ \t]{2,}/.test(lines[i] ?? "")))) {
+      while (
+        i < lines.length &&
+        (isOrdered(lines[i] ?? "") ||
+          (!isBlank(lines[i] ?? "") && /^[ \t]{2,}/.test(lines[i] ?? "")))
+      ) {
         const cur = lines[i] ?? "";
         if (isOrdered(cur)) {
           items.push(renderInline(applyHardBreak(getOrderedContent(cur))));
@@ -187,7 +197,11 @@ export function renderMarkdown(md: string): string {
     // Blockquote
     if (isBlockquote(line)) {
       const bqLines: string[] = [];
-      while (i < lines.length && (isBlockquote(lines[i] ?? "") || (!isBlank(lines[i] ?? "") && !/^[-*]/.test(lines[i] ?? "")))) {
+      while (
+        i < lines.length &&
+        (isBlockquote(lines[i] ?? "") ||
+          (!isBlank(lines[i] ?? "") && !/^[-*]/.test(lines[i] ?? "")))
+      ) {
         const cur = lines[i] ?? "";
         if (isBlockquote(cur)) {
           bqLines.push(renderInline(applyHardBreak(getBlockquoteContent(cur))));
@@ -202,7 +216,14 @@ export function renderMarkdown(md: string): string {
 
     // Paragraph — collect until blank or block-level
     const paraLines: string[] = [];
-    while (i < lines.length && !isBlank(lines[i] ?? "") && !isHr(lines[i] ?? "") && !isBullet(lines[i] ?? "") && !isOrdered(lines[i] ?? "") && !isBlockquote(lines[i] ?? "")) {
+    while (
+      i < lines.length &&
+      !isBlank(lines[i] ?? "") &&
+      !isHr(lines[i] ?? "") &&
+      !isBullet(lines[i] ?? "") &&
+      !isOrdered(lines[i] ?? "") &&
+      !isBlockquote(lines[i] ?? "")
+    ) {
       paraLines.push(applyHardBreak(lines[i] ?? ""));
       i++;
     }

package/src/render/blocks/render.ts

@@ -18,6 +18,7 @@ import { renderPillRow } from "./renderers/pill-row.ts";
 import { renderDivider } from "./renderers/divider.ts";
 import { renderDiagram } from "./renderers/diagram.ts";
 import { renderRawHtml } from "./renderers/raw-html.ts";
+import { renderDiff } from "./renderers/diff.ts";
 
 /** Shared mutable counter — all section renderers increment this via the ctx ref. */
 export interface SectionCounter {
@@ -78,6 +79,8 @@ export async function renderBlock(block: Block, ctx: RenderCtx): Promise<string>
       return renderDiagram(block, ctx);
     case "raw_html":
       return renderRawHtml(block, ctx);
+    case "diff":
+      return renderDiff(block, ctx);
   }
 }
 

package/src/render/blocks/renderers/code.ts

@@ -16,9 +16,7 @@ export async function renderCode(block: CodeBlock, ctx: RenderCtx): Promise<stri
   }
 
   const highlighted = await highlightCode(block.code, block.lang, ctx.highlightTheme);
-  parts.push(
-    `  <pre><code class="lang-${escapeAttr(block.lang)}">${highlighted}</code></pre>`,
-  );
+  parts.push(`  <pre><code class="lang-${escapeAttr(block.lang)}">${highlighted}</code></pre>`);
 
   return `<figure class="code">\n${parts.join("\n")}\n</figure>`;
 }

package/src/render/blocks/renderers/compare-table.ts

@@ -8,9 +8,7 @@ import { escapeHtml } from "../escape.ts";
 import { renderMarkdown } from "../markdown.ts";
 
 export function renderCompareTable(block: CompareTableBlock, _ctx: RenderCtx): string {
-  const headerCells = block.headers
-    .map((h) => `      <th>${escapeHtml(h)}</th>`)
-    .join("\n");
+  const headerCells = block.headers.map((h) => `      <th>${escapeHtml(h)}</th>`).join("\n");
 
   const bodyRows = block.rows
     .map((row) => {
@@ -34,7 +32,8 @@ export function renderCompareTable(block: CompareTableBlock, _ctx: RenderCtx): s
 
 export const meta: BlockMeta = {
   type: "compare_table",
-  description: "Bordered comparison grid. Headers define columns; rows must have matching cell count.",
+  description:
+    "Bordered comparison grid. Headers define columns; rows must have matching cell count.",
   schema: {
     type: "object",
     properties: {

package/src/render/blocks/renderers/diagram.ts

@@ -25,7 +25,7 @@ export function renderDiagram(block: DiagramBlock, _ctx: RenderCtx): string {
 export const meta: BlockMeta = {
   type: "diagram",
   description:
-    "Escape-hatch for inline SVG or bespoke HTML diagrams. Exactly one of svg or html required. Payload is scrubbed. For SVG, prefer fill=\"currentColor\" and stroke=\"currentColor\" so the diagram inherits the theme's text color. Use explicit colors only for emphasis (accents, warnings).",
+    'Escape-hatch for inline SVG or bespoke HTML diagrams. Exactly one of svg or html required. Payload is scrubbed. For SVG, prefer fill="currentColor" and stroke="currentColor" so the diagram inherits the theme\'s text color. Use explicit colors only for emphasis (accents, warnings).',
   schema: {
     type: "object",
     properties: {
@@ -35,10 +35,7 @@ export const meta: BlockMeta = {
       html: { type: "string" },
     },
     required: ["type"],
-    oneOf: [
-      { required: ["svg"] },
-      { required: ["html"] },
-    ],
+    oneOf: [{ required: ["svg"] }, { required: ["html"] }],
   },
   example: {
     type: "diagram",