@runtime-type-inspector/transpiler 2.2.0 → 2.2.2

package/index.cjs

@@ -345,6 +345,13 @@
 	      elements: elements.map(expandTypeDepFree)
 	    };
 	  }
+	  if (type.startsWith('typeof ')) {
+	    var argument = expandTypeDepFree(type.substring(7));
+	    return {
+	      type: 'typeof',
+	      argument: argument
+	    };
+	  }
 	  if (type === 'object' || type === 'Object') {
 	    return {
 	      type: 'object',
@@ -541,6 +548,9 @@
 	        } else {
 	          warn("not an extensible type", lastTypedef);
 	        }
+	      } else if (line.startsWith('@callback')) {
+	        var _name2 = line.substring(9).trim();
+	        typedefs[_name2] = 'Function';
 	      }
 	    }
 	  } catch (err) {
@@ -646,6 +656,14 @@
 	      if (dedicatedLine) {
 	        out += spaces;
 	      }
+	      var multiLine = loc.start.line !== loc.end.line;
+	      if (multiLine) {
+	        var _this$parents$at;
+	        if (((_this$parents$at = this.parents.at(-2)) === null || _this$parents$at === void 0 ? void 0 : _this$parents$at.type) === 'AssignmentExpression') {
+	          spaces += '  ';
+	        }
+	        out += '\n' + spaces;
+	      }
 	      out += '/*';
 	      if (value.includes('\n')) {
 	        value = trimEndSpaces(value.replace(/^\s*\*/gm, '*')).split('\n').filter(function (_) {
@@ -1021,12 +1039,21 @@
 	        id = node.id,
 	        params = node.params;
 	      var out = '';
+	      if (node.leadingComments) {
+	        if (this.parentType === 'AssignmentExpression') {
+	          this.numSpaces++;
+	        }
+	        out += '\n' + this.spaces;
+	      }
 	      if (async) {
 	        out += 'async ';
 	      }
 	      var star = generator ? '*' : '';
 	      out += 'function' + star + ' ' + this.toSource(id) + this.FunctionDeclarationParams(params);
 	      out += this.toSource(body);
+	      if (node.leadingComments && this.parentType === 'AssignmentExpression') {
+	        this.numSpaces--;
+	      }
 	      return out;
 	    }
 	  }, {
@@ -1426,26 +1453,51 @@
 	    value: function ExportAllDeclaration(node) {
 	      return "export * from ".concat(node.source.extra.raw, ";");
 	    }
+	  }, {
+	    key: "ExportNamespaceSpecifier",
+	    value: function ExportNamespaceSpecifier(node) {
+	      var exported = node.exported;
+	      return '* as ' + this.toSource(exported);
+	    }
 	  }, {
 	    key: "ExportNamedDeclaration",
 	    value: function ExportNamedDeclaration(node) {
 	      var _this3 = this;
 	      var declaration = node.declaration,
 	        source = node.source,
-	        specifiers = node.specifiers;
+	        specifiers = node.specifiers,
+	        loc = node.loc;
 	      var out = this.spaces;
 	      if (specifiers.length) {
-	        out += 'export {\n';
-	        out += this.mapToSource(specifiers).map(function (_) {
-	          return "  ".concat(_this3.spaces).concat(_);
-	        }).join(',\n');
-	        out += '\n';
-	        out += this.spaces;
-	        out += '}';
-	        if (source) {
-	          out += " from " + this.toSource(source);
+	        if (!source) {
+	          console.warn("ExportNamedDeclaration> no source given");
+	        }
+	        if (specifiers.length === 1 && specifiers[0].type === 'ExportNamespaceSpecifier') {
+	          out += 'export ';
+	          out += this.toSource(specifiers[0]);
+	          out += ' from ';
+	          out += this.toSource(source);
+	          out += ";";
+	        } else {
+	          var sameLine = loc.start.line === loc.end.line;
+	          if (sameLine) {
+	            out += 'export {';
+	            out += this.mapToSource(specifiers).join(', ');
+	            out += '}';
+	          } else {
+	            out += 'export {\n';
+	            out += this.mapToSource(specifiers).map(function (_) {
+	              return "  ".concat(_this3.spaces).concat(_);
+	            }).join(',\n');
+	            out += '\n';
+	            out += this.spaces;
+	            out += '}';
+	          }
+	          if (source) {
+	            out += " from " + this.toSource(source);
+	          }
+	          out += ";\n";
 	        }
-	        out += ";\n";
 	      } else if (declaration) {
 	        out += 'export ' + this.toSource(declaration);
 	      } else {
@@ -2000,9 +2052,6 @@
 	      i--;
 	      while (i >= 0) {
 	        parent = parents[i];
-	        if (parent.type === 'CallExpression') {
-	          break;
-	        }
 	        if (nodeIsFunction(parent)) {
 	          break;
 	        }
@@ -2021,37 +2070,49 @@
 	      }
 	      (_console = console).warn.apply(_console, arguments);
 	    }
+	  }, {
+	    key: "getLeadingCommentsNodeForFunctionExpression",
+	    value: function getLeadingCommentsNodeForFunctionExpression(node) {
+	      var parents = this.parents;
+	      var i = parents.findLastIndex(function (_) {
+	        return _ === node;
+	      });
+	      var parent = parents[i];
+	      if (parent.leadingComments) {
+	        return parent;
+	      }
+	      i--;
+	      while (i >= 0) {
+	        parent = parents[i];
+	        if (nodeIsFunction(parent)) {
+	          break;
+	        }
+	        if (parent.leadingComments) {
+	          return parent;
+	        }
+	        i--;
+	      }
+	    }
 	  }, {
 	    key: "getJSDoc",
 	    value: function getJSDoc(node) {
 	      if (node.type === 'BlockStatement') {
 	        node = this.parent;
 	      }
-	      if (node.type === 'FunctionExpression') {
-	        if (node.leadingComments) {
-	          this.warn("Case of FunctionExpression containing its own leadingComments is not handled");
-	          return;
-	        }
-	        node = this.findParentOfType(node, 'ExpressionStatement');
-	        if (!node) {
-	          node = this.parents.findLast(function (_) {
-	            return _.type === 'VariableDeclaration';
-	          });
-	          if (!node) {
-	            return;
-	          }
-	        }
-	      }
 	      var _node = node,
 	        leadingComments = _node.leadingComments;
+	      if (node.type === 'FunctionExpression') {
+	        var tmp = this.getLeadingCommentsNodeForFunctionExpression(node);
+	        leadingComments = tmp === null || tmp === void 0 ? void 0 : tmp.leadingComments;
+	      }
 	      if (!leadingComments) {
 	        if (node.type === 'FunctionDeclaration') {
 	          var exportNamedDeclaration = this.findParentOfType(node, 'ExportNamedDeclaration');
 	          leadingComments = exportNamedDeclaration === null || exportNamedDeclaration === void 0 ? void 0 : exportNamedDeclaration.leadingComments;
 	        }
 	        if (node.type === 'ArrowFunctionExpression') {
-	          var tmp = this.getLeadingCommentsNodeForArrowFunctionExpression(node);
-	          leadingComments = tmp === null || tmp === void 0 ? void 0 : tmp.leadingComments;
+	          var _tmp = this.getLeadingCommentsNodeForArrowFunctionExpression(node);
+	          leadingComments = _tmp === null || _tmp === void 0 ? void 0 : _tmp.leadingComments;
 	        }
 	      }
 	      if (leadingComments && leadingComments.length) {
@@ -2279,6 +2340,23 @@
 	      }
 	      return out;
 	    }
+	  }, {
+	    key: "getNameForFunctionExpression",
+	    value: function getNameForFunctionExpression(node) {
+	      var objectProperty = this.findParentOfType(node, 'ObjectProperty');
+	      if (objectProperty) {
+	        return this.toSource(objectProperty.key);
+	      }
+	      var expressionStatement = this.findParentOfType(node, 'ExpressionStatement');
+	      if (expressionStatement) {
+	        var left = expressionStatement.expression.left;
+	        if (left) {
+	          return this.toSource(left);
+	        }
+	        console.warn("Asserter#getNameForFunctionExpression> expression without left");
+	      }
+	      return 'unnamed function expression';
+	    }
 	  }, {
 	    key: "getName",
 	    value: function getName(node) {
@@ -2308,11 +2386,7 @@
 	          if (id) {
 	            return toSource(id);
 	          }
-	          var expressionStatement = this.findParentOfType(node, 'ExpressionStatement');
-	          if (!expressionStatement) {
-	            return 'unnamed function expression';
-	          }
-	          return toSource(expressionStatement.expression.left);
+	          return this.getNameForFunctionExpression(node);
 	        case 'ArrowFunctionExpression':
 	          var parent = this.findParentOfType(node, 'VariableDeclarator');
 	          if (parent) {
@@ -2491,7 +2565,11 @@
 	    ConditionalType = _ts$SyntaxKind.ConditionalType,
 	    IndexedAccessType = _ts$SyntaxKind.IndexedAccessType,
 	    RestType = _ts$SyntaxKind.RestType,
-	    ConstructorType = _ts$SyntaxKind.ConstructorType;
+	    TypeQuery = _ts$SyntaxKind.TypeQuery,
+	    TypeOperator = _ts$SyntaxKind.TypeOperator,
+	    KeyOfKeyword = _ts$SyntaxKind.KeyOfKeyword,
+	    ConstructorType = _ts$SyntaxKind.ConstructorType,
+	    NamedTupleMember = _ts$SyntaxKind.NamedTupleMember;
 	  switch (node.kind) {
 	    case BigIntKeyword:
 	      return {
@@ -2565,6 +2643,21 @@
 	        };
 	      }
 	      return ret;
+	    case TypeQuery:
+	      var argument = toSourceTS(node.exprName);
+	      return {
+	        type: 'typeof',
+	        argument: argument
+	      };
+	    case TypeOperator:
+	      if (node.operator === KeyOfKeyword) {
+	        var _argument = toSourceTS(node.type);
+	        return {
+	          type: 'keyof',
+	          argument: _argument
+	        };
+	      }
+	      console.warn("unimplemented TypeOperator", node);
 	    case TypeReference:
 	      {
 	        if ((typeName.text === 'Object' || typeName.text === 'Record') && (typeArguments === null || typeArguments === void 0 ? void 0 : typeArguments.length) === 2) {
@@ -2626,6 +2719,8 @@
 	      return node.getText();
 	    case NumberKeyword:
 	      return node.getText();
+	    case NamedTupleMember:
+	      return toSourceTS(node.type);
 	    case IntersectionType:
 	      return {
 	        type: 'intersection',
@@ -2845,6 +2940,12 @@
 	      return toSourceBabelTS(node.type);
 	    case 'LastTypeNode':
 	      return toSourceBabelTS(node.qualifier);
+	    case 'TSTypeQuery':
+	      var argument = toSourceBabelTS(node.exprName);
+	      return {
+	        type: 'typeof',
+	        argument: argument
+	      };
 	    default:
 	      console.warn('toSourceBabelTS> unhandled type', node.type, node);
 	      debugger;

package/index.mjs

@@ -81,6 +81,13 @@ function expandTypeDepFree(type) {
       elements: elements.map(expandTypeDepFree)
     };
   }
+  if (type.startsWith('typeof ')) {
+    const argument = expandTypeDepFree(type.substring(7));
+    return {
+      type: 'typeof',
+      argument
+    };
+  }
   if (type === 'object' || type === 'Object') {
     return {
       type: 'object',
@@ -270,6 +277,9 @@ function parseJSDocTypedef(typedefs, warn, comment, expandType) {
       } else {
         warn("not an extensible type", lastTypedef);
       }
+    } else if (line.startsWith('@callback')) {
+      const name = line.substring(9).trim();
+      typedefs[name] = 'Function';
     }
   }
 }
@@ -363,7 +373,7 @@ class Stringifier {
       return '';
     }
     this.lastCommentBlockIndex = loc.start.index;
-    const {
+    let {
       spaces
     } = this;
     let out = '';
@@ -371,6 +381,14 @@ class Stringifier {
     if (dedicatedLine) {
       out += spaces;
     }
+    const multiLine = loc.start.line !== loc.end.line;
+    if (multiLine) {
+      var _this$parents$at;
+      if (((_this$parents$at = this.parents.at(-2)) == null ? void 0 : _this$parents$at.type) === 'AssignmentExpression') {
+        spaces += '  ';
+      }
+      out += '\n' + spaces;
+    }
     out += '/*';
     if (value.includes('\n')) {
       value = trimEndSpaces(value.replace(/^\s*\*/gm, '*')).split('\n').filter(_ => _.length).map((line, i) => (i ? spaces + ' ' : '') + line).join('\n');
@@ -709,12 +727,21 @@ class Stringifier {
       params
     } = node;
     let out = '';
+    if (node.leadingComments) {
+      if (this.parentType === 'AssignmentExpression') {
+        this.numSpaces++;
+      }
+      out += '\n' + this.spaces;
+    }
     if (async) {
       out += 'async ';
     }
     const star = generator ? '*' : '';
     out += 'function' + star + ' ' + this.toSource(id) + this.FunctionDeclarationParams(params);
     out += this.toSource(body);
+    if (node.leadingComments && this.parentType === 'AssignmentExpression') {
+      this.numSpaces--;
+    }
     return out;
   }
   ArrowFunctionExpression(node) {
@@ -1112,23 +1139,48 @@ class Stringifier {
   ExportAllDeclaration(node) {
     return `export * from ${node.source.extra.raw};`;
   }
+  ExportNamespaceSpecifier(node) {
+    const {
+      exported
+    } = node;
+    return '* as ' + this.toSource(exported);
+  }
   ExportNamedDeclaration(node) {
     const {
       declaration,
       source,
-      specifiers
+      specifiers,
+      loc
     } = node;
     let out = this.spaces;
     if (specifiers.length) {
-      out += 'export {\n';
-      out += this.mapToSource(specifiers).map(_ => `  ${this.spaces}${_}`).join(',\n');
-      out += '\n';
-      out += this.spaces;
-      out += '}';
-      if (source) {
-        out += " from " + this.toSource(source);
+      if (!source) {
+        console.warn("ExportNamedDeclaration> no source given");
+      }
+      if (specifiers.length === 1 && specifiers[0].type === 'ExportNamespaceSpecifier') {
+        out += 'export ';
+        out += this.toSource(specifiers[0]);
+        out += ' from ';
+        out += this.toSource(source);
+        out += ";";
+      } else {
+        const sameLine = loc.start.line === loc.end.line;
+        if (sameLine) {
+          out += 'export {';
+          out += this.mapToSource(specifiers).join(', ');
+          out += '}';
+        } else {
+          out += 'export {\n';
+          out += this.mapToSource(specifiers).map(_ => `  ${this.spaces}${_}`).join(',\n');
+          out += '\n';
+          out += this.spaces;
+          out += '}';
+        }
+        if (source) {
+          out += " from " + this.toSource(source);
+        }
+        out += ";\n";
       }
-      out += ";\n";
     } else if (declaration) {
       out += 'export ' + this.toSource(declaration);
     } else {
@@ -1666,9 +1718,6 @@ class Asserter extends Stringifier {
     i--;
     while (i >= 0) {
       parent = parents[i];
-      if (parent.type === 'CallExpression') {
-        break;
-      }
       if (nodeIsFunction(parent)) {
         break;
       }
@@ -1684,26 +1733,38 @@ class Asserter extends Stringifier {
     }
     console.warn(...args);
   }
-  getJSDoc(node) {
-    if (node.type === 'BlockStatement') {
-      node = this.parent;
+  getLeadingCommentsNodeForFunctionExpression(node) {
+    const {
+      parents
+    } = this;
+    let i = parents.findLastIndex(_ => _ === node);
+    let parent = parents[i];
+    if (parent.leadingComments) {
+      return parent;
     }
-    if (node.type === 'FunctionExpression') {
-      if (node.leadingComments) {
-        this.warn("Case of FunctionExpression containing its own leadingComments is not handled");
-        return;
+    i--;
+    while (i >= 0) {
+      parent = parents[i];
+      if (nodeIsFunction(parent)) {
+        break;
       }
-      node = this.findParentOfType(node, 'ExpressionStatement');
-      if (!node) {
-        node = this.parents.findLast(_ => _.type === 'VariableDeclaration');
-        if (!node) {
-          return;
-        }
+      if (parent.leadingComments) {
+        return parent;
       }
+      i--;
+    }
+  }
+  getJSDoc(node) {
+    if (node.type === 'BlockStatement') {
+      node = this.parent;
     }
     let {
       leadingComments
     } = node;
+    if (node.type === 'FunctionExpression') {
+      const tmp = this.getLeadingCommentsNodeForFunctionExpression(node);
+      leadingComments = tmp == null ? void 0 : tmp.leadingComments;
+    }
     if (!leadingComments) {
       if (node.type === 'FunctionDeclaration') {
         const exportNamedDeclaration = this.findParentOfType(node, 'ExportNamedDeclaration');
@@ -1918,6 +1979,23 @@ class Asserter extends Stringifier {
     }
     return out;
   }
+  getNameForFunctionExpression(node) {
+    const objectProperty = this.findParentOfType(node, 'ObjectProperty');
+    if (objectProperty) {
+      return this.toSource(objectProperty.key);
+    }
+    const expressionStatement = this.findParentOfType(node, 'ExpressionStatement');
+    if (expressionStatement) {
+      const {
+        left
+      } = expressionStatement.expression;
+      if (left) {
+        return this.toSource(left);
+      }
+      console.warn("Asserter#getNameForFunctionExpression> expression without left");
+    }
+    return 'unnamed function expression';
+  }
   getName(node) {
     const toSource = this.toSource.bind(this);
     if (node.type === 'BlockStatement') {
@@ -1944,11 +2022,7 @@ class Asserter extends Stringifier {
         if (id) {
           return toSource(id);
         }
-        const expressionStatement = this.findParentOfType(node, 'ExpressionStatement');
-        if (!expressionStatement) {
-          return 'unnamed function expression';
-        }
-        return toSource(expressionStatement.expression.left);
+        return this.getNameForFunctionExpression(node);
       case 'ArrowFunctionExpression':
         const parent = this.findParentOfType(node, 'VariableDeclarator');
         if (parent) {
@@ -2118,7 +2192,11 @@ function toSourceTS(node) {
     ConditionalType,
     IndexedAccessType,
     RestType,
-    ConstructorType
+    TypeQuery,
+    TypeOperator,
+    KeyOfKeyword,
+    ConstructorType,
+    NamedTupleMember
   } = ts.SyntaxKind;
   switch (node.kind) {
     case BigIntKeyword:
@@ -2193,6 +2271,21 @@ function toSourceTS(node) {
         };
       }
       return ret;
+    case TypeQuery:
+      const argument = toSourceTS(node.exprName);
+      return {
+        type: 'typeof',
+        argument
+      };
+    case TypeOperator:
+      if (node.operator === KeyOfKeyword) {
+        const _argument = toSourceTS(node.type);
+        return {
+          type: 'keyof',
+          argument: _argument
+        };
+      }
+      console.warn("unimplemented TypeOperator", node);
     case TypeReference:
       {
         if ((typeName.text === 'Object' || typeName.text === 'Record') && (typeArguments == null ? void 0 : typeArguments.length) === 2) {
@@ -2254,6 +2347,8 @@ function toSourceTS(node) {
       return node.getText();
     case NumberKeyword:
       return node.getText();
+    case NamedTupleMember:
+      return toSourceTS(node.type);
     case IntersectionType:
       return {
         type: 'intersection',
@@ -2473,6 +2568,12 @@ function toSourceBabelTS(node) {
       return toSourceBabelTS(node.type);
     case 'LastTypeNode':
       return toSourceBabelTS(node.qualifier);
+    case 'TSTypeQuery':
+      const argument = toSourceBabelTS(node.exprName);
+      return {
+        type: 'typeof',
+        argument
+      };
     default:
       console.warn('toSourceBabelTS> unhandled type', node.type, node);
       debugger;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@runtime-type-inspector/transpiler",
-  "version": "2.2.0",
+  "version": "2.2.2",
   "description": "Validating JSDoc types at runtime for high-quality types - Trust is good, control is better.",
   "main": "index.cjs",
   "module": "index.mjs",