Add a spec mode to transform-es2015-modules-commonjs

packages/babel-core/src/transformation/file/index.js

@@ -288,14 +288,14 @@ export default class File extends Store {
 
     const generator = this.get("helperGenerator");
     const runtime   = this.get("helpersNamespace");
+    const res = generator && generator(name);
     if (generator) {
-      const res = generator(name);
-      if (res) return res;
+      if (res && t.isIdentifier(res)) return res;
     } else if (runtime) {
       return t.memberExpression(runtime, t.identifier(name));
     }
 
-    const ref = getHelper(name);
+    const ref = res || getHelper(name);
     const uid = this.declarations[name] = this.scope.generateUidIdentifier(name);
 
     if (t.isFunctionExpression(ref) && !ref.id) {

packages/babel-helpers/src/helpers.js

@@ -396,6 +396,9 @@ helpers.interopRequireDefault = template(`
   })
 `);
 
+// interopRequireDefault doesn't technically match spec,
+// but where it does not match is not observable
+
 helpers.interopRequireWildcard = template(`
   (function (obj) {
     if (obj && obj.__esModule) {
@@ -413,6 +416,93 @@ helpers.interopRequireWildcard = template(`
   })
 `);
 
+helpers.specRequireInterop = template(`
+  (function (obj) {
+    if (obj && obj.__esModule) {
+      return obj;
+    } else {
+      var newObj = Object.create ? Object.create(null, {
+          default: {
+            value: obj,
+            writable: true,
+            enumerable: true
+          },
+          __esModule: {
+            value: true
+          }
+        }) : {
+          default: obj,
+          __esModule: true
+        };
+      if (typeof Symbol === "function" && Symbol.toStringTag) {
+        Object.defineProperty(newObj, Symbol.toStringTag, { value: "Module" })
+      }
+      return (Object.freeze || Object)(newObj);
+    }
+  })
+`);
+
+helpers.specImportCheck = template(`
+  (function (module, imports) {
+    if (!module.__esModule) throw new Error("Only ES modules can be checked");
+    var invalid = imports.filter(function (i) { return !Object.prototype.propertyIsEnumerable.call(module, i) });
+    if (invalid.length > 0) {
+      var error = new Error(
+        "Unknown export" + (invalid.length > 1 ? "s " : " ") +
+        JSON.stringify(invalid) +
+        " imported"
+      );
+      error.module = module;
+      throw error;
+    }
+  })
+`);
+
+// The name && typeof Symbol === "function" && ... line is from helpers.typeof, which may be needed
+// when polyfilled. Helpers might not be transformed when using external-helpers, so can't rely on
+// the typeof being augmented when targeting ES5.
+helpers.specNamespaceGet = template(`
+  (function (module, name) {
+    if (!module.__esModule) throw new Error("Only ES modules can be checked");
+    if (
+      typeof name === "symbol" ||
+      name && typeof Symbol === "function" && name.constructor === Symbol && name !== Symbol.prototype
+    ) {
+      return module[name];
+    }
+    if (!Object.prototype.propertyIsEnumerable.call(module, name)) {
+      throw new Error("Unknown export " + JSON.stringify(name) + " imported");
+    }
+    return module[name];
+  })
+`);
+
+// sameValue function based on core-js's SameValue implementation
+// https://github.com/zloirock/core-js/blob/693767b/modules/_same-value.js
+helpers.specNamespaceSpread = template(`
+  (function (exports, ownExports, module) {
+    if (!module.__esModule) throw new Error("Only ES modules can be spread");
+    for (var key in module) {
+      if (!Object.prototype.hasOwnProperty.call(module, key)) continue;
+      if (key === "__esModule" || key === "default" || ownExports.indexOf(key) >= 0) continue;
+      if (key in exports && sameValue(exports[key], module[key])) continue;
+
+      Object.defineProperty(exports, key, {
+        enumerable: true,
+        get: (function (key) {
+          return function () {
+            return module[key];
+          }
+        })(key)
+      });
+    }
+
+    function sameValue(x, y) {
+      return x === y ? x !== 0 || 1 / x === 1 / y : x != x && y != y;
+    }
+  })
+`);
+
 helpers.newArrowCheck = template(`
   (function (innerThis, boundThis) {
     if (innerThis !== boundThis) {

packages/babel-plugin-transform-es2015-modules-commonjs/README.md

@@ -42,7 +42,7 @@ npm install --save-dev babel-plugin-transform-es2015-modules-commonjs
 {
   "plugins": [
     ["transform-es2015-modules-commonjs", {
-      "allowTopLevelThis": true
+      "spec": true
     }]
   ]
 }
@@ -62,6 +62,125 @@ require("babel-core").transform("code", {
 });
 ```
 
+## Options `spec`
+
+By default, `babel` actually implements importing very loosely, by
+supporting treating a commonjs export as if it was a namespace export.
+The exported namespace is also not frozen and has an incorrect prototype.
+
+The `spec` option, when set to `true`, tries to generate code that is as
+close as possible to what is required by the ECMA262 spec without relying
+on `Proxy`. The exports will be frozen, and imports will always be treated
+like ES modules. All imported names will be checked, at import time, if
+they exist in the exports of the imported module. If `let` and `const` are
+not transformed to `var`, the exports will also implement TDZ.
+
+Importing a commonjs module (say, the standard `fs` module) will always
+wrap it in an ES module that has a single `default` export. This means that
+some imports that work in non-`spec` mode, like `import { readFile } from 'fs'`,
+will result errors in `spec` mode.
+
+Note that exports, under this mode, always require runtime support for
+getters. It also is not possible to access or write to the commonjs
+`exports` or `module` objects; attempts to access them will result in
+TDZ errors at runtime.
+
+### Input
+
+```javascript
+import 'a';
+import defaultImport from 'b';
+import * as namespace from 'c';
+import { pick } from 'd';
+
+defaultImport(namespace.foo, pick);
+
+export { pick }
+export default function () {}
+```
+
+### Output
+
+```javascript
+'use strict';
+
+const exports = module.exports = Object.create ? Object.create(null, {
+  __esModule: {
+    value: true
+  }
+}) : {
+  __esModule: true
+};
+if (typeof Symbol === "function" && Symbol.toStringTag) {
+  Object.defineProperty(exports, Symbol.toStringTag, {
+    value: "Module"
+  });
+}
+
+Object.defineProperties(exports, {
+  pick: { enumerable: true, get() { return _d.pick; } },
+  default: { enumerable: true, get() { return _default; } }
+});
+let _default = {
+  default: function () {}
+}.default;
+(Object.freeze || Object)(exports);
+
+require('a');
+
+const _b = babelHelpers.specRequireInterop(require('b'));
+
+babelHelpers.specImportCheck(_b, ['default']);
+
+const _c = babelHelpers.specRequireInterop(require('c'));
+
+babelHelpers.specImportCheck(_c, ['foo']);
+
+const _d = babelHelpers.specRequireInterop(require('d'));
+
+babelHelpers.specImportCheck(_d, ['pick']);
+
+
+(0, _b.default)(_c.foo, _d.pick);
+```
+
+## Options `specImport`
+
+This option enables only the half of `spec` mode that affects the imports, without
+changing how exports are generated. This would allow the generation of code that
+may still be compatible with engines that do not support getters.
+
+Note that the require helpers do use `Object.getOwnPropertyDescriptor` and
+`Object.defineProperty`, so ES5 polyfills may still be required. When running on an
+old engine that does not support `Object.defineProperty`, a polyfill to fake it like
+`es5-sham` is required.
+
+This option is **ignored** if `spec` is enabled. Enabling `spec` implies that this
+option is also enabled.
+
+### Input
+
+```javascript
+import { pick } from 'module'
+
+export default pick()
+```
+
+### Output
+
+```javascript
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+const _module = babelHelpers.specRequireInterop(require('module'));
+
+babelHelpers.specImportCheck(_module, ['pick']);
+exports.default = (0, _module.pick)();
+```
+
 ## Options `loose`
 
 As per the spec, `import` and `export` are only allowed to be used at the top
@@ -85,3 +204,16 @@ and instead of using `Object.defineProperty` an assignment will be used instead.
 var foo = exports.foo = 5;
 exports.__esModule = true;
 ```
+
+The `loose` option is **ignored** if used in combination with `spec`.
+
+## Caveats
+
+Star reexports (`export * from 'module'`) always run before other imports or
+reexports, as this module's exports must be known before other modules execute.
+That is, they behave as if there was an `import 'module'` that runs before any
+of the other imports.
+
+This is particularly hard to avoid in the `spec` / `specImport` mode, as the
+exports must be frozen before importing other modules. Star reexports are the
+only exception.