@nbtca/prompt 1.4.2 → 1.5.1

package/dist/features/schedule-view.js

@@ -1,212 +1,57 @@
-import path from 'node:path';
-import { createNbtTimetableClient, timetableToIcs, } from '@nbtca/nbtcal/timetable';
-import { runMenu, menuFooter } from '../core/components/menu.js';
-import { runTextInput } from '../core/components/text-input.js';
-import { enterScreen, breadcrumb } from '../core/transitions.js';
-import { createSpinner, success, error } from '../core/ui.js';
-import { c, type, space } from '../core/theme.js';
-import { t, fmt } from '../i18n/index.js';
-import { createSessionStore } from '../auth/session-store.js';
-import { withAuthenticatedSession, resolveTerm, relevantTerms, writePrivateIcs, isSessionExpired, safeMessage, JWXT_ORIGIN, } from './student-timetable.js';
-import { currentWeekNumber, campusWeekday, meetingsOnDay, nextMeeting } from './schedule-query.js';
-import { renderNextClassBanner, renderTodayClasses, renderTodayTimeline, renderWeekGrid } from './schedule-render.js';
-import { termKey, loadWeekOne, saveWeekOne, saveTimetableCache, saveCurrentPointer, loadCurrentPointer, loadTimetableCache, clearScheduleCache, } from './schedule-store.js';
-/** Loads a saved week-one Monday for `key`, or prompts for and persists a new one.
- * Returns null when the user cancels or enters an unparsable date (caller aborts). */
-async function ensureWeekOne(key) {
-    const saved = loadWeekOne(key);
-    if (saved)
-        return saved;
-    const value = await runTextInput({
-        message: t().timetable.promptWeekOne,
-        placeholder: 'YYYY-MM-DD',
-    });
-    if (value === null)
+import { createTimetableSchedule } from '@nbtca/nbtcal/timetable';
+import { addLocalDays, parseLocalMonday } from '../core/calendar-day.js';
+import { renderNextClassBanner, renderTodayTimeline } from './schedule-render.js';
+import { loadCurrentPointer, loadTimetableCache } from './schedule-store.js';
+import { sanitizeTimetable } from './timetable-sanitize.js';
+const WEEKDAYS = [1, 2, 3, 4, 5, 6, 7];
+function loadCachedTimetable() {
+    const pointer = loadCurrentPointer();
+    if (!pointer)
         return null;
-    const trimmed = value.trim();
-    if (!/^\d{4}-\d{2}-\d{2}$/.test(trimmed))
+    const value = loadTimetableCache(pointer.termKey);
+    if (!value || typeof value !== 'object')
         return null;
-    if (Number.isNaN(new Date(`${trimmed}T00:00:00`).getTime()))
-        return null;
-    saveWeekOne(key, trimmed);
-    return trimmed;
-}
-/** Fetches a term's timetable behind a spinner, caching it on success. Returns null
- * (after reporting the error) on failure so callers can keep the previous state. */
-async function fetchTimetableWithSpinner(client, term, key, weekOne) {
-    const trans = t();
-    const spinner = createSpinner(trans.calendar.loading);
-    try {
-        const tt = await client.fetchTerm(term);
-        spinner.stop();
-        saveTimetableCache(key, tt);
-        saveCurrentPointer(key, weekOne);
-        return tt;
-    }
-    catch (err) {
-        if (isSessionExpired(err)) {
-            spinner.stop();
-            throw err;
-        }
-        spinner.error(trans.timetable.genericError);
+    const candidate = value;
+    if (!Array.isArray(candidate.meetings) ||
+        !Array.isArray(candidate.periods) ||
+        !Array.isArray(candidate.unresolvedItems) ||
+        !Array.isArray(candidate.calendarDays) ||
+        !Array.isArray(candidate.warnings)) {
         return null;
     }
-}
-function renderHub(tt, weekOne, now) {
-    const week = currentWeekNumber(weekOne, now);
-    const today = meetingsOnDay(tt.meetings, campusWeekday(now), week);
-    const trans = t();
-    console.log();
-    const banner = renderNextClassBanner(nextMeeting(tt.meetings, tt.periods, weekOne, now), now);
-    console.log(banner || `${space.indent}${type.hint(trans.timetable.noNextClass)}`);
-    console.log();
-    console.log(renderTodayClasses(today, tt.periods, now));
-    console.log();
-    return { week, today };
-}
-async function switchTerm(client, catalog) {
-    const trans = t();
-    const picked = await runMenu({
-        title: trans.timetable.hubSwitchTerm,
-        options: relevantTerms(catalog).map((tm) => ({
-            value: `${tm.academicYear}:${tm.semester}`,
-            label: tm.academicYearLabel,
-            hint: tm.current ? trans.common.current : undefined,
-        })),
-        footer: menuFooter(),
-    });
-    if (picked === null)
+    const fetchedAt = new Date(candidate.fetchedAt);
+    if (Number.isNaN(fetchedAt.getTime()))
         return null;
-    const term = resolveTerm(catalog, picked);
-    const key = termKey(term);
-    const weekOne = await ensureWeekOne(key);
-    if (!weekOne)
-        return null;
-    const tt = await fetchTimetableWithSpinner(client, term, key, weekOne);
-    if (!tt)
-        return null;
-    return { term, key, weekOne, tt };
-}
-function exportTimetable(tt, term, key, weekOne) {
-    const trans = t();
-    const ics = timetableToIcs(tt, { weekOneMonday: weekOne, calendarName: `NBT ${term.academicYearLabel}` });
-    const out = `timetable-${key}.ics`;
-    try {
-        writePrivateIcs(out, ics);
-        success(fmt(trans.timetable.exported, { count: tt.meetings.length, file: path.resolve(out) }));
-    }
-    catch {
-        error(trans.timetable.genericError);
-    }
-}
-/** Interactive schedule hub: login/restore, resolve the current term, load or prompt
- * for the week-one Monday, fetch the timetable, then loop a menu of today / week-grid /
- * switch-term / export actions until the user cancels. */
-export async function showSchedule() {
-    const trans = t();
-    await enterScreen(breadcrumb(trans.timetable.menuEntry));
-    try {
-        await withAuthenticatedSession(async (session) => {
-            const client = createNbtTimetableClient(session.timetableTransport, { baseUrl: JWXT_ORIGIN });
-            const catalog = await client.listTerms();
-            let term = resolveTerm(catalog);
-            let key = termKey(term);
-            let weekOne = await ensureWeekOne(key);
-            if (!weekOne)
-                return 0;
-            const initial = await fetchTimetableWithSpinner(client, term, key, weekOne);
-            if (!initial)
-                return 1;
-            let tt = initial;
-            while (true) {
-                const now = new Date();
-                const { week, today } = renderHub(tt, weekOne, now);
-                const action = await runMenu({
-                    title: `${trans.timetable.menuEntry}  ${c.muted(term.academicYearLabel)}  ${c.muted(trans.timetable.weekLabel + String(week))}`,
-                    options: [
-                        { value: 'today', label: trans.timetable.hubToday, hint: String(today.length) },
-                        { value: 'week', label: trans.timetable.hubWeek },
-                        { value: 'term', label: trans.timetable.hubSwitchTerm, hint: term.academicYearLabel },
-                        { value: 'export', label: trans.timetable.hubExport },
-                        { value: 'logout', label: trans.timetable.hubLogout },
-                    ],
-                    footer: menuFooter(),
-                });
-                if (action === null)
-                    return 0;
-                if (action === 'today') {
-                    continue; // The next loop iteration repaints today's classes.
-                }
-                if (action === 'week') {
-                    console.log();
-                    console.log(renderWeekGrid(tt.meetings, tt.periods, week, now));
-                    console.log();
-                    continue;
-                }
-                if (action === 'term') {
-                    const switched = await switchTerm(client, catalog);
-                    if (!switched)
-                        continue;
-                    term = switched.term;
-                    key = switched.key;
-                    weekOne = switched.weekOne;
-                    tt = switched.tt;
-                    continue;
-                }
-                if (action === 'export') {
-                    exportTimetable(tt, term, key, weekOne);
-                    continue;
-                }
-                if (action === 'logout') {
-                    createSessionStore().clear();
-                    clearScheduleCache();
-                    return 0;
-                }
-            }
-        }, {
-            oneShot: false,
-            isInteractive: true,
-            store: createSessionStore(),
-            stderr: process.stderr,
-        });
-    }
-    catch (err) {
-        error(safeMessage(err));
-    }
+    return {
+        timetable: sanitizeTimetable({ ...candidate, fetchedAt }),
+        weekOneMonday: pointer.weekOneMonday,
+    };
 }
-/** Best-effort, cache-only startup line: reads the last-used term pointer and its
- * cached timetable (no network) and renders the next-class banner, or '' if the
- * student isn't "set up" yet or anything about the cache is missing/corrupt. */
 export function peekNextClassLine(now = new Date()) {
     try {
-        const ptr = loadCurrentPointer();
-        if (!ptr)
+        const cached = loadCachedTimetable();
+        if (!cached)
             return '';
-        const cached = loadTimetableCache(ptr.termKey);
-        if (!cached || !Array.isArray(cached.meetings) || !Array.isArray(cached.periods))
-            return '';
-        const next = nextMeeting(cached.meetings, cached.periods, ptr.weekOneMonday, now);
-        return renderNextClassBanner(next, now);
+        const schedule = createTimetableSchedule(cached.timetable, {
+            weekOneMonday: cached.weekOneMonday,
+        });
+        return renderNextClassBanner(schedule.next(now), now);
     }
     catch {
         return '';
     }
 }
-/** Cache-only (no network) render of today's classes for the current term, or
- * [] if not set up. Uses the same renderTodayTimeline Schedule's own hub
- * renders, so Home's preview and Schedule's detail view show the exact same
- * visual language for the exact same data instead of drifting apart. */
 export function peekTodayLines(now = new Date()) {
     try {
-        const ptr = loadCurrentPointer();
-        if (!ptr)
-            return [];
-        const cached = loadTimetableCache(ptr.termKey);
-        if (!cached || !Array.isArray(cached.meetings) || !Array.isArray(cached.periods))
+        const cached = loadCachedTimetable();
+        if (!cached)
             return [];
-        const week = currentWeekNumber(ptr.weekOneMonday, now);
-        const today = meetingsOnDay(cached.meetings, campusWeekday(now), week);
-        return renderTodayTimeline(today, cached.periods, now).split('\n');
+        const schedule = createTimetableSchedule(cached.timetable, {
+            weekOneMonday: cached.weekOneMonday,
+        });
+        const week = schedule.weekAt(now);
+        const today = schedule.meetingsOnDay(week, schedule.weekdayAt(now));
+        return renderTodayTimeline(today, cached.timetable.periods, now).split('\n');
     }
     catch {
         return [];
@@ -214,38 +59,26 @@ export function peekTodayLines(now = new Date()) {
 }
 export function peekWeekAheadInfo(now = new Date()) {
     try {
-        const ptr = loadCurrentPointer();
-        if (!ptr)
-            return null;
-        const cached = loadTimetableCache(ptr.termKey);
-        if (!cached || !Array.isArray(cached.meetings))
+        const cached = loadCachedTimetable();
+        if (!cached)
             return null;
-        const week = currentWeekNumber(ptr.weekOneMonday, now);
+        const schedule = createTimetableSchedule(cached.timetable, {
+            weekOneMonday: cached.weekOneMonday,
+        });
+        const week = schedule.weekAt(now);
         if (week < 1)
             return null;
-        const meetings = cached.meetings;
-        const classDays = [1, 2, 3, 4, 5, 6, 7].map((wd) => meetingsOnDay(meetings, wd, week).length > 0);
-        const base = new Date(`${ptr.weekOneMonday}T00:00:00`);
-        const weekStartDate = new Date(base.getTime() + (week - 1) * 7 * 86400000);
+        const classDays = WEEKDAYS.map((weekday) => schedule.meetingsOnDay(week, weekday).length > 0);
+        const weekStartDate = addLocalDays(parseLocalMonday(cached.weekOneMonday), (week - 1) * 7);
         return { weekStartDate, classDays };
     }
     catch {
         return null;
     }
 }
-/** Best-effort, cache-only (no network) read of how many timetable items
- * still need the student's attention — the same data buildHubField()
- * (schedule.ts) already surfaces inside Schedule's own hub menu, exposed
- * here so Home can show it too without a second source of truth. */
 export function peekUnresolvedCount() {
     try {
-        const ptr = loadCurrentPointer();
-        if (!ptr)
-            return 0;
-        const cached = loadTimetableCache(ptr.termKey);
-        if (!cached || !Array.isArray(cached.unresolvedItems))
-            return 0;
-        return cached.unresolvedItems.length;
+        return loadCachedTimetable()?.timetable.unresolvedItems.length ?? 0;
     }
     catch {
         return 0;

package/dist/features/status.js

@@ -1,13 +1,69 @@
 import chalk from 'chalk';
 import { APP_INFO, URLS } from '../config/data.js';
-import { getCapabilities } from '../core/capabilities.js';
-import { createPainter } from '../core/components/painter.js';
 import { pickIcon } from '../core/icons.js';
-import { padEndV, visualWidth } from '../core/text.js';
+import { padEndV, sanitizeTerminalLine, visualWidth } from '../core/text.js';
 import { c } from '../core/theme.js';
-import { createSpinner } from '../core/ui.js';
-import { enterScreen, breadcrumb } from '../core/transitions.js';
 import { t } from '../i18n/index.js';
+function abortError(signal) {
+    return signal.reason instanceof Error
+        ? signal.reason
+        : new DOMException('The status check was aborted.', 'AbortError');
+}
+function cancelResponseBody(response) {
+    try {
+        const body = response?.body;
+        if (!body)
+            return;
+        void body.cancel().catch(() => {
+            // Cancellation is best-effort and must not delay status results.
+        });
+    }
+    catch {
+        // A custom transport may expose an inaccessible, locked, or closed body.
+    }
+}
+function raceWithSignal(operation, signal, onLateValue) {
+    return new Promise((resolve, reject) => {
+        let settled = false;
+        const cleanup = () => {
+            signal.removeEventListener('abort', onAbort);
+        };
+        const onAbort = () => {
+            if (settled)
+                return;
+            settled = true;
+            cleanup();
+            reject(abortError(signal));
+        };
+        signal.addEventListener('abort', onAbort, { once: true });
+        void operation
+            .then((value) => {
+            if (settled) {
+                try {
+                    onLateValue?.(value);
+                }
+                catch {
+                    // Late cleanup is best-effort.
+                }
+                return;
+            }
+            settled = true;
+            cleanup();
+            resolve(value);
+        }, (error) => {
+            if (settled)
+                return;
+            settled = true;
+            cleanup();
+            reject(error instanceof Error ? error : new Error(String(error)));
+        })
+            .catch(() => {
+            // Both operation outcomes are handled above. This only guards cleanup code.
+        });
+        if (signal.aborted)
+            onAbort();
+    });
+}
 function getServiceTargets() {
     const trans = t();
     return [
@@ -21,46 +77,73 @@ function getServiceTargets() {
         { name: trans.status.serviceMirror, url: URLS.mirror, group: 'intranet', intranet: true },
     ];
 }
-async function checkService(name, url, timeoutMs) {
+async function checkService(name, url, timeoutMs, signal) {
     const start = Date.now();
+    const controller = new AbortController();
+    const onAbort = () => {
+        controller.abort(signal?.reason);
+    };
+    signal?.addEventListener('abort', onAbort, { once: true });
+    if (signal?.aborted)
+        onAbort();
+    const timeout = setTimeout(() => {
+        controller.abort();
+    }, timeoutMs);
+    let response;
     try {
-        const controller = new AbortController();
-        const timeout = setTimeout(() => controller.abort(), timeoutMs);
-        const response = await fetch(url, {
+        response = await raceWithSignal(fetch(url, {
             signal: controller.signal,
             redirect: 'follow',
             headers: { 'User-Agent': `NBTCA-CLI/${APP_INFO.version}` },
-        });
-        clearTimeout(timeout);
+        }), controller.signal, cancelResponseBody);
+        if (signal?.aborted)
+            throw abortError(signal);
         const latencyMs = Date.now() - start;
         const ok = response.status >= 200 && response.status < 400;
         return { name, url, ok, statusCode: response.status, latencyMs };
     }
     catch (err) {
+        if (signal?.aborted)
+            throw abortError(signal);
         const latencyMs = Date.now() - start;
-        const error = err instanceof Error
-            ? (err.name === 'AbortError' ? 'Request timed out' : err.message)
-            : String(err);
+        const error = sanitizeTerminalLine(err instanceof Error
+            ? err.name === 'AbortError'
+                ? 'Request timed out'
+                : err.message
+            : String(err));
         return { name, url, ok: false, latencyMs, error };
     }
+    finally {
+        clearTimeout(timeout);
+        signal?.removeEventListener('abort', onAbort);
+        cancelResponseBody(response);
+    }
 }
-export async function checkServiceWithRetry(target, timeoutMs, retries) {
-    let lastResult = await checkService(target.name, target.url, timeoutMs);
+async function checkServiceWithRetry(target, timeoutMs, retries, signal) {
+    let lastResult = await checkService(target.name, target.url, timeoutMs, signal);
     if (!lastResult.ok) {
         for (let attempt = 0; attempt < retries; attempt++) {
             if (!lastResult.error && !(lastResult.statusCode != null && lastResult.statusCode >= 500))
                 break;
-            lastResult = await checkService(target.name, target.url, timeoutMs);
+            if (signal?.aborted)
+                throw abortError(signal);
+            lastResult = await checkService(target.name, target.url, timeoutMs, signal);
             if (lastResult.ok)
                 break;
         }
     }
-    return { ...lastResult, group: target.group, intranet: target.intranet };
+    return {
+        ...lastResult,
+        group: target.group,
+        ...(target.intranet === undefined ? {} : { intranet: target.intranet }),
+    };
 }
 export async function checkServices(options = {}) {
     const timeoutMs = options.timeoutMs ?? 6000;
     const retries = options.retries ?? 1;
-    return Promise.all(getServiceTargets().map(t => checkServiceWithRetry(t, timeoutMs, retries)));
+    if (options.signal?.aborted)
+        throw abortError(options.signal);
+    return Promise.all(getServiceTargets().map((target) => checkServiceWithRetry(target, timeoutMs, retries, options.signal)));
 }
 export function serializeServiceStatus(items) {
     return items.map((item) => ({
@@ -75,12 +158,12 @@ export function serializeServiceStatus(items) {
     }));
 }
 export function hasServiceFailures(items) {
-    return items.some(item => !item.ok && !item.intranet);
+    return items.some((item) => !item.ok && !item.intranet);
 }
 export function countServiceHealth(items) {
     let up = 0;
     let down = 0;
-    for (const item of items.filter(i => !i.intranet)) {
+    for (const item of items.filter((i) => !i.intranet)) {
         if (item.ok)
             up++;
         else
@@ -97,7 +180,7 @@ export function renderServiceStatusTable(items, options) {
     const applyCyan = useColor ? chalk.cyan : id;
     const applyLatency = useColor ? c.latency : (ms) => `${ms}ms`;
     const trans = t();
-    const nameWidth = Math.max(...items.map(i => visualWidth(i.name)), visualWidth(trans.status.service));
+    const nameWidth = Math.max(...items.map((i) => visualWidth(i.name)), visualWidth(trans.status.service));
     const statusWidth = 10;
     const onIcon = pickIcon('●', '+');
     const offIcon = pickIcon('✕', '!');
@@ -109,14 +192,22 @@ export function renderServiceStatusTable(items, options) {
         if (item.group !== currentGroup) {
             if (currentGroup !== undefined)
                 lines.push('');
-            const groupLabel = item.group === 'nbtca' ? trans.status.groupNbtca :
-                item.group === 'external' ? trans.status.groupExternal :
-                    item.group === 'intranet' ? trans.status.groupIntranet : '';
+            const groupLabel = item.group === 'nbtca'
+                ? trans.status.groupNbtca
+                : item.group === 'external'
+                    ? trans.status.groupExternal
+                    : item.group === 'intranet'
+                        ? trans.status.groupIntranet
+                        : '';
             lines.push(`  ${applyDim(groupLabel)}`);
             lines.push(`  ${applyDim(sep.repeat(nameWidth + statusWidth + 12))}`);
             currentGroup = item.group;
         }
-        const nameCol = padEndV(item.pending ? applyDim(item.name) : (item.intranet ? applyDim(item.name) : applyCyan(item.name)), nameWidth);
+        const nameCol = padEndV(item.pending
+            ? applyDim(item.name)
+            : item.intranet
+                ? applyDim(item.name)
+                : applyCyan(item.name), nameWidth);
         let statusLabel;
         if (item.pending) {
             statusLabel = applyDim(pickIcon('…', '.'));
@@ -138,37 +229,3 @@ export function renderServiceStatusTable(items, options) {
     }
     return lines.join('\n');
 }
-export async function showServiceStatus() {
-    const trans = t();
-    await enterScreen(breadcrumb(trans.menu.status));
-    const targets = getServiceTargets();
-    if (getCapabilities().reducedMotion) {
-        const spinner = createSpinner(trans.status.checking);
-        const items = await checkServices();
-        const hasFailures = hasServiceFailures(items);
-        if (hasFailures)
-            spinner.error(trans.status.summaryFail);
-        else
-            spinner.stop(trans.status.summaryOk);
-        console.log();
-        console.log(renderServiceStatusTable(items, { color: !!process.stdout.isTTY }));
-        console.log();
-        return items;
-    }
-    const items = targets.map((tg) => ({
-        name: tg.name, url: tg.url, ok: false, group: tg.group, intranet: tg.intranet, pending: true,
-    }));
-    const paint = createPainter(() => renderServiceStatusTable(items, { color: getCapabilities().color }));
-    console.log();
-    paint();
-    await Promise.all(targets.map(async (target, i) => {
-        const status = await checkServiceWithRetry(target, 6000, 1);
-        items[i] = { ...status, pending: false };
-        paint();
-    }));
-    console.log('\n');
-    const hasFailures = hasServiceFailures(items);
-    console.log(hasFailures ? c.warn(trans.status.summaryFail) : c.success(trans.status.summaryOk));
-    console.log();
-    return items;
-}