@kabmo-labs/kabmo 0.8.0 → 0.9.0

package/src/shared/lib/code/lazy-window.ts

@@ -1,156 +0,0 @@
-/**
- * @license
- * SPDX-License-Identifier: Apache-2.0
- */
-
-/**
- * Line geometry and windowing policy for the lazy editor surface.
- *
- * Shiki tokenization is linear in document size (≈0.14 ms per line), so a
- * whole-file highlight costs ~0.8 s at 7 000 lines — and the editor pays it on
- * every keystroke, on top of one gutter node and one wrapped-row measurement
- * per line. A long document therefore renders only the lines the reader can
- * actually see, and this module is the DOM-free half of that: px offsets per
- * line, the viewport → line-range mapping, and the blank space the unrendered
- * lines take up so the caret never leaves its row.
- *
- * The browser measurements this needs (row height, per-line wrapped heights)
- * stay in the surface, which feeds them in as a `LineGeometry`.
- */
-
-/** Documents at or below this size render whole — windowing them saves less than it costs. */
-export const WHOLE_DOCUMENT_MAX_LINES = 300;
-export const WHOLE_DOCUMENT_MAX_CHARS = 20_000;
-
-/** Lines kept beyond the viewport so a fast scroll cannot outrun the window. */
-export const WINDOW_OVERSCAN = 24;
-
-/** Lines rendered before the first measurement lands; the surface corrects this in a layout effect. */
-export const INITIAL_WINDOW_LINES = 200;
-
-/** Half-open line range `[start, end)`. */
-export interface LineWindow {
-  start: number;
-  end: number;
-}
-
-/** Blank space (px) the unrendered lines occupy above and below a window. */
-export interface WindowSpace {
-  top: number;
-  bottom: number;
-  /** The window reaches the document's last line, so it keeps the editor's trailing line break. */
-  breakAtEnd: boolean;
-}
-
-/** A windowed render request: the lines to draw plus the space the rest of the document takes. */
-export interface CodeWindow extends LineWindow, WindowSpace {}
-
-/** Per-line vertical layout of a document, in px. */
-export interface LineGeometry {
-  readonly lineCount: number;
-  /** Height (px) of a single visual row. */
-  readonly rowHeight: number;
-  /** Height (px) of every line together. */
-  readonly totalHeight: number;
-  /** Y offset (px) of the top edge of line `index`; `lineCount` is the document's end. */
-  offsetOf(index: number): number;
-  /** Index of the line covering `y`, clamped to the document. */
-  lineAt(y: number): number;
-}
-
-function clamp(value: number, min: number, max: number): number {
-  return value < min ? min : value > max ? max : value;
-}
-
-/** Whether a document is long enough that rendering all of it would be felt. */
-export function shouldWindow(lineCount: number, charCount: number): boolean {
-  return lineCount > WHOLE_DOCUMENT_MAX_LINES || charCount > WHOLE_DOCUMENT_MAX_CHARS;
-}
-
-/** Word wrap off: every line is exactly one row, so no measurement is involved. */
-export function uniformGeometry(rowHeight: number, lineCount: number): LineGeometry {
-  return {
-    lineCount,
-    rowHeight,
-    totalHeight: rowHeight * lineCount,
-    offsetOf: (index) => rowHeight * clamp(index, 0, lineCount),
-    lineAt: (y) => clamp(Math.floor(y / rowHeight), 0, Math.max(lineCount - 1, 0)),
-  };
-}
-
-/**
- * Word wrap on: heights are the measured wrapped heights, one entry per line.
- * Returns `null` when they do not describe every line, which leaves the caller
- * on the whole-document path rather than spacing lines with a wrong geometry.
- */
-export function measuredGeometry(heights: number[], rowHeight: number, lineCount: number): LineGeometry | null {
-  if (lineCount === 0 || heights.length !== lineCount) return null;
-  const offsets = new Float64Array(lineCount + 1);
-  for (let i = 0; i < lineCount; i++) offsets[i + 1] = offsets[i] + heights[i];
-  const total = offsets[lineCount];
-  return {
-    lineCount,
-    rowHeight,
-    totalHeight: total,
-    offsetOf: (index) => offsets[clamp(index, 0, lineCount)],
-    lineAt: (y) => {
-      if (y < 0) return 0;
-      if (total <= 0 || y >= total) return lineCount - 1;
-      // Last line whose top edge sits at or above `y`.
-      let low = 0;
-      let high = lineCount - 1;
-      while (low < high) {
-        const mid = (low + high + 1) >> 1;
-        if (offsets[mid] <= y) low = mid;
-        else high = mid - 1;
-      }
-      return low;
-    },
-  };
-}
-
-/** The lines a viewport band (`top`, `height`) covers, plus overscan on both sides. */
-export function resolveWindow(
-  geometry: LineGeometry,
-  top: number,
-  height: number,
-  overscan: number = WINDOW_OVERSCAN,
-): LineWindow {
-  const first = geometry.lineAt(top);
-  const last = geometry.lineAt(top + Math.max(height, 0));
-  return {
-    start: Math.max(0, first - overscan),
-    end: Math.min(geometry.lineCount, Math.max(last + 1, first + 1) + overscan),
-  };
-}
-
-/** What a freshly opened document renders before its viewport has been read. */
-export function firstWindow(lineCount: number): LineWindow {
-  return { start: 0, end: clamp(INITIAL_WINDOW_LINES, 1, Math.max(lineCount, 1)) };
-}
-
-/** Keep a window inside the document it belongs to (the state may predate a file switch). */
-export function clampWindow(window: LineWindow, lineCount: number): LineWindow {
-  const start = clamp(window.start, 0, Math.max(lineCount - 1, 0));
-  return { start, end: clamp(window.end, start + 1, Math.max(lineCount, 1)) };
-}
-
-export function sameWindow(a: LineWindow | null, b: LineWindow | null): boolean {
-  return a === b || (a !== null && b !== null && a.start === b.start && a.end === b.end);
-}
-
-/** Space the unrendered lines take around `window`, and whether it ends the document. */
-export function windowSpace(geometry: LineGeometry, window: LineWindow): WindowSpace {
-  const top = geometry.offsetOf(window.start);
-  return {
-    top,
-    bottom: Math.max(0, geometry.totalHeight - geometry.offsetOf(window.end)),
-    breakAtEnd: window.end >= geometry.lineCount,
-  };
-}
-
-/** Clamp a window to its document and resolve the space it leaves around itself. */
-export function codeWindow(geometry: LineGeometry, window: LineWindow): CodeWindow {
-  const clamped = clampWindow(window, geometry.lineCount);
-  return { ...clamped, ...windowSpace(geometry, clamped) };
-}

