@nbtca/prompt 1.3.2 → 1.4.1

package/dist/core/capabilities.js

@@ -0,0 +1,42 @@
+import { useUnicodeIcons } from './icons.js';
+import { resolveColorMode } from '../config/preferences.js';
+export function deriveReducedMotion(o) {
+    const env = o.env ?? process.env;
+    if (!o.isTTY)
+        return true;
+    if (env['NBTCA_NO_MOTION'])
+        return true;
+    if (env['CI'])
+        return true;
+    if ((env['TERM'] || '').toLowerCase() === 'dumb')
+        return true;
+    if (!o.color)
+        return true;
+    if (!o.unicode)
+        return true;
+    return false;
+}
+function detectColor() {
+    if (process.env['NO_COLOR'])
+        return false;
+    const mode = resolveColorMode();
+    if (mode === 'off')
+        return false;
+    if (mode === 'on')
+        return true;
+    return !!process.stdout.isTTY;
+}
+let cached = null;
+export function getCapabilities() {
+    if (cached)
+        return cached;
+    const isTTY = !!process.stdout.isTTY && !!process.stdin.isTTY;
+    const unicode = useUnicodeIcons();
+    const color = detectColor();
+    const reducedMotion = deriveReducedMotion({ isTTY, color, unicode });
+    cached = { isTTY, unicode, color, reducedMotion };
+    return cached;
+}
+export function resetCapabilities() {
+    cached = null;
+}

package/dist/core/components/confirm.js

@@ -0,0 +1,75 @@
+import { startRawInput } from './input-session.js';
+import { setVimKeysActive } from '../vim-keys.js';
+import { glyph, type, space } from '../theme.js';
+import { createPainter } from './painter.js';
+export function parseConfirmData(data) {
+    const s = data.toString();
+    if (s === 'y' || s === 'Y')
+        return 'yes';
+    if (s === 'n' || s === 'N')
+        return 'no';
+    if (s === '\t' || s === '\x1b[C' || s === '\x1b[D')
+        return 'toggle';
+    if (s === '\r' || s === '\n')
+        return 'submit';
+    if (s === '\x03' || s === '\x1b')
+        return 'cancel';
+    return 'none';
+}
+export function renderConfirm(opts) {
+    const cursor = glyph.cursor();
+    const gap = ' '.repeat(cursor.length);
+    const yes = opts.value ? `${type.active(cursor)} ${type.active('Yes')}` : `${gap} ${type.body('Yes')}`;
+    const no = opts.value ? `${gap} ${type.body('No')}` : `${type.active(cursor)} ${type.active('No')}`;
+    return [
+        space.indent + type.label(opts.message),
+        `${space.indent}${yes}   ${no}`,
+    ].join('\n');
+}
+export function runConfirm(config) {
+    return new Promise((resolve) => {
+        let value = config.initial ?? true;
+        const frame = () => renderConfirm({ message: config.message, value });
+        const paint = createPainter(frame);
+        const finish = (result) => {
+            handle?.stop();
+            setVimKeysActive(true);
+            process.stdout.write('\n');
+            resolve(result);
+        };
+        const onData = (data) => {
+            const ev = parseConfirmData(data);
+            if (ev === 'cancel') {
+                finish(null);
+                return;
+            }
+            if (ev === 'submit') {
+                finish(value);
+                return;
+            }
+            if (ev === 'yes' && value !== true) {
+                value = true;
+                paint();
+                return;
+            }
+            if (ev === 'no' && value !== false) {
+                value = false;
+                paint();
+                return;
+            }
+            if (ev === 'toggle') {
+                value = !value;
+                paint();
+                return;
+            }
+        };
+        setVimKeysActive(false);
+        const handle = startRawInput(onData);
+        if (!handle) {
+            setVimKeysActive(true);
+            resolve(null);
+            return;
+        }
+        paint();
+    });
+}

package/dist/core/components/input-session.js

