Adds support for setlike and maplike declarations + handles nullable types

dist/convert-idl.js

@@ -1,10 +1,8 @@
 "use strict";
-var __spreadArrays = (this && this.__spreadArrays) || function () {
-    for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length;
-    for (var r = Array(s), k = 0, i = 0; i < il; i++)
-        for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)
-            r[k] = a[j];
-    return r;
+var __spreadArray = (this && this.__spreadArray) || function (to, from) {
+    for (var i = 0, il = from.length, j = to.length; i < il; i++, j++)
+        to[j] = from[i];
+    return to;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.convertIDL = void 0;
@@ -27,7 +25,7 @@ var integerTypes = ['byte', 'octet', 'short', 'unsigned short', 'long', 'unsigne
 var stringTypes = ['ByteString', 'DOMString', 'USVString', 'CSSOMString'];
 var floatTypes = ['float', 'unrestricted float', 'double', 'unrestricted double'];
 var sameTypes = ['any', 'boolean', 'Date', 'Function', 'Promise', 'void'];
-var baseTypeConversionMap = new Map(__spreadArrays(__spreadArrays(bufferSourceTypes).map(function (type) { return [type, type]; }), __spreadArrays(integerTypes).map(function (type) { return [type, 'number']; }), __spreadArrays(floatTypes).map(function (type) { return [type, 'number']; }), __spreadArrays(stringTypes).map(function (type) { return [type, 'string']; }), __spreadArrays(sameTypes).map(function (type) { return [type, type]; }), [
+var baseTypeConversionMap = new Map(__spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray([], __spreadArray([], bufferSourceTypes).map(function (type) { return [type, type]; })), __spreadArray([], integerTypes).map(function (type) { return [type, 'number']; })), __spreadArray([], floatTypes).map(function (type) { return [type, 'number']; })), __spreadArray([], stringTypes).map(function (type) { return [type, 'string']; })), __spreadArray([], sameTypes).map(function (type) { return [type, type]; })), [
     ['object', 'any'],
     ['sequence', 'Array'],
     ['record', 'Record'],
@@ -136,11 +134,20 @@ function convertInterface(idl, options) {
                 }
                 break;
             }
+            case 'setlike':
+                inheritance.push(ts.createExpressionWithTypeArguments([convertType(member.idlType[0])], ts.createIdentifier(member.readonly ? 'ReadonlySet' : 'Set')));
+                break;
+            case 'maplike':
+                inheritance.push(ts.createExpressionWithTypeArguments([convertType(member.idlType[0]), convertType(member.idlType[1])], ts.createIdentifier(member.readonly ? 'ReadonlyMap' : 'Map')));
+                break;
             default:
                 console.log(newUnsupportedError('Unsupported IDL member', member));
                 break;
         }
     });
+    if (inheritance.length === 1 && !members.length) {
+        return ts.createTypeAliasDeclaration(undefined, undefined, ts.createIdentifier(idl.name), undefined, inheritance[0]);
+    }
     if (options === null || options === void 0 ? void 0 : options.emscripten) {
         return ts.createClassDeclaration(undefined, [], ts.createIdentifier(idl.name), undefined, !inheritance.length ? undefined : [ts.createHeritageClause(ts.SyntaxKind.ExtendsKeyword, inheritance)], members);
     }
@@ -185,23 +192,29 @@ function convertArgument(idl) {
     var optional = idl.optional ? ts.createToken(ts.SyntaxKind.QuestionToken) : undefined;
     return ts.createParameter([], [], undefined, idl.name, optional, convertType(idl.idlType));
 }
