inup 1.5.4 → 1.5.6

package/dist/ui/controllers/package-info-modal-controller.js

@@ -38,12 +38,10 @@ const semver = __importStar(require("semver"));
 const services_1 = require("../../services");
 const RELEASE_NOTES_LOAD_DEBOUNCE_MS = 120;
 class PackageInfoModalController {
-    constructor() {
-        this.abortController = null;
-        this.pendingReleaseNotesVersion = null;
-        this.releaseNotesDebounceTimer = null;
-        this.resolveDebouncedLoad = null;
-    }
+    abortController = null;
+    pendingReleaseNotesVersion = null;
+    releaseNotesDebounceTimer = null;
+    resolveDebouncedLoad = null;
     /**
      * Cancel any in-flight hydrate/release-notes fetches.
      * Safe to call multiple times or when nothing is in flight.
@@ -68,32 +66,11 @@ class PackageInfoModalController {
         if (!metadata) {
             return null;
         }
-        const result = {
-            description: metadata.description,
-            homepage: metadata.homepage,
-            repository: metadata.releaseNotes,
-            weeklyDownloads: metadata.weeklyDownloads,
-            author: metadata.author,
-            license: metadata.license,
-        };
-        state.description = result.description;
-        state.homepage = result.homepage;
-        state.repository = result.repository;
-        state.weeklyDownloads = result.weeklyDownloads;
-        state.author = result.author;
-        state.license = result.license;
         // Compute the version range for release notes
         const targetVersion = state.selectedOption === 'range' ? state.rangeVersion : state.latestVersion;
-        if (state.allVersions && state.allVersions.length > 0) {
-            state.releaseNotesVersions = this.buildReleaseNotesVersionQueue(state.allVersions, state.currentVersion, targetVersion);
-        }
-        else {
-            // No allVersions available — just show the target version
-            state.releaseNotesVersions = [targetVersion];
-        }
-        state.releaseNotesLoaded = new Map();
-        state.releaseNotesViewIndex = 0;
-        state.releaseNotesLoadingVersion = undefined;
+        const releaseNotesVersions = state.allVersions && state.allVersions.length > 0
+            ? this.buildReleaseNotesVersionQueue(state.allVersions, state.currentVersion, targetVersion)
+            : [targetVersion];
         this.pendingReleaseNotesVersion = null;
         if (this.releaseNotesDebounceTimer) {
             clearTimeout(this.releaseNotesDebounceTimer);
@@ -101,7 +78,21 @@ class PackageInfoModalController {
         }
         this.resolveDebouncedLoad?.(false);
         this.resolveDebouncedLoad = null;
-        return result;
+        return {
+            name: state.name,
+            patch: {
+                description: metadata.description,
+                homepage: metadata.homepage,
+                repository: metadata.releaseNotes,
+                weeklyDownloads: metadata.weeklyDownloads,
+                author: metadata.author,
+                license: metadata.license,
+                releaseNotesVersions,
+                releaseNotesLoaded: new Map(),
+                releaseNotesViewIndex: 0,
+                releaseNotesLoadingVersion: undefined,
+            },
+        };
     }
     /**
      * Load release notes for a specific version by index.

package/dist/ui/controllers/vulnerability-audit-controller.js

@@ -4,11 +4,9 @@ exports.VulnerabilityAuditController = void 0;
 const services_1 = require("../../services");
 const vulnerability_1 = require("../presenters/vulnerability");
 class VulnerabilityAuditController {
-    constructor() {
-        this.tracker = new services_1.BackgroundAuditTracker();
-        this.cache = new Map();
-        this.drainPromise = null;
-    }
+    tracker = new services_1.BackgroundAuditTracker();
+    cache = new Map();
+    drainPromise = null;
     getCachedSummary(packageName, currentVersionSpecifier, type) {
         return this.cache.get(this.getCacheKey(packageName, currentVersionSpecifier, type));
     }
@@ -25,16 +23,18 @@ class VulnerabilityAuditController {
             this.drain(selectionStates, onUpdate);
         }
     }
-    drain(selectionStates, onUpdate) {
+    async drain(selectionStates, onUpdate) {
         if (this.drainPromise) {
-            return;
+            return [];
         }
+        const allUpdates = [];
         this.drainPromise = (async () => {
             while (true) {
                 const batch = this.tracker.reserveNextBatch(20);
                 if (batch.packageNames.length === 0) {
                     break;
                 }
+                const batchUpdates = [];
                 try {
                     const vulnerabilityData = await (0, services_1.fetchVulnerabilities)(batch.packages);
                     const batchNames = new Set(batch.packageNames);
@@ -55,8 +55,8 @@ class VulnerabilityAuditController {
                             url: item.url,
                         })), vulnerability.highestSeverity);
                         const merged = (0, vulnerability_1.mergeVulnerabilitySummary)(state.vulnerability, summary);
-                        state.vulnerability = merged;
                         this.cache.set(this.getCacheKey(state.name, state.currentVersionSpecifier, state.type), merged);
+                        batchUpdates.push({ name: state.name, patch: { vulnerability: merged } });
                     }
                 }
                 catch {
@@ -64,6 +64,13 @@ class VulnerabilityAuditController {
                 }
                 finally {
                     this.tracker.markCompleted(batch.packageNames);
+                    for (const update of batchUpdates) {
+                        for (const state of selectionStates) {
+                            if (state.name === update.name)
+                                Object.assign(state, update.patch);
+                        }
+                    }
+                    allUpdates.push(...batchUpdates);
                     onUpdate?.();
                 }
             }
@@ -73,6 +80,8 @@ class VulnerabilityAuditController {
                 this.drain(selectionStates, onUpdate);
             }
         });
+        await this.drainPromise;
+        return allUpdates;
     }
     getCacheKey(packageName, currentVersionSpecifier, type) {
         return `${packageName}@${currentVersionSpecifier}@${type}`;

package/dist/ui/index.js

@@ -21,4 +21,7 @@ __exportStar(require("./modal"), exports);
 __exportStar(require("./presenters"), exports);
 __exportStar(require("./controllers"), exports);
 __exportStar(require("./input-handler"), exports);
+__exportStar(require("./keymap"), exports);
+__exportStar(require("./themes"), exports);
+__exportStar(require("./themes-colors"), exports);
 //# sourceMappingURL=index.js.map

package/dist/ui/input-handler.js

@@ -2,7 +2,14 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ConfirmationInputHandler = exports.InputHandler = void 0;
 const utils_1 = require("./utils");
+const keymap_1 = require("./keymap");
 class InputHandler {
+    stateManager;
+    onAction;
+    onConfirm;
+    // Must synchronously release terminal state (alt screen, raw mode, cursor) —
+    // it runs immediately before process.exit(0) on Ctrl+C, with no chance to await.
+    onCancel;
     constructor(stateManager, onAction, onConfirm, onCancel) {
         this.stateManager = stateManager;
         this.onAction = onAction;
@@ -15,7 +22,7 @@ class InputHandler {
             return;
         }
         if (key && key.ctrl && key.name === 'c') {
-            utils_1.CursorUtils.show();
+            this.onCancel();
             process.exit(0);
         }
         const uiState = this.stateManager.getUIState();
@@ -70,6 +77,24 @@ class InputHandler {
             }
             return;
         }
+        // Handle help overlay input (close or scroll)
+        if (uiState.showHelpModal) {
+            if (str === '?' || (key && key.name === 'escape')) {
+                this.onAction({ type: 'toggle_help_modal' });
+                return;
+            }
+            if (key) {
+                if (key.name === 'up') {
+                    this.onAction({ type: 'scroll_help_modal_up' });
+                    return;
+                }
+                if (key.name === 'down') {
+                    this.onAction({ type: 'scroll_help_modal_down' });
+                    return;
+                }
+            }
+            return; // consume all other keys while help is open
+        }
         // Handle info modal input (scroll and close)
         if (uiState.showInfoModal) {
             if (key) {
@@ -111,6 +136,11 @@ class InputHandler {
             this.onAction({ type: 'toggle_debug_modal' });
             return;
         }
+        // '?' opens the help overlay (outside of filter mode)
+        if (str === '?' && !uiState.filterMode) {
+            this.onAction({ type: 'toggle_help_modal' });
+            return;
+        }
         // Check for '/' character to handle filter mode (only when not in modal)
         if (str === '/') {
             if (uiState.filterMode) {
@@ -169,84 +199,36 @@ class InputHandler {
             }
             return;
         }
-        // Normal mode (not in filter mode)
-        if (!key) {
+        // Normal mode (not in filter mode). Keys resolve through the keymap so that
+        // dispatch, the help overlay, the footer, and the README share one source.
+        if (!key || !key.name) {
             return;
         }
-        switch (key.name) {
-            case 'up':
-                this.onAction({ type: 'navigate_up' });
-                break;
-            case 'down':
-                this.onAction({ type: 'navigate_down' });
-                break;
-            case 'left':
-                this.onAction({ type: 'select_left' });
-                break;
-            case 'right':
-                this.onAction({ type: 'select_right' });
-                break;
-            case 'return':
-                // Check if any packages are selected
-                const selectedCount = states.filter((s) => s.loadState === 'ready' && s.selectedOption !== 'none').length;
-                if (selectedCount === 0) {
-                    // Do nothing if no packages selected
-                    return;
-                }
-                this.cleanup();
-                this.onConfirm(states);
+        // Enter confirms the selection (guarding against an empty selection). It runs
+        // the cleanup/confirm path directly rather than going through onAction.
+        if (key.name === 'return') {
+            const selectedCount = states.filter((s) => s.loadState === 'ready' && s.selectedOption !== 'none').length;
+            if (selectedCount === 0) {
+                this.onAction({ type: 'notify_empty_selection' });
                 return;
-            case 'm':
-            case 'M':
-                this.onAction({ type: 'bulk_select_minor' });
-                break;
-            case 'l':
-            case 'L':
-                this.onAction({ type: 'bulk_select_latest' });
-                break;
-            case 'u':
-            case 'U':
-                this.onAction({ type: 'bulk_unselect_all' });
-                break;
-            case 'd':
-            case 'D':
-                if (!uiState.showThemeModal && !uiState.filterMode) {
-                    this.onAction({ type: 'toggle_dep_type_filter', depType: 'devDependencies' });
-                }
-                break;
-            case 'p':
-            case 'P':
-                if (!uiState.showThemeModal && !uiState.filterMode) {
-                    this.onAction({ type: 'toggle_dep_type_filter', depType: 'peerDependencies' });
-                }
-                break;
-            case 'o':
-            case 'O':
-                if (!uiState.showThemeModal && !uiState.filterMode) {
-                    this.onAction({ type: 'toggle_dep_type_filter', depType: 'optionalDependencies' });
-                }
-                break;
-            case 'i':
-            case 'I':
-                this.onAction({ type: 'toggle_info_modal' });
-                break;
-            case 's':
-            case 'S':
-                if (!uiState.showThemeModal) {
-                    this.onAction({ type: 'trigger_audit_scan' });
-                }
-                break;
-            case 't':
-            case 'T':
-                this.onAction({ type: 'toggle_theme_modal' });
-                break;
-            case 'escape':
-                if (uiState.filterQuery) {
-                    // Clear filter if one is applied
-                    this.onAction({ type: 'exit_filter_mode', clearQuery: true });
-                }
-                // Otherwise do nothing - Escape no longer exits the CLI
-                break;
+            }
+            this.cleanup();
+            this.onConfirm(states);
+            return;
+        }
+        // Escape clears an active search filter; otherwise it is a no-op (it no
+        // longer exits the CLI).
+        if (key.name === 'escape') {
+            if (uiState.filterQuery) {
+                this.onAction({ type: 'exit_filter_mode', clearQuery: true });
+            }
+            return;
+        }
+        // Shifted letters become uppercase tokens so the vim pair g/G stays distinct.
+        const token = key.shift && /^[a-z]$/.test(key.name) ? key.name.toUpperCase() : key.name;
+        const binding = (0, keymap_1.findBinding)(token);
+        if (binding?.action) {
+            this.onAction(binding.action);
         }
     }
     handleResize(height) {
@@ -258,6 +240,7 @@ class InputHandler {
 }
 exports.InputHandler = InputHandler;
 class ConfirmationInputHandler {
+    onConfirm;
     constructor(onConfirm) {
         this.onConfirm = onConfirm;
     }
@@ -267,7 +250,9 @@ class ConfirmationInputHandler {
             return;
         }
         if (key && key.ctrl && key.name === 'c') {
-            utils_1.CursorUtils.show();
+            // onConfirm runs the normal cleanup path (cursor show, raw-mode off, listener
+            // removal). The 'exit' listener registered by confirmUpgrade is a final backstop.
+            this.onConfirm(false);
             process.exit(0);
         }
         if (!key) {

package/dist/ui/keymap.js

@@ -0,0 +1,208 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KEY_BINDINGS = exports.KEY_GROUPS = void 0;
+exports.findBinding = findBinding;
+exports.getFooterHints = getFooterHints;
+exports.getHelpGroups = getHelpGroups;
+exports.renderReadmeKeyTable = renderReadmeKeyTable;
+/** Group display order for the help overlay and README. */
+exports.KEY_GROUPS = ['Navigation', 'Selection', 'Filtering', 'View'];
+exports.KEY_BINDINGS = [
+    // Navigation
+    {
+        tokens: ['up', 'k'],
+        action: { type: 'navigate_up' },
+        displayKeys: '↑ / k',
+        help: 'Move up',
+        group: 'Navigation',
+        footer: { keyLabel: '↑/↓', label: 'Move' },
+    },
+    {
+        tokens: ['down', 'j'],
+        action: { type: 'navigate_down' },
+        displayKeys: '↓ / j',
+        help: 'Move down',
+        group: 'Navigation',
+    },
+    {
+        tokens: ['g'],
+        action: { type: 'navigate_top' },
+        displayKeys: 'g',
+        help: 'Jump to the first package',
+        group: 'Navigation',
+    },
+    {
+        tokens: ['G'],
+        action: { type: 'navigate_bottom' },
+        displayKeys: 'G',
+        help: 'Jump to the last package',
+        group: 'Navigation',
+    },
+    // Selection
+    {
+        tokens: ['left'],
+        action: { type: 'select_left' },
+        displayKeys: '←',
+        help: 'Cycle selection left (none → range → latest)',
+        group: 'Selection',
+        footer: { keyLabel: '←/→', label: 'Select' },
+    },
+    {
+        tokens: ['right'],
+        action: { type: 'select_right' },
+        displayKeys: '→',
+        help: 'Cycle selection right (none → range → latest)',
+        group: 'Selection',
+    },
+    {
+        tokens: ['space'],
+        action: { type: 'toggle_selection' },
+        displayKeys: 'Space',
+        help: 'Toggle the current package on/off',
+        group: 'Selection',
+    },
+    {
+        tokens: ['m'],
+        action: { type: 'bulk_select_minor' },
+        displayKeys: 'm',
+        help: 'Select all minor/patch updates',
+        group: 'Selection',
+        footer: { keyLabel: 'M', label: 'Minor' },
+    },
+    {
+        tokens: ['l'],
+        action: { type: 'bulk_select_latest' },
+        displayKeys: 'l',
+        help: 'Select all latest updates (including major)',
+        group: 'Selection',
+        footer: { keyLabel: 'L', label: 'All' },
+    },
+    {
+        tokens: ['u'],
+        action: { type: 'bulk_unselect_all' },
+        displayKeys: 'u',
+        help: 'Unselect all packages',
+        group: 'Selection',
+        footer: { keyLabel: 'U', label: 'None' },
+    },
+    {
+        displayKeys: 'Enter',
+        help: 'Confirm selection and upgrade',
+        group: 'Selection',
+    },
+    // Filtering
+    {
+        displayKeys: '/',
+        help: 'Search packages by name',
+        group: 'Filtering',
+        footer: { keyLabel: '/', label: 'Search' },
+    },
+    {
+        tokens: ['d'],
+        action: { type: 'toggle_dep_type_filter', depType: 'devDependencies' },
+        displayKeys: 'd',
+        help: 'Toggle devDependencies',
+        group: 'Filtering',
+        footer: { keyLabel: 'D/P/O', label: 'Filter' },
+    },
+    {
+        tokens: ['p'],
+        action: { type: 'toggle_dep_type_filter', depType: 'peerDependencies' },
+        displayKeys: 'p',
+        help: 'Toggle peerDependencies',
+        group: 'Filtering',
+    },
+    {
+        tokens: ['o'],
+        action: { type: 'toggle_dep_type_filter', depType: 'optionalDependencies' },
+        displayKeys: 'o',
+        help: 'Toggle optionalDependencies',
+        group: 'Filtering',
+    },
+    {
+        tokens: ['s'],
+        action: { type: 'trigger_audit_scan' },
+        displayKeys: 's',
+        help: 'Run the vulnerability audit',
+        group: 'Filtering',
+        footer: { keyLabel: 'S', label: 'Audit' },
+    },
+    {
+        tokens: ['v'],
+        action: { type: 'toggle_vulnerable_filter' },
+        displayKeys: 'v',
+        help: 'Show only vulnerable packages',
+        group: 'Filtering',
+    },
+    {
+        displayKeys: 'Esc',
+        help: 'Clear the active search filter',
+        group: 'Filtering',
+    },
+    // View
+    {
+        tokens: ['i'],
+        action: { type: 'toggle_info_modal' },
+        displayKeys: 'i',
+        help: 'View package details and changelog',
+        group: 'View',
+        footer: { keyLabel: 'I', label: 'Info' },
+    },
+    {
+        tokens: ['t'],
+        action: { type: 'toggle_theme_modal' },
+        displayKeys: 't',
+        help: 'Change the color theme',
+        group: 'View',
+    },
+    {
+        displayKeys: '?',
+        help: 'Show this help',
+        group: 'View',
+        footer: { keyLabel: '?', label: 'Help' },
+    },
+    {
+        displayKeys: '!',
+        help: 'Show the performance/debug panel',
+        group: 'View',
+    },
+];
+/**
+ * Resolve a pressed key token to its binding. Tries an exact match first so the
+ * case-sensitive vim pair `g`/`G` is honored, then falls back to the lowercase
+ * letter so shifted letters (e.g. `M`) still trigger their lowercase binding.
+ */
+function findBinding(token) {
+    const exact = exports.KEY_BINDINGS.find((binding) => binding.tokens?.includes(token));
+    if (exact)
+        return exact;
+    if (/^[A-Z]$/.test(token)) {
+        const lower = token.toLowerCase();
+        return exports.KEY_BINDINGS.find((binding) => binding.tokens?.includes(lower));
+    }
+    return undefined;
+}
+// Computed once at module load — KEY_BINDINGS is static so these never change.
+const _footerHints = exports.KEY_BINDINGS.flatMap((binding) => binding.footer ? [binding.footer] : []);
+const _helpGroups = exports.KEY_GROUPS.map((group) => ({
+    group,
+    bindings: exports.KEY_BINDINGS.filter((b) => b.group === group),
+})).filter((entry) => entry.bindings.length > 0);
+/** Curated short hints for the compact footer line, in display order. */
+function getFooterHints() {
+    return _footerHints;
+}
+/** Bindings grouped for the `?` help overlay, preserving {@link KEY_GROUPS} order. */
+function getHelpGroups() {
+    return _helpGroups;
+}
+/**
+ * Render the README "Keyboard Shortcuts" markdown table from the keymap. This is
+ * the body placed between the `<!-- KEYS:START -->`/`<!-- KEYS:END -->` markers;
+ * a test fails if the README drifts from it (see keymap-readme.test.ts).
+ */
+function renderReadmeKeyTable() {
+    const rows = exports.KEY_BINDINGS.map((binding) => `| \`${binding.displayKeys}\` | ${binding.help} |`);
+    return ['| Key | Action |', '|-----|--------|', ...rows].join('\n');
+}
+//# sourceMappingURL=keymap.js.map