@ruckc/truss-code 0.0.0-stage → 1.11.0

package/dist/diff.d.ts

@@ -0,0 +1,135 @@
+/**
+ * Pure diff logic, no dependencies: line diff (Myers), intra-line word/character diff, hunks in `git diff`'s shape,
+ * collapsed regions and split-view pairing. Nothing here touches the DOM, so all of it is unit-tested directly.
+ */
+/** One line of a document: its text without the line ending, and what the ending was. */
+export interface Line {
+    text: string;
+    /** The line ended in CRLF. */
+    cr: boolean;
+    /** The last line of the document has no line ending (""). */
+    noEol: boolean;
+}
+/** Splits text on LF, CRLF or a lone CR. `''` is no lines; a final line ending does not start another line. */
+export declare function splitDocument(text: string): Line[];
+export interface DiffOptions {
+    /** Compare lines with all white space removed (and ignore CRLF versus LF and a missing final newline). */
+    ignoreWhitespace?: boolean;
+    ignoreCase?: boolean;
+    /**
+     * Give up on an exact minimal diff after this many edits and show the unmatched middle as one replaced block.
+     * Memory grows with its square, so keep it modest. Default 2000.
+     */
+    maxCost?: number;
+}
+export type Op = {
+    type: 'eq' | 'del' | 'add';
+    a: number;
+    b: number;
+};
+/**
+ * Myers' O(ND) shortest edit script between two sequences. Equal runs at both ends are trimmed first, so a large file with a few edits is
+ * cheap. `a` is the index in the old sequence (`eq`, `del`), `b` in the new one (`eq`, `add`). Past `maxCost` edits the unmatched middle
+ * becomes all deletions followed by all additions.
+ */
+export declare function diffSeq(a: string[], b: string[], maxCost?: number): Op[];
+/** A word or character run inside a changed line. */
+export interface IntraSeg {
+    text: string;
+    changed: boolean;
+}
+export interface DiffLine {
+    /** `gap` stands for unchanged lines a patch did not include; its size is `count`. */
+    type: 'ctx' | 'del' | 'add' | 'gap';
+    oldNo?: number;
+    newNo?: number;
+    text: string;
+    cr?: boolean;
+    noEol?: boolean;
+    count?: number;
+    /** Intra-line changes; only on changed lines that were paired. */
+    segs?: IntraSeg[];
+}
+/** The line-level diff of two texts. Unchanged lines show the new side's text and numbers on both sides. */
+export declare function diffLines(oldText: string, newText: string, opts?: DiffOptions): DiffLine[];
+/** Words (letters, digits, underscore), runs of white space, and single punctuation marks. Unicode-aware. */
+export declare const wordTokens: (s: string) => string[];
+/** One code point per token, so astral characters and combined emoji halves are never split in the middle of a surrogate pair. */
+export declare const charTokens: (s: string) => string[];
+/** Below this share of unchanged text a pair of lines is treated as different lines, not an edit of one. */
+export declare const MIN_SIMILARITY = 0.3;
+/** Joins neighbouring runs that share a `changed` flag and drops empty ones. */
+export declare const mergeSegs: (segs: IntraSeg[]) => IntraSeg[];
+/**
+ * Word- or character-level diff of one changed line against its counterpart. Returns `null` when the lines have too little in common
+ * (under `MIN_SIMILARITY`), where marking every fragment would only add noise.
+ */
+export declare function intraline(oldText: string, newText: string, mode?: 'word' | 'char', opts?: DiffOptions): {
+    old: IntraSeg[];
+    new: IntraSeg[];
+} | null;
+/** Adds `segs` to the changed lines of every replaced block, pairing the i-th removed line with the i-th added one. Mutates and returns `lines`. */
+export declare function annotateIntraline(lines: DiffLine[], mode?: 'word' | 'char', opts?: DiffOptions): DiffLine[];
+export interface Hunk {
+    /** First old line of the hunk; for a hunk with no old lines, the line before (as git prints it). */
+    oldStart: number;
+    oldLines: number;
+    newStart: number;
+    newLines: number;
+    /** Text after the second `@@`. */
+    section?: string;
+    lines: DiffLine[];
+}
+/** Groups changes with `context` unchanged lines around them. Changes whose unchanged gap is at most `2 * context` lines share a hunk, like git. */
+export declare function toHunks(lines: DiffLine[], context?: number): Hunk[];
+/** The `@@ -a,b +c,d @@` header of a hunk. */
+export declare const hunkHeader: (h: Hunk) => string;
+/** Hunks as unified-diff text: headers, prefixed lines, CRs kept and `` markers. Every line ends in `\n`. */
+export declare function formatHunks(hunks: Hunk[]): string;
+/** A unified patch (with `---`/`+++` headers) for two texts, in the same shape `git diff` prints. Empty when they are equal. */
+export declare function unifiedPatch(oldText: string, newText: string, oldName?: string, newName?: string, context?: number, opts?: DiffOptions): string;
+export declare const diffStats: (lines: DiffLine[]) => {
+    additions: number;
+    deletions: number;
+};
+/** Indexes of the first line of every block of changed lines. */
+export declare const changeStarts: (lines: DiffLine[]) => number[];
+/** Rows revealed so far from each end of a collapsed region, or `'all'`. Keyed by the region's `key`. */
+export type Expansion = Record<number, {
+    top: number;
+    bottom: number;
+} | 'all'>;
+export type Item = {
+    type: 'row';
+    index: number;
+}
+/** `from`..`to` (exclusive) are the hidden line indexes; `key` identifies the region across expansions; `fixed` regions (a patch's gaps) cannot be expanded. */
+ | {
+    type: 'fold';
+    key: number;
+    from: number;
+    to: number;
+    count: number;
+    fixed: boolean;
+};
+/** Regions shorter than this are shown instead of collapsed. */
+export declare const MIN_FOLD = 3;
+/**
+ * Which lines to show: changed lines with `context` lines around them, and a fold for every longer run of unchanged lines.
+ * `expansion` reveals more of a fold from its top or bottom edge. With `context` of `Infinity` nothing is hidden.
+ */
+export declare function foldItems(lines: DiffLine[], context?: number, expansion?: Expansion): Item[];
+/** Reveals up to `by` more lines of a fold from its top, its bottom, or all of it. Returns a new expansion. */
+export declare function expandFold(expansion: Expansion, fold: {
+    key: number;
+    count: number;
+}, how: 'top' | 'bottom' | 'all', by?: number): Expansion;
+/** One row of the split view: indexes into the line list for the left (old) and right (new) cells; `null` is an aligned filler. */
+export interface SplitRow {
+    left: number | null;
+    right: number | null;
+}
+/** Pairs a run of consecutive line indexes for side-by-side display: unchanged lines on both sides, the i-th removal beside the i-th addition. */
+export declare function splitRows(lines: DiffLine[], indexes: number[]): SplitRow[];
+/** The screen-reader summary for a change: "Change 2 of 5: 3 lines removed, 4 lines added". */
+export declare function describeChange(lines: DiffLine[], starts: number[], n: number): string;

