initial commit

node_modules/editions/es2015/index.js

@@ -0,0 +1,211 @@
+/* @flow */
+/* eslint no-console:0 */
+'use strict';
+
+// Imports
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
+
+function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
+
+var pathUtil = require('path');
+
+// Helper class to display nested error in a sensible way
+
+var DetailedError = function (_Error) {
+	_inherits(DetailedError, _Error);
+
+	function DetailedError(message /* :string */, details /* :Object */) {
+		_classCallCheck(this, DetailedError);
+
+		Object.keys(details).forEach(function (key) {
+			var data = details[key];
+			var value = require('util').inspect(data.stack || data.message || data);
+			message += '\n' + key + ': ' + value;
+		});
+		return _possibleConstructorReturn(this, (DetailedError.__proto__ || Object.getPrototypeOf(DetailedError)).call(this, message));
+	}
+
+	return DetailedError;
+}(Error);
+
+// Environment fetching
+
+
+var blacklist = process && process.env && process.env.EDITIONS_SYNTAX_BLACKLIST && process.env.EDITIONS_SYNTAX_BLACKLIST.split(',');
+
+// Cache of which syntax combinations are supported or unsupported, hash of booleans
+var syntaxFailedCombitions = {}; // sorted lowercase syntax combination => Error instance of failure
+var syntaxBlacklist = {};
+syntaxBlacklist.import = new Error('The import syntax is skipped as the module package.json field eliminates the need for autoloader support');
+syntaxBlacklist.coffeescript = new Error('The coffeescript syntax is skipped as we want to use a precompiled edition rather than compiling at runtime');
+syntaxBlacklist.typescript = new Error('The typescript syntax is skipped as we want to use a precompiled edition rather than compiling at runtime');
+
+// Blacklist non-esnext node versions from esnext
+if (process && process.versions && process.versions.node) {
+	var EARLIEST_ESNEXT_NODE_VERSION = [0, 12];
+	var NODE_VERSION = process.versions.node.split('.').map(function (n) {
+		return parseInt(n, 10);
+	});
+	var ESNEXT_UNSUPPORTED = NODE_VERSION[0] < EARLIEST_ESNEXT_NODE_VERSION[0] || NODE_VERSION[0] === EARLIEST_ESNEXT_NODE_VERSION[0] && NODE_VERSION[1] < EARLIEST_ESNEXT_NODE_VERSION[1];
+	if (ESNEXT_UNSUPPORTED) syntaxBlacklist.esnext = new Error('The esnext syntax is skipped on early node versions as attempting to use esnext features will output debugging information on these node versions');
+}
+
+// Check the environment configuration for a syntax blacklist
+if (blacklist) {
+	for (var i = 0; i < blacklist.length; ++i) {
+		var syntax = blacklist[i].trim().toLowerCase();
+		syntaxBlacklist[syntax] = new DetailedError('The EDITIONS_SYNTAX_BLACKLIST environment variable has blacklisted an edition syntax:', { syntax: syntax, blacklist: blacklist });
+	}
+}
+
+/* ::
+type edition = {
+	name:number,
+	description?:string,
+	directory?:string,
+	entry?:string,
+	syntaxes?:Array<string>
+};
+type options = {
+	cwd?:string,
+	package?:string,
+	entry?:string,
+	require:function
+};
+*/
+
+/**
+ * Cycle through the editions and require the correct one
+ * @protected internal function that is untested for public consumption
+ * @param {edition} edition - the edition entry
+ * @param {Object} opts - the following options
+ * @param {string} opts.require - the require method of the calling module, used to ensure require paths remain correct
+ * @param {string} [opts.cwd] - if provided, this will be the cwd for entries
+ * @param {string} [opts.entry] - if provided, should be a relative or absolute path to the entry point of the edition
+ * @param {string} [opts.package] - if provided, should be the name of the package that we are loading the editions for
+ * @returns {*}
+ */
+function requireEdition(edition /* :edition */, opts /* :options */) /* :any */{
+	// Prevent require from being included in debug logs
+	Object.defineProperty(opts, 'require', { value: opts.require, enumerable: false });
+
+	// Get the correct entry path
+	// As older versions o
+	var cwd = opts.cwd || '';
+	var dir = edition.directory || '';
+	var entry = opts.entry || edition.entry || '';
+	if (dir && entry && entry.indexOf(dir + '/') === 0) entry = entry.substring(dir.length + 1);
+	// ^ this should not be needed, but as previous versions of editions included the directory inside the entry
+	// it unfortunately is, as such this is a stepping stone for the new format, the new format being
+	// if entry is specified by itself, it is cwd => entry
+	// if entry is specified with a directory, it is cwd => dir => entry
+	// if entry is not specified but dir is, it is cwd => dir
+	// if neither entry nor dir are specified, we have a problem
+	if (!dir && !entry) {
+		var editionFailure = new DetailedError('Skipped edition due to no entry or directory being specified:', { edition: edition, cwd: cwd, dir: dir, entry: entry });
+		throw editionFailure;
+	}
+	var entryPath = pathUtil.resolve(cwd, dir, entry);
+
+	// Check syntax support
+	// Convert syntaxes into a sorted lowercase string
+	var syntaxes = edition.syntaxes && edition.syntaxes.map(function (i) {
+		return i.toLowerCase();
+	}).sort();
+	var syntaxCombination = syntaxes && syntaxes.join(', ');
+	if (syntaxes && syntaxCombination) {
+		// Check if any of the syntaxes are unsupported
+		var unsupportedSyntaxes = syntaxes.filter(function (i) {
+			return syntaxBlacklist[i.toLowerCase()];
+		});
+		if (unsupportedSyntaxes.length) {
+			var _editionFailure = new DetailedError('Skipped edition due to it containing an unsupported syntax:', { edition: edition, unsupportedSyntaxes: unsupportedSyntaxes });
+			throw _editionFailure;
+		}
+		// Is this syntax combination unsupported? If so skip it with a soft failure to try the next edition
+		else if (syntaxFailedCombitions[syntaxCombination]) {
+				var previousCombinationFailure = syntaxFailedCombitions[syntaxCombination];
+				var _editionFailure2 = new DetailedError('Skipped edition due to its syntax combinatiom failing previously:', { edition: edition, previousCombinationFailure: previousCombinationFailure });
+				throw _editionFailure2;
+			}
+	}
+
+	// Try and load this syntax combination
+	try {
+		return opts.require(entryPath);
+	} catch (error) {
+		// Note the error with more details
+		var _editionFailure3 = new DetailedError('Failed to load the edition due to a load error:', { edition: edition, error: error.stack });
+
+		// Blacklist the combination, even if it may have worked before
+		// Perhaps in the future note if that if it did work previously, then we should instruct module owners to be more specific with their syntaxes
+		if (syntaxCombination) syntaxFailedCombitions[syntaxCombination] = _editionFailure3;
+
+		// Continue to the next edition
+		throw _editionFailure3;
+	}
+}
+
+/**
+ * Cycle through the editions and require the correct one
+ * @protected internal function that is untested for public consumption
+ * @param {Array<edition>} editions - an array of edition entries
+ * @param {Object} opts - the following options
+ * @param {string} opts.require - the require method of the calling module, used to ensure require paths remain correct
+ * @param {string} [opts.cwd] - if provided, this will be the cwd for entries
+ * @param {string} [opts.entry] - if provided, should be a relative path to the entry point of the edition
+ * @param {string} [opts.package] - if provided, should be the name of the package that we are loading the editions for
+ * @returns {*}
+ */
+function requireEditions(editions /* :Array<edition> */, opts /* :options */) /* :any */{
+	// Extract
+	if (opts.package == null) opts.package = 'custom runtime package';
+
+	// Check
+	if (!editions || editions.length === 0) {
+		throw new DetailedError('No editions were specified:', { opts: opts });
+	}
+
+	// Note the last error message
+	var editionFailures = [];
+
+	// Cycle through the editions
+	for (var _i = 0; _i < editions.length; ++_i) {
+		var edition = editions[_i];
+		try {
+			return requireEdition(edition, opts);
+		} catch (err) {
+			editionFailures.push(err);
+		}
+	}
+
+	// Through the error as no edition loaded
+	throw new DetailedError('There are no suitable editions for this environment:', { opts: opts, editions: editions, failures: editionFailures });
+}
+
+/**
+ * Cycle through the editions for a package and require the correct one
+ * @param {string} cwd - the path of the package, used to load package.json:editions and handle relative edition entry points
+ * @param {function} require - the require method of the calling module, used to ensure require paths remain correct
+ * @param {string} [entry] - an optional override for the entry of an edition, requires the edition to specify a `directory` property
+ * @returns {*}
+ */
+function requirePackage(cwd /* :string */, require /* :function */, entry /* :: ?:string */) /* :any */{
+	// Load the package.json file to fetch `name` for debugging and `editions` for loading
+	var packagePath = pathUtil.resolve(cwd, 'package.json');
+
+	var _require = require(packagePath),
+	    name = _require.name,
+	    editions = _require.editions;
+
+	var opts /* :options */ = { cwd: cwd, require: require };
+	if (name) opts.package = name;
+	if (entry) opts.entry = entry;
+	return requireEditions(editions, opts);
+}
+
+// Exports
+module.exports = { requireEdition: requireEdition, requireEditions: requireEditions, requirePackage: requirePackage };