inup 1.4.12 → 1.5.1

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

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

@@ -0,0 +1,180 @@
+"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.ReleaseNotesService = void 0;
+const semver = __importStar(require("semver"));
+const github_client_1 = require("../clients/github-client");
+const changelog_parser_1 = require("../parsers/changelog-parser");
+const github_release_html_parser_1 = require("../parsers/github-release-html-parser");
+const constants_1 = require("../../../config/constants");
+const RELEASE_NOTES_FETCH_TIMEOUT_MS = 5000;
+const PREFER_GITHUB_RELEASE_PAGE = true;
+class ReleaseNotesService {
+    constructor(metadataService, githubClient = new github_client_1.GitHubClient()) {
+        this.metadataService = metadataService;
+        this.githubClient = githubClient;
+        this.releaseNotesCache = new Map();
+        this.releaseNotesInFlight = new Map();
+    }
+    clearCache() {
+        this.releaseNotesCache.clear();
+        this.releaseNotesInFlight.clear();
+        this.githubClient.clearCache();
+    }
+    async fetchReleaseNotesForVersion(packageName, version, signal) {
+        const cacheKey = `release-notes:${packageName}@${version}`;
+        if (this.releaseNotesCache.has(cacheKey)) {
+            return this.releaseNotesCache.get(cacheKey);
+        }
+        const inFlight = this.releaseNotesInFlight.get(cacheKey);
+        if (inFlight) {
+            return await inFlight;
+        }
+        const promise = this.doFetchReleaseNotes(packageName, version, signal)
+            .then((result) => {
+            this.releaseNotesCache.set(cacheKey, result);
+            return result;
+        })
+            .finally(() => {
+            this.releaseNotesInFlight.delete(cacheKey);
+        });
+        this.releaseNotesInFlight.set(cacheKey, promise);
+        return await promise;
+    }
+    async doFetchReleaseNotes(packageName, version, callerSignal) {
+        const timeoutSignal = AbortSignal.timeout(RELEASE_NOTES_FETCH_TIMEOUT_MS);
+        const signal = callerSignal ? AbortSignal.any([callerSignal, timeoutSignal]) : timeoutSignal;
+        signal.throwIfAborted();
+        const metadata = this.metadataService.getCached(packageName, version) ??
+            (await this.metadataService.fetchPackageMetadata(packageName, version, signal));
+        const repoUrl = metadata?.repositoryUrl || '';
+        if (repoUrl.includes('github.com')) {
+            for (const loadSource of this.getGitHubSources(repoUrl, version, signal)) {
+                const notes = await loadSource();
+                if (notes)
+                    return notes;
+            }
+        }
+        const changelogNotes = await this.fetchJsdelivrChangelog(packageName, version, signal);
+        if (changelogNotes)
+            return changelogNotes;
+        return null;
+    }
+    getGitHubSources(repoUrl, version, signal) {
+        const directReleaseSources = PREFER_GITHUB_RELEASE_PAGE
+            ? [
+                () => this.fetchGitHubReleasePageNotes(repoUrl, version, signal),
+                () => this.fetchGitHubReleaseNotes(repoUrl, version, signal),
+            ]
+            : [
+                () => this.fetchGitHubReleaseNotes(repoUrl, version, signal),
+                () => this.fetchGitHubReleasePageNotes(repoUrl, version, signal),
+            ];
+        return [
+            ...directReleaseSources,
+            () => this.fetchGitHubReleaseListNotes(repoUrl, version, signal),
+            () => this.fetchGitHubChangelogMd(repoUrl, version, signal),
+        ];
+    }
+    async fetchGitHubReleasePageNotes(repoUrl, version, signal) {
+        for (const tag of [`v${version}`, version]) {
+            const html = await this.githubClient.fetchReleasePageHtml(repoUrl, tag, signal);
+            if (!html)
+                continue;
+            const extracted = (0, github_release_html_parser_1.extractReleaseNotesFromHtml)(html);
+            if (extracted)
+                return extracted;
+        }
+        return null;
+    }
+    async fetchGitHubReleaseNotes(repoUrl, version, signal) {
+        for (const tag of [`v${version}`, version]) {
+            const notes = await this.githubClient.fetchReleaseByTag(repoUrl, tag, signal);
+            if (notes)
+                return notes;
+        }
+        return null;
+    }
+    async fetchGitHubReleaseListNotes(repoUrl, version, signal) {
+        const releases = await this.githubClient.fetchReleases(repoUrl, signal);
+        if (!releases)
+            return null;
+        const normalizedVersion = semver.clean(version);
+        if (!normalizedVersion)
+            return null;
+        for (const release of releases) {
+            if (release.draft)
+                continue;
+            const releaseVersion = (0, changelog_parser_1.normalizeReleaseTag)(release.tag_name);
+            if (releaseVersion !== normalizedVersion)
+                continue;
+            if (release.body?.trim()) {
+                return release.body.trim();
+            }
+        }
+        return null;
+    }
+    async fetchGitHubChangelogMd(repoUrl, version, signal) {
+        const fullText = await this.githubClient.fetchRawChangelog(repoUrl, signal);
+        if (!fullText)
+            return null;
+        return (0, changelog_parser_1.extractVersionSection)(fullText, version);
+    }
+    async fetchJsdelivrChangelog(packageName, version, signal) {
+        const fullText = await this.fetchPublishedPackageChangelog(packageName, version, signal);
+        if (!fullText)
+            return null;
+        return (0, changelog_parser_1.extractVersionSection)(fullText, version);
+    }
+    async fetchPublishedPackageChangelog(packageName, version, signal) {
+        try {
+            const response = await fetch(`${constants_1.JSDELIVR_CDN_URL}/${encodeURIComponent(packageName)}@${version}/CHANGELOG.md`, {
+                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;
+        }
+    }
+}
+exports.ReleaseNotesService = ReleaseNotesService;
+//# sourceMappingURL=release-notes-service.js.map

package/dist/features/changelog/types/changelog.types.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=changelog.types.js.map