[WIP] Add node's "engines" option

package.json

@@ -7,6 +7,9 @@
   "license": "MIT",
   "repository": "https://github.com/babel/babel-preset-env",
   "main": "lib/index.js",
+  "engines" : { 
+    "node" : ">=0.12.0"
+  },
   "scripts": {
     "build": "rimraf lib && babel src -d lib",
     "build-data": "node ./scripts/build-data.js",
@@ -60,6 +63,7 @@
     "eslint-plugin-babel": "^4.0.0",
     "eslint-plugin-flow-vars": "^0.5.0",
     "eslint-plugin-flowtype": "^2.29.1",
+    "semver": "^5.3.0",
     "lodash": "^4.15.0",
     "mocha": "^3.0.2",
     "rimraf": "^2.5.4"

src/index.js

@@ -2,8 +2,11 @@ import pluginList from "../data/plugins.json";
 import pluginFeatures from "../data/plugin-features";
 import builtInsList from "../data/built-ins.json";
 import browserslist from "browserslist";
+import semver from "semver";
+import path from "path";
 import transformPolyfillRequirePlugin from "./transform-polyfill-require-plugin";
 import electronToChromium from "../data/electron-to-chromium";
+import { _extends, desemverify, semverify } from "./utils";
 
 export const MODULE_TRANSFORMATIONS = {
   "amd": "transform-es2015-modules-amd",
@@ -18,13 +21,44 @@ const defaultInclude = [
   "web.dom.iterable"
 ];
 
+const browserNameMap = {
+  chrome: "chrome",
+  edge: "edge",
+  firefox: "firefox",
+  ie: "ie",
+  ios_saf: "ios",
+  safari: "safari"
+};
+
 export const validIncludesAndExcludes = [
   ...Object.keys(pluginFeatures),
   ...Object.keys(MODULE_TRANSFORMATIONS).map((m) => MODULE_TRANSFORMATIONS[m]),
   ...Object.keys(builtInsList),
   ...defaultInclude
 ];
 
+const getVersionsFromList = (list) => {
+  return Object.keys(list).reduce((allVersions, currentItem) => {
+    const currentVersions = list[currentItem];
+    for (let envName in currentVersions) {
+      const currentVersion = allVersions[envName];
+      const envVersion = currentVersions[envName];
+
+      if (!currentVersion) {
+        allVersions[envName] = [envVersion];
+      } else if (currentVersion.indexOf(envVersion) === -1) {
+        allVersions[envName].push(envVersion);
+      }
+    }
+
+    for (let env in allVersions) {
+      allVersions[env].sort((a, b) => a - b);
+    }
+
+    return allVersions;
+  }, {});
+};
+
 /**
  * Determine if a transformation is required
  * @param  {Object}  supportedEnvironments  An Object containing environment keys and the lowest
@@ -33,9 +67,9 @@ export const validIncludesAndExcludes = [
  *                                          version the feature was implmented in as a value
  * @return {Boolean}  Whether or not the transformation is required
  */
-export const isPluginRequired = (supportedEnvironments, plugin) => {
+export const isPluginRequired = (supportedEnvironments, plugin, options) => {
   if (supportedEnvironments.browsers) {
-    supportedEnvironments = getTargets(supportedEnvironments);
+    supportedEnvironments = getTargets(supportedEnvironments, options);
   }
 
   const targetEnvironments = Object.keys(supportedEnvironments);
@@ -64,15 +98,6 @@ const isBrowsersQueryValid = (browsers) => {
   return typeof browsers === "string" || Array.isArray(browsers);
 };
 
-const browserNameMap = {
-  chrome: "chrome",
-  edge: "edge",
-  firefox: "firefox",
-  ie: "ie",
-  ios_saf: "ios",
-  safari: "safari"
-};
-
 const getLowestVersions = (browsers) => {
   return browsers.reduce((all, browser) => {
     const [browserName, browserVersion] = browser.split(" ");
@@ -93,7 +118,45 @@ const mergeBrowsers = (fromQuery, fromTarget) => {
 };
 
 export const getCurrentNodeVersion = () => {
-  return parseFloat(process.versions.node);
+  return desemverify(process.versions.node);
+};
+
+const filterSatisfiedVersions = (range, versions) => {
+  return versions.filter((targ) => semver.satisfies(targ, range));
+};
+
+export const getLowestFromSemverValue = (version, versionsList) => {
+  let lowestSupported;
+  if (version === "*") {
+    return null;
+  }
+
+  if (semver.valid(version)) {
+    lowestSupported = parseFloat(version);
+  } else if (semver.validRange(version)) {
+    const versions = versionsList.map(semverify);
+    const allSupported = filterSatisfiedVersions(version, versions);
+    if (allSupported.length) {
+      lowestSupported = allSupported[0];
+    }
+  }
+  return lowestSupported ? desemverify(lowestSupported) : null;
+};
+
+export const getEnginesNodeVersion = (packageRoot, supportedVersions) => {
+  const pkgPath = path.join(packageRoot, "package.json");
+
+  try {
+    const pkg = require(pkgPath);
+    if (pkg.engines && pkg.engines.node) {
+      const version = pkg.engines.node;
+      return getLowestFromSemverValue(version, supportedVersions);
+    } else {
+      console.warn(`Can't get node.js version from \`engines\` field in ${pkgPath}.`);
+    }
+  } catch (e) {
+    console.warn(`Can't parse ${pkgPath} while trying to get node.js version from \`engines\` field.`);
+  }
 };
 
 export const electronVersionToChromeVersion = (semverVer) => {
@@ -116,24 +179,21 @@ export const electronVersionToChromeVersion = (semverVer) => {
   return result;
 };
 
-const _extends = Object.assign || function (target) {
-  for (let i = 1; i < arguments.length; i++) {
-    const source = arguments[i];
-    for (let key in source) {
-      if (Object.prototype.hasOwnProperty.call(source, key)) {
-        target[key] = source[key];
-      }
-    }
-  }
-  return target;
-};
-
 
-export const getTargets = (targets = {}) => {
+export const getTargets = (targets = {}, options = {}) => {
   const targetOps = _extends({}, targets);
-
-  if (targetOps.node === true || targetOps.node === "current") {
+  const {node: targetNode} = targetOps;
+  if (targetNode === true || targetNode === "current") {
     targetOps.node = getCurrentNodeVersion();
+  } else if (targetNode === "engines") {
+    const lists = [pluginList];
+    if (options.useBuiltIns) {
+      lists.push(builtInsList);
+    }
+
+    const allSupportedVersions = getVersionsFromList(_extends({}, ...lists));
+    const supportedNodeVersions = allSupportedVersions["node"];
+    targetOps.node = getEnginesNodeVersion(process.cwd(), supportedNodeVersions);
   }
 
   // Rewrite Electron versions to their Chrome equivalents
@@ -237,17 +297,17 @@ export default function buildPreset(context, opts = {}) {
   const include = validateIncludeOption(opts.whitelist || opts.include);
   const exclude = validateExcludeOption(opts.exclude);
   checkDuplicateIncludeExcludes(include.all, exclude.all);
-  const targets = getTargets(opts.targets);
+  const targets = getTargets(opts.targets, opts);
   const debug = opts.debug;
   const useBuiltIns = opts.useBuiltIns;
 
   let transformations = Object.keys(pluginList)
-    .filter((pluginName) => isPluginRequired(targets, pluginList[pluginName]));
+    .filter((pluginName) => isPluginRequired(targets, pluginList[pluginName], opts));
 
   let polyfills;
   if (useBuiltIns) {
     polyfills = Object.keys(builtInsList)
-      .filter((builtInName) => isPluginRequired(targets, builtInsList[builtInName]))
+      .filter((builtInName) => isPluginRequired(targets, builtInsList[builtInName], opts))
       .concat(defaultInclude)
       .filter((plugin) => exclude.builtIns.indexOf(plugin) === -1)
       .concat(include.builtIns);
@@ -274,8 +334,8 @@ export default function buildPreset(context, opts = {}) {
   }
 
   const allTransformations = transformations
-  .filter((plugin) => exclude.plugins.indexOf(plugin) === -1)
-  .concat(include.plugins);
+    .filter((plugin) => exclude.plugins.indexOf(plugin) === -1)
+    .concat(include.plugins);
 
   const regenerator = allTransformations.indexOf("transform-regenerator") >= 0;
   const modulePlugin = moduleType !== false && MODULE_TRANSFORMATIONS[moduleType];

src/utils.js

@@ -0,0 +1,23 @@
+export const _extends = Object.assign || function (target) {
+  for (let i = 1; i < arguments.length; i++) {
+    const source = arguments[i];
+    for (let key in source) {
+      if (Object.prototype.hasOwnProperty.call(source, key)) {
+        target[key] = source[key];
+      }
+    }
+  }
+  return target;
+};
+
+export const desemverify = (version) => {
+  return parseFloat(version);
+};
+
+export const semverify = (version) => {
+  const isInt = version % 1 === 0;
+  const stringified = version.toString();
+  const strEnd = isInt ? ".0.0" : ".0";
+  return stringified + strEnd;
+};
+

test/fixtures/preset-options/node-engines/actual.js

@@ -0,0 +1 @@
+const a = "1";

test/fixtures/preset-options/node-engines/expected.js

@@ -0,0 +1,3 @@
+"use strict";
+
+var a = "1";

test/fixtures/preset-options/node-engines/options.json

@@ -0,0 +1,10 @@
+{
+  "presets": [
+    ["../../../../lib", {
+      "targets": {
+        "node": "engines",
+        "chrome": "55"
+      }
+    }]
+  ]
+}

test/index.js

@@ -25,6 +25,22 @@ describe("babel-preset-env", () => {
       }), {
         node: parseFloat(process.versions.node)
       });
+
+    });
+
+    it("should return the current node version with option 'engines'", function() {
+      assert.deepEqual(babelPresetEnv.getTargets({
+        node: "engines"
+      }), {
+        node: 0.12
+      });
+    });
+  });
+
+  describe("getLowestFromSemverValue", () => {
+    it("should return the lowest supported version from semver value", function() {
+      const lowestNodeVersion = babelPresetEnv.getLowestFromSemverValue(">=0.12", [4, 5, 6]);
+      assert.equal(lowestNodeVersion, 4);
     });
   });