@nbtca/prompt 1.3.2 → 1.4.1

package/dist/app/views/schedule.js

@@ -0,0 +1,472 @@
+import path from 'node:path';
+import { createNbtTimetableClient, timetableToIcs, } from '@nbtca/nbtcal/timetable';
+import { captureFooterHint, passiveFooterHint } from '../chrome.js';
+import { ListField, computeMaxVisible } from '../fields/list-field.js';
+import { TextField } from '../fields/text-field.js';
+import { renderSchedule, hubShortcuts } from './schedule-render.js';
+import { defaultGridCursor, handleGridKey } from './schedule-grid-cursor.js';
+import { setVimKeysActive } from '../../core/vim-keys.js';
+import { t } from '../../i18n/index.js';
+import { AuthError } from '../../auth/errors.js';
+import { loginWithStudentPassword, restoreNbtSession } from '../../auth/nbt-auth.js';
+import { createSessionStore } from '../../auth/session-store.js';
+import { resolveTerm, relevantTerms, writePrivateIcs, isSessionExpired, JWXT_ORIGIN, safeMessage, } from '../../features/student-timetable.js';
+import { termKey, loadWeekOne, saveWeekOne, saveTimetableCache, saveCurrentPointer, loadCurrentPointer, loadTimetableCache, clearScheduleCache, } from '../../features/schedule-store.js';
+import { loadCalendarOrThrow, toDisplayEvent } from '../../features/calendar.js';
+import { currentAcademicWindow, inferWeekOneMonday, isAcademicBreakEvent, } from '@nbtca/nbtcal';
+import { currentWeekNumber, campusWeekday } from '../../features/schedule-query.js';
+let state = { mode: 'loading' };
+let session = null;
+let client = null;
+let catalog = [];
+let pendingId = '';
+function isTimetableLike(value) {
+    return !!value && typeof value === 'object'
+        && Array.isArray(value.meetings)
+        && Array.isArray(value.periods);
+}
+function returnToHub() {
+    const tt = state.timetable;
+    const backKey = state.key;
+    const backWeekOne = state.weekOne;
+    if (tt && backKey && backWeekOne) {
+        // Carries over the existing cursor rather than resetting it -- closing a
+        // meeting's detail card (or backing out of term density/unresolved)
+        // should leave the student's grid navigation exactly where it was, not
+        // silently jump back to today.
+        state = {
+            mode: 'hub', key: backKey, term: state.term, weekOne: backWeekOne, timetable: tt,
+            gridCursor: state.gridCursor ?? defaultGridCursor(campusWeekday(new Date()), tt.periods),
+        };
+        return true;
+    }
+    return false;
+}
+function goToLoginId(errorMessage) {
+    pendingId = '';
+    setVimKeysActive(false);
+    state = {
+        mode: 'needsLoginId',
+        errorMessage,
+        idField: new TextField({ message: t().timetable.studentId, placeholder: t().timetable.studentIdHint }),
+    };
+}
+function buildPublicField() {
+    const trans = t();
+    return new ListField({
+        title: trans.timetable.menuEntry,
+        options: [{ value: 'login', label: trans.timetable.publicLoginAction }],
+        footer: trans.menu.hintMove,
+    });
+}
+// A glance-panel ceiling, not "browse everything" (matches the same-purpose
+// constants in events.ts/home.ts) — renderPublicBody trims further based on
+// the real ctx.bodyRows.
+const PUBLIC_UPCOMING_FETCH_CAP = 15;
+/** The default, no-login Schedule view: public term/week status sourced from
+ * the same public calendar feed Events already uses. Login is now something
+ * the student opts into from here, not a gate they hit immediately. */
+async function goToPublic(ctx) {
+    setVimKeysActive(true);
+    state = { mode: 'public', publicField: buildPublicField() };
+    ctx.rerender();
+    try {
+        const cal = await loadCalendarOrThrow();
+        const now = new Date();
+        const windowEvents = cal.inRange(new Date(now.getTime() - 400 * 86400000), new Date(now.getTime() + 400 * 86400000));
+        const publicWindow = currentAcademicWindow(windowEvents, now);
+        const publicUpcoming = cal.upcoming({ days: 30 })
+            .filter((e) => !isAcademicBreakEvent(e))
+            .slice(0, PUBLIC_UPCOMING_FETCH_CAP)
+            .map(toDisplayEvent);
+        state = { ...state, publicWindow, publicUpcoming };
+    }
+    catch {
+        state = { ...state, publicWindow: null };
+    }
+    ctx.rerender();
+}
+/** Best-effort: try to auto-fill "week one Monday" from the same public
+ * calendar feed before falling back to the manual prompt. Never throws —
+ * any failure here just means the student sees today's existing prompt. */
+async function tryInferWeekOne() {
+    try {
+        const cal = await loadCalendarOrThrow();
+        const now = new Date();
+        // Symmetric window (matches goToPublic's): inferWeekOneMonday can look
+        // forward to an *upcoming* semester-start marker while on break (e.g. a
+        // student logging in mid-summer, months before the next term's own
+        // start date) — a narrow forward window would silently miss exactly the
+        // event this is meant to find.
+        const events = cal.inRange(new Date(now.getTime() - 400 * 86400000), new Date(now.getTime() + 400 * 86400000));
+        return inferWeekOneMonday(events, now);
+    }
+    catch {
+        return null;
+    }
+}
+async function afterAuthenticated(ctx, s) {
+    // Captured before any state mutation below, so it reflects whether a
+    // cached hub was already on screen when this call started (e.g. a
+    // background session restore on launch) as opposed to a fresh login
+    // (where state is 'authenticating', so hadCache is false).
+    const hadCache = state.mode === 'hub';
+    session = s;
+    client = createNbtTimetableClient(s.timetableTransport, { baseUrl: JWXT_ORIGIN });
+    try {
+        catalog = await client.listTerms();
+        const term = resolveTerm(catalog);
+        const key = termKey(term);
+        let weekOne = loadWeekOne(key);
+        if (!weekOne) {
+            weekOne = await tryInferWeekOne();
+            if (weekOne)
+                saveWeekOne(key, weekOne);
+        }
+        if (!weekOne) {
+            setVimKeysActive(false);
+            state = {
+                mode: 'needsWeekOne',
+                key,
+                term,
+                errorMessage: t().timetable.weekOneAutoFailed,
+                weekOneField: new TextField({ message: t().timetable.weekOne, placeholder: t().timetable.weekOneHint }),
+            };
+            ctx.rerender();
+            return;
+        }
+        await fetchAndShowHub(ctx, term, key, weekOne);
+    }
+    catch (err) {
+        if (isSessionExpired(err)) {
+            // A dead session must be cleared and routed back to the login
+            // field — leaving it as a bare error message here was a dead end:
+            // the stale session would keep failing the same way on every
+            // future launch/tab-switch, and there was no way back into the
+            // login form short of quitting the app.
+            createSessionStore().clear();
+            if (!hadCache)
+                goToLoginId(t().timetable.expiredRelogin);
+        }
+        else if (!hadCache) {
+            // Only replace the screen with an error if there was nothing
+            // useful showing already — a background refresh failure must not
+            // blow away a working cached timetable (matches the same
+            // best-effort contract refreshFromNetwork documents below).
+            state = { mode: 'error', errorMessage: safeMessage(err) };
+        }
+        ctx.rerender();
+    }
+}
+async function fetchAndShowHub(ctx, term, key, weekOne) {
+    if (!client)
+        return;
+    state = { mode: 'loading', statusMessage: t().calendar.loading };
+    ctx.rerender();
+    try {
+        const timetable = await client.fetchTerm(term);
+        saveTimetableCache(key, timetable);
+        saveCurrentPointer(key, weekOne);
+        state = {
+            mode: 'hub', key, term, weekOne, timetable,
+            gridCursor: defaultGridCursor(campusWeekday(new Date()), timetable.periods),
+        };
+    }
+    catch (err) {
+        if (isSessionExpired(err)) {
+            createSessionStore().clear();
+            goToLoginId(t().timetable.expiredRelogin);
+        }
+        else {
+            state = { mode: 'error', errorMessage: safeMessage(err) };
+        }
+    }
+    ctx.rerender();
+}
+async function refreshFromNetwork(ctx) {
+    const hadCache = state.mode === 'hub';
+    try {
+        const store = createSessionStore();
+        const persisted = store.load();
+        if (!persisted) {
+            if (!hadCache)
+                await goToPublic(ctx);
+            return;
+        }
+        const restored = await restoreNbtSession(persisted);
+        await afterAuthenticated(ctx, restored);
+    }
+    catch (err) {
+        if (!hadCache) {
+            if (err instanceof AuthError && isSessionExpired(err)) {
+                createSessionStore().clear();
+            }
+            await goToPublic(ctx);
+        }
+        // best-effort: a cached hub already showed, keep it as-is on refresh failure.
+    }
+}
+export const scheduleView = {
+    id: 'schedule',
+    title: t().timetable.menuEntry,
+    async load(ctx) {
+        const ptr = loadCurrentPointer();
+        const cached = ptr ? loadTimetableCache(ptr.termKey) : null;
+        if (ptr && isTimetableLike(cached)) {
+            state = {
+                mode: 'hub', key: ptr.termKey, weekOne: ptr.weekOneMonday, timetable: cached,
+                gridCursor: defaultGridCursor(campusWeekday(new Date()), cached.periods),
+            };
+        }
+        else {
+            state = { mode: 'loading' };
+        }
+        ctx.rerender();
+        await refreshFromNetwork(ctx);
+    },
+    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.
+        state.termField?.setMaxVisible(computeMaxVisible(ctx.bodyRows));
+        return renderSchedule(state, new Date(), ctx.bodyRows, ctx.size.cols);
+    },
+    capturesInput() {
+        return state.mode === 'needsLoginId' || state.mode === 'needsLoginPassword' || state.mode === 'needsWeekOne';
+    },
+    footerHint(tabCount, cols = Number.POSITIVE_INFINITY) {
+        const capturing = state.mode === 'needsLoginId' || state.mode === 'needsLoginPassword' || state.mode === 'needsWeekOne';
+        if (capturing)
+            return captureFooterHint(cols);
+        // These three are pure "read this, any key returns to the hub" drill-
+        // downs (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 === 'authenticating' || state.mode === 'error'
+            || state.mode === 'meetingDetail' || state.mode === 'unresolved' || state.mode === 'termDensity';
+        return passive ? passiveFooterHint(tabCount, cols) : undefined;
+    },
+    handleBack(ctx) {
+        if (state.mode === 'needsLoginId') {
+            void goToPublic(ctx);
+            return true;
+        }
+        if (state.mode === 'needsLoginPassword' || state.mode === 'needsWeekOne') {
+            goToLoginId();
+            return true;
+        }
+        if (state.mode === 'meetingDetail') {
+            // Esc respects where the detail card was opened from -- from the
+            // standalone 'week' mode, it steps back there, not all the way to hub.
+            if (state.detailFrom === 'week') {
+                state = { ...state, mode: 'week' };
+                return true;
+            }
+            return returnToHub();
+        }
+        if (state.mode === 'week' || state.mode === 'unresolved' || state.mode === 'termPicker'
+            || state.mode === 'termDensity') {
+            return returnToHub();
+        }
+        return false;
+    },
+    handleKey(key, ctx) {
+        switch (state.mode) {
+            case 'public': {
+                const result = state.publicField?.handleKey(key);
+                if (result?.selected === 'login')
+                    goToLoginId();
+                return;
+            }
+            case 'needsLoginId': {
+                const result = state.idField?.handleKey(key);
+                if (result?.cancelled) {
+                    void goToPublic(ctx);
+                    return;
+                }
+                if (result?.submitted !== undefined) {
+                    pendingId = result.submitted;
+                    state = {
+                        mode: 'needsLoginPassword',
+                        passwordField: new TextField({ message: t().timetable.password, placeholder: t().timetable.passwordHint, secret: true }),
+                    };
+                }
+                return;
+            }
+            case 'needsLoginPassword': {
+                const result = state.passwordField?.handleKey(key);
+                if (result?.cancelled) {
+                    goToLoginId();
+                    return;
+                }
+                if (result?.submitted !== undefined) {
+                    const password = result.submitted;
+                    setVimKeysActive(true);
+                    state = { mode: 'authenticating', statusMessage: t().timetable.loginWillSave };
+                    ctx.rerender();
+                    void loginWithStudentPassword(pendingId, password)
+                        .then(async (s) => {
+                        createSessionStore().save(await s.snapshot());
+                        await afterAuthenticated(ctx, s);
+                    })
+                        .catch((err) => {
+                        goToLoginId(safeMessage(err));
+                        ctx.rerender();
+                    });
+                }
+                return;
+            }
+            case 'needsWeekOne': {
+                const result = state.weekOneField?.handleKey(key);
+                if (result?.cancelled) {
+                    goToLoginId();
+                    return;
+                }
+                if (result?.submitted !== undefined) {
+                    const trimmed = result.submitted.trim();
+                    const valid = /^\d{4}-\d{2}-\d{2}$/.test(trimmed) && !Number.isNaN(new Date(`${trimmed}T00:00:00`).getTime());
+                    const targetKey = state.key;
+                    const targetTerm = state.term;
+                    if (!valid || !targetKey || !targetTerm) {
+                        state = { ...state, errorMessage: t().timetable.weekOneHint };
+                        return;
+                    }
+                    saveWeekOne(targetKey, trimmed);
+                    setVimKeysActive(true);
+                    void fetchAndShowHub(ctx, targetTerm, targetKey, trimmed);
+                }
+                return;
+            }
+            case 'hub': {
+                const tt = state.timetable;
+                const hubKey = state.key;
+                const hubWeekOne = state.weekOne;
+                if (!tt || !hubKey || !hubWeekOne)
+                    return;
+                {
+                    const cursor = state.gridCursor ?? defaultGridCursor(campusWeekday(new Date()), tt.periods);
+                    const week = Math.max(1, currentWeekNumber(hubWeekOne, new Date()));
+                    const nav = handleGridKey(key, cursor, tt, week);
+                    if (nav.kind === 'moveCursor') {
+                        state = { ...state, gridCursor: nav.cursor };
+                        return;
+                    }
+                    if (nav.kind === 'openDetail') {
+                        state = { ...state, mode: 'meetingDetail', detailMeeting: nav.meeting, detailFrom: 'hub' };
+                        return;
+                    }
+                }
+                const shortcut = hubShortcuts(tt).find((sc) => sc.key === key);
+                if (!shortcut)
+                    return;
+                if (shortcut.key === 'w') {
+                    state = { ...state, mode: 'week' };
+                    return;
+                }
+                if (shortcut.key === 't') {
+                    state = { ...state, mode: 'termDensity' };
+                    return;
+                }
+                if (shortcut.key === 'u') {
+                    state = { ...state, mode: 'unresolved' };
+                    return;
+                }
+                if (shortcut.key === 's') {
+                    const options = relevantTerms(catalog).map((tm) => ({
+                        value: `${tm.academicYear}:${tm.semester}`,
+                        label: tm.academicYearLabel,
+                        hint: tm.current ? t().common.current : undefined,
+                    }));
+                    options.push({ value: '__back__', label: t().common.back, hint: undefined });
+                    state = {
+                        ...state,
+                        mode: 'termPicker',
+                        termField: new ListField({ title: t().timetable.hubSwitchTerm, options, maxVisible: computeMaxVisible(ctx.bodyRows) }),
+                    };
+                    return;
+                }
+                if (shortcut.key === 'e') {
+                    try {
+                        const ics = timetableToIcs(tt, { weekOneMonday: hubWeekOne, calendarName: `NBT ${state.term?.academicYearLabel ?? ''}` });
+                        const out = `timetable-${hubKey}.ics`;
+                        writePrivateIcs(out, ics);
+                        state = { ...state, statusMessage: `${t().common.success}: ${path.resolve(out)}` };
+                    }
+                    catch {
+                        state = { ...state, statusMessage: t().timetable.genericError };
+                    }
+                    return;
+                }
+                if (shortcut.key === 'x') {
+                    createSessionStore().clear();
+                    clearScheduleCache();
+                    void session?.close();
+                    session = null;
+                    client = null;
+                    void goToPublic(ctx);
+                }
+                return;
+            }
+            case 'week': {
+                const tt = state.timetable;
+                const weekOne = state.weekOne;
+                if (!tt || !weekOne) {
+                    returnToHub();
+                    return;
+                }
+                const cursor = state.gridCursor ?? defaultGridCursor(campusWeekday(new Date()), tt.periods);
+                const week = Math.max(1, currentWeekNumber(weekOne, new Date()));
+                const nav = handleGridKey(key, cursor, tt, week);
+                if (nav.kind === 'moveCursor') {
+                    state = { ...state, gridCursor: nav.cursor };
+                    return;
+                }
+                if (nav.kind === 'openDetail') {
+                    state = { ...state, mode: 'meetingDetail', detailMeeting: nav.meeting, detailFrom: 'week' };
+                    return;
+                }
+                returnToHub();
+                return;
+            }
+            case 'meetingDetail': {
+                if (state.detailFrom === 'week') {
+                    state = { ...state, mode: 'week' };
+                    return;
+                }
+                returnToHub();
+                return;
+            }
+            case 'unresolved':
+            case 'termDensity': {
+                returnToHub();
+                return;
+            }
+            case 'termPicker': {
+                const result = state.termField?.handleKey(key);
+                if (!result?.selected)
+                    return;
+                if (result.selected === '__back__') {
+                    returnToHub();
+                    return;
+                }
+                const term = resolveTerm(catalog, result.selected);
+                const newTermKey = termKey(term);
+                const weekOne = loadWeekOne(newTermKey);
+                if (!weekOne) {
+                    setVimKeysActive(false);
+                    state = {
+                        mode: 'needsWeekOne',
+                        key: newTermKey,
+                        term,
+                        weekOneField: new TextField({ message: t().timetable.weekOne, placeholder: t().timetable.weekOneHint }),
+                    };
+                    return;
+                }
+                void fetchAndShowHub(ctx, term, newTermKey, weekOne);
+                return;
+            }
+            default:
+                return;
+        }
+    },
+};

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

