From 7f3ab2648f3d20faa20c4fe6e52a455757e0f38a Mon Sep 17 00:00:00 2001 From: Gregory Mitchell <54124162+gmitch215@users.noreply.github.com> Date: Tue, 18 Jun 2024 22:13:09 -0500 Subject: [PATCH] `npm run build` (JBR) --- dist/setup/index.js | 184 ++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 184 insertions(+) diff --git a/dist/setup/index.js b/dist/setup/index.js index c0387ed..c10884e 100644 --- a/dist/setup/index.js +++ b/dist/setup/index.js @@ -123834,6 +123834,7 @@ const installer_7 = __nccwpck_require__(41121); const installer_8 = __nccwpck_require__(34750); const installer_9 = __nccwpck_require__(64298); const installer_10 = __nccwpck_require__(16132); +const installer_11 = __nccwpck_require__(12634); var JavaDistribution; (function (JavaDistribution) { JavaDistribution["Adopt"] = "adopt"; @@ -123848,6 +123849,7 @@ var JavaDistribution; JavaDistribution["Corretto"] = "corretto"; JavaDistribution["Oracle"] = "oracle"; JavaDistribution["Dragonwell"] = "dragonwell"; + JavaDistribution["JetBrains"] = "jetbrains"; })(JavaDistribution || (JavaDistribution = {})); function getJavaDistribution(distributionName, installerOptions, jdkFile) { switch (distributionName) { @@ -123874,6 +123876,8 @@ function getJavaDistribution(distributionName, installerOptions, jdkFile) { return new installer_9.OracleDistribution(installerOptions); case JavaDistribution.Dragonwell: return new installer_10.DragonwellDistribution(installerOptions); + case JavaDistribution.JetBrains: + return new installer_11.JetBrainsDistribution(installerOptions); default: return null; } @@ -124090,6 +124094,186 @@ class DragonwellDistribution extends base_installer_1.JavaBase { exports.DragonwellDistribution = DragonwellDistribution; +/***/ }), + +/***/ 12634: +/***/ (function(__unused_webpack_module, exports, __nccwpck_require__) { + +"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 (mod) { + if (mod && mod.__esModule) return mod; + var result = {}; + if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k); + __setModuleDefault(result, mod); + return result; +}; +var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) { + function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); } + return new (P || (P = Promise))(function (resolve, reject) { + function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } } + function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } } + function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); } + step((generator = generator.apply(thisArg, _arguments || [])).next()); + }); +}; +var __importDefault = (this && this.__importDefault) || function (mod) { + return (mod && mod.__esModule) ? mod : { "default": mod }; +}; +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.JetBrainsDistribution = void 0; +const core = __importStar(__nccwpck_require__(42186)); +const tc = __importStar(__nccwpck_require__(27784)); +const fs_1 = __importDefault(__nccwpck_require__(57147)); +const path_1 = __importDefault(__nccwpck_require__(71017)); +const semver_1 = __importDefault(__nccwpck_require__(11383)); +const base_installer_1 = __nccwpck_require__(59741); +const util_1 = __nccwpck_require__(92629); +class JetBrainsDistribution extends base_installer_1.JavaBase { + constructor(installerOptions) { + super('JetBrains', installerOptions); + } + findPackageForDownload(range) { + return __awaiter(this, void 0, void 0, function* () { + const versionsRaw = yield this.getAvailableVersions(); + const versions = versionsRaw.map(v => { + const formattedVersion = `${v.semver}+${v.build}`; + return { + version: formattedVersion, + url: v.url + }; + }); + const satisfiedVersions = versions + .filter(item => (0, util_1.isVersionSatisfies)(range, item.version)) + .sort((a, b) => { + return -semver_1.default.compareBuild(a.version, b.version); + }); + const resolvedFullVersion = satisfiedVersions.length > 0 ? satisfiedVersions[0] : null; + if (!resolvedFullVersion) { + const availableOptions = versionsRaw.map(item => item.tag_name).join(', '); + const availableOptionsMessage = availableOptions + ? `\nAvailable versions: ${availableOptions}` + : ''; + throw new Error(`Could not find satisfied version for SemVer '${range}'. ${availableOptionsMessage}`); + } + return resolvedFullVersion; + }); + } + downloadTool(javaRelease) { + return __awaiter(this, void 0, void 0, function* () { + core.info(`Downloading Java ${javaRelease.version} (${this.distribution}) from ${javaRelease.url} ...`); + const javaArchivePath = yield tc.downloadTool(javaRelease.url); + core.info(`Extracting Java archive...`); + const extension = (0, util_1.getDownloadArchiveExtension)(); + const extractedJavaPath = yield (0, util_1.extractJdkFile)(javaArchivePath, extension); + const archiveName = fs_1.default.readdirSync(extractedJavaPath)[0]; + const archivePath = path_1.default.join(extractedJavaPath, archiveName); + const version = this.getToolcacheVersionName(javaRelease.version); + const javaPath = yield tc.cacheDir(archivePath, this.toolcacheFolderName, version, this.architecture); + return { version: javaRelease.version, path: javaPath }; + }); + } + getAvailableVersions() { + return __awaiter(this, void 0, void 0, function* () { + const platform = this.getPlatformOption(); + const arch = this.distributionArchitecture(); + if (core.isDebug()) { + console.time('Retrieving available versions for JBR took'); // eslint-disable-line no-console + } + // need to iterate through all pages to retrieve the list of all versions + // GitHub API doesn't provide way to retrieve the count of pages to iterate so infinity loop + let page_index = 1; + const rawVersions = []; + while (true) { + const requestArguments = `per_page=100&page=${page_index}`; + const rawUrl = `https://api.github.com/repos/JetBrains/JetBrainsRuntime/releases?${requestArguments}`; + if (core.isDebug() && page_index === 1) { + // url is identical except page_index so print it once for debug + core.debug(`Gathering available versions from '${rawUrl}'`); + } + const paginationPage = (yield this.http.getJson(rawUrl)).result; + if (!paginationPage || paginationPage.length === 0) { + // break infinity loop because we have reached end of pagination + break; + } + rawVersions.push(...paginationPage); + page_index++; + } + const versions = rawVersions.map(v => { + var _a; + // Release tags look like one of these: + // jbr-release-21.0.3b465.3 + // jb11_0_11-b87.7 + // jbr11_0_15b2043.56 + const tag = v.tag_name; + // Extract version string + let vstring; + switch ((_a = tag.match(/-/g)) === null || _a === void 0 ? void 0 : _a.length) { + case 2: + vstring = tag.substring(tag.lastIndexOf('-') + 1); + break; + case 1: + vstring = tag.substring(2).replace(/-/g, '').replace(/_/g, '.'); + break; + case undefined: // 0 + vstring = tag.substring(3); + break; + default: + throw new Error(`Unrecognized tag_name: ${tag}`); + } + const vsplit = vstring.split('b'); + const semver = vsplit[0].replace(/_/g, '.'); + const build = +vsplit[1]; + // Construct URL + const url = `https://cache-redirector.jetbrains.com/intellij-jbr/jbr_jcef-${semver}-${platform}-${arch}-b${build}.tar.gz`; + return { + tag_name: tag, + semver: semver, + build: build, + url: url + }; + }); + if (core.isDebug()) { + core.startGroup('Print information about available versions'); + console.timeEnd('Retrieving available versions for JBR took'); // eslint-disable-line no-console + core.debug(`Available versions: [${versions.length}]`); + core.debug(versions.map(item => item.tag_name).join(', ')); + core.endGroup(); + } + return versions; + }); + } + getPlatformOption() { + // Jetbrains has own platform names so need to map them + switch (process.platform) { + case 'darwin': + return 'osx'; + case 'win32': + return 'windows'; + default: + return process.platform; + } + } +} +exports.JetBrainsDistribution = JetBrainsDistribution; + + /***/ }), /***/ 40883: