inup 1.5.4 → 1.5.6

package/dist/ui/session/action-dispatcher.js

@@ -0,0 +1,233 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dispatchAction = dispatchAction;
+const themes_1 = require("../themes");
+const INTERACTIVE_ACTIONS = new Set([
+    'navigate_up',
+    'navigate_down',
+    'navigate_top',
+    'navigate_bottom',
+    'select_left',
+    'select_right',
+    'toggle_selection',
+    'bulk_select_minor',
+    'bulk_select_latest',
+    'bulk_unselect_all',
+    'toggle_dep_type_filter',
+    'toggle_vulnerable_filter',
+]);
+function dispatchAction(action, ctx) {
+    const { stateManager, states, vulnerabilityDisplayOptions, packageInfoModalController, vulnerabilityAuditController, isResolved, renderInterface, handleCancel, getInfoModalMaxScrollOffset, getDebugModalMaxScrollOffset, getHelpModalMaxScrollOffset, } = ctx;
+    const uiState = stateManager.getUIState();
+    const filteredStates = stateManager.getFilteredStates(states, vulnerabilityDisplayOptions);
+    // Any deliberate action clears a one-shot status notice (except the action that sets it).
+    if (action.type !== 'notify_empty_selection') {
+        stateManager.clearNotice();
+    }
+    if (uiState.showThemeModal && INTERACTIVE_ACTIONS.has(action.type))
+        return;
+    // Shared by `s` (audit) and `v` (vulnerable filter): run the scan if we have no
+    // data yet, otherwise toggle the vulnerable-only filter.
+    const auditOrToggleVulnerable = () => {
+        const auditProgress = vulnerabilityAuditController.getProgress();
+        if (auditProgress.hasData) {
+            stateManager.toggleVulnerableFilter();
+        }
+        else if (!auditProgress.isRunning) {
+            vulnerabilityAuditController.enqueueStates(states, () => {
+                if (!isResolved())
+                    renderInterface();
+            });
+        }
+    };
+    switch (action.type) {
+        case 'navigate_up':
+            stateManager.navigateUp(filteredStates.length);
+            break;
+        case 'navigate_down':
+            stateManager.navigateDown(filteredStates.length);
+            break;
+        case 'navigate_top':
+            stateManager.navigateTop(filteredStates.length);
+            break;
+        case 'navigate_bottom':
+            stateManager.navigateBottom(filteredStates.length);
+            break;
+        case 'select_left':
+            stateManager.updateSelection(filteredStates, 'left');
+            break;
+        case 'select_right':
+            stateManager.updateSelection(filteredStates, 'right');
+            break;
+        case 'toggle_selection':
+            stateManager.toggleSelection(filteredStates);
+            break;
+        case 'notify_empty_selection':
+            stateManager.setNotice('Nothing selected — use ←/→ or Space to choose updates, then Enter');
+            break;
+        case 'bulk_select_minor':
+            stateManager.bulkSelectMinor(filteredStates);
+            break;
+        case 'bulk_select_latest':
+            stateManager.bulkSelectLatest(filteredStates);
+            break;
+        case 'bulk_unselect_all':
+            stateManager.bulkUnselectAll(filteredStates);
+            break;
+        case 'toggle_dep_type_filter':
+            stateManager.toggleDependencyTypeFilter(action.depType);
+            break;
+        case 'toggle_info_modal':
+            if (!uiState.showInfoModal) {
+                const modalSessionId = stateManager.toggleInfoModal();
+                const currentState = filteredStates[uiState.currentRow];
+                const canFetchMetadata = currentState?.loadState === 'ready';
+                stateManager.setModalLoading(canFetchMetadata, modalSessionId);
+                renderInterface();
+                if (currentState && canFetchMetadata) {
+                    packageInfoModalController
+                        .hydrate(currentState)
+                        .then((update) => {
+                        if (isResolved() || stateManager.getInfoModalSessionId() !== modalSessionId)
+                            return;
+                        if (update)
+                            Object.assign(currentState, update.patch);
+                        stateManager.setModalLoading(false, modalSessionId);
+                        renderInterface();
+                        if (stateManager.getInfoModalSessionId() === modalSessionId &&
+                            packageInfoModalController.getVersionCount(currentState) > 0) {
+                            packageInfoModalController.loadVersionAtIndex(currentState, 0, () => {
+                                if (!isResolved())
+                                    renderInterface();
+                            });
+                        }
+                    })
+                        .catch(() => {
+                        if (isResolved() || stateManager.getInfoModalSessionId() !== modalSessionId)
+                            return;
+                        stateManager.setModalLoading(false, modalSessionId);
+                        renderInterface();
+                    });
+                }
+            }
+            else {
+                packageInfoModalController.cancel();
+                stateManager.toggleInfoModal();
+                renderInterface();
+            }
+            return;
+        case 'scroll_info_modal_up':
+            if (!stateManager.scrollInfoModalUp())
+                return;
+            break;
+        case 'scroll_info_modal_down':
+            if (!stateManager.scrollInfoModalDown(getInfoModalMaxScrollOffset()))
+                return;
+            break;
+        case 'toggle_debug_modal':
+            stateManager.toggleDebugModal();
+            break;
+        case 'toggle_help_modal':
+            stateManager.toggleHelpModal();
+            break;
+        case 'scroll_help_modal_up':
+            if (!stateManager.scrollHelpModalUp())
+                return;
+            break;
+        case 'scroll_help_modal_down':
+            if (!stateManager.scrollHelpModalDown(getHelpModalMaxScrollOffset()))
+                return;
+            break;
+        case 'scroll_debug_modal_up':
+            if (!stateManager.scrollDebugModalUp())
+                return;
+            break;
+        case 'scroll_debug_modal_down':
+            if (!stateManager.scrollDebugModalDown(getDebugModalMaxScrollOffset()))
+                return;
+            break;
+        case 'switch_info_modal_tab': {
+            const nextTab = stateManager.getInfoModalTab() === 'info' ? 'usedBy' : 'info';
+            stateManager.setInfoModalTab(nextTab);
+            break;
+        }
+        case 'navigate_info_modal_version': {
+            if (uiState.infoModalRow >= 0 && uiState.infoModalRow < filteredStates.length) {
+                const currentState = filteredStates[uiState.infoModalRow];
+                const newIndex = packageInfoModalController.navigateVersion(currentState, action.direction);
+                if (newIndex >= 0) {
+                    stateManager.resetInfoModalScroll();
+                    if (!packageInfoModalController.isVersionLoaded(currentState, newIndex)) {
+                        packageInfoModalController.loadVersionAtIndex(currentState, newIndex, () => {
+                            if (!isResolved())
+                                renderInterface();
+                        });
+                    }
+                }
+                else {
+                    return;
+                }
+            }
+            else {
+                return;
+            }
+            break;
+        }
+        case 'enter_filter_mode':
+            stateManager.enterFilterMode(action.preserveQuery);
+            break;
+        case 'exit_filter_mode':
+            stateManager.exitFilterMode(action.clearQuery);
+            break;
+        case 'filter_input':
+            stateManager.appendToFilterQuery(action.char);
+            break;
+        case 'filter_backspace':
+            stateManager.deleteFromFilterQuery();
+            break;
+        case 'resize': {
+            const heightChanged = stateManager.updateTerminalHeight(action.height);
+            if (heightChanged) {
+                stateManager.resetForResize(filteredStates.length);
+            }
+            else {
+                stateManager.setInitialRender(true);
+            }
+            break;
+        }
+        case 'toggle_theme_modal':
+            stateManager.toggleThemeModal();
+            break;
+        case 'theme_navigate_up': {
+            const themeManager = stateManager.getThemeManager();
+            const currentIndex = themes_1.themeNames.indexOf(themeManager.getPreviewTheme());
+            const themeArray = Object.keys(themes_1.themes);
+            const nextIndex = currentIndex > 0 ? currentIndex - 1 : themeArray.length - 1;
+            stateManager.previewTheme(themeArray[nextIndex]);
+            break;
+        }
+        case 'theme_navigate_down': {
+            const themeManager = stateManager.getThemeManager();
+            const currentIndex = themes_1.themeNames.indexOf(themeManager.getPreviewTheme());
+            const themeArray = Object.keys(themes_1.themes);
+            const nextIndex = currentIndex < themeArray.length - 1 ? currentIndex + 1 : 0;
+            stateManager.previewTheme(themeArray[nextIndex]);
+            break;
+        }
+        case 'theme_confirm':
+            stateManager.confirmTheme();
+            break;
+        case 'trigger_audit_scan':
+            auditOrToggleVulnerable();
+            break;
+        case 'toggle_vulnerable_filter':
+            auditOrToggleVulnerable();
+            break;
+        case 'cancel':
+            packageInfoModalController.cancel();
+            handleCancel();
+            return;
+    }
+    renderInterface();
+}
+//# sourceMappingURL=action-dispatcher.js.map

