@runtime-type-inspector/transpiler 3.3.7 → 4.0.1

package/index.cjs

@@ -320,11 +320,14 @@
 	 * This function handles various TypeScript AST node types and converts them into a string
 	 * or an object representing the type.
 	 *
-	 * @param {ts.TypeNode|ts.Identifier} node - The TypeScript AST node to convert.
+	 * @param {ts.TypeNode|ts.Identifier|ts.QualifiedName|undefined} node - The TypeScript AST node to convert.
 	 * @returns {string | number | boolean | {type: string, [key: string]: any} | undefined} The source string/number,
 	 * or an object with type information based on the node, or `undefined` if the node kind is not handled.
 	 */
 	function toSourceTS(node) {
+	  if (!node) {
+	    return 'undefined';
+	  }
 	  var typeArguments = node.typeArguments,
 	    typeName = node.typeName;
 	  var kind_ = ts.SyntaxKind[node.kind];
@@ -333,6 +336,7 @@
 	    ArrayType = _ts$SyntaxKind.ArrayType,
 	    BooleanKeyword = _ts$SyntaxKind.BooleanKeyword,
 	    FunctionType = _ts$SyntaxKind.FunctionType,
+	    JSDocFunctionType = _ts$SyntaxKind.JSDocFunctionType,
 	    Identifier = _ts$SyntaxKind.Identifier,
 	    IntersectionType = _ts$SyntaxKind.IntersectionType,
 	    JSDocAllType = _ts$SyntaxKind.JSDocAllType,
@@ -371,7 +375,8 @@
 	    ConstructorType = _ts$SyntaxKind.ConstructorType,
 	    NamedTupleMember = _ts$SyntaxKind.NamedTupleMember,
 	    MappedType = _ts$SyntaxKind.MappedType,
-	    TypeParameter = _ts$SyntaxKind.TypeParameter;
+	    TypeParameter = _ts$SyntaxKind.TypeParameter,
+	    QualifiedName = _ts$SyntaxKind.QualifiedName;
 	  // console.log({typeArguments, typeName, kind_, node});
 	  switch (node.kind) {
 	    case BigIntKeyword:
@@ -410,23 +415,36 @@
 	        if (!ts.isConstructorTypeNode(node)) {
 	          throw Error("Impossible");
 	        }
-	        var _parameters = node.parameters.map(toSourceTS);
+	        var parameters = node.parameters.map(toSourceTS);
 	        var _ret = toSourceTS(node.type);
 	        return {
 	          type: 'new',
-	          parameters: _parameters,
+	          parameters: parameters,
 	          ret: _ret
 	        };
 	      }
 	    case FunctionType:
-	      if (!ts.isFunctionTypeNode(node)) {
-	        throw Error("Impossible");
+	      {
+	        if (!ts.isFunctionTypeNode(node)) {
+	          throw Error("Impossible");
+	        }
+	        var _parameters = node.parameters.map(toSourceTS);
+	        return {
+	          type: 'function',
+	          parameters: _parameters
+	        };
+	      }
+	    case JSDocFunctionType:
+	      {
+	        if (!ts.isJSDocFunctionType(node)) {
+	          throw Error("Impossible");
+	        }
+	        var _parameters2 = node.parameters.map(toSourceTS);
+	        return {
+	          type: 'function',
+	          parameters: _parameters2
+	        };
 	      }
-	      var parameters = node.parameters.map(toSourceTS);
-	      return {
-	        type: 'function',
-	        parameters: parameters
-	      };
 	    case IndexedAccessType:
 	      if (!ts.isIndexedAccessTypeNode(node)) {
 	        throw Error("Impossible");
@@ -721,6 +739,14 @@
 	      }
 	      // fall-through for parentheses
 	      return toSourceTS(node.type);
+	    // toSourceTS(parseType("import('abc').x.y.z"))
+	    case QualifiedName:
+	      if (!ts.isQualifiedName(node)) {
+	        throw Error("Impossible");
+	      }
+	      var l = toSourceTS(node.left);
+	      var r = toSourceTS(node.right);
+	      return "".concat(l, ".").concat(r);
 	    case ImportType:
 	      if (!ts.isImportTypeNode(node)) {
 	        throw Error("Impossible");
@@ -1235,6 +1261,16 @@
 	  stat.unchecked = 0;
 	}
 
+	/**
+	 * @example
+	 * capitalize("hello"); // Outputs: Hello
+	 * @param {string} _ - The input string.
+	 * @returns {string} The capitalized output string.
+	 */
+	function capitalize(_) {
+	  return _[0].toUpperCase() + _.slice(1);
+	}
+
 	/**
 	 * @example
 	 * trimEndSpaces('test   \n   '); // Returns: 'test   \n'
@@ -1263,8 +1299,13 @@
 	    _defineProperty(this, "forceCurly", false);
 	    /** @type {Node[]} */
 	    _defineProperty(this, "parents", []);
+	    /**
+	     * If we encounter JSX elements, we add React's createElement as import.
+	     */
+	    _defineProperty(this, "addReactImport", false);
 	    _defineProperty(this, "lastCommentBlockIndex", -1);
 	    _defineProperty(this, "lastCommentLineIndex", -1);
+	    _defineProperty(this, "encounteredFragment", false);
 	    _defineProperty(this, "numSpaces", 0);
 	  }
 	  _createClass(Stringifier, [{
@@ -1519,6 +1560,21 @@
 	      }
 	      return out;
 	    }
+	  }, {
+	    key: "getHeader",
+	    value:
+	    /**
+	     * @returns {string} The header.
+	     */
+	    function getHeader() {
+	      if (!this.addReactImport) {
+	        return '';
+	      }
+	      if (this.encounteredFragment) {
+	        return "import {createElement, Fragment} from 'react';\n";
+	      }
+	      return "import {createElement} from 'react';\n";
+	    }
 	  }, {
 	    key: "parent",
 	    get: function get() {
@@ -1901,7 +1957,10 @@
 	        out += ' * ';
 	      }
 	      out += this.FunctionDeclarationParams(params);
-	      out += ' => ';
+	      out += ' =>';
+	      if (body.type !== 'BlockStatement') {
+	        out += ' ';
+	      }
 	      out += this.toSource(body);
 	      return out;
 	    }
@@ -2535,6 +2594,219 @@
 	      // createMesh: createMesh$1\n
 	      return "".concat(spaces).concat(right, " as ").concat(left);
 	    }