+function makeFinalType(type, idl) {
+    if (idl.nullable) {
+        return ts.factory.createUnionTypeNode([type, ts.factory.createNull()]);
+    }
+    return type;
+}
 function convertType(idl) {
     if (typeof idl.idlType === 'string') {
         var type = baseTypeConversionMap.get(idl.idlType) || idl.idlType;
         switch (type) {
             case 'number':
-                return ts.createKeywordTypeNode(ts.SyntaxKind.NumberKeyword);
+                return makeFinalType(ts.createKeywordTypeNode(ts.SyntaxKind.NumberKeyword), idl);
             case 'string':
-                return ts.createKeywordTypeNode(ts.SyntaxKind.StringKeyword);
+                return makeFinalType(ts.createKeywordTypeNode(ts.SyntaxKind.StringKeyword), idl);
             case 'void':
                 return ts.createKeywordTypeNode(ts.SyntaxKind.VoidKeyword);
             default:
-                return ts.createTypeReferenceNode(type, []);
+                return makeFinalType(ts.createTypeReferenceNode(type, []), idl);
         }
     }
     if (idl.generic) {
         var type = baseTypeConversionMap.get(idl.generic) || idl.generic;
-        return ts.createTypeReferenceNode(ts.createIdentifier(type), idl.idlType.map(convertType));
+        return makeFinalType(ts.createTypeReferenceNode(ts.createIdentifier(type), idl.idlType.map(convertType)), idl);
     }
     if (idl.union) {
         return ts.createUnionTypeNode(idl.idlType.map(convertType));

dist/fetch-idl.js

@@ -44,7 +44,7 @@ var idlSelector = [
     'pre.idl:not(.extract):not(.example)',
     'pre.code code.idl-code',
     'pre:not(.extract) code.idl',
-    '#permission-registry + pre.highlight',
+    '#permission-registry + pre.highlight', // Permissions
 ].join(',');
 function fetchIDL(uri) {
     return __awaiter(this, void 0, void 0, function () {

dist/print-ts.js

@@ -1,10 +1,8 @@
 "use strict";
-var __spreadArrays = (this && this.__spreadArrays) || function () {
-    for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length;
-    for (var r = Array(s), k = 0, i = 0; i < il; i++)
-        for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)
-            r[k] = a[j];
-    return r;
+var __spreadArray = (this && this.__spreadArray) || function (to, from) {
+    for (var i = 0, il = from.length, j = to.length; i < il; i++, j++)
+        to[j] = from[i];
+    return to;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.printEmscriptenModule = exports.printTs = void 0;
@@ -49,7 +47,7 @@ function printEmscriptenModule(moduleName, nodes, defaultExport) {
     /* decorators */ [], 
     /* modifiers  */ [ts.createModifier(ts.SyntaxKind.DeclareKeyword)], 
     /* name       */ ts.createIdentifier(moduleName), 
-    /* body       */ ts.createModuleBlock(__spreadArrays(emscriptenAdditions(), nodes))));
+    /* body       */ ts.createModuleBlock(__spreadArray(__spreadArray([], emscriptenAdditions()), nodes))));
     return printTs(result);
 }
 exports.printEmscriptenModule = printEmscriptenModule;

package.json

@@ -23,20 +23,20 @@
     "LICENSE.md"
   ],
   "devDependencies": {
-    "@types/node": "^14.14.6",
+    "@types/node": "^14.14.31",
     "@types/webidl2": "^23.13.5",
-    "@types/yargs": "^15.0.9",
-    "@typescript-eslint/eslint-plugin": "^4.6.1",
-    "@typescript-eslint/parser": "^4.6.1",
-    "eslint": "^7.12.1",
-    "prettier": "^2.1.2",
-    "ts-node": "^9.0.0"
+    "@types/yargs": "^16.0.0",
+    "@typescript-eslint/eslint-plugin": "^4.15.2",
+    "@typescript-eslint/parser": "^4.15.2",
+    "eslint": "^7.21.0",
+    "prettier": "^2.2.1",
+    "ts-node": "^9.1.1"
   },
   "dependencies": {
     "jsdom": "^16.4.0",
-    "typescript": "^4.0.5",
-    "webidl2": "^23.13.0",
-    "yargs": "^16.1.0"
+    "typescript": "^4.2.2",
+    "webidl2": "^23.13.1",
+    "yargs": "^16.2.0"
   },
   "bin": {
     "webidl2ts": "./dist/cli.js"

src/convert-idl.ts

@@ -210,12 +210,32 @@ function convertInterface(idl: webidl2.InterfaceType | webidl2.DictionaryType |
         }
         break
       }
+      case 'setlike':
+        inheritance.push(
+          ts.createExpressionWithTypeArguments(
+            [convertType(member.idlType[0])],
+            ts.createIdentifier(member.readonly ? 'ReadonlySet' : 'Set'),
+          ),
+        )
+        break
+      case 'maplike':
+        inheritance.push(
+          ts.createExpressionWithTypeArguments(
+            [convertType(member.idlType[0]), convertType(member.idlType[1])],
+            ts.createIdentifier(member.readonly ? 'ReadonlyMap' : 'Map'),
+          ),
+        )
+        break
       default:
         console.log(newUnsupportedError('Unsupported IDL member', member))
         break
     }
   })
 
+  if (inheritance.length === 1 && !members.length) {
+    return ts.createTypeAliasDeclaration(undefined, undefined, ts.createIdentifier(idl.name), undefined, inheritance[0])
+  }
+
   if (options?.emscripten) {
     return ts.createClassDeclaration(
       undefined,
@@ -303,24 +323,29 @@ function convertArgument(idl: webidl2.Argument) {
   const optional = idl.optional ? ts.createToken(ts.SyntaxKind.QuestionToken) : undefined
   return ts.createParameter([], [], undefined, idl.name, optional, convertType(idl.idlType))
 }
-
+function makeFinalType(type: ts.TypeNode, idl: webidl2.IDLTypeDescription): ts.TypeNode {
+  if (idl.nullable) {
+    return ts.factory.createUnionTypeNode([type, ts.factory.createNull() as unknown as ts.TypeNode])
+  }
+  return type
+}
 function convertType(idl: webidl2.IDLTypeDescription): ts.TypeNode {
   if (typeof idl.idlType === 'string') {
     const type = baseTypeConversionMap.get(idl.idlType) || idl.idlType
     switch (type) {
       case 'number':
-        return ts.createKeywordTypeNode(ts.SyntaxKind.NumberKeyword)
+        return makeFinalType(ts.createKeywordTypeNode(ts.SyntaxKind.NumberKeyword), idl)
       case 'string':
-        return ts.createKeywordTypeNode(ts.SyntaxKind.StringKeyword)
+        return makeFinalType(ts.createKeywordTypeNode(ts.SyntaxKind.StringKeyword), idl)
       case 'void':
         return ts.createKeywordTypeNode(ts.SyntaxKind.VoidKeyword)
       default:
-        return ts.createTypeReferenceNode(type, [])
+        return makeFinalType(ts.createTypeReferenceNode(type, []), idl)
     }
   }
   if (idl.generic) {
     const type = baseTypeConversionMap.get(idl.generic) || idl.generic
-    return ts.createTypeReferenceNode(ts.createIdentifier(type), idl.idlType.map(convertType))
+    return makeFinalType(ts.createTypeReferenceNode(ts.createIdentifier(type), idl.idlType.map(convertType)), idl)
   }
   if (idl.union) {
     return ts.createUnionTypeNode(idl.idlType.map(convertType))