@nbtca/prompt 1.4.2 → 1.5.1

package/dist/app/chrome.js

@@ -2,70 +2,89 @@ import { type, space, glyph, brandMark } from '../core/theme.js';
 import { pickIcon } from '../core/icons.js';
 import { t } from '../i18n/index.js';
 import { visualWidth } from '../core/text.js';
-/** `renderHeader` always returns exactly this many lines (brand, tabs, rule). */
 export const HEADER_LINES = 3;
-/** `renderFooter` always returns exactly this many lines (rule, keyhints). */
 export const FOOTER_LINES = 2;
+export function resolveChromeLayout(rows) {
+    const height = Math.max(0, Math.floor(rows));
+    if (height >= 11)
+        return { headerLines: 3, footerLines: 2 };
+    if (height >= 9)
+        return { headerLines: 3, footerLines: 1 };
+    if (height >= 7)
+        return { headerLines: 2, footerLines: 1 };
+    if (height >= 4)
+        return { headerLines: 1, footerLines: 1 };
+    if (height >= 2)
+        return { headerLines: 1, footerLines: 0 };
+    return { headerLines: 0, footerLines: 0 };
+}
+function renderRule(cols) {
+    const width = Number.isFinite(cols) ? Math.max(1, Math.floor(cols)) : 80;
+    const indent = visualWidth(space.indent) < width ? space.indent : '';
+    const ruleWidth = Math.max(1, width - visualWidth(indent) * 2);
+    return indent + type.hint(glyph.rule().repeat(ruleWidth));
+}
 function renderTabs(views, active, cols) {
     const dot = pickIcon('·', '-');
-    const full = space.indent + views
-        .map((view) => view.id === active ? type.active(`[${view.title}]`) : type.hint(view.title))
-        .join(`  ${dot}  `);
+    const full = space.indent +
+        views
+            .map((view) => (view.id === active ? type.active(`[${view.title}]`) : type.hint(view.title)))
+            .join(`  ${dot}  `);
     if (visualWidth(full) <= cols)
         return full;
-    const compact = space.indent + views
-        .map((view, index) => view.id === active
-        ? type.active(`[${index + 1} ${view.title}]`)
-        : type.hint(String(index + 1)))
-        .join(` ${dot} `);
+    const compact = space.indent +
+        views
+            .map((view, index) => view.id === active
+            ? type.active(`[${index + 1} ${view.title}]`)
+            : type.hint(String(index + 1)))
+            .join(` ${dot} `);
     if (visualWidth(compact) <= cols)
         return compact;
-    return space.indent + views
-        .map((view, index) => view.id === active
-        ? type.active(`[${index + 1}]`)
-        : type.hint(String(index + 1)))
-        .join(' ');
+    const numeric = space.indent +
+        views
+            .map((view, index) => view.id === active ? type.active(`[${index + 1}]`) : type.hint(String(index + 1)))
+            .join(' ');
+    if (visualWidth(numeric) <= cols)
+        return numeric;
+    const activeIndex = views.findIndex((view) => view.id === active);
+    const activeView = views[activeIndex];
+    if (!activeView)
+        return '';
+    const activeWithTitle = `${space.indent}${type.active(`[${activeIndex + 1} ${activeView.title}]`)}`;
+    if (visualWidth(activeWithTitle) <= cols)
+        return activeWithTitle;
+    const activeNumber = `${space.indent}${type.active(`[${activeIndex + 1}]`)}`;
+    if (visualWidth(activeNumber) <= cols)
+        return activeNumber;
+    return type.active(String(activeIndex + 1));
 }