package/dist/diff.js

@@ -0,0 +1,346 @@
+/**
+ * Pure diff logic, no dependencies: line diff (Myers), intra-line word/character diff, hunks in `git diff`'s shape,
+ * collapsed regions and split-view pairing. Nothing here touches the DOM, so all of it is unit-tested directly.
+ */
+/** Splits text on LF, CRLF or a lone CR. `''` is no lines; a final line ending does not start another line. */
+export function splitDocument(text) {
+    if (text === '')
+        return [];
+    const out = [];
+    const re = /\r\n|\n|\r/g;
+    let last = 0;
+    for (let m = re.exec(text); m; m = re.exec(text)) {
+        out.push({ text: text.slice(last, m.index), cr: m[0] === '\r\n', noEol: false });
+        last = m.index + m[0].length;
+    }
+    if (last < text.length)
+        out.push({ text: text.slice(last), cr: false, noEol: true });
+    return out;
+}
+const DEFAULT_MAX_COST = 2000;
+function keyOf(l, o) {
+    let t = l.text;
+    if (o.ignoreCase)
+        t = t.toLowerCase();
+    if (o.ignoreWhitespace)
+        return t.replace(/\s+/g, '');
+    return t + (l.cr ? '\r' : '') + (l.noEol ? '\0' : '');
+}
+/**
+ * Myers' O(ND) shortest edit script between two sequences. Equal runs at both ends are trimmed first, so a large file with a few edits is
+ * cheap. `a` is the index in the old sequence (`eq`, `del`), `b` in the new one (`eq`, `add`). Past `maxCost` edits the unmatched middle
+ * becomes all deletions followed by all additions.
+ */
+export function diffSeq(a, b, maxCost = DEFAULT_MAX_COST) {
+    let lo = 0;
+    while (lo < a.length && lo < b.length && a[lo] === b[lo])
+        lo++;
+    let ea = a.length, eb = b.length;
+    while (ea > lo && eb > lo && a[ea - 1] === b[eb - 1]) {
+        ea--;
+        eb--;
+    }
+    const ops = [];
+    for (let i = 0; i < lo; i++)
+        ops.push({ type: 'eq', a: i, b: i });
+    for (const op of middle(a.slice(lo, ea), b.slice(lo, eb), maxCost))
+        ops.push({ type: op.type, a: op.a + lo, b: op.b + lo });
+    for (let i = 0; i < a.length - ea; i++)
+        ops.push({ type: 'eq', a: ea + i, b: eb + i });
+    return ops;
+}
+function middle(a, b, maxCost) {
+    const n = a.length, m = b.length;
+    if (!n || !m)
+        return [...a.map((_, i) => ({ type: 'del', a: i, b: 0 })), ...b.map((_, i) => ({ type: 'add', a: 0, b: i }))];
+    const max = Math.min(n + m, maxCost);
+    const off = max + 1;
+    const v = new Int32Array(2 * max + 3);
+    const snaps = [];
+    let found = -1;
+    for (let d = 0; d <= max && found < 0; d++) {
+        snaps.push(v.slice(off - d - 1, off + d + 2)); // the frontier of round d-1, which the backtrack reads
+        for (let k = -d; k <= d; k += 2) {
+            let x = k === -d || (k !== d && v[off + k - 1] < v[off + k + 1]) ? v[off + k + 1] : v[off + k - 1] + 1;
+            let y = x - k;
+            while (x < n && y < m && a[x] === b[y]) {
+                x++;
+                y++;
+            }
+            v[off + k] = x;
+            if (x >= n && y >= m) {
+                found = d;
+                break;
+            }
+        }
+    }
+    if (found < 0)
+        return [...a.map((_, i) => ({ type: 'del', a: i, b: 0 })), ...b.map((_, i) => ({ type: 'add', a: 0, b: i }))];
+    const ops = [];
+    let x = n, y = m;
+    for (let d = found; d > 0; d--) {
+        const s = snaps[d];
+        const at = (k) => s[k + d + 1];
+        const k = x - y;
+        const pk = k === -d || (k !== d && at(k - 1) < at(k + 1)) ? k + 1 : k - 1;
+        const px = at(pk), py = px - pk;
+        while (x > px && y > py) {
+            x--;
+            y--;
+            ops.push({ type: 'eq', a: x, b: y });
+        }
+        if (x === px)
+            ops.push({ type: 'add', a: 0, b: --y });
+        else
+            ops.push({ type: 'del', a: --x, b: 0 });
+    }
+    while (x > 0) {
+        x--;
+        y--;
+        ops.push({ type: 'eq', a: x, b: y });
+    } // round 0 is a pure diagonal, so x equals y here
+    ops.reverse();
+    // an `add` knows its new index only, a `del` its old one: fill in the other side from the running position
+    let ai = 0, bi = 0;
+    for (const op of ops) {
+        if (op.type === 'add')
+            op.a = ai;
+        else if (op.type === 'del')
+            op.b = bi;
+        if (op.type !== 'add')
+            ai++;
+        if (op.type !== 'del')
+            bi++;
+    }
+    return ops;
+}
+/** The line-level diff of two texts. Unchanged lines show the new side's text and numbers on both sides. */
+export function diffLines(oldText, newText, opts = {}) {
+    const A = splitDocument(oldText), B = splitDocument(newText);
+    const ops = diffSeq(A.map((l) => keyOf(l, opts)), B.map((l) => keyOf(l, opts)), opts.maxCost);
+    return ops.map((op) => {
+        if (op.type === 'del')
+            return { type: 'del', oldNo: op.a + 1, text: A[op.a].text, cr: A[op.a].cr, noEol: A[op.a].noEol };
+        if (op.type === 'add')
+            return { type: 'add', newNo: op.b + 1, text: B[op.b].text, cr: B[op.b].cr, noEol: B[op.b].noEol };
+        return { type: 'ctx', oldNo: op.a + 1, newNo: op.b + 1, text: B[op.b].text, cr: B[op.b].cr, noEol: B[op.b].noEol };
+    });
+}
+// ───── intra-line
+/** Words (letters, digits, underscore), runs of white space, and single punctuation marks. Unicode-aware. */
+export const wordTokens = (s) => s.match(/[\p{L}\p{N}_]+|\s+|[^\p{L}\p{N}_\s]/gu) ?? [];
+/** One code point per token, so astral characters and combined emoji halves are never split in the middle of a surrogate pair. */
+export const charTokens = (s) => [...s];
+const norm = (t, o) => (o.ignoreCase ? t.toLowerCase() : t);
+/** Below this share of unchanged text a pair of lines is treated as different lines, not an edit of one. */
+export const MIN_SIMILARITY = 0.3;
+/** Joins neighbouring runs that share a `changed` flag and drops empty ones. */
+export const mergeSegs = (segs) => {
+    const out = [];
+    for (const s of segs) {
+        if (!s.text)
+            continue;
+        const last = out[out.length - 1];
+        if (last && last.changed === s.changed)
+            last.text += s.text;
+        else
+            out.push({ ...s });
+    }
+    return out;
+};
+/**
+ * Word- or character-level diff of one changed line against its counterpart. Returns `null` when the lines have too little in common
+ * (under `MIN_SIMILARITY`), where marking every fragment would only add noise.
+ */
+export function intraline(oldText, newText, mode = 'word', opts = {}) {
+    const tok = mode === 'char' ? charTokens : wordTokens;
+    const A = tok(oldText), B = tok(newText);
+    const ops = diffSeq(A.map((t) => norm(t, opts)), B.map((t) => norm(t, opts)), opts.maxCost);
+    const o = [], n = [];
+    let same = 0;
+    for (const op of ops) {
+        if (op.type === 'eq') {
+            same += B[op.b].length;
+            o.push({ text: A[op.a], changed: false });
+            n.push({ text: B[op.b], changed: false });
+        }
+        else if (op.type === 'del')
+            o.push({ text: A[op.a], changed: true });
+        else
+            n.push({ text: B[op.b], changed: true });
+    }
+    if (same / Math.max(oldText.length, newText.length, 1) < MIN_SIMILARITY)
+        return null;
+    return { old: mergeSegs(o), new: mergeSegs(n) };
+}
+/** Adds `segs` to the changed lines of every replaced block, pairing the i-th removed line with the i-th added one. Mutates and returns `lines`. */
+export function annotateIntraline(lines, mode = 'word', opts = {}) {
+    for (let i = 0; i < lines.length;) {
+        if (lines[i].type !== 'del') {
+            i++;
+            continue;
+        }
+        let j = i;
+        while (j < lines.length && lines[j].type === 'del')
+            j++;
+        let k = j;
+        while (k < lines.length && lines[k].type === 'add')
+            k++;
+        for (let p = 0; p < Math.min(j - i, k - j); p++) {
+            const r = intraline(lines[i + p].text, lines[j + p].text, mode, opts);
+            if (r) {
+                lines[i + p].segs = r.old;
+                lines[j + p].segs = r.new;
+            }
+        }
+        i = k;
+    }
+    return lines;
+}
+/** Groups changes with `context` unchanged lines around them. Changes whose unchanged gap is at most `2 * context` lines share a hunk, like git. */
+export function toHunks(lines, context = 3) {
+    const changed = lines.flatMap((l, i) => (l.type === 'ctx' || l.type === 'gap' ? [] : [i]));
+    if (!changed.length)
+        return [];
+    const spans = [];
+    for (const i of changed) {
+        const last = spans[spans.length - 1];
+        if (last && i - last[1] - 1 <= 2 * context)
+            last[1] = i;
+        else
+            spans.push([i, i]);
+    }
+    return spans.map(([s, e]) => {
+        const from = Math.max(0, s - context), to = Math.min(lines.length, e + context + 1);
+        const body = lines.slice(from, to);
+        const before = lines.slice(0, from);
+        const oldBefore = before.filter((l) => l.type !== 'add').length, newBefore = before.filter((l) => l.type !== 'del').length;
+        const oldLines = body.filter((l) => l.type !== 'add').length, newLines = body.filter((l) => l.type !== 'del').length;
+        return { oldStart: oldLines ? oldBefore + 1 : oldBefore, oldLines, newStart: newLines ? newBefore + 1 : newBefore, newLines, lines: body };
+    });
+}
+const range = (start, n) => (n === 1 ? `${start}` : `${start},${n}`);
+/** The `@@ -a,b +c,d @@` header of a hunk. */
+export const hunkHeader = (h) => `@@ -${range(h.oldStart, h.oldLines)} +${range(h.newStart, h.newLines)} @@${h.section ? ' ' + h.section : ''}`;
+/** Hunks as unified-diff text: headers, prefixed lines, CRs kept and `` markers. Every line ends in `\n`. */
+export function formatHunks(hunks) {
+    let out = '';
+    for (const h of hunks) {
+        out += hunkHeader(h) + '\n';
+        for (const l of h.lines) {
+            if (l.type === 'gap')
+                continue;
+            out += (l.type === 'add' ? '+' : l.type === 'del' ? '-' : ' ') + l.text + (l.cr ? '\r' : '') + '\n';
+            if (l.noEol)
+                out += '\\n';
+        }
+    }
+    return out;
+}
+/** A unified patch (with `---`/`+++` headers) for two texts, in the same shape `git diff` prints. Empty when they are equal. */
+export function unifiedPatch(oldText, newText, oldName = 'a', newName = 'b', context = 3, opts = {}) {
+    const hunks = toHunks(diffLines(oldText, newText, opts), context);
+    return hunks.length ? `--- ${oldName}\n+++ ${newName}\n${formatHunks(hunks)}` : '';
+}
+// ───── stats and navigation
+export const diffStats = (lines) => ({ additions: lines.filter((l) => l.type === 'add').length, deletions: lines.filter((l) => l.type === 'del').length });
+/** Indexes of the first line of every block of changed lines. */
+export const changeStarts = (lines) => lines.flatMap((l, i) => ((l.type === 'add' || l.type === 'del') && !(i > 0 && (lines[i - 1].type === 'add' || lines[i - 1].type === 'del')) ? [i] : []));
+/** Regions shorter than this are shown instead of collapsed. */
+export const MIN_FOLD = 3;
+/**
+ * Which lines to show: changed lines with `context` lines around them, and a fold for every longer run of unchanged lines.
+ * `expansion` reveals more of a fold from its top or bottom edge. With `context` of `Infinity` nothing is hidden.
+ */
+export function foldItems(lines, context = 3, expansion = {}) {
+    const items = [];
+    const n = lines.length;
+    const hasChange = lines.some((l) => l.type === 'add' || l.type === 'del');
+    for (let i = 0; i < n;) {
+        const l = lines[i];
+        if (l.type === 'gap') {
+            items.push({ type: 'fold', key: i, from: i, to: i + 1, count: l.count ?? 0, fixed: true });
+            i++;
+            continue;
+        }
+        if (l.type !== 'ctx' || !hasChange) {
+            items.push({ type: 'row', index: i });
+            i++;
+            continue;
+        }
+        let e = i;
+        while (e < n && lines[e].type === 'ctx')
+            e++;
+        // the run [i, e): keep `context` lines beside any change (not beside the start or end of the file)
+        const hs = i === 0 ? i : i + context, he = e === n ? e : e - context;
+        if (he - hs < MIN_FOLD) {
+            for (let r = i; r < e; r++)
+                items.push({ type: 'row', index: r });
+            i = e;
+            continue;
+        }
+        for (let r = i; r < hs; r++)
+            items.push({ type: 'row', index: r });
+        const ex = expansion[hs];
+        const top = ex === 'all' ? he - hs : Math.min(ex?.top ?? 0, he - hs);
+        const bottom = ex === 'all' ? 0 : Math.min(ex?.bottom ?? 0, he - hs - top);
+        for (let r = hs; r < hs + top; r++)
+            items.push({ type: 'row', index: r });
+        if (hs + top < he - bottom)
+            items.push({ type: 'fold', key: hs, from: hs + top, to: he - bottom, count: he - bottom - hs - top, fixed: false });
+        for (let r = he - bottom; r < he; r++)
+            items.push({ type: 'row', index: r });
+        for (let r = he; r < e; r++)
+            items.push({ type: 'row', index: r });
+        i = e;
+    }
+    return items;
+}
+/** Reveals up to `by` more lines of a fold from its top, its bottom, or all of it. Returns a new expansion. */
+export function expandFold(expansion, fold, how, by = 20) {
+    const cur = expansion[fold.key];
+    if (how === 'all' || cur === 'all')
+        return { ...expansion, [fold.key]: 'all' };
+    const c = cur ?? { top: 0, bottom: 0 };
+    return { ...expansion, [fold.key]: how === 'top' ? { top: c.top + Math.min(by, fold.count), bottom: c.bottom } : { top: c.top, bottom: c.bottom + Math.min(by, fold.count) } };
+}
+/** Pairs a run of consecutive line indexes for side-by-side display: unchanged lines on both sides, the i-th removal beside the i-th addition. */
+export function splitRows(lines, indexes) {
+    const rows = [];
+    for (let p = 0; p < indexes.length;) {
+        const i = indexes[p];
+        const t = lines[i].type;
+        if (t === 'ctx') {
+            rows.push({ left: i, right: i });
+            p++;
+            continue;
+        }
+        if (t === 'add') {
+            rows.push({ left: null, right: i });
+            p++;
+            continue;
+        }
+        const dels = [], adds = [];
+        while (p < indexes.length && lines[indexes[p]].type === 'del')
+            dels.push(indexes[p++]);
+        while (p < indexes.length && lines[indexes[p]].type === 'add')
+            adds.push(indexes[p++]);
+        for (let r = 0; r < Math.max(dels.length, adds.length); r++)
+            rows.push({ left: dels[r] ?? null, right: adds[r] ?? null });
+    }
+    return rows;
+}
+/** The screen-reader summary for a change: "Change 2 of 5: 3 lines removed, 4 lines added". */
+export function describeChange(lines, starts, n) {
+    const s = starts[n];
+    let e = s, del = 0, add = 0;
+    for (; e < lines.length && (lines[e].type === 'add' || lines[e].type === 'del'); e++) {
+        if (lines[e].type === 'del')
+            del++;
+        else
+            add++;
+    }
+    const part = (c, w) => `${c} ${c === 1 ? 'line' : 'lines'} ${w}`;
+    const parts = [del ? part(del, 'removed') : '', add ? part(add, 'added') : ''].filter(Boolean);
+    return `Change ${n + 1} of ${starts.length}: ${parts.join(', ')}`;
+}