@@ -0,0 +1,53 @@
+import { space, type } from '../../core/theme.js';
+import { visualWidth, wrapAnsiToVisualWidth } from '../../core/text.js';
+import { renderListFieldWithContext } from '../fields/list-field.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}`);
+}
+export function renderSettings(state, bodyRows = Number.POSITIVE_INFINITY, cols = Number.POSITIVE_INFINITY) {
+    switch (state.mode) {
+        case 'menu': {
+            const context = [
+                ...(state.statusMessage ? [...wrappedIndentedLines(state.statusMessage, cols, type.hint), ''] : []),
+            ];
+            return state.menuField
+                ? renderListFieldWithContext(context, state.menuField, bodyRows, cols)
+                : context;
+        }
+        case 'language':
+        case 'icon':
+        case 'color':
+            return state.subField?.render(bodyRows, cols) ?? [];
+        case 'about': {
+            const context = [
+                ...(state.aboutLines ?? []).flatMap((line) => (line ? wrappedIndentedLines(line, cols, (value) => value) : [''])),
+                '',
+            ];
+            if (!state.backField)
+                return context;
+            const fieldLines = state.backField.render(Number.POSITIVE_INFINITY, cols);
+            if (!Number.isFinite(bodyRows) || context.length + fieldLines.length <= bodyRows) {
+                return [...context, ...fieldLines];
+            }
+            const rows = Math.max(0, Math.floor(bodyRows));
+            const visibleField = fieldLines.length <= rows
+                ? fieldLines
+                : state.backField.render(rows, cols);
+            const content = context.at(-1) === '' ? context.slice(0, -1) : context;
+            return content.length > 0
+                ? [...visibleField, '', ...content]
+                : visibleField;
+        }
+        default:
+            return [];
+    }
+}

