From 826cdad1ae5ad5a796e6f2a66278a4ee3b65fe57 Mon Sep 17 00:00:00 2001 From: Robert Jackson Date: Wed, 7 Sep 2022 12:14:31 -0400 Subject: [PATCH] Release 4.0.0-beta.1 --- CHANGELOG.md | 18 + dist/index.js | 843 +++++++++++++++++++++++++++++++++++++++++----- package-lock.json | 4 +- package.json | 2 +- 4 files changed, 776 insertions(+), 91 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index e32eb87f..7bfb5436 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -3,6 +3,24 @@ + +## v4.0.0-beta.1 (2022-09-07) + +#### :boom: Breaking Change +* [#102](https://github.com/volta-cli/action/pull/102) Replace `openssl-version` configuration with `variant` ([@scalvert](https://github.com/scalvert)) + +#### :memo: Documentation +* [#104](https://github.com/volta-cli/action/pull/104) Add action-docs updater ([@rwjblue](https://github.com/rwjblue)) +* [#103](https://github.com/volta-cli/action/pull/103) Remove reference to https://volta.sh/latest-version in logging ([@rwjblue](https://github.com/rwjblue)) + +#### :house: Internal +* [#105](https://github.com/volta-cli/action/pull/105) Add CI scenario acceptance test using `variant` ([@rwjblue](https://github.com/rwjblue)) + +#### Committers: 2 +- Robert Jackson ([@rwjblue](https://github.com/rwjblue)) +- Steve Calvert ([@scalvert](https://github.com/scalvert)) + + ## v3.0.2 (2022-09-01) #### :bug: Bug Fix diff --git a/dist/index.js b/dist/index.js index 6e0c596c..e1340d27 100644 --- a/dist/index.js +++ b/dist/index.js @@ -138,7 +138,7 @@ const file_command_1 = __nccwpck_require__(717); const utils_1 = __nccwpck_require__(5278); const os = __importStar(__nccwpck_require__(2037)); const path = __importStar(__nccwpck_require__(1017)); -const uuid_1 = __nccwpck_require__(5840); +const uuid_1 = __nccwpck_require__(8974); const oidc_utils_1 = __nccwpck_require__(8041); /** * The code to exit an action @@ -972,6 +972,637 @@ exports.toCommandProperties = toCommandProperties; /***/ }), +/***/ 8974: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + + + +Object.defineProperty(exports, "__esModule", ({ + value: true +})); +Object.defineProperty(exports, "v1", ({ + enumerable: true, + get: function () { + return _v.default; + } +})); +Object.defineProperty(exports, "v3", ({ + enumerable: true, + get: function () { + return _v2.default; + } +})); +Object.defineProperty(exports, "v4", ({ + enumerable: true, + get: function () { + return _v3.default; + } +})); +Object.defineProperty(exports, "v5", ({ + enumerable: true, + get: function () { + return _v4.default; + } +})); +Object.defineProperty(exports, "NIL", ({ + enumerable: true, + get: function () { + return _nil.default; + } +})); +Object.defineProperty(exports, "version", ({ + enumerable: true, + get: function () { + return _version.default; + } +})); +Object.defineProperty(exports, "validate", ({ + enumerable: true, + get: function () { + return _validate.default; + } +})); +Object.defineProperty(exports, "stringify", ({ + enumerable: true, + get: function () { + return _stringify.default; + } +})); +Object.defineProperty(exports, "parse", ({ + enumerable: true, + get: function () { + return _parse.default; + } +})); + +var _v = _interopRequireDefault(__nccwpck_require__(1595)); + +var _v2 = _interopRequireDefault(__nccwpck_require__(6993)); + +var _v3 = _interopRequireDefault(__nccwpck_require__(1472)); + +var _v4 = _interopRequireDefault(__nccwpck_require__(6217)); + +var _nil = _interopRequireDefault(__nccwpck_require__(2381)); + +var _version = _interopRequireDefault(__nccwpck_require__(427)); + +var _validate = _interopRequireDefault(__nccwpck_require__(2609)); + +var _stringify = _interopRequireDefault(__nccwpck_require__(1458)); + +var _parse = _interopRequireDefault(__nccwpck_require__(6385)); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +/***/ }), + +/***/ 5842: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + + + +Object.defineProperty(exports, "__esModule", ({ + value: true +})); +exports["default"] = void 0; + +var _crypto = _interopRequireDefault(__nccwpck_require__(6113)); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +function md5(bytes) { + if (Array.isArray(bytes)) { + bytes = Buffer.from(bytes); + } else if (typeof bytes === 'string') { + bytes = Buffer.from(bytes, 'utf8'); + } + + return _crypto.default.createHash('md5').update(bytes).digest(); +} + +var _default = md5; +exports["default"] = _default; + +/***/ }), + +/***/ 2381: +/***/ ((__unused_webpack_module, exports) => { + + + +Object.defineProperty(exports, "__esModule", ({ + value: true +})); +exports["default"] = void 0; +var _default = '00000000-0000-0000-0000-000000000000'; +exports["default"] = _default; + +/***/ }), + +/***/ 6385: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + + + +Object.defineProperty(exports, "__esModule", ({ + value: true +})); +exports["default"] = void 0; + +var _validate = _interopRequireDefault(__nccwpck_require__(2609)); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +function parse(uuid) { + if (!(0, _validate.default)(uuid)) { + throw TypeError('Invalid UUID'); + } + + let v; + const arr = new Uint8Array(16); // Parse ########-....-....-....-............ + + arr[0] = (v = parseInt(uuid.slice(0, 8), 16)) >>> 24; + arr[1] = v >>> 16 & 0xff; + arr[2] = v >>> 8 & 0xff; + arr[3] = v & 0xff; // Parse ........-####-....-....-............ + + arr[4] = (v = parseInt(uuid.slice(9, 13), 16)) >>> 8; + arr[5] = v & 0xff; // Parse ........-....-####-....-............ + + arr[6] = (v = parseInt(uuid.slice(14, 18), 16)) >>> 8; + arr[7] = v & 0xff; // Parse ........-....-....-####-............ + + arr[8] = (v = parseInt(uuid.slice(19, 23), 16)) >>> 8; + arr[9] = v & 0xff; // Parse ........-....-....-....-############ + // (Use "/" to avoid 32-bit truncation when bit-shifting high-order bytes) + + arr[10] = (v = parseInt(uuid.slice(24, 36), 16)) / 0x10000000000 & 0xff; + arr[11] = v / 0x100000000 & 0xff; + arr[12] = v >>> 24 & 0xff; + arr[13] = v >>> 16 & 0xff; + arr[14] = v >>> 8 & 0xff; + arr[15] = v & 0xff; + return arr; +} + +var _default = parse; +exports["default"] = _default; + +/***/ }), + +/***/ 6230: +/***/ ((__unused_webpack_module, exports) => { + + + +Object.defineProperty(exports, "__esModule", ({ + value: true +})); +exports["default"] = void 0; +var _default = /^(?:[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}|00000000-0000-0000-0000-000000000000)$/i; +exports["default"] = _default; + +/***/ }), + +/***/ 9784: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + + + +Object.defineProperty(exports, "__esModule", ({ + value: true +})); +exports["default"] = rng; + +var _crypto = _interopRequireDefault(__nccwpck_require__(6113)); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +const rnds8Pool = new Uint8Array(256); // # of random values to pre-allocate + +let poolPtr = rnds8Pool.length; + +function rng() { + if (poolPtr > rnds8Pool.length - 16) { + _crypto.default.randomFillSync(rnds8Pool); + + poolPtr = 0; + } + + return rnds8Pool.slice(poolPtr, poolPtr += 16); +} + +/***/ }), + +/***/ 8844: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + + + +Object.defineProperty(exports, "__esModule", ({ + value: true +})); +exports["default"] = void 0; + +var _crypto = _interopRequireDefault(__nccwpck_require__(6113)); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +function sha1(bytes) { + if (Array.isArray(bytes)) { + bytes = Buffer.from(bytes); + } else if (typeof bytes === 'string') { + bytes = Buffer.from(bytes, 'utf8'); + } + + return _crypto.default.createHash('sha1').update(bytes).digest(); +} + +var _default = sha1; +exports["default"] = _default; + +/***/ }), + +/***/ 1458: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + + + +Object.defineProperty(exports, "__esModule", ({ + value: true +})); +exports["default"] = void 0; + +var _validate = _interopRequireDefault(__nccwpck_require__(2609)); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +/** + * Convert array of 16 byte values to UUID string format of the form: + * XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX + */ +const byteToHex = []; + +for (let i = 0; i < 256; ++i) { + byteToHex.push((i + 0x100).toString(16).substr(1)); +} + +function stringify(arr, offset = 0) { + // Note: Be careful editing this code! It's been tuned for performance + // and works in ways you may not expect. See https://github.com/uuidjs/uuid/pull/434 + const uuid = (byteToHex[arr[offset + 0]] + byteToHex[arr[offset + 1]] + byteToHex[arr[offset + 2]] + byteToHex[arr[offset + 3]] + '-' + byteToHex[arr[offset + 4]] + byteToHex[arr[offset + 5]] + '-' + byteToHex[arr[offset + 6]] + byteToHex[arr[offset + 7]] + '-' + byteToHex[arr[offset + 8]] + byteToHex[arr[offset + 9]] + '-' + byteToHex[arr[offset + 10]] + byteToHex[arr[offset + 11]] + byteToHex[arr[offset + 12]] + byteToHex[arr[offset + 13]] + byteToHex[arr[offset + 14]] + byteToHex[arr[offset + 15]]).toLowerCase(); // Consistency check for valid UUID. If this throws, it's likely due to one + // of the following: + // - One or more input array values don't map to a hex octet (leading to + // "undefined" in the uuid) + // - Invalid input values for the RFC `version` or `variant` fields + + if (!(0, _validate.default)(uuid)) { + throw TypeError('Stringified UUID is invalid'); + } + + return uuid; +} + +var _default = stringify; +exports["default"] = _default; + +/***/ }), + +/***/ 1595: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + + + +Object.defineProperty(exports, "__esModule", ({ + value: true +})); +exports["default"] = void 0; + +var _rng = _interopRequireDefault(__nccwpck_require__(9784)); + +var _stringify = _interopRequireDefault(__nccwpck_require__(1458)); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +// **`v1()` - Generate time-based UUID** +// +// Inspired by https://github.com/LiosK/UUID.js +// and http://docs.python.org/library/uuid.html +let _nodeId; + +let _clockseq; // Previous uuid creation time + + +let _lastMSecs = 0; +let _lastNSecs = 0; // See https://github.com/uuidjs/uuid for API details + +function v1(options, buf, offset) { + let i = buf && offset || 0; + const b = buf || new Array(16); + options = options || {}; + let node = options.node || _nodeId; + let clockseq = options.clockseq !== undefined ? options.clockseq : _clockseq; // node and clockseq need to be initialized to random values if they're not + // specified. We do this lazily to minimize issues related to insufficient + // system entropy. See #189 + + if (node == null || clockseq == null) { + const seedBytes = options.random || (options.rng || _rng.default)(); + + if (node == null) { + // Per 4.5, create and 48-bit node id, (47 random bits + multicast bit = 1) + node = _nodeId = [seedBytes[0] | 0x01, seedBytes[1], seedBytes[2], seedBytes[3], seedBytes[4], seedBytes[5]]; + } + + if (clockseq == null) { + // Per 4.2.2, randomize (14 bit) clockseq + clockseq = _clockseq = (seedBytes[6] << 8 | seedBytes[7]) & 0x3fff; + } + } // UUID timestamps are 100 nano-second units since the Gregorian epoch, + // (1582-10-15 00:00). JSNumbers aren't precise enough for this, so + // time is handled internally as 'msecs' (integer milliseconds) and 'nsecs' + // (100-nanoseconds offset from msecs) since unix epoch, 1970-01-01 00:00. + + + let msecs = options.msecs !== undefined ? options.msecs : Date.now(); // Per 4.2.1.2, use count of uuid's generated during the current clock + // cycle to simulate higher resolution clock + + let nsecs = options.nsecs !== undefined ? options.nsecs : _lastNSecs + 1; // Time since last uuid creation (in msecs) + + const dt = msecs - _lastMSecs + (nsecs - _lastNSecs) / 10000; // Per 4.2.1.2, Bump clockseq on clock regression + + if (dt < 0 && options.clockseq === undefined) { + clockseq = clockseq + 1 & 0x3fff; + } // Reset nsecs if clock regresses (new clockseq) or we've moved onto a new + // time interval + + + if ((dt < 0 || msecs > _lastMSecs) && options.nsecs === undefined) { + nsecs = 0; + } // Per 4.2.1.2 Throw error if too many uuids are requested + + + if (nsecs >= 10000) { + throw new Error("uuid.v1(): Can't create more than 10M uuids/sec"); + } + + _lastMSecs = msecs; + _lastNSecs = nsecs; + _clockseq = clockseq; // Per 4.1.4 - Convert from unix epoch to Gregorian epoch + + msecs += 12219292800000; // `time_low` + + const tl = ((msecs & 0xfffffff) * 10000 + nsecs) % 0x100000000; + b[i++] = tl >>> 24 & 0xff; + b[i++] = tl >>> 16 & 0xff; + b[i++] = tl >>> 8 & 0xff; + b[i++] = tl & 0xff; // `time_mid` + + const tmh = msecs / 0x100000000 * 10000 & 0xfffffff; + b[i++] = tmh >>> 8 & 0xff; + b[i++] = tmh & 0xff; // `time_high_and_version` + + b[i++] = tmh >>> 24 & 0xf | 0x10; // include version + + b[i++] = tmh >>> 16 & 0xff; // `clock_seq_hi_and_reserved` (Per 4.2.2 - include variant) + + b[i++] = clockseq >>> 8 | 0x80; // `clock_seq_low` + + b[i++] = clockseq & 0xff; // `node` + + for (let n = 0; n < 6; ++n) { + b[i + n] = node[n]; + } + + return buf || (0, _stringify.default)(b); +} + +var _default = v1; +exports["default"] = _default; + +/***/ }), + +/***/ 6993: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + + + +Object.defineProperty(exports, "__esModule", ({ + value: true +})); +exports["default"] = void 0; + +var _v = _interopRequireDefault(__nccwpck_require__(5920)); + +var _md = _interopRequireDefault(__nccwpck_require__(5842)); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +const v3 = (0, _v.default)('v3', 0x30, _md.default); +var _default = v3; +exports["default"] = _default; + +/***/ }), + +/***/ 5920: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + + + +Object.defineProperty(exports, "__esModule", ({ + value: true +})); +exports["default"] = _default; +exports.URL = exports.DNS = void 0; + +var _stringify = _interopRequireDefault(__nccwpck_require__(1458)); + +var _parse = _interopRequireDefault(__nccwpck_require__(6385)); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +function stringToBytes(str) { + str = unescape(encodeURIComponent(str)); // UTF8 escape + + const bytes = []; + + for (let i = 0; i < str.length; ++i) { + bytes.push(str.charCodeAt(i)); + } + + return bytes; +} + +const DNS = '6ba7b810-9dad-11d1-80b4-00c04fd430c8'; +exports.DNS = DNS; +const URL = '6ba7b811-9dad-11d1-80b4-00c04fd430c8'; +exports.URL = URL; + +function _default(name, version, hashfunc) { + function generateUUID(value, namespace, buf, offset) { + if (typeof value === 'string') { + value = stringToBytes(value); + } + + if (typeof namespace === 'string') { + namespace = (0, _parse.default)(namespace); + } + + if (namespace.length !== 16) { + throw TypeError('Namespace must be array-like (16 iterable integer values, 0-255)'); + } // Compute hash of namespace and value, Per 4.3 + // Future: Use spread syntax when supported on all platforms, e.g. `bytes = + // hashfunc([...namespace, ... value])` + + + let bytes = new Uint8Array(16 + value.length); + bytes.set(namespace); + bytes.set(value, namespace.length); + bytes = hashfunc(bytes); + bytes[6] = bytes[6] & 0x0f | version; + bytes[8] = bytes[8] & 0x3f | 0x80; + + if (buf) { + offset = offset || 0; + + for (let i = 0; i < 16; ++i) { + buf[offset + i] = bytes[i]; + } + + return buf; + } + + return (0, _stringify.default)(bytes); + } // Function#name is not settable on some platforms (#270) + + + try { + generateUUID.name = name; // eslint-disable-next-line no-empty + } catch (err) {} // For CommonJS default export support + + + generateUUID.DNS = DNS; + generateUUID.URL = URL; + return generateUUID; +} + +/***/ }), + +/***/ 1472: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + + + +Object.defineProperty(exports, "__esModule", ({ + value: true +})); +exports["default"] = void 0; + +var _rng = _interopRequireDefault(__nccwpck_require__(9784)); + +var _stringify = _interopRequireDefault(__nccwpck_require__(1458)); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +function v4(options, buf, offset) { + options = options || {}; + + const rnds = options.random || (options.rng || _rng.default)(); // Per 4.4, set bits for version and `clock_seq_hi_and_reserved` + + + rnds[6] = rnds[6] & 0x0f | 0x40; + rnds[8] = rnds[8] & 0x3f | 0x80; // Copy bytes to buffer, if provided + + if (buf) { + offset = offset || 0; + + for (let i = 0; i < 16; ++i) { + buf[offset + i] = rnds[i]; + } + + return buf; + } + + return (0, _stringify.default)(rnds); +} + +var _default = v4; +exports["default"] = _default; + +/***/ }), + +/***/ 6217: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + + + +Object.defineProperty(exports, "__esModule", ({ + value: true +})); +exports["default"] = void 0; + +var _v = _interopRequireDefault(__nccwpck_require__(5920)); + +var _sha = _interopRequireDefault(__nccwpck_require__(8844)); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +const v5 = (0, _v.default)('v5', 0x50, _sha.default); +var _default = v5; +exports["default"] = _default; + +/***/ }), + +/***/ 2609: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + + + +Object.defineProperty(exports, "__esModule", ({ + value: true +})); +exports["default"] = void 0; + +var _regex = _interopRequireDefault(__nccwpck_require__(6230)); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +function validate(uuid) { + return typeof uuid === 'string' && _regex.default.test(uuid); +} + +var _default = validate; +exports["default"] = _default; + +/***/ }), + +/***/ 427: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + + + +Object.defineProperty(exports, "__esModule", ({ + value: true +})); +exports["default"] = void 0; + +var _validate = _interopRequireDefault(__nccwpck_require__(2609)); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +function version(uuid) { + if (!(0, _validate.default)(uuid)) { + throw TypeError('Invalid UUID'); + } + + return parseInt(uuid.substr(14, 1), 16); +} + +var _default = version; +exports["default"] = _default; + +/***/ }), + /***/ 1514: /***/ (function(__unused_webpack_module, exports, __nccwpck_require__) { @@ -16170,7 +16801,7 @@ module.exports = Comparator const parseOptions = __nccwpck_require__(785) const { re, t } = __nccwpck_require__(9523) const cmp = __nccwpck_require__(5098) -const debug = __nccwpck_require__(427) +const debug = __nccwpck_require__(106) const SemVer = __nccwpck_require__(8088) const Range = __nccwpck_require__(9828) @@ -16379,7 +17010,7 @@ const cache = new LRU({ max: 1000 }) const parseOptions = __nccwpck_require__(785) const Comparator = __nccwpck_require__(1532) -const debug = __nccwpck_require__(427) +const debug = __nccwpck_require__(106) const SemVer = __nccwpck_require__(8088) const { re, @@ -16706,7 +17337,7 @@ const testSet = (set, version, options) => { /***/ 8088: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { -const debug = __nccwpck_require__(427) +const debug = __nccwpck_require__(106) const { MAX_LENGTH, MAX_SAFE_INTEGER } = __nccwpck_require__(2293) const { re, t } = __nccwpck_require__(9523) @@ -17501,7 +18132,7 @@ module.exports = { /***/ }), -/***/ 427: +/***/ 106: /***/ ((module) => { const debug = ( @@ -17569,7 +18200,7 @@ module.exports = parseOptions /***/ ((module, exports, __nccwpck_require__) => { const { MAX_SAFE_COMPONENT_LENGTH } = __nccwpck_require__(2293) -const debug = __nccwpck_require__(427) +const debug = __nccwpck_require__(106) exports = module.exports = {} // The actual regexps go on exports.re @@ -19642,63 +20273,64 @@ exports.getUserAgent = getUserAgent; /***/ 5840: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { +var __webpack_unused_export__; -Object.defineProperty(exports, "__esModule", ({ +__webpack_unused_export__ = ({ value: true -})); -Object.defineProperty(exports, "v1", ({ +}); +Object.defineProperty(exports, "zR", ({ enumerable: true, get: function () { - return _v.default; + return _nil.default; } })); -Object.defineProperty(exports, "v3", ({ +Object.defineProperty(exports, "Qc", ({ enumerable: true, get: function () { - return _v2.default; + return _parse.default; } })); -Object.defineProperty(exports, "v4", ({ +Object.defineProperty(exports, "Pz", ({ enumerable: true, get: function () { - return _v3.default; + return _stringify.default; } })); -Object.defineProperty(exports, "v5", ({ +Object.defineProperty(exports, "v1", ({ enumerable: true, get: function () { - return _v4.default; + return _v.default; } })); -Object.defineProperty(exports, "NIL", ({ +Object.defineProperty(exports, "v3", ({ enumerable: true, get: function () { - return _nil.default; + return _v2.default; } })); -Object.defineProperty(exports, "version", ({ +Object.defineProperty(exports, "v4", ({ enumerable: true, get: function () { - return _version.default; + return _v3.default; } })); -Object.defineProperty(exports, "validate", ({ +Object.defineProperty(exports, "v5", ({ enumerable: true, get: function () { - return _validate.default; + return _v4.default; } })); -Object.defineProperty(exports, "stringify", ({ +Object.defineProperty(exports, "Gu", ({ enumerable: true, get: function () { - return _stringify.default; + return _validate.default; } })); -Object.defineProperty(exports, "parse", ({ +Object.defineProperty(exports, "i8", ({ enumerable: true, get: function () { - return _parse.default; + return _version.default; } })); @@ -19712,7 +20344,7 @@ var _v4 = _interopRequireDefault(__nccwpck_require__(9120)); var _nil = _interopRequireDefault(__nccwpck_require__(5332)); -var _version = _interopRequireDefault(__nccwpck_require__(1595)); +var _version = _interopRequireDefault(__nccwpck_require__(2414)); var _validate = _interopRequireDefault(__nccwpck_require__(6900)); @@ -19753,6 +20385,27 @@ exports["default"] = _default; /***/ }), +/***/ 2054: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + + + +Object.defineProperty(exports, "__esModule", ({ + value: true +})); +exports["default"] = void 0; + +var _crypto = _interopRequireDefault(__nccwpck_require__(6113)); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +var _default = { + randomUUID: _crypto.default.randomUUID +}; +exports["default"] = _default; + +/***/ }), + /***/ 5332: /***/ ((__unused_webpack_module, exports) => { @@ -19900,6 +20553,7 @@ Object.defineProperty(exports, "__esModule", ({ value: true })); exports["default"] = void 0; +exports.unsafeStringify = unsafeStringify; var _validate = _interopRequireDefault(__nccwpck_require__(6900)); @@ -19912,13 +20566,17 @@ function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { de const byteToHex = []; for (let i = 0; i < 256; ++i) { - byteToHex.push((i + 0x100).toString(16).substr(1)); + byteToHex.push((i + 0x100).toString(16).slice(1)); } -function stringify(arr, offset = 0) { +function unsafeStringify(arr, offset = 0) { // Note: Be careful editing this code! It's been tuned for performance // and works in ways you may not expect. See https://github.com/uuidjs/uuid/pull/434 - const uuid = (byteToHex[arr[offset + 0]] + byteToHex[arr[offset + 1]] + byteToHex[arr[offset + 2]] + byteToHex[arr[offset + 3]] + '-' + byteToHex[arr[offset + 4]] + byteToHex[arr[offset + 5]] + '-' + byteToHex[arr[offset + 6]] + byteToHex[arr[offset + 7]] + '-' + byteToHex[arr[offset + 8]] + byteToHex[arr[offset + 9]] + '-' + byteToHex[arr[offset + 10]] + byteToHex[arr[offset + 11]] + byteToHex[arr[offset + 12]] + byteToHex[arr[offset + 13]] + byteToHex[arr[offset + 14]] + byteToHex[arr[offset + 15]]).toLowerCase(); // Consistency check for valid UUID. If this throws, it's likely due to one + return (byteToHex[arr[offset + 0]] + byteToHex[arr[offset + 1]] + byteToHex[arr[offset + 2]] + byteToHex[arr[offset + 3]] + '-' + byteToHex[arr[offset + 4]] + byteToHex[arr[offset + 5]] + '-' + byteToHex[arr[offset + 6]] + byteToHex[arr[offset + 7]] + '-' + byteToHex[arr[offset + 8]] + byteToHex[arr[offset + 9]] + '-' + byteToHex[arr[offset + 10]] + byteToHex[arr[offset + 11]] + byteToHex[arr[offset + 12]] + byteToHex[arr[offset + 13]] + byteToHex[arr[offset + 14]] + byteToHex[arr[offset + 15]]).toLowerCase(); +} + +function stringify(arr, offset = 0) { + const uuid = unsafeStringify(arr, offset); // Consistency check for valid UUID. If this throws, it's likely due to one // of the following: // - One or more input array values don't map to a hex octet (leading to // "undefined" in the uuid) @@ -19948,7 +20606,7 @@ exports["default"] = void 0; var _rng = _interopRequireDefault(__nccwpck_require__(807)); -var _stringify = _interopRequireDefault(__nccwpck_require__(8950)); +var _stringify = __nccwpck_require__(8950); function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } @@ -20041,7 +20699,7 @@ function v1(options, buf, offset) { b[i + n] = node[n]; } - return buf || (0, _stringify.default)(b); + return buf || (0, _stringify.unsafeStringify)(b); } var _default = v1; @@ -20079,10 +20737,10 @@ exports["default"] = _default; Object.defineProperty(exports, "__esModule", ({ value: true })); -exports["default"] = _default; exports.URL = exports.DNS = void 0; +exports["default"] = v35; -var _stringify = _interopRequireDefault(__nccwpck_require__(8950)); +var _stringify = __nccwpck_require__(8950); var _parse = _interopRequireDefault(__nccwpck_require__(2746)); @@ -20105,8 +20763,10 @@ exports.DNS = DNS; const URL = '6ba7b811-9dad-11d1-80b4-00c04fd430c8'; exports.URL = URL; -function _default(name, version, hashfunc) { +function v35(name, version, hashfunc) { function generateUUID(value, namespace, buf, offset) { + var _namespace; + if (typeof value === 'string') { value = stringToBytes(value); } @@ -20115,7 +20775,7 @@ function _default(name, version, hashfunc) { namespace = (0, _parse.default)(namespace); } - if (namespace.length !== 16) { + if (((_namespace = namespace) === null || _namespace === void 0 ? void 0 : _namespace.length) !== 16) { throw TypeError('Namespace must be array-like (16 iterable integer values, 0-255)'); } // Compute hash of namespace and value, Per 4.3 // Future: Use spread syntax when supported on all platforms, e.g. `bytes = @@ -20139,7 +20799,7 @@ function _default(name, version, hashfunc) { return buf; } - return (0, _stringify.default)(bytes); + return (0, _stringify.unsafeStringify)(bytes); } // Function#name is not settable on some platforms (#270) @@ -20165,13 +20825,19 @@ Object.defineProperty(exports, "__esModule", ({ })); exports["default"] = void 0; +var _native = _interopRequireDefault(__nccwpck_require__(2054)); + var _rng = _interopRequireDefault(__nccwpck_require__(807)); -var _stringify = _interopRequireDefault(__nccwpck_require__(8950)); +var _stringify = __nccwpck_require__(8950); function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } function v4(options, buf, offset) { + if (_native.default.randomUUID && !buf && !options) { + return _native.default.randomUUID(); + } + options = options || {}; const rnds = options.random || (options.rng || _rng.default)(); // Per 4.4, set bits for version and `clock_seq_hi_and_reserved` @@ -20190,7 +20856,7 @@ function v4(options, buf, offset) { return buf; } - return (0, _stringify.default)(rnds); + return (0, _stringify.unsafeStringify)(rnds); } var _default = v4; @@ -20243,7 +20909,7 @@ exports["default"] = _default; /***/ }), -/***/ 1595: +/***/ 2414: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { @@ -20262,7 +20928,7 @@ function version(uuid) { throw TypeError('Invalid UUID'); } - return parseInt(uuid.substr(14, 1), 16); + return parseInt(uuid.slice(14, 15), 16); } var _default = version; @@ -22636,11 +23302,11 @@ const v1 = dist.v1; const v3 = dist.v3; const v4 = dist.v4; const v5 = dist.v5; -const NIL = dist.NIL; -const version = dist.version; -const validate = dist.validate; -const stringify = dist.stringify; -const parse = dist.parse; +const NIL = dist/* NIL */.zR; +const version = dist/* version */.i8; +const validate = dist/* validate */.Gu; +const stringify = dist/* stringify */.Pz; +const parse = dist/* parse */.Qc; ;// CONCATENATED MODULE: ./src/installer.ts @@ -22674,44 +23340,31 @@ async function getLatestVolta(authToken) { function voltaVersionHasSetup(version) { return semver.gte(version, '0.7.0'); } -async function buildDownloadUrl(platform, version, openSSLVersion = '') { - let fileName; - switch (platform) { - case 'darwin': - fileName = `volta-${version}-macos.tar.gz`; - break; - case 'linux': { - openSSLVersion = await getOpenSSLVersion(openSSLVersion); - fileName = `volta-${version}-linux-${openSSLVersion}.tar.gz`; - break; +async function buildDownloadUrl(platform, version, variant = '', openSSLVersionForTesting = '') { + let fileName = ''; + if (variant) { + fileName = `volta-${version}-${variant}.tar.gz`; + } + else { + switch (platform) { + case 'darwin': + fileName = `volta-${version}-macos.tar.gz`; + break; + case 'linux': { + const openSSLVersion = await getOpenSSLVersion(openSSLVersionForTesting); + fileName = `volta-${version}-linux-${openSSLVersion}.tar.gz`; + break; + } + case 'win32': + fileName = `volta-${version}-windows-x86_64.msi`; + break; + default: + throw new Error(`your platform ${platform} is not yet supported`); } - case 'win32': - fileName = `volta-${version}-windows-x86_64.msi`; - break; - default: - throw new Error(`your platform ${platform} is not yet supported`); } return `https://github.com/volta-cli/volta/releases/download/v${version}/${fileName}`; } -async function execOpenSSLVersion() { - let output = ''; - const options = {}; - options.listeners = { - stdout: (data) => { - output += data.toString(); - }, - stderr: (data) => { - output += data.toString(); - }, - }; - await (0,exec.exec)('openssl version', [], options); - return output; -} async function getOpenSSLVersion(version = '') { - const specificVersionViaInput = /^\d{1,3}\.\d{1,3}$/.test(version); - if (specificVersionViaInput) { - return `openssl-${version}`; - } if (version === '') { version = await execOpenSSLVersion(); } @@ -22725,6 +23378,20 @@ async function getOpenSSLVersion(version = '') { // should return in openssl-1.1 format return `openssl-${version}`; } +async function execOpenSSLVersion() { + let output = ''; + const options = {}; + options.listeners = { + stdout: (data) => { + output += data.toString(); + }, + stderr: (data) => { + output += data.toString(); + }, + }; + await (0,exec.exec)('openssl version', [], options); + return output; +} /* * Used to setup a specific shim when running volta < 0.7 */ @@ -22768,14 +23435,14 @@ async function buildLayout(voltaHome) { await io.mkdirP(external_path_.join(voltaHome, 'tools/user')); await setupShims(voltaHome); } -async function acquireVolta(version, authToken, openSSLVersion) { +async function acquireVolta(version, options) { // // Download - a tool installer intimately knows how to get the tool (and construct urls) // core.info(`downloading volta@${version}`); - const downloadUrl = await buildDownloadUrl(external_os_.platform(), version, openSSLVersion); + const downloadUrl = await buildDownloadUrl(external_os_.platform(), version, options.variant); core.debug(`downloading from \`${downloadUrl}\``); - const downloadPath = await tool_cache.downloadTool(downloadUrl, undefined, authToken); + const downloadPath = await tool_cache.downloadTool(downloadUrl, undefined, options.authToken); const voltaHome = external_path_.join( // `RUNNER_TEMP` is used by @actions/tool-cache process.env['RUNNER_TEMP'] || '', v4()); @@ -22854,17 +23521,17 @@ async function getVoltaVersion(versionSpec, authToken) { core.info(`using user provided version volta@${version}`); } else { - core.info(`looking up latest volta version from https://volta.sh/latest-version`); + core.info(`looking up latest volta version`); version = await getLatestVolta(authToken); } return version; } -async function getVolta(versionSpec, authToken, openSSLVersion) { - const version = await getVoltaVersion(versionSpec, authToken); +async function getVolta(options) { + const version = await getVoltaVersion(options.versionSpec, options.authToken); let voltaHome = tool_cache.find('volta', version); if (voltaHome === '') { // download, extract, cache - const toolRoot = await acquireVolta(version, authToken, openSSLVersion); + const toolRoot = await acquireVolta(version, options); await setupVolta(version, toolRoot); // Install into the local tool cache - node extracts with a root folder // that matches the fileName downloaded @@ -22959,8 +23626,8 @@ async function run() { try { const authToken = core.getInput('token', { required: false }); const voltaVersion = core.getInput('volta-version', { required: false }); - const openSSLVersion = core.getInput('openssl-version', { required: false }); - await getVolta(voltaVersion, authToken, openSSLVersion); + const variant = core.getInput('variant', { required: false }); + await getVolta({ versionSpec: voltaVersion, authToken, variant }); const hasPackageJSON = await find_up_default()('package.json'); const nodeVersion = core.getInput('node-version', { required: false }); if (nodeVersion !== '') { diff --git a/package-lock.json b/package-lock.json index dc625c71..ac218d79 100644 --- a/package-lock.json +++ b/package-lock.json @@ -1,12 +1,12 @@ { "name": "@volta-cli/action", - "version": "3.0.2", + "version": "4.0.0-beta.1", "lockfileVersion": 2, "requires": true, "packages": { "": { "name": "@volta-cli/action", - "version": "3.0.2", + "version": "4.0.0-beta.1", "license": "MIT", "devDependencies": { "@actions/core": "^1.9.1", diff --git a/package.json b/package.json index b6888465..45db1fa9 100644 --- a/package.json +++ b/package.json @@ -1,6 +1,6 @@ { "name": "@volta-cli/action", - "version": "3.0.2", + "version": "4.0.0-beta.1", "private": true, "description": "Setup volta for usage in your CI runs", "keywords": [