@nbtca/prompt 1.3.2 → 1.4.2

package/dist/app/views/events.js

@@ -0,0 +1,228 @@
+import { captureFooterHint, passiveFooterHint } from '../chrome.js';
+import { ListField, computeMaxVisible } from '../fields/list-field.js';
+import { TextField } from '../fields/text-field.js';
+import { renderEvents } from './events-render.js';
+import { setVimKeysActive } from '../../core/vim-keys.js';
+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';
+let state = { mode: 'loading' };
+let calendar = null;
+let currentList = [];
+function backLabel() {
+    return t().common.back;
+}
+function buildHubField() {
+    const trans = t();
+    const options = [
+        { value: 'upcoming', label: trans.menu.events },
+        { value: 'week', label: trans.calendar.thisWeek },
+        { value: 'month', label: trans.calendar.thisMonth },
+        { value: 'search', label: trans.calendar.search },
+        { value: 'past', label: trans.calendar.pastEvents },
+        { value: 'heatmap', label: trans.calendar.heatmap.title },
+    ];
+    return new ListField({ title: trans.menu.events, options });
+}
+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,
+        })),
+        { value: '__back__', label: backLabel() },
+    ];
+    return new ListField({
+        title: title || trans.menu.events,
+        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)) };
+}
+// 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 }) : [];
+    state = {
+        mode: 'hub',
+        hubField: buildHubField(),
+        nextEvent: upcoming[0] ? toDisplayEvent(upcoming[0]) : undefined,
+        heatmapBuckets: calendar
+            ? calendar.heatmap({ start: new Date(Date.now() - 365 * 86400000), end: new Date(), bucket: 'day' })
+            : [],
+        recentEvents: upcoming.slice(0, RECENT_ACTIVITY_FETCH_CAP).map(toDisplayEvent),
+    };
+}
+function showDetail(raw) {
+    const trans = t();
+    const e = toDisplayEvent(raw);
+    const dot = pickIcon('·', '-');
+    state = {
+        mode: 'detail',
+        detailTitle: e.title,
+        detailMeta: `${e.date}${e.time ? ' ' + e.time : ''}  ${dot}  ${e.location}${raw.recurring ? `  ${dot}  ${trans.calendar.recurringLabel}` : ''}`,
+        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 },
+                { value: '__back__', label: backLabel() },
+            ],
+        }),
+    };
+}
+export const eventsView = {
+    id: 'events',
+    title: t().menu.events,
+    async load(ctx) {
+        state = { mode: 'loading' };
+        ctx.rerender();
+        try {
+            calendar = await loadCalendarOrThrow();
+            goToHub();
+        }
+        catch {
+            state = { mode: 'error', errorMessage: t().calendar.error };
+        }
+        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';
+    },
+    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 === 'search')
+                setVimKeysActive(true);
+            goToHub();
+            return true;
+        }
+        return false;
+    },
+    handleKey(key, ctx) {
+        if (!calendar)
+            return;
+        switch (state.mode) {
+            case 'hub': {
+                const result = state.hubField?.handleKey(key);
+                if (!result?.selected)
+                    return;
+                const now = new Date();
+                if (result.selected === 'upcoming') {
+                    showList(t().menu.events, calendar.upcoming({ days: 30 }), ctx);
+                    return;
+                }
+                if (result.selected === 'week') {
+                    const r = weekRange(now);
+                    showList(t().calendar.thisWeek, calendar.inRange(r.start, r.end), ctx);
+                    return;
+                }
+                if (result.selected === 'month') {
+                    const r = monthRange(now);
+                    showList(t().calendar.thisMonth, calendar.inRange(r.start, r.end), ctx);
+                    return;
+                }
+                if (result.selected === 'past') {
+                    showList(t().calendar.pastEvents, calendar.past({ days: 30 }).reverse(), ctx);
+                    return;
+                }
+                if (result.selected === 'heatmap') {
+                    state = { ...state, mode: 'heatmap' };
+                    return;
+                }
+                if (result.selected === 'search') {
+                    setVimKeysActive(false);
+                    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;
+            }
+            case 'list': {
+                const result = state.listField?.handleKey(key);
+                if (!result?.selected)
+                    return;
+                if (result.selected === '__back__') {
+                    goToHub();
+                    return;
+                }
+                const raw = currentList[Number.parseInt(result.selected, 10)];
+                if (raw)
+                    showDetail(raw);
+                return;
+            }
+            case 'detail': {
+                const result = state.detailField?.handleKey(key);
+                if (!result?.selected)
+                    return;
+                if (result.selected === '__back__') {
+                    showList('', currentList, ctx);
+                    return;
+                }
+                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 ?? ''}` };
+                }
+                return;
+            }
+            case 'search': {
+                const result = state.searchField?.handleKey(key);
+                if (result?.cancelled) {
+                    setVimKeysActive(true);
+                    goToHub();
+                    return;
+                }
+                if (result?.submitted !== undefined) {
+                    setVimKeysActive(true);
+                    const query = result.submitted.trim();
+                    if (!query || !calendar) {
+                        goToHub();
+                        return;
+                    }
+                    const now = new Date();
+                    const pool = calendar.inRange(now, new Date(now.getTime() + 365 * 86400000));
+                    const results = filterEvents(pool, query);
+                    showList(`${t().calendar.search}: ${query}`, results, ctx);
+                }
+                return;
+            }
+            default:
+                return;
+        }
+    },
+};

package/dist/app/views/home.js

@@ -0,0 +1,195 @@
+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 { weekdayShortLabel } from '../../features/schedule-render.js';
+import { campusWeekday } from '../../features/schedule-query.js';
+import { passiveFooterHint } from '../chrome.js';
+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}`);
+}
+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);
+}
+const DAY_PROGRESS_WIDTH = 20;
+function renderDayProgress(now, cols) {
+    const minutesElapsed = now.getHours() * 60 + now.getMinutes();
+    const fraction = Math.min(1, Math.max(0, minutesElapsed / 1440));
+    const pct = Math.round(fraction * 100);
+    const percentage = `${pct}%`;
+    const width = Number.isFinite(cols) ? Math.max(1, Math.floor(cols)) : Number.POSITIVE_INFINITY;
+    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 ? ' ' : '';
+    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();
+    const emptyChar = glyph.barEmpty();
+    const bar = filledChar.repeat(filled) + emptyChar.repeat(barWidth - filled);
+    return `${indent}${type.body(bar)}${gap}${type.hint(percentage)}`;
+}
+function renderWeekAheadGrid(classDays, eventDays, cols) {
+    const trans = t();
+    const hasClassChar = pickIcon('▓▓', '##');
+    const freeChar = pickIcon('░░', '..');
+    const weekendChar = pickIcon('··', '..');
+    const blankCell = '  ';
+    const rowLabelW = Math.max(visualWidth(trans.timetable.weekAheadClasses), visualWidth(trans.menu.events)) + 1;
+    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 isWeekend = wd === 6 || wd === 7;
+        const glyphChar = isWeekend ? weekendChar : (classDays[wd - 1] ? hasClassChar : freeChar);
+        return type.body(glyphChar);
+    }).join('  ');
+    const classLine = `${space.indent}${type.hint(padEndV(trans.timetable.weekAheadClasses, rowLabelW))}${classCells}`;
+    const eventCells = days.map((wd) => {
+        if (!eventDays)
+            return blankCell;
+        return type.body(eventDays[wd - 1] ? hasClassChar : freeChar);
+    }).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];
+    const width = Number.isFinite(cols) ? Math.max(1, Math.floor(cols)) : Number.POSITIVE_INFINITY;
+    if (wideLines.every((line) => visualWidth(line) <= width))
+        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 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');
+}
+export function renderHome(data, now, bodyRows = 100, cols = 80) {
+    const trans = t();
+    const lines = [];
+    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('');
+    lines.push(...panelHeading(trans.timetable.hubToday, cols));
+    lines.push(renderDayProgress(now, cols));
+    if (data.todayLines && data.todayLines.length > 0) {
+        for (const line of data.todayLines)
+            lines.push(...wrappedRenderedLines(line, cols));
+    }
+    else {
+        lines.push(...wrappedIndentedLines(trans.timetable.noClassToday, cols, type.hint));
+    }
+    lines.push('');
+    if (data.weekAhead) {
+        lines.push(...panelHeading(trans.timetable.weekOverviewTitle, cols));
+        lines.push(...renderWeekAheadGrid(data.weekAhead.classDays, data.weekAhead.eventDays, cols).split('\n'));
+        lines.push('');
+    }
+    if ((data.unresolvedCount ?? 0) > 0) {
+        lines.push(...wrappedIndentedLines(`${pickIcon('⚠', '!')} ${trans.timetable.hubUnresolved} · ${data.unresolvedCount}`, cols, c.warn));
+        lines.push('');
+    }
+    lines.push(...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)
+            : Number.POSITIVE_INFINITY;
+        let usedRows = 0;
+        for (const line of data.eventLines) {
+            const wrapped = wrappedRenderedLines(line, cols);
+            if (usedRows + wrapped.length > remaining) {
+                if (usedRows === 0 && remaining === 0)
+                    lines.push(...wrapped);
+                break;
+            }
+            lines.push(...wrapped);
+            usedRows += wrapped.length;
+        }
+    }
+    else if (data.loading) {
+        lines.push(...loadingLines(cols));
+    }
+    else if (data.eventsLoadFailed) {
+        lines.push(...wrappedIndentedLines(trans.calendar.error, cols, type.hint));
+    }
+    else {
+        lines.push(...wrappedIndentedLines(trans.calendar.noEvents, cols, type.hint));
+    }
+    return lines;
+}
+let data = { loading: true };
+export const homeView = {
+    id: 'home',
+    title: 'Home',
+    footerHint(tabCount, cols = Number.POSITIVE_INFINITY) {
+        return passiveFooterHint(tabCount, cols);
+    },
+    async load(ctx) {
+        const weekAheadInfo = peekWeekAheadInfo();
+        try {
+            data = {
+                loading: true,
+                nextClassLine: peekNextClassLine(),
+                todayLines: peekTodayLines(),
+                unresolvedCount: peekUnresolvedCount(),
+                weekAhead: weekAheadInfo ? { classDays: weekAheadInfo.classDays } : undefined,
+            };
+        }
+        catch {
+            data = { loading: true };
+        }
+        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 };
+        }
+        catch {
+            data = { ...data, eventsLoadFailed: true };
+        }
+        finally {
+            data = { ...data, loading: false };
+            ctx.rerender();
+        }
+    },
+    render(ctx) {
+        return renderHome(data, new Date(), ctx.bodyRows, ctx.size.cols);
+    },
+};

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

@@ -0,0 +1,52 @@
+import { meetingAtCursor } from '../../features/schedule-query.js';
+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;
+    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)) };
+}
+/** 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 };
+}
+/** 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) };
+    if (key === KEY_ARROW_RIGHT)
+        return { kind: 'moveCursor', cursor: moveCursorWeekday(cursor, 1) };
+    if (key === KEY_ARROW_UP)
+        return { kind: 'moveCursor', cursor: moveCursorPeriod(cursor, tt.periods, -1) };
+    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);
+        return meeting ? { kind: 'openDetail', meeting } : { kind: 'none' };
+    }
+    return { kind: 'none' };
+}