@g1cloud/api-gen 1.0.0

package/dist/parser/javaParser.js

@@ -0,0 +1,805 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JavaFileParser = void 0;
+exports.parseJavaSource = parseJavaSource;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const java_parser_1 = require("java-parser");
+/**
+ * Extract Javadoc comments from source code
+ */
+function extractJavadocs(content) {
+    const javadocs = new Map();
+    const javadocRegex = /\/\*\*[\s\S]*?\*\//g;
+    let match;
+    while ((match = javadocRegex.exec(content)) !== null) {
+        const javadocText = match[0];
+        // Count newlines to find the end line of the javadoc
+        const beforeMatch = content.substring(0, match.index + javadocText.length);
+        const endLine = beforeMatch.split('\n').length;
+        // Parse the javadoc content
+        const parsedJavadoc = parseJavadocContent(javadocText);
+        if (parsedJavadoc.description || parsedJavadoc.info.returns || Object.keys(parsedJavadoc.info.params).length > 0) {
+            javadocs.set(endLine, parsedJavadoc);
+        }
+    }
+    return javadocs;
+}
+/**
+ * Parse Javadoc content and extract the description, @param, and @return
+ */
+function parseJavadocContent(javadoc) {
+    // Remove /** and */
+    let content = javadoc.replace(/^\/\*\*/, '').replace(/\*\/$/, '');
+    // Split into lines and process each line
+    const lines = content.split('\n').map((line) => {
+        // Remove leading whitespace and asterisks
+        return line.replace(/^\s*\*?\s?/, '');
+    });
+    const descriptionLines = [];
+    const params = {};
+    let returns;
+    let currentTag = null;
+    let currentParamName = null;
+    let currentTagContent = [];
+    const flushCurrentTag = () => {
+        if (currentTag === 'param' && currentParamName) {
+            params[currentParamName] = currentTagContent.join(' ').trim();
+        }
+        else if (currentTag === 'return' || currentTag === 'returns') {
+            returns = currentTagContent.join(' ').trim();
+        }
+        currentTag = null;
+        currentParamName = null;
+        currentTagContent = [];
+    };
+    for (const line of lines) {
+        if (line.startsWith('@param ')) {
+            flushCurrentTag();
+            currentTag = 'param';
+            // Extract param name and description
+            const paramMatch = line.match(/^@param\s+(\w+)\s*(.*)/);
+            if (paramMatch) {
+                currentParamName = paramMatch[1];
+                if (paramMatch[2]) {
+                    currentTagContent.push(paramMatch[2]);
+                }
+            }
+        }
+        else if (line.startsWith('@return ') || line.startsWith('@returns ')) {
+            flushCurrentTag();
+            currentTag = 'return';
+            const returnMatch = line.match(/^@returns?\s+(.*)/);
+            if (returnMatch && returnMatch[1]) {
+                currentTagContent.push(returnMatch[1]);
+            }
+        }
+        else if (line.startsWith('@')) {
+            // Other tags like @throws, @see, etc. - flush current and ignore
+            flushCurrentTag();
+        }
+        else if (currentTag) {
+            // Continuation of current tag
+            currentTagContent.push(line);
+        }
+        else {
+            // Description line
+            descriptionLines.push(line);
+        }
+    }
+    // Flush any remaining tag
+    flushCurrentTag();
+    return {
+        description: descriptionLines.join('\n').trim(),
+        info: {
+            description: descriptionLines.join('\n').trim() || undefined,
+            params,
+            returns,
+        },
+    };
+}
+class JavaFileParser {
+    sourceDir;
+    constructor(sourceDir) {
+        this.sourceDir = sourceDir;
+    }
+    async parseAllJavaFiles() {
+        const javaClasses = new Map();
+        const javaFiles = this.findJavaFiles(this.sourceDir);
+        for (const filePath of javaFiles) {
+            try {
+                const classes = await this.parseJavaFile(filePath);
+                for (const javaClass of classes) {
+                    javaClasses.set(javaClass.name, javaClass);
+                }
+            }
+            catch (error) {
+                console.error(`Error parsing ${filePath}:`, error instanceof Error ? error.message : error);
+            }
+        }
+        return javaClasses;
+    }
+    findJavaFiles(dir) {
+        const files = [];
+        if (!fs.existsSync(dir)) {
+            return files;
+        }
+        const entries = fs.readdirSync(dir, { withFileTypes: true });
+        for (const entry of entries) {
+            const fullPath = path.join(dir, entry.name);
+            if (entry.isDirectory()) {
+                files.push(...this.findJavaFiles(fullPath));
+            }
+            else if (entry.isFile() && entry.name.endsWith('.java')) {
+                files.push(fullPath);
+            }
+        }
+        return files;
+    }
+    async parseJavaFile(filePath) {
+        const content = fs.readFileSync(filePath, 'utf-8');
+        try {
+            const cst = (0, java_parser_1.parse)(content);
+            const javadocs = extractJavadocs(content);
+            const extractor = new JavaClassExtractor(filePath, content, javadocs);
+            extractor.visit(cst);
+            return extractor.getAllClasses();
+        }
+        catch (error) {
+            console.error(`Failed to parse ${filePath}:`, error instanceof Error ? error.message : error);
+            return [];
+        }
+    }
+}
+exports.JavaFileParser = JavaFileParser;
+class JavaClassExtractor extends java_parser_1.BaseJavaCstVisitorWithDefaults {
+    filePath;
+    sourceContent;
+    javadocs;
+    _packageName = '';
+    currentAnnotations = [];
+    // Stack for handling nested classes
+    classStack = [];
+    allClasses = [];
+    constructor(filePath, sourceContent, javadocs) {
+        super();
+        this.filePath = filePath;
+        this.sourceContent = sourceContent;
+        this.javadocs = javadocs;
+        this.validateVisitor();
+    }
+    get currentClass() {
+        return this.classStack[this.classStack.length - 1];
+    }
+    getJavaClass() {
+        // Return the first (top-level) class for backward compatibility
+        return this.allClasses.length > 0 ? this.allClasses[0] : null;
+    }
+    getAllClasses() {
+        return this.allClasses;
+    }
+    finalizeClass(ctx) {
+        this.allClasses.push({
+            name: ctx.className,
+            packageName: this._packageName,
+            annotations: ctx.classAnnotations,
+            methods: ctx.methods,
+            fields: ctx.fields,
+            filePath: this.filePath,
+            javadoc: ctx.classJavadoc,
+            superClass: ctx.superClassName,
+            isEnum: ctx.isEnum,
+            enumValues: ctx.isEnum ? ctx.enumValues : undefined,
+        });
+    }
+    packageDeclaration(ctx) {
+        if (ctx.Identifier) {
+            this._packageName = ctx.Identifier.map((id) => id.image).join('.');
+        }
+    }
+    normalClassDeclaration(ctx) {
+        // Create a new class context
+        const classContext = {
+            className: '',
+            classAnnotations: [...this.currentAnnotations],
+            methods: [],
+            fields: [],
+            isEnum: false,
+            enumValues: [],
+        };
+        this.currentAnnotations = [];
+        // Extract class name
+        if (ctx.typeIdentifier?.[0]?.children?.Identifier?.[0]) {
+            classContext.className = ctx.typeIdentifier[0].children.Identifier[0].image;
+            // Find javadoc for this class
+            const classToken = ctx.typeIdentifier[0].children.Identifier[0];
+            if (classToken.startLine) {
+                const parsedJavadoc = this.findJavadocForLine(classToken.startLine);
+                classContext.classJavadoc = parsedJavadoc?.description;
+            }
+        }
+        // Extract superclass name from classExtends
+        if (ctx.classExtends?.[0]) {
+            const classExtendsChildren = ctx.classExtends[0].children || ctx.classExtends[0];
+            if (classExtendsChildren.classType?.[0]) {
+                const classTypeChildren = classExtendsChildren.classType[0].children || classExtendsChildren.classType[0];
+                if (classTypeChildren.Identifier) {
+                    // Join all identifiers for fully qualified names
+                    classContext.superClassName = classTypeChildren.Identifier.map((id) => id.image).join('.');
+                }
+            }
+        }
+        // Push to stack and visit class body
+        this.classStack.push(classContext);
+        if (ctx.classBody) {
+            this.visit(ctx.classBody);
+        }
+        // Pop from stack and finalize the class
+        const completed = this.classStack.pop();
+        if (completed && completed.className) {
+            this.finalizeClass(completed);
+        }
+    }
+    enumDeclaration(ctx) {
+        // Create a new enum context
+        const enumContext = {
+            className: '',
+            classAnnotations: [...this.currentAnnotations],
+            methods: [],
+            fields: [],
+            isEnum: true,
+            enumValues: [],
+        };
+        this.currentAnnotations = [];
+        // Get enum name
+        if (ctx.typeIdentifier?.[0]?.children?.Identifier?.[0]) {
+            enumContext.className = ctx.typeIdentifier[0].children.Identifier[0].image;
+            // Find javadoc for this enum
+            const enumToken = ctx.typeIdentifier[0].children.Identifier[0];
+            if (enumToken.startLine) {
+                const parsedJavadoc = this.findJavadocForLine(enumToken.startLine);
+                enumContext.classJavadoc = parsedJavadoc?.description;
+            }
+        }
+        // Extract enum constants
+        if (ctx.enumBody?.[0]) {
+            const enumBodyChildren = ctx.enumBody[0].children || ctx.enumBody[0];
+            if (enumBodyChildren.enumConstantList?.[0]) {
+                const constantListChildren = enumBodyChildren.enumConstantList[0].children || enumBodyChildren.enumConstantList[0];
+                if (constantListChildren.enumConstant) {
+                    for (const enumConstant of constantListChildren.enumConstant) {
+                        const constantChildren = enumConstant.children || enumConstant;
+                        if (constantChildren.Identifier?.[0]) {
+                            enumContext.enumValues.push(constantChildren.Identifier[0].image);
+                        }
+                    }
+                }
+            }
+        }
+        // Finalize the enum (enums don't have a body to visit for nested classes)
+        if (enumContext.className) {
+            this.finalizeClass(enumContext);
+        }
+    }
+    /**
+     * Find javadoc that ends near the given line (within a few lines before)
+     */
+    findJavadocForLine(targetLine) {
+        // Look for javadoc that ends 1-10 lines before the target line
+        // (allowing for annotations between javadoc and declaration)
+        for (let offset = 1; offset <= 10; offset++) {
+            const javadoc = this.javadocs.get(targetLine - offset);
+            if (javadoc) {
+                return javadoc;
+            }
+        }
+        return undefined;
+    }
+    classModifier(ctx) {
+        if (ctx.annotation) {
+            for (const annotationCtx of ctx.annotation) {
+                const annotation = this.extractAnnotation(annotationCtx);
+                if (annotation) {
+                    this.currentAnnotations.push(annotation);
+                }
+            }
+        }
+    }
+    methodDeclaration(ctx) {
+        // Extract annotations directly from methodModifier nodes
+        const methodAnnotations = [];
+        let methodStartLine;
+        if (ctx.methodModifier) {
+            for (const modifierCtx of ctx.methodModifier) {
+                const modChildren = modifierCtx.children || modifierCtx;
+                if (modChildren.annotation) {
+                    for (const annotationCtx of modChildren.annotation) {
+                        const annotation = this.extractAnnotation(annotationCtx);
+                        if (annotation) {
+                            methodAnnotations.push(annotation);
+                        }
+                        // Track the earliest line of the method declaration
+                        const annChildren = annotationCtx.children || annotationCtx;
+                        if (annChildren.At?.[0]?.startLine && (!methodStartLine || annChildren.At[0].startLine < methodStartLine)) {
+                            methodStartLine = annChildren.At[0].startLine;
+                        }
+                    }
+                }
+            }
+        }
+        const methodHeader = ctx.methodHeader?.[0];
+        if (!methodHeader)
+            return;
+        const methodName = this.extractMethodName(methodHeader);
+        const returnType = this.extractReturnType(methodHeader);
+        const parameters = this.extractParameters(methodHeader);
+        // Find javadoc for this method
+        let methodJavadoc;
+        let methodJavadocInfo;
+        if (methodStartLine) {
+            const parsedJavadoc = this.findJavadocForLine(methodStartLine);
+            methodJavadoc = parsedJavadoc?.description;
+            methodJavadocInfo = parsedJavadoc?.info;
+        }
+        if (methodName && this.currentClass) {
+            this.currentClass.methods.push({
+                name: methodName,
+                returnType: returnType.type,
+                returnGenericType: returnType.genericType,
+                parameters,
+                annotations: methodAnnotations,
+                javadoc: methodJavadoc,
+                javadocInfo: methodJavadocInfo,
+            });
+        }
+    }
+    fieldDeclaration(ctx) {
+        // Extract annotations and check for static modifier from fieldModifier nodes
+        const fieldAnnotations = [];
+        let isStatic = false;
+        let fieldStartLine;
+        if (ctx.fieldModifier) {
+            for (const modifier of ctx.fieldModifier) {
+                const modChildren = modifier.children || modifier;
+                // Check for static modifier
+                if (modChildren.Static) {
+                    isStatic = true;
+                }
+                // Extract annotations and track start line
+                if (modChildren.annotation) {
+                    for (const annotationCtx of modChildren.annotation) {
+                        const annotation = this.extractAnnotation(annotationCtx);
+                        if (annotation) {
+                            fieldAnnotations.push(annotation);
+                        }
+                        // Track the earliest line of the field declaration
+                        const annChildren = annotationCtx.children || annotationCtx;
+                        if (annChildren.At?.[0]?.startLine && (!fieldStartLine || annChildren.At[0].startLine < fieldStartLine)) {
+                            fieldStartLine = annChildren.At[0].startLine;
+                        }
+                    }
+                }
+            }
+        }
+        // Skip static fields
+        if (isStatic)
+            return;
+        const unannType = ctx.unannType?.[0];
+        const variableDeclaratorList = ctx.variableDeclaratorList?.[0];
+        if (!unannType || !variableDeclaratorList)
+            return;
+        // If no annotation found, try to get start line from type
+        if (!fieldStartLine && unannType) {
+            fieldStartLine = this.getStartLineFromNode(unannType);
+        }
+        const typeInfo = this.extractType(unannType);
+        const fieldNames = this.extractFieldNames(variableDeclaratorList);
+        // Find javadoc for this field
+        let fieldJavadoc;
+        if (fieldStartLine) {
+            const parsedJavadoc = this.findJavadocForLine(fieldStartLine);
+            fieldJavadoc = parsedJavadoc?.description;
+        }
+        if (this.currentClass) {
+            for (const fieldName of fieldNames) {
+                this.currentClass.fields.push({
+                    name: fieldName,
+                    type: typeInfo.type,
+                    genericType: typeInfo.genericType,
+                    annotations: fieldAnnotations,
+                    accessModifier: 'private', // Default, could be extracted from modifiers
+                    javadoc: fieldJavadoc,
+                });
+            }
+        }
+    }
+    /**
+     * Get the start line from a CST node by recursively searching for tokens
+     */
+    getStartLineFromNode(node) {
+        if (!node)
+            return undefined;
+        const children = node.children || node;
+        // Check if this is a token with startLine
+        if (children.startLine) {
+            return children.startLine;
+        }
+        // Recursively search children
+        for (const key of Object.keys(children)) {
+            const child = children[key];
+            if (Array.isArray(child)) {
+                for (const item of child) {
+                    if (item?.startLine) {
+                        return item.startLine;
+                    }
+                    const result = this.getStartLineFromNode(item);
+                    if (result)
+                        return result;
+                }
+            }
+            else if (child?.startLine) {
+                return child.startLine;
+            }
+        }
+        return undefined;
+    }
+    extractAnnotation(ctx) {
+        const children = ctx.children || ctx;
+        // Get annotation name
+        let name = '';
+        if (children.typeName?.[0]) {
+            name = this.extractTypeName(children.typeName[0]);
+        }
+        else if (children.Identifier) {
+            name = children.Identifier.map((id) => id.image).join('.');
+        }
+        if (!name)
+            return null;
+        // Remove @ prefix if present
+        name = name.replace(/^@/, '');
+        // Extract annotation values
+        const values = {};
+        if (children.elementValuePairList?.[0]) {
+            this.extractElementValuePairs(children.elementValuePairList[0], values);
+        }
+        else if (children.elementValue?.[0]) {
+            // Single value annotation like @GetMapping("/path")
+            values['value'] = this.extractElementValue(children.elementValue[0]);
+        }
+        return { name, values };
+    }
+    extractElementValuePairs(ctx, values) {
+        const children = ctx.children || ctx;
+        const pairs = children.elementValuePair || [];
+        for (const pair of pairs) {
+            const pairChildren = pair.children || pair;
+            const key = pairChildren.Identifier?.[0]?.image || 'value';
+            const value = this.extractElementValue(pairChildren.elementValue?.[0]);
+            values[key] = value;
+        }
+    }
+    extractElementValue(ctx) {
+        if (!ctx)
+            return '';
+        const children = ctx.children || ctx;
+        // Array initializer
+        if (children.elementValueArrayInitializer?.[0]) {
+            const arrayInit = children.elementValueArrayInitializer[0];
+            const arrayChildren = arrayInit.children || arrayInit;
+            const elementValues = arrayChildren.elementValue || [];
+            return elementValues.map((ev) => this.extractElementValue(ev)).flat();
+        }
+        // Conditional expression (includes literals and identifiers)
+        if (children.conditionalExpression?.[0]) {
+            return this.extractExpressionValue(children.conditionalExpression[0]);
+        }
+        // Annotation
+        if (children.annotation?.[0]) {
+            return this.extractAnnotationAsString(children.annotation[0]);
+        }
+        return '';
+    }
+    extractExpressionValue(ctx) {
+        const children = ctx.children || ctx;
+        // Handle string literals
+        if (children.StringLiteral?.[0]) {
+            return children.StringLiteral[0].image.replace(/^"|"$/g, '');
+        }
+        // Handle boolean literals
+        if (children.True?.[0])
+            return 'true';
+        if (children.False?.[0])
+            return 'false';
+        // Handle numeric literals
+        if (children.IntegerLiteral?.[0])
+            return children.IntegerLiteral[0].image;
+        if (children.FloatingPointLiteral?.[0])
+            return children.FloatingPointLiteral[0].image;
+        // Handle identifiers (enum values, etc.)
+        if (children.Identifier?.[0])
+            return children.Identifier[0].image;
+        // Recursively search for values in nested structures
+        for (const key of Object.keys(children)) {
+            if (Array.isArray(children[key]) && children[key].length > 0) {
+                const result = this.extractExpressionValue(children[key][0]);
+                if (result)
+                    return result;
+            }
+        }
+        return '';
+    }
+    extractAnnotationAsString(ctx) {
+        const children = ctx.children || ctx;
+        let name = '';
+        if (children.typeName?.[0]) {
+            name = this.extractTypeName(children.typeName[0]);
+        }
+        return `@${name}`;
+    }
+    extractTypeName(ctx) {
+        const children = ctx.children || ctx;
+        if (children.Identifier) {
+            return children.Identifier.map((id) => id.image).join('.');
+        }
+        return '';
+    }
+    extractMethodName(methodHeader) {
+        const children = methodHeader.children || methodHeader;
+        const declarator = children.methodDeclarator?.[0];
+        if (declarator) {
+            const declChildren = declarator.children || declarator;
+            return declChildren.Identifier?.[0]?.image || '';
+        }
+        return '';
+    }
+    extractReturnType(methodHeader) {
+        const children = methodHeader.children || methodHeader;
+        const result = children.result?.[0];
+        if (!result)
+            return { type: 'void' };
+        const resultChildren = result.children || result;
+        if (resultChildren.Void) {
+            return { type: 'void' };
+        }
+        if (resultChildren.unannType?.[0]) {
+            return this.extractType(resultChildren.unannType[0]);
+        }
+        return { type: 'Object' };
+    }
+    extractType(typeCtx) {
+        const children = typeCtx.children || typeCtx;
+        // Handle primitive types with optional dims suffix (e.g., boolean, int, etc.)
+        if (children.unannPrimitiveTypeWithOptionalDimsSuffix?.[0]) {
+            const primitiveWithDims = children.unannPrimitiveTypeWithOptionalDimsSuffix[0].children || children.unannPrimitiveTypeWithOptionalDimsSuffix[0];
+            if (primitiveWithDims.unannPrimitiveType?.[0]) {
+                const primitiveChildren = primitiveWithDims.unannPrimitiveType[0].children || primitiveWithDims.unannPrimitiveType[0];
+                return this.extractPrimitiveType(primitiveChildren);
+            }
+        }
+        // Handle primitive types directly (fallback for older parser versions)
+        if (children.unannPrimitiveType?.[0]) {
+            const primitiveChildren = children.unannPrimitiveType[0].children || children.unannPrimitiveType[0];
+            return this.extractPrimitiveType(primitiveChildren);
+        }
+        // Handle reference types
+        if (children.unannReferenceType?.[0]) {
+            return this.extractReferenceType(children.unannReferenceType[0]);
+        }
+        return { type: 'Object' };
+    }
+    extractPrimitiveType(primitiveChildren) {
+        if (primitiveChildren.numericType?.[0]) {
+            const numericChildren = primitiveChildren.numericType[0].children || primitiveChildren.numericType[0];
+            if (numericChildren.integralType?.[0]) {
+                const integralChildren = numericChildren.integralType[0].children || numericChildren.integralType[0];
+                for (const key of ['Int', 'Long', 'Short', 'Byte', 'Char']) {
+                    if (integralChildren[key])
+                        return { type: key.toLowerCase() };
+                }
+            }
+            if (numericChildren.floatingPointType?.[0]) {
+                const floatChildren = numericChildren.floatingPointType[0].children || numericChildren.floatingPointType[0];
+                if (floatChildren.Float)
+                    return { type: 'float' };
+                if (floatChildren.Double)
+                    return { type: 'double' };
+            }
+        }
+        if (primitiveChildren.Boolean)
+            return { type: 'boolean' };
+        return { type: 'Object' };
+    }
+    extractReferenceType(refTypeCtx) {
+        const children = refTypeCtx.children || refTypeCtx;
+        // Handle class or interface type
+        if (children.unannClassOrInterfaceType?.[0]) {
+            return this.extractClassOrInterfaceType(children.unannClassOrInterfaceType[0]);
+        }
+        // Handle array type
+        if (children.unannArrayType?.[0]) {
+            const arrayChildren = children.unannArrayType[0].children || children.unannArrayType[0];
+            if (arrayChildren.unannClassOrInterfaceType?.[0]) {
+                const innerType = this.extractClassOrInterfaceType(arrayChildren.unannClassOrInterfaceType[0]);
+                return { type: `${innerType.type}[]`, genericType: innerType.genericType };
+            }
+        }
+        return { type: 'Object' };
+    }
+    extractClassOrInterfaceType(ctx) {
+        const children = ctx.children || ctx;
+        let type = '';
+        let genericType;
+        // Handle the class type
+        if (children.unannClassType?.[0]) {
+            const classTypeChildren = children.unannClassType[0].children || children.unannClassType[0];
+            // Get the class name from annotation chain or directly
+            if (classTypeChildren.Identifier) {
+                type = classTypeChildren.Identifier.map((id) => id.image).join('.');
+            }
+            // Check for generic type arguments
+            if (classTypeChildren.typeArguments?.[0]) {
+                genericType = this.extractTypeArguments(classTypeChildren.typeArguments[0]);
+            }
+        }
+        return { type: type || 'Object', genericType };
+    }
+    extractTypeArguments(ctx) {
+        const children = ctx.children || ctx;
+        const typeArgumentList = children.typeArgumentList?.[0];
+        if (!typeArgumentList)
+            return '';
+        const typeArgChildren = typeArgumentList.children || typeArgumentList;
+        const typeArguments = typeArgChildren.typeArgument || [];
+        const types = typeArguments.map((arg) => {
+            const argChildren = arg.children || arg;
+            if (argChildren.referenceType?.[0]) {
+                const refType = this.extractReferenceTypeFromGeneric(argChildren.referenceType[0]);
+                return refType;
+            }
+            if (argChildren.wildcard?.[0]) {
+                return '?';
+            }
+            return 'Object';
+        });
+        return types.join(', ');
+    }
+    extractReferenceTypeFromGeneric(refTypeCtx) {
+        const children = refTypeCtx.children || refTypeCtx;
+        if (children.classOrInterfaceType?.[0]) {
+            const classTypeChildren = children.classOrInterfaceType[0].children || children.classOrInterfaceType[0];
+            if (classTypeChildren.classType?.[0]) {
+                const innerClassChildren = classTypeChildren.classType[0].children || classTypeChildren.classType[0];
+                if (innerClassChildren.Identifier) {
+                    let typeName = innerClassChildren.Identifier.map((id) => id.image).join('.');
+                    // Handle nested generic types
+                    if (innerClassChildren.typeArguments?.[0]) {
+                        const nestedGenerics = this.extractTypeArguments(innerClassChildren.typeArguments[0]);
+                        if (nestedGenerics) {
+                            typeName += `<${nestedGenerics}>`;
+                        }
+                    }
+                    return typeName;
+                }
+            }
+        }
+        return 'Object';
+    }
+    extractParameters(methodHeader) {
+        const children = methodHeader.children || methodHeader;
+        const declarator = children.methodDeclarator?.[0];
+        if (!declarator)
+            return [];
+        const declChildren = declarator.children || declarator;
+        const formalParameterList = declChildren.formalParameterList?.[0];
+        if (!formalParameterList)
+            return [];
+        const formalChildren = formalParameterList.children || formalParameterList;
+        const parameters = [];
+        // Handle regular formal parameters
+        if (formalChildren.formalParameter) {
+            for (const param of formalChildren.formalParameter) {
+                const parameter = this.extractFormalParameter(param);
+                if (parameter) {
+                    parameters.push(parameter);
+                }
+            }
+        }
+        return parameters;
+    }
+    extractFormalParameter(paramCtx) {
+        let children = paramCtx.children || paramCtx;
+        // Handle variableParaRegularParameter wrapper
+        if (children.variableParaRegularParameter?.[0]) {
+            children = children.variableParaRegularParameter[0].children || children.variableParaRegularParameter[0];
+        }
+        // Extract annotations from variableModifier
+        const annotations = [];
+        if (children.variableModifier) {
+            for (const modifier of children.variableModifier) {
+                const modChildren = modifier.children || modifier;
+                if (modChildren.annotation?.[0]) {
+                    const annotation = this.extractAnnotation(modChildren.annotation[0]);
+                    if (annotation) {
+                        annotations.push(annotation);
+                    }
+                }
+            }
+        }
+        // Extract type
+        let type = 'Object';
+        let genericType;
+        if (children.unannType?.[0]) {
+            const typeInfo = this.extractType(children.unannType[0]);
+            type = typeInfo.type;
+            genericType = typeInfo.genericType;
+        }
+        // Extract parameter name
+        let name = '';
+        if (children.variableDeclaratorId?.[0]) {
+            const varIdChildren = children.variableDeclaratorId[0].children || children.variableDeclaratorId[0];
+            name = varIdChildren.Identifier?.[0]?.image || '';
+        }
+        if (!name)
+            return null;
+        return {
+            name,
+            type,
+            genericType,
+            annotations,
+        };
+    }
+    extractFieldNames(variableDeclaratorList) {
+        const children = variableDeclaratorList.children || variableDeclaratorList;
+        const declarators = children.variableDeclarator || [];
+        const names = [];
+        for (const declarator of declarators) {
+            const declChildren = declarator.children || declarator;
+            if (declChildren.variableDeclaratorId?.[0]) {
+                const varIdChildren = declChildren.variableDeclaratorId[0].children || declChildren.variableDeclaratorId[0];
+                const name = varIdChildren.Identifier?.[0]?.image;
+                if (name) {
+                    names.push(name);
+                }
+            }
+        }
+        return names;
+    }
+}
+function parseJavaSource(sourceDir) {
+    const parser = new JavaFileParser(sourceDir);
+    return parser.parseAllJavaFiles();
+}
+//# sourceMappingURL=javaParser.js.map