@nbtca/prompt 1.3.2 → 1.4.2

package/dist/app/keys.js

@@ -0,0 +1,20 @@
+export function routeGlobalKey(key, viewIds, current) {
+    if (key === 'q' || key === '\x03')
+        return { quit: true, handled: true };
+    if (key === '\x1b')
+        return current === 'home' ? { quit: true, handled: true } : { back: true, handled: true };
+    if (key === '\t') {
+        const i = viewIds.indexOf(current);
+        return { switchTo: viewIds[(i + 1) % viewIds.length], handled: true };
+    }
+    if (key === '\x1b[5~')
+        return { scrollBy: -1, handled: true };
+    if (key === '\x1b[6~')
+        return { scrollBy: 1, handled: true };
+    if (/^[1-9]$/.test(key)) {
+        const idx = Number(key) - 1;
+        if (idx < viewIds.length)
+            return { switchTo: viewIds[idx], handled: true };
+    }
+    return { handled: false };
+}

package/dist/app/tabs.js

@@ -0,0 +1,11 @@
+import { t } from '../i18n/index.js';
+export function getAppTabs() {
+    const trans = t();
+    return [
+        { id: 'home', title: 'Home' },
+        { id: 'schedule', title: trans.timetable.menuEntry },
+        { id: 'events', title: trans.menu.events },
+        { id: 'docs', title: trans.menu.docs },
+        { id: 'settings', title: trans.menu.settings },
+    ];
+}