package/src/shared/lib/code/windowed-highlight.ts

@@ -1,114 +0,0 @@
-/**
- * @license
- * SPDX-License-Identifier: Apache-2.0
- */
-
-import type { LineWindow } from '@/shared/lib/code/lazy-window';
-import type { FindMatch } from '@/shared/lib/code/editor/find';
-import { lineStartOffset } from '@/shared/lib/code/editor/lines';
-import { highlightLines } from '@/shared/lib/code/syntax-highlight';
-
-/**
- * Lines tokenized *above* the window and dropped from the result. They only
- * seed the grammar state, so a window that starts inside a block comment or a
- * template literal still tokenizes as a comment / template literal. Tokenizing
- * them costs a fraction of the window itself; carrying the whole document as
- * context would defeat the point of windowing at all.
- */
-const CONTEXT_LINES = 40;
-
-/**
- * Lines at or above this length render as plain text. A minified bundle is one
- * line of hundreds of KB, which the tokenizer would chew through on every
- * scroll; the cap keeps that bounded, exactly like Shiki's own
- * `tokenizeMaxLineLength` bail-out.
- */
-const MAX_LINE_CHARS = 12_000;
-
-export interface HighlightCodeWindowOptions {
-  /** Lines of grammar context above the window. */
-  contextLines?: number;
-  /** Length at which a line falls back to plain text. */
-  maxLineLength?: number;
-  /**
-   * Find matches in DOCUMENT offsets. Only those inside the rendered window are
-   * passed on, re-based to the sliced source the tokenizer sees.
-   */
-  marks?: readonly FindMatch[];
-  /** Index of the current match within `marks`. */
-  currentMark?: number;
-  /** Marks from this index on are extra ⌘D selections rather than find matches. */
-  occurrenceFrom?: number;
-}
-
-/**
- * Shiki markup for lines `[window.start, window.end)` of `code`, joined with
- * newlines so it can be dropped straight into the editor's `<pre>`. The caller
- * reserves the space of the lines it is not given (`lazy-window`'s
- * `windowSpace`), which is what keeps the caret over its own row.
- *
- * The rows are wrapped in `.shiki` — the app colours tokens through the
- * `.shiki span { color: var(--shiki-light) }` rule (`tailwind.css`), so markup
- * that skipped the wrapper would render in the plain ink colour. Every other
- * consumer of `highlightLines` carries the same class.
- *
- * Editing is unaffected: the `<textarea>` above the highlight layer always
- * holds the full document — only the markup is windowed.
- */
-export function highlightCodeWindow(
-  code: string,
-  language: string,
-  window: LineWindow,
-  options: HighlightCodeWindowOptions = {},
-): string {
-  const { contextLines = CONTEXT_LINES, maxLineLength = MAX_LINE_CHARS } = options;
-  const lines = code.split('\n');
-  const start = Math.min(Math.max(window.start, 0), lines.length);
-  const end = Math.min(Math.max(window.end, start), lines.length);
-  if (start === end) return '';
-
-  const contextStart = Math.max(0, start - contextLines);
-  const slice = lines.slice(contextStart, end).join('\n');
-  const base = lineStartOffset(code, contextStart);
-  const sliceEnd = base + slice.length;
-  const { marks, currentMark, occurrenceFrom } = rebaseMarks(
-    options.marks,
-    options.currentMark ?? -1,
-    options.occurrenceFrom ?? -1,
-    base,
-    sliceEnd,
-  );
-  const rows = highlightLines(slice, language, { maxLineLength, marks, currentMark, occurrenceFrom });
-  const offset = start - contextStart;
-  return `<span class="shiki">${rows.slice(offset, offset + (end - start)).join('\n')}</span>`;
-}
-
-/**
- * The marks inside `[base, sliceEnd)`, shifted to slice coordinates, with the
- * current-match index remapped — the index points into the full list, so the
- * rows below the window cannot simply reuse it.
- */
-function rebaseMarks(
-  marks: readonly FindMatch[] | undefined,
-  currentMark: number,
-  occurrenceFrom: number,
-  base: number,
-  sliceEnd: number,
-): { marks: FindMatch[]; currentMark: number; occurrenceFrom: number } {
-  if (!marks || marks.length === 0) return { marks: [], currentMark: -1, occurrenceFrom: -1 };
-  const kept: FindMatch[] = [];
-  let remapped = -1;
-  let remappedOccurrenceFrom = -1;
-  for (let index = 0; index < marks.length; index++) {
-    const mark = marks[index];
-    if (mark.end <= base) continue;
-    if (mark.start >= sliceEnd) break;
-    if (index === currentMark) remapped = kept.length;
-    // The first surviving occurrence keeps the split, wherever it landed: a
-    // window whose opening lines held only matches still has to paint the
-    // selections below them differently.
-    if (remappedOccurrenceFrom === -1 && occurrenceFrom >= 0 && index >= occurrenceFrom) remappedOccurrenceFrom = kept.length;
-    kept.push({ start: mark.start - base, end: Math.min(mark.end, sliceEnd) - base });
-  }
-  return { marks: kept, currentMark: remapped, occurrenceFrom: remappedOccurrenceFrom };
-}