package/dist/ui/session/index.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dispatchAction = exports.deduplicatePackages = exports.createUpgradeChoices = exports.createPendingSelectionStates = exports.createSelectionStates = exports.runInteractiveSession = void 0;
+var interactive_session_1 = require("./interactive-session");
+Object.defineProperty(exports, "runInteractiveSession", { enumerable: true, get: function () { return interactive_session_1.runInteractiveSession; } });
+var selection_state_builder_1 = require("./selection-state-builder");
+Object.defineProperty(exports, "createSelectionStates", { enumerable: true, get: function () { return selection_state_builder_1.createSelectionStates; } });
+Object.defineProperty(exports, "createPendingSelectionStates", { enumerable: true, get: function () { return selection_state_builder_1.createPendingSelectionStates; } });
+Object.defineProperty(exports, "createUpgradeChoices", { enumerable: true, get: function () { return selection_state_builder_1.createUpgradeChoices; } });
+Object.defineProperty(exports, "deduplicatePackages", { enumerable: true, get: function () { return selection_state_builder_1.deduplicatePackages; } });
+var action_dispatcher_1 = require("./action-dispatcher");
+Object.defineProperty(exports, "dispatchAction", { enumerable: true, get: function () { return action_dispatcher_1.dispatchAction; } });
+//# sourceMappingURL=index.js.map