package/dist/editor-util.d.ts

@@ -0,0 +1,46 @@
+import type { CodeMarker, CompletionItem, CompletionKind, MarkerSeverity } from './types.js';
+/** Monaco's `MarkerSeverity` enum (numeric), passed in so these helpers stay independent of the Monaco bundle. */
+export interface SeverityEnum {
+    Error: number;
+    Warning: number;
+    Info: number;
+    Hint: number;
+}
+export declare const markerSeverity: (s: MarkerSeverity, e: SeverityEnum) => number;
+/** Column just past the word that starts at `col` (1-based) in `lineText`; one column when there is no word there. */
+export declare function wordEnd(lineText: string, col: number): number;
+/** A `CodeMarker` as Monaco's `IMarkerData`. */
+export declare function toMonacoMarker(m: CodeMarker, sev: SeverityEnum, lineText?: string): {
+    code?: string | undefined;
+    source?: string | undefined;
+    severity: number;
+    message: string;
+    startLineNumber: number;
+    startColumn: number;
+    endLineNumber: number;
+    endColumn: number;
+};
+/** Monaco's `CompletionItemKind` entries used here. */
+export type KindEnum = Record<'Text' | 'Keyword' | 'Function' | 'Method' | 'Variable' | 'Field' | 'Class' | 'Interface' | 'Module' | 'Property' | 'Constant' | 'Snippet' | 'Value', number>;
+export declare function completionKind(k: CompletionKind | undefined, e: KindEnum): number;
+/** A `CompletionItem` as Monaco's suggestion for the word range `range`. `snippetRule` is `CompletionItemInsertTextRule.InsertAsSnippet`. */
+export declare function toMonacoCompletion(item: CompletionItem, kinds: KindEnum, range: {
+    startLineNumber: number;
+    endLineNumber: number;
+    startColumn: number;
+    endColumn: number;
+}, snippetRule: number): {
+    insertTextRules?: number | undefined;
+    sortText?: string | undefined;
+    documentation?: string | undefined;
+    detail?: string | undefined;
+    label: string;
+    kind: number;
+    insertText: string;
+    range: {
+        startLineNumber: number;
+        endLineNumber: number;
+        startColumn: number;
+        endColumn: number;
+    };
+};