-// The header's persistent brand mark. A literal shrunk-down copy of the
-// emblem doesn't survive down to header height (verified: even the boldest
-// inner icon alone dissolves into noise below ~12 character-rows), so this
-// is a wordmark painted in the same gradient as the startup logo instead --
-// ties the two together by color, the one dimension that still reads at
-// one line tall, rather than attempting a shape reproduction this small
-// can't carry.
-export function renderHeader(views, active, cols) {
-    const brand = `${space.indent}${brandMark('nbtca')}`;
+export function renderHeader(views, active, cols, lineCount = HEADER_LINES) {
+    if (lineCount === 0)
+        return [];
+    const mark = brandMark('nbtca');
+    const brand = `${visualWidth(space.indent + mark) <= cols ? space.indent : ''}${mark}`;
     const tabs = renderTabs(views, active, cols);
-    const rule = space.indent + type.hint(glyph.rule().repeat(Math.max(1, cols - 6)));
+    const rule = renderRule(cols);
+    if (lineCount === 1)
+        return [tabs];
+    if (lineCount === 2)
+        return [brand, tabs];
     return [brand, tabs, rule];
 }
-/** Shared footer hint for any view mode that captures all input (a focused
- * text field or a modal-like list) — the only keys that still do something
- * are Ctrl-C/Esc/Enter, so this is what every such view's `footerHint()`
- * should return instead of each re-declaring an identical string. Digits/Tab
- * are deliberately absent: while input is captured they're typed into the
- * field, not routed to global tab-switching, so promising them would itself
- * be the false-promise this hint exists to avoid. */
 export function fitFooterHint(cols, ...candidates) {
-    return candidates.find((candidate) => visualWidth(space.indent + candidate) <= cols)
-        ?? candidates[candidates.length - 1]
-        ?? '';
+    return (candidates.find((candidate) => visualWidth(space.indent + candidate) <= cols) ??
+        candidates[candidates.length - 1] ??
+        '');
 }
 export function captureFooterHint(cols = Number.POSITIVE_INFINITY) {
     const trans = t();
     const dot = pickIcon('·', '-');
     return fitFooterHint(cols, `Ctrl+C ${trans.common.exit}  ${dot}  Esc ${trans.common.back}  ${dot}  Enter ${trans.common.confirm}`, 'Ctrl+C Esc Enter', 'Ctrl+C Esc', 'Ctrl+C');
 }
-/** The "1-N / Tab" tab-switch prefix, factored out so a view's own
- * `footerHint()` override can still include it accurately (tab count isn't
- * knowable inside a view module otherwise) instead of either hardcoding a
- * digit range that goes stale, or dropping a still-true promise entirely. */
 export function digitTabHint(tabCount) {
     const dot = pickIcon('·', '-');
     return tabCount > 1 ? `1-${tabCount} / Tab ${dot} ` : '';
 }
-/** Shared hint for a non-interactive state: digits/Tab still switch tabs,
- * while move/open do nothing and must not be advertised. */
 export function passiveFooterHint(tabCount, cols = Number.POSITIVE_INFINITY) {
     const trans = t();
     const dot = pickIcon('·', '-');
@@ -91,14 +110,12 @@ function interactiveFooterHint(tabCount, cols) {
     ];
     return fitFooterHint(cols, ...candidates);
 }
-/** `overrideHint`: a view supplies this (via `View.footerHint()`) when the
- * generic tab-switching hint would be false — e.g. while a text field has
- * focus, digits/Tab/q are typed characters, not shortcuts, and only Ctrl-C/
- * Esc/Enter actually do anything. The footer must never promise a key that
- * doesn't work. */
-export function renderFooter(_active, cols, tabCount, overrideHint) {
-    const rule = space.indent + type.hint(glyph.rule().repeat(Math.max(1, cols - 6)));
+export function renderFooter(_active, cols, tabCount, overrideHint, lineCount = FOOTER_LINES) {
+    if (lineCount === 0)
+        return [];
+    const rule = renderRule(cols);
     const hintText = overrideHint ?? interactiveFooterHint(tabCount, cols);
-    const hint = space.indent + type.hint(hintText);
-    return [rule, hint];
+    const indent = visualWidth(space.indent + hintText) <= cols ? space.indent : '';
+    const hint = indent + type.hint(hintText);
+    return lineCount === 1 ? [hint] : [rule, hint];
 }

package/dist/app/fields/list-field.js

@@ -3,10 +3,6 @@ import { space, type } from '../../core/theme.js';
 import { pickIcon } from '../../core/icons.js';
 import { t, fmt } from '../../i18n/index.js';
 import { visualWidth, wrapAnsiToVisualWidth } from '../../core/text.js';
-/** A conservative rows-to-options budget for a ListField that fills a
- * view's whole body (title + blank + up to N options + an optional
- * more-indicator + footer). Reserves ~4 lines for that non-option chrome
- * so the field never itself overflows `bodyRows`. */
 export function computeMaxVisible(bodyRows) {
     return Math.max(3, bodyRows - 4);
 }
@@ -16,10 +12,6 @@ function renderIndentedOutput(value, cols) {
     const contentWidth = Math.max(1, width - visualWidth(indent));
     return wrapAnsiToVisualWidth(value, contentWidth).map((line) => `${indent}${line}`);
 }
-/** Non-blocking equivalent of `runMenu`: a view holds one of these in its own
- * state and drives it from the app loop's single stdin listener via
- * `handleKey`, instead of `runMenu` attaching a second listener and blocking
- * on a Promise. */
 export class ListField {
     config;
     index;
@@ -34,18 +26,9 @@ export class ListField {
     get selectedIndex() {
         return this.index;
     }
-    /** How many options this field actually has — lets a caller reserve
-     * exactly enough room for this specific menu instead of guessing a
-     * shared constant that's wrong for every menu of a different size. */
     get optionCount() {
         return this.config.options.length;
     }
-    /** Updates the visible-row budget in place (re-clamping the scroll window
-     * so the selection stays visible) instead of losing the field's current
-     * selection/scroll by rebuilding it. Views call this from their own
-     * `render(ctx)` on every frame — cheap, and it's what keeps a field's
-     * window in sync with the *current* terminal size even though the field
-     * itself was constructed against whatever size was current at the time. */
     setMaxVisible(maxVisible) {
         this.maxVisible = maxVisible;
         this.clampScroll();
@@ -60,7 +43,12 @@ export class ListField {
         const { title, options, footer } = this.config;
         const maxVisible = this.maxVisible;
         if (!maxVisible || options.length <= maxVisible) {
-            return renderMenu({ title, options, selectedIndex: this.index, footer }, cols).split('\n');
+            return renderMenu({
+                title,
+                options,
+                selectedIndex: this.index,
+                ...(footer === undefined ? {} : { footer }),
+            }, cols).split('\n');
         }
         const visible = options.slice(this.scrollTop, this.scrollTop + maxVisible);
         const lines = renderMenu({
@@ -130,17 +118,18 @@ export class ListField {
         const parsed = parseKey(key);
         if (parsed === 'cancel')
             return { cancelled: true };
-        if (parsed === 'enter')
-            return { selected: this.config.options[this.index]?.value };
-        const next = nextIndex(this.index, parsed, this.config.options.length);
+        if (parsed === 'enter') {
+            const selected = this.config.options[this.index]?.value;
+            return selected === undefined ? {} : { selected };
+        }
+        const pageSize = Math.max(1, (this.maxVisible ?? 6) - 1);
+        const next = nextIndex(this.index, parsed, this.config.options.length, pageSize);
         if (next !== this.index) {
             this.index = next;
             this.clampScroll();
         }
         return {};
     }
-    /** Keeps `index` within [scrollTop, scrollTop + maxVisible) after any move
-     * or after maxVisible itself changes (e.g. a terminal resize). */
     clampScroll() {
         const maxVisible = this.maxVisible;
         if (!maxVisible) {
@@ -151,8 +140,6 @@ export class ListField {
             this.scrollTop = this.index;
         else if (this.index >= this.scrollTop + maxVisible)
             this.scrollTop = this.index - maxVisible + 1;
-        // The window may also need to slide backward if it shrank enough that
-        // scrollTop..scrollTop+maxVisible now runs past the end of the list.
         this.scrollTop = Math.max(0, Math.min(this.scrollTop, Math.max(0, this.config.options.length - maxVisible)));
     }
 }

package/dist/app/fields/text-field.js

@@ -1,9 +1,4 @@
 import { renderInput, applyInputEvent, parseInputData } from '../../core/components/text-input.js';
-/** Non-blocking equivalent of `runTextInput`/`runSecretInput`: a view holds
- * one of these and drives it via `handleKey` from the app loop's single
- * stdin listener. Does not touch vim-key activation — the owning view is
- * responsible for `setVimKeysActive(false)` while a TextField is focused
- * (mirrors what `runTextInput` already does for the blocking widget). */
 export class TextField {
     config;
     value = '';
@@ -17,9 +12,9 @@ export class TextField {
         return renderInput({
             message: this.config.message,
             value: this.value,
-            placeholder: this.config.placeholder,
-            secret: this.config.secret,
-            mask: this.config.mask,
+            ...(this.config.placeholder === undefined ? {} : { placeholder: this.config.placeholder }),
+            ...(this.config.secret === undefined ? {} : { secret: this.config.secret }),
+            ...(this.config.mask === undefined ? {} : { mask: this.config.mask }),
             cols,
         }).split('\n');
     }

package/dist/app/frame.js

@@ -1,27 +1,9 @@
-import { visualWidth } from '../core/text.js';
+import { ansi } from '../core/canvas.js';
+import { clipAnsiToVisualWidth, visualWidth } from '../core/text.js';
 export function clipToWidth(line, cols) {
     if (visualWidth(line) <= cols)
         return line;
-    let out = '';
-    let w = 0;
-    let i = 0;
-    while (i < line.length) {
-        const esc = line.slice(i).match(/^\x1b\[[0-9;]*m/);
-        if (esc) {
-            out += esc[0];
-            i += esc[0].length;
-            continue;
-        }
-        const cp = line.codePointAt(i);
-        const ch = String.fromCodePoint(cp);
-        const cw = visualWidth(ch);
-        if (w + cw > cols)
-            break;
-        out += ch;
-        w += cw;
-        i += ch.length;
-    }
-    return out + '\x1b[0m';
+    return clipAnsiToVisualWidth(line, cols) + '\x1b[0m';
 }
 export function fitLine(line, cols) {
     const clipped = visualWidth(line) > cols ? clipToWidth(line, cols) : line;
@@ -36,12 +18,23 @@ export function fitBody(lines, height, scroll, cols) {
         out.push(' '.repeat(cols));
     return out;
 }
-export function composeFrame(header, body, footer, rows, cols, scroll) {
+export function composeFrameLines(header, body, footer, rows, cols, scroll) {
     const h = header.map((l) => fitLine(l, cols));
     const f = footer.map((l) => fitLine(l, cols));
     const bodyH = Math.max(0, rows - h.length - f.length);
     const b = fitBody(body, bodyH, scroll, cols);
-    return [...h, ...b, ...f].slice(0, rows).join('\n');
+    return [...h, ...b, ...f].slice(0, rows);
+}
+export function diffFrame(prev, next) {
+    if (prev?.length !== next.length)
+        return ansi.home + next.join('\n') + ansi.eraseDown;
+    let out = '';
+    for (let row = 0; row < next.length; row += 1) {
+        const line = next[row];
+        if (line !== undefined && prev[row] !== line)
+            out += ansi.cursorToRow(row + 1) + line;
+    }
+    return out;
 }
 export function computeBodyRows(rows, headerLines, footerLines) {
     return Math.max(0, rows - headerLines - footerLines);

package/dist/app/keys.js

@@ -1,3 +1,106 @@
+const ESC = '\x1b';
+const GRAPHEME_SEGMENTER = new Intl.Segmenter(undefined, { granularity: 'grapheme' });
+function isControl(value) {
+    const code = value.charCodeAt(0);
+    return code <= 0x1f || (code >= 0x7f && code <= 0x9f);
+}
+export function isPrintableKey(value) {
+    if (value.length === 0 || value.startsWith(ESC))
+        return false;
+    return Array.from(value).every((char) => !isControl(char));
+}
+function escapeSequenceLength(value) {
+    if (value.length === 1)
+        return null;
+    const introducer = value[1];
+    if (introducer === ESC || (introducer !== undefined && isControl(introducer)))
+        return 1;
+    if (introducer === '[' || introducer === 'O') {
+        for (let index = 2; index < value.length; index += 1) {
+            const code = value.charCodeAt(index);
+            if (code >= 0x40 && code <= 0x7e)
+                return index + 1;
+            if (code < 0x20 || code > 0x3f)
+                return 1;
+        }
+        return null;
+    }
+    if (introducer === ']' || introducer === 'P' || introducer === '^' || introducer === '_') {
+        for (let index = 2; index < value.length; index += 1) {
+            if (value[index] === '\x07')
+                return index + 1;
+            if (value[index] === ESC && value[index + 1] === '\\')
+                return index + 2;
+        }
+        return null;
+    }
+    const segment = GRAPHEME_SEGMENTER.segment(value.slice(1))[Symbol.iterator]().next();
+    return segment.done ? null : 1 + segment.value.segment.length;
+}
+export class KeyStreamDecoder {
+    decoder = new TextDecoder();
+    pending = '';
+    get hasPending() {
+        return this.pending.length > 0;
+    }
+    write(data) {
+        this.pending += typeof data === 'string' ? data : this.decoder.decode(data, { stream: true });
+        return this.drain(false);
+    }
+    flush() {
+        return this.drain(true);
+    }
+    reset() {
+        this.pending = '';
+        this.decoder = new TextDecoder();
+    }
+    drain(flush) {
+        const keys = [];
+        let offset = 0;
+        while (offset < this.pending.length) {
+            const value = this.pending.slice(offset);
+            const first = value[0];
+            if (first === undefined)
+                break;
+            if (first === ESC) {
+                const length = escapeSequenceLength(value);
+                if (length === null) {
+                    if (flush) {
+                        keys.push(value);
+                        offset = this.pending.length;
+                    }
+                    break;
+                }
+                keys.push(value.slice(0, length));
+                offset += length;
+                continue;
+            }
+            if (isControl(first)) {
+                keys.push(first);
+                offset += 1;
+                continue;
+            }
+            let end = offset;
+            while (end < this.pending.length) {
+                const char = this.pending[end];
+                if (char === undefined || char === ESC || isControl(char))
+                    break;
+                end += char.length;
+            }
+            const run = this.pending.slice(offset, end);
+            const segments = Array.from(GRAPHEME_SEGMENTER.segment(run), ({ segment }) => segment);
+            for (const segment of segments) {
+                keys.push(segment);
+                offset += segment.length;
+            }
+        }
+        this.pending = this.pending.slice(offset);
+        return keys;
+    }
+}
+function switchResult(target) {
+    return target === undefined ? { handled: true } : { switchTo: target, handled: true };
+}
 export function routeGlobalKey(key, viewIds, current) {
     if (key === 'q' || key === '\x03')
         return { quit: true, handled: true };
@@ -5,7 +108,12 @@ export function routeGlobalKey(key, viewIds, current) {
         return current === 'home' ? { quit: true, handled: true } : { back: true, handled: true };
     if (key === '\t') {
         const i = viewIds.indexOf(current);
-        return { switchTo: viewIds[(i + 1) % viewIds.length], handled: true };
+        return switchResult(viewIds[(i + 1) % viewIds.length]);
+    }
+    if (key === '\x1b[Z') {
+        const i = viewIds.indexOf(current);
+        const previous = i < 0 ? viewIds.length - 1 : (i - 1 + viewIds.length) % viewIds.length;
+        return switchResult(viewIds[previous]);
     }
     if (key === '\x1b[5~')
         return { scrollBy: -1, handled: true };
@@ -14,7 +122,7 @@ export function routeGlobalKey(key, viewIds, current) {
     if (/^[1-9]$/.test(key)) {
         const idx = Number(key) - 1;
         if (idx < viewIds.length)
-            return { switchTo: viewIds[idx], handled: true };
+            return switchResult(viewIds[idx]);
     }
     return { handled: false };
 }

package/dist/app/views/docs-render.js

@@ -1,32 +1,35 @@
 import { type, space } from '../../core/theme.js';
 import { t } from '../../i18n/index.js';
 import { renderListFieldWithContext } from '../fields/list-field.js';
-import { visualWidth, wrapAnsiToVisualWidth } from '../../core/text.js';
+import { visualWidth, wrapAnsiToVisualWidth, wrapAnsiWithIndent } from '../../core/text.js';
+import { loadingLines } from '../../core/components/spinner.js';
 function hintLines(label, cols) {
-    const width = Number.isFinite(cols) ? Math.max(1, Math.floor(cols)) : Number.POSITIVE_INFINITY;
-    const styled = type.hint(label);
-    const preferredIndent = visualWidth(space.indent) < width ? space.indent : '';
-    const indent = preferredIndent
-        && visualWidth(styled) > width - visualWidth(preferredIndent)
-        && visualWidth(styled) <= width
-        ? ''
-        : preferredIndent;
-    const contentWidth = Math.max(1, width - visualWidth(indent));
-    return wrapAnsiToVisualWidth(styled, contentWidth).map((line) => `${indent}${line}`);
+    return wrapAnsiWithIndent(type.hint(label), cols, space.indent);
 }
 function renderReader(lines, cols) {
     const contentWidth = Math.max(1, Math.min(80, cols - visualWidth(space.indent)));
-    return lines.flatMap((line) => (wrapAnsiToVisualWidth(line, contentWidth).map((part) => `${space.indent}${part}`)));
+    return lines.flatMap((line) => wrapAnsiToVisualWidth(line, contentWidth).map((part) => `${space.indent}${part}`));
 }
 function listFieldForState(state) {
     switch (state.mode) {
-        case 'sections': return state.sectionsField;
-        case 'files': return state.filesField;
-        case 'archivedGroups': return state.archivedGroupsField;
-        case 'archivedFiles': return state.archivedFilesField;
-        case 'searchResults': return state.searchResultsField;
-        case 'reader': return state.readerLinksField;
-        default: return undefined;
+        case 'sections':
+            return state.sectionsField;
+        case 'files':
+            return state.filesField;
+        case 'archivedGroups':
+            return state.archivedGroupsField;
+        case 'archivedFiles':
+            return state.archivedFilesField;
+        case 'searchResults':
+            return state.searchResultsField;
+        case 'reader':
+            return state.readerLinksField;
+        case 'error':
+        case 'loading':
+        case 'readerLoading':
+        case 'search':
+        case 'searchLoading':
+            return undefined;
     }
 }
 export function renderDocs(state, cols = 80, bodyRows = Number.POSITIVE_INFINITY) {
@@ -34,7 +37,7 @@ export function renderDocs(state, cols = 80, bodyRows = Number.POSITIVE_INFINITY
     let lines;
     switch (state.mode) {
         case 'loading':
-            lines = hintLines(trans.common.loading, cols);
+            lines = loadingLines(trans.common.loading, cols);
             break;
         case 'sections':
             lines = state.sectionsField?.render(bodyRows, cols) ?? [];
@@ -51,13 +54,20 @@ export function renderDocs(state, cols = 80, bodyRows = Number.POSITIVE_INFINITY
         case 'search':
             lines = state.searchField?.render(cols) ?? [];
             break;
+        case 'searchLoading':
+            lines = hintLines(trans.docs.searching, cols);
+            break;
         case 'searchResults':
-            lines = state.searchResultsField ? renderListFieldWithContext([
-                ...(state.searchResultsEmpty ? [...hintLines(trans.docs.searchNoResults, cols), ''] : []),
-            ], state.searchResultsField, bodyRows, cols) : [];
+            lines = state.searchResultsField
+                ? renderListFieldWithContext([
+                    ...(state.searchResultsEmpty
+                        ? [...hintLines(trans.docs.searchNoResults, cols), '']
+                        : []),
+                ], state.searchResultsField, bodyRows, cols)
+                : [];
             break;
         case 'readerLoading':
-            lines = hintLines(trans.docs.loadingFile, cols);
+            lines = loadingLines(trans.docs.loadingFile, cols);
             break;
         case 'reader':
             lines = state.readerLinksField
@@ -66,8 +76,6 @@ export function renderDocs(state, cols = 80, bodyRows = Number.POSITIVE_INFINITY
             break;
         case 'error':
             return hintLines(state.errorMessage ?? trans.docs.loadError, cols);
-        default:
-            lines = [];
     }
     if (!state.errorMessage)
         return lines;