@nbtca/prompt 1.4.1 → 1.5.0

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

@@ -3,29 +3,14 @@ import { t } from '../../i18n/index.js';
 import { renderListFieldWithContext } from '../fields/list-field.js';
 import { renderCountdownBanner, renderEventBrief } from '../../features/calendar.js';
 import { renderHeatmap } from '../../features/calendar-heatmap.js';
-import { visualWidth, wrapAnsiToVisualWidth } from '../../core/text.js';
+import { wrapAnsiWithIndent } from '../../core/text.js';
 function wrappedIndentedLines(label, cols, style) {
-    const width = Number.isFinite(cols) ? Math.max(1, Math.floor(cols ?? 1)) : Number.POSITIVE_INFINITY;
-    const styled = style(label);
-    const styledWidth = visualWidth(styled);
-    const preferredIndent = visualWidth(space.indent) < width ? space.indent : '';
-    const indent = preferredIndent
-        && styledWidth > width - visualWidth(preferredIndent)
-        && styledWidth <= width
-        ? ''
-        : preferredIndent;
-    const contentWidth = Math.max(1, width - visualWidth(indent));
-    return wrapAnsiToVisualWidth(styled, contentWidth).map((line) => `${indent}${line}`);
+    return wrapAnsiWithIndent(style(label), cols ?? Number.POSITIVE_INFINITY, space.indent);
 }
 function wrappedRenderedLine(line, cols) {
     const content = line.startsWith(space.indent) ? line.slice(space.indent.length) : line;
     return wrappedIndentedLines(content, cols, (value) => value);
 }