package/dist/ui/session/interactive-session.js

@@ -0,0 +1,280 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runInteractiveSession = runInteractiveSession;
+const chalk_1 = __importDefault(require("chalk"));
+const index_1 = require("../index");
+const cursor_1 = require("../utils/cursor");
+const themes_colors_1 = require("../themes-colors");
+const debug_1 = require("../../features/debug");
+const help_modal_1 = require("../renderer/help-modal");
+const config_1 = require("../../utils/config");
+const action_dispatcher_1 = require("./action-dispatcher");
+function getTerminalHeight() {
+    if (process.stdout.isTTY && typeof process.stdout.rows === 'number' && process.stdout.rows > 0) {
+        return process.stdout.rows;
+    }
+    return 24;
+}
+async function runInteractiveSession(selectionStates, packageManager, renderer, packageInfoModalController, vulnerabilityAuditController, options, onRefreshViewReady, loadingProgress, attachRefresh) {
+    return new Promise((resolve) => {
+        const states = selectionStates;
+        const stateManager = new index_1.StateManager(0, getTerminalHeight(), config_1.configManager.getFilters() ?? undefined);
+        let isResolved = false;
+        let ownsAlternateScreen = false;
+        const vulnerabilityDisplayOptions = options;
+        let infoModalMaxScrollOffset = 0;
+        let debugModalMaxScrollOffset = 0;
+        let helpModalMaxScrollOffset = 0;
+        let previousViewportMode = null;
+        let previousModalViewportLineCount = null;
+        stateManager.setRenderableItems([]);
+        const claimInteractiveScreen = () => {
+            if (ownsAlternateScreen)
+                return;
+            index_1.ConsoleUtils.clearProgress();
+            index_1.CursorUtils.enterAlternateScreen();
+            index_1.CursorUtils.clearScreen();
+            ownsAlternateScreen = true;
+        };
+        const releaseInteractiveScreen = () => {
+            if (!ownsAlternateScreen)
+                return;
+            index_1.CursorUtils.exitAlternateScreen();
+            ownsAlternateScreen = false;
+        };
+        const resetAnsiPattern = /\x1b\[(?:0|49)m/g;
+        const packageListRenderOptions = {
+            showPeerDependencyVulnerabilities: options.showPeerDependencyVulnerabilities,
+            showOptionalDependencyVulnerabilities: options.showOptionalDependencyVulnerabilities,
+        };
+        const key = (text) => chalk_1.default.bold.white(text);
+        const hint = (text) => chalk_1.default.gray(text);
+        const sep = hint('  ·  ');
+        const SHORTCUTS = {
+            scroll: key('↑/↓ ') + hint('Scroll'),
+            version: key('←/→ ') + hint('Version'),
+            switchTab: key('Tab ') + hint('Switch tab'),
+            closeInfo: key('I / Esc ') + hint('Close'),
+            closeTheme: key('T / Esc ') + hint('Close'),
+            closeHelp: key('? / Esc ') + hint('Close'),
+        };
+        const buildModalHeaderLines = (shortcutLabel) => [
+            '  ' + chalk_1.default.bold('🚀 ') + (0, themes_colors_1.coloredInupLogo)(),
+            '',
+            '  ' + shortcutLabel,
+            '',
+        ];
+        const buildRemainingViewport = (terminalWidth, terminalHeight, usedLines) => {
+            const remainingLines = Math.max(0, terminalHeight - usedLines);
+            const blankLine = ' '.repeat(terminalWidth);
+            return Array.from({ length: remainingLines }, () => blankLine);
+        };
+        const applyBackgroundToLine = (line, bgCode) => `${bgCode}${line.replace(resetAnsiPattern, (match) => `${match}${bgCode}`)}${(0, themes_colors_1.getTerminalResetCode)()}`;
+        const writeFrame = (lines, bgCode) => {
+            if (lines.length === 0)
+                return;
+            process.stdout.write(lines.map((line) => applyBackgroundToLine(line, bgCode)).join('\n'));
+        };
+        const renderViewport = (lines, terminalWidth, terminalHeight, bgCode) => {
+            const viewportLines = [
+                ...lines,
+                ...buildRemainingViewport(terminalWidth, terminalHeight, lines.length),
+            ];
+            writeFrame(viewportLines, bgCode);
+        };
+        const renderModalViewport = (mode, shortcutLabel, modalLines, terminalWidth, terminalHeight, bgCode) => {
+            const viewportLineCount = buildModalHeaderLines(shortcutLabel).length + modalLines.length;
+            const shouldClearBeforeRender = previousViewportMode !== mode || previousModalViewportLineCount !== viewportLineCount;
+            if (shouldClearBeforeRender) {
+                index_1.CursorUtils.clearScreen();
+                index_1.CursorUtils.hide();
+            }
+            renderViewport([...buildModalHeaderLines(shortcutLabel), ...modalLines], terminalWidth, terminalHeight, bgCode);
+            previousViewportMode = mode;
+            previousModalViewportLineCount = viewportLineCount;
+            stateManager.markRendered([]);
+        };
+        const renderInterface = () => {
+            const uiState = stateManager.getUIState();
+            const filteredStates = stateManager.getFilteredStates(states, vulnerabilityDisplayOptions);
+            const auditProgress = vulnerabilityAuditController.getProgress();
+            const bgCode = (0, themes_colors_1.getTerminalBgColorCode)();
+            process.stdout.write(bgCode);
+            if (uiState.forceFullRender) {
+                index_1.CursorUtils.clearScreen();
+                index_1.CursorUtils.hide();
+            }
+            else {
+                index_1.CursorUtils.moveToHome();
+            }
+            if (uiState.showThemeModal) {
+                const terminalWidth = process.stdout.columns || 80;
+                const terminalHeight = getTerminalHeight();
+                const themeManager = stateManager.getThemeManager();
+                const modalLines = renderer.renderThemeSelectorModal(themeManager.getCurrentTheme(), themeManager.getPreviewTheme(), terminalWidth, Math.max(8, terminalHeight - 8));
+                renderModalViewport('theme-modal', SHORTCUTS.closeTheme, modalLines, terminalWidth, terminalHeight, bgCode);
+            }
+            else if (uiState.showHelpModal) {
+                const terminalWidth = process.stdout.columns || 80;
+                const terminalHeight = getTerminalHeight();
+                const result = (0, help_modal_1.renderHelpModal)(terminalWidth, Math.max(8, terminalHeight - 4), uiState.helpModalScrollOffset);
+                helpModalMaxScrollOffset = result.maxScrollOffset;
+                stateManager.clampHelpModalScrollOffset(helpModalMaxScrollOffset);
+                const helpHints = [
+                    result.usesInternalScroll && result.maxScrollOffset > 0 ? SHORTCUTS.scroll : '',
+                    SHORTCUTS.closeHelp,
+                ]
+                    .filter(Boolean)
+                    .join(sep);
+                renderModalViewport('info-modal', helpHints, result.lines, terminalWidth, terminalHeight, bgCode);
+            }
+            else if (uiState.showDebugModal) {
+                const terminalWidth = process.stdout.columns || 80;
+                const terminalHeight = getTerminalHeight();
+                const snapshot = (0, debug_1.getPerformanceTracker)().snapshot();
+                const result = (0, debug_1.renderPerformanceModal)(snapshot, terminalWidth, Math.max(8, terminalHeight - 4), uiState.debugModalScrollOffset);
+                debugModalMaxScrollOffset = result.maxScrollOffset;
+                stateManager.clampDebugModalScrollOffset(debugModalMaxScrollOffset);
+                const debugHints = [
+                    result.usesInternalScroll && result.maxScrollOffset > 0 ? SHORTCUTS.scroll : '',
+                    SHORTCUTS.closeInfo,
+                ]
+                    .filter(Boolean)
+                    .join(sep);
+                renderModalViewport('info-modal', debugHints, result.lines, terminalWidth, terminalHeight, bgCode);
+            }
+            else if (uiState.showInfoModal &&
+                uiState.infoModalRow >= 0 &&
+                uiState.infoModalRow < filteredStates.length) {
+                const selectedState = filteredStates[uiState.infoModalRow];
+                const terminalWidth = process.stdout.columns || 80;
+                const terminalHeight = getTerminalHeight();
+                if (uiState.isLoadingModalInfo) {
+                    const result = renderer.renderPackageInfoLoading(selectedState, terminalWidth, Math.max(8, terminalHeight - 8));
+                    infoModalMaxScrollOffset = result.maxScrollOffset;
+                    renderModalViewport('info-modal', SHORTCUTS.closeInfo, result.lines, terminalWidth, terminalHeight, bgCode);
+                }
+                else {
+                    const activeTab = uiState.infoModalTab;
+                    const result = renderer.renderPackageInfoModal(selectedState, terminalWidth, Math.max(8, terminalHeight - 4), uiState.infoModalScrollOffset, activeTab);
+                    infoModalMaxScrollOffset = result.maxScrollOffset;
+                    stateManager.clampInfoModalScrollOffset(infoModalMaxScrollOffset);
+                    const hints = [
+                        result.usesInternalScroll && result.maxScrollOffset > 0 ? SHORTCUTS.scroll : '',
+                        activeTab === 'info' ? SHORTCUTS.version : '',
+                        SHORTCUTS.switchTab,
+                        SHORTCUTS.closeInfo,
+                    ]
+                        .filter(Boolean)
+                        .join(sep);
+                    renderModalViewport('info-modal', hints, result.lines, terminalWidth, terminalHeight, bgCode);
+                }
+            }
+            else {
+                const terminalWidth = process.stdout.columns || 80;
+                const terminalHeight = getTerminalHeight();
+                const activeFilterLabel = stateManager.getActiveFilterLabel();
+                const lines = renderer.renderInterface(filteredStates, uiState.currentRow, uiState.scrollOffset, uiState.maxVisibleItems, uiState.forceFullRender, [], activeFilterLabel, packageManager, uiState.filterMode, uiState.filterQuery, states.length, terminalWidth, loadingProgress, auditProgress, packageListRenderOptions, uiState.notice);
+                renderViewport(lines, terminalWidth, terminalHeight, bgCode);
+                previousViewportMode = 'list';
+                previousModalViewportLineCount = null;
+                stateManager.markRendered(lines);
+            }
+            stateManager.setInitialRender(false);
+        };
+        // Safety net: restore terminal if the process exits without going through finalizeSelection.
+        // Only synchronous writes work in an 'exit' handler, but that's all we need here.
+        const emergencyCleanup = () => {
+            if (ownsAlternateScreen) {
+                process.stdout.write(cursor_1.RAW_EXIT_ALT_SCREEN);
+            }
+            process.stdout.write(cursor_1.RAW_SHOW_CURSOR);
+            if (process.stdin.setRawMode) {
+                process.stdin.setRawMode(false);
+            }
+        };
+        process.on('exit', emergencyCleanup);
+        let cleanupInteractiveSession = () => {
+            process.stdout.write((0, themes_colors_1.getTerminalResetCode)());
+            index_1.CursorUtils.show();
+            process.stdin.off('keypress', keypressHandler);
+            process.stdin.pause();
+            process.off('SIGWINCH', handleResize);
+        };
+        const finalizeSelection = (selectedStates) => {
+            isResolved = true;
+            onRefreshViewReady?.(undefined);
+            packageInfoModalController.cancel();
+            // Remember the view filters for next launch (best-effort, never throws).
+            config_1.configManager.setFilters(stateManager.getFilterSnapshot());
+            releaseInteractiveScreen();
+            cleanupInteractiveSession();
+            process.off('exit', emergencyCleanup);
+            resolve(selectedStates);
+        };
+        const handleConfirm = (confirmed) => {
+            finalizeSelection(confirmed);
+        };
+        const handleCancel = () => {
+            finalizeSelection(states.map((s) => ({ ...s, selectedOption: 'none' })));
+        };
+        const inputHandler = new index_1.InputHandler(stateManager, (action) => (0, action_dispatcher_1.dispatchAction)(action, {
+            stateManager,
+            states,
+            vulnerabilityDisplayOptions,
+            packageInfoModalController,
+            vulnerabilityAuditController,
+            isResolved: () => isResolved,
+            renderInterface,
+            handleCancel,
+            getInfoModalMaxScrollOffset: () => infoModalMaxScrollOffset,
+            getDebugModalMaxScrollOffset: () => debugModalMaxScrollOffset,
+            getHelpModalMaxScrollOffset: () => helpModalMaxScrollOffset,
+        }), handleConfirm, handleCancel);
+        const keypressHandler = (str, key) => inputHandler.handleKeypress(str, key, states);
+        const handleResize = () => {
+            inputHandler.handleResize(getTerminalHeight());
+        };
+        try {
+            claimInteractiveScreen();
+            onRefreshViewReady?.(() => {
+                if (!isResolved)
+                    renderInterface();
+            });
+            attachRefresh?.(() => {
+                if (!isResolved) {
+                    renderInterface();
+                }
+            });
+            const keypressSession = index_1.TerminalInput.startKeypressSession(keypressHandler);
+            const previousCleanup = cleanupInteractiveSession;
+            cleanupInteractiveSession = () => {
+                keypressSession.close();
+                previousCleanup();
+            };
+            process.on('SIGWINCH', handleResize);
+            const currentHeight = getTerminalHeight();
+            if (stateManager.updateTerminalHeight(currentHeight)) {
+                const initialFiltered = stateManager.getFilteredStates(states, vulnerabilityDisplayOptions);
+                stateManager.resetForResize(initialFiltered.length);
+            }
+            renderInterface();
+            vulnerabilityAuditController.enqueueStates(states, () => {
+                if (!isResolved)
+                    renderInterface();
+            });
+        }
+        catch (error) {
+            onRefreshViewReady?.(undefined);
+            process.off('exit', emergencyCleanup);
+            releaseInteractiveScreen();
+            process.stdout.write((0, themes_colors_1.getTerminalResetCode)());
+            console.log(chalk_1.default.yellow('Raw mode not available, using fallback interface...'));
+            resolve(states);
+        }
+    });
+}
+//# sourceMappingURL=interactive-session.js.map

package/dist/ui/session/selection-state-builder.js

@@ -0,0 +1,144 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deduplicatePackages = deduplicatePackages;
+exports.createSelectionStates = createSelectionStates;
+exports.createPendingSelectionStates = createPendingSelectionStates;
+exports.createUpgradeChoices = createUpgradeChoices;
+const semver = __importStar(require("semver"));
+const utils_1 = require("../utils");
+function deduplicatePackages(packages) {
+    const uniquePackages = new Map();
+    for (const pkg of packages) {
+        const key = `${pkg.name}@${pkg.currentVersion}@${pkg.type}`;
+        if (!uniquePackages.has(key)) {
+            uniquePackages.set(key, {
+                pkg,
+                packageJsonPaths: new Set([pkg.packageJsonPath]),
+            });
+        }
+        else {
+            uniquePackages.get(key).packageJsonPaths.add(pkg.packageJsonPath);
+        }
+    }
+    return new Map(Array.from(uniquePackages.entries()).sort(([, a], [, b]) => {
+        const aIsScoped = a.pkg.name.startsWith('@');
+        const bIsScoped = b.pkg.name.startsWith('@');
+        if (aIsScoped && !bIsScoped)
+            return -1;
+        if (!aIsScoped && bIsScoped)
+            return 1;
+        return a.pkg.name.localeCompare(b.pkg.name);
+    }));
+}
+function createSelectionStates(packages, getCachedSummary, previousSelections, includeUpToDate = true) {
+    const relevantPackages = includeUpToDate ? packages : packages.filter((p) => p.isOutdated);
+    const uniquePackages = deduplicatePackages(relevantPackages);
+    return Array.from(uniquePackages.values()).map(({ pkg, packageJsonPaths }) => {
+        const currentClean = semver.coerce(pkg.currentVersion)?.version || pkg.currentVersion;
+        const rangeClean = semver.coerce(pkg.rangeVersion)?.version || pkg.rangeVersion;
+        const latestClean = semver.coerce(pkg.latestVersion)?.version || pkg.latestVersion;
+        const key = `${pkg.name}@${pkg.currentVersion}@${pkg.type}`;
+        const previousSelection = previousSelections?.get(key) || 'none';
+        return {
+            name: pkg.name,
+            packageJsonPath: pkg.packageJsonPath,
+            packageJsonPaths: Array.from(packageJsonPaths),
+            currentVersionSpecifier: pkg.currentVersion,
+            currentVersion: currentClean,
+            rangeVersion: rangeClean,
+            latestVersion: latestClean,
+            selectedOption: previousSelection,
+            loadState: 'ready',
+            hasRangeUpdate: pkg.hasRangeUpdate,
+            hasMajorUpdate: pkg.hasMajorUpdate,
+            type: pkg.type,
+            vulnerability: getCachedSummary(pkg.name, pkg.currentVersion, pkg.type),
+            allVersions: pkg.allVersions,
+        };
+    });
+}
+function createPendingSelectionStates(packages, getCachedSummary, previousSelections) {
+    const uniquePackages = deduplicatePackages(packages.map((pkg) => ({
+        ...pkg,
+        rangeVersion: pkg.currentVersion,
+        latestVersion: pkg.currentVersion,
+        isOutdated: false,
+        hasRangeUpdate: false,
+        hasMajorUpdate: false,
+    })));
+    return Array.from(uniquePackages.values()).map(({ pkg, packageJsonPaths }) => {
+        const currentClean = semver.coerce(pkg.currentVersion)?.version || pkg.currentVersion;
+        const key = `${pkg.name}@${pkg.currentVersion}@${pkg.type}`;
+        const previousSelection = previousSelections?.get(key) || 'none';
+        return {
+            name: pkg.name,
+            packageJsonPath: pkg.packageJsonPath,
+            packageJsonPaths: Array.from(packageJsonPaths),
+            currentVersionSpecifier: pkg.currentVersion,
+            currentVersion: currentClean,
+            rangeVersion: 'loading',
+            latestVersion: 'loading',
+            selectedOption: previousSelection,
+            loadState: 'pending',
+            hasRangeUpdate: false,
+            hasMajorUpdate: false,
+            type: pkg.type,
+            vulnerability: getCachedSummary(pkg.name, pkg.currentVersion, pkg.type),
+        };
+    });
+}
+function createUpgradeChoices(selectedStates) {
+    const choices = [];
+    selectedStates
+        .filter((state) => state.loadState === 'ready' && state.selectedOption !== 'none')
+        .forEach((state) => {
+        const targetVersion = state.selectedOption === 'range' ? state.rangeVersion : state.latestVersion;
+        const targetVersionWithPrefix = (0, utils_1.applyVersionPrefix)(state.currentVersionSpecifier, targetVersion);
+        const pathsToUpdate = state.packageJsonPaths || [state.packageJsonPath];
+        pathsToUpdate.forEach((packageJsonPath) => {
+            choices.push({
+                name: state.name,
+                packageJsonPath,
+                dependencyType: state.type,
+                upgradeType: state.selectedOption,
+                targetVersion: targetVersionWithPrefix,
+                currentVersionSpecifier: state.currentVersionSpecifier,
+            });
+        });
+    });
+    return choices;
+}
+//# sourceMappingURL=selection-state-builder.js.map