refactor(interface): Use default export for implementation

README.md

@@ -15,20 +15,33 @@ interface SomeInterface {
 combined with the JavaScript implementation class file
 
 ```js
-exports.implementation = class SomeInterfaceImpl {
+module.exports = class SomeInterfaceImpl {
   add(x, y) {
     return x + y;
   }
 };
 ```
 
+> Note: It's also possible to use ES2015 module default export syntax:
+>
+> ```js
+> export default class SomeInterfaceImpl {
+>   add(x, y) {
+>     return x + y;
+>   }
+> };
+> ```
+
 will generate a JavaScript wrapper class file roughly like this:
 
 ```js
 const conversions = require("webidl-conversions");
-const impl = require("./utils.js").implSymbol;
+const utils = require("./utils.js");
+const impl = utils.implSymbol;
 
-const Impl = require("./SomeInterface-impl.js").implementation;
+// utils.importStar is roughly equivalent to Babel's _interopRequireWildcard()
+// and TypeScript's __importStar() functions.
+const Impl = utils.importStar(require("./SomeInterface-impl.js")).default;
 
 class SomeInterface {
   constructor() {

lib/constructs/attribute.js

@@ -44,8 +44,8 @@ class Attribute {
 
     if (this.static) {
       brandCheck = "";
-      getterBody = `return Impl.implementation["${this.idl.name}"];`;
-      setterBody = `Impl.implementation["${this.idl.name}"] = V;`;
+      getterBody = `return Impl.default["${this.idl.name}"];`;
+      setterBody = `Impl.default["${this.idl.name}"] = V;`;
     } else if (shouldReflect) {
       if (!reflector[this.idl.idlType.idlType]) {
         throw new Error("Unknown reflector type: " + this.idl.idlType.idlType);

lib/constructs/interface.js

@@ -528,7 +528,7 @@ class Interface {
       _mixedIntoPredicates: [],
       is(obj) {
         if (obj) {
-          if (utils.hasOwn(obj, impl) && obj[impl] instanceof Impl.implementation) {
+          if (utils.hasOwn(obj, impl) && obj[impl] instanceof Impl.default) {
             return true;
           }
           for (const isMixedInto of module.exports._mixedIntoPredicates) {
@@ -541,7 +541,7 @@ class Interface {
       },
       isImpl(obj) {
         if (obj) {
-          if (obj instanceof Impl.implementation) {
+          if (obj instanceof Impl.default) {
             return true;
           }
 
@@ -1162,7 +1162,7 @@ class Interface {
 
         this._internalSetup(obj);
         Object.defineProperty(obj, impl, {
-          value: new Impl.implementation(constructorArgs, privateData),
+          value: new Impl.default(constructorArgs, privateData),
           configurable: true
         });
     `;

lib/constructs/operation.js

@@ -67,7 +67,7 @@ class Operation {
       `;
     }
 
-    const callOn = this.static ? "Impl.implementation" : "this[impl]";
+    const callOn = this.static ? "Impl.default" : "this[impl]";
     // In case of stringifiers, use the named implementation function rather than hardcoded "toString".
     // All overloads will have the same name, so pick the first one.
     const implFunc = this.idls[0].name || this.name;

lib/output/utils.js

@@ -74,6 +74,52 @@ const namedSetNew = Symbol("named property set new");
 const namedSetExisting = Symbol("named property set existing");
 const namedDelete = Symbol("named property delete");
 
+/**
+ * Used to cache importStar results.
+ */
+const importStarCache = new WeakMap();
+
+/**
+ * Mostly copied from TypeScript and Babel.
+ *
+ * @template T
+ * @param {T} obj
+ * @return {T extends { default: any }
+ * ? T : T extends string | number | bigint | boolean | symbol | null | undefined
+ * ? { default: T } : { default: T } & { [K in keyof T]: T[K] }}
+ */
+function importStar(obj) {
+  if (obj && obj.__esModule) {
+    return obj;
+  }
+
+  if (obj === null || (typeof obj !== "object" && typeof obj !== "function")) {
+    return { default: obj };
+  }
+
+  if (importStarCache.has(obj)) {
+    return importStarCache.get(obj);
+  }
+
+  const newObj = {};
+
+  for (const key in obj) {
+    if (hasOwn(obj, key) && key !== "default") {
+      Object.defineProperty(
+        newObj,
+        key,
+        Object.getOwnPropertyDescriptor(obj, key)
+      );
+    }
+  }
+
+  newObj.default = obj;
+
+  importStarCache.set(obj, newObj);
+
+  return newObj;
+}
+
 module.exports = exports = {
   isObject,
   hasOwn,
@@ -97,5 +143,6 @@ module.exports = exports = {
   namedGet,
   namedSetNew,
   namedSetExisting,
-  namedDelete
+  namedDelete,
+  importStar
 };

lib/transformer.js

@@ -212,7 +212,7 @@ class Transformer {
         const conversions = require("webidl-conversions");
         const utils = require("${relativeUtils}");
         ${source}
-        const Impl = require("${implFile}.js");
+        const Impl = utils.importStar(require("${implFile}.js"));
       `;
 
       source = this._prettify(source);