-// Lines a fully-expanded hub needs: banner+blank (2) + heatmap+blank (12) +
-// recent-activity heading+up to 5 events+blank (7) + hubField
-// (title+blank+6 options, 8) = 29. Below this, a terminal can't fit the
-// heatmap without pushing the menu into scroll territory — better to keep
-// it as the existing drill-down destination than show a truncated grid.
 const EXPANDED_HUB_MIN_BODY_ROWS = 29;
 function renderHubBody(state, now, bodyRows, cols) {
     const trans = t();
@@ -38,7 +23,10 @@ function renderHubBody(state, now, bodyRows, cols) {
         lines.push(...banner.split('\n'), '');
     const buckets = state.heatmapBuckets;
     if (bodyRows >= EXPANDED_HUB_MIN_BODY_ROWS && buckets && buckets.length > 0) {
-        lines.push(...renderHeatmap(buckets, now, { color: true, cols }).split('\n'));
+        lines.push(...renderHeatmap(buckets, now, {
+            color: true,
+            ...(cols === undefined ? {} : { cols }),
+        }).split('\n'));
         lines.push('');
     }
     if (state.recentEvents && state.recentEvents.length > 0) {
@@ -77,12 +65,11 @@ export function renderEvents(state, now, bodyRows = 100, cols) {
         case 'hub':
             return renderHubBody(state, now, bodyRows, cols);
         case 'heatmap':
-            // renderHeatmap() already prints its own title (space.indent +
-            // type.heading), so this mode doesn't add a second heading on top —
-            // unlike Schedule's 'week'/'unresolved' modes, which wrap a
-            // title-less renderer.
             return state.heatmapBuckets && state.heatmapBuckets.length > 0
-                ? renderHeatmap(state.heatmapBuckets, now, { color: true, cols }).split('\n')
+                ? renderHeatmap(state.heatmapBuckets, now, {
+                    color: true,
+                    ...(cols === undefined ? {} : { cols }),
+                }).split('\n')
                 : wrappedIndentedLines(trans.calendar.noEvents, cols, type.hint);
         case 'list':
             return state.listField?.render(bodyRows, cols) ?? [];
@@ -92,14 +79,20 @@ export function renderEvents(state, now, bodyRows = 100, cols) {
                 ...wrappedIndentedLines(state.detailMeta ?? '', cols, type.hint),
                 '',
                 ...(state.detailDescription
-                    ? state.detailDescription.split('\n').flatMap((line) => wrappedIndentedLines(line, cols, type.body))
+                    ? state.detailDescription
+                        .split('\n')
+                        .flatMap((line) => wrappedIndentedLines(line, cols, type.body))
                     : wrappedIndentedLines(trans.calendar.noDescription, cols, type.hint)),
                 '',
-                ...(state.statusMessage ? [...wrappedIndentedLines(state.statusMessage, cols, type.hint), ''] : []),
+                ...(state.statusMessage
+                    ? [...wrappedIndentedLines(state.statusMessage, cols, type.hint), '']
+                    : []),
             ];
             return state.detailField
                 ? renderListFieldWithContext(context, state.detailField, bodyRows, cols)
-                : Number.isFinite(bodyRows) ? context.slice(0, Math.max(0, Math.floor(bodyRows))) : context;
+                : Number.isFinite(bodyRows)
+                    ? context.slice(0, Math.max(0, Math.floor(bodyRows)))
+                    : context;
         }
         case 'search':
             return state.searchField?.render(cols) ?? [];

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 },
@@ -102,27 +105,26 @@ export const eventsView = {
         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);
     },
     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 +165,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 +203,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 +222,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,23 +1,16 @@
 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 { padEndV, visualWidth, wrapAnsiWithIndent } from '../../core/text.js';
+import { peekNextClassLine, peekTodayLines, peekWeekAheadInfo, peekUnresolvedCount, } from '../../features/schedule-view.js';
 import { loadCalendarOrThrow, 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';
+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);
@@ -30,7 +23,6 @@ function wrappedRenderedLines(line, cols) {
     return wrappedIndentedLines(content, cols, (value) => value);
 }
 const DAY_PROGRESS_WIDTH = 20;
-/** Pure: a block-character bar for how far into the calendar day `now` is. */
 function renderDayProgress(now, cols) {
     const minutesElapsed = now.getHours() * 60 + now.getMinutes();
     const fraction = Math.min(1, Math.max(0, minutesElapsed / 1440));
@@ -40,7 +32,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();
@@ -48,13 +42,6 @@ function renderDayProgress(now, cols) {
     const bar = filledChar.repeat(filled) + emptyChar.repeat(barWidth - filled);
     return `${indent}${type.body(bar)}${gap}${type.hint(percentage)}`;
 }
-/** Combined class+event density grid for the coming campus week — the one
- * visualization neither Schedule nor Events alone can produce, since it
- * needs both data sources at once. Deliberately coarser (binary, not
- * 5-level) than Schedule's own term-density strip, and deliberately
- * uncolored (see the design spec's "Visual language decision") since it's
- * an overview of two other already-colored things, not a third color
- * language to learn. */
 function renderWeekAheadGrid(classDays, eventDays, cols) {
     const trans = t();
     const hasClassChar = pickIcon('▓▓', '##');
@@ -65,25 +52,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}`;
-    // Class row: weekend is hardcoded to the "N/A" glyph regardless of
-    // classDays data (campus never has weekend classes) -- the same
-    // weekend treatment used throughout the Schedule tab's own renderers.
-    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}`;
-    // Event row: deliberately NOT hardcoding weekend -- a club event can
-    // happen on a Saturday, so this row checks real data for all 7 days.
-    // undefined eventDays (events still loading, or the fetch failed) means
-    // "not yet known" -- rendered as blank, not the "free" glyph, to
-    // visually distinguish "no data yet" from "checked, nothing happening".
-    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];
@@ -92,30 +75,23 @@ 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);
     });
     const compactLegend = wrappedIndentedLines(`${hasClassChar} ${trans.timetable.weekAheadBusy}  ${freeChar} ${trans.timetable.weekAheadFree}  ${weekendChar} ${trans.timetable.weekAheadNone}`, cols, type.hint);
     return [...compactHeading, ...compactDays, ...compactLegend].join('\n');
 }
