@optave/codegraph 3.1.5 → 3.2.0

package/src/extractors/javascript.js

@@ -320,333 +320,303 @@ function handleCommonJSAssignment(left, right, node, imports) {
 // ── Manual tree walk (fallback when Query not available) ────────────────────
 
 function extractSymbolsWalk(tree) {
-  const definitions = [];
-  const calls = [];
-  const imports = [];
-  const classes = [];
-  const exports = [];
-
-  function walkJavaScriptNode(node) {
-    switch (node.type) {
-      case 'function_declaration': {
-        const nameNode = node.childForFieldName('name');
-        if (nameNode) {
-          const fnChildren = extractParameters(node);
-          definitions.push({
-            name: nameNode.text,
-            kind: 'function',
-            line: node.startPosition.row + 1,
-            endLine: nodeEndLine(node),
-            children: fnChildren.length > 0 ? fnChildren : undefined,
-          });
-        }
-        break;
-      }
+  const ctx = {
+    definitions: [],
+    calls: [],
+    imports: [],
+    classes: [],
+    exports: [],
+  };
+
+  walkJavaScriptNode(tree.rootNode, ctx);
+  return ctx;
+}
 
-      case 'class_declaration': {
-        const nameNode = node.childForFieldName('name');
-        if (nameNode) {
-          const className = nameNode.text;
-          const startLine = node.startPosition.row + 1;
-          const clsChildren = extractClassProperties(node);
-          definitions.push({
-            name: className,
-            kind: 'class',
-            line: startLine,
-            endLine: nodeEndLine(node),
-            children: clsChildren.length > 0 ? clsChildren : undefined,
-          });
-          const heritage = node.childForFieldName('heritage') || findChild(node, 'class_heritage');
-          if (heritage) {
-            const superName = extractSuperclass(heritage);
-            if (superName) {
-              classes.push({ name: className, extends: superName, line: startLine });
-            }
-            const implementsList = extractImplements(heritage);
-            for (const iface of implementsList) {
-              classes.push({ name: className, implements: iface, line: startLine });
-            }
-          }
-        }
-        break;
-      }
+function walkJavaScriptNode(node, ctx) {
+  switch (node.type) {
+    case 'function_declaration':
+      handleFunctionDecl(node, ctx);
+      break;
+    case 'class_declaration':
+      handleClassDecl(node, ctx);
+      break;
+    case 'method_definition':
+      handleMethodDef(node, ctx);
+      break;
+    case 'interface_declaration':
+      handleInterfaceDecl(node, ctx);
+      break;
+    case 'type_alias_declaration':
+      handleTypeAliasDecl(node, ctx);
+      break;
+    case 'lexical_declaration':
+    case 'variable_declaration':
+      handleVariableDecl(node, ctx);
+      break;
+    case 'enum_declaration':
+      handleEnumDecl(node, ctx);
+      break;
+    case 'call_expression':
+      handleCallExpr(node, ctx);
+      break;
+    case 'import_statement':
+      handleImportStmt(node, ctx);
+      break;
+    case 'export_statement':
+      handleExportStmt(node, ctx);
+      break;
+    case 'expression_statement':
+      handleExpressionStmt(node, ctx);
+      break;
+  }
 
-      case 'method_definition': {
-        const nameNode = node.childForFieldName('name');
-        if (nameNode) {
-          const parentClass = findParentClass(node);
-          const fullName = parentClass ? `${parentClass}.${nameNode.text}` : nameNode.text;
-          const methChildren = extractParameters(node);
-          const methVis = extractVisibility(node);
-          definitions.push({
-            name: fullName,
-            kind: 'method',
-            line: node.startPosition.row + 1,
-            endLine: nodeEndLine(node),
-            children: methChildren.length > 0 ? methChildren : undefined,
-            visibility: methVis,
-          });
-        }
-        break;
-      }
+  for (let i = 0; i < node.childCount; i++) {
+    walkJavaScriptNode(node.child(i), ctx);
+  }
+}
 
-      case 'interface_declaration': {
-        const nameNode = node.childForFieldName('name');
-        if (nameNode) {
-          definitions.push({
-            name: nameNode.text,
-            kind: 'interface',
-            line: node.startPosition.row + 1,
-            endLine: nodeEndLine(node),
-          });
-          const body =
-            node.childForFieldName('body') ||
-            findChild(node, 'interface_body') ||
-            findChild(node, 'object_type');
-          if (body) {
-            extractInterfaceMethods(body, nameNode.text, definitions);
-          }
-        }
-        break;
-      }
+// ── Walk-path per-node-type handlers ────────────────────────────────────────
 
-      case 'type_alias_declaration': {
-        const nameNode = node.childForFieldName('name');
-        if (nameNode) {
-          definitions.push({
-            name: nameNode.text,
-            kind: 'type',
-            line: node.startPosition.row + 1,
-            endLine: nodeEndLine(node),
-          });
-        }
-        break;
-      }
+function handleFunctionDecl(node, ctx) {
+  const nameNode = node.childForFieldName('name');
+  if (nameNode) {
+    const fnChildren = extractParameters(node);
+    ctx.definitions.push({
+      name: nameNode.text,
+      kind: 'function',
+      line: node.startPosition.row + 1,
+      endLine: nodeEndLine(node),
+      children: fnChildren.length > 0 ? fnChildren : undefined,
+    });
+  }
+}
 
-      case 'lexical_declaration':
-      case 'variable_declaration': {
-        const isConst = node.text.startsWith('const ');
-        for (let i = 0; i < node.childCount; i++) {
-          const declarator = node.child(i);
-          if (declarator && declarator.type === 'variable_declarator') {
-            const nameN = declarator.childForFieldName('name');
-            const valueN = declarator.childForFieldName('value');
-            if (nameN && valueN) {
-              const valType = valueN.type;
-              if (
-                valType === 'arrow_function' ||
-                valType === 'function_expression' ||
-                valType === 'function'
-              ) {
-                const varFnChildren = extractParameters(valueN);
-                definitions.push({
-                  name: nameN.text,
-                  kind: 'function',
-                  line: node.startPosition.row + 1,
-                  endLine: nodeEndLine(valueN),
-                  children: varFnChildren.length > 0 ? varFnChildren : undefined,
-                });
-              } else if (isConst && nameN.type === 'identifier' && isConstantValue(valueN)) {
-                definitions.push({
-                  name: nameN.text,
-                  kind: 'constant',
-                  line: node.startPosition.row + 1,
-                  endLine: nodeEndLine(node),
-                });
-              }
-            } else if (isConst && nameN && nameN.type === 'identifier' && !valueN) {
-              // const with no value (shouldn't happen but be safe)
-            }
-          }
-        }
-        break;
-      }
+function handleClassDecl(node, ctx) {
+  const nameNode = node.childForFieldName('name');
+  if (!nameNode) return;
+  const className = nameNode.text;
+  const startLine = node.startPosition.row + 1;
+  const clsChildren = extractClassProperties(node);
+  ctx.definitions.push({
+    name: className,
+    kind: 'class',
+    line: startLine,
+    endLine: nodeEndLine(node),
+    children: clsChildren.length > 0 ? clsChildren : undefined,
+  });
+  const heritage = node.childForFieldName('heritage') || findChild(node, 'class_heritage');
+  if (heritage) {
+    const superName = extractSuperclass(heritage);
+    if (superName) {
+      ctx.classes.push({ name: className, extends: superName, line: startLine });
+    }
+    const implementsList = extractImplements(heritage);
+    for (const iface of implementsList) {
+      ctx.classes.push({ name: className, implements: iface, line: startLine });
+    }
+  }
+}
 
-      case 'enum_declaration': {
-        // TypeScript enum
-        const nameNode = node.childForFieldName('name');
-        if (nameNode) {
-          const enumChildren = [];
-          const body = node.childForFieldName('body') || findChild(node, 'enum_body');
-          if (body) {
-            for (let i = 0; i < body.childCount; i++) {
-              const member = body.child(i);
-              if (!member) continue;
-              if (member.type === 'enum_assignment' || member.type === 'property_identifier') {
-                const mName = member.childForFieldName('name') || member.child(0);
-                if (mName) {
-                  enumChildren.push({
-                    name: mName.text,
-                    kind: 'constant',
-                    line: member.startPosition.row + 1,
-                  });
-                }
-              }
-            }
-          }
-          definitions.push({
-            name: nameNode.text,
-            kind: 'enum',
-            line: node.startPosition.row + 1,
-            endLine: nodeEndLine(node),
-            children: enumChildren.length > 0 ? enumChildren : undefined,
-          });
-        }
-        break;
-      }
+function handleMethodDef(node, ctx) {
+  const nameNode = node.childForFieldName('name');
+  if (nameNode) {
+    const parentClass = findParentClass(node);
+    const fullName = parentClass ? `${parentClass}.${nameNode.text}` : nameNode.text;
+    const methChildren = extractParameters(node);
+    const methVis = extractVisibility(node);
+    ctx.definitions.push({
+      name: fullName,
+      kind: 'method',
+      line: node.startPosition.row + 1,
+      endLine: nodeEndLine(node),
+      children: methChildren.length > 0 ? methChildren : undefined,
+      visibility: methVis,
+    });
+  }
+}
 
-      case 'call_expression': {
-        const fn = node.childForFieldName('function');
-        if (fn) {
-          // Dynamic import(): import('./foo.js') → extract as an import entry
-          if (fn.type === 'import') {
-            const args = node.childForFieldName('arguments') || findChild(node, 'arguments');
-            if (args) {
-              const strArg = findChild(args, 'string');
-              if (strArg) {
-                const modPath = strArg.text.replace(/['"]/g, '');
-                // Extract destructured names from parent context:
-                //   const { a, b } = await import('./foo.js')
-                // (standalone import('./foo.js').then(...) calls produce an edge with empty names)
-                const names = extractDynamicImportNames(node);
-                imports.push({
-                  source: modPath,
-                  names,
-                  line: node.startPosition.row + 1,
-                  dynamicImport: true,
-                });
-              } else {
-                debug(
-                  `Skipping non-static dynamic import() at line ${node.startPosition.row + 1} (template literal or variable)`,
-                );
-              }
-            }
-          } else {
-            const callInfo = extractCallInfo(fn, node);
-            if (callInfo) calls.push(callInfo);
-            if (fn.type === 'member_expression') {
-              const cbDef = extractCallbackDefinition(node, fn);
-              if (cbDef) definitions.push(cbDef);
-            }
-          }
-        }
-        break;
-      }
+function handleInterfaceDecl(node, ctx) {
+  const nameNode = node.childForFieldName('name');
+  if (!nameNode) return;
+  ctx.definitions.push({
+    name: nameNode.text,
+    kind: 'interface',
+    line: node.startPosition.row + 1,
+    endLine: nodeEndLine(node),
+  });
+  const body =
+    node.childForFieldName('body') ||
+    findChild(node, 'interface_body') ||
+    findChild(node, 'object_type');
+  if (body) {
+    extractInterfaceMethods(body, nameNode.text, ctx.definitions);
+  }
+}
 
-      case 'import_statement': {
-        const isTypeOnly = node.text.startsWith('import type');
-        const source = node.childForFieldName('source') || findChild(node, 'string');
-        if (source) {
-          const modPath = source.text.replace(/['"]/g, '');
-          const names = extractImportNames(node);
-          imports.push({
-            source: modPath,
-            names,
+function handleTypeAliasDecl(node, ctx) {
+  const nameNode = node.childForFieldName('name');
+  if (nameNode) {
+    ctx.definitions.push({
+      name: nameNode.text,
+      kind: 'type',
+      line: node.startPosition.row + 1,
+      endLine: nodeEndLine(node),
+    });
+  }
+}
+
+function handleVariableDecl(node, ctx) {
+  const isConst = node.text.startsWith('const ');
+  for (let i = 0; i < node.childCount; i++) {
+    const declarator = node.child(i);
+    if (declarator && declarator.type === 'variable_declarator') {
+      const nameN = declarator.childForFieldName('name');
+      const valueN = declarator.childForFieldName('value');
+      if (nameN && valueN) {
+        const valType = valueN.type;
+        if (
+          valType === 'arrow_function' ||
+          valType === 'function_expression' ||
+          valType === 'function'
+        ) {
+          const varFnChildren = extractParameters(valueN);
+          ctx.definitions.push({
+            name: nameN.text,
+            kind: 'function',
+            line: node.startPosition.row + 1,
+            endLine: nodeEndLine(valueN),
+            children: varFnChildren.length > 0 ? varFnChildren : undefined,
+          });
+        } else if (isConst && nameN.type === 'identifier' && isConstantValue(valueN)) {
+          ctx.definitions.push({
+            name: nameN.text,
+            kind: 'constant',
             line: node.startPosition.row + 1,
-            typeOnly: isTypeOnly,
+            endLine: nodeEndLine(node),
           });
         }
-        break;
       }
+    }
+  }
+}
 
-      case 'export_statement': {
-        const exportLine = node.startPosition.row + 1;
-        const decl = node.childForFieldName('declaration');
-        if (decl) {
-          const declType = decl.type;
-          const kindMap = {
-            function_declaration: 'function',
-            class_declaration: 'class',
-            interface_declaration: 'interface',
-            type_alias_declaration: 'type',
-          };
-          const kind = kindMap[declType];
-          if (kind) {
-            const n = decl.childForFieldName('name');
-            if (n) exports.push({ name: n.text, kind, line: exportLine });
-          }
-        }
-        const source = node.childForFieldName('source') || findChild(node, 'string');
-        if (source && !decl) {
-          const modPath = source.text.replace(/['"]/g, '');
-          const reexportNames = extractImportNames(node);
-          const nodeText = node.text;
-          const isWildcard = nodeText.includes('export *') || nodeText.includes('export*');
-          imports.push({
-            source: modPath,
-            names: reexportNames,
-            line: exportLine,
-            reexport: true,
-            wildcardReexport: isWildcard && reexportNames.length === 0,
+function handleEnumDecl(node, ctx) {
+  const nameNode = node.childForFieldName('name');
+  if (!nameNode) return;
+  const enumChildren = [];
+  const body = node.childForFieldName('body') || findChild(node, 'enum_body');
+  if (body) {
+    for (let i = 0; i < body.childCount; i++) {
+      const member = body.child(i);
+      if (!member) continue;
+      if (member.type === 'enum_assignment' || member.type === 'property_identifier') {
+        const mName = member.childForFieldName('name') || member.child(0);
+        if (mName) {
+          enumChildren.push({
+            name: mName.text,
+            kind: 'constant',
+            line: member.startPosition.row + 1,
           });
         }
-        break;
       }
+    }
+  }
+  ctx.definitions.push({
+    name: nameNode.text,
+    kind: 'enum',
+    line: node.startPosition.row + 1,
+    endLine: nodeEndLine(node),
+    children: enumChildren.length > 0 ? enumChildren : undefined,
+  });
+}
 
-      case 'expression_statement': {
-        const expr = node.child(0);
-        if (expr && expr.type === 'assignment_expression') {
-          const left = expr.childForFieldName('left');
-          const right = expr.childForFieldName('right');
-          if (left && right) {
-            const leftText = left.text;
-            if (leftText.startsWith('module.exports') || leftText === 'exports') {
-              if (right.type === 'call_expression') {
-                const fn = right.childForFieldName('function');
-                const args = right.childForFieldName('arguments') || findChild(right, 'arguments');
-                if (fn && fn.text === 'require' && args) {
-                  const strArg = findChild(args, 'string');
-                  if (strArg) {
-                    imports.push({
-                      source: strArg.text.replace(/['"]/g, ''),
-                      names: [],
-                      line: node.startPosition.row + 1,
-                      reexport: true,
-                      wildcardReexport: true,
-                    });
-                  }
-                }
-              }
-              if (right.type === 'object') {
-                for (let ci = 0; ci < right.childCount; ci++) {
-                  const child = right.child(ci);
-                  if (child && child.type === 'spread_element') {
-                    const spreadExpr = child.child(1) || child.childForFieldName('value');
-                    if (spreadExpr && spreadExpr.type === 'call_expression') {
-                      const fn2 = spreadExpr.childForFieldName('function');
-                      const args2 =
-                        spreadExpr.childForFieldName('arguments') ||
-                        findChild(spreadExpr, 'arguments');
-                      if (fn2 && fn2.text === 'require' && args2) {
-                        const strArg2 = findChild(args2, 'string');
-                        if (strArg2) {
-                          imports.push({
-                            source: strArg2.text.replace(/['"]/g, ''),
-                            names: [],
-                            line: node.startPosition.row + 1,
-                            reexport: true,
-                            wildcardReexport: true,
-                          });
-                        }
-                      }
-                    }
-                  }
-                }
-              }
-            }
-          }
-        }
-        break;
+function handleCallExpr(node, ctx) {
+  const fn = node.childForFieldName('function');
+  if (!fn) return;
+  if (fn.type === 'import') {
+    const args = node.childForFieldName('arguments') || findChild(node, 'arguments');
+    if (args) {
+      const strArg = findChild(args, 'string');
+      if (strArg) {
+        const modPath = strArg.text.replace(/['"]/g, '');
+        const names = extractDynamicImportNames(node);
+        ctx.imports.push({
+          source: modPath,
+          names,
+          line: node.startPosition.row + 1,
+          dynamicImport: true,
+        });
+      } else {
+        debug(
+          `Skipping non-static dynamic import() at line ${node.startPosition.row + 1} (template literal or variable)`,
+        );
       }
     }
+  } else {
+    const callInfo = extractCallInfo(fn, node);
+    if (callInfo) ctx.calls.push(callInfo);
+    if (fn.type === 'member_expression') {
+      const cbDef = extractCallbackDefinition(node, fn);
+      if (cbDef) ctx.definitions.push(cbDef);
+    }
+  }
+}
 
-    for (let i = 0; i < node.childCount; i++) {
-      walkJavaScriptNode(node.child(i));
+function handleImportStmt(node, ctx) {
+  const isTypeOnly = node.text.startsWith('import type');
+  const source = node.childForFieldName('source') || findChild(node, 'string');
+  if (source) {
+    const modPath = source.text.replace(/['"]/g, '');
+    const names = extractImportNames(node);
+    ctx.imports.push({
+      source: modPath,
+      names,
+      line: node.startPosition.row + 1,
+      typeOnly: isTypeOnly,
+    });
+  }
+}
+
+function handleExportStmt(node, ctx) {
+  const exportLine = node.startPosition.row + 1;
+  const decl = node.childForFieldName('declaration');
+  if (decl) {
+    const declType = decl.type;
+    const kindMap = {
+      function_declaration: 'function',
+      class_declaration: 'class',
+      interface_declaration: 'interface',
+      type_alias_declaration: 'type',
+    };
+    const kind = kindMap[declType];
+    if (kind) {
+      const n = decl.childForFieldName('name');
+      if (n) ctx.exports.push({ name: n.text, kind, line: exportLine });
     }
   }
+  const source = node.childForFieldName('source') || findChild(node, 'string');
+  if (source && !decl) {
+    const modPath = source.text.replace(/['"]/g, '');
+    const reexportNames = extractImportNames(node);
+    const nodeText = node.text;
+    const isWildcard = nodeText.includes('export *') || nodeText.includes('export*');
+    ctx.imports.push({
+      source: modPath,
+      names: reexportNames,
+      line: exportLine,
+      reexport: true,
+      wildcardReexport: isWildcard && reexportNames.length === 0,
+    });
+  }
+}
 
-  walkJavaScriptNode(tree.rootNode);
-  return { definitions, calls, imports, classes, exports };
+function handleExpressionStmt(node, ctx) {
+  const expr = node.child(0);
+  if (expr && expr.type === 'assignment_expression') {
+    const left = expr.childForFieldName('left');
+    const right = expr.childForFieldName('right');
+    handleCommonJSAssignment(left, right, node, ctx.imports);
+  }
 }
 
 // ── Child extraction helpers ────────────────────────────────────────────────