inup 1.4.12 → 1.5.1

package/dist/services/vulnerability-checker.js

@@ -0,0 +1,133 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fetchVulnerabilities = fetchVulnerabilities;
+const config_1 = require("../config");
+const utils_1 = require("../utils");
+const SEVERITY_ORDER = {
+    info: 0,
+    low: 1,
+    moderate: 2,
+    high: 3,
+    critical: 4,
+};
+function isKnownSeverity(severity) {
+    return severity in SEVERITY_ORDER;
+}
+function getHighestSeverity(vulnerabilities) {
+    if (vulnerabilities.length === 0)
+        return null;
+    let highest = 'info';
+    for (const vuln of vulnerabilities) {
+        if (SEVERITY_ORDER[vuln.severity] > SEVERITY_ORDER[highest]) {
+            highest = vuln.severity;
+        }
+    }
+    return highest;
+}
+/**
+ * Fetches security advisories for a set of packages using the npm bulk advisory API.
+ * This is the same endpoint that `npm audit` uses under the hood.
+ *
+ * POST https://registry.npmjs.org/-/npm/v1/security/advisories/bulk
+ * Body: { "package-name": ["version1"], ... }
+ * Response: { "package-name": [{ id, title, severity, url, vulnerable_versions }], ... }
+ */
+async function fetchVulnerabilities(packages) {
+    const results = new Map();
+    if (packages.size === 0) {
+        return results;
+    }
+    // Build the request body: { "package-name": ["version"], ... }
+    const body = {};
+    for (const [name, version] of packages) {
+        const cleanVersion = version.replace(/^[^0-9]*/, '');
+        if (cleanVersion) {
+            body[name] = [cleanVersion];
+        }
+    }
+    if (Object.keys(body).length === 0) {
+        return results;
+    }
+    const url = `${config_1.NPM_REGISTRY_URL}/-/npm/v1/security/advisories/bulk`;
+    utils_1.debugLog.info('vulnerability-checker', `checking ${Object.keys(body).length} packages`);
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), config_1.REQUEST_TIMEOUT);
+    try {
+        const response = await fetch(url, {
+            method: 'POST',
+            headers: {
+                'content-type': 'application/json',
+                accept: 'application/json',
+            },
+            body: JSON.stringify(body),
+            signal: controller.signal,
+        });
+        clearTimeout(timeoutId);
+        if (!response.ok) {
+            utils_1.debugLog.warn('vulnerability-checker', `API returned HTTP ${response.status}`);
+            return results;
+        }
+        // Response is keyed by package name, values are arrays of advisories
+        const data = (await response.json());
+        if (!data || typeof data !== 'object' || Array.isArray(data)) {
+            utils_1.debugLog.warn('vulnerability-checker', 'unexpected API payload shape');
+            return results;
+        }
+        for (const [packageName, advisories] of Object.entries(data)) {
+            if (!Array.isArray(advisories) || advisories.length === 0)
+                continue;
+            const seen = new Set();
+            const unique = [];
+            for (const advisory of advisories) {
+                if (!advisory ||
+                    typeof advisory.id !== 'number' ||
+                    typeof advisory.title !== 'string' ||
+                    typeof advisory.url !== 'string' ||
+                    typeof advisory.vulnerable_versions !== 'string' ||
+                    typeof advisory.severity !== 'string' ||
+                    !isKnownSeverity(advisory.severity)) {
+                    continue;
+                }
+                if (seen.has(advisory.id))
+                    continue;
+                seen.add(advisory.id);
+                unique.push({
+                    id: advisory.id,
+                    title: advisory.title,
+                    severity: advisory.severity,
+                    url: advisory.url,
+                    vulnerable_versions: advisory.vulnerable_versions,
+                });
+            }
+            unique.sort((left, right) => {
+                const severityDelta = SEVERITY_ORDER[right.severity] - SEVERITY_ORDER[left.severity];
+                if (severityDelta !== 0) {
+                    return severityDelta;
+                }
+                return left.id - right.id;
+            });
+            if (unique.length === 0)
+                continue;
+            results.set(packageName, {
+                packageName,
+                vulnerabilities: unique,
+                highestSeverity: getHighestSeverity(unique),
+            });
+        }
+        utils_1.debugLog.info('vulnerability-checker', `found ${results.size} packages with vulnerabilities`);
+        return results;
+    }
+    catch (error) {
+        if (error instanceof Error && error.name === 'AbortError') {
+            utils_1.debugLog.warn('vulnerability-checker', 'request timed out');
+        }
+        else {
+            utils_1.debugLog.warn('vulnerability-checker', 'failed to fetch vulnerabilities', error);
+        }
+        return results;
+    }
+    finally {
+        clearTimeout(timeoutId);
+    }
+}
+//# sourceMappingURL=vulnerability-checker.js.map

