[WIP] Add node's "engines" option

.gitignore

@@ -2,4 +2,5 @@ node_modules
 lib
 .DS_Store
 *.log
-.vscode
+.vscode
+yarn.lock

package.json

@@ -7,6 +7,12 @@
   "license": "MIT",
   "repository": "https://github.com/babel/babel-preset-env",
   "main": "lib/index.js",
+  "engines" : { 
+    "node" : ">=0.12.0"
+  },
+  "devEngines" : { 
+    "node" : ">= 4.x"
+  },
   "scripts": {
     "build": "rimraf lib && babel src -d lib",
     "build-data": "node ./scripts/build-data.js",
@@ -60,6 +66,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, getEnv } 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,47 @@ 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 env = getEnv(process.env);
+  const pkgPath = path.join(packageRoot, "package.json");
+
+  try {
+    const pkg = require(pkgPath);
+    const engines = env === "development" && pkg.devEngines || pkg.engines;
+    if (engines && engines.node) {
+      const version = 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 +181,22 @@ 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);
+  const {node} = targetOps;
 
-  if (targetOps.node === true || targetOps.node === "current") {
+  if (node === true || node === "current") {
     targetOps.node = getCurrentNodeVersion();
+  } else if (node === "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 +300,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 +337,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,28 @@
+const DEFAULT_ENV = "development";
+
+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;
+};
+
+export const getEnv = (env) => {
+  return env.BABEL_ENV || env.NODE_ENV || DEFAULT_ENV;
+};

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,49 @@ describe("babel-preset-env", () => {
       }), {
         node: parseFloat(process.versions.node)
       });
+
+    });
+
+    it("should return the current node version with option 'engines' with BABEL_ENV='development'", function() {
+      const prevEnv = process.env.BABEL_ENV;
+      process.env.BABEL_ENV = "development";
+
+      assert.deepEqual(babelPresetEnv.getTargets({
+        node: "engines"
+      }), {
+        node: 4
+      });
+
+      process.env.BABEL_ENV = prevEnv;
+    });
+
+    it("should return the current node version with option 'engines' with BABEL_ENV='production'", function() {
+      const prevEnv = process.env.BABEL_ENV;
+      process.env.BABEL_ENV = "production";
+
+      assert.deepEqual(babelPresetEnv.getTargets({
+        node: "engines"
+      }), {
+        node: 0.12
+      });
+      process.env.BABEL_ENV = prevEnv;
+    });
+  });
+
+  describe("getLowestFromSemverValue", () => {
+    it("should return the lowest supported version from semver value '>=0.12'", function() {
+      const lowestNodeVersion = babelPresetEnv.getLowestFromSemverValue(">=0.12", [4, 5, 6]);
+      assert.equal(lowestNodeVersion, 4);
+    });
+
+    it("should return null from semver value '*'", function() {
+      const lowestNodeVersion = babelPresetEnv.getLowestFromSemverValue("*", [4, 5, 6]);
+      assert.equal(lowestNodeVersion, null);
+    });
+
+    it("should return null if version isnt a semver value", function() {
+      const lowestNodeVersion = babelPresetEnv.getLowestFromSemverValue("💩", [4, 5, 6]);
+      assert.equal(lowestNodeVersion, null);
     });
   });