package/src/shared/lib/fs/diff-parser.test.ts

@@ -1,116 +0,0 @@
-/**
- * @license
- * SPDX-License-Identifier: Apache-2.0
- */
-
-/**
- * The whitespace toggle's contract. Trimming the displayed text left a
- * whitespace-only rewrite painted red/green and counted in `+n/-n`, so the
- * toggle changed the glyphs and nothing else — these cases pin the behavior a
- * reader actually expects from it.
- */
-
-import { describe, expect, test } from 'bun:test';
-
-import { parseUnifiedDiff } from '@/shared/lib/fs/diff-parser';
-
-const WHITESPACE_ONLY = [
-  'diff --git a/ws.ts b/ws.ts',
-  'index 46378b4..c824424 100644',
-  '--- a/ws.ts',
-  '+++ b/ws.ts',
-  '@@ -1,3 +1,3 @@',
-  ' function ws() {',
-  '-  return 1;',
-  '+    return 1;',
-  ' }',
-  '',
-].join('\n');
-
-const REAL_CHANGE = [
-  'diff --git a/main.ts b/main.ts',
-  '--- a/main.ts',
-  '+++ b/main.ts',
-  '@@ -1,2 +1,2 @@',
-  ' export const a = 1;',
-  '-export function f() { return a; }',
-  '+export function f() { return a + 1; }',
-  '',
-].join('\n');
-
-const MIXED = [
-  'diff --git a/mixed.ts b/mixed.ts',
-  '--- a/mixed.ts',
-  '+++ b/mixed.ts',
-  '@@ -1,3 +1,3 @@',
-  '-  const a = 1;',
-  '+    const a = 1;',
-  '-  const b = 2;',
-  '+  const b = 3;',
-  '',
-].join('\n');
-
-describe('parseUnifiedDiff', () => {
-  test('counts and marks a whitespace-only rewrite by default', () => {
-    const { lines, additions, deletions } = parseUnifiedDiff(WHITESPACE_ONLY);
-
-    expect(additions).toBe(1);
-    expect(deletions).toBe(1);
-    expect(lines.filter((l) => l.type === 'add')).toHaveLength(1);
-    expect(lines.filter((l) => l.type === 'del')).toHaveLength(1);
-  });
-
-  test('folds a whitespace-only rewrite into context when ignoring whitespace', () => {
-    const { lines, splitRows, additions, deletions } = parseUnifiedDiff(WHITESPACE_ONLY, { ignoreWhitespace: true });
-
-    // The counts the toolbar renders must match what is on screen.
-    expect(additions).toBe(0);
-    expect(deletions).toBe(0);
-    expect(lines.some((l) => l.type === 'add' || l.type === 'del')).toBe(false);
-
-    const folded = lines.find((l) => l.type === 'context' && l.oldLineNumber === 2);
-    expect(folded?.newLineNumber).toBe(2);
-    expect(folded?.text).toBe('    return 1;');
-
-    // Split view reads the same decision — it is built by the same flush.
-    const row = splitRows.find((r) => r.left?.lineNumber === 2);
-    expect(row?.left?.type).toBe('context');
-    expect(row?.right?.type).toBe('context');
-    expect(row?.left?.text).toBe('  return 1;');
-    expect(row?.right?.text).toBe('    return 1;');
-  });
-
-  test('keeps a real change when ignoring whitespace', () => {
-    const { lines, additions, deletions } = parseUnifiedDiff(REAL_CHANGE, { ignoreWhitespace: true });
-
-    expect(additions).toBe(1);
-    expect(deletions).toBe(1);
-    expect(lines.find((l) => l.type === 'del')?.text).toBe('export function f() { return a; }');
-    expect(lines.find((l) => l.type === 'add')?.text).toBe('export function f() { return a + 1; }');
-  });
-
-  test('folds only the whitespace pair of a mixed hunk', () => {
-    const { lines, additions, deletions } = parseUnifiedDiff(MIXED, { ignoreWhitespace: true });
-
-    // Line 1 differs by indentation only; line 2 is a genuine edit.
-    expect(additions).toBe(1);
-    expect(deletions).toBe(1);
-    expect(lines.filter((l) => l.type === 'del').map((l) => l.text)).toEqual(['  const b = 2;']);
-    expect(lines.filter((l) => l.type === 'add').map((l) => l.text)).toEqual(['  const b = 3;']);
-  });
-
-  test('emits unified lines in diff order (deletions before additions)', () => {
-    const { lines } = parseUnifiedDiff(REAL_CHANGE);
-    const kinds = lines.map((l) => l.type);
-
-    // A git diff ends with a newline, which `split` turns into one trailing
-    // empty context line — pre-existing, and the same row the view has always
-    // drawn under the last change.
-    expect(kinds.slice(0, 4)).toEqual(['meta', 'context', 'del', 'add']);
-  });
-
-  test('returns empty results for an empty diff', () => {
-    expect(parseUnifiedDiff('', { ignoreWhitespace: true })).toEqual({ lines: [], splitRows: [], additions: 0, deletions: 0 });
-    expect(parseUnifiedDiff('   \n', { ignoreWhitespace: false })).toEqual({ lines: [], splitRows: [], additions: 0, deletions: 0 });
-  });
-});

