@nbtca/prompt 1.4.2 → 1.5.1

package/dist/app/views/events.js

@@ -7,6 +7,7 @@ import { pickIcon } from '../../core/icons.js';
 import { t } from '../../i18n/index.js';
 import { loadCalendarOrThrow, toDisplayEvent, exportEventIcs } from '../../features/calendar.js';
 import { weekRange, monthRange, filterEvents } from '../../features/calendar-query.js';
+import { addLocalDays } from '../../core/calendar-day.js';
 let state = { mode: 'loading' };
 let calendar = null;
 let currentList = [];
@@ -29,36 +30,42 @@ function buildListField(title, events, maxVisible) {
     const trans = t();
     const display = events.map(toDisplayEvent);
     const options = [
-        ...events.map((_e, i) => ({
-            value: String(i),
-            label: `${display[i].date}${display[i].time ? ' ' + display[i].time : ''}  ${display[i].title}`,
-            hint: display[i].location,
+        ...display.map((event, index) => ({
+            value: String(index),
+            label: `${event.date}${event.time ? ` ${event.time}` : ''}  ${event.title}`,
+            hint: event.location,
         })),
         { value: '__back__', label: backLabel() },
     ];
     return new ListField({
         title: title || trans.menu.events,
-        options: options.length > 1 ? options : [{ value: '__back__', label: `${trans.calendar.noEvents} — ${backLabel()}` }],
+        options: options.length > 1
+            ? options
+            : [{ value: '__back__', label: `${trans.calendar.noEvents} — ${backLabel()}` }],
         maxVisible,
     });
 }
 function showList(title, events, ctx) {
     currentList = events;
-    state = { mode: 'list', listField: buildListField(title, events, computeMaxVisible(ctx.bodyRows)) };
+    state = {
+        mode: 'list',
+        listField: buildListField(title, events, computeMaxVisible(ctx.bodyRows)),
+    };
 }
-// A glance-panel ceiling, not "browse everything" (this tab's own "Events"
-// list is for that) — just needs to be at least as many as the tallest
-// reasonable terminal could fit; renderHubBody trims further based on the
-// real ctx.bodyRows.
 const RECENT_ACTIVITY_FETCH_CAP = 15;
 function goToHub() {
     const upcoming = calendar ? calendar.upcoming({ days: 30 }) : [];
+    const nextEvent = upcoming[0];
     state = {
         mode: 'hub',
         hubField: buildHubField(),
-        nextEvent: upcoming[0] ? toDisplayEvent(upcoming[0]) : undefined,
+        ...(nextEvent === undefined ? {} : { nextEvent: toDisplayEvent(nextEvent) }),
         heatmapBuckets: calendar
-            ? calendar.heatmap({ start: new Date(Date.now() - 365 * 86400000), end: new Date(), bucket: 'day' })
+            ? calendar.heatmap({
+                start: addLocalDays(new Date(), -365),
+                end: new Date(),
+                bucket: 'day',
+            })
             : [],
         recentEvents: upcoming.slice(0, RECENT_ACTIVITY_FETCH_CAP).map(toDisplayEvent),
     };
@@ -74,10 +81,6 @@ function showDetail(raw) {
         detailDescription: e.description,
         detailEvent: raw,
         detailField: new ListField({
-            // Empty, not e.title: renderEvents already prints the event title as
-            // its own heading right above (detailTitle) -- giving the field the
-            // same string a second time repeated it verbatim just above the
-            // Export/Back options.
             title: '',
             options: [
                 { value: 'export', label: trans.calendar.exportIcs },
@@ -90,39 +93,49 @@ export const eventsView = {
     id: 'events',
     title: t().menu.events,
     async load(ctx) {
+        if (ctx.signal?.aborted)
+            return;
         state = { mode: 'loading' };
         ctx.rerender();
         try {
-            calendar = await loadCalendarOrThrow();
+            const loadedCalendar = await loadCalendarOrThrow(ctx.signal);
+            if (ctx.signal?.aborted)
+                return;
+            calendar = loadedCalendar;
             goToHub();
         }
         catch {
+            if (ctx.signal?.aborted)
+                return;
             state = { mode: 'error', errorMessage: t().calendar.error };
         }
-        ctx.rerender();
+        if (!ctx.signal?.aborted)
+            ctx.rerender();
     },
     render(ctx) {
-        // Sync the list's scroll window to the *current* terminal size on every
-        // frame (not just construction time) — this is what keeps a long list
-        // correctly windowed across a live resize.
         state.listField?.setMaxVisible(computeMaxVisible(ctx.bodyRows));
         return renderEvents(state, new Date(), ctx.bodyRows, ctx.size.cols);
     },
+    isBusy() {
+        return state.mode === 'loading';
+    },
     capturesInput() {
         return state.mode === 'search';
     },
+    capturesPageKeys() {
+        return state.mode === 'hub' || state.mode === 'list' || state.mode === 'detail';
+    },
     footerHint(tabCount, cols = Number.POSITIVE_INFINITY) {
         if (state.mode === 'search')
             return captureFooterHint(cols);
-        // A pure "read this, any key returns to the hub" drill-down (see
-        // handleKey below) -- no field to move a cursor within or open an item
-        // from, so the generic "move · open" hint would promise keys that
-        // don't do that here.
         const passive = state.mode === 'loading' || state.mode === 'error' || state.mode === 'heatmap';
         return passive ? passiveFooterHint(tabCount, cols) : undefined;
     },
     handleBack() {
-        if (state.mode === 'list' || state.mode === 'detail' || state.mode === 'search' || state.mode === 'heatmap') {
+        if (state.mode === 'list' ||
+            state.mode === 'detail' ||
+            state.mode === 'search' ||
+            state.mode === 'heatmap') {
             if (state.mode === 'search')
                 setVimKeysActive(true);
             goToHub();
@@ -163,12 +176,17 @@ export const eventsView = {
                 }
                 if (result.selected === 'search') {
                     setVimKeysActive(false);
-                    state = { mode: 'search', searchField: new TextField({ message: t().calendar.searchPrompt, placeholder: t().calendar.searchPlaceholder, allowEmpty: true }) };
+                    state = {
+                        mode: 'search',
+                        searchField: new TextField({
+                            message: t().calendar.searchPrompt,
+                            placeholder: t().calendar.searchPlaceholder,
+                            allowEmpty: true,
+                        }),
+                    };
                 }
                 return;
             }
-            // A pure detail/drill-down view with no field of its own — any key
-            // returns to the hub, matching Schedule's 'week'/'unresolved' modes.
             case 'heatmap': {
                 goToHub();
                 return;
@@ -196,7 +214,12 @@ export const eventsView = {
                 }
                 if (result.selected === 'export' && state.detailEvent) {
                     const res = exportEventIcs(state.detailEvent);
-                    state = { ...state, statusMessage: res.ok ? `${t().calendar.exportSuccess}: ${res.path}` : `${t().calendar.exportError}: ${res.error ?? ''}` };
+                    state = {
+                        ...state,
+                        statusMessage: res.ok
+                            ? `${t().calendar.exportSuccess}: ${res.path}`
+                            : `${t().calendar.exportError}: ${res.error ?? ''}`,
+                    };
                 }
                 return;
             }
@@ -210,18 +233,19 @@ export const eventsView = {
                 if (result?.submitted !== undefined) {
                     setVimKeysActive(true);
                     const query = result.submitted.trim();
-                    if (!query || !calendar) {
+                    if (!query) {
                         goToHub();
                         return;
                     }
                     const now = new Date();
-                    const pool = calendar.inRange(now, new Date(now.getTime() + 365 * 86400000));
+                    const pool = calendar.inRange(now, addLocalDays(now, 365));
                     const results = filterEvents(pool, query);
                     showList(`${t().calendar.search}: ${query}`, results, ctx);
                 }
                 return;
             }
-            default:
+            case 'loading':
+            case 'error':
                 return;
         }
     },

package/dist/app/views/home.js

@@ -1,30 +1,21 @@
 import { c, type, space, glyph } from '../../core/theme.js';
 import { t } from '../../i18n/index.js';
 import { pickIcon } from '../../core/icons.js';
-import { padEndV, visualWidth, wrapAnsiToVisualWidth } from '../../core/text.js';
-import { peekNextClassLine, peekTodayLines, peekWeekAheadInfo, peekUnresolvedCount } from '../../features/schedule-view.js';
-import { loadCalendarOrThrow, toDisplayEvent, renderEventBrief } from '../../features/calendar.js';
+import { padEndV, visualWidth, wrapAnsiWithIndent } from '../../core/text.js';
+import { peekNextClassLine, peekTodayLines, peekWeekAheadInfo, peekUnresolvedCount, } from '../../features/schedule-view.js';
+import { loadCalendarOrThrow, peekCalendar, toDisplayEvent, renderEventBrief, } from '../../features/calendar.js';
 import { weekdayShortLabel } from '../../features/schedule-render.js';
-import { campusWeekday } from '../../features/schedule-query.js';
+import { addLocalDays } from '../../core/calendar-day.js';
 import { passiveFooterHint } from '../chrome.js';
+import { campusWeekday } from '@nbtca/nbtcal/timetable';
+import { loadingLines } from '../../core/components/spinner.js';
+const WEEKDAYS = [1, 2, 3, 4, 5, 6, 7];
 function wrappedIndentedLines(label, cols, style) {
-    const width = Number.isFinite(cols) ? Math.max(1, Math.floor(cols)) : Number.POSITIVE_INFINITY;
-    const styled = style(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(style(label), cols, space.indent);
 }
 function panelHeading(label, cols) {
     return wrappedIndentedLines(label, cols, type.heading);
 }
-function loadingLines(cols) {
-    return wrappedIndentedLines(t().common.loading, cols, type.hint);
-}
 function wrappedRenderedLines(line, cols) {
     const content = line.startsWith(space.indent) ? line.slice(space.indent.length) : line;
     return wrappedIndentedLines(content, cols, (value) => value);
@@ -39,7 +30,9 @@ function renderDayProgress(now, cols) {
     const indent = visualWidth(space.indent) + 2 + visualWidth(percentage) + 1 <= width ? space.indent : '';
     const gap = visualWidth(indent) + 2 + visualWidth(percentage) + 1 <= width
         ? '  '
-        : visualWidth(indent) + 1 + visualWidth(percentage) + 1 <= width ? ' ' : '';
+        : visualWidth(indent) + 1 + visualWidth(percentage) + 1 <= width
+            ? ' '
+            : '';
     const barWidth = Math.max(0, Math.min(DAY_PROGRESS_WIDTH, width - visualWidth(indent) - visualWidth(gap) - visualWidth(percentage)));
     const filled = Math.round(fraction * barWidth);
     const filledChar = glyph.barFilled();
@@ -57,17 +50,21 @@ function renderWeekAheadGrid(classDays, eventDays, cols) {
     const days = [1, 2, 3, 4, 5, 6, 7];
     const dayLabels = days.map((wd) => type.hint(weekdayShortLabel(wd))).join('  ');
     const headerLine = `${space.indent}${padEndV('', rowLabelW)}${dayLabels}`;
-    const classCells = days.map((wd) => {
+    const classCells = days
+        .map((wd) => {
         const isWeekend = wd === 6 || wd === 7;
-        const glyphChar = isWeekend ? weekendChar : (classDays[wd - 1] ? hasClassChar : freeChar);
+        const glyphChar = isWeekend ? weekendChar : classDays[wd - 1] ? hasClassChar : freeChar;
         return type.body(glyphChar);
-    }).join('  ');
+    })
+        .join('  ');
     const classLine = `${space.indent}${type.hint(padEndV(trans.timetable.weekAheadClasses, rowLabelW))}${classCells}`;
-    const eventCells = days.map((wd) => {
+    const eventCells = days
+        .map((wd) => {
         if (!eventDays)
             return blankCell;
         return type.body(eventDays[wd - 1] ? hasClassChar : freeChar);
-    }).join('  ');
+    })
+        .join('  ');
     const eventLine = `${space.indent}${type.hint(padEndV(trans.menu.events, rowLabelW))}${eventCells}`;
     const legend = `${space.indent}${type.hint(`${hasClassChar} ${trans.timetable.weekAheadBusy}  ${freeChar} ${trans.timetable.weekAheadFree}  ${weekendChar} ${trans.timetable.weekAheadNone}`)}`;
     const wideLines = [headerLine, classLine, eventLine, legend];
@@ -76,12 +73,8 @@ function renderWeekAheadGrid(classDays, eventDays, cols) {
         return wideLines.join('\n');
     const compactHeading = wrappedIndentedLines(`${trans.timetable.weekAheadClasses} / ${trans.menu.events}`, cols, type.hint);
     const compactDays = days.flatMap((wd) => {
-        const classCell = wd === 6 || wd === 7
-            ? weekendChar
-            : classDays[wd - 1] ? hasClassChar : freeChar;
-        const eventCell = eventDays
-            ? eventDays[wd - 1] ? hasClassChar : freeChar
-            : blankCell;
+        const classCell = wd === 6 || wd === 7 ? weekendChar : classDays[wd - 1] ? hasClassChar : freeChar;
+        const eventCell = eventDays ? (eventDays[wd - 1] ? hasClassChar : freeChar) : blankCell;
         const row = `${type.hint(weekdayShortLabel(wd))}  ${type.body(classCell)}  ${type.body(eventCell)}`;
         return wrappedIndentedLines(row, cols, (value) => value);
     });
@@ -116,7 +109,10 @@ export function renderHome(data, now, bodyRows = 100, cols = 80) {
         lines.push(...wrappedIndentedLines(`${pickIcon('⚠', '!')} ${trans.timetable.hubUnresolved} · ${data.unresolvedCount}`, cols, c.warn));
         lines.push('');
     }
-    lines.push(...panelHeading(trans.menu.events, cols));
+    const eventsStale = data.eventsLoadFailed === true && (data.eventLines?.length ?? 0) > 0;
+    lines.push(...(eventsStale
+        ? wrappedIndentedLines(`${type.heading(trans.menu.events)}  ${type.hint(`${pickIcon('·', '-')} ${trans.calendar.stale}`)}`, cols, (value) => value)
+        : panelHeading(trans.menu.events, cols)));
     if (data.eventLines && data.eventLines.length > 0) {
         const remaining = Number.isFinite(bodyRows)
             ? Math.max(0, Math.floor(bodyRows) - lines.length)
@@ -134,7 +130,7 @@ export function renderHome(data, now, bodyRows = 100, cols = 80) {
         }
     }
     else if (data.loading) {
-        lines.push(...loadingLines(cols));
+        lines.push(...loadingLines(trans.common.loading, cols));
     }
     else if (data.eventsLoadFailed) {
         lines.push(...wrappedIndentedLines(trans.calendar.error, cols, type.hint));
@@ -144,6 +140,25 @@ export function renderHome(data, now, bodyRows = 100, cols = 80) {
     }
     return lines;
 }
+const HOME_EVENT_FETCH_CAP = 15;
+function calendarSnapshot(cal, weekAheadInfo) {
+    const now = new Date();
+    const eventLines = cal
+        .upcoming({ days: 30 })
+        .slice(0, HOME_EVENT_FETCH_CAP)
+        .map((event) => renderEventBrief(toDisplayEvent(event), now));
+    if (!weekAheadInfo)
+        return { eventLines };
+    const weekEnd = addLocalDays(weekAheadInfo.weekStartDate, 7);
+    const daySet = new Set(cal.inRange(weekAheadInfo.weekStartDate, weekEnd).map((event) => campusWeekday(event.start)));
+    return {
+        eventLines,
+        weekAhead: {
+            classDays: weekAheadInfo.classDays,
+            eventDays: WEEKDAYS.map((weekday) => daySet.has(weekday)),
+        },
+    };
+}
 let data = { loading: true };
 export const homeView = {
     id: 'home',
@@ -152,6 +167,8 @@ export const homeView = {
         return passiveFooterHint(tabCount, cols);
     },
     async load(ctx) {
+        if (ctx.signal?.aborted)
+            return;
         const weekAheadInfo = peekWeekAheadInfo();
         try {
             data = {
@@ -159,36 +176,39 @@ export const homeView = {
                 nextClassLine: peekNextClassLine(),
                 todayLines: peekTodayLines(),
                 unresolvedCount: peekUnresolvedCount(),
-                weekAhead: weekAheadInfo ? { classDays: weekAheadInfo.classDays } : undefined,
+                ...(weekAheadInfo ? { weekAhead: { classDays: weekAheadInfo.classDays } } : {}),
             };
         }
         catch {
             data = { loading: true };
         }
+        const cached = peekCalendar();
+        if (cached)
+            data = { ...data, ...calendarSnapshot(cached, weekAheadInfo) };
+        if (ctx.signal?.aborted)
+            return;
         ctx.rerender();
-        const HOME_EVENT_FETCH_CAP = 15;
         try {
-            const cal = await loadCalendarOrThrow();
-            const now = new Date();
-            const items = cal.upcoming({ days: 30 }).slice(0, HOME_EVENT_FETCH_CAP).map(toDisplayEvent);
-            const eventLines = items.map((e) => renderEventBrief(e, now));
-            let weekAhead = data.weekAhead;
-            if (weekAheadInfo) {
-                const weekEnd = new Date(weekAheadInfo.weekStartDate.getTime() + 7 * 86400000);
-                const weekEvents = cal.inRange(weekAheadInfo.weekStartDate, weekEnd);
-                const daySet = new Set(weekEvents.map((e) => campusWeekday(e.start)));
-                weekAhead = { classDays: weekAheadInfo.classDays, eventDays: [1, 2, 3, 4, 5, 6, 7].map((wd) => daySet.has(wd)) };
-            }
-            data = { ...data, eventLines, weekAhead };
+            const cal = await loadCalendarOrThrow(ctx.signal);
+            if (ctx.signal?.aborted)
+                return;
+            data = { ...data, ...calendarSnapshot(cal, weekAheadInfo) };
         }
         catch {
+            if (ctx.signal?.aborted)
+                return;
             data = { ...data, eventsLoadFailed: true };
         }
         finally {
-            data = { ...data, loading: false };
-            ctx.rerender();
+            if (!ctx.signal?.aborted) {
+                data = { ...data, loading: false };
+                ctx.rerender();
+            }
         }
     },
+    isBusy() {
+        return data.loading === true;
+    },
     render(ctx) {
         return renderHome(data, new Date(), ctx.bodyRows, ctx.size.cols);
     },

package/dist/app/views/schedule-grid-cursor.js

@@ -1,40 +1,31 @@
-import { meetingAtCursor } from '../../features/schedule-query.js';
+import { createTimetableSchedule, } from '@nbtca/nbtcal/timetable';
 export const KEY_ARROW_LEFT = '\x1b[D';
 export const KEY_ARROW_RIGHT = '\x1b[C';
 export const KEY_ARROW_UP = '\x1b[A';
 export const KEY_ARROW_DOWN = '\x1b[B';
 export const KEY_ENTER_CR = '\r';
 export const KEY_ENTER_LF = '\n';
-/** The cursor's starting position on entering hub/week mode: today's own
- * weekday (falling back to Monday on a weekend, since the grid's Sat/Sun
- * columns are always empty for a personal timetable) and the first period
- * this term's own period table actually defines. */
 export function defaultGridCursor(todayWeekday, periods) {
     const sorted = [...periods].sort((a, b) => a.period - b.period);
     const firstPeriod = sorted[0]?.period ?? 1;
-    const weekday = todayWeekday >= 1 && todayWeekday <= 5 ? todayWeekday : 1;
+    const weekday = (todayWeekday >= 1 && todayWeekday <= 5 ? todayWeekday : 1);
     return { weekday, period: firstPeriod };
 }
-/** Moves the cursor one weekday left/right, clamped to [1, 7] with no
- * wraparound -- a 7-day week has a real fixed edge, unlike a scrollable
- * list where wrapping back to the top makes sense. */
 export function moveCursorWeekday(cursor, delta) {
-    return { ...cursor, weekday: Math.max(1, Math.min(7, cursor.weekday + delta)) };
+    return {
+        ...cursor,
+        weekday: Math.max(1, Math.min(7, cursor.weekday + delta)),
+    };
 }
-/** Moves the cursor to the previous/next *defined* period in the sorted
- * period table (not period±1 -- real period numbers aren't always
- * contiguous), clamped at the first/last period with no wraparound. */
 export function moveCursorPeriod(cursor, periods, delta) {
     const sorted = [...periods].sort((a, b) => a.period - b.period);
     if (sorted.length === 0)
         return cursor;
     const idx = sorted.findIndex((p) => p.period === cursor.period);
     const nextIdx = Math.max(0, Math.min(sorted.length - 1, (idx === -1 ? 0 : idx) + delta));
-    return { ...cursor, period: sorted[nextIdx].period };
+    const nextPeriod = sorted[nextIdx];
+    return nextPeriod ? { ...cursor, period: nextPeriod.period } : cursor;
 }
-/** Pure key-to-action mapping shared by hub mode's inline grid and the
- * standalone full-screen 'week' mode -- both are cursor-navigable over the
- * exact same rules, so this is the one place that logic lives. */
 export function handleGridKey(key, cursor, tt, week) {
     if (key === KEY_ARROW_LEFT)
         return { kind: 'moveCursor', cursor: moveCursorWeekday(cursor, -1) };
@@ -45,7 +36,7 @@ export function handleGridKey(key, cursor, tt, week) {
     if (key === KEY_ARROW_DOWN)
         return { kind: 'moveCursor', cursor: moveCursorPeriod(cursor, tt.periods, 1) };
     if (key === KEY_ENTER_CR || key === KEY_ENTER_LF) {
-        const meeting = meetingAtCursor(tt.meetings, week, cursor);
+        const meeting = createTimetableSchedule(tt).meetingAt(week, cursor.weekday, cursor.period);
         return meeting ? { kind: 'openDetail', meeting } : { kind: 'none' };
     }
     return { kind: 'none' };