+	    /**
+	     * @param {import("@babel/types").JSXAttribute} node - The Babel AST node.
+	     * @returns {string} Stringification of the node.
+	     */
+	  }, {
+	    key: "JSXAttribute",
+	    value: function JSXAttribute(node) {
+	      var name = node.name,
+	        value = node.value;
+	      // console.log("JSXAttribute", {name, value});
+	      var keySource = this.toSource(name);
+	      // E.g. <audio controls/>
+	      if (value === null) {
+	        return "".concat(this.spaces).concat(keySource, ": true");
+	      }
+	      var valSource = this.toSource(value);
+	      if (keySource === valSource) {
+	        return this.spaces + keySource;
+	      }
+	      return "".concat(this.spaces).concat(keySource, ": ").concat(valSource);
+	    }
+	    /**
+	     * @param {import("@babel/types").JSXElement} node - The Babel AST node.
+	     * @returns {string} Stringification of the node.
+	     */
+	  }, {
+	    key: "JSXElement",
+	    value: function JSXElement(node) {
+	      var _this4 = this;
+	      this.addReactImport = true;
+	      var openingElement = node.openingElement;
+	        node.closingElement;
+	        var children = node.children;
+	      // console.log("JSXElement", {openingElement, closingElement, children});
+	      if (openingElement.type !== 'JSXOpeningElement') {
+	        debugger;
+	      }
+	      var spaces = this.spaces;
+	      var name = openingElement.name,
+	        attributes = openingElement.attributes;
+	      var out = '';
+	      out += 'createElement(';
+	      this.numSpaces++;
+	      spaces = this.spaces;
+	      out += '\n';
+	      out += spaces;
+	      var sourceName = this.toSource(name);
+	      if (sourceName[0] === sourceName[0].toLowerCase()) {
+	        // If something like 'div', it has to become "'div'"
+	        sourceName = JSON.stringify(sourceName);
+	      }
+	      out += sourceName;
+	      out += ',';
+	      if (attributes.length) {
+	        out += '\n';
+	        out += spaces;
+	        out += '{\n';
+	        this.numSpaces++;
+	        out += attributes.map(function (attr) {
+	          return _this4.toSource(attr) + ',\n';
+	        }).join('');
+	        this.numSpaces--;
+	        out += spaces;
+	        out += '}';
+	      } else {
+	        out += '\n';
+	        out += spaces;
+	        out += 'null';
+	      }
+	      if (children.length) {
+	        out += ',\n';
+	        var _iterator2 = _createForOfIteratorHelper(children),
+	          _step2;
+	        try {
+	          for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+	            var child = _step2.value;
+	            var source = this.toSource(child);
+	            if (!source.length) {
+	              continue;
+	            }
+	            out += spaces;
+	            out += source;
+	            out += ',\n';
+	          }
+	        } catch (err) {
+	          _iterator2.e(err);
+	        } finally {
+	          _iterator2.f();
+	        }
+	      } else {
+	        out += '\n';
+	      }
+	      this.numSpaces--;
+	      out += this.spaces;
+	      out += ')';
+	      return out;
+	    }
+	    /**
+	     * @param {import("@babel/types").JSXFragment} node - The Babel AST node.
+	     * @returns {string} Stringification of the node.
+	     */
+	  }, {
+	    key: "JSXFragment",
+	    value: function JSXFragment(node) {
+	      var children = node.children;
+	      this.encounteredFragment = true;
+	      // console.log('JSXFragment', {openingFragment, closingFragment, children});
+	      var spaces = this.spaces;
+	      var out = 'createElement(\n';
+	      this.numSpaces++;
+	      spaces = this.spaces;
+	      out += spaces;
+	      out += 'Fragment,\n';
+	      out += spaces;
+	      out += 'null';
+	      // Same code for children as in JSXElement
+	      if (children.length) {
+	        out += ',\n';
+	        var _iterator3 = _createForOfIteratorHelper(children),
+	          _step3;
+	        try {
+	          for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
+	            var child = _step3.value;
+	            var source = this.toSource(child);
+	            if (!source.length) {
+	              continue;
+	            }
+	            out += spaces;
+	            out += source;
+	            out += ',\n';
+	          }
+	        } catch (err) {
+	          _iterator3.e(err);
+	        } finally {
+	          _iterator3.f();
+	        }
+	      } else {
+	        out += '\n';
+	      }
+	      this.numSpaces--;
+	      out += this.spaces;
+	      out += ')';
+	      return out;
+	    }
+	    /**
+	     * @param {import("@babel/types").JSXIdentifier} node - The Babel AST node.
+	     * @returns {string} Stringification of the node.
+	     */
+	  }, {
+	    key: "JSXIdentifier",
+	    value: function JSXIdentifier(node) {
+	      var name = node.name;
+	      // console.log('JSXIdentifier', {name});
+	      // https://github.com/kungfooman/RuntimeTypeInspector.js/issues/201
+	      // https://stackoverflow.com/questions/38998987/using-aria-attributes-on-elements-in-react
+	      if (name.includes('-')) {
+	        return JSON.stringify(name);
+	      }
+	      return name;
+	    }
+	    /**
+	     * @param {import("@babel/types").JSXNamespacedName} node - The Babel AST node.
+	     * @returns {string} Stringification of the node.
+	     */
+	  }, {
+	    key: "JSXNamespacedName",
+	    value: function JSXNamespacedName(node) {
+	      var namespace = node.namespace,
+	        name = node.name;
+	      var a = this.toSource(namespace);
+	      var b = capitalize(this.toSource(name));
+	      return a + b;
+	    }
+	    /**
+	     * @param {import("@babel/types").JSXExpressionContainer} node - The Babel AST node.
+	     * @returns {string} Stringification of the node.
+	     */
+	  }, {
+	    key: "JSXExpressionContainer",
+	    value: function JSXExpressionContainer(node) {
+	      var expression = node.expression;
+	      // console.log('JSXExpressionContainer', {expression});
+	      return this.toSource(expression);
+	    }
+	    /**
+	     * @param {import("@babel/types").JSXMemberExpression} node - The Babel AST node.
+	     * @returns {string} Stringification of the node.
+	     */
+	  }, {
+	    key: "JSXMemberExpression",
+	    value: function JSXMemberExpression(node) {
+	      var object = node.object,
+	        property = node.property;
+	      // console.log('JSXMemberExpression', 'object', object, 'property', property);
+	      var o = this.toSource(object);
+	      var p = this.toSource(property);
+	      return "".concat(o, ".").concat(p);
+	    }
+	    /**
+	     * @param {import("@babel/types").JSXText} node - The Babel AST node.
+	     * @returns {string} Stringification of the node.
+	     */
+	  }, {
+	    key: "JSXText",
+	    value: function JSXText(node) {
+	      node.extra;
+	        var value = node.value;
+	      // console.log('JSXText', {extra, value});
+	      if (!value.trim().length) {
+	        return '';
+	      }
+	      return JSON.stringify(value);
+	    }
 	    /**
 	     * @param {import("@babel/types").Super} node - The Babel AST node.
 	     * @returns {string} Stringification of the node.
@@ -2927,6 +3199,22 @@
 	    value: function Import(node) {
 	      return 'import';
 	    }
+	    /**
+	     * @param {import("@babel/types").ImportExpression} node - The Babel AST node.
+	     * @returns {string} Stringification of the node.
+	     */
+	  }, {
+	    key: "ImportExpression",
+	    value: function ImportExpression(node) {
+	      var source = node.source,
+	        options = node.options;
+	      var out = "import(" + this.toSource(source);
+	      if (options) {
+	        out += ', ' + this.toSource(options);
+	      }
+	      out += ')';
+	      return out;
+	    }
 	    /**
 	     * @param {import("@babel/types").ImportDeclaration} node - The Babel AST node.
 	     * @returns {string} Stringification of the node.
@@ -2939,15 +3227,39 @@
 	      // ImportNamespaceSpecifier: import * as a   from "b";
 	      // ImportDefaultSpecifier  : import      a   from "b";
 	      // ImportSpecifier         : import {    a } from "b";
-	      var a = this.mapToSource(specifiers).join(', ');
-	      var b = this.toSource(source);
+	      var from = this.toSource(source);
 	      if (specifiers.length === 0) {
-	        return "import ".concat(b);
+	        return "import ".concat(from);
 	      }
-	      if (specifiers[0].type !== 'ImportSpecifier') {
-	        return "import ".concat(a, " from ").concat(b, ";");
+	      var out = 'import ';
+	      var n = specifiers.length;
+	      var inImportSpecifier = false;
+	      var i = 0;
+	      var _iterator4 = _createForOfIteratorHelper(specifiers),
+	        _step4;
+	      try {
+	        for (_iterator4.s(); !(_step4 = _iterator4.n()).done;) {
+	          var specifier = _step4.value;
+	          if (specifier.type === 'ImportSpecifier' && !inImportSpecifier) {
+	            out += "{";
+	            inImportSpecifier = true;
+	          }
+	          out += this.toSource(specifier);
+	          if (i !== n - 1) {
+	            out += ', ';
+	          }
+	          i++;
+	        }
+	      } catch (err) {
+	        _iterator4.e(err);
+	      } finally {
+	        _iterator4.f();
 	      }
-	      return "import {".concat(a, "} from ").concat(b, ";");
+	      if (inImportSpecifier) {
+	        out += '}';
+	      }
+	      out += " from ".concat(from, ";");
+	      return out;
 	    }
 	    /**
 	     * @param {import("@babel/types").ImportSpecifier} node - The Babel AST node.
@@ -3216,7 +3528,11 @@
 	      } else {
 	        out += ' {\n';
 	        out += this.generateTypeChecks(node);
+	        var spaces = this.spaces;
+	        this.numSpaces++;
 	        out += this.spaces + 'return ' + this.toSource(body) + ';\n';
+	        this.numSpaces--;
+	        out += spaces;
 	        out += '}';
 	      }
 	      return out;
@@ -3262,6 +3578,7 @@
 	     * @todo
 	     * Once we went over every node, we can see if we really require registerTypef, registerClass etc.
 	     * @returns {string} The import declaration header for importing RTI.
+	     * @override
 	     */
 	  }, {
 	    key: "getHeader",
@@ -3269,7 +3586,8 @@
 	      if (!this.addHeader) {
 	        return '';
 	      }
-	      var header = "import {inspectType, inspectTypeWithTemplates, youCanAddABreakpointHere, registerVariable";
+	      var header = _get(_getPrototypeOf(Asserter.prototype), "getHeader", this).call(this);
+	      header += "import {inspectType, inspectTypeWithTemplates, youCanAddABreakpointHere, registerVariable";
 	      if (this.validateDivision) {
 	        header += ", validateDivision";
 	      }
@@ -4001,6 +4319,17 @@
 	  return Asserter;
 	}(Stringifier);
 
