@codeflow-map/core 0.1.0

package/dist/analyzer/languages/tsx.js

@@ -0,0 +1,358 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tsxAnalyzer = void 0;
+const extractorUtils_1 = require("../extractorUtils");
+exports.tsxAnalyzer = {
+    functionQuery: `
+(function_declaration
+  name: (identifier) @fn.name
+  parameters: (formal_parameters) @fn.params
+  return_type: (type_annotation)? @fn.return_type) @fn.decl
+
+(lexical_declaration
+  (variable_declarator
+    name: (identifier) @fn.name
+    value: [(arrow_function) (function_expression)] @fn.decl))
+
+(export_statement
+  declaration: (lexical_declaration
+    (variable_declarator
+      name: (identifier) @fn.name
+      value: [(arrow_function) (function_expression)] @fn.decl)))
+
+(method_definition
+  name: (property_identifier) @fn.name
+  parameters: (formal_parameters) @fn.params
+  return_type: (type_annotation)? @fn.return_type) @fn.decl
+
+(call_expression
+  function: (identifier) @hook.name
+  arguments: (arguments
+    [(arrow_function) (function_expression)] @fn.decl)
+  (#match? @hook.name "^use"))
+
+(generator_function_declaration
+  name: (identifier) @fn.name
+  parameters: (formal_parameters) @fn.params
+  return_type: (type_annotation)? @fn.return_type) @fn.decl
+
+(lexical_declaration
+  (variable_declarator
+    name: (identifier) @fn.name
+    value: (generator_function) @fn.decl))
+
+(export_statement
+  declaration: (lexical_declaration
+    (variable_declarator
+      name: (identifier) @fn.name
+      value: (generator_function) @fn.decl)))
+
+(function_expression
+  name: (identifier) @fn.name
+  parameters: (formal_parameters) @fn.params) @fn.decl
+
+(lexical_declaration
+  (variable_declarator
+    name: (identifier) @fn.name
+    value: (call_expression
+      function: [(parenthesized_expression
+                   [(function_expression)(arrow_function)] @fn.decl)
+                 (arrow_function) @fn.decl
+                 (function_expression) @fn.decl])))
+
+(expression_statement
+  (call_expression
+    function: (parenthesized_expression
+      [(function_expression)(arrow_function)] @fn.decl)))
+
+(assignment_expression
+  left: (member_expression
+    object: (identifier) @worker.obj
+    property: (property_identifier) @worker.prop)
+  right: [(arrow_function) (function_expression)] @worker.fn
+  (#match? @worker.obj "^self$")
+  (#match? @worker.prop "^onmessage$"))
+
+(call_expression
+  function: (member_expression
+    object: (identifier) @worker.obj
+    property: (property_identifier) @worker.method)
+  arguments: (arguments
+    (string) @worker.event
+    [(arrow_function) (function_expression)] @worker.fn)
+  (#match? @worker.obj "^self$")
+  (#match? @worker.method "^addEventListener$")
+  (#match? @worker.event "message"))
+
+(lexical_declaration
+  (variable_declarator
+    name: (identifier) @fn.name
+    value: (call_expression
+      function: (identifier) @wrapper.name
+      arguments: (arguments
+        [(arrow_function) (function_expression)] @fn.decl)
+      (#match? @wrapper.name "^(forwardRef|memo)$"))))
+
+(lexical_declaration
+  (variable_declarator
+    name: (identifier) @fn.name
+    value: (call_expression
+      function: (identifier) @wrapper.outer
+      arguments: (arguments
+        (call_expression
+          function: (identifier) @wrapper.inner
+          arguments: (arguments
+            [(arrow_function) (function_expression)] @fn.decl)))
+      (#match? @wrapper.outer "^(memo|forwardRef)$"))))
+
+(export_statement
+  declaration: (lexical_declaration
+    (variable_declarator
+      name: (identifier) @fn.name
+      value: (call_expression
+        function: (identifier) @wrapper.name
+        arguments: (arguments
+          [(arrow_function) (function_expression)] @fn.decl)
+        (#match? @wrapper.name "^(forwardRef|memo)$")))))
+
+(export_statement
+  declaration: (lexical_declaration
+    (variable_declarator
+      name: (identifier) @fn.name
+      value: (call_expression
+        function: (identifier) @wrapper.outer
+        arguments: (arguments
+          (call_expression
+            function: (identifier) @wrapper.inner
+            arguments: (arguments
+              [(arrow_function) (function_expression)] @fn.decl)))
+        (#match? @wrapper.outer "^(memo|forwardRef)$")))))
+
+(public_field_definition
+  name: (property_identifier) @fn.name
+  value: [(arrow_function)(function_expression)] @fn.decl)
+  `,
+    callQuery: `
+(call_expression
+  function: [(identifier)(member_expression)] @call.name) @call.expr
+
+(jsx_element
+  open_tag: (jsx_opening_element
+    name: (identifier) @call.name
+    (#match? @call.name "^[A-Z]"))) @call.expr
+
+(jsx_self_closing_element
+  name: (identifier) @call.name
+  (#match? @call.name "^[A-Z]")) @call.expr
+
+(new_expression
+  constructor: (identifier) @call.name) @call.expr
+
+(call_expression
+  function: (member_expression
+    property: (property_identifier) @call.name
+    (#match? @call.name "^(then|catch|finally)$"))) @call.expr
+  `,
+    extractFunction(match, filePath, languageId) {
+        const declCapture = match.captures.find((c) => c.name === 'fn.decl');
+        if (!declCapture) {
+            const workerFn = match.captures.find((c) => c.name === 'worker.fn');
+            if (workerFn) {
+                const workerProp = match.captures.find((c) => c.name === 'worker.prop');
+                const node = workerFn.node;
+                const rawName = workerProp ? 'onmessage_handler' : `message_handler_${node.startPosition.row}`;
+                const paramsList = (0, extractorUtils_1.getParamsFromFunctionNode)(node, true);
+                return {
+                    id: `${filePath}::${rawName}::${node.startPosition.row}`,
+                    name: rawName,
+                    filePath,
+                    startLine: node.startPosition.row,
+                    endLine: node.endPosition.row,
+                    params: paramsList,
+                    returnType: null,
+                    isAsync: (0, extractorUtils_1.checkIsAsync)(node),
+                    isExported: false,
+                    isEntryPoint: true,
+                    language: languageId,
+                    kind: 'function'
+                };
+            }
+            return null;
+        }
+        const nameCapture = match.captures.find((c) => c.name === 'fn.name');
+        const hookNameCapture = match.captures.find((c) => c.name === 'hook.name');
+        // For wrapper patterns (memo, forwardRef), only capture the first argument
+        const wrapperCapture = match.captures.find((c) => c.name === 'wrapper.name' || c.name === 'wrapper.outer');
+        if (wrapperCapture) {
+            const argsParent = declCapture.node.parent;
+            if (argsParent?.type === 'arguments') {
+                const firstArg = argsParent.namedChildren[0];
+                if (firstArg.id !== declCapture.node.id) {
+                    return null;
+                }
+            }
+        }
+        let rawName = "anonymous";
+        let kind = 'function';
+        let parentFunctionId;
+        if (nameCapture) {
+            rawName = nameCapture.node.text;
+            if (declCapture.node.type === 'function_expression' && nameCapture.node.parent?.id === declCapture.node.id) {
+                if (declCapture.node.parent?.type === 'variable_declarator') {
+                    return null;
+                }
+                parentFunctionId = (0, extractorUtils_1.getEnclosingFunctionId)(declCapture.node, filePath) ?? undefined;
+            }
+            if (declCapture.node.type === 'method_definition') {
+                kind = 'method';
+            }
+            else if (rawName.length > 0 && rawName[0] === rawName[0].toUpperCase())
+                kind = 'component';
+        }
+        else if (hookNameCapture) {
+            const startLine = declCapture.node.startPosition.row;
+            rawName = `${hookNameCapture.node.text}_callback_${startLine}`;
+            kind = 'hook';
+        }
+        // Detect IIFE: fn.decl is inside a call_expression (the IIFE invocation)
+        // Skip IIFE detection for wrapper patterns (forwardRef, memo)
+        const declParent = declCapture.node.parent;
+        const isParenWrapped = declParent?.type === 'parenthesized_expression';
+        const callParent = isParenWrapped ? declParent.parent : declParent;
+        if (callParent?.type === 'call_expression' && !wrapperCapture) {
+            if (rawName === 'anonymous') {
+                rawName = `iife_${declCapture.node.startPosition.row}`;
+            }
+            kind = 'iife';
+        }
+        else if (rawName === "anonymous" && !hookNameCapture) {
+            return null;
+        }
+        // Prefix with enclosing scope chain (parent functions, classes, and object literals)
+        const scopeChain = (0, extractorUtils_1.getEnclosingScopeChain)(declCapture.node, extractorUtils_1.JS_FN_SCOPE_TYPES, extractorUtils_1.JS_CLASS_SCOPE_TYPES);
+        if (scopeChain.length > 0) {
+            rawName = `${scopeChain.map(s => s.name).join('.')}.${rawName}`;
+        }
+        // For wrapper patterns, use the outermost wrapper call_expression range
+        let rangeNode = declCapture.node;
+        if (wrapperCapture) {
+            let target = declCapture.node.parent;
+            while (target?.type === 'arguments') {
+                const callExpr = target.parent;
+                if (callExpr?.type !== 'call_expression')
+                    break;
+                const fn = callExpr.childForFieldName('function');
+                const isKnownWrapper = fn && ((fn.type === 'identifier' && /^(forwardRef|memo)$/.test(fn.text)) ||
+                    (fn.type === 'member_expression' && /^(forwardRef|memo)$/.test(fn.childForFieldName('property')?.text ?? '')));
+                if (!isKnownWrapper)
+                    break;
+                rangeNode = callExpr;
+                target = callExpr.parent;
+            }
+        }
+        const paramsCapture = match.captures.find((c) => c.name === 'fn.params');
+        const returnCapture = match.captures.find((c) => c.name === 'fn.return_type');
+        const isExported = (0, extractorUtils_1.checkExportedByParentWalk)(declCapture.node);
+        const paramsList = paramsCapture
+            ? (0, extractorUtils_1.buildJsParams)(paramsCapture.node, true)
+            : (0, extractorUtils_1.getParamsFromFunctionNode)(declCapture.node, true);
+        let finalReturnType = returnCapture ? returnCapture.node.text.replace(/^:\s*/, '') : null;
+        if (!finalReturnType) {
+            const returnValues = (0, extractorUtils_1.getReturnValues)(declCapture.node, extractorUtils_1.JS_NESTED_FN_TYPES);
+            if (returnValues.length > 0) {
+                finalReturnType = returnValues.join(' | ');
+            }
+        }
+        return {
+            id: `${filePath}::${rawName}::${rangeNode.startPosition.row}`,
+            name: rawName,
+            filePath,
+            startLine: rangeNode.startPosition.row,
+            endLine: rangeNode.endPosition.row,
+            params: paramsList,
+            returnType: finalReturnType,
+            isAsync: (0, extractorUtils_1.checkIsAsync)(declCapture.node),
+            isExported,
+            isEntryPoint: false,
+            language: languageId,
+            kind,
+            ...(parentFunctionId ? { parentFunctionId } : {})
+        };
+    },
+    extractCall(match, filePath) {
+        const nameCapture = match.captures.find((c) => c.name === 'call.name');
+        const exprCapture = match.captures.find((c) => c.name === 'call.expr');
+        if (nameCapture && exprCapture) {
+            let calleeName = nameCapture.node.text;
+            if (nameCapture.node.type === 'member_expression') {
+                const prop = nameCapture.node.childForFieldName('property');
+                if (prop)
+                    calleeName = prop.text;
+            }
+            // Unwrap .bind(): handleWorkerMessage.bind(this) → ref to handleWorkerMessage
+            if (calleeName === 'bind' && nameCapture.node.type === 'member_expression') {
+                const obj = nameCapture.node.childForFieldName('object');
+                if (obj?.type === 'identifier') {
+                    return {
+                        callerFilePath: filePath,
+                        calleeName: obj.text,
+                        line: exprCapture.node.startPosition.row,
+                        callType: (0, extractorUtils_1.isInsidePromiseCombinator)(exprCapture.node) ? 'concurrent' : 'ref',
+                        isRef: true
+                    };
+                }
+            }
+            const callType = (0, extractorUtils_1.isInsidePromiseCombinator)(exprCapture.node) ? 'concurrent' : undefined;
+            const directCall = {
+                callerFilePath: filePath,
+                calleeName,
+                line: exprCapture.node.startPosition.row,
+                ...(callType ? { callType } : {})
+            };
+            // Extract function reference arguments from any call
+            const refCalls = [];
+            const callNode = exprCapture.node;
+            const argsNode = callNode.childForFieldName('arguments');
+            if (argsNode) {
+                for (const arg of argsNode.namedChildren) {
+                    let refName = null;
+                    if (arg.type === 'identifier') {
+                        refName = arg.text;
+                    }
+                    else if (arg.type === 'member_expression') {
+                        const obj = arg.childForFieldName('object');
+                        const prop = arg.childForFieldName('property');
+                        if (obj?.type === 'this' && prop) {
+                            refName = prop.text;
+                        }
+                    }
+                    else if (arg.type === 'call_expression') {
+                        const fn = arg.childForFieldName('function');
+                        if (fn?.type === 'member_expression') {
+                            const prop = fn.childForFieldName('property');
+                            const obj = fn.childForFieldName('object');
+                            if (prop?.text === 'bind' && obj?.type === 'identifier') {
+                                refName = obj.text;
+                            }
+                        }
+                    }
+                    if (refName) {
+                        const refCallType = (0, extractorUtils_1.isInsidePromiseCombinator)(callNode) ? 'concurrent' : 'ref';
+                        refCalls.push({
+                            callerFilePath: filePath,
+                            calleeName: refName,
+                            line: callNode.startPosition.row,
+                            callType: refCallType,
+                            isRef: true
+                        });
+                    }
+                }
+            }
+            if (refCalls.length > 0) {
+                return [directCall, ...refCalls];
+            }
+            return directCall;
+        }
+        return null;
+    }
+};

package/dist/analyzer/languages/typescript.d.ts

@@ -0,0 +1,2 @@
+import { LanguageAnalyzer } from '../../types';
+export declare const typescriptAnalyzer: LanguageAnalyzer;