package/dist/ui/controllers/index.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PackageInfoModalController = exports.VulnerabilityAuditController = void 0;
+var vulnerability_audit_controller_1 = require("./vulnerability-audit-controller");
+Object.defineProperty(exports, "VulnerabilityAuditController", { enumerable: true, get: function () { return vulnerability_audit_controller_1.VulnerabilityAuditController; } });
+var package_info_modal_controller_1 = require("./package-info-modal-controller");
+Object.defineProperty(exports, "PackageInfoModalController", { enumerable: true, get: function () { return package_info_modal_controller_1.PackageInfoModalController; } });
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1,237 @@
+"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.PackageInfoModalController = void 0;
+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;
+    }
+    /**
+     * Cancel any in-flight hydrate/release-notes fetches.
+     * Safe to call multiple times or when nothing is in flight.
+     */
+    cancel() {
+        this.abortController?.abort();
+        this.abortController = null;
+        this.pendingReleaseNotesVersion = null;
+        if (this.releaseNotesDebounceTimer) {
+            clearTimeout(this.releaseNotesDebounceTimer);
+            this.releaseNotesDebounceTimer = null;
+        }
+        this.resolveDebouncedLoad?.(false);
+        this.resolveDebouncedLoad = null;
+    }
+    async hydrate(state) {
+        // Abort any previous session
+        this.cancel();
+        const controller = new AbortController();
+        this.abortController = controller;
+        const metadata = await services_1.changelogFetcher.fetchPackageMetadata(state.name, state.latestVersion, controller.signal);
+        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;
+        this.pendingReleaseNotesVersion = null;
+        if (this.releaseNotesDebounceTimer) {
+            clearTimeout(this.releaseNotesDebounceTimer);
+            this.releaseNotesDebounceTimer = null;
+        }
+        this.resolveDebouncedLoad?.(false);
+        this.resolveDebouncedLoad = null;
+        return result;
+    }
+    /**
+     * Load release notes for a specific version by index.
+     * Returns true if a load was triggered, false if nothing to load.
+     */
+    async loadVersionAtIndex(state, index, onLoaded) {
+        if (!state.releaseNotesVersions || !state.releaseNotesLoaded)
+            return false;
+        if (index < 0 || index >= state.releaseNotesVersions.length)
+            return false;
+        const version = state.releaseNotesVersions[index];
+        // Already loaded
+        if (state.releaseNotesLoaded.has(version))
+            return false;
+        if (state.releaseNotesLoadingVersion) {
+            this.pendingReleaseNotesVersion = version;
+            return false;
+        }
+        return await this.scheduleVersionLoad(state, version, onLoaded);
+    }
+    scheduleVersionLoad(state, version, onLoaded) {
+        if (this.releaseNotesDebounceTimer) {
+            clearTimeout(this.releaseNotesDebounceTimer);
+            this.releaseNotesDebounceTimer = null;
+        }
+        this.resolveDebouncedLoad?.(false);
+        this.pendingReleaseNotesVersion = version;
+        return new Promise((resolve) => {
+            this.resolveDebouncedLoad = resolve;
+            this.releaseNotesDebounceTimer = setTimeout(() => {
+                this.releaseNotesDebounceTimer = null;
+                this.resolveDebouncedLoad = null;
+                const nextVersion = this.pendingReleaseNotesVersion;
+                this.pendingReleaseNotesVersion = null;
+                if (!nextVersion || state.releaseNotesLoadingVersion) {
+                    resolve(false);
+                    return;
+                }
+                void this.loadVersion(state, nextVersion, onLoaded).then(resolve);
+            }, RELEASE_NOTES_LOAD_DEBOUNCE_MS);
+        });
+    }
+    async loadVersion(state, version, onLoaded) {
+        const loadedNotes = state.releaseNotesLoaded;
+        if (!loadedNotes)
+            return false;
+        state.releaseNotesLoadingVersion = version;
+        onLoaded(); // Re-render to show loading indicator
+        try {
+            const notes = await services_1.changelogFetcher.fetchReleaseNotesForVersion(state.name, version, this.abortController?.signal);
+            loadedNotes.set(version, notes);
+            return true;
+        }
+        catch (error) {
+            if (error instanceof DOMException && error.name === 'AbortError') {
+                return false;
+            }
+            loadedNotes.set(version, null);
+            return true;
+        }
+        finally {
+            state.releaseNotesLoadingVersion = undefined;
+            onLoaded(); // Re-render with new content or recovered state
+            const pendingVersion = this.pendingReleaseNotesVersion;
+            this.pendingReleaseNotesVersion = null;
+            if (pendingVersion &&
+                pendingVersion !== version &&
+                loadedNotes &&
+                !loadedNotes.has(pendingVersion)) {
+                void this.loadVersion(state, pendingVersion, onLoaded);
+            }
+        }
+    }
+    /**
+     * Navigate to the next or previous version in the release notes list.
+     * Returns the new view index, or -1 if navigation is not possible.
+     */
+    navigateVersion(state, direction) {
+        if (!state.releaseNotesVersions || state.releaseNotesVersions.length === 0)
+            return -1;
+        const currentIndex = state.releaseNotesViewIndex ?? 0;
+        const newIndex = direction === 'older' ? currentIndex + 1 : currentIndex - 1;
+        if (newIndex < 0 || newIndex >= state.releaseNotesVersions.length)
+            return -1;
+        state.releaseNotesViewIndex = newIndex;
+        return newIndex;
+    }
+    /**
+     * Check if the version at the given index is already loaded.
+     */
+    isVersionLoaded(state, index) {
+        if (!state.releaseNotesVersions || !state.releaseNotesLoaded)
+            return false;
+        if (index < 0 || index >= state.releaseNotesVersions.length)
+            return false;
+        return state.releaseNotesLoaded.has(state.releaseNotesVersions[index]);
+    }
+    /**
+     * Get the total number of versions available.
+     */
+    getVersionCount(state) {
+        return state.releaseNotesVersions?.length ?? 0;
+    }
+    /**
+     * Check if navigation in a direction is possible.
+     */
+    canNavigate(state, direction) {
+        if (!state.releaseNotesVersions || state.releaseNotesVersions.length === 0)
+            return false;
+        const currentIndex = state.releaseNotesViewIndex ?? 0;
+        if (direction === 'newer')
+            return currentIndex > 0;
+        return currentIndex < state.releaseNotesVersions.length - 1;
+    }
+    buildReleaseNotesVersionQueue(allVersions, currentVersion, targetVersion) {
+        const cleanTarget = semver.clean(targetVersion);
+        if (!cleanTarget) {
+            return [];
+        }
+        const cleanCurrent = semver.clean(currentVersion);
+        const versionsAtOrBelowTarget = Array.from(new Set(allVersions
+            .map((version) => semver.clean(version))
+            .filter((version) => version !== null)
+            .filter((version) => semver.lte(version, cleanTarget)))).sort(semver.rcompare);
+        if (!cleanCurrent) {
+            return versionsAtOrBelowTarget;
+        }
+        const relevantVersions = versionsAtOrBelowTarget.filter((version) => semver.gte(version, cleanCurrent));
+        return relevantVersions;
+    }
+}
+exports.PackageInfoModalController = PackageInfoModalController;
+//# sourceMappingURL=package-info-modal-controller.js.map

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

