@nbtca/prompt 1.5.0 → 1.5.1

package/dist/app/app.js

@@ -1,6 +1,6 @@
 import { ansi, ensureCursorRestored } from '../core/canvas.js';
-import { composeFrame, computeBodyRows } from './frame.js';
-import { routeGlobalKey } from './keys.js';
+import { composeFrameLines, computeBodyRows, diffFrame } from './frame.js';
+import { isPrintableKey, KeyStreamDecoder, routeGlobalKey } from './keys.js';
 import { renderHeader, renderFooter, resolveChromeLayout } from './chrome.js';
 import { homeView } from './views/home.js';
 import { scheduleView } from './views/schedule.js';
@@ -8,6 +8,7 @@ import { docsView } from './views/docs.js';
 import { eventsView } from './views/events.js';
 import { settingsView } from './views/settings.js';
 import { getAppTabs } from './tabs.js';
+import { SPINNER_FRAME_MS } from '../core/components/spinner.js';
 export async function runApp() {
     if (!process.stdin.isTTY || !process.stdout.isTTY)
         return;
@@ -15,6 +16,13 @@ export async function runApp() {
     let scroll = 0;
     let running = true;
     let suspended = false;
+    let entered = false;
+    const lifecycle = new AbortController();
+    const keyDecoder = new KeyStreamDecoder();
+    let keyFlushTimer;
+    let clockTimer;
+    let busyTimer;
+    let painted;
     const viewIds = getAppTabs().map((tab) => tab.id);
     const nativeViews = {
         home: homeView,
@@ -38,6 +46,7 @@ export async function runApp() {
         return { rows: process.stdout.rows || 24, cols: process.stdout.columns || 80 };
     }
     const ctx = {
+        signal: lifecycle.signal,
         get size() {
             return size();
         },
@@ -70,11 +79,29 @@ export async function runApp() {
         const footer = renderFooter(view, cols, tabs.length, active?.footerHint?.(tabs.length, cols), chrome.footerLines);
         const body = active?.render(ctx) ?? [];
         const bodyScroll = active?.capturesInput?.() ? Number.MAX_SAFE_INTEGER : scroll;
-        process.stdout.write(ansi.home + composeFrame(header, body, footer, rows, cols, bodyScroll) + ansi.eraseDown);
+        const lines = composeFrameLines(header, body, footer, rows, cols, bodyScroll);
+        const patch = diffFrame(painted?.cols === cols ? painted.lines : undefined, lines);
+        painted = { cols, lines };
+        if (patch)
+            process.stdout.write(patch);
+        scheduleBusyTick(active?.isBusy?.() === true);
     }
-    function onKey(data) {
-        const key = data.toString();
+    function scheduleBusyTick(busy) {
+        if (busy && running && busyTimer === undefined) {
+            busyTimer = setTimeout(() => {
+                busyTimer = undefined;
+                render();
+            }, SPINNER_FRAME_MS);
+            return;
+        }
+        if (busy || busyTimer === undefined)
+            return;
+        clearTimeout(busyTimer);
+        busyTimer = undefined;
+    }
+    function dispatchKey(key) {
         if (key === '\x03') {
+            process.exitCode = 130;
             quit();
             return;
         } // Ctrl-C always quits, even mid-capture.
@@ -119,15 +146,73 @@ export async function runApp() {
         active?.handleKey?.(key, ctx);
         render();
     }
+    function dispatchKeys(keys) {
+        for (let index = 0; index < keys.length && running && !suspended; index += 1) {
+            let key = keys[index];
+            if (key === undefined)
+                continue;
+            if (nativeViews[view]?.capturesInput?.() && isPrintableKey(key)) {
+                while (index + 1 < keys.length) {
+                    const next = keys[index + 1];
+                    if (next === undefined || !isPrintableKey(next))
+                        break;
+                    key += next;
+                    index += 1;
+                }
+            }
+            dispatchKey(key);
+        }
+    }
+    function scheduleClock() {
+        if (!running)
+            return;
+        clockTimer = setTimeout(() => {
+            clockTimer = undefined;
+            render();
+            scheduleClock();
+        }, 60_000 - (Date.now() % 60_000));
+    }
+    function clearKeyFlush() {
+        if (keyFlushTimer === undefined)
+            return;
+        clearTimeout(keyFlushTimer);
+        keyFlushTimer = undefined;
+    }
+    function onKey(data) {
+        clearKeyFlush();
+        dispatchKeys(keyDecoder.write(data));
+        if (!running || suspended || !keyDecoder.hasPending)
+            return;
+        keyFlushTimer = setTimeout(() => {
+            keyFlushTimer = undefined;
+            dispatchKeys(keyDecoder.flush());
+        }, 20);
+    }
     function enter() {
+        if (entered || lifecycle.signal.aborted)
+            return;
+        entered = true;
+        painted = undefined;
+        keyDecoder.reset();
         ensureCursorRestored();
-        process.stdout.write(ansi.enterAlt + ansi.hideCursor);
-        if (process.stdin.isTTY)
-            process.stdin.setRawMode(true);
-        process.stdin.resume();
-        process.stdin.on('data', onKey);
+        try {
+            process.stdout.write(ansi.enterAlt + ansi.hideCursor);
+            if (process.stdin.isTTY)
+                process.stdin.setRawMode(true);
+            process.stdin.resume();
+            process.stdin.on('data', onKey);
+        }
+        catch (error) {
+            leave();
+            throw error;
+        }
     }
     function leave() {
+        if (!entered)
+            return;
+        entered = false;
+        clearKeyFlush();
+        keyDecoder.reset();
         process.stdin.removeListener('data', onKey);
         if (process.stdin.isTTY)
             process.stdin.setRawMode(false);
@@ -162,6 +247,15 @@ export async function runApp() {
         leave();
     }
     function onSigint() {
+        process.exitCode = 130;
+        quit();
+    }
+    function onSigterm() {
+        process.exitCode = 143;
+        quit();
+    }
+    function onSighup() {
+        process.exitCode = 129;
         quit();
     }
     let resolveRun;
@@ -172,6 +266,12 @@ export async function runApp() {
         if (!running)
             return;
         running = false;
+        lifecycle.abort();
+        if (clockTimer !== undefined) {
+            clearTimeout(clockTimer);
+            clockTimer = undefined;
+        }
+        scheduleBusyTick(false);
         try {
             leave();
         }
@@ -179,16 +279,21 @@ export async function runApp() {
             process.stdout.removeListener('resize', onResize);
             process.removeListener('exit', onExit);
             process.removeListener('SIGINT', onSigint);
+            process.removeListener('SIGTERM', onSigterm);
+            process.removeListener('SIGHUP', onSighup);
             resolveRun();
         }
     }
     process.on('exit', onExit);
     process.stdout.on('resize', onResize);
     process.once('SIGINT', onSigint);
+    process.once('SIGTERM', onSigterm);
+    process.once('SIGHUP', onSighup);
     try {
         enter();
         loadView('home');
         render();
+        scheduleClock();
         await done;
     }
     finally {

package/dist/app/frame.js

@@ -1,3 +1,4 @@
+import { ansi } from '../core/canvas.js';
 import { clipAnsiToVisualWidth, visualWidth } from '../core/text.js';
 export function clipToWidth(line, cols) {
     if (visualWidth(line) <= cols)
@@ -17,12 +18,23 @@ export function fitBody(lines, height, scroll, cols) {
         out.push(' '.repeat(cols));
     return out;
 }
-export function composeFrame(header, body, footer, rows, cols, scroll) {
+export function composeFrameLines(header, body, footer, rows, cols, scroll) {
     const h = header.map((l) => fitLine(l, cols));
     const f = footer.map((l) => fitLine(l, cols));
     const bodyH = Math.max(0, rows - h.length - f.length);
     const b = fitBody(body, bodyH, scroll, cols);
-    return [...h, ...b, ...f].slice(0, rows).join('\n');
+    return [...h, ...b, ...f].slice(0, rows);
+}
+export function diffFrame(prev, next) {
+    if (prev?.length !== next.length)
+        return ansi.home + next.join('\n') + ansi.eraseDown;
+    let out = '';
+    for (let row = 0; row < next.length; row += 1) {
+        const line = next[row];
+        if (line !== undefined && prev[row] !== line)
+            out += ansi.cursorToRow(row + 1) + line;
+    }
+    return out;
 }
 export function computeBodyRows(rows, headerLines, footerLines) {
     return Math.max(0, rows - headerLines - footerLines);

package/dist/app/keys.js

@@ -1,3 +1,103 @@
+const ESC = '\x1b';
+const GRAPHEME_SEGMENTER = new Intl.Segmenter(undefined, { granularity: 'grapheme' });
+function isControl(value) {
+    const code = value.charCodeAt(0);
+    return code <= 0x1f || (code >= 0x7f && code <= 0x9f);
+}
+export function isPrintableKey(value) {
+    if (value.length === 0 || value.startsWith(ESC))
+        return false;
+    return Array.from(value).every((char) => !isControl(char));
+}
+function escapeSequenceLength(value) {
+    if (value.length === 1)
+        return null;
+    const introducer = value[1];
+    if (introducer === ESC || (introducer !== undefined && isControl(introducer)))
+        return 1;
+    if (introducer === '[' || introducer === 'O') {
+        for (let index = 2; index < value.length; index += 1) {
+            const code = value.charCodeAt(index);
+            if (code >= 0x40 && code <= 0x7e)
+                return index + 1;
+            if (code < 0x20 || code > 0x3f)
+                return 1;
+        }
+        return null;
+    }
+    if (introducer === ']' || introducer === 'P' || introducer === '^' || introducer === '_') {
+        for (let index = 2; index < value.length; index += 1) {
+            if (value[index] === '\x07')
+                return index + 1;
+            if (value[index] === ESC && value[index + 1] === '\\')
+                return index + 2;
+        }
+        return null;
+    }
+    const segment = GRAPHEME_SEGMENTER.segment(value.slice(1))[Symbol.iterator]().next();
+    return segment.done ? null : 1 + segment.value.segment.length;
+}
+export class KeyStreamDecoder {
+    decoder = new TextDecoder();
+    pending = '';
+    get hasPending() {
+        return this.pending.length > 0;
+    }
+    write(data) {
+        this.pending += typeof data === 'string' ? data : this.decoder.decode(data, { stream: true });
+        return this.drain(false);
+    }
+    flush() {
+        return this.drain(true);
+    }
+    reset() {
+        this.pending = '';
+        this.decoder = new TextDecoder();
+    }
+    drain(flush) {
+        const keys = [];
+        let offset = 0;
+        while (offset < this.pending.length) {
+            const value = this.pending.slice(offset);
+            const first = value[0];
+            if (first === undefined)
+                break;
+            if (first === ESC) {
+                const length = escapeSequenceLength(value);
+                if (length === null) {
+                    if (flush) {
+                        keys.push(value);
+                        offset = this.pending.length;
+                    }
+                    break;
+                }
+                keys.push(value.slice(0, length));
+                offset += length;
+                continue;
+            }
+            if (isControl(first)) {
+                keys.push(first);
+                offset += 1;
+                continue;
+            }
+            let end = offset;
+            while (end < this.pending.length) {
+                const char = this.pending[end];
+                if (char === undefined || char === ESC || isControl(char))
+                    break;
+                end += char.length;
+            }
+            const run = this.pending.slice(offset, end);
+            const segments = Array.from(GRAPHEME_SEGMENTER.segment(run), ({ segment }) => segment);
+            for (const segment of segments) {
+                keys.push(segment);
+                offset += segment.length;
+            }
+        }
+        this.pending = this.pending.slice(offset);
+        return keys;
+    }
+}
 function switchResult(target) {
     return target === undefined ? { handled: true } : { switchTo: target, handled: true };
 }

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

@@ -2,6 +2,7 @@ import { type, space } from '../../core/theme.js';
 import { t } from '../../i18n/index.js';
 import { renderListFieldWithContext } from '../fields/list-field.js';
 import { visualWidth, wrapAnsiToVisualWidth, wrapAnsiWithIndent } from '../../core/text.js';
+import { loadingLines } from '../../core/components/spinner.js';
 function hintLines(label, cols) {
     return wrapAnsiWithIndent(type.hint(label), cols, space.indent);
 }
@@ -36,7 +37,7 @@ export function renderDocs(state, cols = 80, bodyRows = Number.POSITIVE_INFINITY
     let lines;
     switch (state.mode) {
         case 'loading':
-            lines = hintLines(trans.common.loading, cols);
+            lines = loadingLines(trans.common.loading, cols);
             break;
         case 'sections':
             lines = state.sectionsField?.render(bodyRows, cols) ?? [];
@@ -66,7 +67,7 @@ export function renderDocs(state, cols = 80, bodyRows = Number.POSITIVE_INFINITY
                 : [];
             break;
         case 'readerLoading':
-            lines = hintLines(trans.docs.loadingFile, cols);
+            lines = loadingLines(trans.docs.loadingFile, cols);
             break;
         case 'reader':
             lines = state.readerLinksField

package/dist/app/views/docs.js

@@ -4,9 +4,9 @@ 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 { fmt, getCurrentLanguage, t } from '../../i18n/index.js';
 import { sanitizeTerminalLine, truncate } from '../../core/text.js';
-import { localizeDocSections, fetchSections, fetchDocMetadata, fetchSectionMetadata, searchDocuments, getArchivedGroups, displayDocTitle, loadDocForReader, openDocsInBrowser, clearDocsCache, } from '../../features/docs.js';
+import { localizeDocSections, fetchSections, fetchDocMetadata, fetchSectionMetadata, searchDocuments, getArchivedGroups, displayDocTitle, loadDocForReader, openDocsInBrowser, docsUrlFromPath, clearDocsCache, } from '../../features/docs.js';
 let state = { mode: 'loading' };
 let sections = [];
 let archivedGroups = new Map();
@@ -23,7 +23,11 @@ let readerNavStack = [];
 let readerPrevState = null;
 let readerLoadingPrevState = null;
 let readerRequestId = 0;
+let lifecycleGeneration = 0;
 const DOC_HINT_WIDTH = 44;
+function isLifecycleActive(ctx, generation) {
+    return generation === lifecycleGeneration && ctx.signal?.aborted !== true;
+}
 function backLabel() {
     return t().common.back;
 }
@@ -43,6 +47,27 @@ function withoutErrorMessage(value) {
     delete next.errorMessage;
     return next;
 }
+async function runBrowserOpen(ctx, path) {
+    let opened;
+    await ctx.runClassic(async () => {
+        opened =
+            path === undefined
+                ? await openDocsInBrowser(undefined, ctx.signal)
+                : await openDocsInBrowser(path, ctx.signal);
+    });
+    return opened;
+}
+async function openBrowserFromView(ctx, path, generation = lifecycleGeneration) {
+    const opened = await runBrowserOpen(ctx, path);
+    if (!isLifecycleActive(ctx, generation) || opened === true)
+        return;
+    const url = docsUrlFromPath(path);
+    state = {
+        ...state,
+        errorMessage: sanitizeTerminalLine(`${t().docs.browserError}. ${fmt(t().links.openManually, { url })}`),
+    };
+    ctx.rerender();
+}
 function buildSectionsField() {
     const trans = t();
     const options = [
@@ -184,6 +209,9 @@ function replaceSection(section) {
     sections = sections.map((current) => (current.key === section.key ? section : current));
 }
 async function openSectionFiles(ctx, section) {
+    const generation = lifecycleGeneration;
+    if (!isLifecycleActive(ctx, generation))
+        return;
     const requestId = ++metadataRequestId;
     currentSectionKey = section.key;
     state = {
@@ -192,8 +220,9 @@ async function openSectionFiles(ctx, section) {
     };
     ctx.rerender();
     try {
-        const hydrated = await fetchSectionMetadata(section);
-        if (requestId !== metadataRequestId ||
+        const hydrated = await fetchSectionMetadata(section, ctx.signal);
+        if (!isLifecycleActive(ctx, generation) ||
+            requestId !== metadataRequestId ||
             state.mode !== 'files' ||
             currentSectionKey !== section.key)
             return;
@@ -205,15 +234,20 @@ async function openSectionFiles(ctx, section) {
         };
     }
     catch {
-        if (requestId !== metadataRequestId ||
+        if (!isLifecycleActive(ctx, generation) ||
+            requestId !== metadataRequestId ||
             state.mode !== 'files' ||
             currentSectionKey !== section.key)
             return;
         state = { ...state, errorMessage: t().docs.loadError };
     }
-    ctx.rerender();
+    if (isLifecycleActive(ctx, generation))
+        ctx.rerender();
 }
 async function openArchivedFiles(ctx, groupKey, groupFiles) {
+    const generation = lifecycleGeneration;
+    if (!isLifecycleActive(ctx, generation))
+        return;
     const requestId = ++metadataRequestId;
     currentArchivedGroupKey = groupKey;
     state = {
@@ -222,8 +256,9 @@ async function openArchivedFiles(ctx, groupKey, groupFiles) {
     };
     ctx.rerender();
     try {
-        const hydrated = await fetchDocMetadata(groupFiles);
-        if (requestId !== metadataRequestId ||
+        const hydrated = await fetchDocMetadata(groupFiles, ctx.signal);
+        if (!isLifecycleActive(ctx, generation) ||
+            requestId !== metadataRequestId ||
             state.mode !== 'archivedFiles' ||
             currentArchivedGroupKey !== groupKey)
             return;
@@ -234,7 +269,8 @@ async function openArchivedFiles(ctx, groupKey, groupFiles) {
         };
     }
     catch {
-        if (requestId !== metadataRequestId ||
+        if (!isLifecycleActive(ctx, generation) ||
+            requestId !== metadataRequestId ||
             state.mode !== 'archivedFiles' ||
             currentArchivedGroupKey !== groupKey)
             return;
@@ -243,15 +279,19 @@ async function openArchivedFiles(ctx, groupKey, groupFiles) {
             errorMessage: t().docs.loadError,
         };
     }
-    ctx.rerender();
+    if (isLifecycleActive(ctx, generation))
+        ctx.rerender();
 }
 async function runSearch(ctx, query) {
+    const generation = lifecycleGeneration;
+    if (!isLifecycleActive(ctx, generation))
+        return;
     const requestId = ++searchRequestId;
     state = { mode: 'searchLoading' };
     ctx.rerender();
     try {
-        const matches = await searchDocuments(query);
-        if (requestId !== searchRequestId)
+        const matches = await searchDocuments(query, ctx.signal);
+        if (!isLifecycleActive(ctx, generation) || requestId !== searchRequestId)
             return;
         currentSearchResults = matches;
         state = {
@@ -261,15 +301,19 @@ async function runSearch(ctx, query) {
         };
     }
     catch {
-        if (requestId !== searchRequestId)
+        if (!isLifecycleActive(ctx, generation) || requestId !== searchRequestId)
             return;
         currentSearchResults = [];
         goToSections();
         state = { ...state, errorMessage: t().docs.loadError };
     }
-    ctx.rerender();
+    if (isLifecycleActive(ctx, generation))
+        ctx.rerender();
 }
 async function openInReader(ctx, path, pushCurrent) {
+    const generation = lifecycleGeneration;
+    if (!isLifecycleActive(ctx, generation))
+        return;
     const requestId = ++readerRequestId;
     const previousState = state;
     const previousPath = readerCurrentPath;
@@ -277,8 +321,8 @@ async function openInReader(ctx, path, pushCurrent) {
     state = { mode: 'readerLoading' };
     ctx.rerender();
     try {
-        const doc = await loadDocForReader(path);
-        if (requestId !== readerRequestId)
+        const doc = await loadDocForReader(path, ctx.signal);
+        if (!isLifecycleActive(ctx, generation) || requestId !== readerRequestId)
             return;
         if (pushCurrent && previousPath)
             readerNavStack.push(previousPath);
@@ -293,7 +337,7 @@ async function openInReader(ctx, path, pushCurrent) {
         ctx.resetScroll();
     }
     catch {
-        if (requestId !== readerRequestId)
+        if (!isLifecycleActive(ctx, generation) || requestId !== readerRequestId)
             return;
         readerLoadingPrevState = null;
         const fallbackState = pushCurrent && previousState.mode === 'reader'
@@ -301,7 +345,8 @@ async function openInReader(ctx, path, pushCurrent) {
             : previousState;
         state = { ...fallbackState, errorMessage: t().docs.loadError };
     }
-    ctx.rerender();
+    if (isLifecycleActive(ctx, generation))
+        ctx.rerender();
 }
 function enterReaderFrom(ctx, path) {
     readerPrevState = state;
@@ -313,6 +358,9 @@ export const docsView = {
     id: 'docs',
     title: t().menu.docs,
     async load(ctx) {
+        const generation = loaded ? lifecycleGeneration : ++lifecycleGeneration;
+        if (!isLifecycleActive(ctx, generation))
+            return;
         if (loaded) {
             const language = getCurrentLanguage();
             if (loadedLanguage !== language) {
@@ -330,8 +378,8 @@ export const docsView = {
         state = { mode: 'loading' };
         ctx.rerender();
         try {
-            const nextSections = await fetchSections();
-            if (requestId !== sectionsRequestId)
+            const nextSections = await fetchSections(ctx.signal);
+            if (!isLifecycleActive(ctx, generation) || requestId !== sectionsRequestId)
                 return;
             sections = nextSections;
             loaded = true;
@@ -339,11 +387,21 @@ export const docsView = {
             goToSections();
         }
         catch {
-            if (requestId !== sectionsRequestId)
+            if (!isLifecycleActive(ctx, generation) || requestId !== sectionsRequestId)
                 return;
             state = { mode: 'error', errorMessage: t().docs.loadError };
         }
-        ctx.rerender();
+        if (isLifecycleActive(ctx, generation))
+            ctx.rerender();
+    },
+    dispose() {
+        lifecycleGeneration += 1;
+        sectionsRequestId += 1;
+        metadataRequestId += 1;
+        searchRequestId += 1;
+        readerRequestId += 1;
+        clearDocsCache();
+        setVimKeysActive(true);
     },
     render(ctx) {
         const maxVisible = computeMaxVisible(ctx.bodyRows);
@@ -354,6 +412,9 @@ export const docsView = {
         state.readerLinksField?.setMaxVisible(maxVisible);
         return renderDocs(state, ctx.size.cols, ctx.bodyRows);
     },
+    isBusy() {
+        return (state.mode === 'loading' || state.mode === 'searchLoading' || state.mode === 'readerLoading');
+    },
     capturesInput() {
         return state.mode === 'search';
     },
@@ -479,7 +540,7 @@ export const docsView = {
                     return;
                 }
                 if (result.selected === '__browser__') {
-                    void ctx.runClassic(() => openDocsInBrowser());
+                    void openBrowserFromView(ctx);
                     return;
                 }
                 const section = sections.find((s) => s.key === result.selected);
@@ -586,7 +647,7 @@ export const docsView = {
                     return;
                 }
                 if (key === 'b') {
-                    void ctx.runClassic(() => openDocsInBrowser(readerCurrentPath ?? undefined));
+                    void openBrowserFromView(ctx, readerCurrentPath ?? undefined);
                     return;
                 }
                 return;

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

@@ -4,6 +4,7 @@ import { renderListFieldWithContext } from '../fields/list-field.js';
 import { renderCountdownBanner, renderEventBrief } from '../../features/calendar.js';
 import { renderHeatmap } from '../../features/calendar-heatmap.js';
 import { wrapAnsiWithIndent } from '../../core/text.js';
+import { loadingLines } from '../../core/components/spinner.js';
 function wrappedIndentedLines(label, cols, style) {
     return wrapAnsiWithIndent(style(label), cols ?? Number.POSITIVE_INFINITY, space.indent);
 }
@@ -61,7 +62,7 @@ export function renderEvents(state, now, bodyRows = 100, cols) {
     const trans = t();
     switch (state.mode) {
         case 'loading':
-            return wrappedIndentedLines(trans.calendar.loading, cols, type.hint);
+            return loadingLines(trans.calendar.loading, cols);
         case 'hub':
             return renderHubBody(state, now, bodyRows, cols);
         case 'heatmap':

package/dist/app/views/events.js

@@ -93,21 +93,32 @@ 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) {
         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';
     },