inup 1.4.0

package/dist/ui/renderer/modal.js

@@ -0,0 +1,184 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.renderPackageInfoLoading = renderPackageInfoLoading;
+exports.renderPackageInfoModal = renderPackageInfoModal;
+const chalk_1 = __importDefault(require("chalk"));
+/**
+ * Remove ANSI color codes from a string for length calculation
+ */
+function stripAnsi(str) {
+    return str.replace(/\u001b\[[0-9;]*m/g, '');
+}
+/**
+ * Format a number for display (e.g., 1000000 -> "1M", 1000 -> "1K")
+ */
+function formatNumber(num) {
+    if (!num)
+        return 'N/A';
+    if (num >= 1000000)
+        return (num / 1000000).toFixed(1) + 'M';
+    if (num >= 1000)
+        return (num / 1000).toFixed(1) + 'K';
+    return num.toString();
+}
+/**
+ * Wrap text to fit within max width
+ */
+function wrapText(text, maxWidth) {
+    if (text.length <= maxWidth) {
+        return [text];
+    }
+    const lines = [];
+    let current = '';
+    const words = text.split(' ');
+    for (const word of words) {
+        if ((current + ' ' + word).length > maxWidth) {
+            if (current)
+                lines.push(current);
+            current = word;
+        }
+        else {
+            current = current ? current + ' ' + word : word;
+        }
+    }
+    if (current)
+        lines.push(current);
+    return lines;
+}
+/**
+ * Render a loading state for the info modal
+ */
+function renderPackageInfoLoading(state, terminalWidth = 80, terminalHeight = 24) {
+    const modalWidth = Math.min(terminalWidth - 6, 120);
+    const padding = Math.floor((terminalWidth - modalWidth) / 2);
+    const lines = [];
+    // Top padding to center vertically
+    const topPadding = Math.max(1, Math.floor((terminalHeight - 10) / 2));
+    for (let i = 0; i < topPadding; i++) {
+        lines.push('');
+    }
+    // Modal border
+    lines.push(' '.repeat(padding) + chalk_1.default.gray('╭' + '─'.repeat(modalWidth - 2) + '╮'));
+    // Loading message
+    const loadingMsg = '⏳ Loading package info...';
+    const msgPadding = modalWidth - 4 - stripAnsi(loadingMsg).length;
+    lines.push(' '.repeat(padding) +
+        chalk_1.default.gray('│') +
+        ' ' +
+        chalk_1.default.cyan(loadingMsg) +
+        ' '.repeat(Math.max(0, msgPadding)) +
+        chalk_1.default.gray('│'));
+    // Package name
+    const nameMsg = `${state.name}`;
+    const namePadding = modalWidth - 4 - nameMsg.length;
+    lines.push(' '.repeat(padding) +
+        chalk_1.default.gray('│') +
+        ' ' +
+        chalk_1.default.white(nameMsg) +
+        ' '.repeat(Math.max(0, namePadding)) +
+        chalk_1.default.gray('│'));
+    lines.push(' '.repeat(padding) + chalk_1.default.gray('╰' + '─'.repeat(modalWidth - 2) + '╯'));
+    return lines;
+}
+/**
+ * Render a full-screen modal overlay showing package information
+ * Similar to Turbo's help menu - centered with disabled background
+ */
+function renderPackageInfoModal(state, terminalWidth = 80, terminalHeight = 24) {
+    const modalWidth = Math.min(terminalWidth - 6, 120); // Leave margins
+    const padding = Math.floor((terminalWidth - modalWidth) / 2);
+    const lines = [];
+    // Top padding to center vertically
+    const topPadding = Math.max(1, Math.floor((terminalHeight - 20) / 2));
+    for (let i = 0; i < topPadding; i++) {
+        lines.push('');
+    }
+    // Modal border and header
+    lines.push(' '.repeat(padding) + chalk_1.default.gray('╭' + '─'.repeat(modalWidth - 2) + '╮'));
+    // Title with package name
+    const title = ` ℹ️  ${state.name}`;
+    const titleLength = stripAnsi(title).length;
+    const titlePadding = Math.max(0, modalWidth - 2 - titleLength);
+    lines.push(' '.repeat(padding) +
+        chalk_1.default.gray('│') +
+        chalk_1.default.cyan.bold(title) +
+        ' '.repeat(titlePadding) +
+        chalk_1.default.gray('│'));
+    // License and author line
+    const authorLicense = `${state.author || 'Unknown'} • ${state.license || 'MIT'}`;
+    const authorLength = authorLicense.length;
+    const authorPadding = Math.max(0, modalWidth - 3 - authorLength);
+    lines.push(' '.repeat(padding) +
+        chalk_1.default.gray('│') +
+        ' ' +
+        chalk_1.default.gray(authorLicense) +
+        ' '.repeat(authorPadding) +
+        chalk_1.default.gray('│'));
+    lines.push(' '.repeat(padding) + chalk_1.default.gray('├' + '─'.repeat(modalWidth - 2) + '┤'));
+    // Current and target versions
+    const currentVersion = chalk_1.default.yellow(state.currentVersionSpecifier);
+    const targetVersion = chalk_1.default.green(state.selectedOption === 'range' ? state.rangeVersion : state.latestVersion);
+    const versionText = `Current: ${currentVersion} → Target: ${targetVersion}`;
+    const versionLength = stripAnsi(versionText).length;
+    const versionPadding = Math.max(0, modalWidth - 3 - versionLength);
+    lines.push(' '.repeat(padding) +
+        chalk_1.default.gray('│') +
+        ' ' +
+        versionText +
+        ' '.repeat(versionPadding) +
+        chalk_1.default.gray('│'));
+    // Weekly downloads
+    if (state.weeklyDownloads !== undefined) {
+        const downloadsText = `📊 ${formatNumber(state.weeklyDownloads)} downloads/week`;
+        const downloadsLength = stripAnsi(downloadsText).length;
+        const downloadsPadding = Math.max(0, modalWidth - 3 - downloadsLength);
+        lines.push(' '.repeat(padding) +
+            chalk_1.default.gray('│') +
+            ' ' +
+            chalk_1.default.blue(downloadsText) +
+            ' '.repeat(downloadsPadding) +
+            chalk_1.default.gray('│'));
+    }
+    // Description
+    if (state.description) {
+        lines.push(' '.repeat(padding) + chalk_1.default.gray('├' + '─'.repeat(modalWidth - 2) + '┤'));
+        const descriptionLines = wrapText(state.description, modalWidth - 4);
+        for (const descLine of descriptionLines) {
+            const descLength = descLine.length;
+            const descPadding = Math.max(0, modalWidth - 3 - descLength);
+            lines.push(' '.repeat(padding) +
+                chalk_1.default.gray('│') +
+                ' ' +
+                chalk_1.default.white(descLine) +
+                ' '.repeat(descPadding) +
+                chalk_1.default.gray('│'));
+        }
+    }
+    // Changelog/Releases section (moved to middle)
+    if (state.repository) {
+        lines.push(' '.repeat(padding) + chalk_1.default.gray('├' + '─'.repeat(modalWidth - 2) + '┤'));
+        const repoLabel = 'Changelog:';
+        const repoUrl = state.repository.substring(0, modalWidth - 20);
+        const repoText = `  ${repoLabel} ${chalk_1.default.blue.underline(repoUrl)}`;
+        const repoLength = stripAnsi(repoText).length;
+        const repoPadding = Math.max(0, modalWidth - 2 - repoLength);
+        lines.push(' '.repeat(padding) + chalk_1.default.gray('│') + repoText + ' '.repeat(repoPadding) + chalk_1.default.gray('│'));
+    }
+    // Links section
+    if (state.homepage) {
+        lines.push(' '.repeat(padding) + chalk_1.default.gray('├' + '─'.repeat(modalWidth - 2) + '┤'));
+        const homeLabel = 'Homepage:';
+        const homeUrl = state.homepage.substring(0, modalWidth - 20);
+        const homeText = `  ${homeLabel} ${chalk_1.default.blue.underline(homeUrl)}`;
+        const homeLength = stripAnsi(homeText).length;
+        const homePadding = Math.max(0, modalWidth - 2 - homeLength);
+        lines.push(' '.repeat(padding) + chalk_1.default.gray('│') + homeText + ' '.repeat(homePadding) + chalk_1.default.gray('│'));
+    }
+    // Footer
+    lines.push(' '.repeat(padding) + chalk_1.default.gray('╰' + '─'.repeat(modalWidth - 2) + '╯'));
+    return lines;
+}
+//# sourceMappingURL=modal.js.map

package/dist/ui/renderer/package-list.js

@@ -0,0 +1,243 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.renderPackageLine = renderPackageLine;
+exports.renderSectionHeader = renderSectionHeader;
+exports.renderSpacer = renderSpacer;
+exports.renderInterface = renderInterface;
+exports.renderPackagesTable = renderPackagesTable;
+const chalk_1 = __importDefault(require("chalk"));
+const utils_1 = require("../utils");
+/**
+ * Render a single package line
+ */
+function renderPackageLine(state, index, isCurrentRow) {
+    const prefix = isCurrentRow ? chalk_1.default.green('❯ ') : '  ';
+    // Package name with special formatting for scoped packages (@author/package)
+    let packageName;
+    if (state.name.startsWith('@')) {
+        const parts = state.name.split('/');
+        if (parts.length >= 2) {
+            const author = parts[0]; // @author
+            const packagePart = parts.slice(1).join('/'); // package name
+            if (isCurrentRow) {
+                packageName = chalk_1.default.white.bold(author) + chalk_1.default.cyan('/' + packagePart);
+            }
+            else {
+                packageName = chalk_1.default.white.bold(author) + chalk_1.default.white('/' + packagePart);
+            }
+        }
+        else {
+            packageName = isCurrentRow ? chalk_1.default.cyan(state.name) : chalk_1.default.white(state.name);
+        }
+    }
+    else {
+        packageName = isCurrentRow ? chalk_1.default.cyan(state.name) : chalk_1.default.white(state.name);
+    }
+    // Determine which dot should be filled (only one per package)
+    const isCurrentSelected = state.selectedOption === 'none';
+    const isRangeSelected = state.selectedOption === 'range';
+    const isLatestSelected = state.selectedOption === 'latest';
+    // Current version dot and version (show original specifier with prefix)
+    const currentDot = isCurrentSelected ? chalk_1.default.green('●') : chalk_1.default.gray('○');
+    const currentVersion = chalk_1.default.white(state.currentVersionSpecifier);
+    // Range version dot and version
+    let rangeDot = '';
+    let rangeVersionText = '';
+    let rangeDashes = '';
+    if (state.hasRangeUpdate) {
+        rangeDot = isRangeSelected ? chalk_1.default.green('●') : chalk_1.default.gray('○');
+        const rangeVersionWithPrefix = utils_1.VersionUtils.applyVersionPrefix(state.currentVersionSpecifier, state.rangeVersion);
+        rangeVersionText = chalk_1.default.yellow(rangeVersionWithPrefix);
+        rangeDashes = '';
+    }
+    else {
+        rangeDot = chalk_1.default.gray('○');
+        rangeVersionText = '';
+        rangeDashes = chalk_1.default.gray('─');
+    }
+    // Latest version dot and version
+    let latestDot = '';
+    let latestVersionText = '';
+    let latestDashes = '';
+    if (state.hasMajorUpdate) {
+        latestDot = isLatestSelected ? chalk_1.default.green('●') : chalk_1.default.gray('○');
+        const latestVersionWithPrefix = utils_1.VersionUtils.applyVersionPrefix(state.currentVersionSpecifier, state.latestVersion);
+        latestVersionText = chalk_1.default.red(latestVersionWithPrefix);
+        latestDashes = '';
+    }
+    else {
+        latestDot = chalk_1.default.gray('○');
+        latestVersionText = '';
+        latestDashes = chalk_1.default.gray('─');
+    }
+    // Fixed column widths for perfect alignment
+    const packageNameWidth = 38; // Total package column width minus prefix (2 chars)
+    const currentColumnWidth = 16; // Increased to accommodate ^ and ~ prefixes
+    const rangeColumnWidth = 16; // Increased to accommodate ^ and ~ prefixes
+    const latestColumnWidth = 16; // Increased to accommodate ^ and ~ prefixes
+    // Package name with fixed width and dashes
+    const nameLength = state.name.length;
+    const namePadding = Math.max(0, packageNameWidth - nameLength - 1); // -1 for space after package name
+    const nameDashes = '-'.repeat(namePadding);
+    const dashColor = isCurrentRow ? chalk_1.default.white : chalk_1.default.gray;
+    const packageNameSection = `${packageName} ${dashColor(nameDashes)}`;
+    // Current version section with fixed width
+    const currentSection = `${currentDot} ${currentVersion}`;
+    const currentSectionLength = utils_1.VersionUtils.getVisualLength(currentSection) + 1; // +1 for space before dashes
+    const currentPadding = Math.max(0, currentColumnWidth - currentSectionLength);
+    const currentWithPadding = currentSection + ' ' + dashColor('-').repeat(currentPadding);
+    // Range version section with fixed width
+    let rangeSection = '';
+    if (state.hasRangeUpdate) {
+        rangeSection = `${rangeDot} ${rangeVersionText}`;
+        const rangeSectionLength = utils_1.VersionUtils.getVisualLength(rangeSection) + 1; // +1 for space before dashes
+        const rangePadding = Math.max(0, rangeColumnWidth - rangeSectionLength);
+        rangeSection += ' ' + dashColor('-').repeat(rangePadding);
+    }
+    else {
+        // Empty slot - just spaces to maintain column width
+        rangeSection = ' '.repeat(rangeColumnWidth);
+    }
+    // Latest version section with fixed width
+    let latestSection = '';
+    if (state.hasMajorUpdate) {
+        latestSection = `${latestDot} ${latestVersionText}`;
+        const latestSectionLength = utils_1.VersionUtils.getVisualLength(latestSection) + 1; // +1 for space before dashes
+        const latestPadding = Math.max(0, latestColumnWidth - latestSectionLength);
+        latestSection += ' ' + dashColor('-').repeat(latestPadding);
+    }
+    else {
+        // Empty slot - just spaces to maintain column width
+        latestSection = ' '.repeat(latestColumnWidth);
+    }
+    // Build line with fixed column widths
+    const line = `${prefix}${packageNameSection}   ${currentWithPadding}   ${rangeSection}   ${latestSection}`;
+    return line;
+}
+/**
+ * Render section header
+ */
+function renderSectionHeader(title, sectionType) {
+    const colorFn = sectionType === 'main' ? chalk_1.default.cyan : sectionType === 'peer' ? chalk_1.default.magenta : chalk_1.default.yellow;
+    return '  ' + colorFn.bold(title);
+}
+/**
+ * Render spacer
+ */
+function renderSpacer() {
+    return '';
+}
+/**
+ * Render the main interface
+ */
+function renderInterface(states, currentRow, scrollOffset, maxVisibleItems, isInitialRender, renderableItems, dependencyTypeLabel, packageManager) {
+    const output = [];
+    // Header section (same for initial and incremental render)
+    if (packageManager) {
+        // Color map for each package manager - use their primary color for main text
+        const colorMap = {
+            npm: chalk_1.default.red,
+            yarn: chalk_1.default.blue,
+            pnpm: chalk_1.default.yellow,
+            bun: chalk_1.default.magenta,
+        };
+        const pmColor = colorMap[packageManager.name] || packageManager.color;
+        // Each character in "inup" gets a different color
+        const inupColors = [chalk_1.default.red, chalk_1.default.yellow, chalk_1.default.blue, chalk_1.default.magenta];
+        const coloredInup = inupColors.map((color, i) => color.bold('inup'[i])).join('');
+        output.push('  ' + chalk_1.default.bold(pmColor('🚀')) + ' ' + coloredInup + chalk_1.default.gray(` (${packageManager.displayName})`));
+    }
+    else {
+        output.push('  ' + chalk_1.default.bold.blue('🚀 ') + chalk_1.default.bold.red('i') + chalk_1.default.bold.yellow('n') + chalk_1.default.bold.blue('u') + chalk_1.default.bold.magenta('p'));
+    }
+    output.push('');
+    // Show dependency type if provided
+    if (dependencyTypeLabel) {
+        output.push('  ' + chalk_1.default.bold.cyan(dependencyTypeLabel));
+        output.push('');
+    }
+    output.push('  ' +
+        chalk_1.default.bold.white('↑/↓ ') +
+        chalk_1.default.gray('Move') +
+        '  ' +
+        chalk_1.default.bold.white('←/→ ') +
+        chalk_1.default.gray('Select versions') +
+        '  ' +
+        chalk_1.default.bold.white('I ') +
+        chalk_1.default.gray('Info') +
+        '  ' +
+        chalk_1.default.bold.white('M ') +
+        chalk_1.default.gray('Select all minor') +
+        '  ' +
+        chalk_1.default.bold.white('L ') +
+        chalk_1.default.gray('Select all') +
+        '  ' +
+        chalk_1.default.bold.white('U ') +
+        chalk_1.default.gray('Unselect all'));
+    // Show status line with item range
+    const totalPackages = states.length;
+    // Use renderableItems length only if we have renderable items (grouped mode), otherwise use totalPackages (flat mode)
+    const totalVisualItems = renderableItems && renderableItems.length > 0 ? renderableItems.length : totalPackages;
+    const startItem = scrollOffset + 1;
+    const endItem = Math.min(scrollOffset + maxVisibleItems, totalVisualItems);
+    const statusLine = totalVisualItems > maxVisibleItems
+        ? chalk_1.default.gray(`Showing ${chalk_1.default.gray(startItem)}-${chalk_1.default.gray(endItem)} of ${chalk_1.default.gray(totalPackages)} packages`) +
+            '  ' +
+            chalk_1.default.gray('Enter ') +
+            chalk_1.default.gray('Confirm') +
+            '  ' +
+            chalk_1.default.gray('Esc ') +
+            chalk_1.default.gray('Cancel')
+        : chalk_1.default.gray(`Showing all ${chalk_1.default.gray(totalPackages)} packages`) +
+            '  ' +
+            chalk_1.default.gray('Enter ') +
+            chalk_1.default.gray('Confirm') +
+            '  ' +
+            chalk_1.default.gray('Esc ') +
+            chalk_1.default.gray('Cancel');
+    output.push('  ' + statusLine);
+    output.push('');
+    // Render visible items
+    if (renderableItems && renderableItems.length > 0) {
+        // Use renderable items for grouped display
+        for (let i = scrollOffset; i < Math.min(scrollOffset + maxVisibleItems, renderableItems.length); i++) {
+            const item = renderableItems[i];
+            if (item.type === 'header') {
+                output.push(renderSectionHeader(item.title, item.sectionType));
+            }
+            else if (item.type === 'spacer') {
+                output.push(renderSpacer());
+            }
+            else if (item.type === 'package') {
+                const line = renderPackageLine(item.state, item.originalIndex, item.originalIndex === currentRow);
+                output.push(line);
+            }
+        }
+    }
+    else {
+        // Fallback to flat rendering (legacy mode)
+        for (let i = scrollOffset; i < Math.min(scrollOffset + maxVisibleItems, states.length); i++) {
+            const line = renderPackageLine(states[i], i, i === currentRow);
+            output.push(line);
+        }
+    }
+    return output;
+}
+/**
+ * Render packages table
+ */
+function renderPackagesTable(packages) {
+    if (packages.length === 0) {
+        return chalk_1.default.green('✅ All packages are up to date!');
+    }
+    const outdatedPackages = packages.filter((p) => p.isOutdated);
+    if (outdatedPackages.length === 0) {
+        return chalk_1.default.green('✅ All packages are up to date!');
+    }
+    // Just show a simple message, the interactive interface will handle the display
+    return chalk_1.default.bold.blue('🚀 inup\n');
+}
+//# sourceMappingURL=package-list.js.map

package/dist/ui/state.js

@@ -0,0 +1,250 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StateManager = void 0;
+class StateManager {
+    constructor(initialRow = 0, terminalHeight = 24) {
+        this.headerLines = 7; // title + empty + label + empty + 1 instruction line + status + empty
+        this.uiState = {
+            currentRow: initialRow,
+            previousRow: -1,
+            scrollOffset: 0,
+            previousScrollOffset: 0,
+            maxVisibleItems: Math.max(5, terminalHeight - this.headerLines - 2),
+            terminalHeight,
+            isInitialRender: true,
+            renderedLines: [],
+            renderableItems: [],
+            showInfoModal: false,
+            infoModalRow: -1,
+            isLoadingModalInfo: false,
+        };
+    }
+    getUIState() {
+        return { ...this.uiState };
+    }
+    setRenderableItems(items) {
+        this.uiState.renderableItems = items;
+    }
+    // Convert package index to visual row index in renderable items
+    packageIndexToVisualIndex(packageIndex) {
+        // If no renderable items (flat mode), visual index equals package index
+        if (this.uiState.renderableItems.length === 0) {
+            return packageIndex;
+        }
+        // Otherwise search in renderable items (grouped mode)
+        for (let i = 0; i < this.uiState.renderableItems.length; i++) {
+            const item = this.uiState.renderableItems[i];
+            if (item.type === 'package' && item.originalIndex === packageIndex) {
+                return i;
+            }
+        }
+        return 0;
+    }
+    // Find the next navigable package index in the given direction
+    findNextPackageIndex(currentPackageIndex, direction, totalPackages) {
+        if (this.uiState.renderableItems.length === 0) {
+            // Fallback to simple navigation if no renderable items
+            if (direction === 'up') {
+                return currentPackageIndex <= 0 ? totalPackages - 1 : currentPackageIndex - 1;
+            }
+            else {
+                return currentPackageIndex >= totalPackages - 1 ? 0 : currentPackageIndex + 1;
+            }
+        }
+        // Find current visual index
+        const currentVisualIndex = this.packageIndexToVisualIndex(currentPackageIndex);
+        // Get all package items with their visual indices
+        const packageItems = [];
+        for (let i = 0; i < this.uiState.renderableItems.length; i++) {
+            const item = this.uiState.renderableItems[i];
+            if (item.type === 'package') {
+                packageItems.push({ visualIndex: i, packageIndex: item.originalIndex });
+            }
+        }
+        if (packageItems.length === 0)
+            return currentPackageIndex;
+        // Find current position in packageItems
+        const currentPos = packageItems.findIndex((p) => p.packageIndex === currentPackageIndex);
+        if (currentPos === -1)
+            return packageItems[0].packageIndex;
+        // Navigate with wrap-around
+        if (direction === 'up') {
+            const newPos = currentPos <= 0 ? packageItems.length - 1 : currentPos - 1;
+            return packageItems[newPos].packageIndex;
+        }
+        else {
+            const newPos = currentPos >= packageItems.length - 1 ? 0 : currentPos + 1;
+            return packageItems[newPos].packageIndex;
+        }
+    }
+    updateTerminalHeight(newHeight) {
+        const newMaxVisibleItems = Math.max(5, newHeight - this.headerLines - 2);
+        if (newHeight !== this.uiState.terminalHeight ||
+            newMaxVisibleItems !== this.uiState.maxVisibleItems) {
+            this.uiState.terminalHeight = newHeight;
+            this.uiState.maxVisibleItems = newMaxVisibleItems;
+            return true; // Changed
+        }
+        return false; // No change
+    }
+    navigateUp(totalItems) {
+        this.uiState.previousRow = this.uiState.currentRow;
+        this.uiState.currentRow = this.findNextPackageIndex(this.uiState.currentRow, 'up', totalItems);
+        this.ensureVisible(this.uiState.currentRow, totalItems);
+    }
+    navigateDown(totalItems) {
+        this.uiState.previousRow = this.uiState.currentRow;
+        this.uiState.currentRow = this.findNextPackageIndex(this.uiState.currentRow, 'down', totalItems);
+        this.ensureVisible(this.uiState.currentRow, totalItems);
+    }
+    ensureVisible(packageIndex, totalPackages) {
+        // Convert package index to visual index for scrolling
+        const visualIndex = this.packageIndexToVisualIndex(packageIndex);
+        const totalVisualItems = this.uiState.renderableItems.length || totalPackages;
+        // Try to show section header if the current item is just below a header
+        let targetVisualIndex = visualIndex;
+        if (visualIndex > 0) {
+            const prevItem = this.uiState.renderableItems[visualIndex - 1];
+            if (prevItem?.type === 'header') {
+                targetVisualIndex = visualIndex - 1;
+            }
+            else if (visualIndex > 1) {
+                // Also check for spacer + header combo (for first package in non-first section)
+                const prevPrevItem = this.uiState.renderableItems[visualIndex - 2];
+                if (prevItem?.type === 'spacer' && prevPrevItem?.type === 'header') {
+                    // Show spacer and header if possible
+                    targetVisualIndex = Math.max(0, visualIndex - 2);
+                }
+            }
+        }
+        // Scrolling up: show from targetVisualIndex (includes headers if applicable)
+        if (targetVisualIndex < this.uiState.scrollOffset) {
+            this.uiState.scrollOffset = targetVisualIndex;
+        }
+        // Scrolling down: ensure the package is visible, but prefer showing context if possible
+        else if (visualIndex >= this.uiState.scrollOffset + this.uiState.maxVisibleItems) {
+            // Calculate how many items we need to show from targetVisualIndex to visualIndex
+            const rangeSize = visualIndex - targetVisualIndex + 1;
+            if (rangeSize <= this.uiState.maxVisibleItems) {
+                // We can fit the context (header/spacer) and the package, so show from targetVisualIndex
+                this.uiState.scrollOffset = targetVisualIndex;
+            }
+            else {
+                // Not enough room for context, position package at bottom of viewport
+                this.uiState.scrollOffset = visualIndex - this.uiState.maxVisibleItems + 1;
+            }
+        }
+        // Ensure scrollOffset doesn't go negative or beyond bounds
+        this.uiState.scrollOffset = Math.max(0, Math.min(this.uiState.scrollOffset, Math.max(0, totalVisualItems - this.uiState.maxVisibleItems)));
+    }
+    updateSelection(states, direction) {
+        const currentState = states[this.uiState.currentRow];
+        if (direction === 'left') {
+            // Move selection left with wraparound: latest -> range -> none -> latest
+            if (currentState.selectedOption === 'latest') {
+                if (currentState.hasRangeUpdate) {
+                    currentState.selectedOption = 'range';
+                }
+                else {
+                    currentState.selectedOption = 'none';
+                }
+            }
+            else if (currentState.selectedOption === 'range') {
+                currentState.selectedOption = 'none';
+            }
+            else if (currentState.selectedOption === 'none') {
+                // Wrap around to the last available option
+                if (currentState.hasMajorUpdate) {
+                    currentState.selectedOption = 'latest';
+                }
+                else if (currentState.hasRangeUpdate) {
+                    currentState.selectedOption = 'range';
+                }
+            }
+        }
+        else {
+            // Move selection right with wraparound: none -> range -> latest -> none
+            if (currentState.selectedOption === 'none') {
+                if (currentState.hasRangeUpdate) {
+                    currentState.selectedOption = 'range';
+                }
+                else if (currentState.hasMajorUpdate) {
+                    currentState.selectedOption = 'latest';
+                }
+            }
+            else if (currentState.selectedOption === 'range') {
+                if (currentState.hasMajorUpdate) {
+                    currentState.selectedOption = 'latest';
+                }
+                else {
+                    // Wrap around to none
+                    currentState.selectedOption = 'none';
+                }
+            }
+            else if (currentState.selectedOption === 'latest') {
+                // Wrap around to none
+                currentState.selectedOption = 'none';
+            }
+        }
+    }
+    bulkSelectMinor(states) {
+        states.forEach((state) => {
+            if (state.hasRangeUpdate) {
+                state.selectedOption = 'range';
+            }
+        });
+    }
+    bulkSelectLatest(states) {
+        states.forEach((state) => {
+            if (state.hasMajorUpdate) {
+                state.selectedOption = 'latest';
+            }
+            else if (state.hasRangeUpdate) {
+                state.selectedOption = 'range';
+            }
+        });
+    }
+    bulkUnselectAll(states) {
+        states.forEach((state) => {
+            state.selectedOption = 'none';
+        });
+    }
+    markRendered(renderedLines) {
+        this.uiState.renderedLines = renderedLines;
+        this.uiState.previousRow = this.uiState.currentRow;
+        this.uiState.previousScrollOffset = this.uiState.scrollOffset;
+    }
+    setInitialRender(isInitial) {
+        this.uiState.isInitialRender = isInitial;
+    }
+    resetForResize() {
+        const totalItems = this.uiState.renderableItems.length || this.uiState.maxVisibleItems;
+        this.ensureVisible(this.uiState.currentRow, totalItems);
+        this.uiState.isInitialRender = true;
+    }
+    toggleInfoModal() {
+        if (this.uiState.showInfoModal) {
+            // Close the modal
+            this.uiState.showInfoModal = false;
+            this.uiState.infoModalRow = -1;
+        }
+        else {
+            // Open the modal for the current package
+            this.uiState.showInfoModal = true;
+            this.uiState.infoModalRow = this.uiState.currentRow;
+        }
+        this.uiState.isInitialRender = true;
+    }
+    closeInfoModal() {
+        this.uiState.showInfoModal = false;
+        this.uiState.infoModalRow = -1;
+        this.uiState.isLoadingModalInfo = false;
+        this.uiState.isInitialRender = true;
+    }
+    setModalLoading(isLoading) {
+        this.uiState.isLoadingModalInfo = isLoading;
+        this.uiState.isInitialRender = true;
+    }
+}
+exports.StateManager = StateManager;
+//# sourceMappingURL=state.js.map