@runtime-type-inspector/transpiler 3.2.5 → 3.2.7

package/index.mjs

@@ -25,24 +25,19 @@ import ts from 'typescript';
  * expandType('typeof Number            '); // Outputs:
  * @param {string} type - The type string to be expanded into a structured representation.
  * @todo Share type with expandTypeBabelTS and expandTypeDepFree
- * @returns {string | {type: string, [key: string]: any} | undefined} The structured type
+ * @returns {string | number | boolean | {type: string, [key: string]: any} | undefined} The structured type
  * representation obtained from parsing and converting the provided type string.
  */
 function expandType(type) {
   const ast = parseType(type);
+  if (!ast) {
+    return 'never';
+  }
   return toSourceTS(ast);
 }
-/**
- * @todo I want to use for example: import('typescript').Node
- * But the TS types make no sense to me so far ... need to investigate more.
- * @typedef TypeScriptType
- * @property {object[]|undefined} typeArguments - The type arguments.
- * @property {import('typescript').Node} typeName - The type name.
- * @property {number} kind - The kind for `ts.SyntaxKind[kind]`.
- */
 /**
  * @param {string} str - The type string.
- * @returns {TypeScriptType} - The node containing all the information about the input type string.
+ * @returns {ts.TypeNode|undefined} - The node containing all the information about the input type string.
  */
 function parseType(str) {
   // TS doesn't like ... notation in this context
@@ -53,7 +48,12 @@ function parseType(str) {
   // type tmp = (...string) => 123; to have a function context
   str = `type tmp = ${str};`;
   const ast = ts.createSourceFile('repl.ts', str, ts.ScriptTarget.Latest, true /*setParentNodes*/);
-  return ast.statements[0].type;
+  const firstStatement = ast.statements[0];
+  if (!ts.isTypeAliasDeclaration(firstStatement)) {
+    console.warn('parseType> Expected type alias declaration, got', firstStatement, 'instead.');
+    return;
+  }
+  return firstStatement.type;
 }
 /** @type {Record<string, 'missing'|'found'>} */
 const requiredTypeofs = {};
@@ -63,7 +63,7 @@ const requiredTypeofs = {};
  * This function handles various TypeScript AST node types and converts them into a string
  * or an object representing the type.
  *
- * @param {TypeScriptType} node - The TypeScript AST node to convert.
+ * @param {ts.TypeNode|ts.Identifier} 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.
  */
@@ -75,52 +75,90 @@ function toSourceTS(node) {
   const kind_ = ts.SyntaxKind[node.kind];
   const {
     AnyKeyword,
+    // parseType('any'                            ).kind                 === ts.SyntaxKind.AnyKeyword && toSourceTS(parseType('any')) === 'any'
     ArrayType,
+    // parseType('number[]'                       ).kind                 === ts.SyntaxKind.ArrayType // todo toSourceTS(parseType('number[]')) === {type: 'array etc.
     BooleanKeyword,
+    // parseType("boolean"                        ).kind                 === ts.SyntaxKind.BooleanKeyword
     FunctionType,
+    // parseType("() => void"                     ).kind                 === ts.SyntaxKind.FunctionType
     Identifier,
+    // parseType("{a: 1, b: 2}"                   ).members[0].name.kind === ts.SyntaxKind.Identifier
     IntersectionType,
+    // parseType("1 & 2"                          ).kind                 === ts.SyntaxKind.IntersectionType
     JSDocAllType,
-    LastTypeNode,
+    // parseType("*"                              ).kind                 === ts.SyntaxKind.JSDocAllType
+    ImportType,
+    // parseType('import("test").Test'            ).kind                 === ts.SyntaxKind.ImportType
     LiteralType,
+    // parseType("123"                            ).kind                 === ts.SyntaxKind.LiteralType
     NullKeyword,
+    // parseType("null"                           ).literal.kind         === ts.SyntaxKind.NullKeyword
     NumberKeyword,
+    // parseType("number"                         ).kind                 === ts.SyntaxKind.NumberKeyword
     NumericLiteral,
+    // parseType("123"                            ).literal.kind         === ts.SyntaxKind.NumericLiteral
     ObjectKeyword,
+    // parseType("object"                         ).kind                 === ts.SyntaxKind.ObjectKeyword
     Parameter,
+    // parseType("(a) => void"                    ).parameters[0].kind   === ts.SyntaxKind.Parameter
     ParenthesizedType,
+    // parseType("(SomeType)"                     ).kind                 === ts.SyntaxKind.ParenthesizedType
     PropertySignature,
+    // parseType("{a: 1, b: 2}"                   ).members[0].kind      === ts.SyntaxKind.PropertySignature
     StringKeyword,
+    // parseType("string"                         ).kind                 === ts.SyntaxKind.StringKeyword
     StringLiteral,
+    // parseType("'test'"                         ).literal.kind         === ts.SyntaxKind.StringLiteral
     ThisType,
+    // parseType("this"                           ).kind                 === ts.SyntaxKind.ThisType
     TupleType,
+    // parseType("[1, 2, 3]"                      ).kind                 === ts.SyntaxKind.TupleType
     TypeLiteral,
+    // parseType("{a: 1, b: 2}"                   ).kind                 === ts.SyntaxKind.TypeLiteral
     TypeReference,
+    // parseType("SomeOtherType"                  ).kind                 === ts.SyntaxKind.TypeReference
     UndefinedKeyword,
+    // parseType("undefined"                      ).kind                 === ts.SyntaxKind.UndefinedKeyword
     UnionType,
+    // parseType("1|2"                            ).kind                 === ts.SyntaxKind.UnionType
     JSDocNullableType,
+    // parseType("?lol?"                          ).kind                 === ts.SyntaxKind.JSDocNullableType
     TrueKeyword,
+    // parseType("true"                           ).literal.kind         === ts.SyntaxKind.TrueKeyword
     FalseKeyword,
+    // parseType("false"                          ).literal.kind         === ts.SyntaxKind.FalseKeyword
     VoidKeyword,
+    // parseType("void"                           ).kind                 === ts.SyntaxKind.VoidKeyword
     UnknownKeyword,
+    // parseType("unknown"                        ).kind                 === ts.SyntaxKind.UnknownKeyword
     NeverKeyword,
+    // parseType("never"                          ).kind                 === ts.SyntaxKind.NeverKeyword
     BigIntKeyword,
+    // parseType("bigint"                         ).kind                 === ts.SyntaxKind.BigIntKeyword
     BigIntLiteral,
+    // parseType("123n"                           ).literal.kind         === ts.SyntaxKind.BigIntLiteral
     ConditionalType,
+    // parseType("1 extends number ? true : false").kind                 === ts.SyntaxKind.ConditionalType
     IndexedAccessType,
+    // parseType('Test[123]'                      ).kind                 === ts.SyntaxKind.IndexedAccessType
+    IndexSignature,
+    // parseType('{[n: number]: string}'          ).members[0].kind      === ts.SyntaxKind.IndexSignature
     RestType,
+    // parseType("[...number]"                    ).elements[0].kind     === ts.SyntaxKind.RestType
     TypeQuery,
-    // parseType('typeof Number')
+    // parseType('typeof Number'                  ).kind                 === ts.SyntaxKind.TypeQuery
     TypeOperator,
-    // parseType('keyof typeof obj')
+    // parseType('keyof typeof obj'               ).kind                 === ts.SyntaxKind.TypeOperator
     KeyOfKeyword,
-    // "operator" key in TypeOperator node
+    // parseType('keyof typeof obj'               ).operator             === ts.SyntaxKind.KeyOfKeyword
     ConstructorType,
-    // parseType('new (...args: any[]) => any');
+    // parseType('new (...args: any[]) => any'    ).kind                 === ts.SyntaxKind.ConstructorType
     NamedTupleMember,
+    // parseType('[a: 1]'                         ).elements[0].kind     === ts.SyntaxKind.NamedTupleMember
     MappedType,
-    // parseType('{[K in TaskType]: InstanceType<typeof SUPPORTED_TASKS[K]["pipeline"]>}')
-    TypeParameter // Basically K and TaskType of MappedType
+    // parseType('{[K in TaskType]: 123}'         ).kind                 === ts.SyntaxKind.MappedType
+    TypeParameter // parseType('{[K in TaskType]: 123}'         ).typeParameter.kind   ===  ts.SyntaxKind.TypeParameter
   } = ts.SyntaxKind;
   // console.log({typeArguments, typeName, kind_, node});
   switch (node.kind) {
@@ -129,12 +167,18 @@ function toSourceTS(node) {
         type: 'bigint'
       };
     case BigIntLiteral:
+      if (!ts.isBigIntLiteral(node)) {
+        throw Error("Impossible");
+      }
       const literal = node.text.slice(0, -1); // Remove the "n"
       return {
         type: 'bigint',
         literal
       };
     case ConditionalType:
+      if (!ts.isConditionalTypeNode(node)) {
+        throw Error("Impossible");
+      }
       // Keys on node:
       // ['pos', 'end', 'flags', 'modifierFlagsCache', 'transformFlags', 'parent', 'kind', 'checkType',
       // 'extendsType', 'trueType', 'falseType', 'locals', 'nextContainer']
@@ -151,6 +195,9 @@ function toSourceTS(node) {
       };
     case ConstructorType:
       {
+        if (!ts.isConstructorTypeNode(node)) {
+          throw Error("Impossible");
+        }
         const _parameters = node.parameters.map(toSourceTS);
         const _ret = toSourceTS(node.type);
         return {
@@ -160,12 +207,18 @@ function toSourceTS(node) {
         };
       }
     case FunctionType:
+      if (!ts.isFunctionTypeNode(node)) {
+        throw Error("Impossible");
+      }
       const parameters = node.parameters.map(toSourceTS);
       return {
         type: 'function',
         parameters
       };
     case IndexedAccessType:
+      if (!ts.isIndexedAccessTypeNode(node)) {
+        throw Error("Impossible");
+      }
       const index = toSourceTS(node.indexType);
       const object = toSourceTS(node.objectType);
       return {
@@ -174,12 +227,18 @@ function toSourceTS(node) {
         object
       };
     case RestType:
+      if (!ts.isRestTypeNode(node)) {
+        throw Error("Impossible");
+      }
       const annotation = toSourceTS(node.type);
       return {
         type: 'rest',
         annotation
       };
     case JSDocNullableType:
+      if (!ts.isJSDocNullableType(node)) {
+        throw Error("Impossible");
+      }
       const t = toSourceTS(node.type);
       return {
         type: 'union',
@@ -187,6 +246,9 @@ function toSourceTS(node) {
       };
     case MappedType:
       {
+        if (!ts.isMappedTypeNode(node)) {
+          throw Error("Impossible");
+        }
         const result = toSourceTS(node.type);
         const parameter = node.typeParameter;
         if (parameter.kind === TypeParameter) {
@@ -206,6 +268,9 @@ function toSourceTS(node) {
     // todo work out more: const jsdoc = `(...a: ...number) => 123
     // TS even thinks it's two parameters... just go for array/[]
     case Parameter:
+      if (!ts.isParameter(node)) {
+        throw Error("Impossible");
+      }
       const type = node.type ? toSourceTS(node.type) : 'any';
       const name = toSourceTS(node.name);
       const ret = {
@@ -220,6 +285,9 @@ function toSourceTS(node) {
       }
       return ret;
     case TypeQuery:
+      if (!ts.isTypeQueryNode(node)) {
+        throw Error("Impossible");
+      }
       const argument = toSourceTS(node.exprName);
       // Notify Asserter class that we have to register variables with this name
       if (!requiredTypeofs[argument]) {
@@ -230,6 +298,9 @@ function toSourceTS(node) {
         argument
       };
     case TypeOperator:
+      if (!ts.isTypeOperatorNode(node)) {
+        throw Error("Impossible");
+      }
       if (node.operator === KeyOfKeyword) {
         const _argument = toSourceTS(node.type);
         return {
@@ -240,6 +311,9 @@ function toSourceTS(node) {
       console.warn("unimplemented TypeOperator", node);
     case TypeReference:
       {
+        if (!ts.isTypeReferenceNode(node)) {
+          throw Error("Impossible");
+        }
         if ((typeName.text === 'Object' || typeName.text === 'Record') && (typeArguments == null ? void 0 : typeArguments.length) === 2) {
           return {
             type: 'record',
@@ -295,14 +369,16 @@ function toSourceTS(node) {
           args
         };
       }
-    case StringKeyword:
-      return node.getText();
-    case NumberKeyword:
-      return node.getText();
     case NamedTupleMember:
+      if (!ts.isNamedTupleMember(node)) {
+        throw Error("Impossible");
+      }
       return toSourceTS(node.type);
     case IntersectionType:
       {
+        if (!ts.isIntersectionTypeNode(node)) {
+          throw Error("Impossible");
+        }
         const _members = node.types.map(toSourceTS);
         return {
           type: 'intersection',
@@ -310,35 +386,87 @@ function toSourceTS(node) {
         };
       }
     case TupleType:
+      if (!ts.isTupleTypeNode(node)) {
+        throw Error("Impossible");
+      }
       const elements = node.elements.map(toSourceTS);
       return {
         type: 'tuple',
         elements
       };
     case UnionType:
+      if (!ts.isUnionTypeNode(node)) {
+        throw Error("Impossible");
+      }
       const members = node.types.map(toSourceTS);
       return {
         type: 'union',
         members
       };
     case TypeLiteral:
-      const properties = {};
-      node.members.forEach(member => {
-        const name = toSourceTS(member.name);
-        const type = toSourceTS(member.type);
-        properties[name] = type;
-      });
-      return {
-        type: 'object',
-        properties
-      };
+      {
+        if (!ts.isTypeLiteralNode(node)) {
+          throw Error("Impossible");
+        }
+        const properties = {};
+        /** @type {object[]} */
+        let indexSignatures;
+        node.members.forEach(member => {
+          if (member.kind === IndexSignature) {
+            var _indexSignatures;
+            indexSignatures = (_indexSignatures = indexSignatures) != null ? _indexSignatures : [];
+            indexSignatures.push(toSourceTS(member));
+          } else if (member.kind === PropertySignature) {
+            if (!ts.isPropertySignature(member)) {
+              throw Error("Impossible");
+            }
+            const name = toSourceTS(member.name);
+            const type = toSourceTS(member.type);
+            properties[name] = type;
+          } else {
+            console.warn('TypeLiteral: unhandled member', member);
+          }
+        });
+        const _ret2 = {
+          type: 'object'
+        };
+        if (Object.keys(properties).length) {
+          _ret2.properties = properties;
+        }
+        if (indexSignatures) {
+          _ret2.indexSignatures = indexSignatures;
+        }
+        return _ret2;
+      }
     case PropertySignature:
+      if (!ts.isPropertySignature(node)) {
+        throw Error("Impossible");
+      }
       console.warn('toSourceTS> should not happen, handled by TypeLiteral directly');
       return `${toSourceTS(node.name)}: ${toSourceTS(node.type)}`;
+    case IndexSignature:
+      if (!ts.isIndexSignatureDeclaration(node)) {
+        throw Error("Impossible");
+      }
+      // Only possible modifier I know of, but we don't need it:
+      //   {readonly [n: number]: string, length: number}
+      const indexType = toSourceTS(node.type);
+      const indexParameters = node.parameters.map(toSourceTS);
+      return {
+        type: 'indexSignature',
+        indexType,
+        indexParameters
+      };
     case Identifier:
+      if (!ts.isIdentifier(node)) {
+        throw Error("Impossible");
+      }
       return node.text;
     case ArrayType:
       {
+        if (!ts.isArrayTypeNode(node)) {
+          throw Error("Impossible");
+        }
         const elementType = toSourceTS(node.elementType);
         return {
           type: 'array',
@@ -346,18 +474,23 @@ function toSourceTS(node) {
         };
       }
     case LiteralType:
+      if (!ts.isLiteralTypeNode(node)) {
+        throw Error("Impossible");
+      }
       return toSourceTS(node.literal);
     case AnyKeyword:
     case BooleanKeyword:
-    // ts.SyntaxKind[parseType("*").kind] === 'JSDocAllType'
-    case JSDocAllType:
+    case StringKeyword:
+    case NeverKeyword:
     case NullKeyword:
-    case StringLiteral:
-    case ThisType:
+    case NumberKeyword:
     case UndefinedKeyword:
-    case VoidKeyword:
     case UnknownKeyword:
-    case NeverKeyword:
+    case VoidKeyword:
+    // ts.SyntaxKind[parseType("*").kind] === 'JSDocAllType'
+    case JSDocAllType:
+    case ThisType:
+    case StringLiteral:
       return node.getText();
     case TrueKeyword:
       return true;
@@ -371,9 +504,16 @@ function toSourceTS(node) {
         properties: {}
       };
     case ParenthesizedType:
+      if (!ts.isParenthesizedTypeNode(node)) {
+        throw Error("Impossible");
+      }
       // fall-through for parentheses
       return toSourceTS(node.type);
-    case LastTypeNode:
+    case ImportType:
+      if (!ts.isImportTypeNode(node)) {
+        throw Error("Impossible");
+      }
+      /** @todo Handle case without any qualifier like `import('test')` */
       return toSourceTS(node.qualifier);
     default:
       // const test = {};
@@ -588,18 +728,25 @@ function simplifyType(type, optional) {
   return type;
 }
 
+/**
+ * @typedef {ReturnType<typeof parseJSDoc>} ParseJSDocReturnType
+ */
+/**
+ * @typedef {typeof expandTypeDepFree} ExpandType
+ * @typedef {ReturnType<ExpandType>} ExpandTypeReturnType
+ */
 /**
  * Parses JSDoc comments to extract parameter type information.
  *
  * @param {string} src - The JSDoc comment string to parse.
- * @param {Function} [expandType] - An optional function to process the types found in the JSDoc.
- * @returns {Record<string, any> | undefined} An object mapping parameter names to their parsed types, or undefined if no parameters are found.
+ * @param {ExpandType} [expandType] - An optional function to process the types found in the JSDoc.
+ * @returns {Record<string, ExpandTypeReturnType> | undefined} An object mapping parameter names to their parsed types, or undefined if no parameters are found.
  */
 function parseJSDoc(src, expandType = expandTypeDepFree) {
   // Parse something like: @param {Object} [kwargs={}] Optional arguments.
   const regex = /@param \{(.*?)\} ([\[\]a-zA-Z0-9_$=\{\}\.'" ]+)/g;
   const matches = [...src.matchAll(regex)];
-  /** @type {Record<string, any>} */
+  /** @type {Record<string, ExpandTypeReturnType>} */
   const params = Object.create(null);
   matches.forEach(_ => {
     const type = expandType(_[1].trim());
@@ -619,44 +766,31 @@ function parseJSDoc(src, expandType = expandTypeDepFree) {
     // Strip the rest (either leftover of optional value or description)
     name = name.split(' ')[0].split('=')[0].trim();
     const simplifiedType = simplifyType(type, optional);
-    const parts = name.split(".");
-    if (parts.length === 3) {
-      // Something like: @param {number[]} settings.render.skyboxRotation - Rotation of skybox.
-      const parts0 = parts[0]; // settings
-      const parts1 = parts[1]; // render
-      const parts2 = parts[2]; // skyboxRotation
-      const toptype = params[parts0];
-      toptype.properties[parts1].properties = toptype.properties[parts1].properties || {};
-      toptype.properties[parts1].properties[parts2] = simplifiedType;
-    } else if (parts.length === 2) {
-      // Something like: @param {number} description[].components
-      let parts0 = parts[0]; // description[]
-      const parts1 = parts[1]; // components
-      if (parts0.endsWith('[]')) {
-        parts0 = parts0.slice(0, -2); // description[] -> description
-      }
-
-      const toptype = params[parts0];
-      if ((toptype == null ? void 0 : toptype.type) === "union") {
+    // Turn "options.stats[].unitsName" into ['options', 'stats', 'unitsName'].
+    const parts = name.split(/[\[\]]*\./);
+    let properties = params;
+    for (const part of parts) {
+      const toptype = properties[part];
+      if (!toptype) {
+        // No toptype means we resolved as far as possible, now we can add `simplifiedType`.
+        console.assert(part === parts.at(-1), 'Current part and last part should be the same.');
+        properties[part] = simplifiedType;
+      } else if (toptype.type === "union") {
         const typeObject = toptype.members.find(_ => (_ == null ? void 0 : _.type) === 'object');
-        typeObject.properties[parts1] = simplifiedType;
-        //typeObject.properties = simplifiedType; // todo add test case
-      } else if ((toptype == null ? void 0 : toptype.type) === "array") {
-        toptype.elementType.properties[parts1] = simplifiedType;
-      } else if ((toptype == null ? void 0 : toptype.type) === "object") {
-        toptype.properties = toptype.properties || {};
-        toptype.properties[parts1] = simplifiedType;
+        properties = typeObject.properties;
+      } else if (toptype.type === "array") {
+        properties = toptype.elementType.properties;
+      } else if (toptype.type === "object") {
+        toptype.properties = toptype.properties || Object.create(null);
+        properties = toptype.properties;
       } else {
-        console.warn("parseJSDoc> skipping @param, unseen syntax detected, please check if your JSDoc is valid or open an issue about this", {
+        console.warn("parseJSDoc> Skipping @param, unseen syntax detected. Please check if your JSDoc is valid or open an issue about this!", {
           src,
           toptype,
-          parts0,
-          parts1,
+          parts,
           simplifiedType
         });
       }
-    } else {
-      params[name] = simplifiedType;
     }
   });
   if (Object.keys(params).length === 0) {
@@ -682,6 +816,34 @@ function parseJSDocSetter(src, expandType = expandTypeDepFree) {
   }
 }
 
+/**
+ * @typedef {typeof expandTypeDepFree} ExpandType
+ * @typedef {ReturnType<ExpandType>} ExpandTypeReturnType
+ */
+/**
+ * Parses JSDoc comments to extract parameter type information.
+ *
+ * @param {string} src - The JSDoc comment string to parse.
+ * @param {ExpandType} [expandType] - An optional function to process the types found in the JSDoc.
+ * @returns {Record<string, ExpandTypeReturnType> | undefined} An object mapping template names to their parsed types,
+ * or `undefined` if no template tags were found.
+ */
+function parseJSDocTemplates(src, expandType = expandTypeDepFree) {
+  const regexTemplateTyped = /@template \{(.*?)\} ([a-zA-Z0-9_$=]+)/g;
+  const matches = [...src.matchAll(regexTemplateTyped)];
+  if (!matches.length) {
+    return;
+  }
+  /** @type {Record<string, ExpandTypeReturnType>} */
+  const templates = Object.create(null);
+  matches.forEach(_ => {
+    const type = expandType(_[1].trim());
+    const name = _[2].trim();
+    templates[name] = type;
+  });
+  return templates;
+}
+
 /**
  * Extracts the parameter name and its optionality from a JSDoc parameter string.
  *
@@ -2631,14 +2793,14 @@ class Stringifier {
 }
 
 /** @typedef {import('@babel/types').Node              } Node               */
-/** @typedef {import("@babel/types").ClassMethod       } ClassMethod        */
-/** @typedef {import("@babel/types").ClassPrivateMethod} ClassPrivateMethod */
-/** @typedef {import('./stat.js').Stat                } Stat               */
+/** @typedef {import('@babel/types').ClassMethod       } ClassMethod        */
+/** @typedef {import('@babel/types').ClassPrivateMethod} ClassPrivateMethod */
+/** @typedef {import('./stat.js').Stat                 } Stat               */
 /**
  * @typedef {object} Options
  * @property {boolean} [forceCurly] - Determines whether curly braces are enforced in Stringifier.
  * @property {boolean} [validateDivision] - Indicates whether division operations should be validated.
- * @property {Function} [expandType] - A function that expands shorthand types into full descriptions.
+ * @property {import('./parseJSDoc.js').ExpandType} [expandType] - A function that expands shorthand types into full descriptions.
  * @property {string} [filename] - The name of a file to which the instance pertains.
  * @property {boolean} [addHeader] - Whether to add import declarations headers. Defaults to true.
  * @property {string[]} [ignoreLocations] - Ignore these locations because they are known false-positives.
@@ -2891,9 +3053,9 @@ class Asserter extends Stringifier {
   }
   /**
    * @param {Node} node - The Babel AST node.
-   * @returns {undefined | {}} The return value of `parseJSDoc`.
+   * @returns {string|undefined} The JSDoc comment of `node`.
    */
-  getJSDoc(node) {
+  getLeadingComment(node) {
     if (node.type === 'BlockStatement') {
       node = this.parent;
     }
@@ -2919,28 +3081,56 @@ class Asserter extends Stringifier {
     if (leadingComments && leadingComments.length) {
       const lastComment = leadingComments[leadingComments.length - 1];
       if (lastComment.type === "CommentBlock") {
-        if (lastComment.value.includes('@event')) {
-          return;
-        }
-        if (node.type === 'ClassMethod' && node.kind === 'set') {
-          const paramName = this.getNameOfParam(node.params[0]);
-          if (node.params.length !== 1) {
-            this.warn("getJSDoc> setters require exactly one argument");
-          }
-          const setterType = parseJSDocSetter(lastComment.value, this.expandType);
-          if (!setterType) {
-            return;
-          }
-          return {
-            [paramName]: setterType
-          };
-        }
-        if (lastComment.value.includes('@ignoreRTI')) {
-          return;
-        }
-        return parseJSDoc(lastComment.value, this.expandType);
+        return lastComment.value;
+      }
+    }
+  }
+  /**
+   * @param {Node} node - The Babel AST node.
+   * @todo ESLint problem:
+   * returns {import('./parseJSDoc.js').ParseJSDocReturnType} The return value of `parseJSDoc`
+   * returns {Record<string, import('./parseJSDoc.js').ExpandTypeReturnType> | undefined} The
+   * return value of `parseJSDoc`.
+   * @returns {Record<string, any>|undefined} asd
+   */
+  getJSDoc(node) {
+    const comment = this.getLeadingComment(node);
+    if (!comment) {
+      return;
+    }
+    if (comment.includes('@event')) {
+      return;
+    }
+    if (comment.includes('@ignoreRTI')) {
+      return;
+    }
+    // Need to do same resolving as in: this.getLeadingComment(node)
+    if (node.type === 'BlockStatement') {
+      node = this.parent;
+    }
+    if (node.type === 'ClassMethod' && node.kind === 'set') {
+      const paramName = this.getNameOfParam(node.params[0]);
+      if (node.params.length !== 1) {
+        this.warn("getJSDoc> setters require exactly one argument");
       }
+      const setterType = parseJSDocSetter(comment, this.expandType);
+      if (!setterType) {
+        return;
+      }
+      const _params = {
+        [paramName]: setterType
+      };
+      return {
+        templates: undefined,
+        params: _params
+      };
     }
+    const templates = parseJSDocTemplates(comment);
+    const params = parseJSDoc(comment, this.expandType);
+    return {
+      templates,
+      params
+    };
   }
   /**
    * Retrieves the name of a parameter from a Babel AST node.
@@ -2959,8 +3149,7 @@ class Asserter extends Stringifier {
         return param.left.name;
       }
     }
-    debugger;
-    this.warn("unable to extra name from param in specified way - may contain too much information");
+    this.warn("Unable to retrieve name from param in specified way - may contain too much information.");
     return this.toSource(param);
   }
   statsReset() {
@@ -3079,6 +3268,17 @@ class Asserter extends Stringifier {
       stat.unchecked++;
       return '';
     }
+    const {
+      templates,
+      params
+    } = jsdoc;
+    if (!params) {
+      console.warn("This should never happen, please check your input code.", this.getLeadingComment(node), {
+        jsdoc
+      });
+      stat.unchecked++;
+      return '';
+    }
     stat.checked++;
     const {
       spaces
@@ -3089,17 +3289,21 @@ class Asserter extends Stringifier {
     if (this.ignoreLocations.includes(loc)) {
       return '// IGNORE RTI TYPE VALIDATIONS, KNOWN ISSUES\n';
     }
+    if (templates) {
+      const tmp = JSON.stringify(templates, null, 2).replaceAll('\n', '\n' + spaces);
+      out += `\n${spaces}const rtiTemplates = ${tmp};`;
+    }
     //out += `${spaces}/*${spaces}  node.type=${node.type}\n${spaces}
     //  ${JSON.stringify(jsdoc)}\n${parent}\n${spaces}*/\n`;
-    for (let name in jsdoc) {
-      const type = jsdoc[name];
+    for (let name in params) {
+      const type = params[name];
       const hasParam = this.nodeHasParamName(node, name);
       if (!hasParam) {
         let testNode = node;
         if (node.type === 'BlockStatement') {
           testNode = this.parent;
         }
-        const paramIndex = Object.keys(jsdoc).findIndex(_ => _ === name);
+        const paramIndex = Object.keys(params).findIndex(_ => _ === name);
         const param = testNode.params[paramIndex];
         if (param) {
           const isObjectPattern = param.type === 'ObjectPattern';
@@ -3129,7 +3333,11 @@ class Asserter extends Stringifier {
                   continue;
                 }
                 const _t = JSON.stringify(type.elementType, null, 2).replaceAll('\n', '\n' + spaces);
-                out += `${spaces}if (!inspectType(${element.name}, ${_t}, '${_loc}', '${name}')) {\n`;
+                if (templates) {
+                  out += `${spaces}if (!inspectTypeWithTemplates(${element.name}, ${_t}, '${_loc}', '${name}', rtiTemplates)) {\n`;
+                } else {
+                  out += `${spaces}if (!inspectType(${element.name}, ${_t}, '${_loc}', '${name}')) {\n`;
+                }
                 out += `${spaces}  youCanAddABreakpointHere();\n${spaces}}\n`;
               }
               continue;
@@ -3151,7 +3359,11 @@ class Asserter extends Stringifier {
                   continue;
                 }
                 const _t2 = JSON.stringify(subType, null, 2).replaceAll('\n', '\n' + spaces);
-                out += `${spaces}if (!inspectType(${keyName}, ${_t2}, '${_loc}', '${name}')) {\n`;
+                if (templates) {
+                  out += `${spaces}if (!inspectTypeWithTemplates(${keyName}, ${_t2}, '${_loc}', '${name}', rtiTemplates)) {\n`;
+                } else {
+                  out += `${spaces}if (!inspectType(${keyName}, ${_t2}, '${_loc}', '${name}')) {\n`;
+                }
                 out += `${spaces}  youCanAddABreakpointHere();\n${spaces}}\n`;
               }
               continue;
@@ -3184,7 +3396,11 @@ class Asserter extends Stringifier {
         out += '\n';
         first = false;
       }
-      out += `${spaces}if (${prevCheck}!inspectType(${name}, ${t}, '${_loc3}', '${name}')) {\n`;
+      if (templates) {
+        out += `${spaces}if (${prevCheck}!inspectTypeWithTemplates(${name}, ${t}, '${_loc3}', '${name}', rtiTemplates)) {\n`;
+      } else {
+        out += `${spaces}if (${prevCheck}!inspectType(${name}, ${t}, '${_loc3}', '${name}')) {\n`;
+      }
       out += `${spaces}  youCanAddABreakpointHere();\n${spaces}}\n`;
     }
     return out;
@@ -3710,4 +3926,4 @@ function toSourceBabelTS(node) {
   }
 }
 
-export { Asserter, Stringifier, addTypeChecks, ast2json, ast2jsonForComparison, code2ast2code, compareAST, expandType, expandTypeBabelTS, expandTypeDepFree, extractCurlyContent, extractNameAndOptionality, nodeIsFunction, parseJSDoc, parseJSDocSetter, 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, requiredTypeofs, simplifyType, toSourceBabelTS, toSourceTS, trimEndSpaces };