287 lines
12 KiB
JavaScript
287 lines
12 KiB
JavaScript
/* eslint no-console:0 */
|
|
'use strict';
|
|
var __assign = (this && this.__assign) || function () {
|
|
__assign = Object.assign || function(t) {
|
|
for (var s, i = 1, n = arguments.length; i < n; i++) {
|
|
s = arguments[i];
|
|
for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
|
|
t[p] = s[p];
|
|
}
|
|
return t;
|
|
};
|
|
return __assign.apply(this, arguments);
|
|
};
|
|
var __importDefault = (this && this.__importDefault) || function (mod) {
|
|
return (mod && mod.__esModule) ? mod : { "default": mod };
|
|
};
|
|
var _a, _b;
|
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
// Imports
|
|
var path_1 = __importDefault(require("path"));
|
|
var semver_1 = __importDefault(require("semver"));
|
|
var util_js_1 = require("./util.js");
|
|
// As Errlop uses Editions, we should use a specific Errlop edition
|
|
// As otherwise, the circular reference may fail on some machines
|
|
// https://github.com/bevry/errlop/issues/2
|
|
var errlop_1 = __importDefault(require("errlop"));
|
|
/**
|
|
* The current node version that we are operating within.
|
|
* It is compared in {@link requireEdition} against {@link Edition.engines}.
|
|
*/
|
|
var NODE_VERSION = process.versions.node;
|
|
/**
|
|
* Whether or not {@link EDITIONS_VERBOSE} is enabled.
|
|
* @type {bollean}
|
|
* @private
|
|
*/
|
|
var VERBOSE = process.env.EDITIONS_VERBOSE === true ||
|
|
process.env.EDITIONS_VERBOSE === 'yes' ||
|
|
process.env.EDITIONS_VERBOSE === 'true' ||
|
|
false;
|
|
/**
|
|
* A list of the blacklisted tags.
|
|
* Data imported from {@link EDITIONS_TAG_BLACKLIST}.
|
|
*/
|
|
var BLACKLIST = ((_a = process.env.EDITIONS_TAG_BLACKLIST) === null || _a === void 0 ? void 0 : _a.split(/[, ]+/g)) || ((_b = process.env.EDITIONS_SYNTAX_BLACKLIST) === null || _b === void 0 ? void 0 : _b.split(/[, ]+/g));
|
|
/**
|
|
* A mapping of blacklisted tags to their reasons.
|
|
* Keys are the tags.
|
|
* Values are the error instances that contain the reasoning for why/how that tag is/became blacklisted.
|
|
* Data imported from {@link EDITIONS_TAG_BLACKLIST}.
|
|
*/
|
|
var blacklist = {};
|
|
// Create the mapping of blacklisted tags and their reasonings
|
|
if (BLACKLIST) {
|
|
for (var i = 0; i < BLACKLIST.length; ++i) {
|
|
var tag = BLACKLIST[i].trim().toLowerCase();
|
|
blacklist[tag] = util_js_1.errtion({
|
|
message: "The EDITIONS_TAG_BLACKLIST (aka EDITIONS_SYNTAX_BLACKLIST) environment variable blacklisted the tag [" + tag + "]",
|
|
code: 'blacklisted-tag'
|
|
});
|
|
}
|
|
}
|
|
// Blacklist the tag 'esnext' if our node version is below 0.12
|
|
if (semver_1.default.satisfies(NODE_VERSION, '<0.12')) {
|
|
blacklist.esnext = new Error('The esnext tag is skipped on early node versions as attempting to use esnext features will output debugging information on these node versions');
|
|
}
|
|
/**
|
|
* Attempt to load a specific {@link Edition}.
|
|
* @returns The result of the loaded edition.
|
|
* @throws An error if the edition failed to load.
|
|
*/
|
|
function loadEdition(edition, opts) {
|
|
var entry = path_1.default.resolve(opts.cwd || '', edition.directory, opts.entry || edition.entry || '');
|
|
if (opts.require == null) {
|
|
throw util_js_1.errtion({
|
|
message: "Skipped edition [" + edition.description + "] as opts.require was not provided, this is probably due to a testing misconfiguration.",
|
|
code: 'unsupported-edition-require'
|
|
});
|
|
}
|
|
try {
|
|
return opts.require(entry);
|
|
}
|
|
catch (loadError) {
|
|
// Note the error with more details
|
|
throw util_js_1.errtion({
|
|
message: "Skipped edition [" + edition.description + "] at entry [" + entry + "] because it failed to load",
|
|
code: 'unsupported-edition-tried'
|
|
}, loadError);
|
|
}
|
|
}
|
|
exports.loadEdition = loadEdition;
|
|
/**
|
|
* Attempt to require an {@link Edition}, based on its compatibility with the current environment, such as {@link NODE_VERSION} and {@link EDITIONS_TAG_BLACKLIST} compatibility.
|
|
* If compatibility is established with the environment, it will load the edition using {@link loadEdition}.
|
|
* @returns The result of the loaded edition
|
|
* @throws An error if the edition failed to load
|
|
*/
|
|
function requireEdition(edition, opts) {
|
|
// Verify the edition is valid
|
|
if (!edition.description ||
|
|
!edition.directory ||
|
|
!edition.entry ||
|
|
edition.engines == null) {
|
|
throw util_js_1.errtion({
|
|
message: "Each edition must have its [description, directory, entry, engines] fields defined, yet all it had was [" + Object.keys(edition).join(', ') + "]",
|
|
code: 'unsupported-edition-malformed',
|
|
level: 'fatal'
|
|
});
|
|
}
|
|
// Handle strict omission
|
|
if (opts.strict == null) {
|
|
try {
|
|
return requireEdition(edition, __assign(__assign({}, opts), { strict: true }));
|
|
}
|
|
catch (err) {
|
|
return requireEdition(edition, __assign(__assign({}, opts), { strict: false }));
|
|
}
|
|
}
|
|
// Verify tag support
|
|
// Convert tags into a sorted lowercase string
|
|
var tags = (edition.tags || edition.syntaxes || [])
|
|
.map(function (i) { return i.toLowerCase(); })
|
|
.sort();
|
|
for (var index = 0; index < tags.length; index++) {
|
|
var tag = tags[index];
|
|
var blacklisted = blacklist[tag];
|
|
if (blacklisted) {
|
|
throw util_js_1.errtion({
|
|
message: "Skipping edition [" + edition.description + "] because it contained a blacklisted tag [" + tag + "]",
|
|
code: 'unsupported-edition-backlisted-tag'
|
|
}, blacklisted);
|
|
}
|
|
}
|
|
// Verify engine support
|
|
if (edition.engines === false) {
|
|
throw util_js_1.errtion({
|
|
message: "Skipping edition [" + edition.description + "] because its engines field was false",
|
|
code: 'unsupported-edition-engine'
|
|
});
|
|
}
|
|
if (!edition.engines.node) {
|
|
throw util_js_1.errtion({
|
|
message: "Skipping edition [" + edition.description + "] because its .engines.node field was falsey",
|
|
code: 'unsupported-edition-engines-node'
|
|
});
|
|
}
|
|
if (opts.strict) {
|
|
if (edition.engines.node === true) {
|
|
throw util_js_1.errtion({
|
|
message: "Skipping edition [" + edition.description + "] because its .engines.node field was true yet we are in strict mode",
|
|
code: 'unsupported-edition-engines-node-version-true'
|
|
});
|
|
}
|
|
else if (semver_1.default.satisfies(NODE_VERSION, edition.engines.node) === false) {
|
|
throw util_js_1.errtion({
|
|
message: "Skipping edition [" + edition.description + "] because our current node version [" + NODE_VERSION + "] is not supported by its specific range [" + util_js_1.stringify(edition.engines.node) + "]",
|
|
code: 'unsupported-edition-engines-node-version-specific'
|
|
});
|
|
}
|
|
}
|
|
else if (edition.engines.node !== true) {
|
|
var simplifiedRange = util_js_1.simplifyRange(edition.engines.node);
|
|
if (semver_1.default.satisfies(NODE_VERSION, simplifiedRange) === false) {
|
|
throw util_js_1.errtion({
|
|
message: "Skipping edition [" + edition.description + "] because our current node version [" + NODE_VERSION + "] is not supported by its simplified range [" + util_js_1.stringify(simplifiedRange) + "]",
|
|
code: 'unsupported-edition-engines-node-version-simplified'
|
|
});
|
|
}
|
|
}
|
|
// Load the edition
|
|
return loadEdition(edition, opts);
|
|
}
|
|
exports.requireEdition = requireEdition;
|
|
/**
|
|
* Cycles through a list of editions, returning the require result of the first suitable {@link Edition} that it was able to load.
|
|
* Editions should be ordered from most preferable first, to least desirable last.
|
|
* Providing the editions configuration is valid, individual edition handling is forwarded to {@link requireEdition}.
|
|
* @returns The result of the loaded edition.
|
|
* @throws An error if a suitable edition was unable to be resolved.
|
|
*/
|
|
function requireEditions(editions, opts) {
|
|
// Check
|
|
if (!editions || editions.length === 0) {
|
|
if (opts.packagePath) {
|
|
throw util_js_1.errtion({
|
|
message: "There were no editions specified for package [" + opts.packagePath + "]",
|
|
code: 'unsupported-editions-missing'
|
|
});
|
|
}
|
|
else {
|
|
throw util_js_1.errtion({
|
|
message: 'There were no editions specified',
|
|
code: 'unsupported-editions-missing'
|
|
});
|
|
}
|
|
}
|
|
// Handle strict omission
|
|
if (opts.strict == null) {
|
|
try {
|
|
return requireEditions(editions, __assign(__assign({}, opts), { strict: true }));
|
|
}
|
|
catch (err) {
|
|
return requireEditions(editions, __assign(__assign({}, opts), { strict: false }));
|
|
}
|
|
}
|
|
// Whether or not we should be verbose
|
|
var verbose = opts.verbose == null ? VERBOSE : opts.verbose;
|
|
// Capture the load result, the last error, and the fallback option
|
|
var result, loaded = false, editionsError = null, fallbackEdition = null;
|
|
// Cycle through the editions determing the above
|
|
for (var i = 0; i < editions.length; ++i) {
|
|
var edition = editions[i];
|
|
try {
|
|
result = requireEdition(edition, opts);
|
|
loaded = true;
|
|
break;
|
|
}
|
|
catch (editionError) {
|
|
if (editionError.level === 'fatal') {
|
|
editionsError = editionError;
|
|
break;
|
|
}
|
|
else if (editionsError) {
|
|
editionsError = util_js_1.errtion(editionsError, editionError);
|
|
}
|
|
else {
|
|
editionsError = editionError;
|
|
}
|
|
// make the fallback edition one that we don't bother loading due to its engines
|
|
// also: don't assume that .code is accessible, as it may not be, even if it should be, due to the way different environments behave
|
|
if (String(editionError.code || '').indexOf('unsupported-edition-engines-node-version') === 0) {
|
|
fallbackEdition = edition;
|
|
}
|
|
}
|
|
}
|
|
// if no edition was suitable for our environment, then try the fallback if it exists
|
|
// that is to say, ignore its engines.node
|
|
if (opts.strict === false && loaded === false && fallbackEdition) {
|
|
try {
|
|
result = loadEdition(fallbackEdition, opts);
|
|
loaded = true;
|
|
}
|
|
catch (editionError) {
|
|
editionsError = new errlop_1.default(editionError, editionsError);
|
|
}
|
|
}
|
|
// if we were able to load something, then provide it
|
|
if (loaded) {
|
|
// make note of any errors if desired
|
|
if (editionsError && verbose) {
|
|
var stderr = opts.stderr || process.stderr;
|
|
stderr.write(editionsError.stack + '\n');
|
|
}
|
|
return result;
|
|
}
|
|
// otherwise, provide the error
|
|
else if (editionsError) {
|
|
if (opts.packagePath) {
|
|
throw util_js_1.errtion({
|
|
message: "There were no suitable editions for package [" + opts.packagePath + "]",
|
|
code: 'unsupported-editions-tried'
|
|
}, editionsError);
|
|
}
|
|
else {
|
|
throw util_js_1.errtion({
|
|
message: 'There were no suitable editions',
|
|
code: 'unsupported-editions-tried'
|
|
}, editionsError);
|
|
}
|
|
}
|
|
}
|
|
exports.requireEditions = requireEditions;
|
|
/**
|
|
* Cycle through the editions for a package and require the correct one.
|
|
* Providing the package configuration is valid, editions handling is forwarded to {@link requireEditions}.
|
|
* @returns The result of the loaded edition.
|
|
* @throws An error if a suitable edition was unable to be resolved.
|
|
*/
|
|
function requirePackage(cwd, require, entry) {
|
|
// Load the package.json file to fetch `name` for debugging and `editions` for loading
|
|
var packagePath = path_1.default.resolve(cwd || '', 'package.json');
|
|
var editions = require(packagePath).editions;
|
|
var opts = { packagePath: packagePath, cwd: cwd, require: require, entry: entry };
|
|
return requireEditions(editions, opts);
|
|
}
|
|
exports.requirePackage = requirePackage;
|