package/dist/app/view.js

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,82 @@
+import { type, space } from '../../core/theme.js';
+import { t } from '../../i18n/index.js';
+import { renderListFieldWithContext } from '../fields/list-field.js';
+import { visualWidth, wrapAnsiToVisualWidth } from '../../core/text.js';
+function hintLines(label, cols) {
+    const width = Number.isFinite(cols) ? Math.max(1, Math.floor(cols)) : Number.POSITIVE_INFINITY;
+    const styled = type.hint(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 renderReader(lines, cols) {
+    const contentWidth = Math.max(1, Math.min(80, cols - visualWidth(space.indent)));
+    return lines.flatMap((line) => (wrapAnsiToVisualWidth(line, contentWidth).map((part) => `${space.indent}${part}`)));
+}
+function listFieldForState(state) {
+    switch (state.mode) {
+        case 'sections': return state.sectionsField;
+        case 'files': return state.filesField;
+        case 'archivedGroups': return state.archivedGroupsField;
+        case 'archivedFiles': return state.archivedFilesField;
+        case 'searchResults': return state.searchResultsField;
+        case 'reader': return state.readerLinksField;
+        default: return undefined;
+    }
+}
+export function renderDocs(state, cols = 80, bodyRows = Number.POSITIVE_INFINITY) {
+    const trans = t();
+    let lines;
+    switch (state.mode) {
+        case 'loading':
+            lines = hintLines(trans.common.loading, cols);
+            break;
+        case 'sections':
+            lines = state.sectionsField?.render(bodyRows, cols) ?? [];
+            break;
+        case 'files':
+            lines = state.filesField?.render(bodyRows, cols) ?? [];
+            break;
+        case 'archivedGroups':
+            lines = state.archivedGroupsField?.render(bodyRows, cols) ?? [];
+            break;
+        case 'archivedFiles':
+            lines = state.archivedFilesField?.render(bodyRows, cols) ?? [];
+            break;
+        case 'search':
+            lines = state.searchField?.render(cols) ?? [];
+            break;
+        case 'searchResults':
+            lines = state.searchResultsField ? renderListFieldWithContext([
+                ...(state.searchResultsEmpty ? [...hintLines(trans.docs.searchNoResults, cols), ''] : []),
+            ], state.searchResultsField, bodyRows, cols) : [];
+            break;
+        case 'readerLoading':
+            lines = hintLines(trans.docs.loadingFile, cols);
+            break;
+        case 'reader':
+            lines = state.readerLinksField
+                ? state.readerLinksField.render(bodyRows, cols)
+                : renderReader(state.readerLines ?? [], cols);
+            break;
+        case 'error':
+            return hintLines(state.errorMessage ?? trans.docs.loadError, cols);
+        default:
+            lines = [];
+    }
+    if (!state.errorMessage)
+        return lines;
+    const errorContext = [...hintLines(state.errorMessage, cols), ''];
+    const listField = listFieldForState(state);
+    if (!listField)
+        return [...errorContext, ...lines];
+    const context = state.mode === 'searchResults' && state.searchResultsEmpty
+        ? [...errorContext, ...hintLines(trans.docs.searchNoResults, cols), '']
+        : errorContext;
+    return renderListFieldWithContext(context, listField, bodyRows, cols);
+}

package/dist/app/views/docs.js

@@ -0,0 +1,450 @@
+import { captureFooterHint, digitTabHint, fitFooterHint, passiveFooterHint } from '../chrome.js';
+import { ListField, computeMaxVisible } from '../fields/list-field.js';
+import { TextField } from '../fields/text-field.js';
+import { renderDocs } from './docs-render.js';
+import { setVimKeysActive } from '../../core/vim-keys.js';
+import { pickIcon } from '../../core/icons.js';
+import { getCurrentLanguage, t } from '../../i18n/index.js';
+import { localizeDocSections, fetchSections, fetchAllDocs, getArchivedGroups, cleanFileName, displayDocTitle, loadDocForReader, openDocsInBrowser, clearDocsCache, } from '../../features/docs.js';
+let state = { mode: 'loading' };
+let sections = [];
+let archivedGroups = new Map();
+let loaded = false;
+let loadedLanguage = null;
+let currentSectionKey = null;
+let currentArchivedGroupKey = null;
+let currentSearchResults = [];
+// In-app reader navigation: readerCurrentPath is the doc on screen right
+// now; readerNavStack holds the paths of docs visited before it (pushed
+// only when following a link forward, popped on Esc); readerPrevState is
+// whichever file-listing state (files/archivedFiles/searchResults) the
+// reader was entered from, restored once the nav stack empties.
+let readerCurrentPath = null;
+let readerNavStack = [];
+let readerPrevState = null;
+let readerLoadingPrevState = null;
+let readerRequestId = 0;
+function backLabel() {
+    return t().common.back;
+}
+function buildSectionsField() {
+    const trans = t();
+    const options = [
+        ...sections.map((sec) => ({ value: sec.key, label: sec.label, hint: String(sec.count) })),
+        { value: '__search__', label: trans.docs.searchPrompt.replace(':', '') },
+        { value: '__refresh__', label: trans.docs.refreshCache },
+        { value: '__browser__', label: trans.docs.openBrowser },
+    ];
+    return new ListField({ title: trans.docs.chooseCategory, options });
+}
+function buildFilesField(section, maxVisible, initialIndex = 0) {
+    const trans = t();
+    const isIndex = (f) => f.name === 'index.md' || f.name.startsWith('index.');
+    const index = section.files.find(isIndex);
+    const files = section.files.filter((f) => !isIndex(f));
+    const options = [
+        ...(index ? [{ value: index.path, label: trans.docs.overviewLabel }] : []),
+        ...files.map((f) => ({ value: f.path, label: displayDocTitle(f.path, f.name) })),
+        { value: '__back__', label: backLabel() },
+    ];
+    return new ListField({ title: section.label, options, maxVisible, initialIndex });
+}
+function buildArchivedGroupsField(groups, maxVisible, initialIndex = 0) {
+    const trans = t();
+    const sortedKeys = [...groups.keys()].sort((a, b) => {
+        const aYear = /^\d{4}$/.test(a);
+        const bYear = /^\d{4}$/.test(b);
+        if (aYear && bYear)
+            return Number(b) - Number(a);
+        if (aYear)
+            return -1;
+        if (bYear)
+            return 1;
+        return a.localeCompare(b);
+    });
+    const options = [
+        ...sortedKeys.map((k) => ({ value: k, label: k, hint: String(groups.get(k).length) })),
+        { value: '__back__', label: backLabel() },
+    ];
+    return new ListField({ title: trans.docs.categoryArchived, options, maxVisible, initialIndex });
+}
+function buildArchivedFilesField(groupKey, groupFiles, maxVisible, initialIndex = 0) {
+    const trans = t();
+    const subDirs = new Set(groupFiles.map((f) => f.path.split('/')[2]).filter(Boolean));
+    const options = [
+        ...groupFiles.map((f) => {
+            const sub = f.path.split('/').slice(2, -1).join('/');
+            return { value: f.path, label: cleanFileName(f.name), hint: subDirs.size > 1 ? sub : undefined };
+        }),
+        { value: '__back__', label: backLabel() },
+    ];
+    return new ListField({ title: `${trans.docs.categoryArchived} · ${groupKey}`, options, maxVisible, initialIndex });
+}
+function buildReaderLinksField(links, maxVisible, initialIndex = 0) {
+    const trans = t();
+    const options = [
+        ...links.map((l) => ({ value: l.href, label: l.text })),
+        { value: '__back__', label: backLabel() },
+    ];
+    return new ListField({ title: trans.docs.readerLinksTitle, options, maxVisible, initialIndex });
+}
+function buildSearchResultsField(matches, maxVisible, initialIndex = 0) {
+    const trans = t();
+    const options = [
+        ...matches.map((result) => ({
+            value: result.path,
+            label: displayDocTitle(result.path, result.name),
+            hint: result.path.includes('/') ? result.path.split('/').slice(0, -1).join('/') : undefined,
+        })),
+        { value: '__back__', label: backLabel() },
+    ];
+    return new ListField({ title: trans.docs.chooseDoc, options, maxVisible, initialIndex });
+}
+function relocalizeStateFields(value, maxVisible) {
+    if (value.mode === 'sections') {
+        return { ...value, sectionsField: buildSectionsField() };
+    }
+    if (value.mode === 'files' && currentSectionKey) {
+        const section = sections.find((candidate) => candidate.key === currentSectionKey);
+        return section
+            ? { ...value, filesField: buildFilesField(section, maxVisible, value.filesField?.selectedIndex) }
+            : value;
+    }
+    if (value.mode === 'archivedGroups') {
+        return {
+            ...value,
+            archivedGroupsField: buildArchivedGroupsField(archivedGroups, maxVisible, value.archivedGroupsField?.selectedIndex),
+        };
+    }
+    if (value.mode === 'archivedFiles' && currentArchivedGroupKey) {
+        return {
+            ...value,
+            archivedFilesField: buildArchivedFilesField(currentArchivedGroupKey, archivedGroups.get(currentArchivedGroupKey) ?? [], maxVisible, value.archivedFilesField?.selectedIndex),
+        };
+    }
+    if (value.mode === 'searchResults') {
+        return {
+            ...value,
+            searchResultsField: buildSearchResultsField(currentSearchResults, maxVisible, value.searchResultsField?.selectedIndex),
+        };
+    }
+    if (value.mode === 'reader' && value.readerLinksField) {
+        return {
+            ...value,
+            readerLinksField: buildReaderLinksField(value.readerLinks ?? [], maxVisible, value.readerLinksField.selectedIndex),
+        };
+    }
+    return value;
+}
+function goToSections() {
+    currentSectionKey = null;
+    currentArchivedGroupKey = null;
+    currentSearchResults = [];
+    state = { mode: 'sections', sectionsField: buildSectionsField() };
+}
+/** Enters (or re-enters) the reader on `path`. `pushCurrent` distinguishes
+ * following a link forward (push readerCurrentPath so Esc can return to it)
+ * from navigating backward or entering fresh from a file list (nothing to
+ * push -- the caller has already saved/cleared readerPrevState itself). */
+async function openInReader(ctx, path, pushCurrent) {
+    const requestId = ++readerRequestId;
+    const previousState = state;
+    const previousPath = readerCurrentPath;
+    readerLoadingPrevState = previousState;
+    state = { mode: 'readerLoading' };
+    ctx.rerender();
+    try {
+        const doc = await loadDocForReader(path);
+        if (requestId !== readerRequestId)
+            return;
+        if (pushCurrent && previousPath)
+            readerNavStack.push(previousPath);
+        readerCurrentPath = path;
+        readerLoadingPrevState = null;
+        state = { mode: 'reader', readerTitle: doc.title, readerLines: doc.lines, readerLinks: doc.links };
+        ctx.resetScroll();
+    }
+    catch {
+        if (requestId !== readerRequestId)
+            return;
+        readerLoadingPrevState = null;
+        const fallbackState = pushCurrent && previousState.mode === 'reader'
+            ? { ...previousState, readerLinksField: undefined }
+            : previousState;
+        state = { ...fallbackState, errorMessage: t().docs.loadError };
+    }
+    ctx.rerender();
+}
+/** Enters the reader from a file-listing mode (files/archivedFiles/
+ * searchResults) -- saves that listing so Esc can restore it once the nav
+ * stack (built by following links from here) empties back out. */
+function enterReaderFrom(ctx, path) {
+    readerPrevState = state;
+    readerNavStack = [];
+    readerCurrentPath = null;
+    void openInReader(ctx, path, false);
+}
+export const docsView = {
+    id: 'docs',
+    title: t().menu.docs,
+    async load(ctx) {
+        if (loaded) {
+            const language = getCurrentLanguage();
+            if (loadedLanguage !== language) {
+                sections = localizeDocSections(sections, t());
+                loadedLanguage = language;
+                const maxVisible = computeMaxVisible(ctx.bodyRows);
+                state = relocalizeStateFields(state, maxVisible);
+                if (readerPrevState)
+                    readerPrevState = relocalizeStateFields(readerPrevState, maxVisible);
+                ctx.rerender();
+            }
+            return;
+        }
+        state = { mode: 'loading' };
+        ctx.rerender();
+        try {
+            sections = await fetchSections();
+            loaded = true;
+            loadedLanguage = getCurrentLanguage();
+            goToSections();
+        }
+        catch {
+            state = { mode: 'error', errorMessage: t().docs.loadError };
+        }
+        ctx.rerender();
+    },
+    render(ctx) {
+        // Sync every visible field'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.
+        const maxVisible = computeMaxVisible(ctx.bodyRows);
+        state.filesField?.setMaxVisible(maxVisible);
+        state.archivedGroupsField?.setMaxVisible(maxVisible);
+        state.archivedFilesField?.setMaxVisible(maxVisible);
+        state.searchResultsField?.setMaxVisible(maxVisible);
+        state.readerLinksField?.setMaxVisible(maxVisible);
+        return renderDocs(state, ctx.size.cols, ctx.bodyRows);
+    },
+    capturesInput() {
+        return state.mode === 'search';
+    },
+    footerHint(tabCount, cols = Number.POSITIVE_INFINITY) {
+        if (state.mode === 'search')
+            return captureFooterHint(cols);
+        if (state.mode === 'loading' || state.mode === 'error')
+            return passiveFooterHint(tabCount, cols);
+        if (state.mode === 'readerLoading') {
+            return fitFooterHint(cols, `${digitTabHint(tabCount)}q ${t().menu.hintQuit}`, `${digitTabHint(tabCount)}q`, 'q');
+        }
+        if (state.mode === 'reader' && !state.readerLinksField) {
+            const trans = t();
+            const dot = pickIcon('·', '-');
+            const hasLinks = (state.readerLinks?.length ?? 0) > 0;
+            const linkHint = hasLinks ? `f ${trans.docs.readerLinksHint} ${dot} ` : '';
+            const pageHint = `PgUp/PgDn ${dot} `;
+            const localFull = `${pageHint}${linkHint}b ${trans.docs.openBrowser} ${dot} Esc ${dot} q ${trans.menu.hintQuit}`;
+            const localCompact = `${pageHint}${hasLinks ? `f ${dot} ` : ''}b ${dot} Esc ${dot} q`;
+            return fitFooterHint(cols, `${digitTabHint(tabCount)}${localFull}`, localFull, localCompact, `${hasLinks ? 'f ' : ''}b Esc q`, 'Esc q', 'q');
+        }
+        return undefined;
+    },
+    handleBack(ctx) {
+        if (state.mode === 'reader' || state.mode === 'readerLoading') {
+            if (state.mode === 'readerLoading') {
+                const previousState = readerLoadingPrevState;
+                readerRequestId++;
+                readerLoadingPrevState = null;
+                if (!previousState)
+                    return false;
+                state = previousState;
+                return true;
+            }
+            if (state.readerLinksField) {
+                state = { ...state, readerLinksField: undefined };
+                return true;
+            }
+            const prevPath = readerNavStack.pop();
+            if (prevPath) {
+                void openInReader(ctx, prevPath, false);
+                return true;
+            }
+            if (readerPrevState) {
+                state = readerPrevState;
+                readerPrevState = null;
+                readerCurrentPath = null;
+                return true;
+            }
+            return false;
+        }
+        if (state.mode === 'archivedFiles') {
+            state = { mode: 'archivedGroups', archivedGroupsField: buildArchivedGroupsField(archivedGroups, computeMaxVisible(ctx.bodyRows)) };
+            return true;
+        }
+        if (state.mode === 'search') {
+            setVimKeysActive(true);
+            goToSections();
+            return true;
+        }
+        if (state.mode === 'files' || state.mode === 'archivedGroups' || state.mode === 'searchResults') {
+            goToSections();
+            return true;
+        }
+        return false;
+    },
+    handleKey(key, ctx) {
+        if (state.mode !== 'error' && state.errorMessage)
+            state = { ...state, errorMessage: undefined };
+        switch (state.mode) {
+            case 'sections': {
+                const result = state.sectionsField?.handleKey(key);
+                if (!result?.selected)
+                    return;
+                if (result.selected === '__search__') {
+                    setVimKeysActive(false);
+                    state = { mode: 'search', searchField: new TextField({ message: t().docs.searchPrompt, placeholder: t().docs.searchPlaceholder, allowEmpty: true }) };
+                    return;
+                }
+                if (result.selected === '__refresh__') {
+                    clearDocsCache();
+                    loaded = false;
+                    loadedLanguage = null;
+                    sections = [];
+                    archivedGroups = new Map();
+                    currentSectionKey = null;
+                    currentArchivedGroupKey = null;
+                    currentSearchResults = [];
+                    readerCurrentPath = null;
+                    readerNavStack = [];
+                    readerPrevState = null;
+                    readerLoadingPrevState = null;
+                    readerRequestId++;
+                    void docsView.load?.(ctx);
+                    return;
+                }
+                if (result.selected === '__browser__') {
+                    void ctx.runClassic(() => openDocsInBrowser());
+                    return;
+                }
+                const section = sections.find((s) => s.key === result.selected);
+                if (!section)
+                    return;
+                if (section.key === 'archived') {
+                    currentSectionKey = null;
+                    currentArchivedGroupKey = null;
+                    archivedGroups = getArchivedGroups(section.files);
+                    state = { mode: 'archivedGroups', archivedGroupsField: buildArchivedGroupsField(archivedGroups, computeMaxVisible(ctx.bodyRows)) };
+                }
+                else {
+                    currentSectionKey = section.key;
+                    state = { mode: 'files', filesField: buildFilesField(section, computeMaxVisible(ctx.bodyRows)) };
+                }
+                return;
+            }
+            case 'files': {
+                const result = state.filesField?.handleKey(key);
+                if (!result?.selected)
+                    return;
+                if (result.selected === '__back__') {
+                    goToSections();
+                    return;
+                }
+                enterReaderFrom(ctx, result.selected);
+                return;
+            }
+            case 'archivedGroups': {
+                const result = state.archivedGroupsField?.handleKey(key);
+                if (!result?.selected)
+                    return;
+                if (result.selected === '__back__') {
+                    goToSections();
+                    return;
+                }
+                currentArchivedGroupKey = result.selected;
+                const groupFiles = archivedGroups.get(result.selected) ?? [];
+                state = { mode: 'archivedFiles', archivedFilesField: buildArchivedFilesField(result.selected, groupFiles, computeMaxVisible(ctx.bodyRows)) };
+                return;
+            }
+            case 'archivedFiles': {
+                const result = state.archivedFilesField?.handleKey(key);
+                if (!result?.selected)
+                    return;
+                if (result.selected === '__back__') {
+                    currentArchivedGroupKey = null;
+                    state = { mode: 'archivedGroups', archivedGroupsField: buildArchivedGroupsField(archivedGroups, computeMaxVisible(ctx.bodyRows)) };
+                    return;
+                }
+                enterReaderFrom(ctx, result.selected);
+                return;
+            }
+            case 'search': {
+                const result = state.searchField?.handleKey(key);
+                if (result?.cancelled) {
+                    setVimKeysActive(true);
+                    goToSections();
+                    return;
+                }
+                if (result?.submitted !== undefined) {
+                    const query = result.submitted.trim().toLowerCase();
+                    setVimKeysActive(true);
+                    if (!query) {
+                        goToSections();
+                        return;
+                    }
+                    void fetchAllDocs().then((all) => {
+                        const matches = all.filter((item) => item.path.toLowerCase().includes(query));
+                        currentSearchResults = matches;
+                        state = {
+                            mode: 'searchResults',
+                            searchResultsEmpty: matches.length === 0,
+                            searchResultsField: buildSearchResultsField(matches, computeMaxVisible(ctx.bodyRows)),
+                        };
+                        ctx.rerender();
+                    }).catch(() => {
+                        state = { mode: 'error', errorMessage: t().docs.loadError };
+                        ctx.rerender();
+                    });
+                }
+                return;
+            }
+            case 'searchResults': {
+                const result = state.searchResultsField?.handleKey(key);
+                if (!result?.selected)
+                    return;
+                if (result.selected === '__back__') {
+                    goToSections();
+                    return;
+                }
+                enterReaderFrom(ctx, result.selected);
+                return;
+            }
+            case 'reader': {
+                if (state.readerLinksField) {
+                    const result = state.readerLinksField.handleKey(key);
+                    if (result.cancelled || result.selected === '__back__') {
+                        state = { ...state, readerLinksField: undefined };
+                        return;
+                    }
+                    if (result.selected)
+                        void openInReader(ctx, result.selected, true);
+                    return;
+                }
+                // 'f' (Vimium/vim-browser-extension convention: "follow a link"),
+                // not 'l' -- core/vim-keys.ts already reserves 'l' globally,
+                // ranger-style, as an alias for Enter/confirm (vimActive defaults
+                // to true), so a literal 'l' keypress never even reaches here.
+                if (key === 'f' && (state.readerLinks?.length ?? 0) > 0) {
+                    state = { ...state, readerLinksField: buildReaderLinksField(state.readerLinks ?? [], computeMaxVisible(ctx.bodyRows)) };
+                    return;
+                }
+                if (key === 'b') {
+                    void ctx.runClassic(() => openDocsInBrowser(readerCurrentPath ?? undefined));
+                    return;
+                }
+                return;
+            }
+            default:
+                return;
+        }
+    },
+};

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

@@ -0,0 +1,111 @@
+import { type, space } from '../../core/theme.js';
+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';
+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}`);
+}
+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();
+    const lines = [];
+    const rows = Number.isFinite(bodyRows)
+        ? Math.max(0, Math.floor(bodyRows))
+        : Number.POSITIVE_INFINITY;
+    const banner = renderCountdownBanner(state.nextEvent, now, cols);
+    if (banner)
+        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('');
+    }
+    if (state.recentEvents && state.recentEvents.length > 0) {
+        const activityHeading = wrappedIndentedLines(trans.calendar.recentActivity, cols, type.heading);
+        const fieldRows = state.hubField
+            ? state.hubField.render(Number.POSITIVE_INFINITY, cols).length
+            : 0;
+        const collectEventLines = (reservedFieldRows) => {
+            const budget = Math.max(0, rows - lines.length - activityHeading.length - 1 - reservedFieldRows);
+            const collected = [];
+            for (const event of state.recentEvents ?? []) {
+                const wrapped = wrappedRenderedLine(renderEventBrief(event, now), cols);
+                if (collected.length + wrapped.length > budget)
+                    break;
+                collected.push(...wrapped);
+            }
+            return collected;
+        };
+        let eventLines = collectEventLines(fieldRows);
+        if (eventLines.length === 0 && state.hubField && fieldRows > 3) {
+            eventLines = collectEventLines(Math.min(3, rows));
+        }
+        if (eventLines.length > 0)
+            lines.push(...activityHeading, ...eventLines, '');
+    }
+    if (state.hubField) {
+        return renderListFieldWithContext(lines, state.hubField, bodyRows, cols);
+    }
+    return lines;
+}
+export function renderEvents(state, now, bodyRows = 100, cols) {
+    const trans = t();
+    switch (state.mode) {
+        case 'loading':
+            return wrappedIndentedLines(trans.calendar.loading, cols, type.hint);
+        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')
+                : wrappedIndentedLines(trans.calendar.noEvents, cols, type.hint);
+        case 'list':
+            return state.listField?.render(bodyRows, cols) ?? [];
+        case 'detail': {
+            const context = [
+                ...wrappedIndentedLines(state.detailTitle ?? '', cols, type.heading),
+                ...wrappedIndentedLines(state.detailMeta ?? '', cols, type.hint),
+                '',
+                ...(state.detailDescription
+                    ? 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), ''] : []),
+            ];
+            return state.detailField
+                ? renderListFieldWithContext(context, state.detailField, bodyRows, cols)
+                : Number.isFinite(bodyRows) ? context.slice(0, Math.max(0, Math.floor(bodyRows))) : context;
+        }
+        case 'search':
+            return state.searchField?.render(cols) ?? [];
+        case 'error':
+            return wrappedIndentedLines(state.errorMessage ?? trans.calendar.error, cols, type.hint);
+        default:
+            return [];
+    }
+}