package/dist/editor-util.js

@@ -0,0 +1,52 @@
+export const markerSeverity = (s, e) => (s === 'error' ? e.Error : s === 'warning' ? e.Warning : s === 'hint' ? e.Hint : e.Info);
+/** Column just past the word that starts at `col` (1-based) in `lineText`; one column when there is no word there. */
+export function wordEnd(lineText, col) {
+    const m = /^[\w$]+/.exec(lineText.slice(col - 1));
+    return col + (m ? m[0].length : 1);
+}
+/** A `CodeMarker` as Monaco's `IMarkerData`. */
+export function toMonacoMarker(m, sev, lineText = '') {
+    const endLineNumber = m.endLine ?? m.line;
+    return {
+        severity: markerSeverity(m.severity, sev),
+        message: m.message,
+        startLineNumber: m.line,
+        startColumn: m.col,
+        endLineNumber,
+        endColumn: m.endCol ?? (endLineNumber === m.line ? wordEnd(lineText, m.col) : 1),
+        ...(m.source ? { source: m.source } : {}),
+        ...(m.code ? { code: m.code } : {})
+    };
+}
+export function completionKind(k, e) {
+    switch (k) {
+        case 'keyword': return e.Keyword;
+        case 'function': return e.Function;
+        case 'method': return e.Method;
+        case 'variable': return e.Variable;
+        case 'field':
+        case 'column': return e.Field;
+        case 'class':
+        case 'table': return e.Class;
+        case 'interface': return e.Interface;
+        case 'module': return e.Module;
+        case 'property': return e.Property;
+        case 'constant': return e.Constant;
+        case 'snippet': return e.Snippet;
+        case 'value': return e.Value;
+        default: return e.Text;
+    }
+}
+/** A `CompletionItem` as Monaco's suggestion for the word range `range`. `snippetRule` is `CompletionItemInsertTextRule.InsertAsSnippet`. */
+export function toMonacoCompletion(item, kinds, range, snippetRule) {
+    return {
+        label: item.label,
+        kind: completionKind(item.kind, kinds),
+        insertText: item.insertText ?? item.label,
+        range,
+        ...(item.detail ? { detail: item.detail } : {}),
+        ...(item.documentation ? { documentation: item.documentation } : {}),
+        ...(item.sortText ? { sortText: item.sortText } : {}),
+        ...(item.snippet ? { insertTextRules: snippetRule } : {})
+    };
+}