package/src/shared/lib/fs/diff-parser.ts

@@ -1,213 +0,0 @@
-export interface DiffLine {
-  type: 'add' | 'del' | 'context' | 'meta';
-  text: string;
-  oldLineNumber?: number;
-  newLineNumber?: number;
-}
-
-export interface SplitDiffRow {
-  left?: { type: 'del' | 'context'; text: string; lineNumber: number };
-  right?: { type: 'add' | 'context'; text: string; lineNumber: number };
-  isMeta?: boolean;
-  metaText?: string;
-}
-
-/** A buffered `-`/`+` line, before it is decided whether it is a real change. */
-interface PendingChange {
-  text: string;
-  lineNumber: number;
-}
-
-/**
- * Parse a unified diff into the flat line list (Unified view) and the paired
- * row list (Split view), plus the addition/deletion counts the toolbar shows.
- *
- * Both outputs are produced by the same flush, so a decision made here cannot
- * land in one view and not the other.
- *
- * With `ignoreWhitespace`, a `-`/`+` pair whose text differs only in whitespace
- * is folded back into context: the change is still in the file, but the reader
- * asked not to be shown formatting noise. Merely trimming the displayed text —
- * which is what this used to do — left the row painted red/green and counted in
- * `+n/-n`, so the toggle changed the glyphs and nothing else.
- */
-export interface ParseDiffOptions {
-  /** Fold `-`/`+` pairs that differ only in whitespace back into context. */
-  ignoreWhitespace?: boolean;
-  /**
-   * Which view the caller renders. Both views are built from one flush so a
-   * decision cannot land in one and not the other, but building the one nobody
-   * shows doubled the allocations on a full-context diff — an 80k-line file
-   * produced ~60k discarded `SplitDiffRow` objects. `'both'` is the default so
-   * the counts and the shared flush stay exactly as they were.
-   */
-  views?: 'unified' | 'split' | 'both';
-}
-
-export function parseUnifiedDiff(rawDiff: string, options: ParseDiffOptions = {}): {
-  lines: DiffLine[];
-  splitRows: SplitDiffRow[];
-  additions: number;
-  deletions: number;
-} {
-  const ignoreWhitespace = options.ignoreWhitespace ?? false;
-  const views = options.views ?? 'both';
-  const wantUnified = views !== 'split';
-  const wantSplit = views !== 'unified';
-  const lines: DiffLine[] = [];
-  const splitRows: SplitDiffRow[] = [];
-  let additions = 0;
-  let deletions = 0;
-
-  if (!rawDiff || !rawDiff.trim()) {
-    return { lines, splitRows, additions, deletions };
-  }
-
-  const rawLines = rawDiff.split(/\r?\n/);
-  const hasHunk = rawLines.some((l) => l.startsWith('@@'));
-  const linesToProcess = hasHunk
-    ? rawLines
-    : [`@@ -1,${rawLines.length} +1,${rawLines.length} @@`, ...rawLines];
-
-  let oldCounter = 1;
-  let newCounter = 1;
-
-  // Consecutive deletions and additions, paired up in split view.
-  let delBuffer: PendingChange[] = [];
-  let addBuffer: PendingChange[] = [];
-
-  const flushBuffers = () => {
-    const maxLen = Math.max(delBuffer.length, addBuffer.length);
-    // A whitespace-only rewrite is decided per pair, but the flat line list
-    // keeps unified-diff order (every `-` of the group, then every `+`), which
-    // is what the original loop produced as it walked the raw diff.
-    const folded = new Array<boolean>(maxLen).fill(false);
-    if (ignoreWhitespace) {
-      for (let i = 0; i < maxLen; i++) {
-        const del = delBuffer[i];
-        const add = addBuffer[i];
-        folded[i] = Boolean(del && add && del.text.trim() === add.text.trim());
-      }
-    }
-
-    if (wantUnified) {
-      for (let i = 0; i < delBuffer.length; i++) {
-        const del = delBuffer[i];
-        const add = addBuffer[i];
-        if (folded[i] && add) {
-          // Show it as unchanged on both sides: the change is still in the file,
-          // the reader asked not to be shown formatting noise.
-          lines.push({
-            type: 'context',
-            // The new form, so the row reads as the file's current state.
-            text: add.text,
-            oldLineNumber: del.lineNumber,
-            newLineNumber: add.lineNumber,
-          });
-          continue;
-        }
-        lines.push({ type: 'del', text: del.text, oldLineNumber: del.lineNumber });
-      }
-      for (let i = 0; i < addBuffer.length; i++) {
-        const add = addBuffer[i];
-        if (folded[i]) continue;
-        lines.push({ type: 'add', text: add.text, newLineNumber: add.lineNumber });
-      }
-    }
-
-    if (wantSplit) {
-      for (let i = 0; i < maxLen; i++) {
-        const del = delBuffer[i];
-        const add = addBuffer[i];
-        if (folded[i] && del && add) {
-          splitRows.push({
-            left: { type: 'context', text: del.text, lineNumber: del.lineNumber },
-            right: { type: 'context', text: add.text, lineNumber: add.lineNumber },
-          });
-          continue;
-        }
-        splitRows.push({
-          left: del ? { type: 'del', text: del.text, lineNumber: del.lineNumber } : undefined,
-          right: add ? { type: 'add', text: add.text, lineNumber: add.lineNumber } : undefined,
-        });
-      }
-    }
-    delBuffer = [];
-    addBuffer = [];
-  };
-
-  for (const rawLine of linesToProcess) {
-    if (
-      rawLine.startsWith('diff --git') ||
-      rawLine.startsWith('index ') ||
-      rawLine.startsWith('---') ||
-      rawLine.startsWith('+++') ||
-      rawLine.startsWith('new file mode') ||
-      rawLine.startsWith('deleted file mode') ||
-      rawLine.startsWith('similarity index') ||
-      rawLine.startsWith('old mode') ||
-      rawLine.startsWith('new mode') ||
-      rawLine.startsWith('\\ No newline')
-    ) {
-      continue;
-    }
-
-    if (rawLine.startsWith('@@')) {
-      flushBuffers();
-      const match = rawLine.match(/@@ -(\d+)(?:,\d+)? \+(\d+)(?:,\d+)? @@/);
-      if (match) {
-        oldCounter = parseInt(match[1], 10);
-        newCounter = parseInt(match[2], 10);
-      }
-      lines.push({ type: 'meta', text: rawLine });
-      splitRows.push({ isMeta: true, metaText: rawLine });
-      continue;
-    }
-
-    if (rawLine.startsWith('+')) {
-      const text = rawLine.slice(1);
-      additions++;
-      addBuffer.push({ text, lineNumber: newCounter });
-      newCounter++;
-    } else if (rawLine.startsWith('-')) {
-      const text = rawLine.slice(1);
-      deletions++;
-      delBuffer.push({ text, lineNumber: oldCounter });
-      oldCounter++;
-    } else {
-      flushBuffers();
-      const text = rawLine.startsWith(' ') ? rawLine.slice(1) : rawLine;
-      if (wantUnified) {
-        lines.push({
-          type: 'context',
-          text,
-          oldLineNumber: oldCounter,
-          newLineNumber: newCounter,
-        });
-      }
-      if (wantSplit) {
-        splitRows.push({
-          left: { type: 'context', text, lineNumber: oldCounter },
-          right: { type: 'context', text, lineNumber: newCounter },
-        });
-      }
-      oldCounter++;
-      newCounter++;
-    }
-  }
-
-  flushBuffers();
-
-  if (ignoreWhitespace) {
-    // The counts were tallied before the pairs could be folded, so re-derive
-    // them from what is actually shown.
-    additions = 0;
-    deletions = 0;
-    for (const line of lines) {
-      if (line.type === 'add') additions++;
-      else if (line.type === 'del') deletions++;
-    }
-  }
-
-  return { lines, splitRows, additions, deletions };
-}