@@ -0,0 +1,24 @@
+import { ansi, ensureCursorRestored } from '../canvas.js';
+export function startRawInput(onData) {
+    const stdin = process.stdin;
+    if (!stdin.isTTY || !process.stdout.isTTY)
+        return null;
+    let stopped = false;
+    ensureCursorRestored();
+    stdin.setRawMode(true);
+    stdin.resume();
+    process.stdout.write(ansi.hideCursor);
+    stdin.on('data', onData);
+    return {
+        stop() {
+            if (stopped)
+                return;
+            stopped = true;
+            stdin.removeListener('data', onData);
+            if (stdin.isTTY)
+                stdin.setRawMode(false);
+            stdin.pause();
+            process.stdout.write(ansi.showCursor);
+        },
+    };
+}

package/dist/core/components/menu.js

@@ -0,0 +1,122 @@
+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 { t } from '../../i18n/index.js';
+export function parseKey(data) {
+    const s = data.toString();
+    switch (s) {
+        case '\x1b[A': return 'up';
+        case '\x1b[B': return 'down';
+        case '\x1b[H': return 'home';
+        case '\x1b[F': return 'end';
+        case '\r':
+        case '\n': return 'enter';
+        case '\x03':
+        case '\x1b': return 'cancel';
+        default: return 'none';
+    }
+}
+export function nextIndex(current, key, len) {
+    if (len <= 0)
+        return 0;
+    switch (key) {
+        case 'up': return (current - 1 + len) % len;
+        case 'down': return (current + 1) % len;
+        case 'home': return 0;
+        case 'end': return len - 1;
+        default: return current;
+    }
+}
+function normalizedWidth(cols) {
+    return Number.isFinite(cols) ? Math.max(1, Math.floor(cols)) : Number.POSITIVE_INFINITY;
+}
+function renderIndentedText(label, cols, style) {
+    const width = normalizedWidth(cols);
+    const indent = visualWidth(space.indent) < width ? space.indent : '';
+    const contentWidth = Math.max(1, width - visualWidth(indent));
+    return wrapAnsiToVisualWidth(style(label), contentWidth).map((line) => `${indent}${line}`);
+}
+export function renderMenuOption(option, selected, labelWidth = visualWidth(option.label), cols = Number.POSITIVE_INFINITY) {
+    const width = normalizedWidth(cols);
+    const cursor = glyph.cursor();
+    const gap = ' '.repeat(visualWidth(cursor));
+    const marker = selected ? type.active(cursor) : gap;
+    const prefixes = [`${space.indent}${marker} `, `${marker} `, marker, ''];
+    const prefix = prefixes.find((candidate) => visualWidth(candidate) < width) ?? '';
+    const continuation = ' '.repeat(visualWidth(prefix));
+    const contentWidth = Math.max(1, width - visualWidth(prefix));
+    const hintWidth = option.hint ? 2 + visualWidth(option.hint) : 0;
+    const paddedWidth = labelWidth + hintWidth <= contentWidth ? labelWidth : visualWidth(option.label);
+    const padded = padEndV(option.label, paddedWidth);
+    const label = selected ? type.active(padded) : type.body(padded);
+    const hint = option.hint ? `  ${type.hint(option.hint)}` : '';
+    return wrapAnsiToVisualWidth(`${label}${hint}`, contentWidth)
+        .map((line, index) => `${index === 0 ? prefix : continuation}${line}`);
+}
+export function renderMenu(state, cols = Number.POSITIVE_INFINITY) {
+    const labelWidth = state.options.reduce((width, option) => Math.max(width, visualWidth(option.label)), 0);
+    const lines = renderIndentedText(state.title, cols, type.heading);
+    lines.push('');
+    state.options.forEach((option, index) => {
+        lines.push(...renderMenuOption(option, index === state.selectedIndex, labelWidth, cols));
+    });
+    if (state.footer) {
+        lines.push('');
+        lines.push(...renderIndentedText(state.footer, cols, type.hint));
+    }
+    return lines.join('\n');
+}
+/** Standard navigation keyhint footer shared by every menu surface. */
+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;
+        const paint = createPainter(() => renderMenu({
+            title: config.title,
+            options: config.options,
+            selectedIndex: index,
+            footer: config.footer,
+        }));
+        const cleanup = () => {
+            stdin.removeListener('data', onData);
+            if (stdin.isTTY)
+                stdin.setRawMode(false);
+            process.stdout.write('\n' + ansi.showCursor);
+        };
+        const onData = (data) => {
+            const key = parseKey(data);
+            if (key === 'cancel') {
+                cleanup();
+                resolve(null);
+                return;
+            }
+            if (key === 'enter') {
+                cleanup();
+                resolve(config.options[index]?.value ?? null);
+                return;
+            }
+            const next = nextIndex(index, key, config.options.length);
+            if (next !== index) {
+                index = next;
+                paint();
+            }
+        };
+        ensureCursorRestored();
+        stdin.setRawMode(true);
+        stdin.resume();
+        process.stdout.write(ansi.hideCursor);
+        paint();
+        stdin.on('data', onData);
+    });
+}