package/dist/files.d.ts

@@ -0,0 +1,44 @@
+import type { TreeNode } from '@ruckc/truss-ui';
+import { type DiffOptions } from './diff.js';
+import { type PatchFile } from './patch.js';
+export type DiffStatus = 'added' | 'modified' | 'deleted' | 'renamed';
+/** One file handed to `DiffFiles`: its two texts, or a unified patch for it. */
+export interface DiffFileInput {
+    path: string;
+    /** The previous path of a renamed file. */
+    oldPath?: string;
+    /** Defaults to `renamed` when `oldPath` differs from `path`, else `modified`. */
+    status?: DiffStatus;
+    old?: string;
+    new?: string;
+    /** A unified patch for this file (instead of `old`/`new`). */
+    patch?: string;
+    binary?: boolean;
+}
+/** A file ready to show: where it is, what happened to it and its +/- counts. */
+export interface FileEntry {
+    path: string;
+    oldPath?: string;
+    status: DiffStatus;
+    binary: boolean;
+    additions: number;
+    deletions: number;
+    /** Set for patch input; the diff view draws from it instead of two texts. */
+    file?: PatchFile;
+    old?: string;
+    new?: string;
+}
+/** The files of a `git diff` as entries. */
+export declare const entriesFromPatch: (patch: string) => FileEntry[];
+/** An input file as an entry, counting its changes with the same options the diff view will use. */
+export declare function entryFromInput(f: DiffFileInput, opts?: DiffOptions): FileEntry;
+export declare const statusLetter: (s: DiffStatus) => string;
+export declare function totals(entries: FileEntry[]): {
+    files: number;
+    additions: number;
+    deletions: number;
+};
+/** A folder tree of the changed files: folders first, then files, each sorted by name. Folder ids are `dir:` plus their path; file ids are the file's path. */
+export declare function buildTree(entries: FileEntry[]): TreeNode[];
+/** Ids of every folder in a tree, so the whole tree can start expanded. */
+export declare const folderIds: (nodes: TreeNode[]) => string[];