@@ -0,0 +1,82 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+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;
+    }
+    getCachedSummary(packageName, currentVersionSpecifier, type) {
+        return this.cache.get(this.getCacheKey(packageName, currentVersionSpecifier, type));
+    }
+    getProgress() {
+        return this.tracker.getProgress();
+    }
+    enqueueStates(selectionStates, onUpdate) {
+        const packages = selectionStates.map((state) => ({
+            name: state.name,
+            version: state.currentVersionSpecifier,
+        }));
+        const added = this.tracker.enqueue(packages);
+        if (added > 0) {
+            this.drain(selectionStates, onUpdate);
+        }
+    }
+    drain(selectionStates, onUpdate) {
+        if (this.drainPromise) {
+            return;
+        }
+        this.drainPromise = (async () => {
+            while (true) {
+                const batch = this.tracker.reserveNextBatch(20);
+                if (batch.packageNames.length === 0) {
+                    break;
+                }
+                try {
+                    const vulnerabilityData = await (0, services_1.fetchVulnerabilities)(batch.packages);
+                    const batchNames = new Set(batch.packageNames);
+                    for (const state of selectionStates) {
+                        if (!batchNames.has(state.name)) {
+                            continue;
+                        }
+                        const vulnerability = vulnerabilityData.get(state.name);
+                        if (!vulnerability ||
+                            vulnerability.vulnerabilities.length === 0 ||
+                            !vulnerability.highestSeverity) {
+                            continue;
+                        }
+                        const summary = (0, vulnerability_1.createVulnerabilitySummary)(state.vulnerability, vulnerability.vulnerabilities.map((item) => ({
+                            id: item.id,
+                            title: item.title,
+                            severity: item.severity,
+                            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);
+                    }
+                }
+                catch {
+                    // Best-effort enrichment only. Keep the UI responsive on audit failures.
+                }
+                finally {
+                    this.tracker.markCompleted(batch.packageNames);
+                    onUpdate?.();
+                }
+            }
+        })().finally(() => {
+            this.drainPromise = null;
+            if (this.tracker.getProgress().isRunning) {
+                this.drain(selectionStates, onUpdate);
+            }
+        });
+    }
+    getCacheKey(packageName, currentVersionSpecifier, type) {
+        return `${packageName}@${currentVersionSpecifier}@${type}`;
+    }
+}
+exports.VulnerabilityAuditController = VulnerabilityAuditController;
+//# sourceMappingURL=vulnerability-audit-controller.js.map

package/dist/ui/index.js

@@ -17,5 +17,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./utils"), exports);
 __exportStar(require("./state"), exports);
 __exportStar(require("./renderer"), exports);
+__exportStar(require("./modal"), exports);
+__exportStar(require("./presenters"), exports);
+__exportStar(require("./controllers"), exports);
 __exportStar(require("./input-handler"), exports);
 //# sourceMappingURL=index.js.map

package/dist/ui/input-handler.js

@@ -47,8 +47,37 @@ class InputHandler {
             }
             return;
         }
+        // Handle info modal input (scroll and close)
+        if (uiState.showInfoModal) {
+            if (key) {
+                switch (key.name) {
+                    case 'escape':
+                        this.onAction({ type: 'toggle_info_modal' });
+                        return;
+                    case 'i':
+                    case 'I':
+                        this.onAction({ type: 'toggle_info_modal' });
+                        return;
+                    case 'up':
+                        this.onAction({ type: 'scroll_info_modal_up' });
+                        return;
+                    case 'down':
+                        this.onAction({ type: 'scroll_info_modal_down' });
+                        return;
+                    case 'left':
+                        this.onAction({ type: 'navigate_info_modal_version', direction: 'newer' });
+                        return;
+                    case 'right':
+                        this.onAction({ type: 'navigate_info_modal_version', direction: 'older' });
+                        return;
+                    default:
+                        return; // Consume all other keys while modal is open
+                }
+            }
+            return;
+        }
         // Check for '/' character to handle filter mode (only when not in modal)
-        if (str === '/' && !uiState.showInfoModal) {
+        if (str === '/') {
             if (uiState.filterMode) {
                 // Apply search (exit filter mode but keep the filter)
                 this.onAction({ type: 'exit_filter_mode' });
@@ -146,19 +175,19 @@ class InputHandler {
                 break;
             case 'd':
             case 'D':
-                if (!uiState.showInfoModal && !uiState.showThemeModal && !uiState.filterMode) {
+                if (!uiState.showThemeModal && !uiState.filterMode) {
                     this.onAction({ type: 'toggle_dep_type_filter', depType: 'devDependencies' });
                 }
                 break;
             case 'p':
             case 'P':
-                if (!uiState.showInfoModal && !uiState.showThemeModal && !uiState.filterMode) {
+                if (!uiState.showThemeModal && !uiState.filterMode) {
                     this.onAction({ type: 'toggle_dep_type_filter', depType: 'peerDependencies' });
                 }
                 break;
             case 'o':
             case 'O':
-                if (!uiState.showInfoModal && !uiState.showThemeModal && !uiState.filterMode) {
+                if (!uiState.showThemeModal && !uiState.filterMode) {
                     this.onAction({ type: 'toggle_dep_type_filter', depType: 'optionalDependencies' });
                 }
                 break;
@@ -166,16 +195,18 @@ class InputHandler {
             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':
-                // Close modal if open
-                if (uiState.showInfoModal) {
-                    this.onAction({ type: 'toggle_info_modal' });
-                }
-                else if (uiState.filterQuery) {
+                if (uiState.filterQuery) {
                     // Clear filter if one is applied
                     this.onAction({ type: 'exit_filter_mode', clearQuery: true });
                 }

package/dist/ui/modal/index.js

@@ -0,0 +1,22 @@
+"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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./types"), exports);
+__exportStar(require("./layout"), exports);
+__exportStar(require("./package-info"), exports);
+__exportStar(require("./package-info-sections"), exports);
+__exportStar(require("./theme-selector"), exports);
+//# sourceMappingURL=index.js.map

package/dist/ui/modal/layout.js

@@ -0,0 +1,84 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getModalWidth = getModalWidth;
+exports.renderModalRow = renderModalRow;
+exports.renderModalSeparator = renderModalSeparator;
+exports.fitModalSections = fitModalSections;
+exports.getModalSectionRowCount = getModalSectionRowCount;
+exports.getModalFrameHeight = getModalFrameHeight;
+exports.renderModalFrame = renderModalFrame;
+const chalk_1 = __importDefault(require("chalk"));
+const utils_1 = require("../utils");
+function getModalWidth(terminalWidth, minWidth, maxWidth) {
+    return Math.min(Math.max(minWidth, terminalWidth - 6), maxWidth);
+}
+function renderModalRow(padding, modalWidth, text) {
+    const rowLength = (0, utils_1.getVisualLength)(text);
+    const rowPadding = Math.max(0, modalWidth - 4 - rowLength);
+    return (' '.repeat(padding) +
+        chalk_1.default.gray('│') +
+        ' ' +
+        text +
+        ' '.repeat(rowPadding) +
+        ' ' +
+        chalk_1.default.gray('│'));
+}
+function renderModalSeparator(padding, modalWidth) {
+    return ' '.repeat(padding) + chalk_1.default.gray('├' + '─'.repeat(modalWidth - 2) + '┤');
+}
+function fitModalSections(sections, maxHeight, trimOrder) {
+    const activeSections = sections.map((section) => ({ ...section, rows: [...section.rows] }));
+    while (getModalFrameHeight(activeSections) > maxHeight) {
+        let trimmed = false;
+        for (const key of trimOrder) {
+            const section = activeSections.find((candidate) => candidate.key === key && candidate.rows.length > 0 && !candidate.required);
+            if (!section) {
+                continue;
+            }
+            if (section.rows.length === 1) {
+                section.rows = [];
+            }
+            else {
+                section.rows = section.rows.slice(0, -1);
+            }
+            trimmed = true;
+            break;
+        }
+        if (!trimmed) {
+            break;
+        }
+    }
+    return activeSections.filter((section) => section.rows.length > 0);
+}
+function getModalSectionRowCount(sections) {
+    const visible = sections.filter((section) => section.rows.length > 0);
+    return visible.reduce((sum, section, index) => sum + section.rows.length + (index > 0 ? 1 : 0), 0);
+}
+function getModalFrameHeight(sections) {
+    return 2 + getModalSectionRowCount(sections);
+}
+function renderModalFrame(sections, options) {
+    const modalWidth = getModalWidth(options.terminalWidth, options.minWidth, options.maxWidth);
+    const padding = Math.floor((options.terminalWidth - modalWidth) / 2);
+    const contentHeight = getModalFrameHeight(sections);
+    const topPadding = Math.max(0, Math.floor((options.terminalHeight - contentHeight) / 2));
+    const lines = [];
+    for (let i = 0; i < topPadding; i++) {
+        lines.push('');
+    }
+    lines.push(' '.repeat(padding) + chalk_1.default.gray('╭' + '─'.repeat(modalWidth - 2) + '╮'));
+    sections.forEach((section, index) => {
+        if (index > 0) {
+            lines.push(renderModalSeparator(padding, modalWidth));
+        }
+        section.rows.forEach((row) => {
+            lines.push(renderModalRow(padding, modalWidth, row));
+        });
+    });
+    lines.push(' '.repeat(padding) + chalk_1.default.gray('╰' + '─'.repeat(modalWidth - 2) + '╯'));
+    return lines;
+}
+//# sourceMappingURL=layout.js.map