inup 1.4.12 → 1.5.0

package/dist/cli.js

@@ -25,7 +25,6 @@ program
     .option('--package-manager <name>', 'manually specify package manager (npm, yarn, pnpm, bun)')
     .option('--debug', 'write verbose debug log to /tmp/inup-debug-YYYY-MM-DD.log')
     .action(async (options) => {
-    console.log(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`) + `\n`);
     const cwd = (0, path_1.resolve)(options.dir);
     if (options.debug || process.env.INUP_DEBUG === '1') {
         (0, utils_1.enableDebugLogging)();
@@ -73,6 +72,8 @@ program
         maxDepth,
         ignorePackages,
         packageManager,
+        showPeerDependencyVulnerabilities: projectConfig.showPeerDependencyVulnerabilities ?? false,
+        showOptionalDependencyVulnerabilities: projectConfig.showOptionalDependencyVulnerabilities ?? false,
         debug: options.debug || process.env.INUP_DEBUG === '1',
     });
     await upgrader.run();

package/dist/config/project-config.js

@@ -49,6 +49,12 @@ function normalizeConfig(config) {
             normalized.exclude = config.exclude.filter((item) => typeof item === 'string');
         }
     }
+    if (typeof config.showPeerDependencyVulnerabilities === 'boolean') {
+        normalized.showPeerDependencyVulnerabilities = config.showPeerDependencyVulnerabilities;
+    }
+    if (typeof config.showOptionalDependencyVulnerabilities === 'boolean') {
+        normalized.showOptionalDependencyVulnerabilities = config.showOptionalDependencyVulnerabilities;
+    }
     return normalized;
 }
 /**

package/dist/core/package-detector.js

@@ -44,7 +44,7 @@ class PackageDetector {
     constructor(options) {
         this.packageJsonPath = null;
         this.packageJson = null;
-        this.batchSizes = [10, 15, 20, 25];
+        this.batchSize = 25;
         this.batchConcurrency = 5;
         this.cwd = options?.cwd || process.cwd();
         this.excludePatterns = options?.excludePatterns || [];
@@ -115,7 +115,7 @@ class PackageDetector {
                 },
             });
         }, prepared.currentVersions, {
-            batchSizes: this.batchSizes,
+            batchSize: this.batchSize,
             concurrency: this.batchConcurrency,
         });
         utils_3.debugLog.perf('PackageDetector', `registry fetch (${resolved}/${prepared.uniquePackages.length} resolved)`, tFetch);
@@ -245,6 +245,7 @@ class PackageDetector {
                     isOutdated,
                     hasRangeUpdate,
                     hasMajorUpdate,
+                    allVersions,
                 };
             }
             catch (error) {

package/dist/core/upgrade-runner.js

@@ -9,6 +9,7 @@ const package_detector_1 = require("./package-detector");
 const interactive_ui_1 = require("../interactive-ui");
 const upgrader_1 = require("./upgrader");
 const package_manager_detector_1 = require("../services/package-manager-detector");
+const utils_1 = require("../ui/utils");
 /**
  * Main orchestrator for the inup upgrade process
  */
@@ -24,7 +25,10 @@ class UpgradeRunner {
             this.packageManager = package_manager_detector_1.PackageManagerDetector.detect(cwd);
         }
         this.detector = new package_detector_1.PackageDetector(options);
-        this.ui = new interactive_ui_1.InteractiveUI(this.packageManager);
+        this.ui = new interactive_ui_1.InteractiveUI(this.packageManager, {
+            showPeerDependencyVulnerabilities: options?.showPeerDependencyVulnerabilities ?? false,
+            showOptionalDependencyVulnerabilities: options?.showOptionalDependencyVulnerabilities ?? false,
+        });
         this.upgrader = new upgrader_1.PackageUpgrader(this.packageManager);
     }
     async run() {
@@ -114,8 +118,7 @@ class UpgradeRunner {
                 shouldProceed = await this.ui.confirmUpgrade(selectedChoices);
                 if (shouldProceed === null) {
                     // User pressed N or ESC - go back to selection with current selections preserved
-                    console.clear();
-                    console.log(chalk_1.default.bold.blue('🚀 inup\n'));
+                    utils_1.ConsoleUtils.clearProgress();
                     selectedChoices = progress.isLoading
                         ? await this.ui.selectPackagesToUpgradeProgressive(selectionStates, progress, (refresh) => {
                             refreshUI = refresh;

package/dist/features/changelog/clients/github-client.js

@@ -0,0 +1,134 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GitHubClient = void 0;
+const repository_ref_1 = require("../parsers/repository-ref");
+const GITHUB_RELEASES_PAGE_LIMIT = 3;
+class GitHubClient {
+    constructor() {
+        this.releasesCache = new Map();
+        this.rawChangelogCache = new Map();
+    }
+    clearCache() {
+        this.releasesCache.clear();
+        this.rawChangelogCache.clear();
+    }
+    async fetchReleaseByTag(repoUrl, tag, signal) {
+        const repo = (0, repository_ref_1.parseGitHubRepo)(repoUrl);
+        if (!repo)
+            return null;
+        try {
+            const response = await fetch(`https://api.github.com/repos/${repo.owner}/${repo.repo}/releases/tags/${tag}`, {
+                method: 'GET',
+                headers: {
+                    accept: 'application/vnd.github.v3+json',
+                    'user-agent': 'inup-cli',
+                },
+                signal,
+            });
+            if (!response.ok)
+                return null;
+            const data = (await response.json());
+            return data.body?.trim() ? data.body.trim() : null;
+        }
+        catch (error) {
+            if (error instanceof DOMException && error.name === 'AbortError') {
+                throw error;
+            }
+            return null;
+        }
+    }
+    async fetchReleasePageHtml(repoUrl, tag, signal) {
+        const repo = (0, repository_ref_1.parseGitHubRepo)(repoUrl);
+        if (!repo)
+            return null;
+        try {
+            const response = await fetch(`https://github.com/${repo.owner}/${repo.repo}/releases/tag/${tag}`, {
+                method: 'GET',
+                signal,
+            });
+            if (!response.ok)
+                return null;
+            return await response.text();
+        }
+        catch (error) {
+            if (error instanceof DOMException && error.name === 'AbortError') {
+                throw error;
+            }
+            return null;
+        }
+    }
+    async fetchReleases(repoUrl, signal) {
+        const repo = (0, repository_ref_1.parseGitHubRepo)(repoUrl);
+        if (!repo)
+            return null;
+        const cacheKey = `${repo.owner}/${repo.repo}`;
+        if (this.releasesCache.has(cacheKey)) {
+            return this.releasesCache.get(cacheKey);
+        }
+        const releases = [];
+        for (let page = 1; page <= GITHUB_RELEASES_PAGE_LIMIT; page += 1) {
+            try {
+                const response = await fetch(`https://api.github.com/repos/${repo.owner}/${repo.repo}/releases?per_page=100&page=${page}`, {
+                    method: 'GET',
+                    headers: {
+                        accept: 'application/vnd.github.v3+json',
+                        'user-agent': 'inup-cli',
+                    },
+                    signal,
+                });
+                if (!response.ok)
+                    break;
+                const pageReleases = (await response.json());
+                if (!Array.isArray(pageReleases) || pageReleases.length === 0)
+                    break;
+                releases.push(...pageReleases);
+                if (pageReleases.length < 100)
+                    break;
+            }
+            catch (error) {
+                if (error instanceof DOMException && error.name === 'AbortError') {
+                    throw error;
+                }
+                break;
+            }
+        }
+        const result = releases.length > 0 ? releases : null;
+        this.releasesCache.set(cacheKey, result);
+        return result;
+    }
+    async fetchRawChangelog(repoUrl, signal) {
+        const repo = (0, repository_ref_1.parseGitHubRepo)(repoUrl);
+        if (!repo)
+            return null;
+        const cacheKey = `${repo.owner}/${repo.repo}`;
+        if (this.rawChangelogCache.has(cacheKey)) {
+            return this.rawChangelogCache.get(cacheKey);
+        }
+        const branches = ['main', 'master'];
+        const filenames = ['CHANGELOG.md', 'CHANGES.md', 'HISTORY.md'];
+        for (const branch of branches) {
+            for (const filename of filenames) {
+                try {
+                    const response = await fetch(`https://raw.githubusercontent.com/${repo.owner}/${repo.repo}/${branch}/${filename}`, {
+                        method: 'GET',
+                        signal,
+                    });
+                    if (response.ok) {
+                        const text = await response.text();
+                        this.rawChangelogCache.set(cacheKey, text);
+                        return text;
+                    }
+                }
+                catch (error) {
+                    if (error instanceof DOMException && error.name === 'AbortError') {
+                        throw error;
+                    }
+                }
+            }
+        }
+        this.rawChangelogCache.set(cacheKey, null);
+        return null;
+    }
+}
+exports.GitHubClient = GitHubClient;
+//# sourceMappingURL=github-client.js.map

