@kabmo-labs/kabmo 0.7.0 → 0.9.0

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

@@ -1,161 +0,0 @@
-/**
- * @license
- * SPDX-License-Identifier: Apache-2.0
- */
-
-import { describe, expect, test } from 'bun:test';
-
-import {
-  codeWindow,
-  clampWindow,
-  firstWindow,
-  measuredGeometry,
-  resolveWindow,
-  shouldWindow,
-  uniformGeometry,
-  windowSpace,
-  WHOLE_DOCUMENT_MAX_CHARS,
-  WHOLE_DOCUMENT_MAX_LINES,
-  WINDOW_OVERSCAN,
-  type LineGeometry,
-} from '@/shared/lib/code/lazy-window';
-
-const ROW = 18;
-
-/** `measuredGeometry` returns null for heights that do not fit the document. */
-function measured(heights: number[]): LineGeometry {
-  const geometry = measuredGeometry(heights, ROW, heights.length);
-  if (!geometry) throw new Error('heights should describe every line');
-  return geometry;
-}
-
-describe('shouldWindow', () => {
-  test('leaves a short document on the plain surface', () => {
-    expect(shouldWindow(120, 4_000)).toBe(false);
-  });
-
-  test('windows a document that is long in lines or in characters', () => {
-    expect(shouldWindow(WHOLE_DOCUMENT_MAX_LINES + 1, 10)).toBe(true);
-    expect(shouldWindow(10, WHOLE_DOCUMENT_MAX_CHARS + 1)).toBe(true);
-  });
-});
-
-describe('uniformGeometry', () => {
-  const geometry = uniformGeometry(ROW, 500);
-
-  test('spaces lines one row apart and totals the document', () => {
-    expect(geometry.offsetOf(0)).toBe(0);
-    expect(geometry.offsetOf(10)).toBe(10 * ROW);
-    expect(geometry.totalHeight).toBe(500 * ROW);
-  });
-
-  test('maps an offset back to the line covering it', () => {
-    expect(geometry.lineAt(0)).toBe(0);
-    expect(geometry.lineAt(ROW - 1)).toBe(0);
-    expect(geometry.lineAt(ROW)).toBe(1);
-    expect(geometry.lineAt(499 * ROW + 3)).toBe(499);
-  });
-
-  test('clamps an offset outside the document', () => {
-    expect(geometry.lineAt(-50)).toBe(0);
-    expect(geometry.lineAt(999_999)).toBe(499);
-    expect(geometry.offsetOf(500)).toBe(geometry.totalHeight);
-    expect(geometry.offsetOf(999)).toBe(geometry.totalHeight);
-  });
-});
-
-describe('measuredGeometry', () => {
-  // Every third line wraps over three rows; the rest are single rows.
-  const heights = Array.from({ length: 9 }, (_, index) => (index % 3 === 2 ? ROW * 3 : ROW));
-  const geometry = measured(heights);
-
-  test('builds offsets from the wrapped heights', () => {
-    expect(geometry.offsetOf(0)).toBe(0);
-    expect(geometry.offsetOf(1)).toBe(ROW);
-    expect(geometry.offsetOf(2)).toBe(2 * ROW);
-    // Line 2 spans three rows, so line 3 starts after all three.
-    expect(geometry.offsetOf(3)).toBe(5 * ROW);
-    expect(geometry.totalHeight).toBe(heights.reduce((sum, height) => sum + height, 0));
-  });
-
-  test('maps an offset inside a wrapped line to that line', () => {
-    expect(geometry.lineAt(2 * ROW)).toBe(2);
-    expect(geometry.lineAt(4 * ROW + 5)).toBe(2);
-    expect(geometry.lineAt(5 * ROW)).toBe(3);
-  });
-
-  test('refuses heights that do not describe every line', () => {
-    expect(measuredGeometry([ROW, ROW], ROW, 5)).toBeNull();
-    expect(measuredGeometry([], ROW, 0)).toBeNull();
-  });
-});
-
-describe('resolveWindow', () => {
-  const geometry = uniformGeometry(ROW, 1_000);
-
-  test('covers the viewport plus overscan on both sides', () => {
-    // Viewport rows 100..128 (the last row is half covered, so it is included).
-    const window = resolveWindow(geometry, 100 * ROW, 28 * ROW);
-    expect(window).toEqual({ start: 100 - WINDOW_OVERSCAN, end: 129 + WINDOW_OVERSCAN });
-  });
-
-  test('never runs past either end of the document', () => {
-    expect(resolveWindow(geometry, 0, ROW)).toEqual({ start: 0, end: 2 + WINDOW_OVERSCAN });
-    expect(resolveWindow(geometry, 999 * ROW, 40 * ROW).end).toBe(1_000);
-  });
-
-  test('keeps a zero-height band to at least the line under it', () => {
-    const window = resolveWindow(geometry, 400 * ROW, 0);
-    expect(window.start).toBeLessThanOrEqual(400);
-    expect(window.end).toBeGreaterThan(400);
-  });
-});
-
-describe('firstWindow', () => {
-  test('bounds the opening render of a long document', () => {
-    expect(firstWindow(20_000).start).toBe(0);
-    expect(firstWindow(20_000).end).toBeLessThan(20_000);
-  });
-
-  test('keeps a short document whole', () => {
-    expect(firstWindow(3)).toEqual({ start: 0, end: 3 });
-  });
-});
-
-describe('clampWindow', () => {
-  test('pulls a window left over from another document back inside it', () => {
-    expect(clampWindow({ start: 9_000, end: 9_500 }, 40)).toEqual({ start: 39, end: 40 });
-    expect(clampWindow({ start: -5, end: 10 }, 40)).toEqual({ start: 0, end: 10 });
-  });
-
-  test('never returns an empty range', () => {
-    expect(clampWindow({ start: 5, end: 5 }, 40).end).toBeGreaterThan(5);
-  });
-});
-
-describe('windowSpace', () => {
-  test('reserves exactly the height of the lines outside the window', () => {
-    const geometry = uniformGeometry(ROW, 100);
-    const space = windowSpace(geometry, { start: 10, end: 30 });
-    expect(space).toEqual({ top: 10 * ROW, bottom: 70 * ROW, breakAtEnd: false });
-    expect(space.top + space.bottom + (30 - 10) * ROW).toBe(geometry.totalHeight);
-  });
-
-  test('flags a window that reaches the last line', () => {
-    const geometry = uniformGeometry(ROW, 100);
-    expect(windowSpace(geometry, { start: 90, end: 100 }).breakAtEnd).toBe(true);
-  });
-});
-
-describe('codeWindow', () => {
-  test('clamps the range and spaces it in one step', () => {
-    const geometry = uniformGeometry(ROW, 50);
-    expect(codeWindow(geometry, { start: 0, end: 5_000 })).toEqual({
-      start: 0,
-      end: 50,
-      top: 0,
-      bottom: 0,
-      breakAtEnd: true,
-    });
-  });
-});

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 });
-  });
-});