rename common to commonStrict and commonInterop to common

lib/6to5/templates/exports-default-module-override.js

@@ -0,0 +1 @@
+exports = module.exports = VALUE;

lib/6to5/transformation/modules/_default.js

@@ -0,0 +1,153 @@
+module.exports = DefaultFormatter;
+
+var traverse = require("../../traverse");
+var util     = require("../../util");
+var t        = require("../../types");
+var _        = require("lodash");
+
+function DefaultFormatter(file) {
+  this.exports = [];
+  this.file    = file;
+
+  var localExports = [];
+  _.each(file.ast.program.body, function (node) {
+    var declar = node.declaration;
+    if (t.isExportDeclaration(node) && declar && t.isStatement(declar)) {
+      localExports = localExports.concat(t.getIds(declar));
+    }
+  });
+  this.localExports = localExports;
+
+  this.remapAssignments();
+}
+
+DefaultFormatter.prototype.remapAssignments = function () {
+  var localExports = this.localExports;
+
+  traverse(this.file.ast, function (node) {
+    if (t.isExportDeclaration(node)) return false;
+
+    if (t.isAssignmentExpression(node)) {
+      var left = node.left;
+      if (t.isIdentifier(left) && _.contains(localExports, left.name)) {
+        return t.assignmentExpression(
+          "=",
+          left,
+          t.assignmentExpression(
+            node.operator,
+            t.memberExpression(t.identifier("exports"), left),
+            node.right
+          )
+        );
+      }
+    }
+  });
+};
+
+DefaultFormatter.prototype.getModuleName = function () {
+  var opts = this.file.opts;
+  var filenameRelative = opts.filenameRelative;
+  var moduleName = "";
+
+  if (opts.moduleRoot) {
+    moduleName = opts.moduleRoot + "/";
+  }
+
+  if (!opts.filenameRelative) {
+    return moduleName + opts.filename.replace(/^\//, "");
+  }
+
+  if (opts.sourceRoot) {
+    // remove sourceRoot from filename
+    var sourceRootRegEx = new RegExp("^" + opts.sourceRoot + "\/?");
+    filenameRelative = filenameRelative.replace(sourceRootRegEx, "");
+  }
+
+  // remove extension
+  filenameRelative = filenameRelative.replace(/\.(.*?)$/, "");
+
+  moduleName += filenameRelative;
+
+  return moduleName;
+};
+
+DefaultFormatter.prototype._pushStatement = function (ref, nodes) {
+  if (t.isClass(ref) || t.isFunction(ref)) {
+    if (ref.id) {
+      nodes.push(t.toStatement(ref));
+      ref = ref.id;
+    }
+  }
+
+  return ref;
+};
+
+DefaultFormatter.prototype._hoistExport = function (declar, assign) {
+  if (t.isFunctionDeclaration(declar)) {
+    assign._blockHoist = true;
+  }
+
+  return assign;
+};
+
+DefaultFormatter.prototype._exportSpecifier = function (getRef, specifier, node, nodes) {
+  var variableName = t.getSpecifierName(specifier);
+
+  var inherits = false;
+  if (node.specifiers.length === 1) inherits = node;
+
+  if (node.source) {
+    if (t.isExportBatchSpecifier(specifier)) {
+      // export * from "foo";
+      nodes.push(util.template("exports-wildcard", {
+        OBJECT: getRef()
+      }, true));
+    } else {
+      // export { foo } from "test";
+      nodes.push(util.template("exports-assign-key", {
+        VARIABLE_NAME: variableName.name,
+        OBJECT:        getRef(),
+        KEY:           specifier.id
+      }, true));
+    }
+  } else {
+    // export { foo };
+    nodes.push(util.template("exports-assign", {
+      VALUE: specifier.id,
+      KEY:   variableName
+    }, true));
+  }
+};
+
+DefaultFormatter.prototype.export = function (node, nodes) {
+  var declar = node.declaration;
+
+  if (node.default) {
+    nodes.push(util.template("exports-default", {
+      VALUE: this._pushStatement(declar, nodes)
+    }, true));
+  } else {
+    var assign;
+
+    if (t.isVariableDeclaration(declar)) {
+      var decl = declar.declarations[0];
+
+      decl.init = util.template("exports-assign", {
+        VALUE: decl.init,
+        KEY:   decl.id
+      });
+
+      nodes.push(declar);
+    } else {
+      assign = util.template("exports-assign", {
+        VALUE: declar.id,
+        KEY:   declar.id
+      }, true);
+
+      nodes.push(t.toStatement(declar));
+      nodes.push(assign);
+
+      this._hoistExport(declar, assign);
+    }
+  }
+};

lib/6to5/transformation/modules/amd.js

@@ -1,16 +1,20 @@
 module.exports = AMDFormatter;
 
-var CommonJSFormatter = require("./common");
-var util              = require("../../util");
-var t                 = require("../../types");
-var _                 = require("lodash");
+var DefaultFormatter = require("./_default");
+var util             = require("../../util");
+var t                = require("../../types");
+var _                = require("lodash");
 
 function AMDFormatter(file) {
   this.file = file;
   this.ids  = {};
 }
 
-util.inherits(AMDFormatter, CommonJSFormatter);
+util.inherits(AMDFormatter, DefaultFormatter);
+
+/**
+ * Wrap the entire body in a `define` wrapper.
+ */
 
 AMDFormatter.prototype.transform = function (ast) {
   var program = ast.program;
@@ -40,6 +44,11 @@ AMDFormatter.prototype.transform = function (ast) {
   program.body = [t.expressionStatement(call)];
 };
 
+/**
+ * Get the AMD module name that we'll prepend to the wrapper
+ * to define this module
+ */
+
 AMDFormatter.prototype.getModuleName = function () {
   if (this.file.opts.amdModuleIds) {
     return CommonJSFormatter.prototype.getModuleName.apply(this, arguments);

lib/6to5/transformation/modules/common-interop.js

@@ -1,56 +0,0 @@
-module.exports = CommonJSInteropFormatter;
-
-var CommonJSFormatter = require("./common");
-var util              = require("../../util");
-var t                 = require("../../types");
-var _                 = require("lodash");
-
-function CommonJSInteropFormatter(file) {
-  CommonJSFormatter.apply(this, arguments);
-
-  var has = false;
-  _.each(file.ast.program.body, function (node) {
-    if (t.isExportDeclaration(node) && !node.default) has = true;
-  });
-  this.has = has;
-}
-
-util.inherits(CommonJSInteropFormatter, CommonJSFormatter);
-
-CommonJSInteropFormatter.prototype.importSpecifier = function (specifier, node, nodes) {
-  var variableName = t.getSpecifierName(specifier);
-
-  // import foo from "foo";
-   if (specifier.default) {
-    nodes.push(t.variableDeclaration("var", [
-      t.variableDeclarator(variableName,
-        t.callExpression(this.file.addDeclaration("interop-require"), [util.template("require", {
-          MODULE_NAME: node.source.raw
-        })])
-      )
-    ]));
-  } else {
-    CommonJSFormatter.prototype.importSpecifier.apply(this, arguments);
-  }
-};
-
-CommonJSInteropFormatter.prototype.export = function (node, nodes) {
-  if (node.default && !this.has) {
-    var declar = node.declaration;
-
-    // module.exports = VALUE;
-    var assign = util.template("exports-default-module", {
-      VALUE: this._pushStatement(declar, nodes)
-    }, true);
-
-    // hoist to the top if this default is a function
-    nodes.push(this._hoistExport(declar, assign));
-    return;
-  }
-
-  CommonJSFormatter.prototype.export.apply(this, arguments);
-};
-
-CommonJSInteropFormatter.prototype.exportSpecifier = function () {
-  CommonJSFormatter.prototype.exportSpecifier.apply(this, arguments);
-};

lib/6to5/transformation/modules/common-strict.js

@@ -0,0 +1,46 @@
+module.exports = CommonJSStrictFormatter;
+
+var DefaultFormatter = require("./_default");
+var util             = require("../../util");
+var t                = require("../../types");
+
+function CommonJSStrictFormatter() {
+  DefaultFormatter.apply(this, arguments);
+}
+
+util.inherits(CommonJSStrictFormatter, DefaultFormatter);
+
+CommonJSStrictFormatter.prototype.import = function (node, nodes) {
+  // import "foo";
+  nodes.push(util.template("require", {
+    //inherits: node,
+
+    MODULE_NAME: node.source.raw
+  }, true));
+};
+
+CommonJSStrictFormatter.prototype.importSpecifier = function (specifier, node, nodes) {
+  var variableName = t.getSpecifierName(specifier);
+
+  // import foo from "foo";
+  if (specifier.default) {
+    specifier.id = t.identifier("default");
+  }
+
+  var templateName = "require-assign";
+
+  // import * as bar from "foo";
+  if (specifier.type !== "ImportBatchSpecifier") templateName += "-key";
+
+  nodes.push(util.template(templateName, {
+    VARIABLE_NAME: variableName,
+    MODULE_NAME:   node.source.raw,
+    KEY:           specifier.id
+  }));
+};
+
+CommonJSStrictFormatter.prototype.exportSpecifier = function (specifier, node, nodes) {
+  this._exportSpecifier(function () {
+    return t.callExpression(t.identifier("require"), [node.source]);
+  }, specifier, node, nodes);
+};

lib/6to5/transformation/modules/common.js

@@ -1,164 +1,60 @@
 module.exports = CommonJSFormatter;
 
-var util = require("../../util");
-var t    = require("../../types");
+var CommonJSStrictFormatter = require("./common-strict");
+var util                    = require("../../util");
+var t                       = require("../../types");
+var _                       = require("lodash");
 
 function CommonJSFormatter(file) {
-  this.file = file;
+  CommonJSStrictFormatter.apply(this, arguments);
+
+  var hasNonDefaultExports = false;
+  _.each(file.ast.program.body, function (node) {
+    if (t.isExportDeclaration(node) && !node.default) hasNonDefaultExports = true;
+  });
+  this.hasNonDefaultExports = hasNonDefaultExports;
 }
 
-CommonJSFormatter.prototype.getModuleName = function () {
-  var opts = this.file.opts;
-  var filenameRelative = opts.filenameRelative;
-  var moduleName = "";
-
-  if (opts.moduleRoot) {
-    moduleName = opts.moduleRoot + "/";
-  }
-
-  if (!opts.filenameRelative) {
-    return moduleName + opts.filename.replace(/^\//, "");
-  }
-
-  if (opts.sourceRoot) {
-    // remove sourceRoot from filename
-    var sourceRootRegEx = new RegExp("^" + opts.sourceRoot + "\/?");
-    filenameRelative = filenameRelative.replace(sourceRootRegEx, "");
-  }
-
-  // remove extension
-  filenameRelative = filenameRelative.replace(/\.(.*?)$/, "");
-
-  moduleName += filenameRelative;
-
-  return moduleName;
-};
-
-CommonJSFormatter.prototype.import = function (node, nodes) {
-  // import "foo";
-  nodes.push(util.template("require", {
-    //inherits: node,
-
-    MODULE_NAME: node.source.raw
-  }, true));
-};
+util.inherits(CommonJSFormatter, CommonJSStrictFormatter);
 
 CommonJSFormatter.prototype.importSpecifier = function (specifier, node, nodes) {
   var variableName = t.getSpecifierName(specifier);
 
   // import foo from "foo";
-  if (specifier.default) {
-    specifier.id = t.identifier("default");
+  if (t.isIdentifier(specifier.id) && specifier.id.name === "default") {
+    nodes.push(t.variableDeclaration("var", [
+      t.variableDeclarator(variableName,
+        t.callExpression(this.file.addDeclaration("interop-require"), [util.template("require", {
+          MODULE_NAME: node.source.raw
+        })])
+      )
+    ]));
+  } else {
+    CommonJSStrictFormatter.prototype.importSpecifier.apply(this, arguments);
   }
-
-  var templateName = "require-assign";
-
-  // import * as bar from "foo";
-  if (specifier.type !== "ImportBatchSpecifier") templateName += "-key";
-
-  nodes.push(util.template(templateName, {
-    //inherits: node.specifiers.length === 1 && node,
-
-    VARIABLE_NAME: variableName,
-    MODULE_NAME:   node.source.raw,
-    KEY:           specifier.id
-  }));
-};
-
-CommonJSFormatter.prototype._hoistExport = function (declar, assign) {
-  if (t.isFunctionDeclaration(declar)) {
-    assign._blockHoist = true;
-  }
-
-  return assign;
-};
-
-CommonJSFormatter.prototype._pushStatement = function (ref, nodes) {
-  if (t.isClass(ref) || t.isFunction(ref)) {
-    if (ref.id) {
-      nodes.push(t.toStatement(ref));
-      ref = ref.id;
-    }
-  }
-  return ref;
 };
 
 CommonJSFormatter.prototype.export = function (node, nodes) {
-  var declar = node.declaration;
-
   if (node.default) {
-    nodes.push(util.template("exports-default", {
-      //inherits: node,
+    var declar = node.declaration;
 
+    // module.exports = VALUE;
+    var templateName = "exports-default-module";
+
+    // exports = module.exports = VALUE;
+    if (this.hasNonDefaultExports) templateName = "exports-default-module-override"
+
+    var assign = util.template(templateName, {
       VALUE: this._pushStatement(declar, nodes)
-    }, true));
+    }, true);
+
+    // hoist to the top if this default is a function
+    nodes.push(this._hoistExport(declar, assign));
   } else {
-    var assign;
-
-    if (t.isVariableDeclaration(declar)) {
-      var decl = declar.declarations[0];
-
-      decl.init = util.template("exports-assign", {
-        //inherits: node,
-
-        VALUE: decl.init,
-        KEY:   decl.id
-      });
-
-      nodes.push(declar);
-    } else {
-      assign = util.template("exports-assign", {
-        //inherits: node,
-
-        VALUE: declar.id,
-        KEY:   declar.id
-      }, true);
-
-      nodes.push(t.toStatement(declar));
-      nodes.push(assign);
-
-      this._hoistExport(declar, assign);
-    }
+    CommonJSStrictFormatter.prototype.export.apply(this, arguments);
   }
 };
 
-CommonJSFormatter.prototype._exportSpecifier = function (getRef, specifier, node, nodes) {
-  var variableName = t.getSpecifierName(specifier);
-
-  var inherits = false;
-  if (node.specifiers.length === 1) inherits = node;
-
-  if (node.source) {
-    if (t.isExportBatchSpecifier(specifier)) {
-      // export * from "foo";
-      nodes.push(util.template("exports-wildcard", {
-        //inherits: inherits,
-
-        OBJECT: getRef()
-      }, true));
-    } else {
-      // export { foo } from "test";
-      nodes.push(util.template("exports-assign-key", {
-        //inherits: inherits,
-
-        VARIABLE_NAME: variableName.name,
-        OBJECT:        getRef(),
-        KEY:           specifier.id
-      }, true));
-    }
-  } else {
-    // export { foo };
-    nodes.push(util.template("exports-assign", {
-      //inherits: inherits,
-
-      VALUE: specifier.id,
-      KEY:   variableName
-    }, true));
-  }
-};
-
-CommonJSFormatter.prototype.exportSpecifier = function (specifier, node, nodes) {
-  this._exportSpecifier(function () {
-    return t.callExpression(t.identifier("require"), [node.source]);
-  }, specifier, node, nodes);
+CommonJSFormatter.prototype.exportSpecifier = function () {
+  CommonJSStrictFormatter.prototype.exportSpecifier.apply(this, arguments);
 };