inup 1.4.10 → 1.4.12

package/dist/interactive-ui.js

@@ -54,74 +54,116 @@ class InteractiveUI {
         console.log(this.renderer.renderPackagesTable(packages));
     }
     async selectPackagesToUpgrade(packages, previousSelections) {
-        const outdatedPackages = packages.filter((p) => p.isOutdated);
-        if (outdatedPackages.length === 0) {
+        const selectionStates = this.createSelectionStates(packages, previousSelections, false);
+        if (selectionStates.length === 0) {
             return [];
         }
-        // Deduplicate packages by name and version specifier, but track all package.json paths
-        const uniquePackages = new Map();
-        for (const pkg of outdatedPackages) {
-            const key = `${pkg.name}@${pkg.currentVersion}@${pkg.type}`;
-            if (!uniquePackages.has(key)) {
-                uniquePackages.set(key, {
-                    pkg,
-                    packageJsonPaths: new Set([pkg.packageJsonPath]),
-                    type: pkg.type,
-                });
-            }
-            else {
-                uniquePackages.get(key).packageJsonPaths.add(pkg.packageJsonPath);
-            }
-        }
-        // Convert to array and sort alphabetically by name (@scoped packages first, then unscoped)
-        const deduplicatedPackages = Array.from(uniquePackages.values()).map(({ pkg, packageJsonPaths, type }) => ({
-            ...pkg,
-            packageJsonPaths: Array.from(packageJsonPaths),
-            type,
-        }));
-        deduplicatedPackages.sort((a, b) => {
-            const aIsScoped = a.name.startsWith('@');
-            const bIsScoped = b.name.startsWith('@');
-            // If one is scoped and the other isn't, scoped comes first
-            if (aIsScoped && !bIsScoped)
-                return -1;
-            if (!aIsScoped && bIsScoped)
-                return 1;
-            // Both scoped or both unscoped - sort alphabetically
-            return a.name.localeCompare(b.name);
-        });
-        // Create selection states for each unique package
-        const selectionStates = deduplicatedPackages.map((pkg) => {
+        const selectedStates = await this.interactiveTableSelector(selectionStates);
+        return this.createUpgradeChoices(selectedStates);
+    }
+    createSelectionStates(packages, previousSelections, includeUpToDate = true) {
+        const relevantPackages = includeUpToDate ? packages : packages.filter((p) => p.isOutdated);
+        const uniquePackages = this.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;
-            // Use previous selection if available, otherwise default to 'none'
             const key = `${pkg.name}@${pkg.currentVersion}@${pkg.type}`;
             const previousSelection = previousSelections?.get(key) || 'none';
             return {
                 name: pkg.name,
-                packageJsonPath: pkg.packageJsonPaths[0], // Use first path for display
-                packageJsonPaths: pkg.packageJsonPaths, // Store all paths for upgrading
-                currentVersionSpecifier: pkg.currentVersion, // Keep original with prefix
+                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,
             };
         });
-        // Use custom interactive table selector (simplified - no grouping)
-        const selectedStates = await this.interactiveTableSelector(selectionStates);
-        // Convert to PackageUpgradeChoice[] - create one choice per package.json path
+    }
+    createPendingSelectionStates(packages, previousSelections) {
+        const uniquePackages = this.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,
+            };
+        });
+    }
+    appendOutdatedBatchToSelectionStates(selectionStates, batch, previousSelections) {
+        const outdatedStates = this.createSelectionStates(batch.flatMap((batchItem) => batchItem.packageInfo).filter((pkg) => pkg.isOutdated), previousSelections, false);
+        if (outdatedStates.length === 0) {
+            return;
+        }
+        const seen = new Set(selectionStates.map((state) => `${state.name}@${state.currentVersionSpecifier}@${state.type}`));
+        outdatedStates.forEach((state) => {
+            const key = `${state.name}@${state.currentVersionSpecifier}@${state.type}`;
+            if (!seen.has(key)) {
+                selectionStates.push(state);
+                seen.add(key);
+            }
+        });
+    }
+    async selectPackagesToUpgradeProgressive(selectionStates, progress, attachRefresh) {
+        const selectedStates = await this.interactiveTableSelector(selectionStates, progress, attachRefresh);
+        return this.createUpgradeChoices(selectedStates);
+    }
+    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);
+        }));
+    }
+    createUpgradeChoices(selectedStates) {
         const choices = [];
         selectedStates
-            .filter((state) => state.selectedOption !== 'none')
+            .filter((state) => state.loadState === 'ready' && state.selectedOption !== 'none')
             .forEach((state) => {
             const targetVersion = state.selectedOption === 'range' ? state.rangeVersion : state.latestVersion;
             const targetVersionWithPrefix = ui_1.VersionUtils.applyVersionPrefix(state.currentVersionSpecifier, targetVersion);
-            // Create a choice for each package.json path where this package appears
             const pathsToUpdate = state.packageJsonPaths || [state.packageJsonPath];
             pathsToUpdate.forEach((packageJsonPath) => {
                 choices.push({
@@ -143,10 +185,11 @@ class InteractiveUI {
         }
         return 24; // Fallback default
     }
-    async interactiveTableSelector(selectionStates) {
+    async interactiveTableSelector(selectionStates, loadingProgress, attachRefresh) {
         return new Promise((resolve) => {
-            const states = [...selectionStates];
+            const states = selectionStates;
             const stateManager = new ui_1.StateManager(0, this.getTerminalHeight());
+            let isResolved = false;
             // No grouping needed - packages are already filtered by type
             // This simplifies scrolling and avoids rendering issues
             stateManager.setRenderableItems([]);
@@ -199,21 +242,25 @@ class InteractiveUI {
                             // Opening modal - load package info asynchronously
                             stateManager.toggleInfoModal();
                             const currentState = filteredStates[uiState.currentRow];
-                            stateManager.setModalLoading(true);
+                            const canFetchMetadata = currentState?.loadState === 'ready';
+                            stateManager.setModalLoading(canFetchMetadata);
                             renderInterface();
-                            // Fetch metadata asynchronously
-                            services_1.changelogFetcher.fetchPackageMetadata(currentState.name).then((metadata) => {
-                                if (metadata) {
-                                    currentState.description = metadata.description;
-                                    currentState.homepage = metadata.homepage;
-                                    currentState.repository = metadata.releaseNotes;
-                                    currentState.weeklyDownloads = metadata.weeklyDownloads;
-                                    currentState.author = metadata.author;
-                                    currentState.license = metadata.license;
-                                }
-                                stateManager.setModalLoading(false);
-                                renderInterface();
-                            });
+                            if (currentState && canFetchMetadata) {
+                                services_1.changelogFetcher
+                                    .fetchPackageMetadata(currentState.name, currentState.latestVersion)
+                                    .then((metadata) => {
+                                    if (metadata) {
+                                        currentState.description = metadata.description;
+                                        currentState.homepage = metadata.homepage;
+                                        currentState.repository = metadata.releaseNotes;
+                                        currentState.weeklyDownloads = metadata.weeklyDownloads;
+                                        currentState.author = metadata.author;
+                                        currentState.license = metadata.license;
+                                    }
+                                    stateManager.setModalLoading(false);
+                                    renderInterface();
+                                });
+                            }
                         }
                         else {
                             // Closing modal
@@ -277,6 +324,7 @@ class InteractiveUI {
                 }
             };
             const handleConfirm = (selectedStates) => {
+                isResolved = true;
                 // Reset terminal colors
                 process.stdout.write((0, themes_colors_1.getTerminalResetCode)());
                 ui_1.CursorUtils.show();
@@ -290,6 +338,7 @@ class InteractiveUI {
                 resolve(selectedStates);
             };
             const handleCancel = () => {
+                isResolved = true;
                 // Reset terminal colors
                 process.stdout.write((0, themes_colors_1.getTerminalResetCode)());
                 ui_1.CursorUtils.show();
@@ -370,7 +419,7 @@ class InteractiveUI {
                     const lines = this.renderer.renderInterface(filteredStates, uiState.currentRow, uiState.scrollOffset, uiState.maxVisibleItems, uiState.forceFullRender, [], // No renderable items - use flat rendering
                     activeFilterLabel, // Show current dependency type filter state
                     this.packageManager, // Pass package manager info for header
-                    uiState.filterMode, uiState.filterQuery, states.length, terminalWidth);
+                    uiState.filterMode, uiState.filterQuery, states.length, terminalWidth, loadingProgress);
                     // Print all lines
                     lines.forEach((line) => console.log(line));
                     // Clear any remaining lines from previous render
@@ -389,6 +438,11 @@ class InteractiveUI {
             };
             // Setup keypress handling
             try {
+                attachRefresh?.(() => {
+                    if (!isResolved) {
+                        renderInterface();
+                    }
+                });
                 keypress(process.stdin);
                 if (process.stdin.setRawMode) {
                     process.stdin.setRawMode(true);

package/dist/services/changelog-fetcher.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.changelogFetcher = exports.ChangelogFetcher = void 0;
 const constants_1 = require("../config/constants");
+const jsdelivr_registry_1 = require("./jsdelivr-registry");
 /**
  * Fetches package metadata from npm registry
  * Includes description, repository info, and basic metadata
@@ -10,38 +11,62 @@ class ChangelogFetcher {
     constructor() {
         this.cache = new Map();
         this.failureCache = new Set(); // Track packages that failed to fetch
+        this.inFlight = new Map();
+    }
+    getCacheKey(packageName, version) {
+        return `${packageName}@${version?.trim() || 'latest'}`;
     }
     /**
      * Fetch package metadata from npm registry
      * Uses a cached approach to avoid repeated requests
      */
-    async fetchPackageMetadata(packageName) {
+    async fetchPackageMetadata(packageName, version) {
+        const cacheKey = this.getCacheKey(packageName, version);
         // Check if we already have this in cache
-        if (this.cache.has(packageName)) {
-            return this.cache.get(packageName);
+        if (this.cache.has(cacheKey)) {
+            return this.cache.get(cacheKey);
         }
         // Check if we already failed to fetch this
-        if (this.failureCache.has(packageName)) {
+        if (this.failureCache.has(cacheKey)) {
             return null;
         }
+        const inFlight = this.inFlight.get(cacheKey);
+        if (inFlight) {
+            return await inFlight;
+        }
+        const lookupPromise = this.fetchAndCachePackageMetadata(packageName, version).finally(() => {
+            this.inFlight.delete(cacheKey);
+        });
+        this.inFlight.set(cacheKey, lookupPromise);
+        return await lookupPromise;
+    }
+    async fetchAndCachePackageMetadata(packageName, version) {
+        const cacheKey = this.getCacheKey(packageName, version);
         try {
-            // Fetch from npm registry
-            const response = await this.fetchFromRegistry(packageName);
+            const response = await this.fetchPackageManifest(packageName, version);
             if (!response) {
-                this.failureCache.add(packageName);
+                this.failureCache.add(cacheKey);
                 return null;
             }
-            const repositoryUrl = this.extractRepositoryUrl(response.repository?.url || '');
+            const repository = response.repository;
+            const bugs = response.bugs;
+            const keywords = Array.isArray(response.keywords) ? response.keywords : [];
+            const author = typeof response.author === 'object' && response.author !== null
+                ? (response.author.name ?? response.author)
+                : response.author;
+            const repositoryUrl = this.extractRepositoryUrl(repository?.url || '');
             const npmUrl = `https://www.npmjs.com/package/${encodeURIComponent(packageName)}`;
             const issuesUrl = repositoryUrl ? `${repositoryUrl}/issues` : undefined;
             const metadata = {
-                description: response.description || 'No description available',
-                homepage: response.homepage,
-                repository: response.repository,
-                bugs: response.bugs,
-                keywords: response.keywords || [],
-                author: response.author?.name || response.author,
-                license: response.license,
+                description: typeof response.description === 'string' && response.description
+                    ? response.description
+                    : 'No description available',
+                homepage: typeof response.homepage === 'string' ? response.homepage : undefined,
+                repository,
+                bugs,
+                keywords,
+                author: typeof author === 'string' ? author : undefined,
+                license: typeof response.license === 'string' ? response.license : undefined,
                 repositoryUrl,
                 npmUrl,
                 issuesUrl,
@@ -60,23 +85,29 @@ class ChangelogFetcher {
             catch {
                 // Ignore download stats errors - optional data
             }
-            this.cache.set(packageName, metadata);
+            this.cache.set(cacheKey, metadata);
             return metadata;
         }
-        catch (error) {
+        catch {
             // Cache the failure to avoid retrying
-            this.failureCache.add(packageName);
+            this.failureCache.add(cacheKey);
             return null;
         }
     }
     /**
-     * Fetch data from jsdelivr CDN
-     * Returns the package data by fetching package.json directly from jsdelivr
+     * Fetch metadata from a lightweight manifest endpoint.
      */
-    async fetchFromRegistry(packageName) {
+    async fetchPackageManifest(packageName, version) {
         try {
-            // Fetch package.json directly from jsdelivr CDN (resolves to latest automatically)
-            const response = await fetch(`${constants_1.JSDELIVR_CDN_URL}/${encodeURIComponent(packageName)}@latest/package.json`, {
+            const normalizedVersion = version?.trim();
+            if (normalizedVersion) {
+                const jsdelivrManifest = await (0, jsdelivr_registry_1.fetchExactPackageManifest)(packageName, normalizedVersion);
+                if (jsdelivrManifest) {
+                    return jsdelivrManifest;
+                }
+            }
+            const npmPath = normalizedVersion ? normalizedVersion : 'latest';
+            const response = await fetch(`${constants_1.NPM_REGISTRY_URL}/${encodeURIComponent(packageName)}/${encodeURIComponent(npmPath)}`, {
                 method: 'GET',
                 headers: {
                     accept: 'application/json',
@@ -85,16 +116,7 @@ class ChangelogFetcher {
             if (!response.ok) {
                 return null;
             }
-            const pkgData = (await response.json());
-            return {
-                description: pkgData.description,
-                homepage: pkgData.homepage,
-                repository: pkgData.repository,
-                bugs: pkgData.bugs,
-                keywords: (pkgData.keywords || []),
-                author: pkgData.author,
-                license: pkgData.license,
-            };
+            return (await response.json());
         }
         catch {
             return null;
@@ -147,7 +169,9 @@ class ChangelogFetcher {
      * Get repository release URL for a package
      */
     getRepositoryReleaseUrl(packageName, version) {
-        const metadata = this.cache.get(packageName);
+        const metadata = this.cache.get(this.getCacheKey(packageName, version)) ??
+            this.cache.get(this.getCacheKey(packageName)) ??
+            this.cache.get(packageName);
         if (!metadata || !metadata.releaseNotes) {
             return null;
         }
@@ -183,6 +207,7 @@ class ChangelogFetcher {
     clearCache() {
         this.cache.clear();
         this.failureCache.clear();
+        this.inFlight.clear();
     }
 }
 exports.ChangelogFetcher = ChangelogFetcher;

package/dist/services/index.js

@@ -21,6 +21,4 @@ __exportStar(require("./npm-registry"), exports);
 __exportStar(require("./jsdelivr-registry"), exports);
 __exportStar(require("./changelog-fetcher"), exports);
 __exportStar(require("./version-checker"), exports);
-__exportStar(require("./persistent-cache"), exports);
-__exportStar(require("./cache-manager"), exports);
 //# sourceMappingURL=index.js.map