6.7.0 - Alpha6 - Scrapers 工具的更新机制由 "锚点更新" 替换为 "结构化更新"

.utils/scrape-and-inject-ksp-releases-map.mjs

@@ -0,0 +1,175 @@
+// scrape-and-inject-ksp-releases-map.mjs
+// after: [ scrape-and-inject-gradle-kotlin-compatibility-map.mjs ]
+
+import { httpFetch } from './utils/fetch.mjs';
+import { readPropertiesSync } from './utils/properties.mjs';
+import { toUpdatedStamp } from './utils/date.mjs';
+import { updateGradleLinesData } from './utils/update-helper.mjs';
+
+const URL = 'https://api.github.com/repos/google/ksp/releases';
+const GITHUB_TOKEN = process.env.GITHUB_TOKEN;
+
+/**
+ * @returns {Promise<KspRelease[]>}
+ */
+async function fetchKspReleases() {
+    /** @type {import('http').OutgoingHttpHeaders} */
+    const headers = {
+        'accept': 'application/vnd.github+json',
+        'user-agent': 'node',
+        ...(GITHUB_TOKEN ? { 'authorization': `Bearer ${GITHUB_TOKEN}` } : {}),
+    };
+    const minToCheck = await getMinKotlinVersionToCheck();
+    const out = [];
+
+    let page = 1;
+    let reached = false;
+
+    while (!reached) {
+        const query = { per_page: 100, page };
+        /** @type {ReleasesData} */
+        const releases = await httpFetch(URL, { query, headers });
+
+        if (!Array.isArray(releases) || releases.length === 0) break;
+
+        for (const release of releases) {
+            const tag = String(release.tag_name || '').trim();
+            out.push({
+                version: tag,
+                name: release.name,
+                publishedAt: release.published_at,
+            });
+
+            const parts = tag.split('-');
+            if (parts.length < 2) continue;
+            /**
+             * @example string
+             * "2.2.20-2.0.3" -> "2.2.20"
+             * "1.9.10-1.0.13" -> "1.9.10"
+             * "2.2.20-RC2-2.0.2" -> "2.2.20-RC2"
+             * "1.9.20-RC-1.0.13" -> "1.9.20-RC"
+             * @type {string}
+             */
+            const kotlinVer = parts.slice(0, -1).join('-');
+            if (kotlinVer === minToCheck) {
+                reached = true;
+                break;
+            }
+        }
+
+        if (reached) break;
+        page += 1;
+    }
+
+    return out;
+}
+
+async function getMinKotlinVersionToCheck() {
+    const minGradle = readPropertiesSync('../version.properties').get('MIN_SUPPORTED_GRADLE_VERSION');
+    const mapElement = readPropertiesSync('../gradle/data/gradle-kotlin-compat.properties').get(minGradle);
+    if (mapElement) return mapElement;
+    throw new Error(`Failed to find the minimum Kotlin version to check in settings.gradle.kts`);
+}
+
+/**
+ * @param {KspRelease[]} releases
+ * @returns {string[]}
+ */
+function parseReleases(releases) {
+    if (!Array.isArray(releases)) return [];
+
+    // De-duplicate by Kotlin version, keep the latest one by release date.
+    // zh-CN: 根据 Kotlin 版本去重, 保留发布时间最新的一条.
+
+    /** @type {Map<string, { kspVer: string, date: Date }>} */
+    const latestByKotlin = new Map();
+    for (const r of releases) {
+        const rawVer = String(r.version || '').trim();
+        const parts = rawVer.split('-');
+        if (parts.length < 2) continue;
+
+        const kspVer = parts.pop();
+        const KotlinVer = parts.join('-');
+
+        const d = new Date(r.publishedAt);
+        if (Number.isNaN(d.getTime())) continue;
+
+        const prev = latestByKotlin.get(KotlinVer);
+        if (!prev || d > prev.date) {
+            latestByKotlin.set(KotlinVer, { kspVer, date: d });
+        }
+    }
+
+    /**
+     * Parse Kotlin version for sorting.<br>
+     * zh-CN: 解析 Kotlin 版本用于排序.
+     *
+     * @param {string} kotlinVer
+     * @returns {{ baseNums: number[], rank: number, qName: string, qNum: number }}
+     */
+    function parseKotlinVer(kotlinVer) {
+        const [ base, qualifierRaw = '' ] = kotlinVer.split('-', 2);
+        const baseNums = base.split('.').map((n) => parseInt(String(n), 10) || 0);
+
+        let qName = '';
+        let qNum = 0;
+        if (qualifierRaw) {
+            const m = /^([A-Za-z]+)(\d+)?$/i.exec(qualifierRaw.trim());
+            if (m) {
+                qName = m[1].toUpperCase();
+                qNum = m[2] ? parseInt(m[2], 10) : 0;
+            } else {
+                qName = qualifierRaw.toUpperCase();
+            }
+        }
+
+        const rankMap = { '': 3, RC: 2, BETA: 1 };
+        const rank = Object.prototype.hasOwnProperty.call(rankMap, qName) ? rankMap[qName] : 0;
+
+        return { baseNums, rank, qName, qNum };
+    }
+
+    /**
+     * @param {number[]} aNums
+     * @param {number[]} bNums
+     * @returns {number}
+     */
+    function cmpBaseDesc(aNums, bNums) {
+        const len = Math.max(aNums.length, bNums.length);
+        for (let i = 0; i < len; i++) {
+            const av = aNums[i] ?? 0;
+            const bv = bNums[i] ?? 0;
+            if (av !== bv) return bv - av;
+        }
+        return 0;
+    }
+
+    return Array.from(latestByKotlin.entries())
+        .map(([ kotlinVer, v ]) => {
+            const parsed = parseKotlinVer(kotlinVer);
+            return { kotlinVer, kspVer: v.kspVer, date: v.date, parsed };
+        })
+        .sort((a, b) => {
+            const c = cmpBaseDesc(a.parsed.baseNums, b.parsed.baseNums);
+            if (c !== 0) return c;
+            if (a.parsed.rank !== b.parsed.rank) return b.parsed.rank - a.parsed.rank;
+            if (a.parsed.qNum !== b.parsed.qNum) return b.parsed.qNum - a.parsed.qNum;
+            if (a.parsed.qName !== b.parsed.qName) return a.parsed.qName < b.parsed.qName ? 1 : -1;
+            return b.date.getTime() - a.date.getTime();
+        })
+        .map(({ kotlinVer, kspVer, date }) => {
+            return [ `#${toUpdatedStamp(date)}`, `${kotlinVer}=${kspVer}` ];
+        })
+        .flat(1);
+}
+
+(async function main() {
+    const releases = await fetchKspReleases();
+    const lines = parseReleases(releases);
+    await updateGradleLinesData('ksp-releases', lines, {
+        label: 'KSP releases version map',
+    });
+})().catch((err) => {
+    console.error('Failed to fetch KSP releases:', err);
+    process.exitCode = 1;
+});