@nbtca/prompt 1.5.0 → 1.5.2

package/dist/core/components/menu.js

@@ -1,14 +1,16 @@
 import { glyph, type, space } from '../theme.js';
 import { visualWidth, padEndV, wrapAnsiToVisualWidth } from '../text.js';
-import { ansi, ensureCursorRestored } from '../canvas.js';
 import { createPainter } from './painter.js';
+import { startRawInput } from './input-session.js';
 import { t } from '../../i18n/index.js';
 export function parseKey(data) {
     const s = data.toString();
     switch (s) {
         case '\x1b[A':
+        case 'k':
             return 'up';
         case '\x1b[B':
+        case 'j':
             return 'down';
         case '\x1b[5~':
             return 'pageUp';
@@ -17,16 +19,20 @@ export function parseKey(data) {
         case '\x1b[H':
         case '\x1b[1~':
         case '\x1bOH':
+        case 'g':
             return 'home';
         case '\x1b[F':
         case '\x1b[4~':
         case '\x1bOF':
+        case 'G':
             return 'end';
         case '\r':
         case '\n':
+        case 'l':
             return 'enter';
         case '\x03':
         case '\x1b':
+        case 'q':
             return 'cancel';
         default:
             return 'none';
@@ -97,38 +103,32 @@ export function menuFooter() {
     const m = t().menu;
     return `${glyph.updown()} ${m.hintMove}   ${glyph.enter()} ${m.hintOpen}   q ${m.hintQuit}`;
 }
-// Note: runMenu relies on ambient vim-key translation (j/k/l/g/G/q) being ACTIVE.
-// Callers must not invoke it with setVimKeysActive(false) still in effect.
 export function runMenu(config) {
     return new Promise((resolve) => {
-        const stdin = process.stdin;
-        if (!stdin.isTTY || !process.stdout.isTTY) {
-            resolve(null);
-            return;
-        }
         let index = config.initialIndex ?? 0;
+        let finished = false;
         const paint = createPainter(() => renderMenu({
             title: config.title,
             options: config.options,
             selectedIndex: index,
             ...(config.footer === undefined ? {} : { footer: config.footer }),
         }));
-        const cleanup = () => {
-            stdin.removeListener('data', onData);
-            if (stdin.isTTY)
-                stdin.setRawMode(false);
-            process.stdout.write('\n' + ansi.showCursor);
+        const finish = (result) => {
+            if (finished)
+                return;
+            finished = true;
+            handle?.stop();
+            process.stdout.write('\n');
+            resolve(result);
         };
         const onData = (data) => {
             const key = parseKey(data);
             if (key === 'cancel') {
-                cleanup();
-                resolve(null);
+                finish(null);
                 return;
             }
             if (key === 'enter') {
-                cleanup();
-                resolve(config.options[index]?.value ?? null);
+                finish(config.options[index]?.value ?? null);
                 return;
             }
             const next = nextIndex(index, key, config.options.length);
@@ -137,11 +137,12 @@ export function runMenu(config) {
                 paint();
             }
         };
-        ensureCursorRestored();
-        stdin.setRawMode(true);
-        stdin.resume();
-        process.stdout.write(ansi.hideCursor);
+        const handle = startRawInput(onData);
+        if (!handle) {
+            finished = true;
+            resolve(null);
+            return;
+        }
         paint();
-        stdin.on('data', onData);
     });
 }

package/dist/core/components/spinner.js

@@ -2,12 +2,28 @@ import { getCapabilities } from '../capabilities.js';
 import { ansi, ensureCursorRestored } from '../canvas.js';
 import { renderMessage } from './messages.js';
 import { pickIcon } from '../icons.js';
-import { c, space } from '../theme.js';
+import { c, space, type } from '../theme.js';
+import { visualWidth, wrapAnsiWithIndent } from '../text.js';
 const FRAMES_UNICODE = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
 const FRAMES_ASCII = ['|', '/', '-', '\\'];
+export const SPINNER_FRAME_MS = 80;
 export function renderSpinnerFrame(frame, msg) {
     return `${space.indent}${c.accent(frame)} ${msg}`;
 }
+export function spinnerFrame(at = Date.now()) {
+    const frames = pickIcon('u', 'a') === 'u' ? FRAMES_UNICODE : FRAMES_ASCII;
+    const index = getCapabilities().reducedMotion
+        ? 0
+        : Math.floor(at / SPINNER_FRAME_MS) % frames.length;
+    return frames[index] ?? '|';
+}
+export function loadingLines(label, cols = Number.POSITIVE_INFINITY, at = Date.now()) {
+    const message = type.hint(label);
+    const spun = `${space.indent}${c.accent(spinnerFrame(at))} ${message}`;
+    if (visualWidth(spun) <= cols)
+        return [spun];
+    return wrapAnsiWithIndent(message, cols, space.indent);
+}
 export function startSpinner(msg = '', opts = {}) {
     const write = opts.write ??
         ((s) => {

package/dist/core/text.js

@@ -273,9 +273,13 @@ export function wrapAnsiWithIndent(str, maxWidth, preferredIndent = '') {
         : Number.POSITIVE_INFINITY;
     const indentWidth = visualWidth(preferredIndent);
     const contentWidth = visualWidth(str);
-    const indent = indentWidth >= width || (contentWidth > width - indentWidth && contentWidth <= width)
+    let indent = indentWidth >= width || (contentWidth > width - indentWidth && contentWidth <= width)
         ? ''
         : preferredIndent;
-    const availableWidth = Math.max(1, width - visualWidth(indent));
-    return wrapAnsiToVisualWidth(str, availableWidth).map((line) => `${indent}${line}`);
+    let lines = wrapAnsiToVisualWidth(str, Math.max(1, width - visualWidth(indent)));
+    if (indent && lines.some((line) => visualWidth(indent + line) > width)) {
+        indent = '';
+        lines = wrapAnsiToVisualWidth(str, width);
+    }
+    return lines.map((line) => `${indent}${line}`);
 }

package/dist/core/vim-keys.js

@@ -4,24 +4,167 @@ const VIM_TO_SEQ = {
     l: Buffer.from('\r'),
     g: Buffer.from('\u001b[H'),
     G: Buffer.from('\u001b[F'),
-    q: Buffer.from('\u0003'),
 };
 let vimActive = true;
 export function setVimKeysActive(active) {
     vimActive = active;
 }
+function vimKeysAreActive() {
+    return vimActive;
+}
+function utf8Length(chunk, start) {
+    const first = chunk[start] ?? 0;
+    const length = first <= 0x7f
+        ? 1
+        : first >= 0xc2 && first <= 0xdf
+            ? 2
+            : first >= 0xe0 && first <= 0xef
+                ? 3
+                : first >= 0xf0 && first <= 0xf4
+                    ? 4
+                    : 1;
+    if (start + length > chunk.length)
+        return null;
+    for (let index = start + 1; index < start + length; index += 1) {
+        const byte = chunk[index] ?? 0;
+        if (byte < 0x80 || byte > 0xbf)
+            return 1;
+    }
+    return length;
+}
+function escapeLength(chunk, start) {
+    const introducer = chunk[start + 1];
+    if (introducer === undefined)
+        return null;
+    if (introducer === 0x1b || introducer <= 0x1f || introducer === 0x7f)
+        return 1;
+    if (introducer === 0x5b || introducer === 0x4f) {
+        for (let index = start + 2; index < chunk.length; index += 1) {
+            const byte = chunk[index] ?? 0;
+            if (byte >= 0x40 && byte <= 0x7e)
+                return index - start + 1;
+            if (byte < 0x20 || byte > 0x3f)
+                return 1;
+        }
+        return null;
+    }
+    if ([0x5d, 0x50, 0x5e, 0x5f].includes(introducer)) {
+        for (let index = start + 2; index < chunk.length; index += 1) {
+            if (chunk[index] === 0x07)
+                return index - start + 1;
+            if (chunk[index] === 0x1b && chunk[index + 1] === 0x5c)
+                return index - start + 2;
+        }
+        return null;
+    }
+    const length = utf8Length(chunk, start + 1);
+    return length === null ? null : length + 1;
+}
+function keyLength(chunk, start) {
+    return chunk[start] === 0x1b ? escapeLength(chunk, start) : utf8Length(chunk, start);
+}
+function concatBuffers(chunks) {
+    const size = chunks.reduce((total, chunk) => total + chunk.length, 0);
+    const result = Buffer.allocUnsafe(size);
+    let offset = 0;
+    for (const chunk of chunks) {
+        for (const byte of chunk) {
+            result[offset] = byte;
+            offset += 1;
+        }
+    }
+    return result;
+}
+class KeyByteFramer {
+    pending = Buffer.alloc(0);
+    get hasPending() {
+        return this.pending.length > 0;
+    }
+    write(chunk) {
+        this.pending = this.pending.length === 0 ? chunk : concatBuffers([this.pending, chunk]);
+        return this.drain(false);
+    }
+    flush() {
+        return this.drain(true);
+    }
+    takePending() {
+        const pending = this.pending;
+        this.pending = Buffer.alloc(0);
+        return pending;
+    }
+    drain(flush) {
+        const keys = [];
+        let offset = 0;
+        while (offset < this.pending.length) {
+            const length = keyLength(this.pending, offset);
+            if (length === null) {
+                if (flush) {
+                    keys.push(this.pending.subarray(offset));
+                    offset = this.pending.length;
+                }
+                break;
+            }
+            keys.push(this.pending.subarray(offset, offset + length));
+            offset += length;
+        }
+        this.pending = this.pending.subarray(offset);
+        return keys;
+    }
+}
 export function enableVimKeys() {
     const stdin = process.stdin;
     if (!stdin.isTTY)
         return;
     const originalEmit = stdin.emit.bind(stdin);
+    const framer = new KeyByteFramer();
+    let flushTimer;
+    const clearFlush = () => {
+        if (flushTimer === undefined)
+            return;
+        clearTimeout(flushTimer);
+        flushTimer = undefined;
+    };
+    const emitKeys = (keys) => {
+        let emitted = false;
+        for (let index = 0; index < keys.length; index += 1) {
+            if (!vimKeysAreActive()) {
+                emitted = originalEmit('data', concatBuffers(keys.slice(index))) || emitted;
+                return emitted;
+            }
+            const key = keys[index];
+            if (key === undefined)
+                continue;
+            const sequence = key.length === 1 ? VIM_TO_SEQ[String.fromCharCode(key[0] ?? 0)] : undefined;
+            emitted = originalEmit('data', sequence ?? key) || emitted;
+        }
+        return emitted;
+    };
+    const scheduleFlush = () => {
+        if (!framer.hasPending)
+            return;
+        flushTimer = setTimeout(() => {
+            flushTimer = undefined;
+            if (!vimKeysAreActive()) {
+                originalEmit('data', framer.takePending());
+                return;
+            }
+            emitKeys(framer.flush());
+        }, 20);
+    };
     const translatedEmit = (event, ...args) => {
-        if (event === 'data' && vimActive) {
+        if (event === 'data') {
             const chunk = args[0];
-            if (Buffer.isBuffer(chunk) && chunk.length === 1) {
-                const seq = VIM_TO_SEQ[String.fromCharCode(chunk.readUInt8(0))];
-                if (seq)
-                    return originalEmit('data', seq);
+            if (Buffer.isBuffer(chunk)) {
+                clearFlush();
+                if (!vimKeysAreActive()) {
+                    const pending = framer.takePending();
+                    return pending.length === 0
+                        ? originalEmit(event, ...args)
+                        : originalEmit('data', concatBuffers([pending, chunk]));
+                }
+                const emitted = emitKeys(framer.write(chunk));
+                scheduleFlush();
+                return emitted;
             }
         }
         return originalEmit(event, ...args);

package/dist/features/calendar-store.js

@@ -0,0 +1,27 @@
+import fs from 'fs';
+import path from 'path';
+import { getStateDir, getWritableStateDir } from '../config/paths.js';
+const FEED_FILE = 'calendar-feed.ics';
+const MAX_AGE_MS = 7 * 24 * 60 * 60 * 1000;
+export function saveFeedCache(text, dir) {
+    try {
+        fs.writeFileSync(path.join(dir ?? getWritableStateDir(), FEED_FILE), text, {
+            encoding: 'utf8',
+            mode: 0o600,
+        });
+    }
+    catch {
+        /* best effort */
+    }
+}
+export function loadFeedCache(dir, maxAgeMs = MAX_AGE_MS) {
+    try {
+        const file = path.join(dir ?? getStateDir(), FEED_FILE);
+        if (Date.now() - fs.statSync(file).mtimeMs > maxAgeMs)
+            return null;
+        return fs.readFileSync(file, 'utf8');
+    }
+    catch {
+        return null;
+    }
+}

package/dist/features/calendar.js

@@ -1,11 +1,12 @@
-import { loadCalendar, FeedFetchError, FeedParseError, eventToICS } from '@nbtca/nbtcal';
+import { fetchFeed, parseCalendar, createCalendar, FeedFetchError, FeedParseError, eventToICS, } from '@nbtca/nbtcal';
 import chalk from 'chalk';
 import { c, type, space, glyph } from '../core/theme.js';
 import { pickIcon } from '../core/icons.js';
-import { padEndV, sanitizeTerminalLine, sanitizeTerminalText, truncate, visualWidth, wrapAnsiToVisualWidth, } from '../core/text.js';
+import { padEndV, sanitizeTerminalLine, sanitizeTerminalText, truncate, visualWidth, wrapAnsiWithIndent, wrapAnsiToVisualWidth, } from '../core/text.js';
 import { t } from '../i18n/index.js';
 import { addLocalDays } from '../core/calendar-day.js';
 import { countdownParts, isCountdownUrgent, buildExportFilename } from './calendar-query.js';
+import { loadFeedCache, saveFeedCache } from './calendar-store.js';
 import { writeFileSync, existsSync } from 'fs';
 import { join } from 'path';
 function formatDate(date) {
@@ -22,15 +23,46 @@ function formatTime(date) {
     const minutes = String(date.getMinutes()).padStart(2, '0');
     return `${hours}:${minutes}`;
 }
-export async function loadCalendarOrThrow() {
+const MEMO_TTL_MS = 5 * 60 * 1000;
+let memo;
+let inFlight;
+export function peekCalendar() {
+    if (memo)
+        return memo.calendar;
+    const text = loadFeedCache();
+    if (text === null)
+        return undefined;
     try {
-        return await loadCalendar({ timeoutMs: 15000 });
+        memo = { calendar: createCalendar(parseCalendar(text)), fetchedAt: 0 };
+        return memo.calendar;
+    }
+    catch {
+        return undefined;
+    }
+}
+async function refetchCalendar(signal) {
+    try {
+        const text = await fetchFeed(undefined, {
+            timeoutMs: 15000,
+            ...(signal === undefined ? {} : { signal }),
+        });
+        memo = { calendar: createCalendar(parseCalendar(text)), fetchedAt: Date.now() };
+        saveFeedCache(text);
+        return memo.calendar;
     }
     catch (err) {
         const detail = sanitizeTerminalLine(err instanceof FeedFetchError || err instanceof FeedParseError ? err.message : String(err));
         throw new Error(`${t().calendar.error}: ${detail}`);
     }
 }
+export async function loadCalendarOrThrow(signal) {
+    if (memo && Date.now() - memo.fetchedAt < MEMO_TTL_MS)
+        return memo.calendar;
+    inFlight ??= refetchCalendar(signal).finally(() => {
+        inFlight = undefined;
+    });
+    return inFlight;
+}
 export function toDisplayEvent(e) {
     const trans = t();
     return {
@@ -70,13 +102,30 @@ export function serializeEvents(events) {
 export function renderEventsTable(events, options) {
     const trans = t();
     const useColor = options?.color !== false;
-    if (events.length === 0)
-        return `${space.indent}${type.hint(trans.calendar.noEvents)}`;
+    const width = options?.width === undefined || !Number.isFinite(options.width)
+        ? Number.POSITIVE_INFINITY
+        : Math.max(1, Math.floor(options.width));
+    if (events.length === 0) {
+        return wrapAnsiWithIndent(type.hint(trans.calendar.noEvents), width, space.indent).join('\n');
+    }
     const id = (s) => s;
     const applyDim = useColor ? chalk.dim : id;
     const applyCyan = useColor ? chalk.cyan : id;
     const applyBold = useColor ? chalk.bold : id;
     const applyGray = useColor ? chalk.gray : id;
+    if (width < 68) {
+        const lines = [];
+        for (const event of events) {
+            if (lines.length > 0)
+                lines.push('');
+            const dateTime = event.time ? `${event.date} ${event.time}` : event.date;
+            const marker = event.recurring ? `${pickIcon('↻', '~')} ` : '';
+            lines.push(...wrapAnsiWithIndent(applyCyan(dateTime), width, space.indent));
+            lines.push(...wrapAnsiWithIndent(applyBold(`${marker}${event.title}`), width, space.indent));
+            lines.push(...wrapAnsiWithIndent(applyGray(`${pickIcon('⌖', '@')} ${event.location}`), width, space.indent));
+        }
+        return lines.join('\n');
+    }
     const dateWidth = 16;
     const titleWidth = 32;
     const locWidth = 14;

package/dist/features/docs-client.js

@@ -0,0 +1,225 @@
+import { AsyncLocalStorage } from 'node:async_hooks';
+import { createDocsClient } from '@nbtca/docs';
+const contextKey = Symbol.for('@nbtca/prompt/docs-fetch-context/v2');
+const globalWithContext = globalThis;
+function abortError(signal) {
+    return signal.reason instanceof Error ? signal.reason : new DOMException('Aborted', 'AbortError');
+}
+function raceWithSignal(request, signal) {
+    if (!signal)
+        return request;
+    if (signal.aborted)
+        return Promise.reject(abortError(signal));
+    return new Promise((resolve, reject) => {
+        const finish = (result) => {
+            signal.removeEventListener('abort', onAbort);
+            result();
+        };
+        const onAbort = () => {
+            finish(() => {
+                reject(abortError(signal));
+            });
+        };
+        signal.addEventListener('abort', onAbort, { once: true });
+        void request.then((value) => {
+            finish(() => {
+                resolve(value);
+            });
+        }, (error) => {
+            finish(() => {
+                reject(error instanceof Error ? error : new Error(String(error)));
+            });
+        });
+    });
+}
+function createDocsFetchContext() {
+    const installed = globalWithContext[contextKey];
+    if (installed)
+        return installed;
+    const nativeFetch = globalThis.fetch;
+    const storage = new AsyncLocalStorage();
+    let delegate = nativeFetch;
+    let fallbackDispatching = false;
+    const contextualFetch = (input, init) => {
+        const forward = (delegate, options) => options ? delegate(input, options) : delegate(input);
+        const store = storage.getStore();
+        if (!store) {
+            if (fallbackDispatching)
+                return forward(nativeFetch, init);
+            fallbackDispatching = true;
+            try {
+                return forward(delegate, init);
+            }
+            finally {
+                fallbackDispatching = false;
+            }
+        }
+        if (store.dispatching)
+            return forward(nativeFetch, init);
+        if (store.signal?.aborted)
+            return Promise.reject(abortError(store.signal));
+        const requestSignal = init?.signal;
+        const signal = store.signal
+            ? requestSignal
+                ? AbortSignal.any([store.signal, requestSignal])
+                : store.signal
+            : requestSignal;
+        store.dispatching = true;
+        try {
+            return raceWithSignal(forward(store.delegate, signal ? { ...init, signal } : init), signal);
+        }
+        finally {
+            store.dispatching = false;
+        }
+    };
+    const getFetch = () => (storage.getStore() ? contextualFetch : delegate);
+    const setFetch = (value) => {
+        delegate = value;
+    };
+    const context = {
+        active: 0,
+        contextualFetch,
+        get delegate() {
+            return delegate;
+        },
+        set delegate(value) {
+            delegate = value;
+        },
+        getFetch,
+        nativeFetch,
+        restoreDescriptor: undefined,
+        setFetch,
+        storage,
+    };
+    globalWithContext[contextKey] = context;
+    return context;
+}
+function beginDocsFetch() {
+    const context = createDocsFetchContext();
+    const descriptor = Object.getOwnPropertyDescriptor(globalThis, 'fetch');
+    const installedAccessor = descriptor?.get === context.getFetch && descriptor.set === context.setFetch;
+    const installedValue = descriptor?.value === context.contextualFetch;
+    if (context.active === 0)
+        context.restoreDescriptor = descriptor;
+    if (!installedAccessor && !installedValue) {
+        const observed = globalThis.fetch;
+        if (observed !== context.contextualFetch)
+            context.delegate = observed;
+        if (descriptor?.configurable === false) {
+            if (descriptor.writable !== true) {
+                return {
+                    context,
+                    finish() {
+                        return undefined;
+                    },
+                };
+            }
+            globalThis.fetch = context.contextualFetch;
+        }
+        else {
+            Object.defineProperty(globalThis, 'fetch', {
+                configurable: true,
+                enumerable: descriptor?.enumerable ?? true,
+                get: context.getFetch,
+                set: context.setFetch,
+            });
+        }
+    }
+    context.active += 1;
+    let finished = false;
+    return {
+        context,
+        finish() {
+            if (finished)
+                return;
+            finished = true;
+            context.active = Math.max(0, context.active - 1);
+            if (context.active > 0)
+                return;
+            const current = Object.getOwnPropertyDescriptor(globalThis, 'fetch');
+            if (current?.value === context.contextualFetch && current.writable === true) {
+                globalThis.fetch = context.delegate;
+                return;
+            }
+            if (current?.get !== context.getFetch || current.set !== context.setFetch)
+                return;
+            const restore = context.restoreDescriptor;
+            if (restore && ('get' in restore || 'set' in restore)) {
+                Object.defineProperty(globalThis, 'fetch', restore);
+            }
+            else {
+                Object.defineProperty(globalThis, 'fetch', {
+                    configurable: restore?.configurable ?? true,
+                    enumerable: restore?.enumerable ?? true,
+                    value: context.delegate,
+                    writable: restore?.writable ?? true,
+                });
+            }
+        },
+    };
+}
+const defaultClient = createDocsClient();
+const clientsBySignal = new WeakMap();
+const clients = new Set([defaultClient]);
+function clientFor(signal) {
+    if (!signal)
+        return defaultClient;
+    const existing = clientsBySignal.get(signal);
+    if (existing)
+        return existing;
+    const client = createDocsClient();
+    clientsBySignal.set(signal, client);
+    clients.add(client);
+    signal.addEventListener('abort', () => {
+        client.clear();
+        clients.delete(client);
+        clientsBySignal.delete(signal);
+    }, { once: true });
+    return client;
+}
+export function clearDocsClients() {
+    for (const client of clients)
+        client.clear();
+}
+export function runDocsClientOperation(signal, operation) {
+    if (signal?.aborted)
+        return Promise.reject(abortError(signal));
+    const scope = beginDocsFetch();
+    let request;
+    try {
+        request = scope.context.storage.run({ delegate: scope.context.delegate, dispatching: false, signal }, () => operation(clientFor(signal)));
+    }
+    catch (error) {
+        scope.finish();
+        return Promise.reject(error instanceof Error ? error : new Error(String(error)));
+    }
+    return new Promise((resolve, reject) => {
+        let settled = false;
+        const settle = (result) => {
+            if (settled)
+                return;
+            settled = true;
+            signal?.removeEventListener('abort', onAbort);
+            result();
+        };
+        const onAbort = () => {
+            settle(() => {
+                reject(signal ? abortError(signal) : new DOMException('Aborted', 'AbortError'));
+            });
+        };
+        signal?.addEventListener('abort', onAbort, { once: true });
+        if (signal?.aborted)
+            onAbort();
+        void request.then((value) => {
+            scope.finish();
+            settle(() => {
+                resolve(value);
+            });
+        }, (error) => {
+            scope.finish();
+            settle(() => {
+                reject(error instanceof Error ? error : new Error(String(error)));
+            });
+        });
+    });
+}