package/dist/core/components/messages.js

@@ -0,0 +1,16 @@
+import { c, space } from '../theme.js';
+import { pickIcon } from '../icons.js';
+const MARKERS = {
+    success: { icon: () => pickIcon('✓', '+'), color: c.success },
+    error: { icon: () => pickIcon('✕', 'x'), color: c.error },
+    warn: { icon: () => pickIcon('⚠', '!'), color: c.warn },
+    info: { icon: () => pickIcon('›', '>'), color: c.accent },
+};
+export function renderMessage(kind, msg) {
+    const m = MARKERS[kind];
+    return `${space.indent}${m.color(m.icon())} ${msg}`;
+}
+export function success(msg) { console.log(renderMessage('success', msg)); }
+export function error(msg) { console.log(renderMessage('error', msg)); }
+export function warning(msg) { console.log(renderMessage('warn', msg)); }
+export function info(msg) { console.log(renderMessage('info', msg)); }

package/dist/core/components/note.js

@@ -0,0 +1,18 @@
+import { glyph, type, space } from '../theme.js';
+import { visualWidth } from '../text.js';
+export function renderNote(message, title) {
+    const bodyLines = message.split('\n');
+    const lines = [];
+    if (title) {
+        const width = Math.max(visualWidth(title), ...bodyLines.map((l) => visualWidth(l)));
+        lines.push(space.indent + type.heading(title));
+        lines.push(space.indent + type.hint(glyph.rule().repeat(width)));
+    }
+    for (const line of bodyLines) {
+        lines.push(space.indent + line);
+    }
+    return lines.join('\n');
+}
+export function note(message, title) {
+    console.log(renderNote(message, title));
+}

package/dist/core/components/painter.js

@@ -0,0 +1,26 @@
+import { ansi } from '../canvas.js';
+import { visualWidth } from '../text.js';
+/** Visual row count for a frame, accounting for terminal soft-wrap. */
+export function frameRows(frame, cols) {
+    return frame.split('\n').reduce((n, line) => {
+        const w = visualWidth(line);
+        return n + Math.max(1, Math.ceil(w / cols));
+    }, 0);
+}
+/**
+ * Returns a paint() closure that redraws a fixed-line-count frame in place,
+ * erasing the previous frame first. `write` is injectable for tests.
+ */
+export function createPainter(frame, write = (s) => { process.stdout.write(s); }) {
+    let painted = 0;
+    return () => {
+        const f = frame();
+        const cols = process.stdout.columns || 80;
+        const rows = frameRows(f, cols);
+        if (painted > 0) {
+            write(ansi.cursorUp(painted - 1) + ansi.cursorToCol0 + ansi.eraseDown);
+        }
+        write(f);
+        painted = rows;
+    };
+}

package/dist/core/components/screen.js

@@ -0,0 +1,18 @@
+import { glyph, type, space } from '../theme.js';
+export function screenWidth() {
+    return Math.min(process.stdout.columns || 80, 64);
+}
+export function renderScreen(opts) {
+    const width = opts.width ?? screenWidth();
+    const lines = [];
+    if (opts.title) {
+        lines.push(space.indent + type.heading(opts.title));
+        lines.push(space.indent + type.hint(glyph.rule().repeat(width)));
+    }
+    lines.push(opts.body);
+    if (opts.footer) {
+        lines.push('');
+        lines.push(space.indent + type.hint(opts.footer));
+    }
+    return lines.join('\n');
+}

