Add [WebIDL2JSFactory] for producing an interface factory function

This will allow per-Window interfaces to be generated, which is important for certain cases in jsdom.

Author: TimothyGu

lib/constructs/interface.js

@@ -14,12 +14,13 @@ const keywords = require("../keywords");
 function Interface(idl, opts) {
   this.idl = idl;
   this.name = idl.name;
+  this.factory = !!utils.getExtAttr(this.idl.extAttrs, "WebIDL2JSFactory");
 
   this.mixins = [];
   this.requires = {};
   this.str = null;
   this.opts = opts;
-  this.iterable = false;
+  this.iterable = this.idl.members.some(member => member.type === "iterable");
 }
 
 Interface.prototype.type = "interface";
@@ -28,6 +29,55 @@ Interface.prototype.implements = function (source) {
   this.mixins.push(source);
 };
 
+Interface.prototype.generateIterator = function () {
+  if (this.iterable) {
+    this.str += `
+const IteratorPrototype = Object.create(utils.IteratorPrototype, {
+  next: {
+    value: function next() {
+      const internal = this[utils.iterInternalSymbol];
+      const target = internal.target;
+      const kind = internal.kind;
+      const index = internal.index;
+      const values = Array.from(target[impl]);
+      const len = values.length;
+      if (index >= len) {
+        return { value: undefined, done: true };
+      }
+
+      const pair = values[index];
+      internal.index = index + 1;
+
+      let result;
+      switch (kind) {
+        case "key":
+          result = pair[0];
+          break;
+        case "value":
+          result = pair[1];
+          break;
+        case "key+value":
+          result = [pair[0], pair[1]];
+          break;
+      }
+      return { value: result, done: false };
+    },
+    writable: true,
+    enumerable: true,
+    configurable: true
+  },
+  toString: {
+    value: function toString() {
+      return "[object ${this.name}Iterator]";
+    },
+    writable: true,
+    enumerable: false,
+    configurable: true
+  }
+});`;
+  }
+};
+
 Interface.prototype.generateConstructor = function () {
   const overloads = Overloads.getEffectiveOverloads("constructor", 0, this.idl, null);
 
@@ -58,7 +108,7 @@ Interface.prototype.generateConstructor = function () {
     this.str += conversions.body + "\n";
 
     this.str += `
-  module.exports.setup(this, args);
+  iface.setup(this, args);
 }\n`;
   } else {
     this.str += `function ${this.name}() {
@@ -105,6 +155,52 @@ ${this.mixins[i]}.mixedInto.push(${this.name});\n`;
 };
 
 Interface.prototype.generateExport = function () {
+  this.str += `
+  mixedInto: [],
+  is(obj) {
+    if (obj) {
+      if (obj[impl] instanceof Impl.implementation) {
+        return true;
+      }
+      for (let i = 0; i < module.exports.mixedInto.length; ++i) {
+        if (obj instanceof module.exports.mixedInto[i]) {
+          return true;
+        }
+      }
+    }
+    return false;
+  },
+  isImpl(obj) {
+    if (obj) {
+      if (obj instanceof Impl.implementation) {
+        return true;
+      }
+
+      const wrapper = utils.wrapperForImpl(obj);
+      for (let i = 0; i < module.exports.mixedInto.length; ++i) {
+        if (wrapper instanceof module.exports.mixedInto[i]) {
+          return true;
+        }
+      }
+    }
+    return false;
+  },`;
+
+  if (this.iterable) {
+    this.str += `
+  createDefaultIterator(target, kind) {
+    const iterator = Object.create(IteratorPrototype);
+    iterator[utils.iterInternalSymbol] = {
+      target,
+      kind,
+      index: 0
+    };
+    return iterator;
+  },`;
+  }
+};
+
+Interface.prototype.generateIface = function () {
   const shouldExposeRoot = !utils.getExtAttr(this.idl.extAttrs, "NoInterfaceObject");
 
   const exposedMap = {};
@@ -132,84 +228,9 @@ Interface.prototype.generateExport = function () {
     exposers.push(keys[i] + ": { " + exposedOnObj.join(", ") + " }");
   }
 
-  if (this.iterable) {
-    this.str += `\nconst IteratorPrototype = Object.create(utils.IteratorPrototype, {
-  next: {
-    value: function next() {
-      const internal = this[utils.iterInternalSymbol];
-      const target = internal.target;
-      const kind = internal.kind;
-      const index = internal.index;
-      const values = Array.from(target[impl]);
-      const len = values.length;
-      if (index >= len) {
-        return { value: undefined, done: true };
-      }
-
-      const pair = values[index];
-      internal.index = index + 1;
-
-      let result;
-      switch (kind) {
-        case "key":
-          result = pair[0];
-          break;
-        case "value":
-          result = pair[1];
-          break;
-        case "key+value":
-          result = [pair[0], pair[1]];
-          break;
-      }
-      return { value: result, done: false };
-    },
-    writable: true,
-    enumerable: true,
-    configurable: true
-  },
-  toString: {
-    value: function toString() {
-      return "[object ${this.name}Iterator]";
-    },
-    writable: true,
-    enumerable: false,
-    configurable: true
-  }
-});`;
-  }
-
   // since we don't have spread arg calls, we can't do new Interface(...arguments) yet
   // add initialized symbol as to not destroy the object shape and cause deopts
-  this.str += `\nmodule.exports = {
-  mixedInto: [],
-  is(obj) {
-    if (obj) {
-      if (obj[impl] instanceof Impl.implementation) {
-        return true;
-      }
-      for (let i = 0; i < module.exports.mixedInto.length; ++i) {
-        if (obj instanceof module.exports.mixedInto[i]) {
-          return true;
-        }
-      }
-    }
-    return false;
-  },
-  isImpl(obj) {
-    if (obj) {
-      if (obj instanceof Impl.implementation) {
-        return true;
-      }
-
-      const wrapper = utils.wrapperForImpl(obj);
-      for (let i = 0; i < module.exports.mixedInto.length; ++i) {
-        if (wrapper instanceof module.exports.mixedInto[i]) {
-          return true;
-        }
-      }
-    }
-    return false;
-  },
+  this.str += `
   create(constructorArgs, privateData) {
     let obj = Object.create(${this.name}.prototype);
     this.setup(obj, constructorArgs, privateData);
@@ -220,15 +241,6 @@ Interface.prototype.generateExport = function () {
     this.setup(obj, constructorArgs, privateData);
     return utils.implForWrapper(obj);
   },
-  createDefaultIterator(target, kind) {
-    const iterator = Object.create(IteratorPrototype);
-    iterator[utils.iterInternalSymbol] = {
-      target,
-      kind,
-      index: 0
-    };
-    return iterator;
-  },
   _internalSetup(obj) {`;
 
     if (this.idl.inheritance) {
@@ -255,7 +267,18 @@ Interface.prototype.generateExport = function () {
   this.str += `
   },
   setup(obj, constructorArgs, privateData) {
-    if (!privateData) privateData = {};
+    if (!privateData) privateData = {};`;
+
+  if (this.factory) {
+    this.str += `
+    for (var prop in defaultPrivateData) {
+      if (!(prop in privateData)) {
+        privateData[prop] = defaultPrivateData[prop];
+      }
+    }`;
+  }
+
+  this.str += `
     privateData.wrapper = obj;
 
     this._internalSetup(obj);\n`;
@@ -273,8 +296,7 @@ Interface.prototype.generateExport = function () {
   interface: ${this.name},
   expose: {
     ${exposers.join(",\n    ")}
-  }
-};\n\n`;
+  }`;
 };
 
 Interface.prototype.generateOperations = function () {
@@ -292,7 +314,6 @@ Interface.prototype.generateOperations = function () {
         done[member.name] = true;
         break;
       case "iterable":
-        this.iterable = true;
         member = new Iterable(this, this.idl, memberIdl, { customTypes: this.opts.customTypes });
         break;
       default:
@@ -375,6 +396,16 @@ ${this.name}.prototype[Symbol.unscopables] = ${JSON.stringify(unscopables, null,
 };
 
 Interface.prototype.generate = function () {
+  this.generateIterator();
+
+  if (this.factory) {
+    // TODO: use default function parameters when jsdom requires Node >=6
+    this.str += `
+module.exports = {
+  createInterface: function (defaultPrivateData) {
+    defaultPrivateData = defaultPrivateData === undefined ? {} : defaultPrivateData;\n\n`;
+  }
+
   this.generateConstructor();
   this.generateMixins();
 
@@ -386,7 +417,25 @@ Interface.prototype.generate = function () {
 
   this.generateSymbols();
 
-  this.generateExport();
+  this.str += `
+const iface = {`;
+
+  if (this.factory) {
+    this.generateIface();
+    this.str += `
+};
+return iface;
+  },`;
+    this.generateExport();
+    this.str += `
+};\n`;
+  } else {
+    this.generateExport();
+    this.generateIface();
+    this.str += `
+};
+module.exports = iface;\n`;
+  }
 };
 
 Interface.prototype.toString = function () {