inup 1.5.5 → 1.6.0

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;
@@ -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;
     }

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

package/dist/ui/modal/package-info-sections/release-notes.js

@@ -0,0 +1,161 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildReleaseNotesSections = buildReleaseNotesSections;
+const chalk_1 = __importDefault(require("chalk"));
+const themes_colors_1 = require("../../themes-colors");
+const text_1 = require("./text");
+function formatReleaseNotesMarkdown(markdown, width, repositoryUrl) {
+    const lines = [];
+    const rawLines = markdown.split('\n');
+    let prevBlank = false;
+    for (const rawLine of rawLines) {
+        const trimmed = rawLine.trim();
+        if (trimmed === '') {
+            if (!prevBlank && lines.length > 0) {
+                lines.push('');
+                prevBlank = true;
+            }
+            continue;
+        }
+        prevBlank = false;
+        if (/^```/.test(trimmed) || /^---+$/.test(trimmed)) {
+            continue;
+        }
+        const cleaned = (0, text_1.sanitizeMarkdownText)(trimmed);
+        if (!cleaned) {
+            continue;
+        }
+        const quoteMatch = trimmed.match(/^>\s*(.+)/);
+        if (quoteMatch) {
+            const quoteBody = (0, text_1.linkifyMarkdownText)((0, text_1.sanitizeMarkdownText)(quoteMatch[1]), repositoryUrl);
+            const admonitionMatch = quoteBody.match(/^\[!([A-Z]+)\]$/i);
+            if (admonitionMatch) {
+                const label = `${admonitionMatch[1][0]}${admonitionMatch[1].slice(1).toLowerCase()}`;
+                if (lines.length > 0 && lines[lines.length - 1] !== '') {
+                    lines.push('');
+                }
+                lines.push(chalk_1.default.blue.bold(`  ${label}`));
+            }
+            else {
+                (0, text_1.pushWrappedLines)(lines, quoteBody, width, '  ', '  ', chalk_1.default.gray);
+            }
+            continue;
+        }
+        const headerMatch = cleaned.match(/^(#{1,6})\s+(.+)/);
+        if (headerMatch) {
+            const title = (0, text_1.sanitizeMarkdownText)(headerMatch[2]);
+            const lower = title.toLowerCase();
+            let style = chalk_1.default.white.bold;
+            if (lower.includes('breaking')) {
+                style = chalk_1.default.red.bold;
+            }
+            else if (lower.includes('feature') ||
+                lower.includes('added') ||
+                lower.includes('improvement')) {
+                style = chalk_1.default.green.bold;
+            }
+            else if (lower.includes('fix') || lower.includes('bug')) {
+                style = chalk_1.default.yellow.bold;
+            }
+            else if (lower.includes('deprecat')) {
+                style = chalk_1.default.magenta.bold;
+            }
+            if (lines.length > 0 && lines[lines.length - 1] !== '') {
+                lines.push('');
+            }
+            lines.push(style(`  ${title}`));
+            continue;
+        }
+        const bulletMatch = cleaned.match(/^(\s*)[*-]\s+(.+)/);
+        if (bulletMatch) {
+            const indentLevel = Math.min(2, Math.floor(bulletMatch[1].length / 2));
+            const prefix = `  ${'  '.repeat(indentLevel)}${chalk_1.default.gray('•')} `;
+            const restPrefix = `  ${'  '.repeat(indentLevel + 1)}`;
+            const style = /breaking/i.test(bulletMatch[2]) ? chalk_1.default.red : undefined;
+            (0, text_1.pushWrappedLines)(lines, (0, text_1.linkifyMarkdownText)((0, text_1.sanitizeMarkdownText)(bulletMatch[2]), repositoryUrl), width, prefix, restPrefix, style);
+            continue;
+        }
+        const orderedMatch = cleaned.match(/^(\s*)(\d+)\.\s+(.+)/);
+        if (orderedMatch) {
+            const indentLevel = Math.min(2, Math.floor(orderedMatch[1].length / 2));
+            const marker = `${orderedMatch[2]}.`;
+            const prefix = `  ${'  '.repeat(indentLevel)}${marker} `;
+            const restPrefix = `  ${'  '.repeat(indentLevel)}${' '.repeat(marker.length + 1)}`;
+            (0, text_1.pushWrappedLines)(lines, (0, text_1.linkifyMarkdownText)((0, text_1.sanitizeMarkdownText)(orderedMatch[3]), repositoryUrl), width, prefix, restPrefix);
+            continue;
+        }
+        const style = (0, text_1.isLowSignalTrailerLine)(cleaned) ? chalk_1.default.gray : undefined;
+        (0, text_1.pushWrappedLines)(lines, (0, text_1.linkifyMarkdownText)(cleaned, repositoryUrl), width, '  ', '  ', style);
+    }
+    while (lines.length > 0 && lines[lines.length - 1] === '') {
+        lines.pop();
+    }
+    return lines;
+}
+function buildReleaseNotesSections(state, modalWidth) {
+    const sections = [];
+    if (!state.releaseNotesVersions || state.releaseNotesVersions.length === 0) {
+        return sections;
+    }
+    const loaded = state.releaseNotesLoaded;
+    const viewIndex = state.releaseNotesViewIndex ?? 0;
+    const totalVersions = state.releaseNotesVersions.length;
+    const currentVersion = state.releaseNotesVersions[viewIndex];
+    if (!currentVersion)
+        return sections;
+    if (state.releaseNotesLoadingVersion === currentVersion) {
+        sections.push({
+            key: 'release-loading',
+            rows: [chalk_1.default.gray(`Loading release notes for v${currentVersion}...`)],
+            behavior: 'status',
+        });
+        return sections;
+    }
+    if (!loaded || !loaded.has(currentVersion)) {
+        sections.push({
+            key: 'release-pending',
+            rows: [chalk_1.default.gray(`Press ←/→ to load release notes for v${currentVersion}`)],
+            behavior: 'status',
+        });
+        return sections;
+    }
+    const content = loaded.get(currentVersion);
+    if (!content) {
+        sections.push({
+            key: 'release-none',
+            rows: [chalk_1.default.gray.italic(`No release notes found for v${currentVersion}`)],
+            behavior: 'status',
+        });
+    }
+    else {
+        const versionHeader = (0, themes_colors_1.getThemeColor)('primary')(`Version ${currentVersion}`);
+        const navHint = totalVersions > 1 ? chalk_1.default.gray(` (${viewIndex + 1}/${totalVersions})`) : '';
+        const rows = [chalk_1.default.bold(versionHeader) + navHint];
+        const formatted = formatReleaseNotesMarkdown(content, modalWidth - 4, state.repository);
+        rows.push(...formatted);
+        sections.push({
+            key: `release-${currentVersion}`,
+            rows,
+            behavior: 'body',
+        });
+    }
+    const canGoNewer = viewIndex > 0;
+    const canGoOlder = viewIndex < totalVersions - 1;
+    if (canGoNewer || canGoOlder) {
+        const hints = [];
+        if (canGoNewer)
+            hints.push('← newer');
+        if (canGoOlder)
+            hints.push('→ older');
+        sections.push({
+            key: 'release-nav',
+            rows: [chalk_1.default.gray(hints.join('  ·  '))],
+            behavior: 'status',
+        });
+    }
+    return sections;
+}
+//# sourceMappingURL=release-notes.js.map