-/** Pure: renders the schedule-first dashboard from already-fetched data. No I/O. */
 export function renderHome(data, now, bodyRows = 100, cols = 80) {
     const trans = t();
     const lines = [];
-    // Next class (cache-only, instant).
     const nextClass = data.nextClassLine !== undefined && data.nextClassLine.trim().length > 0
         ? wrappedRenderedLines(data.nextClassLine, cols)
         : wrappedIndentedLines(trans.timetable.noNextClass, cols, type.hint);
     lines.push(...panelHeading(trans.timetable.nextClass, cols));
     lines.push(...nextClass);
     lines.push('');
-    // Today's classes (cache-only, instant).
     lines.push(...panelHeading(trans.timetable.hubToday, cols));
     lines.push(renderDayProgress(now, cols));
     if (data.todayLines && data.todayLines.length > 0) {
@@ -126,28 +102,15 @@ export function renderHome(data, now, bodyRows = 100, cols = 80) {
         lines.push(...wrappedIndentedLines(trans.timetable.noClassToday, cols, type.hint));
     }
     lines.push('');
-    // Week overview (Part D): only when the student has a set-up, in-term
-    // personal timetable -- mirrors peekWeekAheadInfo's own "not set up yet
-    // / term hasn't started" -> null contract, hiding the whole panel rather
-    // than showing empty/misleading cells.
     if (data.weekAhead) {
         lines.push(...panelHeading(trans.timetable.weekOverviewTitle, cols));
         lines.push(...renderWeekAheadGrid(data.weekAhead.classDays, data.weekAhead.eventDays, cols).split('\n'));
         lines.push('');
     }
-    // Unresolved schedule items (Part E): surfaced directly on Home instead
-    // of only inside Schedule's own hub menu -- same c.warn + ⚠ treatment
-    // buildHubField() (schedule.ts) already uses for this exact condition,
-    // matching the "everything that needs your attention, in one place"
-    // spirit of a gh-status-like control center.
     if ((data.unresolvedCount ?? 0) > 0) {
         lines.push(...wrappedIndentedLines(`${pickIcon('⚠', '!')} ${trans.timetable.hubUnresolved} · ${data.unresolvedCount}`, cols, c.warn));
         lines.push('');
     }
-    // Upcoming events (network, best-effort). How many fit is whatever room
-    // is actually left after next-class/today above — on a tall terminal
-    // that's most of `data.eventLines`; on a normal one, still just a few,
-    // same as before this was ever adaptive.
     lines.push(...panelHeading(trans.menu.events, cols));
     if (data.eventLines && data.eventLines.length > 0) {
         const remaining = Number.isFinite(bodyRows)
@@ -168,7 +131,7 @@ export function renderHome(data, now, bodyRows = 100, cols = 80) {
     else if (data.loading) {
         lines.push(...loadingLines(cols));
     }
-    else if (data.eventsError) {
+    else if (data.eventsLoadFailed) {
         lines.push(...wrappedIndentedLines(trans.calendar.error, cols, type.hint));
     }
     else {
@@ -184,29 +147,20 @@ export const homeView = {
         return passiveFooterHint(tabCount, cols);
     },
     async load(ctx) {
-        // Schedule panels are cache-only and instant — populate them
-        // synchronously first. weekAheadSync is computed once here and reused
-        // below (peekWeekAheadInfo is itself cache-only/cheap, but capturing
-        // its result avoids a second, redundant cache read for weekStartDate).
-        const weekAheadSync = peekWeekAheadInfo();
+        const weekAheadInfo = peekWeekAheadInfo();
         try {
             data = {
                 loading: true,
                 nextClassLine: peekNextClassLine(),
                 todayLines: peekTodayLines(),
                 unresolvedCount: peekUnresolvedCount(),
-                weekAhead: weekAheadSync ? { classDays: weekAheadSync.classDays } : undefined,
+                ...(weekAheadInfo ? { weekAhead: { classDays: weekAheadInfo.classDays } } : {}),
             };
         }
         catch {
             data = { loading: true };
         }
         ctx.rerender();
-        // Events is the only networked panel; best-effort. Fetches the calendar
-        // exactly once and reuses that same Calendar instance for both the
-        // upcoming-events list below and the week-ahead event row (when there's
-        // a personal timetable to correlate it against) — not two separate
-        // network round-trips for what both come from the same public feed.
         const HOME_EVENT_FETCH_CAP = 15;
         try {
             const cal = await loadCalendarOrThrow();
@@ -214,16 +168,19 @@ export const homeView = {
             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 (weekAheadSync) {
-                const weekEnd = new Date(weekAheadSync.weekStartDate.getTime() + 7 * 86400000);
-                const weekEvents = cal.inRange(weekAheadSync.weekStartDate, weekEnd);
-                const daySet = new Set(weekEvents.map((e) => campusWeekday(e.start)));
-                weekAhead = { classDays: weekAheadSync.classDays, eventDays: [1, 2, 3, 4, 5, 6, 7].map((wd) => daySet.has(wd)) };
+            if (weekAheadInfo) {
+                const weekEnd = addLocalDays(weekAheadInfo.weekStartDate, 7);
+                const weekEvents = cal.inRange(weekAheadInfo.weekStartDate, weekEnd);
+                const daySet = new Set(weekEvents.map((event) => campusWeekday(event.start)));
+                weekAhead = {
+                    classDays: weekAheadInfo.classDays,
+                    eventDays: WEEKDAYS.map((weekday) => daySet.has(weekday)),
+                };
             }
-            data = { ...data, eventLines, weekAhead };
+            data = weekAhead ? { ...data, eventLines, weekAhead } : { ...data, eventLines };
         }
         catch {
-            data = { ...data, eventsError: true };
+            data = { ...data, eventsLoadFailed: true };
         }
         finally {
             data = { ...data, loading: false };

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' };