package/dist/core/components/spinner.js

@@ -0,0 +1,47 @@
+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';
+const FRAMES_UNICODE = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
+const FRAMES_ASCII = ['|', '/', '-', '\\'];
+export function renderSpinnerFrame(frame, msg) {
+    return `${space.indent}${c.accent(frame)} ${msg}`;
+}
+export function startSpinner(msg = '', opts = {}) {
+    const write = opts.write ?? ((s) => { process.stdout.write(s); });
+    const reduced = opts.reducedMotion ?? getCapabilities().reducedMotion;
+    const frames = pickIcon('u', 'a') === 'u' ? FRAMES_UNICODE : FRAMES_ASCII;
+    let current = msg;
+    let timer = null;
+    let i = 0;
+    const clearLine = () => write(ansi.cursorToCol0 + ansi.eraseDown);
+    const paint = () => {
+        clearLine();
+        write(renderSpinnerFrame(frames[i % frames.length], current));
+        i++;
+    };
+    if (!reduced) {
+        ensureCursorRestored();
+        write(ansi.hideCursor);
+        paint();
+        timer = setInterval(paint, 80);
+    }
+    const finish = (line) => {
+        if (timer) {
+            clearInterval(timer);
+            timer = null;
+        }
+        if (!reduced) {
+            clearLine();
+            write(ansi.showCursor);
+        }
+        if (line)
+            write(line + '\n');
+    };
+    return {
+        message: (m) => { current = m; },
+        stop: (m) => finish(m ? renderMessage('success', m) : null),
+        error: (m) => finish(m ? renderMessage('error', m) : null),
+    };
+}

package/dist/core/components/text-input.js

@@ -0,0 +1,98 @@
+import { glyph, type, space } from '../theme.js';
+import { startRawInput } from './input-session.js';
+import { setVimKeysActive } from '../vim-keys.js';
+import { createPainter } from './painter.js';
+import { visualWidth, wrapAnsiToVisualWidth } from '../text.js';
+export function parseInputData(data) {
+    const s = data.toString();
+    if (s === '\r' || s === '\n')
+        return { type: 'enter' };
+    if (s === '\x03')
+        return { type: 'cancel' }; // ctrl-c
+    if (s === '\x1b')
+        return { type: 'cancel' }; // bare esc
+    if (s === '\x7f' || s === '\b')
+        return { type: 'backspace' };
+    if (s.startsWith('\x1b'))
+        return { type: 'none' }; // escape sequence (arrows, etc.)
+    // printable run: drop control chars, keep the rest (supports paste / batched keys)
+    const text = [...s].filter((ch) => ch >= ' ' && ch !== '\x7f').join('');
+    return text.length > 0 ? { type: 'char', ch: text } : { type: 'none' };
+}
+export function applyInputEvent(value, ev) {
+    if (ev.type === 'char')
+        return value + ev.ch;
+    if (ev.type === 'backspace')
+        return [...value].slice(0, -1).join('');
+    return value;
+}
+export function renderInput(opts) {
+    const width = Number.isFinite(opts.cols)
+        ? Math.max(1, Math.floor(opts.cols ?? Number.POSITIVE_INFINITY))
+        : Number.POSITIVE_INFINITY;
+    const indent = visualWidth(space.indent) < width ? space.indent : '';
+    const messageWidth = Math.max(1, width - visualWidth(indent));
+    const messageLines = wrapAnsiToVisualWidth(type.label(opts.message), messageWidth)
+        .map((line) => `${indent}${line}`);
+    const visibleValue = opts.secret
+        ? (opts.mask ?? '*').repeat([...opts.value].length)
+        : opts.value;
+    const shown = opts.value.length > 0
+        ? type.body(visibleValue)
+        : type.hint(opts.placeholder ?? '');
+    const cursor = type.active(glyph.cursor());
+    const prefixes = [`${space.indent}${cursor} `, `${cursor} `, cursor, ''];
+    const prefix = prefixes.find((candidate) => visualWidth(candidate) < width) ?? '';
+    const continuation = ' '.repeat(visualWidth(prefix));
+    const inputWidth = Math.max(1, width - visualWidth(prefix));
+    const inputLines = wrapAnsiToVisualWidth(shown, inputWidth)
+        .map((line, index) => `${index === 0 ? prefix : continuation}${line}`);
+    return [...messageLines, ...inputLines].join('\n');
+}
+export function runTextInput(config) {
+    return new Promise((resolve) => {
+        let value = '';
+        const frame = () => renderInput({
+            message: config.message,
+            value,
+            placeholder: config.placeholder,
+            secret: config.secret,
+            mask: config.mask,
+        });
+        const paint = createPainter(frame);
+        const onData = (data) => {
+            const ev = parseInputData(data);
+            if (ev.type === 'cancel') {
+                finish(null);
+                return;
+            }
+            if (ev.type === 'enter') {
+                if (value.length > 0 || config.allowEmpty !== false)
+                    finish(value);
+                return;
+            }
+            const next = applyInputEvent(value, ev);
+            if (next !== value) {
+                value = next;
+                paint();
+            }
+        };
+        const finish = (result) => {
+            handle?.stop();
+            setVimKeysActive(true);
+            process.stdout.write('\n');
+            resolve(result);
+        };
+        setVimKeysActive(false);
+        const handle = startRawInput(onData);
+        if (!handle) {
+            setVimKeysActive(true);
+            resolve(null);
+            return;
+        }
+        paint();
+    });
+}
+export function runSecretInput(config) {
+    return runTextInput({ ...config, secret: true });
+}