+	/**
+	 * We use the same options in different places, so it's nice to keep them in sync without
+	 * changing them in multiple locations.
+	 * @type {import('@babel/parser').ParserOptions}
+	 */
+	var parserOptions = {
+	  sourceType: 'module',
+	  createParenthesizedExpressions: true,
+	  plugins: ['jsx']
+	};
+
 	/**
 	 * Simple facade which does all the processing. Processes the input
 	 * source string, adding runtime type checks based on JSDoc comments.
@@ -4020,11 +4349,10 @@
 	function addTypeChecks(src, options) {
 	  try {
 	    var asserter = new Asserter(options);
-	    var ast = parser.parse(src, {
-	      sourceType: 'module',
-	      createParenthesizedExpressions: true
-	    });
-	    var out = asserter.getHeader() + asserter.toSource(ast);
+	    var ast = parser.parse(src, parserOptions);
+	    // Must be called before getHeader since it's keeping an eye open for JSX elements.
+	    var source = asserter.toSource(ast);
+	    var out = asserter.getHeader() + source;
 	    return out;
 	  } catch (e) {
 	    console.error(e);
@@ -4072,15 +4400,13 @@
 	 * @returns {string | undefined} The new and once parsed and stringified code.
 	 */
 	function code2ast2code(code) {
-	  var stringifier = new Stringifier();
-	  var ast = parser.parse(code, {
-	    sourceType: 'module'
-	  });
+	  var ast = parser.parse(code, parserOptions);
 	  if (!ast) {
 	    return;
 	  }
+	  var stringifier = new Stringifier();
 	  var out = stringifier.toSource(ast);
-	  return out;
+	  return stringifier.getHeader() + out;
 	}
 
 	/**
@@ -4347,6 +4673,7 @@
 	exports.addTypeChecks = addTypeChecks;
 	exports.ast2json = ast2json;
 	exports.ast2jsonForComparison = ast2jsonForComparison;
+	exports.capitalize = capitalize;
 	exports.code2ast2code = code2ast2code;
 	exports.compareAST = compareAST;
 	exports.expandType = expandType;
@@ -4361,6 +4688,7 @@
 	exports.parseJSDocTypedef = parseJSDocTypedef;
 	exports.parseType = parseType;
 	exports.parseTypeBabelTS = parseTypeBabelTS;
+	exports.parserOptions = parserOptions;
 	exports.requiredTypeofs = requiredTypeofs;
 	exports.simplifyType = simplifyType;
 	exports.toSourceBabelTS = toSourceBabelTS;

package/index.mjs

@@ -63,11 +63,14 @@ const requiredTypeofs = {};
  * This function handles various TypeScript AST node types and converts them into a string
  * or an object representing the type.
  *
- * @param {ts.TypeNode|ts.Identifier} node - The TypeScript AST node to convert.
+ * @param {ts.TypeNode|ts.Identifier|ts.QualifiedName|undefined} node - The TypeScript AST node to convert.
  * @returns {string | number | boolean | {type: string, [key: string]: any} | undefined} The source string/number,
  * or an object with type information based on the node, or `undefined` if the node kind is not handled.
  */
 function toSourceTS(node) {
+  if (!node) {
+    return 'undefined';
+  }
   const {
     typeArguments,
     typeName
@@ -82,6 +85,8 @@ function toSourceTS(node) {
     // parseType("boolean"                        ).kind                 === ts.SyntaxKind.BooleanKeyword
     FunctionType,
     // parseType("() => void"                     ).kind                 === ts.SyntaxKind.FunctionType
+    JSDocFunctionType,
+    // parseType("function (number, number): number").kind               === ts.SyntaxKind.JSDocFunctionType
     Identifier,
     // parseType("{a: 1, b: 2}"                   ).members[0].name.kind === ts.SyntaxKind.Identifier
     IntersectionType,
@@ -158,7 +163,9 @@ function toSourceTS(node) {
     // parseType('[a: 1]'                         ).elements[0].kind     === ts.SyntaxKind.NamedTupleMember
     MappedType,
     // parseType('{[K in TaskType]: 123}'         ).kind                 === ts.SyntaxKind.MappedType
-    TypeParameter // parseType('{[K in TaskType]: 123}'         ).typeParameter.kind   ===  ts.SyntaxKind.TypeParameter
+    TypeParameter,
+    // parseType('{[K in TaskType]: 123}'         ).typeParameter.kind   ===  ts.SyntaxKind.TypeParameter
+    QualifiedName // parseType("import('abc').x.y"              ).qualifier.kind       === ts.SyntaxKind.QualifiedName
   } = ts.SyntaxKind;
   // console.log({typeArguments, typeName, kind_, node});
   switch (node.kind) {
@@ -198,23 +205,36 @@ function toSourceTS(node) {
         if (!ts.isConstructorTypeNode(node)) {
           throw Error("Impossible");
         }
-        const _parameters = node.parameters.map(toSourceTS);
+        const parameters = node.parameters.map(toSourceTS);
         const _ret = toSourceTS(node.type);
         return {
           type: 'new',
-          parameters: _parameters,
+          parameters,
           ret: _ret
         };
       }
     case FunctionType:
-      if (!ts.isFunctionTypeNode(node)) {
-        throw Error("Impossible");
+      {
+        if (!ts.isFunctionTypeNode(node)) {
+          throw Error("Impossible");
+        }
+        const parameters = node.parameters.map(toSourceTS);
+        return {
+          type: 'function',
+          parameters
+        };
+      }
+    case JSDocFunctionType:
+      {
+        if (!ts.isJSDocFunctionType(node)) {
+          throw Error("Impossible");
+        }
+        const parameters = node.parameters.map(toSourceTS);
+        return {
+          type: 'function',
+          parameters
+        };
       }
-      const parameters = node.parameters.map(toSourceTS);
-      return {
-        type: 'function',
-        parameters
-      };
     case IndexedAccessType:
       if (!ts.isIndexedAccessTypeNode(node)) {
         throw Error("Impossible");
@@ -509,6 +529,14 @@ function toSourceTS(node) {
       }
       // fall-through for parentheses
       return toSourceTS(node.type);
+    // toSourceTS(parseType("import('abc').x.y.z"))
+    case QualifiedName:
+      if (!ts.isQualifiedName(node)) {
+        throw Error("Impossible");
+      }
+      const l = toSourceTS(node.left);
+      const r = toSourceTS(node.right);
+      return `${l}.${r}`;
     case ImportType:
       if (!ts.isImportTypeNode(node)) {
         throw Error("Impossible");
@@ -994,6 +1022,16 @@ function statReset(stat) {
   stat.unchecked = 0;
 }
 
+/**
+ * @example
+ * capitalize("hello"); // Outputs: Hello
+ * @param {string} _ - The input string.
+ * @returns {string} The capitalized output string.
+ */
+function capitalize(_) {
+  return _[0].toUpperCase() + _.slice(1);
+}
+
 /**
  * @example
  * trimEndSpaces('test   \n   '); // Returns: 'test   \n'
@@ -1021,8 +1059,13 @@ class Stringifier {
     this.forceCurly = false;
     /** @type {Node[]} */
     this.parents = [];
+    /**
+     * If we encounter JSX elements, we add React's createElement as import.
+     */
+    this.addReactImport = false;
     this.lastCommentBlockIndex = -1;
     this.lastCommentLineIndex = -1;
+    this.encounteredFragment = false;
     this.numSpaces = 0;
   }
   /**
@@ -1258,6 +1301,18 @@ class Stringifier {
     }
     return out;
   }
+  /**
+   * @returns {string} The header.
+   */
+  getHeader() {
+    if (!this.addReactImport) {
+      return '';
+    }
+    if (this.encounteredFragment) {
+      return "import {createElement, Fragment} from 'react';\n";
+    }
+    return "import {createElement} from 'react';\n";
+  }
   get parent() {
     return this.parents[this.parents.length - 2];
   }
@@ -1618,7 +1673,10 @@ class Stringifier {
       out += ' * ';
     }
     out += this.FunctionDeclarationParams(params);
-    out += ' => ';
+    out += ' =>';
+    if (body.type !== 'BlockStatement') {
+      out += ' ';
+    }
     out += this.toSource(body);
     return out;
   }
@@ -2249,6 +2307,204 @@ class Stringifier {
     // createMesh: createMesh$1\n
     return `${spaces}${right} as ${left}`;
   }
+  /**
+   * @param {import("@babel/types").JSXAttribute} node - The Babel AST node.
+   * @returns {string} Stringification of the node.
+   */
+  JSXAttribute(node) {
+    const {
+      name,
+      value
+    } = node;
+    // console.log("JSXAttribute", {name, value});
+    const keySource = this.toSource(name);
+    // E.g. <audio controls/>
+    if (value === null) {
+      return `${this.spaces}${keySource}: true`;
+    }
+    const valSource = this.toSource(value);
+    if (keySource === valSource) {
+      return this.spaces + keySource;
+    }
+    return `${this.spaces}${keySource}: ${valSource}`;
+  }
+  /**
+   * @param {import("@babel/types").JSXElement} node - The Babel AST node.
+   * @returns {string} Stringification of the node.
+   */
+  JSXElement(node) {
+    this.addReactImport = true;
+    const {
+      openingElement,
+      closingElement,
+      children
+    } = node;
+    // console.log("JSXElement", {openingElement, closingElement, children});
+    if (openingElement.type !== 'JSXOpeningElement') {
+      debugger;
+    }
+    let {
+      spaces
+    } = this;
+    const {
+      name,
+      attributes
+    } = openingElement;
+    let out = '';
+    out += 'createElement(';
+    this.numSpaces++;
+    spaces = this.spaces;
+    out += '\n';
+    out += spaces;
+    let sourceName = this.toSource(name);
+    if (sourceName[0] === sourceName[0].toLowerCase()) {
+      // If something like 'div', it has to become "'div'"
+      sourceName = JSON.stringify(sourceName);
+    }
+    out += sourceName;
+    out += ',';
+    if (attributes.length) {
+      out += '\n';
+      out += spaces;
+      out += '{\n';
+      this.numSpaces++;
+      out += attributes.map(attr => this.toSource(attr) + ',\n').join('');
+      this.numSpaces--;
+      out += spaces;
+      out += '}';
+    } else {
+      out += '\n';
+      out += spaces;
+      out += 'null';
+    }
+    if (children.length) {
+      out += ',\n';
+      for (const child of children) {
+        const source = this.toSource(child);
+        if (!source.length) {
+          continue;
+        }
+        out += spaces;
+        out += source;
+        out += ',\n';
+      }
+    } else {
+      out += '\n';
+    }
+    this.numSpaces--;
+    out += this.spaces;
+    out += ')';
+    return out;
+  }
+  /**
+   * @param {import("@babel/types").JSXFragment} node - The Babel AST node.
+   * @returns {string} Stringification of the node.
+   */
+  JSXFragment(node) {
+    const {
+      /*openingFragment, closingFragment,*/children
+    } = node;
+    this.encounteredFragment = true;
+    // console.log('JSXFragment', {openingFragment, closingFragment, children});
+    let {
+      spaces
+    } = this;
+    let out = 'createElement(\n';
+    this.numSpaces++;
+    spaces = this.spaces;
+    out += spaces;
+    out += 'Fragment,\n';
+    out += spaces;
+    out += 'null';
+    // Same code for children as in JSXElement
+    if (children.length) {
+      out += ',\n';
+      for (const child of children) {
+        const source = this.toSource(child);
+        if (!source.length) {
+          continue;
+        }
+        out += spaces;
+        out += source;
+        out += ',\n';
+      }
+    } else {
+      out += '\n';
+    }
+    this.numSpaces--;
+    out += this.spaces;
+    out += ')';
+    return out;
+  }
+  /**
+   * @param {import("@babel/types").JSXIdentifier} node - The Babel AST node.
+   * @returns {string} Stringification of the node.
+   */
+  JSXIdentifier(node) {
+    const {
+      name
+    } = node;
+    // console.log('JSXIdentifier', {name});
+    // https://github.com/kungfooman/RuntimeTypeInspector.js/issues/201
+    // https://stackoverflow.com/questions/38998987/using-aria-attributes-on-elements-in-react
+    if (name.includes('-')) {
+      return JSON.stringify(name);
+    }
+    return name;
+  }
+  /**
+   * @param {import("@babel/types").JSXNamespacedName} node - The Babel AST node.
+   * @returns {string} Stringification of the node.
+   */
+  JSXNamespacedName(node) {
+    const {
+      namespace,
+      name
+    } = node;
+    const a = this.toSource(namespace);
+    const b = capitalize(this.toSource(name));
+    return a + b;
+  }
+  /**
+   * @param {import("@babel/types").JSXExpressionContainer} node - The Babel AST node.
+   * @returns {string} Stringification of the node.
+   */
+  JSXExpressionContainer(node) {
+    const {
+      expression
+    } = node;
+    // console.log('JSXExpressionContainer', {expression});
+    return this.toSource(expression);
+  }
+  /**
+   * @param {import("@babel/types").JSXMemberExpression} node - The Babel AST node.
+   * @returns {string} Stringification of the node.
+   */
+  JSXMemberExpression(node) {
+    const {
+      object,
+      property
+    } = node;
+    // console.log('JSXMemberExpression', 'object', object, 'property', property);
+    const o = this.toSource(object);
+    const p = this.toSource(property);
+    return `${o}.${p}`;
+  }
+  /**
+   * @param {import("@babel/types").JSXText} node - The Babel AST node.
+   * @returns {string} Stringification of the node.
+   */
+  JSXText(node) {
+    const {
+      extra,
+      value
+    } = node;
+    // console.log('JSXText', {extra, value});
+    if (!value.trim().length) {
+      return '';
+    }
+    return JSON.stringify(value);
+  }
   /**
    * @param {import("@babel/types").Super} node - The Babel AST node.
    * @returns {string} Stringification of the node.
@@ -2647,6 +2903,22 @@ class Stringifier {
   Import(node) {
     return 'import';
   }
+  /**
+   * @param {import("@babel/types").ImportExpression} node - The Babel AST node.
+   * @returns {string} Stringification of the node.
+   */
+  ImportExpression(node) {
+    const {
+      source,
+      options
+    } = node;
+    let out = "import(" + this.toSource(source);
+    if (options) {
+      out += ', ' + this.toSource(options);
+    }
+    out += ')';
+    return out;
+  }
   /**
    * @param {import("@babel/types").ImportDeclaration} node - The Babel AST node.
    * @returns {string} Stringification of the node.
@@ -2659,15 +2931,30 @@ class Stringifier {
     // ImportNamespaceSpecifier: import * as a   from "b";
     // ImportDefaultSpecifier  : import      a   from "b";
     // ImportSpecifier         : import {    a } from "b";
-    const a = this.mapToSource(specifiers).join(', ');
-    const b = this.toSource(source);
+    const from = this.toSource(source);
     if (specifiers.length === 0) {
-      return `import ${b}`;
+      return `import ${from}`;
+    }
+    let out = 'import ';
+    const n = specifiers.length;
+    let inImportSpecifier = false;
+    let i = 0;
+    for (const specifier of specifiers) {
+      if (specifier.type === 'ImportSpecifier' && !inImportSpecifier) {
+        out += "{";
+        inImportSpecifier = true;
+      }
+      out += this.toSource(specifier);
+      if (i !== n - 1) {
+        out += ', ';
+      }
+      i++;
     }
-    if (specifiers[0].type !== 'ImportSpecifier') {
-      return `import ${a} from ${b};`;
+    if (inImportSpecifier) {
+      out += '}';
     }
-    return `import {${a}} from ${b};`;
+    out += ` from ${from};`;
+    return out;
   }
   /**
    * @param {import("@babel/types").ImportSpecifier} node - The Babel AST node.
@@ -2917,7 +3204,13 @@ class Asserter extends Stringifier {
     } else {
       out += ' {\n';
       out += this.generateTypeChecks(node);
+      const {
+        spaces
+      } = this;
+      this.numSpaces++;
       out += this.spaces + 'return ' + this.toSource(body) + ';\n';
+      this.numSpaces--;
+      out += spaces;
       out += '}';
     }
     return out;
@@ -2959,12 +3252,14 @@ class Asserter extends Stringifier {
    * @todo
    * Once we went over every node, we can see if we really require registerTypef, registerClass etc.
    * @returns {string} The import declaration header for importing RTI.
+   * @override
    */
   getHeader() {
     if (!this.addHeader) {
       return '';
     }
-    let header = "import {inspectType, inspectTypeWithTemplates, youCanAddABreakpointHere, registerVariable";
+    let header = super.getHeader();
+    header += "import {inspectType, inspectTypeWithTemplates, youCanAddABreakpointHere, registerVariable";
     if (this.validateDivision) {
       header += ", validateDivision";
     }
@@ -3631,6 +3926,17 @@ class Asserter extends Stringifier {
   }
 }
 
+/**
+ * We use the same options in different places, so it's nice to keep them in sync without
+ * changing them in multiple locations.
+ * @type {import('@babel/parser').ParserOptions}
+ */
+const parserOptions = {
+  sourceType: 'module',
+  createParenthesizedExpressions: true,
+  plugins: ['jsx']
+};
+
 /**
  * Simple facade which does all the processing. Processes the input
  * source string, adding runtime type checks based on JSDoc comments.
@@ -3650,11 +3956,10 @@ class Asserter extends Stringifier {
 function addTypeChecks(src, options) {
   try {
     const asserter = new Asserter(options);
-    const ast = parse(src, {
-      sourceType: 'module',
-      createParenthesizedExpressions: true
-    });
-    const out = asserter.getHeader() + asserter.toSource(ast);
+    const ast = parse(src, parserOptions);
+    // Must be called before getHeader since it's keeping an eye open for JSX elements.
+    const source = asserter.toSource(ast);
+    const out = asserter.getHeader() + source;
     return out;
   } catch (e) {
     console.error(e);
@@ -3702,15 +4007,13 @@ function ast2jsonForComparison(ast) {
  * @returns {string | undefined} The new and once parsed and stringified code.
  */
 function code2ast2code(code) {
-  const stringifier = new Stringifier();
-  const ast = parse(code, {
-    sourceType: 'module'
-  });
+  const ast = parse(code, parserOptions);
   if (!ast) {
     return;
   }
+  const stringifier = new Stringifier();
   const out = stringifier.toSource(ast);
-  return out;
+  return stringifier.getHeader() + out;
 }
 
 /**
@@ -3972,4 +4275,4 @@ function toSourceBabelTS(node) {
   }
 }
 
-export { Asserter, Stringifier, addTypeChecks, ast2json, ast2jsonForComparison, code2ast2code, compareAST, expandType, expandTypeBabelTS, expandTypeDepFree, extractCurlyContent, extractNameAndOptionality, nodeIsFunction, parseJSDoc, parseJSDocSetter, parseJSDocTemplates, parseJSDocTypedef, parseType, parseTypeBabelTS, requiredTypeofs, simplifyType, toSourceBabelTS, toSourceTS, trimEndSpaces };
+export { Asserter, Stringifier, addTypeChecks, ast2json, ast2jsonForComparison, capitalize, code2ast2code, compareAST, expandType, expandTypeBabelTS, expandTypeDepFree, extractCurlyContent, extractNameAndOptionality, nodeIsFunction, parseJSDoc, parseJSDocSetter, parseJSDocTemplates, parseJSDocTypedef, parseType, parseTypeBabelTS, parserOptions, requiredTypeofs, simplifyType, toSourceBabelTS, toSourceTS, trimEndSpaces };

package/package.json

@@ -1,7 +1,7 @@
 {
   "bin": "bin.js",
   "name": "@runtime-type-inspector/transpiler",
-  "version": "3.3.7",
+  "version": "4.0.1",
   "description": "Validating JSDoc types at runtime for high-quality types - Trust is good, control is better.",
   "main": "index.cjs",
   "module": "index.mjs",
@@ -19,7 +19,7 @@
   "homepage": "https://github.com/kungfooman/RuntimeTypeInspector.js#readme",
   "dependencies": {
     "@babel/parser": "^7.23.0",
-    "@runtime-type-inspector/runtime": "^3.3.7",
+    "@runtime-type-inspector/runtime": "^4.0.1",
     "typescript": "^5.1.6"
   },
   "files": [