svelte

tools/parse_ts.js

@@ -1,9 +1,10 @@
 #!/usr/bin/env node
+// Enhanced TypeScript/JavaScript AST parser
 // Usage: node parse_ts.js file.ts
 
-const fs = require('fs');
-const path = require('path');
-const { parse } = require('@typescript-eslint/typescript-estree');
+const fs = require("fs");
+const path = require("path");
+const { parse } = require("@typescript-eslint/typescript-estree");
 
 function getLoc(node) {
   if (node.loc) {
@@ -14,139 +15,459 @@ function getLoc(node) {
 
 function extractLeadingComment(node, sourceCode) {
   if (!node.range || !sourceCode) return "";
+
   const startIdx = node.range[0];
-  let commentEnd = startIdx;
-  // Look backward for comments
-  let i = startIdx - 1;
-  let commentLines = [];
-  let inBlock = false;
 
-  while (i >= 0) {
-    const char = sourceCode[i];
-    if (char === '\n') break;
-    i--;
-  }
-  const lineStart = i + 1;
-  const lineAbove = sourceCode.slice(lineStart, startIdx).trim();
-
-  // Check for // comment on same line before node
-  if (lineAbove.startsWith('//')) {
-    return lineAbove.substring(2).trim();
+  // Find the start of the line containing the node
+  let lineStart = startIdx;
+  while (lineStart > 0 && sourceCode[lineStart - 1] !== "\n") {
+    lineStart--;
   }
 
-  // Look further up for multi-line or JSDoc
-  const lines = sourceCode.substring(0, lineStart).split('\n');
-  for (let j = lines.length - 1; j >= Math.max(0, lines.length - 5); j--) {
-    const line = lines[j].trim();
-    if (line.startsWith('//')) {
-      commentLines.unshift(line.substring(2).trim());
-    } else if (line.endsWith('*/')) {
-      inBlock = true;
-      commentLines.unshift(line.slice(0, -2).trim());
-    } else if (inBlock) {
-      if (line.startsWith('/*') || line.startsWith('/**')) {
-        commentLines.unshift(line.slice(2).trim());
+  // Check for inline comment on the same line
+  const lineContent = sourceCode.slice(lineStart, startIdx).trim();
+  if (lineContent.startsWith("//")) {
+    return lineContent.substring(2).trim();
+  }
+
+  // Look backward through previous lines for comments
+  const lines = sourceCode.substring(0, lineStart).split("\n");
+  const commentLines = [];
+  let inBlockComment = false;
+
+  for (let i = lines.length - 1; i >= Math.max(0, lines.length - 10); i--) {
+    const line = lines[i].trim();
+
+    if (line.endsWith("*/")) {
+      // End of block comment found
+      inBlockComment = true;
+      const blockContent = line
+        .slice(0, -2)
+        .replace(/^\*+\s*/, "")
+        .trim();
+      if (blockContent) {
+        commentLines.unshift(blockContent);
+      }
+    } else if (inBlockComment) {
+      if (line.startsWith("/*") || line.startsWith("/**")) {
+        // Start of block comment found
+        const blockContent = line
+          .substring(line.indexOf("/*") + 2)
+          .replace(/^\*+\s*/, "")
+          .trim();
+        if (blockContent) {
+          commentLines.unshift(blockContent);
+        }
         break;
       } else {
-        commentLines.unshift(line);
+        // Inside block comment
+        const blockContent = line.replace(/^\*+\s*/, "").trim();
+        if (blockContent) {
+          commentLines.unshift(blockContent);
+        }
+      }
+    } else if (line.startsWith("//")) {
+      // Single-line comment
+      commentLines.unshift(line.substring(2).trim());
+    } else if (line === "") {
+      // Empty line - continue if we already have comments
+      if (commentLines.length === 0) {
+        break;
       }
-    } else if (line === '') {
-      if (commentLines.length > 0) continue;
-      else break;
     } else {
+      // Non-comment, non-empty line - stop looking
       break;
     }
   }
-  return commentLines.join('\n').trim();
+
+  return commentLines.join("\n").trim();
+}
+
+function extractTypeInfo(node) {
+  const typeInfo = {};
+
+  // Extract type annotation
+  if (node.typeAnnotation) {
+    typeInfo.returnType = extractTypeString(node.typeAnnotation.typeAnnotation);
+  }
+
+  // Extract parameters for functions
+  if (node.params) {
+    typeInfo.parameters = node.params.map((param) => {
+      const paramInfo = {
+        name: extractParamName(param),
+        type: param.typeAnnotation
+          ? extractTypeString(param.typeAnnotation.typeAnnotation)
+          : "any",
+      };
+      if (param.optional) {
+        paramInfo.optional = true;
+      }
+      return paramInfo;
+    });
+  }
+
+  // Extract generics
+  if (node.typeParameters) {
+    typeInfo.generics = node.typeParameters.params.map((tp) => tp.name.name);
+  }
+
+  return typeInfo;
+}
+
+function extractParamName(param) {
+  if (param.type === "Identifier") {
+    return param.name;
+  }
+  if (param.type === "RestElement" && param.argument.type === "Identifier") {
+    return "..." + param.argument.name;
+  }
+  if (param.type === "AssignmentPattern" && param.left.type === "Identifier") {
+    return param.left.name;
+  }
+  return "unknown";
+}
+
+function extractTypeString(typeNode) {
+  if (!typeNode) return "any";
+
+  switch (typeNode.type) {
+    case "TSStringKeyword":
+      return "string";
+    case "TSNumberKeyword":
+      return "number";
+    case "TSBooleanKeyword":
+      return "boolean";
+    case "TSAnyKeyword":
+      return "any";
+    case "TSVoidKeyword":
+      return "void";
+    case "TSUndefinedKeyword":
+      return "undefined";
+    case "TSNullKeyword":
+      return "null";
+    case "TSTypeReference":
+      if (typeNode.typeName.type === "Identifier") {
+        let typeStr = typeNode.typeName.name;
+        if (typeNode.typeParameters) {
+          const params = typeNode.typeParameters.params
+            .map(extractTypeString)
+            .join(", ");
+          typeStr += `<${params}>`;
+        }
+        return typeStr;
+      }
+      return "unknown";
+    case "TSArrayType":
+      return extractTypeString(typeNode.elementType) + "[]";
+    case "TSUnionType":
+      return typeNode.types.map(extractTypeString).join(" | ");
+    case "TSIntersectionType":
+      return typeNode.types.map(extractTypeString).join(" & ");
+    case "TSFunctionType":
+      return "Function";
+    case "TSTypeLiteral":
+      return "object";
+    default:
+      return "unknown";
+  }
 }
 
 function extractDeclarations(ast, sourceCode) {
   const decls = [];
+  const parentMap = new WeakMap();
 
-  function visit(node) {
-    if (!node || typeof node !== 'object') return;
+  function setParents(node, parent = null) {
+    if (!node || typeof node !== "object") return;
 
     if (Array.isArray(node)) {
-      node.forEach(n => visit(n));
+      node.forEach((n) => setParents(n, parent));
       return;
     }
 
-    let docComment = extractLeadingComment(node, sourceCode);
+    parentMap.set(node, parent);
+    Object.values(node).forEach((child) => setParents(child, node));
+  }
+
+  setParents(ast);
+
+  function visit(node) {
+    if (!node || typeof node !== "object") return;
+
+    if (Array.isArray(node)) {
+      node.forEach((n) => visit(n));
+      return;
+    }
+
+    const docComment = extractLeadingComment(node, sourceCode);
+    const loc = getLoc(node);
+
+    // Function Declarations
+    if (node.type === "FunctionDeclaration" && node.id?.name) {
+      const typeInfo = extractTypeInfo(node);
 
-    if (node.type === 'FunctionDeclaration' && node.id?.name) {
-      const loc = getLoc(node);
       decls.push({
         name: node.id.name,
-        type: 'function',
+        type: "function",
         doc_comment: docComment,
         start_line: loc.start,
-        end_line: loc.end
+        end_line: loc.end,
+        is_async: node.async || false,
+        is_generator: node.generator || false,
+        ...typeInfo,
       });
     }
+    // Arrow Functions assigned to variables
     else if (
-      node.type === 'VariableDeclarator' &&
-      node.id?.type === 'Identifier' &&
-      node.init?.type === 'ArrowFunctionExpression'
+      node.type === "VariableDeclarator" &&
+      node.id?.type === "Identifier" &&
+      node.init?.type === "ArrowFunctionExpression"
     ) {
-      const loc = getLoc(node);
+      const typeInfo = extractTypeInfo(node.init);
+
       decls.push({
         name: node.id.name,
-        type: 'function',
+        type: "function",
         doc_comment: docComment,
         start_line: loc.start,
-        end_line: loc.end
+        end_line: loc.end,
+        is_async: node.init.async || false,
+        is_arrow: true,
+        ...typeInfo,
       });
     }
-    else if (node.type === 'ClassDeclaration' && node.id?.name) {
-      const loc = getLoc(node);
+    // Class Declarations
+    else if (node.type === "ClassDeclaration" && node.id?.name) {
+      const classInfo = {
+        name: node.id.name,
+        type: "class",
+        doc_comment: docComment,
+        start_line: loc.start,
+        end_line: loc.end,
+        is_abstract: node.abstract || false,
+      };
+
+      // Extract extends
+      if (node.superClass) {
+        if (node.superClass.type === "Identifier") {
+          classInfo.extends = node.superClass.name;
+        }
+      }
+
+      // Extract implements
+      if (node.implements && node.implements.length > 0) {
+        classInfo.implements = node.implements.map(
+          (impl) => impl.expression.name || "unknown",
+        );
+      }
+
+      // Extract generics
+      if (node.typeParameters) {
+        classInfo.generics = node.typeParameters.params.map(
+          (tp) => tp.name.name,
+        );
+      }
+
+      // Extract methods and properties
+      const methods = [];
+      const properties = [];
+
+      if (node.body && node.body.body) {
+        for (const member of node.body.body) {
+          if (member.type === "MethodDefinition" && member.key?.name) {
+            methods.push(member.key.name);
+          } else if (member.type === "PropertyDefinition" && member.key?.name) {
+            properties.push(member.key.name);
+          }
+        }
+      }
+
+      if (methods.length > 0) {
+        classInfo.methods = methods;
+      }
+      if (properties.length > 0) {
+        classInfo.properties = properties;
+      }
+
+      decls.push(classInfo);
+    }
+    // Interface Declarations
+    else if (node.type === "TSInterfaceDeclaration" && node.id?.name) {
+      const interfaceInfo = {
+        name: node.id.name,
+        type: "interface",
+        doc_comment: docComment,
+        start_line: loc.start,
+        end_line: loc.end,
+      };
+
+      // Extract extends
+      if (node.extends && node.extends.length > 0) {
+        interfaceInfo.extends = node.extends.map(
+          (ext) => ext.expression.name || "unknown",
+        );
+      }
+
+      // Extract generics
+      if (node.typeParameters) {
+        interfaceInfo.generics = node.typeParameters.params.map(
+          (tp) => tp.name.name,
+        );
+      }
+
+      // Extract properties/methods
+      const properties = [];
+      const methods = [];
+
+      if (node.body && node.body.body) {
+        for (const member of node.body.body) {
+          if (member.type === "TSPropertySignature" && member.key?.name) {
+            properties.push(member.key.name);
+          } else if (member.type === "TSMethodSignature" && member.key?.name) {
+            methods.push(member.key.name);
+          }
+        }
+      }
+
+      if (properties.length > 0) {
+        interfaceInfo.properties = properties;
+      }
+      if (methods.length > 0) {
+        interfaceInfo.methods = methods;
+      }
+
+      decls.push(interfaceInfo);
+    }
+    // Type Alias Declarations
+    else if (node.type === "TSTypeAliasDeclaration" && node.id?.name) {
+      const typeInfo = {
+        name: node.id.name,
+        type: "type",
+        doc_comment: docComment,
+        start_line: loc.start,
+        end_line: loc.end,
+      };
+
+      // Extract generics
+      if (node.typeParameters) {
+        typeInfo.generics = node.typeParameters.params.map(
+          (tp) => tp.name.name,
+        );
+      }
+
+      // Extract type definition
+      if (node.typeAnnotation) {
+        typeInfo.type_definition = extractTypeString(node.typeAnnotation);
+      }
+
+      decls.push(typeInfo);
+    }
+    // Enum Declarations
+    else if (node.type === "TSEnumDeclaration" && node.id?.name) {
+      const members = [];
+
+      if (node.members) {
+        for (const member of node.members) {
+          if (member.id?.type === "Identifier") {
+            members.push(member.id.name);
+          }
+        }
+      }
+
       decls.push({
         name: node.id.name,
-        type: 'class',
+        type: "enum",
         doc_comment: docComment,
         start_line: loc.start,
-        end_line: loc.end
-      });
-    }
-    else if (node.type === 'TSInterfaceDeclaration' && node.id?.name) {
-      const loc = getLoc(node);
-      decls.push({
-        name: node.id.name,
-        type: 'interface',
-        doc_comment: docComment,
-        start_line: loc.start,
-        end_line: loc.end
-      });
-    }
-    else if (node.type === 'TSTypeAliasDeclaration' && node.id?.name) {
-      const loc = getLoc(node);
-      decls.push({
-        name: node.id.name,
-        type: 'type',
-        doc_comment: docComment,
-        start_line: loc.start,
-        end_line: loc.end
+        end_line: loc.end,
+        members: members,
       });
     }
+    // Variable Declarations (const, let, var)
     else if (
-      node.type === 'VariableDeclarator' &&
-      node.id?.type === 'Identifier'
+      node.type === "VariableDeclarator" &&
+      node.id?.type === "Identifier"
     ) {
-      const parent = node.parent;
-      if (
-        parent?.type === 'VariableDeclaration' &&
-        ['const', 'let'].includes(parent.kind)
-      ) {
-        const loc = getLoc(node);
-        decls.push({
+      const parent = parentMap.get(node);
+
+      if (parent?.type === "VariableDeclaration") {
+        const varInfo = {
           name: node.id.name,
-          type: 'variable',
+          type: "variable",
           doc_comment: docComment,
           start_line: loc.start,
-          end_line: loc.end
-        });
+          end_line: loc.end,
+          var_kind: parent.kind, // const, let, or var
+        };
+
+        // Extract type annotation
+        if (node.id.typeAnnotation) {
+          varInfo.var_type = extractTypeString(
+            node.id.typeAnnotation.typeAnnotation,
+          );
+        }
+
+        decls.push(varInfo);
+      }
+    }
+    // Import Declarations
+    else if (node.type === "ImportDeclaration" && node.source?.value) {
+      const importInfo = {
+        name: node.source.value,
+        type: "import",
+        start_line: loc.start,
+        end_line: loc.end,
+        import_path: node.source.value,
+      };
+
+      // Extract imported names
+      const imports = [];
+      if (node.specifiers) {
+        for (const spec of node.specifiers) {
+          if (spec.type === "ImportSpecifier" && spec.imported?.name) {
+            imports.push(spec.imported.name);
+          } else if (
+            spec.type === "ImportDefaultSpecifier" &&
+            spec.local?.name
+          ) {
+            imports.push(`default as ${spec.local.name}`);
+          } else if (
+            spec.type === "ImportNamespaceSpecifier" &&
+            spec.local?.name
+          ) {
+            imports.push(`* as ${spec.local.name}`);
+          }
+        }
+      }
+
+      if (imports.length > 0) {
+        importInfo.imported_names = imports;
+      }
+
+      decls.push(importInfo);
+    }
+    // Export Declarations
+    else if (node.type === "ExportNamedDeclaration") {
+      if (node.declaration) {
+        // Export with declaration: export const x = ...
+        visit(node.declaration);
+      } else if (node.specifiers && node.specifiers.length > 0) {
+        // Named exports: export { x, y }
+        for (const spec of node.specifiers) {
+          if (spec.exported?.name) {
+            decls.push({
+              name: spec.exported.name,
+              type: "export",
+              start_line: loc.start,
+              end_line: loc.end,
+              export_kind: "named",
+            });
+          }
+        }
       }
     }
 
+    // Continue traversing
     Object.values(node).forEach(visit);
   }
 
@@ -154,24 +475,29 @@ function extractDeclarations(ast, sourceCode) {
   return decls;
 }
 
+// Main execution
 if (process.argv.length < 3) {
-  console.error('Usage: node parse_ts.js <file.ts>');
+  console.error("Usage: node parse_ts.js <file.ts|file.js>");
   process.exit(1);
 }
 
 const filePath = path.resolve(process.argv[2]);
 
 try {
-  const code = fs.readFileSync(filePath, 'utf8');
+  const code = fs.readFileSync(filePath, "utf8");
   const ast = parse(code, {
-    sourceType: 'module',
+    sourceType: "module",
     loc: true,
     range: true,
-    comment: false // we extract manually for simplicity
+    comment: false,
+    ecmaFeatures: {
+      jsx: true,
+    },
   });
+
   const decls = extractDeclarations(ast, code);
   console.log(JSON.stringify(decls, null, 2));
 } catch (e) {
   console.error(`ERR: ${e.message}`);
   process.exit(2);
-}
+}