package/dist/features/changelog/clients/npm-registry-client.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NpmRegistryClient = void 0;
+const constants_1 = require("../../../config/constants");
+class NpmRegistryClient {
+    async fetchPackageManifest(packageName, version, signal) {
+        try {
+            const response = await fetch(`${constants_1.NPM_REGISTRY_URL}/${encodeURIComponent(packageName)}/${encodeURIComponent(version)}`, {
+                method: 'GET',
+                headers: {
+                    accept: 'application/json',
+                },
+                signal,
+            });
+            if (!response.ok) {
+                return null;
+            }
+            return (await response.json());
+        }
+        catch (error) {
+            if (error instanceof DOMException && error.name === 'AbortError') {
+                throw error;
+            }
+            return null;
+        }
+    }
+    async fetchDownloadStats(packageName, signal) {
+        try {
+            const response = await fetch(`https://api.npmjs.org/downloads/point/last-week/${encodeURIComponent(packageName)}`, {
+                method: 'GET',
+                headers: {
+                    accept: 'application/json',
+                },
+                signal,
+            });
+            if (!response.ok) {
+                return null;
+            }
+            const data = (await response.json());
+            return {
+                downloads: data.downloads || 0,
+            };
+        }
+        catch (error) {
+            if (error instanceof DOMException && error.name === 'AbortError') {
+                throw error;
+            }
+            return null;
+        }
+    }
+}
+exports.NpmRegistryClient = NpmRegistryClient;
+//# sourceMappingURL=npm-registry-client.js.map