package/dist/core/logo.js

@@ -7,17 +7,12 @@ import { readFileSync } from 'fs';
 import { fileURLToPath } from 'url';
 import { dirname, join } from 'path';
 import chalk from 'chalk';
-import gradient from 'gradient-string';
 import { useUnicodeIcons } from './icons.js';
 import { APP_INFO } from '../config/data.js';
+import { typeReveal, materializeBraille } from './motion.js';
+import { brandGradient as brand } from './theme.js';
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const TAGLINE = 'To be at the intersection of technology and liberal arts.';
-// Brand gradient: emblem blue -> sky -> cyan.
-const brand = gradient([
-    { color: '#124689', pos: 0 },
-    { color: '#0ea5e9', pos: 0.55 },
-    { color: '#06b6d4', pos: 1 },
-]);
 function readArt(file) {
     try {
         return readFileSync(join(__dirname, '../logo', file), 'utf-8').replace(/\s+$/, '');
@@ -26,6 +21,24 @@ function readArt(file) {
         return null;
     }
 }
+// Three braille dot-matrix tiers of the same emblem (all rendered from the
+// same text-ring-stripped SVG, so none of them reintroduce the illegible-blob
+// problem -- see ca-dotmatrix.txt's own history). Picking a tier is not just
+// "shrink to fit": a narrow terminal gets a purpose-built lower-detail render
+// rather than a squashed version of the big one, mirroring how the schedule
+// grid swaps in a whole different layout below its own width floor instead
+// of cramming columns.
+const TIERS = [
+    { file: 'ca-dotmatrix-large.txt', minCols: 60, minRows: 34 },
+    { file: 'ca-dotmatrix.txt', minCols: 44, minRows: 24 },
+    { file: 'ca-dotmatrix-small.txt', minCols: 0, minRows: 0 },
+];
+function dotmatrixFile() {
+    const cols = process.stdout.columns ?? 0;
+    const rows = process.stdout.rows ?? 0;
+    const tier = TIERS.find((t) => cols >= t.minCols && rows >= t.minRows);
+    return tier?.file ?? 'ca-dotmatrix-small.txt';
+}
 function paint(text, color) {
     if (!color)
         return text;
@@ -36,15 +49,27 @@ function paint(text, color) {
         ? fn.multiline(text)
         : text.split('\n').map((line) => brand(line)).join('\n');
 }
-export function printLogo() {
+function loadArt() {
+    const art = useUnicodeIcons() ? readArt(dotmatrixFile()) : readArt('ascii-logo.txt');
+    return art ?? 'NBTCA';
+}
+export function buildLogoLines() {
+    const color = !process.env['NO_COLOR'];
+    const paintedArt = paint(loadArt(), color).split('\n');
+    return [
+        '',
+        ...paintedArt,
+        '',
+        color ? brand(TAGLINE) : TAGLINE,
+        chalk.dim(`@nbtca/prompt  v${APP_INFO.version}`),
+        '',
+    ];
+}
+export async function runStartup() {
     if (!process.stdout.isTTY)
         return;
     const color = !process.env['NO_COLOR'];
-    const art = useUnicodeIcons() ? readArt('ca-dotmatrix.txt') : readArt('ascii-logo.txt');
-    console.log();
-    console.log(paint(art ?? 'NBTCA', color));
-    console.log();
-    console.log(color ? brand(TAGLINE) : TAGLINE);
-    console.log(chalk.dim(`@nbtca/prompt  v${APP_INFO.version}`));
-    console.log();
+    process.stdout.write('\n');
+    await materializeBraille(loadArt(), (s) => paint(s, color));
+    await typeReveal(['', color ? brand(TAGLINE) : TAGLINE, chalk.dim(`@nbtca/prompt  v${APP_INFO.version}`), '']);
 }

package/dist/core/menu.js

@@ -1,18 +1,23 @@
 /**
  * Minimalist menu system
  */
-import { select, isCancel, outro } from '@clack/prompts';
-import chalk from 'chalk';
+import { runMenu } from './components/menu.js';
+import { type, space, glyph } from './theme.js';
+import { clearScreen } from './ui.js';
 import { showCalendar } from '../features/calendar.js';
 import { showDocsMenu } from '../features/docs.js';
 import { showServiceStatus } from '../features/status.js';
 import { showLinksMenu } from '../features/links.js';
 import { showSettingsMenu } from '../features/settings.js';
+import { showStudentTimetableMenu } from '../features/student-timetable.js';
+import { showSchedule } from '../features/schedule-view.js';
 import { t } from '../i18n/index.js';
 function getMainMenuOptions() {
     const trans = t();
     return [
         { value: 'events', label: trans.menu.events, hint: trans.menu.eventsDesc || undefined },
+        { value: 'schedule', label: t().timetable.menuEntry },
+        { value: 'timetable', label: trans.menu.timetable, hint: trans.menu.timetableDesc || undefined },
         { value: 'docs', label: trans.menu.docs, hint: trans.menu.docsDesc || undefined },
         { value: 'status', label: trans.menu.status, hint: trans.menu.statusDesc || undefined },
         { value: 'links', label: trans.menu.links, hint: trans.menu.linksDesc || undefined },
@@ -20,13 +25,20 @@ function getMainMenuOptions() {
     ];
 }
 export async function showMainMenu() {
+    let first = true;
     while (true) {
-        const action = await select({
-            message: 'nbtca',
+        if (!first)
+            clearScreen();
+        first = false;
+        const trans = t();
+        const footer = `${glyph.updown()} ${trans.menu.hintMove}   ${glyph.enter()} ${trans.menu.hintOpen}   q ${trans.menu.hintQuit}`;
+        const action = await runMenu({
+            title: trans.menu.chooseAction,
             options: getMainMenuOptions(),
+            footer,
         });
-        if (isCancel(action)) {
-            outro(chalk.dim(t().common.goodbye));
+        if (action === null) {
+            console.log(space.indent + type.hint(t().common.goodbye));
             process.exit(0);
         }
         await runMenuAction(action);
@@ -37,6 +49,12 @@ export async function runMenuAction(action) {
         case 'events':
             await showCalendar();
             break;
+        case 'schedule':
+            await showSchedule();
+            break;
+        case 'timetable':
+            await showStudentTimetableMenu();
+            break;
         case 'docs':
             await showDocsMenu();
             break;