@runtime-type-inspector/transpiler 3.3.6 → 4.0.0

package/index.cjs

@@ -976,10 +976,22 @@
 	    //   name: [kwargs={}] The configuration parameters.
 	    //   name: [d = 1.0] Sample spacing
 	    if (name[0] === '[') {
-	      // Possible improvement: counting opening/closing brackets for perfect match
-	      var closer = name.lastIndexOf(']');
+	      // Counting opening/closing brackets for perfect match
+	      var openCloseCount = 1;
+	      var i = 1;
+	      for (; i < name.length; i++) {
+	        var c = name[i];
+	        if (c === '[') {
+	          openCloseCount++;
+	        } else if (c === ']') {
+	          openCloseCount--;
+	        }
+	        if (openCloseCount === 0) {
+	          break;
+	        }
+	      }
 	      // Afterwards name will be: d = 1.0
-	      name = name.substring(1, closer);
+	      name = name.substring(1, i);
 	      // mark it for the type:
 	      optional = true;
 	    }
@@ -1251,6 +1263,10 @@
 	    _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, "numSpaces", 0);
@@ -1507,6 +1523,17 @@
 	      }
 	      return out;
 	    }
+	    /**
+	     * @returns {string} The header.
+	     */
+	  }, {
+	    key: "getHeader",
+	    value: function getHeader() {
+	      if (!this.addReactImport) {
+	        return '';
+	      }
+	      return "import {createElement} from 'react';\n";
+	    }
 	  }, {
 	    key: "parent",
 	    get: function get() {
@@ -1889,7 +1916,10 @@
 	        out += ' * ';
 	      }
 	      out += this.FunctionDeclarationParams(params);
-	      out += ' => ';
+	      out += ' =>';
+	      if (body.type !== 'BlockStatement') {
+	        out += ' ';
+	      }
 	      out += this.toSource(body);
 	      return out;
 	    }
@@ -2523,6 +2553,154 @@
 	      // 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").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});
+	      return name;
+	    }
+	    /**
+	     * @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.
@@ -3204,7 +3382,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;
@@ -3250,6 +3432,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",
@@ -3257,7 +3440,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";
 	      }
@@ -3686,7 +3870,8 @@
 	                  }
 	                  return 0; // continue
 	                } else if (param.left.type === 'ObjectPattern') {
-	                  if (type.type === 'object') {
+	                  // If we have properties from JSDoc, we can create individual type inspections.
+	                  if (type !== null && type !== void 0 && type.properties && Object.keys(type.properties).length) {
 	                    // Add a type assertion for each property of the ObjectPattern
 	                    var _iterator2 = _createForOfIteratorHelper(param.left.properties),
 	                      _step2;
@@ -3727,7 +3912,7 @@
 	                      _iterator2.f();
 	                    }
 	                    return 0; // continue
-	                  } else if (typeof type === 'string') {
+	                  } else {
 	                    // The case when we have an ObjectPattern with a @typedef
 	                    name = "arguments[".concat(paramIndex, "]");
 	                  }
@@ -3988,6 +4173,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.
@@ -4007,11 +4203,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);
@@ -4059,15 +4254,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;
 	}
 
 	/**
@@ -4348,6 +4541,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

@@ -756,10 +756,22 @@ function parseJSDoc(src, expandType = expandTypeDepFree) {
     //   name: [kwargs={}] The configuration parameters.
     //   name: [d = 1.0] Sample spacing
     if (name[0] === '[') {
-      // Possible improvement: counting opening/closing brackets for perfect match
-      const closer = name.lastIndexOf(']');
+      // Counting opening/closing brackets for perfect match
+      let openCloseCount = 1;
+      let i = 1;
+      for (; i < name.length; i++) {
+        const c = name[i];
+        if (c === '[') {
+          openCloseCount++;
+        } else if (c === ']') {
+          openCloseCount--;
+        }
+        if (openCloseCount === 0) {
+          break;
+        }
+      }
       // Afterwards name will be: d = 1.0
-      name = name.substring(1, closer);
+      name = name.substring(1, i);
       // mark it for the type:
       optional = true;
     }
@@ -1009,6 +1021,10 @@ 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.numSpaces = 0;
@@ -1246,6 +1262,15 @@ class Stringifier {
     }
     return out;
   }
+  /**
+   * @returns {string} The header.
+   */
+  getHeader() {
+    if (!this.addReactImport) {
+      return '';
+    }
+    return "import {createElement} from 'react';\n";
+  }
   get parent() {
     return this.parents[this.parents.length - 2];
   }
@@ -1606,7 +1631,10 @@ class Stringifier {
       out += ' * ';
     }
     out += this.FunctionDeclarationParams(params);
-    out += ' => ';
+    out += ' =>';
+    if (body.type !== 'BlockStatement') {
+      out += ' ';
+    }
     out += this.toSource(body);
     return out;
   }
@@ -2237,6 +2265,146 @@ 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").JSXIdentifier} node - The Babel AST node.
+   * @returns {string} Stringification of the node.
+   */
+  JSXIdentifier(node) {
+    const {
+      name
+    } = node;
+    // console.log('JSXIdentifier', {name});
+    return name;
+  }
+  /**
+   * @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.
@@ -2905,7 +3073,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;
@@ -2947,12 +3121,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";
     }
@@ -3366,7 +3542,8 @@ class Asserter extends Stringifier {
               }
               continue;
             } else if (param.left.type === 'ObjectPattern') {
-              if (type.type === 'object') {
+              // If we have properties from JSDoc, we can create individual type inspections.
+              if (type != null && type.properties && Object.keys(type.properties).length) {
                 // Add a type assertion for each property of the ObjectPattern
                 for (const property of param.left.properties) {
                   if (property.type !== 'ObjectProperty') {
@@ -3398,7 +3575,7 @@ class Asserter extends Stringifier {
                   out += `${spaces}  youCanAddABreakpointHere();\n${spaces}}\n`;
                 }
                 continue;
-              } else if (typeof type === 'string') {
+              } else {
                 // The case when we have an ObjectPattern with a @typedef
                 name = `arguments[${paramIndex}]`;
               }
@@ -3618,6 +3795,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.
@@ -3637,11 +3825,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);
@@ -3689,15 +3876,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;
 }
 
 /**
@@ -3959,4 +4144,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, 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.6",
+  "version": "4.0.0",
   "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.6",
+    "@runtime-type-inspector/runtime": "^4.0.0",
     "typescript": "^5.1.6"
   },
   "files": [