package/dist/features/changelog/index.js

@@ -0,0 +1,19 @@
+"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/changelog.types"), exports);
+__exportStar(require("./services/changelog-service"), exports);
+//# sourceMappingURL=index.js.map

package/dist/features/changelog/parsers/changelog-parser.js

@@ -0,0 +1,68 @@
+"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.normalizeReleaseTag = normalizeReleaseTag;
+exports.extractVersionSection = extractVersionSection;
+const semver = __importStar(require("semver"));
+function normalizeReleaseTag(tagName) {
+    if (!tagName)
+        return null;
+    const cleanedTag = semver.clean(tagName);
+    if (cleanedTag)
+        return cleanedTag;
+    const semverMatch = tagName.match(/\d+\.\d+\.\d+(?:-[0-9A-Za-z-.]+)?(?:\+[0-9A-Za-z-.]+)?/);
+    if (!semverMatch)
+        return null;
+    return semver.clean(semverMatch[0]);
+}
+function extractVersionSection(changelog, version) {
+    const escapedVersion = version.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    const sectionRegex = new RegExp(`^##\\s+\\[?v?${escapedVersion}\\]?[^\\n]*\\n`, 'm');
+    const match = sectionRegex.exec(changelog);
+    if (!match)
+        return null;
+    const startIndex = match.index + match[0].length;
+    const nextSectionMatch = /^## /m.exec(changelog.slice(startIndex));
+    const endIndex = nextSectionMatch ? startIndex + nextSectionMatch.index : changelog.length;
+    const section = changelog.slice(startIndex, endIndex).trim();
+    if (section.length === 0)
+        return null;
+    const lines = section.split('\n');
+    if (lines.length > 100) {
+        return `${lines.slice(0, 100).join('\n')}\n...`;
+    }
+    return section;
+}
+//# sourceMappingURL=changelog-parser.js.map