package/dist/app/views/settings.js

@@ -0,0 +1,153 @@
+import { ListField } from '../fields/list-field.js';
+import { renderSettings } from './settings-render.js';
+import { applyColorModePreference, loadPreferences, resetPreferences, setColorMode, setIconMode, } from '../../config/preferences.js';
+import { resetIconCache, pickIcon } from '../../core/icons.js';
+import { APP_INFO, URLS } from '../../config/data.js';
+import { t, getCurrentLanguage, setLanguage, clearTranslationCache } from '../../i18n/index.js';
+import { padEndV } from '../../core/text.js';
+let state = { mode: 'menu' };
+function buildMenuField(statusMessage) {
+    const trans = t();
+    const prefs = loadPreferences();
+    const currentLang = getCurrentLanguage();
+    const options = [
+        { value: 'language', label: trans.language.selectLanguage, hint: currentLang === 'zh' ? trans.language.zh : trans.language.en },
+        { value: 'icon', label: trans.theme.iconMode, hint: prefs.iconMode },
+        { value: 'color', label: trans.theme.colorMode, hint: prefs.colorMode },
+        { value: 'reset', label: trans.theme.resetLabel },
+        { value: 'about', label: trans.about.title },
+    ];
+    return { mode: 'menu', statusMessage, menuField: new ListField({ title: trans.theme.chooseAction, options }) };
+}
+function goToMenu(statusMessage) {
+    state = buildMenuField(statusMessage);
+}
+export const settingsView = {
+    id: 'settings',
+    title: t().menu.settings,
+    async load(_ctx) {
+        goToMenu();
+    },
+    render(ctx) {
+        return renderSettings(state, ctx.bodyRows, ctx.size.cols);
+    },
+    capturesInput() {
+        return false;
+    },
+    handleBack() {
+        if (state.mode !== 'menu') {
+            goToMenu();
+            return true;
+        }
+        return false;
+    },
+    handleKey(key, _ctx) {
+        const trans = t();
+        switch (state.mode) {
+            case 'menu': {
+                const result = state.menuField?.handleKey(key);
+                if (!result?.selected)
+                    return;
+                if (result.selected === 'language') {
+                    const currentLang = getCurrentLanguage();
+                    const options = [
+                        { value: 'zh', label: trans.language.zh, hint: currentLang === 'zh' ? trans.common.current : undefined },
+                        { value: 'en', label: trans.language.en, hint: currentLang === 'en' ? trans.common.current : undefined },
+                    ];
+                    state = { mode: 'language', subField: new ListField({ title: trans.language.selectLanguage, options, initialIndex: currentLang === 'en' ? 1 : 0 }) };
+                    return;
+                }
+                if (result.selected === 'icon') {
+                    const prefs = loadPreferences();
+                    const options = [
+                        { value: 'auto', label: trans.theme.modeAuto, hint: prefs.iconMode === 'auto' ? trans.common.current : undefined },
+                        { value: 'ascii', label: trans.theme.modeAscii, hint: prefs.iconMode === 'ascii' ? trans.common.current : undefined },
+                        { value: 'unicode', label: trans.theme.modeUnicode, hint: prefs.iconMode === 'unicode' ? trans.common.current : undefined },
+                    ];
+                    const idx = Math.max(0, options.findIndex((o) => o.value === prefs.iconMode));
+                    state = { mode: 'icon', subField: new ListField({ title: trans.theme.chooseIconMode, options, initialIndex: idx }) };
+                    return;
+                }
+                if (result.selected === 'color') {
+                    const prefs = loadPreferences();
+                    const options = [
+                        { value: 'auto', label: trans.theme.modeAuto, hint: prefs.colorMode === 'auto' ? trans.common.current : undefined },
+                        { value: 'on', label: trans.theme.modeOn, hint: prefs.colorMode === 'on' ? trans.common.current : undefined },
+                        { value: 'off', label: trans.theme.modeOff, hint: prefs.colorMode === 'off' ? trans.common.current : undefined },
+                    ];
+                    const idx = Math.max(0, options.findIndex((o) => o.value === prefs.colorMode));
+                    state = { mode: 'color', subField: new ListField({ title: trans.theme.chooseColorMode, options, initialIndex: idx }) };
+                    return;
+                }
+                if (result.selected === 'reset') {
+                    const saved = resetPreferences();
+                    resetIconCache();
+                    applyColorModePreference(false);
+                    goToMenu(saved ? trans.theme.reset : trans.theme.resetSessionOnly);
+                    return;
+                }
+                if (result.selected === 'about') {
+                    const pad = 12;
+                    const row = (label, value) => `${padEndV(label, pad)}${value}`;
+                    state = {
+                        mode: 'about',
+                        aboutLines: [
+                            row(trans.about.project, APP_INFO.name),
+                            row(trans.about.version, `v${APP_INFO.version}`),
+                            row(trans.about.description, trans.about.descriptionText),
+                            '',
+                            row(trans.about.github, APP_INFO.repository),
+                            row(trans.about.website, URLS.homepage),
+                            row(trans.about.email, URLS.email),
+                            '',
+                            row(trans.about.license, `MIT  ${pickIcon('·', '-')}  ${trans.about.author}: m1ngsama`),
+                        ],
+                        backField: new ListField({ title: trans.about.title, options: [{ value: '__back__', label: trans.common.back }] }),
+                    };
+                }
+                return;
+            }
+            case 'language': {
+                const result = state.subField?.handleKey(key);
+                if (!result?.selected)
+                    return;
+                const currentLang = getCurrentLanguage();
+                if (result.selected !== currentLang) {
+                    const saved = setLanguage(result.selected);
+                    clearTranslationCache();
+                    goToMenu(saved ? t().language.changed : t().language.changedSessionOnly);
+                }
+                else {
+                    goToMenu();
+                }
+                return;
+            }
+            case 'icon': {
+                const result = state.subField?.handleKey(key);
+                if (!result?.selected)
+                    return;
+                const saved = setIconMode(result.selected);
+                resetIconCache();
+                goToMenu(saved ? trans.theme.updated : trans.theme.updatedSessionOnly);
+                return;
+            }
+            case 'color': {
+                const result = state.subField?.handleKey(key);
+                if (!result?.selected)
+                    return;
+                const saved = setColorMode(result.selected);
+                applyColorModePreference(false);
+                goToMenu(saved ? trans.theme.updated : trans.theme.updatedSessionOnly);
+                return;
+            }
+            case 'about': {
+                const result = state.backField?.handleKey(key);
+                if (result?.selected === '__back__')
+                    goToMenu();
+                return;
+            }
+            default:
+                return;
+        }
+    },
+};