windows-development-sandbox 1.4.1 → 1.4.3

package/dist/cli/{progress.d.ts → output/progress.d.ts}

@@ -1,7 +1,7 @@
 /** Can a line be redrawn in place? */
-export declare const canAnimate: (env: NodeJS.ProcessEnv, isTTY: boolean) => boolean;
+export declare function canAnimate(env: NodeJS.ProcessEnv, isTTY: boolean): boolean;
 /** "12 s", "2 min 5 s". */
-export declare const elapsed: (ms: number) => string;
+export declare function elapsed(ms: number): string;
 /** One line of progress: `line` is shown, `key` changes when it is worth a new plain line, `what` names what runs. */
 export interface Progressing {
     line: string;
@@ -13,12 +13,12 @@ export interface Progressing {
  * plain line each time `key` changes. When nothing changes for `stallMs` it says so (stall(what, ms)). A failure first
  * prints where it stopped, then rethrows.
  */
-export declare const follow: <T>(show: () => Progressing, work: () => Promise<T>, o: {
+export declare function follow<T>(show: () => Progressing, work: () => Promise<T>, o: {
     stallMs?: number;
     stall: (what: string, ms: number) => string;
-}) => Promise<T>;
+}): Promise<T>;
 /**
  * Shows `message` while work runs and removes the line afterwards. The spinner only moves while the event loop is free
  * (waiting on the sandbox); for long synchronous work (measuring folders) the static line is what you see.
  */
-export declare const working: <T>(message: string | (() => string), work: () => Promise<T> | T, enabled?: boolean) => Promise<T>;
+export declare function working<T>(message: string | (() => string), work: () => Promise<T> | T, enabled?: boolean): Promise<T>;

package/dist/cli/{progress.js → output/progress.js}

@@ -1,20 +1,22 @@
-// Feedback for slow work: a spinner line on stderr (so --json and piped output stay clean). Without a terminal (pipe, CI,
-// TERM=dumb) it prints one plain line instead of animating.
+// Feedback for slow work: a spinner line on stderr (so --json and piped output stay clean). Without a terminal (pipe,
+// CI, TERM=dumb) it prints one plain line instead of animating.
 import { colorEnabled, shorten, termWidth } from './colors.js';
 const FRAMES = ['|', '/', '-', '\\'];
 /** Can a line be redrawn in place? */
-export const canAnimate = (env, isTTY) => isTTY && !env.CI && env.TERM !== 'dumb';
+export function canAnimate(env, isTTY) {
+    return isTTY && !env.CI && env.TERM !== 'dumb';
+}
 /** "12 s", "2 min 5 s". */
-export const elapsed = (ms) => {
+export function elapsed(ms) {
     const s = Math.round(ms / 1000);
     return s < 60 ? s + ' s' : Math.floor(s / 60) + ' min ' + (s % 60) + ' s';
-};
+}
 /**
  * Follows long work (a sandbox's boot): on a terminal one line redrawn in place with the time so far; without one a
  * plain line each time `key` changes. When nothing changes for `stallMs` it says so (stall(what, ms)). A failure first
  * prints where it stopped, then rethrows.
  */
-export const follow = async (show, work, o) => {
+export async function follow(show, work, o) {
     const err = process.stderr;
     const animate = canAnimate(process.env, Boolean(err.isTTY));
     const colour = colorEnabled(process.env, true);
@@ -25,8 +27,10 @@ export const follow = async (show, work, o) => {
     let changedAt = start;
     let noticedAt = start;
     let frame = 0;
-    const clear = () => { if (animate)
-        err.write('\r\x1b[2K'); };
+    const clear = () => {
+        if (animate)
+            err.write('\r\x1b[2K');
+    };
     const tick = () => {
         const now = show();
         if (now.line !== shown.line)
@@ -37,13 +41,19 @@ export const follow = async (show, work, o) => {
             err.write(o.stall(shown.what, Date.now() - changedAt) + '\n');
             noticedAt = Date.now();
         }
+        const time = Date.now() - start > 3000 ? ' (' + elapsed(Date.now() - start) + ')' : '';
         if (animate) {
-            const time = Date.now() - start > 3000 ? ' (' + elapsed(Date.now() - start) + ')' : '';
-            err.write('\r\x1b[2K' + (colour ? '\x1b[36m' : '') + FRAMES[frame++ % FRAMES.length] + (colour ? '\x1b[0m' : '') + ' ' + shorten(shown.line, termWidth() - 4 - time.length) + time);
+            err.write('\r\x1b[2K' +
+                (colour ? '\x1b[36m' : '') +
+                FRAMES[frame++ % FRAMES.length] +
+                (colour ? '\x1b[0m' : '') +
+                ' ' +
+                shorten(shown.line, termWidth() - 4 - time.length) +
+                time);
         }
         else if (shown.key !== lastKey) {
             lastKey = shown.key;
-            err.write(shown.line + (Date.now() - start > 3000 ? ' (' + elapsed(Date.now() - start) + ')' : '') + '\n');
+            err.write(shown.line + time + '\n');
         }
     };
     tick();
@@ -60,12 +70,12 @@ export const follow = async (show, work, o) => {
         clearInterval(timer);
         clear();
     }
-};
+}
 /**
  * Shows `message` while work runs and removes the line afterwards. The spinner only moves while the event loop is free
  * (waiting on the sandbox); for long synchronous work (measuring folders) the static line is what you see.
  */
-export const working = async (message, work, enabled = true) => {
+export async function working(message, work, enabled = true) {
     if (!enabled)
         return work();
     const err = process.stderr;
@@ -75,10 +85,15 @@ export const working = async (message, work, enabled = true) => {
     if (!canAnimate(process.env, Boolean(err.isTTY))) {
         let last = text();
         err.write(last + '...\n');
-        const follow = typeof message === 'function' ? setInterval(() => { const now = text(); if (now !== last) {
-            last = now;
-            err.write(now + '\n');
-        } }, 500) : null;
+        const follow = typeof message === 'function'
+            ? setInterval(() => {
+                const now = text();
+                if (now !== last) {
+                    last = now;
+                    err.write(now + '\n');
+                }
+            }, 500)
+            : null;
         try {
             return await work();
         }
@@ -88,7 +103,15 @@ export const working = async (message, work, enabled = true) => {
         }
     }
     let frame = 0;
-    const draw = () => { err.write('\r\x1b[2K' + (colorEnabled(process.env, true) ? '\x1b[36m' : '') + FRAMES[frame++ % FRAMES.length] + (colorEnabled(process.env, true) ? '\x1b[0m' : '') + ' ' + shorten(text(), termWidth() - 14) + (Date.now() - start > 3000 ? ' (' + elapsed(Date.now() - start) + ')' : '')); };
+    const draw = () => {
+        err.write('\r\x1b[2K' +
+            (colorEnabled(process.env, true) ? '\x1b[36m' : '') +
+            FRAMES[frame++ % FRAMES.length] +
+            (colorEnabled(process.env, true) ? '\x1b[0m' : '') +
+            ' ' +
+            shorten(text(), termWidth() - 14) +
+            (Date.now() - start > 3000 ? ' (' + elapsed(Date.now() - start) + ')' : ''));
+    };
     draw();
     const timer = setInterval(draw, 120);
     try {
@@ -98,4 +121,4 @@ export const working = async (message, work, enabled = true) => {
         clearInterval(timer);
         err.write('\r\x1b[2K');
     }
-};
+}

package/dist/cli/report.d.ts

@@ -0,0 +1,2 @@
+/** Prints a problem the way a user can act on it: what happened, how to fix it; stack traces only for real bugs. */
+export declare function report(e: unknown): number;

package/dist/cli/report.js

@@ -0,0 +1,20 @@
+import { CommanderError } from 'commander';
+import { c } from './output/index.js';
+import { UserError, errMsg, plainText } from '../core/util/index.js';
+/** Prints a problem the way a user can act on it: what happened, how to fix it; stack traces only for real bugs. */
+export function report(e) {
+    if (e instanceof CommanderError)
+        return ['commander.helpDisplayed', 'commander.help', 'commander.version'].includes(e.code) ? 0 : e.exitCode || 1;
+    if (e instanceof UserError) {
+        // Messages can quote what the sandbox wrote (a session's status, an address): never with its control codes.
+        console.error(c.red('Error: ') + plainText(e.message));
+        if (e.fix)
+            console.error('  Fix:  ' + plainText(e.fix));
+        return 1;
+    }
+    console.error(c.red('Unexpected error: ') + errMsg(e));
+    console.error(c.dim('This is a bug in windows-development-sandbox. Details: ' +
+        (e instanceof Error && e.stack ? e.stack.split('\n').slice(1, 4).join(' | ').trim() : 'none')));
+    console.error('  Please report it with the output of: sandbox doctor');
+    return 1;
+}

package/dist/cli/tui/app.d.ts

@@ -1,19 +1,9 @@
-import { MessageScreen, type ConfirmOptions, type TextOptions } from './dialogs.js';
-import { type FrameParts } from './frame.js';
-import { type ListOptions, type ListResult } from './list-screen.js';
-import { Terminal, type Key } from './terminal.js';
-export interface Size {
-    width: number;
-    height: number;
-}
-/** What a screen's key handler returns: `{ done: value }` ends the screen, nothing keeps it open (and redraws it). */
-export type Step<T> = {
-    done: T;
-} | undefined | void;
-export interface Screen<T> {
-    render(size: Size): FrameParts;
-    handle(key: Key): Step<T> | Promise<Step<T>>;
-}
+import { type ConfirmOptions } from './dialogs/confirm-screen.js';
+import { MessageScreen } from './dialogs/message-screen.js';
+import { type TextOptions } from './dialogs/text-screen.js';
+import { type ListOptions, type ListResult } from './list/list-types.js';
+import { Terminal } from './terminal.js';
+import type { Screen } from './screen.js';
 export declare class App {
     readonly terminal: Terminal;
     /** The status line for screens that do not set their own (refreshed on every draw). */

package/dist/cli/tui/app.js

@@ -1,8 +1,10 @@
 // The menu as an application: screens are shown one at a time in the frame, each until it is done. Commands that print
 // (or take over the terminal) run with the terminal handed back, and the next screen takes it again.
-import { ConfirmScreen, MessageScreen, TextScreen } from './dialogs.js';
+import { ConfirmScreen } from './dialogs/confirm-screen.js';
+import { MessageScreen } from './dialogs/message-screen.js';
+import { TextScreen } from './dialogs/text-screen.js';
 import { Frame } from './frame.js';
-import { ListScreen } from './list-screen.js';
+import { ListScreen } from './list/list-screen.js';
 import { Terminal } from './terminal.js';
 import { Theme } from './theme.js';
 export class App {
@@ -33,13 +35,29 @@ export class App {
             this.terminal.onResized(null);
         }
     }
-    list(o) { return this.show(new ListScreen(o)); }
-    text(o) { return this.show(new TextScreen(o)); }
-    confirm(o) { return this.show(new ConfirmScreen(o)); }
-    message(o) { return this.show(new MessageScreen(o)); }
+    list(o) {
+        return this.show(new ListScreen(o));
+    }
+    text(o) {
+        return this.show(new TextScreen(o));
+    }
+    confirm(o) {
+        return this.show(new ConfirmScreen(o));
+    }
+    message(o) {
+        return this.show(new MessageScreen(o));
+    }
     /** One of a few values (undefined = back). */
     async choose(path, intro, choices, current) {
-        const picked = await this.list({ path, intro, items: choices.map((c) => ({ ...c, icon: c.value === current ? Theme.ok(Theme.glyph.on) : Theme.muted(Theme.glyph.off) })), startAt: current });
+        const picked = await this.list({
+            path,
+            intro,
+            items: choices.map((c) => ({
+                ...c,
+                icon: c.value === current ? Theme.ok(Theme.glyph.on) : Theme.muted(Theme.glyph.off),
+            })),
+            startAt: current,
+        });
         return picked.kind === 'pick' ? picked.value : undefined;
     }
     /** Runs `work` on the normal screen (command output, interactive commands); the next show() takes the screen back. */
@@ -48,5 +66,7 @@ export class App {
         return work();
     }
     /** Leaves the alternate screen for good. */
-    close() { this.terminal.stop(); }
+    close() {
+        this.terminal.stop();
+    }
 }

package/dist/cli/tui/dialogs/confirm-screen.d.ts

@@ -0,0 +1,20 @@
+import type { FrameParts } from '../frame.js';
+import type { Screen, Size, Step } from '../screen.js';
+import type { Key } from '../terminal.js';
+export interface ConfirmOptions {
+    path: string[];
+    question: string;
+    about?: string[];
+    yes?: string;
+    no?: string;
+    initial?: boolean;
+    danger?: boolean;
+}
+/** Yes or no. Esc answers no. */
+export declare class ConfirmScreen implements Screen<boolean> {
+    private readonly o;
+    private yes;
+    constructor(o: ConfirmOptions);
+    render(size: Size): FrameParts;
+    handle(key: Key): Step<boolean>;
+}

package/dist/cli/tui/dialogs/confirm-screen.js

@@ -0,0 +1,50 @@
+import { Theme } from '../theme.js';
+import { paragraphs } from './paragraphs.js';
+/** Yes or no. Esc answers no. */
+export class ConfirmScreen {
+    o;
+    yes;
+    constructor(o) {
+        this.o = o;
+        this.yes = o.initial ?? true;
+    }
+    render(size) {
+        const button = (label, on, danger = false) => on
+            ? danger
+                ? Theme.colour
+                    ? '\x1b[48;5;160m\x1b[97m ' + label + ' \x1b[0m'
+                    : '[' + label + ']'
+                : Theme.selected(' ' + label + ' ')
+            : Theme.muted(' ' + label + ' ');
+        const body = [
+            '',
+            '  ' + Theme.bold(this.o.question),
+            ...(this.o.about?.length ? ['', ...paragraphs(this.o.about, size.width)] : []),
+            '',
+            '  ' + button(this.o.yes ?? 'Yes', this.yes, this.o.danger) + '   ' + button(this.o.no ?? 'No', !this.yes),
+        ];
+        return {
+            path: this.o.path,
+            body,
+            keys: [
+                ['←→', 'choose'],
+                ['↵', 'confirm'],
+                ['y/n', 'answer'],
+                ['esc', 'no'],
+            ],
+        };
+    }
+    handle(key) {
+        if (key.name === 'left' || key.name === 'right' || key.name === 'tab') {
+            this.yes = !this.yes;
+            return;
+        }
+        if (key.text?.toLowerCase() === 'y')
+            return { done: true };
+        if (key.text?.toLowerCase() === 'n' || key.name === 'escape')
+            return { done: false };
+        if (key.name === 'return')
+            return { done: this.yes };
+        return;
+    }
+}

package/dist/cli/tui/dialogs/message-screen.d.ts

@@ -0,0 +1,17 @@
+import type { FrameParts } from '../frame.js';
+import type { Screen, Size, Step } from '../screen.js';
+import type { Key } from '../terminal.js';
+/** Text to read (scrolls); any key but the arrows closes it. */
+export declare class MessageScreen implements Screen<void> {
+    private readonly o;
+    private offset;
+    private height;
+    constructor(o: {
+        path: string[];
+        title?: string;
+        lines: string[];
+        tone?: 'ok' | 'warn' | 'error';
+    });
+    render(size: Size): FrameParts;
+    handle(key: Key): Step<void>;
+}

package/dist/cli/tui/dialogs/message-screen.js

@@ -0,0 +1,55 @@
+import { Text } from '../text.js';
+import { Theme } from '../theme.js';
+/** Text to read (scrolls); any key but the arrows closes it. */
+export class MessageScreen {
+    o;
+    offset = 0;
+    height = 10;
+    constructor(o) {
+        this.o = o;
+    }
+    render(size) {
+        const paint = this.o.tone === 'ok'
+            ? Theme.ok
+            : this.o.tone === 'warn'
+                ? Theme.warn
+                : this.o.tone === 'error'
+                    ? Theme.error
+                    : Theme.bold;
+        const head = this.o.title ? ['', '  ' + paint(this.o.title), ''] : [''];
+        const lines = this.o.lines
+            .flatMap((l) => (Text.width(l) > size.width - 4 && Text.strip(l) === l ? Text.wrap(l, size.width - 4) : [l]))
+            .map((l) => '  ' + l);
+        this.height = size.height - head.length;
+        this.offset = Math.max(0, Math.min(this.offset, lines.length - this.height));
+        return {
+            path: this.o.path,
+            body: [...head, ...lines.slice(this.offset, this.offset + this.height)],
+            keys: lines.length > this.height
+                ? [
+                    ['↑↓', 'scroll'],
+                    ['↵', 'close'],
+                ]
+                : [['any key', 'close']],
+        };
+    }
+    handle(key) {
+        if (key.name === 'up') {
+            this.offset--;
+            return;
+        }
+        if (key.name === 'down') {
+            this.offset++;
+            return;
+        }
+        if (key.name === 'pageup') {
+            this.offset -= this.height;
+            return;
+        }
+        if (key.name === 'pagedown') {
+            this.offset += this.height;
+            return;
+        }
+        return { done: undefined };
+    }
+}

package/dist/cli/tui/dialogs/paragraphs.d.ts

@@ -0,0 +1,2 @@
+/** Plain lines are wrapped to the width; coloured ones are kept as they are (the frame cuts them). */
+export declare function paragraphs(lines: string[], width: number): string[];

package/dist/cli/tui/dialogs/paragraphs.js

@@ -0,0 +1,5 @@
+import { Text } from '../text.js';
+/** Plain lines are wrapped to the width; coloured ones are kept as they are (the frame cuts them). */
+export function paragraphs(lines, width) {
+    return lines.flatMap((l) => (Text.strip(l) === l ? Text.wrap(l, width - 4) : [l]).map((x) => '  ' + x));
+}

package/dist/cli/tui/dialogs/text-screen.d.ts

@@ -0,0 +1,26 @@
+import type { FrameParts } from '../frame.js';
+import type { Screen, Size, Step } from '../screen.js';
+import type { Key } from '../terminal.js';
+export interface TextOptions {
+    path: string[];
+    label: string;
+    /** Explanation above the field (plain lines). */
+    about?: string[];
+    initial?: string;
+    placeholder?: string;
+    /** true = fine, a string = what is wrong (shown under the field). */
+    validate?: (value: string) => true | string;
+    /** Allow an empty answer (otherwise Enter on an empty field cancels). */
+    allowEmpty?: boolean;
+}
+/** One line of text. Resolves to the text, or undefined when you press Esc. */
+export declare class TextScreen implements Screen<string | undefined> {
+    private readonly o;
+    private value;
+    private cursor;
+    private problem;
+    constructor(o: TextOptions);
+    render(size: Size): FrameParts;
+    handle(key: Key): Step<string | undefined>;
+    private check;
+}

package/dist/cli/tui/dialogs/text-screen.js

@@ -0,0 +1,107 @@
+import { Text } from '../text.js';
+import { Theme } from '../theme.js';
+import { paragraphs } from './paragraphs.js';
+/** One line of text. Resolves to the text, or undefined when you press Esc. */
+export class TextScreen {
+    o;
+    value;
+    cursor;
+    problem;
+    constructor(o) {
+        this.o = o;
+        this.value = o.initial ?? '';
+        this.cursor = [...this.value].length;
+    }
+    render(size) {
+        const width = Math.min(size.width - 4, 100);
+        const chars = [...this.value];
+        // Scroll the field so the cursor stays visible.
+        const inner = width - 4;
+        const start = Math.max(0, this.cursor - inner + 1);
+        const shown = chars.slice(start, start + inner);
+        const before = shown.slice(0, this.cursor - start).join('');
+        const at = shown[this.cursor - start] ?? ' ';
+        const after = shown.slice(this.cursor - start + 1).join('');
+        const text = this.value === '' && this.o.placeholder
+            ? Theme.muted(this.o.placeholder)
+            : before + (Theme.colour ? '\x1b[7m' + at + '\x1b[27m' : '_') + after;
+        const body = [
+            '',
+            '  ' + Theme.bold(this.o.label),
+            ...(this.o.about?.length ? paragraphs(this.o.about, size.width).map((l) => Theme.muted(l)) : []),
+            '',
+            '  ' + Theme.accent('╭' + '─'.repeat(width - 2) + '╮'),
+            '  ' + Theme.accent('│') + ' ' + Text.fit(text, inner) + ' ' + Theme.accent('│'),
+            '  ' + Theme.accent('╰' + '─'.repeat(width - 2) + '╯'),
+            this.problem ? '  ' + Theme.error(Theme.glyph.cross + ' ' + this.problem) : '',
+        ];
+        return {
+            path: this.o.path,
+            body,
+            keys: [
+                ['↵', 'save'],
+                ['esc', 'cancel'],
+                ['ctrl+u', 'clear'],
+                ['←→', 'move'],
+            ],
+        };
+    }
+    handle(key) {
+        const chars = [...this.value];
+        const set = (next, cursor) => {
+            this.value = next.join('');
+            this.cursor = Math.max(0, Math.min(next.length, cursor));
+            this.check();
+        };
+        if (key.name === 'escape')
+            return { done: undefined };
+        if (key.name === 'return') {
+            if (this.value === '' && !this.o.allowEmpty)
+                return { done: undefined };
+            const verdict = this.o.validate?.(this.value) ?? true;
+            if (verdict !== true) {
+                this.problem = verdict;
+                return;
+            }
+            return { done: this.value };
+        }
+        if (key.name === 'left') {
+            this.cursor = Math.max(0, this.cursor - 1);
+            return;
+        }
+        if (key.name === 'right') {
+            this.cursor = Math.min(chars.length, this.cursor + 1);
+            return;
+        }
+        if (key.name === 'home') {
+            this.cursor = 0;
+            return;
+        }
+        if (key.name === 'end') {
+            this.cursor = chars.length;
+            return;
+        }
+        if (key.name === 'backspace') {
+            if (this.cursor > 0)
+                set([...chars.slice(0, this.cursor - 1), ...chars.slice(this.cursor)], this.cursor - 1);
+            return;
+        }
+        if (key.name === 'delete') {
+            set([...chars.slice(0, this.cursor), ...chars.slice(this.cursor + 1)], this.cursor);
+            return;
+        }
+        if (key.ctrl && key.name === 'u') {
+            set([], 0);
+            return;
+        }
+        if (key.text) {
+            const add = [...key.text.replace(/[\r\n]/g, '')];
+            set([...chars.slice(0, this.cursor), ...add, ...chars.slice(this.cursor)], this.cursor + add.length);
+        }
+        return;
+    }
+    check() {
+        const verdict = this.value === '' ? true : (this.o.validate?.(this.value) ?? true);
+        this.problem = verdict === true ? undefined : verdict;
+    }
+}

package/dist/cli/tui/frame.js

@@ -11,7 +11,9 @@ export class Frame {
     }
     static render(parts, width, height) {
         const w = width - 1;
-        const crumbs = [Frame.title, ...parts.path].map((p, i, all) => (i === all.length - 1 ? Theme.bold(p) : p)).join(Theme.dim(' › '));
+        const crumbs = [Frame.title, ...parts.path]
+            .map((p, i, all) => (i === all.length - 1 ? Theme.bold(p) : p))
+            .join(Theme.dim(' › '));
         const right = Frame.version ? 'v' + Frame.version + ' ' : '';
         const title = Theme.bar(Text.fit(' ' + Theme.accent('◆') + ' ' + crumbs, w - Text.width(right)) + right);
         const status = ' ' + Text.truncate(parts.status ?? '', w - 2);

package/dist/cli/tui/index.d.ts

@@ -1,7 +1,11 @@
-export { App, type Screen, type Size, type Step } from './app.js';
-export { ConfirmScreen, MessageScreen, TextScreen } from './dialogs.js';
+export { App } from './app.js';
+export { type Screen, type Size, type Step } from './screen.js';
+export { ConfirmScreen } from './dialogs/confirm-screen.js';
+export { MessageScreen } from './dialogs/message-screen.js';
+export { TextScreen } from './dialogs/text-screen.js';
 export { Frame } from './frame.js';
-export { ListScreen, type Category, type ListItem, type ListOptions, type ListResult, type Tab } from './list-screen.js';
+export { ListScreen } from './list/list-screen.js';
+export { type Category, type ListItem, type ListOptions, type ListResult, type Tab } from './list/list-types.js';
 export { ExitRequested, Terminal, type Key } from './terminal.js';
 export { Text } from './text.js';
 export { Theme } from './theme.js';

package/dist/cli/tui/index.js

@@ -1,8 +1,10 @@
 // The menu's screen toolkit: a full-screen app (App) showing one screen at a time in a common frame.
 export { App } from './app.js';
-export { ConfirmScreen, MessageScreen, TextScreen } from './dialogs.js';
+export { ConfirmScreen } from './dialogs/confirm-screen.js';
+export { MessageScreen } from './dialogs/message-screen.js';
+export { TextScreen } from './dialogs/text-screen.js';
 export { Frame } from './frame.js';
-export { ListScreen } from './list-screen.js';
+export { ListScreen } from './list/list-screen.js';
 export { ExitRequested, Terminal } from './terminal.js';
 export { Text } from './text.js';
 export { Theme } from './theme.js';

package/dist/cli/tui/list/list-screen.d.ts

@@ -0,0 +1,29 @@
+import type { FrameParts } from '../frame.js';
+import type { Screen, Size, Step } from '../screen.js';
+import type { Key } from '../terminal.js';
+import type { ListResult, ListOptions } from './list-types.js';
+export declare class ListScreen<T> implements Screen<ListResult<T>> {
+    private readonly o;
+    private category;
+    private focus;
+    private cursor;
+    private offset;
+    private query;
+    private searching;
+    private notice;
+    private readonly checked;
+    constructor(o: ListOptions<T>);
+    /** Indexes of the entries shown now: all matches of the search, else the current category's, else all. */
+    private visible;
+    private rows;
+    render(size: Size): FrameParts;
+    private rowLine;
+    private sideLines;
+    private detailsLines;
+    private keys;
+    /** Programmatic notice (e.g. "Saved") shown until the next key. */
+    setNotice(text: string | undefined): void;
+    handle(key: Key): Step<ListResult<T>>;
+    private toggle;
+    private switchCategory;
+}