package/dist/features/changelog/parsers/github-release-html-parser.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractReleaseNotesFromHtml = extractReleaseNotesFromHtml;
+function extractReleaseNotesFromHtml(html) {
+    const bodyContentIndex = html.indexOf('data-test-selector="body-content"');
+    if (bodyContentIndex === -1)
+        return null;
+    const markdownBodyIndex = html.indexOf('class="markdown-body', bodyContentIndex);
+    if (markdownBodyIndex === -1)
+        return null;
+    const contentStart = html.indexOf('>', markdownBodyIndex);
+    if (contentStart === -1)
+        return null;
+    let depth = 1;
+    let cursor = contentStart + 1;
+    while (depth > 0 && cursor < html.length) {
+        const nextOpen = html.indexOf('<div', cursor);
+        const nextClose = html.indexOf('</div>', cursor);
+        if (nextClose === -1)
+            return null;
+        if (nextOpen !== -1 && nextOpen < nextClose) {
+            depth += 1;
+            cursor = nextOpen + 4;
+        }
+        else {
+            depth -= 1;
+            cursor = nextClose + 6;
+        }
+    }
+    if (depth !== 0)
+        return null;
+    const normalized = html
+        .slice(contentStart + 1, cursor - 6)
+        .replace(/<svg[\s\S]*?<\/svg>/g, '')
+        .replace(/<h([1-6])[^>]*>/g, (_full, level) => `${'#'.repeat(Number(level))} `)
+        .replace(/<\/h[1-6]>/g, '\n\n')
+        .replace(/<li[^>]*>/g, '- ')
+        .replace(/<\/li>/g, '\n')
+        .replace(/<p[^>]*>/g, '')
+        .replace(/<\/p>/g, '\n\n')
+        .replace(/<br\s*\/?>/g, '\n')
+        .replace(/<a\b[^>]*>([\s\S]*?)<\/a>/g, '$1')
+        .replace(/<strong[^>]*>([\s\S]*?)<\/strong>/g, '**$1**')
+        .replace(/<code[^>]*>([\s\S]*?)<\/code>/g, '`$1`')
+        .replace(/<[^>]+>/g, '');
+    const decoded = normalized
+        .replace(/&amp;/g, '&')
+        .replace(/&lt;/g, '<')
+        .replace(/&gt;/g, '>')
+        .replace(/&quot;/g, '"')
+        .replace(/&#39;/g, "'")
+        .replace(/&nbsp;/g, ' ');
+    const cleaned = decoded
+        .split('\n')
+        .map((line) => line.trimEnd())
+        .join('\n')
+        .replace(/\n{3,}/g, '\n\n')
+        .trim();
+    return cleaned.length > 0 ? cleaned : null;
+}
+//# sourceMappingURL=github-release-html-parser.js.map

package/dist/features/changelog/parsers/package-metadata.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mapPackageManifestToMetadata = mapPackageManifestToMetadata;
+const repository_ref_1 = require("./repository-ref");
+function mapPackageManifestToMetadata(packageName, rawData) {
+    const repository = rawData.repository;
+    const bugs = rawData.bugs;
+    const keywords = Array.isArray(rawData.keywords) ? rawData.keywords : [];
+    const author = typeof rawData.author === 'object' && rawData.author !== null
+        ? (rawData.author.name ?? rawData.author)
+        : rawData.author;
+    const repositoryUrl = (0, repository_ref_1.extractRepositoryUrl)(repository?.url || '');
+    const npmUrl = `https://www.npmjs.com/package/${encodeURIComponent(packageName)}`;
+    const issuesUrl = repositoryUrl ? `${repositoryUrl}/issues` : undefined;
+    const metadata = {
+        description: typeof rawData.description === 'string' && rawData.description
+            ? rawData.description
+            : 'No description available',
+        homepage: typeof rawData.homepage === 'string' ? rawData.homepage : undefined,
+        repository,
+        bugs,
+        keywords,
+        author: typeof author === 'string' ? author : undefined,
+        license: typeof rawData.license === 'string' ? rawData.license : undefined,
+        repositoryUrl,
+        npmUrl,
+        issuesUrl,
+    };
+    if (repositoryUrl) {
+        metadata.releaseNotes = `${repositoryUrl}/releases`;
+    }
+    return metadata;
+}
+//# sourceMappingURL=package-metadata.js.map

package/dist/features/changelog/parsers/repository-ref.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractRepositoryUrl = extractRepositoryUrl;
+exports.parseGitHubRepo = parseGitHubRepo;
+function extractRepositoryUrl(repoUrl) {
+    if (!repoUrl)
+        return '';
+    let cleanUrl = repoUrl
+        .replace(/^git\+/, '')
+        .replace(/\.git$/, '')
+        .replace(/^github:/, 'https://github.com/');
+    if (!cleanUrl.startsWith('http')) {
+        cleanUrl = `https://github.com/${cleanUrl}`;
+    }
+    return cleanUrl;
+}
+function parseGitHubRepo(repoUrl) {
+    const match = repoUrl.match(/github\.com\/([^/]+)\/([^/]+)/);
+    if (!match)
+        return null;
+    return {
+        owner: match[1],
+        repo: match[2],
+    };
+}
+//# sourceMappingURL=repository-ref.js.map

package/dist/features/changelog/services/changelog-service.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.changelogFetcher = exports.ChangelogFetcher = void 0;
+const package_metadata_service_1 = require("./package-metadata-service");
+const release_notes_service_1 = require("./release-notes-service");
+class ChangelogFetcher {
+    constructor() {
+        this.metadataService = new package_metadata_service_1.PackageMetadataService();
+        this.releaseNotesService = new release_notes_service_1.ReleaseNotesService(this.metadataService);
+    }
+    async fetchPackageMetadata(packageName, version, signal) {
+        return await this.metadataService.fetchPackageMetadata(packageName, version, signal);
+    }
+    getRepositoryReleaseUrl(packageName, version) {
+        return this.metadataService.getRepositoryReleaseUrl(packageName, version);
+    }
+    cacheMetadata(packageName, rawData) {
+        this.metadataService.cacheMetadata(packageName, rawData);
+    }
+    async fetchReleaseNotesForVersion(packageName, version, signal) {
+        return await this.releaseNotesService.fetchReleaseNotesForVersion(packageName, version, signal);
+    }
+    clearCache() {
+        this.metadataService.clearCache();
+        this.releaseNotesService.clearCache();
+    }
+}
+exports.ChangelogFetcher = ChangelogFetcher;
+exports.changelogFetcher = new ChangelogFetcher();
+//# sourceMappingURL=changelog-service.js.map

package/dist/features/changelog/services/package-metadata-service.js

@@ -0,0 +1,108 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PackageMetadataService = void 0;
+const npm_registry_client_1 = require("../clients/npm-registry-client");
+const package_metadata_1 = require("../parsers/package-metadata");
+const jsdelivr_registry_1 = require("../../../services/jsdelivr-registry");
+class PackageMetadataService {
+    constructor(npmRegistryClient = new npm_registry_client_1.NpmRegistryClient(), exactManifestFetcher = jsdelivr_registry_1.fetchExactPackageManifest) {
+        this.npmRegistryClient = npmRegistryClient;
+        this.exactManifestFetcher = exactManifestFetcher;
+        this.cache = new Map();
+        this.inFlight = new Map();
+    }
+    clearCache() {
+        this.cache.clear();
+        this.inFlight.clear();
+    }
+    getCached(packageName, version) {
+        for (const key of [this.getCacheKey(packageName, version), this.getCacheKey(packageName), packageName]) {
+            if (this.cache.has(key)) {
+                return this.cache.get(key) ?? null;
+            }
+        }
+        return null;
+    }
+    async fetchPackageMetadata(packageName, version, signal) {
+        const cacheKey = this.getCacheKey(packageName, version);
+        if (this.cache.has(cacheKey)) {
+            return this.cache.get(cacheKey) ?? null;
+        }
+        const inFlight = this.inFlight.get(cacheKey);
+        if (inFlight) {
+            return await inFlight;
+        }
+        const lookupPromise = this.fetchAndCachePackageMetadata(packageName, version, signal).finally(() => {
+            this.inFlight.delete(cacheKey);
+        });
+        this.inFlight.set(cacheKey, lookupPromise);
+        return await lookupPromise;
+    }
+    cacheMetadata(packageName, rawData) {
+        const metadata = this.buildMetadata(packageName, rawData);
+        this.cache.set(packageName, metadata);
+    }
+    getRepositoryReleaseUrl(packageName, version) {
+        const metadata = this.getCached(packageName, version);
+        if (!metadata?.releaseNotes) {
+            return null;
+        }
+        return `${metadata.releaseNotes}/tag/v${version}`;
+    }
+    getCacheKey(packageName, version) {
+        return `${packageName}@${version?.trim() || 'latest'}`;
+    }
+    cachePackageMetadata(packageName, cacheKey, metadata) {
+        this.cache.set(cacheKey, metadata);
+        this.cache.set(this.getCacheKey(packageName), metadata);
+        this.cache.set(packageName, metadata);
+    }
+    async fetchAndCachePackageMetadata(packageName, version, signal) {
+        const cacheKey = this.getCacheKey(packageName, version);
+        try {
+            signal?.throwIfAborted();
+            const manifest = await this.fetchPackageManifest(packageName, version, signal);
+            if (!manifest) {
+                this.cache.set(cacheKey, null);
+                return null;
+            }
+            const metadata = (0, package_metadata_1.mapPackageManifestToMetadata)(packageName, manifest);
+            try {
+                signal?.throwIfAborted();
+                const downloadsData = await this.npmRegistryClient.fetchDownloadStats(packageName, signal);
+                if (downloadsData) {
+                    metadata.weeklyDownloads = downloadsData.downloads;
+                }
+            }
+            catch {
+                // Optional data should not fail metadata hydration.
+            }
+            this.cachePackageMetadata(packageName, cacheKey, metadata);
+            return metadata;
+        }
+        catch (error) {
+            if (error instanceof DOMException && error.name === 'AbortError') {
+                throw error;
+            }
+            this.cache.set(cacheKey, null);
+            return null;
+        }
+    }
+    async fetchPackageManifest(packageName, version, signal) {
+        signal?.throwIfAborted();
+        const normalizedVersion = version?.trim();
+        if (normalizedVersion) {
+            const jsdelivrManifest = await this.exactManifestFetcher(packageName, normalizedVersion);
+            if (jsdelivrManifest) {
+                return jsdelivrManifest;
+            }
+        }
+        signal?.throwIfAborted();
+        return await this.npmRegistryClient.fetchPackageManifest(packageName, normalizedVersion || 'latest', signal);
+    }
+    buildMetadata(packageName, rawData) {
+        return (0, package_metadata_1.mapPackageManifestToMetadata)(packageName, rawData);
+    }
+}
+exports.PackageMetadataService = PackageMetadataService;
+//# sourceMappingURL=package-metadata-service.js.map