@nbtca/prompt 1.5.0 → 1.5.2

package/dist/app/app.js

@@ -1,6 +1,6 @@
 import { ansi, ensureCursorRestored } from '../core/canvas.js';
-import { composeFrame, computeBodyRows } from './frame.js';
-import { routeGlobalKey } from './keys.js';
+import { composeFrameLines, computeBodyRows, diffFrame } from './frame.js';
+import { isPrintableKey, KeyStreamDecoder, routeGlobalKey } from './keys.js';
 import { renderHeader, renderFooter, resolveChromeLayout } from './chrome.js';
 import { homeView } from './views/home.js';
 import { scheduleView } from './views/schedule.js';
@@ -8,6 +8,7 @@ import { docsView } from './views/docs.js';
 import { eventsView } from './views/events.js';
 import { settingsView } from './views/settings.js';
 import { getAppTabs } from './tabs.js';
+import { SPINNER_FRAME_MS } from '../core/components/spinner.js';
 export async function runApp() {
     if (!process.stdin.isTTY || !process.stdout.isTTY)
         return;
@@ -15,6 +16,14 @@ export async function runApp() {
     let scroll = 0;
     let running = true;
     let suspended = false;
+    let entered = false;
+    const lifecycle = new AbortController();
+    const keyDecoder = new KeyStreamDecoder();
+    let keyFlushTimer;
+    let clockTimer;
+    let busyTimer;
+    let painted;
+    let lastBody = { length: 0, height: 0 };
     const viewIds = getAppTabs().map((tab) => tab.id);
     const nativeViews = {
         home: homeView,
@@ -38,6 +47,7 @@ export async function runApp() {
         return { rows: process.stdout.rows || 24, cols: process.stdout.columns || 80 };
     }
     const ctx = {
+        signal: lifecycle.signal,
         get size() {
             return size();
         },
@@ -67,14 +77,47 @@ export async function runApp() {
         const tabs = getAppTabs();
         const chrome = resolveChromeLayout(rows);
         const header = renderHeader(tabs, view, cols, chrome.headerLines);
-        const footer = renderFooter(view, cols, tabs.length, active?.footerHint?.(tabs.length, cols), chrome.footerLines);
         const body = active?.render(ctx) ?? [];
         const bodyScroll = active?.capturesInput?.() ? Number.MAX_SAFE_INTEGER : scroll;
-        process.stdout.write(ansi.home + composeFrame(header, body, footer, rows, cols, bodyScroll) + ansi.eraseDown);
+        const height = computeBodyRows(rows, chrome.headerLines, chrome.footerLines);
+        lastBody = { length: body.length, height };
+        const footer = renderFooter(view, cols, tabs.length, active?.footerHint?.(tabs.length, cols), chrome.footerLines, active?.scrollsBody?.() === true ? scrollPercent() : undefined);
+        const lines = composeFrameLines(header, body, footer, rows, cols, bodyScroll);
+        const patch = diffFrame(painted?.cols === cols ? painted.lines : undefined, lines);
+        painted = { cols, lines };
+        if (patch)
+            process.stdout.write(patch);
+        scheduleBusyTick(active?.isBusy?.() === true);
     }
-    function onKey(data) {
-        const key = data.toString();
+    function maxScroll() {
+        return Math.max(0, lastBody.length - lastBody.height);
+    }
+    function scrollPercent() {
+        const max = maxScroll();
+        if (max === 0)
+            return undefined;
+        return `${Math.round((Math.min(scroll, max) / max) * 100)}%`;
+    }
+    function scrollTo(next) {
+        scroll = Math.min(Math.max(0, next), maxScroll());
+        render();
+    }
+    function scheduleBusyTick(busy) {
+        if (busy && running && busyTimer === undefined) {
+            busyTimer = setTimeout(() => {
+                busyTimer = undefined;
+                render();
+            }, SPINNER_FRAME_MS);
+            return;
+        }
+        if (busy || busyTimer === undefined)
+            return;
+        clearTimeout(busyTimer);
+        busyTimer = undefined;
+    }
+    function dispatchKey(key) {
         if (key === '\x03') {
+            process.exitCode = 130;
             quit();
             return;
         } // Ctrl-C always quits, even mid-capture.
@@ -112,22 +155,88 @@ export async function runApp() {
                 return;
             }
             const page = Math.max(1, ctx.bodyRows - 2);
-            scroll = Math.max(0, scroll + g.scrollBy * page);
-            render();
+            scrollTo(scroll + g.scrollBy * page);
+            return;
+        }
+        if ((g.scrollLines !== undefined || g.scrollTo !== undefined) && active?.scrollsBody?.()) {
+            if (g.scrollTo === 'top')
+                scrollTo(0);
+            else if (g.scrollTo === 'end')
+                scrollTo(maxScroll());
+            else
+                scrollTo(scroll + (g.scrollLines ?? 0));
             return;
         }
         active?.handleKey?.(key, ctx);
         render();
     }
+    function dispatchKeys(keys) {
+        for (let index = 0; index < keys.length && running && !suspended; index += 1) {
+            let key = keys[index];
+            if (key === undefined)
+                continue;
+            if (nativeViews[view]?.capturesInput?.() && isPrintableKey(key)) {
+                while (index + 1 < keys.length) {
+                    const next = keys[index + 1];
+                    if (next === undefined || !isPrintableKey(next))
+                        break;
+                    key += next;
+                    index += 1;
+                }
+            }
+            dispatchKey(key);
+        }
+    }
+    function scheduleClock() {
+        if (!running)
+            return;
+        clockTimer = setTimeout(() => {
+            clockTimer = undefined;
+            render();
+            scheduleClock();
+        }, 60_000 - (Date.now() % 60_000));
+    }
+    function clearKeyFlush() {
+        if (keyFlushTimer === undefined)
+            return;
+        clearTimeout(keyFlushTimer);
+        keyFlushTimer = undefined;
+    }
+    function onKey(data) {
+        clearKeyFlush();
+        dispatchKeys(keyDecoder.write(data));
+        if (!running || suspended || !keyDecoder.hasPending)
+            return;
+        keyFlushTimer = setTimeout(() => {
+            keyFlushTimer = undefined;
+            dispatchKeys(keyDecoder.flush());
+        }, 20);
+    }
     function enter() {
+        if (entered || lifecycle.signal.aborted)
+            return;
+        entered = true;
+        painted = undefined;
+        keyDecoder.reset();
         ensureCursorRestored();
-        process.stdout.write(ansi.enterAlt + ansi.hideCursor);
-        if (process.stdin.isTTY)
-            process.stdin.setRawMode(true);
-        process.stdin.resume();
-        process.stdin.on('data', onKey);
+        try {
+            process.stdout.write(ansi.enterAlt + ansi.hideCursor);
+            if (process.stdin.isTTY)
+                process.stdin.setRawMode(true);
+            process.stdin.resume();
+            process.stdin.on('data', onKey);
+        }
+        catch (error) {
+            leave();
+            throw error;
+        }
     }
     function leave() {
+        if (!entered)
+            return;
+        entered = false;
+        clearKeyFlush();
+        keyDecoder.reset();
         process.stdin.removeListener('data', onKey);
         if (process.stdin.isTTY)
             process.stdin.setRawMode(false);
@@ -162,6 +271,15 @@ export async function runApp() {
         leave();
     }
     function onSigint() {
+        process.exitCode = 130;
+        quit();
+    }
+    function onSigterm() {
+        process.exitCode = 143;
+        quit();
+    }
+    function onSighup() {
+        process.exitCode = 129;
         quit();
     }
     let resolveRun;
@@ -172,6 +290,12 @@ export async function runApp() {
         if (!running)
             return;
         running = false;
+        lifecycle.abort();
+        if (clockTimer !== undefined) {
+            clearTimeout(clockTimer);
+            clockTimer = undefined;
+        }
+        scheduleBusyTick(false);
         try {
             leave();
         }
@@ -179,16 +303,21 @@ export async function runApp() {
             process.stdout.removeListener('resize', onResize);
             process.removeListener('exit', onExit);
             process.removeListener('SIGINT', onSigint);
+            process.removeListener('SIGTERM', onSigterm);
+            process.removeListener('SIGHUP', onSighup);
             resolveRun();
         }
     }
     process.on('exit', onExit);
     process.stdout.on('resize', onResize);
     process.once('SIGINT', onSigint);
+    process.once('SIGTERM', onSigterm);
+    process.once('SIGHUP', onSighup);
     try {
         enter();
         loadView('home');
         render();
+        scheduleClock();
         await done;
     }
     finally {

package/dist/app/chrome.js

@@ -110,12 +110,23 @@ function interactiveFooterHint(tabCount, cols) {
     ];
     return fitFooterHint(cols, ...candidates);
 }
-export function renderFooter(_active, cols, tabCount, overrideHint, lineCount = FOOTER_LINES) {
+export function renderFooter(_active, cols, tabCount, overrideHint, lineCount = FOOTER_LINES, position) {
     if (lineCount === 0)
         return [];
     const rule = renderRule(cols);
     const hintText = overrideHint ?? interactiveFooterHint(tabCount, cols);
     const indent = visualWidth(space.indent + hintText) <= cols ? space.indent : '';
     const hint = indent + type.hint(hintText);
-    return lineCount === 1 ? [hint] : [rule, hint];
+    return lineCount === 1
+        ? [withPosition(hint, hintText, indent, position, cols)]
+        : [rule, withPosition(hint, hintText, indent, position, cols)];
+}
+function withPosition(hint, hintText, indent, position, cols) {
+    if (position === undefined)
+        return hint;
+    const margin = visualWidth(space.indent) < cols ? space.indent : '';
+    const gap = cols - visualWidth(indent + hintText) - visualWidth(position) - visualWidth(margin);
+    if (gap < 2)
+        return hint;
+    return hint + ' '.repeat(gap) + type.hint(position) + margin;
 }

package/dist/app/frame.js

@@ -1,3 +1,4 @@
+import { ansi } from '../core/canvas.js';
 import { clipAnsiToVisualWidth, visualWidth } from '../core/text.js';
 export function clipToWidth(line, cols) {
     if (visualWidth(line) <= cols)
@@ -17,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,103 @@
+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 };
 }
@@ -17,8 +117,16 @@ export function routeGlobalKey(key, viewIds, current) {
     }
     if (key === '\x1b[5~')
         return { scrollBy: -1, handled: true };
-    if (key === '\x1b[6~')
+    if (key === '\x1b[6~' || key === ' ')
         return { scrollBy: 1, handled: true };
+    if (key === '\x1b[A')
+        return { scrollLines: -1, handled: true };
+    if (key === '\x1b[B')
+        return { scrollLines: 1, handled: true };
+    if (key === '\x1b[H')
+        return { scrollTo: 'top', handled: true };
+    if (key === '\x1b[F')
+        return { scrollTo: 'end', handled: true };
     if (/^[1-9]$/.test(key)) {
         const idx = Number(key) - 1;
         if (idx < viewIds.length)

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

@@ -2,6 +2,7 @@ import { type, space } from '../../core/theme.js';
 import { t } from '../../i18n/index.js';
 import { renderListFieldWithContext } from '../fields/list-field.js';
 import { visualWidth, wrapAnsiToVisualWidth, wrapAnsiWithIndent } from '../../core/text.js';
+import { loadingLines } from '../../core/components/spinner.js';
 function hintLines(label, cols) {
     return wrapAnsiWithIndent(type.hint(label), cols, space.indent);
 }
@@ -36,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) ?? [];
@@ -66,7 +67,7 @@ export function renderDocs(state, cols = 80, bodyRows = Number.POSITIVE_INFINITY
                 : [];
             break;
         case 'readerLoading':
-            lines = hintLines(trans.docs.loadingFile, cols);
+            lines = loadingLines(trans.docs.loadingFile, cols);
             break;
         case 'reader':
             lines = state.readerLinksField