@runtime-type-inspector/transpiler 4.0.0 → 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'
@@ -1269,6 +1305,7 @@
 	    _defineProperty(this, "addReactImport", false);
 	    _defineProperty(this, "lastCommentBlockIndex", -1);
 	    _defineProperty(this, "lastCommentLineIndex", -1);
+	    _defineProperty(this, "encounteredFragment", false);
 	    _defineProperty(this, "numSpaces", 0);
 	  }
 	  _createClass(Stringifier, [{
@@ -1523,15 +1560,19 @@
 	      }
 	      return out;
 	    }
+	  }, {
+	    key: "getHeader",
+	    value:
 	    /**
 	     * @returns {string} The header.
 	     */
-	  }, {
-	    key: "getHeader",
-	    value: function getHeader() {
+	    function getHeader() {
 	      if (!this.addReactImport) {
 	        return '';
 	      }
+	      if (this.encounteredFragment) {
+	        return "import {createElement, Fragment} from 'react';\n";
+	      }
 	      return "import {createElement} from 'react';\n";
 	    }
 	  }, {
@@ -2650,6 +2691,53 @@
 	      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.
@@ -2659,8 +2747,26 @@
 	    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.
@@ -3093,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.
@@ -3105,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.
@@ -4527,6 +4673,7 @@
 	exports.addTypeChecks = addTypeChecks;
 	exports.ast2json = ast2json;
 	exports.ast2jsonForComparison = ast2jsonForComparison;
+	exports.capitalize = capitalize;
 	exports.code2ast2code = code2ast2code;
 	exports.compareAST = compareAST;
 	exports.expandType = expandType;

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'
@@ -1027,6 +1065,7 @@ class Stringifier {
     this.addReactImport = false;
     this.lastCommentBlockIndex = -1;
     this.lastCommentLineIndex = -1;
+    this.encounteredFragment = false;
     this.numSpaces = 0;
   }
   /**
@@ -1269,6 +1308,9 @@ class Stringifier {
     if (!this.addReactImport) {
       return '';
     }
+    if (this.encounteredFragment) {
+      return "import {createElement, Fragment} from 'react';\n";
+    }
     return "import {createElement} from 'react';\n";
   }
   get parent() {
@@ -2354,6 +2396,46 @@ class Stringifier {
     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.
@@ -2363,8 +2445,26 @@ class Stringifier {
       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.
@@ -2803,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.
@@ -2815,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.
@@ -4144,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, parserOptions, 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": "4.0.0",
+  "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": "^4.0.0",
+    "@runtime-type-inspector/runtime": "^4.0.1",
     "typescript": "^5.1.6"
   },
   "files": [