477 lines
19 KiB
JavaScript
477 lines
19 KiB
JavaScript
// scrape-and-inject-android-studio-codename_maps.mjs
|
|
|
|
/** @typedef {import('puppeteer').Page} Page */
|
|
/** @typedef {import('puppeteer').Frame} Frame */
|
|
/** @typedef {import('./fetch-and-parse-android-studio-latest-stable-version.mjs').StableArchiveItem} Row */
|
|
/** @typedef {import('./fetch-and-parse-android-studio-archives.mjs').ArchiveItem} ArchiveItem */
|
|
/**
|
|
* @template {Node} T
|
|
* @typedef {import('puppeteer').ElementHandle<T>} ElementHandle
|
|
*/
|
|
|
|
import * as fsp from 'node:fs/promises';
|
|
import * as path from 'node:path';
|
|
import { batchUpdateAnchoredBlocks } from './utils/anchors.mjs';
|
|
import { bytes2GiB } from './utils/format.mjs';
|
|
import { compareVersionStrings } from './utils/versioning.mjs';
|
|
import { getAndroidStudioArchives } from './fetch-and-parse-android-studio-archives.mjs';
|
|
import { getLatestStableArchives } from './fetch-and-parse-android-studio-latest-stable-version.mjs';
|
|
import { getRemoteFileSizeBytes } from './utils/fetch.mjs';
|
|
import { toUpdatedStamp, toYYYYMMDD } from './utils/date.mjs';
|
|
|
|
/**
|
|
* Manual override for codename mappings (for resolving codename prefix conflicts).<br>
|
|
* Default is first letter, e.g. 'Meerkat' and 'Bumblebee' gives { Meerkat: 'M', Bumblebee: 'B' }.<br>
|
|
* When first letters conflict, conflicts are auto-resolved,
|
|
* e.g. 'Camel' and 'Catfish' gives { Camel: 'CAM', Catfish: 'CAT' }.<br>
|
|
* For extreme cases where conflicts cannot be auto-resolved,
|
|
* e.g. 'Cat' and 'Catfish', manual prefix mapping is needed, like { Cat: 'CT', Catfish: 'CTF' }.<br>
|
|
* zh-CN:<br>
|
|
* 手动覆盖代号映射 (可用于解决代号前缀冲突).<br>
|
|
* 默认为首字母, 如 'Meerkat' 与 'Bumblebee', 得到 { Meerkat: 'M', Bumblebee: 'B' }.<br>
|
|
* 首字母重复时自动消解冲突, 如 'Camel' 与 'Catfish', 得到 { Camel: 'CAM', Catfish: 'CAT' }.<br>
|
|
* 极端情况无法自动消解冲突, 如 'Cat' 与 'Catfish', 此时需要手动指定前缀, 如 { Cat: 'CT', Catfish: 'CTF' }.
|
|
* @example Object<codename name, codename prefix>
|
|
* {
|
|
* 'Camel': 'CM',
|
|
* 'Cat': 'CT',
|
|
* 'Catfish': 'CTF',
|
|
* ... ...
|
|
* }
|
|
* @type {Object<string, string>}
|
|
*/
|
|
const manualCodenameOverrides = {};
|
|
|
|
/**
|
|
* Use the latest stable version's checksum/filename to locate the entry in archives,
|
|
* complete and update common.json.<br>
|
|
* zh-CN: 用 "最新稳定版" 的校验和/文件名, 在归档中定位条目, 补全并更新 common.json.
|
|
*
|
|
* @param {ArchiveItem[]} archives
|
|
* @returns {Promise<void>}
|
|
*/
|
|
async function updateLatestArchiveInfo(archives) {
|
|
const latestRows = await getLatestStableArchives(); // [ { kind, filename, sha256, url, size, ... } ]
|
|
const latestExe = latestRows.find(x => x.kind === 'exe');
|
|
const latestZip = latestRows.find(x => x.kind === 'zip');
|
|
const latestTar = latestRows.find(x => x.kind === 'tar');
|
|
if (!latestExe || !latestZip || !latestTar) {
|
|
throw new Error('Latest stable archives missing required "kind" info: exe, zip, or tar');
|
|
}
|
|
|
|
/**
|
|
* Search the archive: first try to match by sha256, then by filename.<br>
|
|
* zh-CN: 在归档中查找: 优先用 sha256 命中, 其次用文件名.
|
|
*
|
|
* @param {ArchiveItem[]} rows
|
|
* @param {Row} target
|
|
* @returns {ArchiveItem | null}
|
|
*/
|
|
const matchArchive = (rows, target) => {
|
|
for (const arc of rows) {
|
|
const bySha = target.sha256 && arc.checksums[target.filename] === target.sha256;
|
|
const byName = arc.links.some(l => l.text === target.filename);
|
|
if (bySha || byName) return arc;
|
|
}
|
|
return null;
|
|
};
|
|
const matchedArc = matchArchive(archives, latestExe) || matchArchive(archives, latestZip);
|
|
if (!matchedArc) {
|
|
throw new Error('Could not locate entries in the archive corresponding to the latest version (neither by sha256 nor filename)');
|
|
}
|
|
|
|
/**
|
|
* @param {string} suffix
|
|
* @returns {{ filename: string, url: string, sizeGiB?: string | null } | null}
|
|
*/
|
|
const pickWinItem = (suffix) => {
|
|
const link = matchedArc.links.find(l => l.text.endsWith(suffix));
|
|
if (!link) return null;
|
|
return { filename: link.text, url: link.href };
|
|
};
|
|
const exeItem = pickWinItem('-windows.exe');
|
|
const zipItem = pickWinItem('-windows.zip');
|
|
const tarItem = pickWinItem('-linux.tar.gz');
|
|
|
|
if (!exeItem || !zipItem || !tarItem) {
|
|
throw new Error('Matched archive entry missing Windows EXE/ZIP or Linux TAR download information');
|
|
}
|
|
|
|
// Query real file size (concurrent fetch) and format to GiB.
|
|
// zh-CN: 查询真实文件大小 (并发获取), 格式化为 GiB.
|
|
|
|
const [ exeBytes, zipBytes, tarBytes ] = await Promise.all([
|
|
exeItem ? getRemoteFileSizeBytes(exeItem.url) : Promise.resolve(null),
|
|
zipItem ? getRemoteFileSizeBytes(zipItem.url) : Promise.resolve(null),
|
|
tarItem ? getRemoteFileSizeBytes(tarItem.url) : Promise.resolve(null),
|
|
]);
|
|
if (exeItem) exeItem.sizeGiB = bytes2GiB(exeBytes);
|
|
if (zipItem) zipItem.sizeGiB = bytes2GiB(zipBytes);
|
|
if (tarItem) tarItem.sizeGiB = bytes2GiB(tarBytes);
|
|
|
|
// Prepare fields needed to write back to common.json.
|
|
// zh-CN: 准备写回 common.json 所需字段.
|
|
|
|
const latestVersionName = matchedArc.title.trim(); // e.g. "Android Studio Narwhal Feature Drop | 2025.1.2"
|
|
const latestVersionDate = toYYYYMMDD(matchedArc.date) || ''; // e.g. "2025/07/31"
|
|
|
|
// Read and update common.json (only update keys containing "android_studio_latest_" fragment and version name date key).
|
|
// zh-CN: 读取并更新 common.json (仅更新带有 "android_studio_latest_" 片段的键与版本名日期键).
|
|
|
|
const commonJsonPath = path.resolve(process.cwd(), '../.readme/common.json');
|
|
const commonRaw = await fsp.readFile(commonJsonPath, 'utf8');
|
|
const commonObj = JSON.parse(commonRaw);
|
|
|
|
const updatedCommon = {
|
|
...commonObj,
|
|
android_studio_latest_recommended_version_name: latestVersionName,
|
|
var_date_android_studio_latest_recommended_version_name: latestVersionDate,
|
|
android_studio_latest_recommended_file_name_of_exe: exeItem.filename,
|
|
android_studio_latest_recommended_download_address_of_exe: exeItem.url,
|
|
android_studio_latest_recommended_file_size_of_exe: exeItem.sizeGiB ?? commonObj.android_studio_latest_recommended_file_size_of_exe,
|
|
android_studio_latest_recommended_file_name_of_zip: zipItem.filename,
|
|
android_studio_latest_recommended_download_address_of_zip: zipItem.url,
|
|
android_studio_latest_recommended_file_size_of_zip: zipItem.sizeGiB ?? commonObj.android_studio_latest_recommended_file_size_of_zip,
|
|
android_studio_latest_recommended_file_name_of_tar: tarItem.filename,
|
|
android_studio_latest_recommended_download_address_of_tar: tarItem.url,
|
|
android_studio_latest_recommended_file_size_of_tar: tarItem.sizeGiB ?? commonObj.android_studio_latest_recommended_file_size_of_tar,
|
|
};
|
|
|
|
if (JSON.stringify(updatedCommon) !== JSON.stringify(commonObj)) {
|
|
await fsp.writeFile(commonJsonPath, JSON.stringify(updatedCommon, null, 2), 'utf8');
|
|
console.log('[common.json] Updated (Android Studio information)');
|
|
const from = commonObj.android_studio_latest_recommended_version_name;
|
|
const to = updatedCommon.android_studio_latest_recommended_version_name;
|
|
if (from !== to) {
|
|
const maxLength = Math.max(...[ from, to ].map(s => s.length + 5));
|
|
const SEP_EQ = '='.repeat(maxLength);
|
|
console.log(SEP_EQ);
|
|
console.log(`-- "${from}"`);
|
|
console.log(`-> "${to}"`);
|
|
console.log(SEP_EQ);
|
|
}
|
|
} else {
|
|
// console.log('[common.json] No update needed (Android Studio information)');
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Summarize codename-to-version mappings and codename first release dates.<br>
|
|
* zh-CN: 汇总代号版本映射以及代号的首发日期.
|
|
*
|
|
* @param {ArchiveItem[]} archives
|
|
*/
|
|
function getCodenameMapLinesInfo(archives) {
|
|
|
|
/**
|
|
* Parse "codename and version number" from title,
|
|
* zh-CN: 从标题中解析 "代号与版本号",
|
|
*
|
|
* @example string
|
|
* 'Android Studio Meerkat Feature Drop | 2024.3.2 RC 1'
|
|
*
|
|
* @param {string} title
|
|
* @returns {string | null}
|
|
*/
|
|
const codenameFromTitle = title => {
|
|
// Capture "Android Studio <Codename> [Feature Drop]".
|
|
// zh-CN: 捕获 "Android Studio <Codename> [Feature Drop]".
|
|
const m = /Android Studio\s+(.+?)\s*(?:(\s+\d+\s+)?Feature Drop)?(?=\s*\|)/i.exec(title);
|
|
return m ? m[1].trim() : null;
|
|
};
|
|
|
|
/**
|
|
* Generate unique codes: sequentially, uniformly increase length for conflict groups;
|
|
* override mappings take precedence.<br>
|
|
* zh-CN:<br>
|
|
* 生成唯一代码: 按顺序, 出现冲突则对冲突组统一递增长度; 覆盖映射优先考虑.
|
|
*
|
|
* @example Map<name, prefixCode>
|
|
* Map(14) {
|
|
* 'Arctic Fox' => 'A',
|
|
* 'Bumblebee' => 'B',
|
|
* ... ...
|
|
* 'Narwhal' => 'N'
|
|
* }
|
|
*
|
|
* @param {string[]} names
|
|
* Original codenames (preserves case and spaces, e.g. "Arctic Fox", "Bumblebee", "Narwhal" etc).<br>
|
|
* zh-CN: 原始代号 (保留大小写与空格, 如 "Arctic Fox", "Bumblebee", "Narwhal" 等).
|
|
* @param {Object<string, string>} overrides
|
|
* Manual override mappings.<br>
|
|
* zh-CN: 手动覆盖映射.
|
|
* @returns {Map<string, string>}
|
|
*/
|
|
const buildUniquePrefixes = (names, overrides) => {
|
|
|
|
/**
|
|
* @param {string} s
|
|
* @returns {string}
|
|
*/
|
|
const normalize = (s) => s.replace(/\s+/g, '');
|
|
|
|
/**
|
|
* @param {string} s
|
|
* @param {string} def
|
|
* @returns {string}
|
|
*/
|
|
const normalizeOrDefault = (s, def) => s && normalize(s) || normalize(def);
|
|
|
|
/**
|
|
* @param {string }s
|
|
* @param {number} def
|
|
* @returns {number}
|
|
*/
|
|
const normalizeLength = (s, def) => s && normalize(s).length || def;
|
|
|
|
const entries = names.map(name => {
|
|
const override = overrides[name]?.toUpperCase();
|
|
const base = normalize(name);
|
|
const len = normalizeLength(override, 1);
|
|
const code = normalizeOrDefault(override, base.slice(0, len)).toUpperCase();
|
|
const locked = Boolean(override);
|
|
return { name, base, len, code, locked };
|
|
});
|
|
|
|
// Detect and resolve conflicts. (zh-CN: 检测并解决冲突.)
|
|
const maxLenByName = new Map(entries.map(e => [ e.name, e.base.length ]));
|
|
// Loop limit protection to prevent infinite loops in extreme cases.
|
|
// zh-CN: 循环上限保护, 防止极端情况下死循环.
|
|
for (let step = 0; step < 1 << 10; step++) {
|
|
/**
|
|
* Count conflict groups. (zh-CN: 统计冲突组.)
|
|
* @example Map<code, indices>
|
|
* Map(14) {
|
|
* 'N' => [ 0 ],
|
|
* 'M' => [ 1 ],
|
|
* ... ...
|
|
* 'B' => [ 12 ],
|
|
* 'A' => [ 13 ]
|
|
* }
|
|
* @type {Map<string, number[]>}
|
|
*/
|
|
const bucket = new Map();
|
|
entries.forEach((e, idx) => {
|
|
const key = e.code;
|
|
if (!bucket.has(key)) bucket.set(key, []);
|
|
bucket.get(key).push(idx);
|
|
});
|
|
|
|
const conflicts = Array.from(bucket.entries()).filter(([ _, indices ]) => indices.length >= 2);
|
|
if (conflicts.length === 0) {
|
|
// No conflicts, or all conflicts have been resolved.
|
|
// zh-CN: 没有冲突, 或冲突已全部解决.
|
|
break;
|
|
}
|
|
|
|
for (const [ code, indices ] of conflicts) {
|
|
const lockedIndices = indices.filter(i => entries[i].locked);
|
|
if (lockedIndices.length >= 2) {
|
|
const groupNames = indices.map(i => entries[i].name);
|
|
throw new Error(`[CodenameMap] Manual override mapping conflict: "${code}" -> [ ${groupNames.join(', ')} ]`);
|
|
}
|
|
for (const i of indices) {
|
|
const e = entries[i];
|
|
if (e.locked) continue;
|
|
const maxLen = maxLenByName.get(e.name);
|
|
if (e.len >= maxLen) {
|
|
const groupNames = indices.map(i => entries[i].name);
|
|
throw new Error(`[CodenameMap] Unable to auto-resolve conflicts: [ ${groupNames.join(', ')} ]`);
|
|
}
|
|
e.len += 1;
|
|
e.code = e.base.slice(0, e.len);
|
|
}
|
|
}
|
|
}
|
|
|
|
return new Map(entries.map(e => [ e.name, e.code ]));
|
|
};
|
|
|
|
const codenames = [ ...new Set(archives.map(o => codenameFromTitle(o.title)).filter(Boolean)) ];
|
|
const nameToCode = buildUniquePrefixes(codenames, manualCodenameOverrides);
|
|
|
|
/**
|
|
* @example Map<version, Set<prefixCode>>
|
|
* Map(22) {
|
|
* ... ...
|
|
* '2024.2.1' => Set(1) { 'L' },
|
|
* '2024.1.3' => Set(1) { 'L' },
|
|
* '2024.1.2' => Set(1) { 'K' },
|
|
* '2024.1.1' => Set(1) { 'K' },
|
|
* '2023.3.2' => Set(2) { 'K', 'J' },
|
|
* '2023.3.1' => Set(1) { 'J' },
|
|
* '2023.2.1' => Set(1) { 'I' },
|
|
* ... ...
|
|
* }
|
|
* @type {Map<string, Set<string>>}
|
|
*/
|
|
const versionToLetters = new Map();
|
|
|
|
/**
|
|
* @example Map<prefixCode, { name, born }>
|
|
* Map(14) {
|
|
* 'N' => { name: 'Narwhal', born: 2025-03-18T16:00:00.000Z },
|
|
* 'M' => { name: 'Meerkat', born: 2024-11-11T16:00:00.000Z },
|
|
* ... ...
|
|
* 'B' => { name: 'Bumblebee', born: 2021-05-17T16:00:00.000Z },
|
|
* 'A' => { name: 'Arctic Fox', born: 2021-01-25T16:00:00.000Z }
|
|
* }
|
|
* @type {Map<string, { name: string, born: Date } >}
|
|
*/
|
|
const letterBorn = new Map();
|
|
|
|
for (const arc of archives) {
|
|
if (!arc.version) continue;
|
|
const cname = codenameFromTitle(arc.title);
|
|
if (!cname) continue;
|
|
|
|
const code = nameToCode.get(cname);
|
|
if (!code) continue;
|
|
|
|
if (!versionToLetters.has(arc.version)) versionToLetters.set(arc.version, new Set());
|
|
versionToLetters.get(arc.version).add(code);
|
|
|
|
const d = new Date(arc.date);
|
|
const existed = letterBorn.get(code);
|
|
if (!existed || d < existed.born) {
|
|
letterBorn.set(code, { name: cname, born: d });
|
|
}
|
|
}
|
|
|
|
const sortedVersions = Array.from(versionToLetters.keys()).sort((a, b) => {
|
|
// Split version string into [ y: year, m: minor, p: patch ].
|
|
// zh-CN: 将版本字符串拆分为 [ y: 年份, m: 次版本号, p: 补丁版本号 ].
|
|
// e.g. "2024.3.2" -> [ y: 2024, m: 3, p: 2 ].
|
|
const [ ay, am, ap ] = a.split('.').map(Number);
|
|
const [ by, bm, bp ] = b.split('.').map(Number);
|
|
return by - ay || bm - am || bp - ap;
|
|
});
|
|
|
|
/**
|
|
* @example Array<[version, jointPrefixCode]>
|
|
* [
|
|
* ... ..
|
|
* [ '2024.2.2', 'L' ],
|
|
* [ '2024.2.1', 'L' ],
|
|
* [ '2024.1.3', 'L' ],
|
|
* [ '2024.1.2', 'K' ],
|
|
* [ '2024.1.1', 'K' ],
|
|
* [ '2023.3.2', 'J|K' ],
|
|
* [ '2023.3.1', 'J' ],
|
|
* [ '2023.2.1', 'I' ],
|
|
* ... ...
|
|
* ]
|
|
* @type {Array<[string, string]>}
|
|
*/
|
|
const versionLettersList = sortedVersions.map(v => [ v, Array.from(versionToLetters.get(v)).sort().join('|') ]);
|
|
|
|
/**
|
|
* @example { minorSeries: { patch: letters } }
|
|
* {
|
|
* ... ...
|
|
* '2025.1': { '1': 'N', '2': 'N', '3': 'N', '4': 'N' },
|
|
* '2024.3': { '1': 'M', '2': 'M' },
|
|
* '2024.2': { '1': 'L', '2': 'L' },
|
|
* '2024.1': { '1': 'K', '2': 'K', '3': 'L' },
|
|
* '2023.3': { '1': 'J', '2': 'J|K' },
|
|
* '2023.2': { '1': 'I' },
|
|
* '2023.1': { '1': 'H' },
|
|
* '2022.3': { '1': 'G' },
|
|
* ... ...
|
|
* }
|
|
* @type {Object<string, { [patch: number]: string }>}
|
|
*/
|
|
const rawVersionLettersMap = {};
|
|
for (let i = 0; i < versionLettersList.length; i++) {
|
|
const [ v, letters ] = versionLettersList[i];
|
|
const matched = v.match(/(^\d+\.\d+)(?:\.(\d+))?/);
|
|
if (!matched) continue;
|
|
const [ , minorSeries, patch ] = matched;
|
|
if (minorSeries in rawVersionLettersMap) {
|
|
rawVersionLettersMap[minorSeries][patch] = letters;
|
|
} else {
|
|
rawVersionLettersMap[minorSeries] = { [patch]: letters };
|
|
}
|
|
}
|
|
|
|
/**
|
|
* When all versions with the same minor series prefix (like `2025.1.x`)
|
|
* point to the same codename prefix (like `'N'`),
|
|
* they can be merged (like `{ '2025.1' : 'N' }`, where `2025.1` is the minor series prefix),
|
|
* otherwise retain the original split form (like `2024.1.x` cannot be merged).<br>
|
|
* zh-CN:<br>
|
|
* 当次版本系列相同的版本 (如 `2025.1.x`) 全部指向同一个代号前缀 (如 `'N'`) 时,
|
|
* 可进行合并 (如 `{ '2025.1' : 'N' }`, 其中 `2025.1` 为次版本系列),
|
|
* 否则保留原始的拆分形式 (如 `2024.1.x` 不可合并).
|
|
* @example { version: letters }
|
|
* {
|
|
* ... ...
|
|
* '2025.1': 'N',
|
|
* '2024.3': 'M',
|
|
* '2024.2': 'L',
|
|
* '2024.1.1': 'K',
|
|
* '2024.1.2': 'K',
|
|
* '2024.1.3': 'L',
|
|
* '2023.3.1': 'J',
|
|
* '2023.3.2': 'J|K',
|
|
* '2023.2': 'I',
|
|
* '2023.1': 'H',
|
|
* '2022.3': 'G',
|
|
* ... ...
|
|
* }
|
|
* @type {Object<[version: string], string>}
|
|
*/
|
|
const combinedVersionLettersMap = {};
|
|
|
|
Object.entries(rawVersionLettersMap).forEach(([ minorSeries, patchToLetters ]) => {
|
|
const letterValues = Object.values(patchToLetters);
|
|
if (new Set(letterValues).size === 1) {
|
|
/* Combine. (zh-CN: 合并.) */
|
|
combinedVersionLettersMap[minorSeries] = letterValues[0];
|
|
} else {
|
|
/* Keep expanded. (zh-CN: 保持展开.) */
|
|
Object.entries(patchToLetters).forEach(([ patch, letters ]) => {
|
|
combinedVersionLettersMap[`${minorSeries}.${patch}`] = letters;
|
|
});
|
|
}
|
|
});
|
|
|
|
const versionMapLines = Object.entries(combinedVersionLettersMap)
|
|
.sort((a, b) => compareVersionStrings(b[0], a[0]))
|
|
.map(([ v, letters ]) => `"${v}" to "${letters}",`);
|
|
|
|
const sortedLetters = Array.from(letterBorn.entries())
|
|
.sort((a, b) => b[1].born.getTime() - a[1].born.getTime());
|
|
|
|
const codenameMapLines = sortedLetters.map(([ code, { name, born } ]) => {
|
|
const bornStr = toUpdatedStamp(born);
|
|
// e.g. `"M" to "Meerkat", /* Born on Nov 12, 2024. */`.
|
|
return `"${code}" to "${name}", /* Born on ${bornStr}. */`;
|
|
});
|
|
|
|
return { versionMapLines, codenameMapLines };
|
|
}
|
|
|
|
(async function main() {
|
|
const archives = await getAndroidStudioArchives();
|
|
await updateLatestArchiveInfo(archives);
|
|
|
|
const { versionMapLines, codenameMapLines } = getCodenameMapLinesInfo(archives);
|
|
await batchUpdateAnchoredBlocks('../settings.gradle.kts', [ {
|
|
type: 'map',
|
|
anchorTag: 'ANDROID_STUDIO_CODENAME_VERSION_MAP',
|
|
mapName: 'codenameVersionMap',
|
|
lines: versionMapLines,
|
|
updatedLabel: 'Android Studio codename version map',
|
|
}, {
|
|
type: 'map',
|
|
anchorTag: 'ANDROID_STUDIO_CODENAME_MAP',
|
|
mapName: 'codenameMap',
|
|
lines: codenameMapLines,
|
|
updatedLabel: 'Android Studio codename map',
|
|
} ]);
|
|
})().catch(err => {
|
|
console.error(err);
|
|
process.exitCode = 1;
|
|
});
|