@grafema/core 0.1.0-alpha.5 → 0.2.0-beta

package/dist/plugins/analysis/ast/visitors/FunctionVisitor.js

@@ -6,16 +6,24 @@
  * - ArrowFunctionExpression (module-level)
  */
 import { ASTVisitor } from './ASTVisitor.js';
+import { typeNodeToString } from './TypeScriptVisitor.js';
+import { IdGenerator } from '../IdGenerator.js';
+import { createParameterNodes } from '../utils/createParameterNodes.js';
+import { getLine, getColumn } from '../utils/location.js';
+import { ConstructorCallNode } from '../../../../core/nodes/ConstructorCallNode.js';
 export class FunctionVisitor extends ASTVisitor {
     analyzeFunctionBody;
+    scopeTracker;
     /**
      * @param module - Current module being analyzed
      * @param collections - Must contain arrays and counter refs
      * @param analyzeFunctionBody - Callback to analyze function internals
+     * @param scopeTracker - REQUIRED for semantic ID generation
      */
-    constructor(module, collections, analyzeFunctionBody) {
+    constructor(module, collections, analyzeFunctionBody, scopeTracker) {
         super(module, collections);
         this.analyzeFunctionBody = analyzeFunctionBody;
+        this.scopeTracker = scopeTracker;
     }
     getHandlers() {
         const { module } = this;
@@ -23,71 +31,96 @@ export class FunctionVisitor extends ASTVisitor {
         const parameters = this.collections.parameters ?? [];
         const scopes = this.collections.scopes ?? [];
         const functionCounterRef = (this.collections.functionCounterRef ?? { value: 0 });
-        const moduleScopeCtx = this.collections.moduleScopeCtx;
+        const scopeTracker = this.scopeTracker;
         const analyzeFunctionBody = this.analyzeFunctionBody;
         const collections = this.collections;
         // Helper function to generate stable anonymous function name
         const generateAnonymousName = () => {
-            if (!moduleScopeCtx)
-                return 'anonymous';
-            const index = moduleScopeCtx.siblingCounters.get('anonymous') || 0;
-            moduleScopeCtx.siblingCounters.set('anonymous', index + 1);
+            const index = scopeTracker.getSiblingIndex('anonymous');
             return `anonymous[${index}]`;
         };
-        // Helper function to create PARAMETER nodes for function params
-        const createParameterNodes = (params, functionId, file, line) => {
-            if (!parameters)
-                return; // Guard for backward compatibility
-            params.forEach((param, index) => {
-                // Handle different parameter types
+        // Helper function to extract parameter names and types from function params
+        const extractParamInfo = (params) => {
+            const names = [];
+            const types = [];
+            params.forEach((param) => {
                 if (param.type === 'Identifier') {
-                    const paramId = `PARAMETER#${param.name}#${file}#${line}:${index}`;
-                    parameters.push({
-                        id: paramId,
-                        type: 'PARAMETER',
-                        name: param.name,
-                        file: file,
-                        line: param.loc?.start.line || line,
-                        index: index,
-                        parentFunctionId: functionId
-                    });
+                    const id = param;
+                    names.push(id.name);
+                    // Check for type annotation
+                    const typeAnnotation = id.typeAnnotation?.typeAnnotation;
+                    types.push(typeAnnotation ? typeNodeToString(typeAnnotation) : 'any');
                 }
                 else if (param.type === 'AssignmentPattern') {
-                    // Default parameter: function(a = 1)
                     const assignmentParam = param;
                     if (assignmentParam.left.type === 'Identifier') {
-                        const paramId = `PARAMETER#${assignmentParam.left.name}#${file}#${line}:${index}`;
-                        parameters.push({
-                            id: paramId,
-                            type: 'PARAMETER',
-                            name: assignmentParam.left.name,
-                            file: file,
-                            line: assignmentParam.left.loc?.start.line || line,
-                            index: index,
-                            hasDefault: true,
-                            parentFunctionId: functionId
-                        });
+                        const id = assignmentParam.left;
+                        names.push(id.name + '?');
+                        const typeAnnotation = id.typeAnnotation?.typeAnnotation;
+                        types.push(typeAnnotation ? typeNodeToString(typeAnnotation) : 'any');
                     }
                 }
                 else if (param.type === 'RestElement') {
-                    // Rest parameter: function(...args)
                     const restParam = param;
                     if (restParam.argument.type === 'Identifier') {
-                        const paramId = `PARAMETER#${restParam.argument.name}#${file}#${line}:${index}`;
-                        parameters.push({
-                            id: paramId,
-                            type: 'PARAMETER',
-                            name: restParam.argument.name,
-                            file: file,
-                            line: restParam.argument.loc?.start.line || line,
-                            index: index,
-                            isRest: true,
-                            parentFunctionId: functionId
-                        });
+                        const id = restParam.argument;
+                        names.push('...' + id.name);
+                        const typeAnnotation = id.typeAnnotation?.typeAnnotation;
+                        types.push(typeAnnotation ? typeNodeToString(typeAnnotation) : 'any[]');
                     }
                 }
-                // ObjectPattern and ArrayPattern (destructuring parameters) can be added later
             });
+            return { names, types };
+        };
+        // Helper function to extract return type from function
+        const extractReturnType = (node) => {
+            const returnTypeAnnotation = node.returnType?.typeAnnotation;
+            if (returnTypeAnnotation) {
+                return typeNodeToString(returnTypeAnnotation);
+            }
+            return 'void';
+        };
+        // Helper function to extract JSDoc summary from leading comments
+        const extractJsdocSummary = (node) => {
+            const comments = node.leadingComments;
+            if (!comments || comments.length === 0)
+                return undefined;
+            // Find the last block comment that looks like JSDoc
+            for (let i = comments.length - 1; i >= 0; i--) {
+                const comment = comments[i];
+                if (comment.type === 'CommentBlock' && comment.value.startsWith('*')) {
+                    // Parse JSDoc - get first non-empty line after the opening
+                    const lines = comment.value.split('\n');
+                    for (const line of lines) {
+                        const trimmed = line.replace(/^\s*\*\s?/, '').trim();
+                        // Skip empty lines and @tags
+                        if (trimmed && !trimmed.startsWith('@')) {
+                            return trimmed.slice(0, 200); // Limit length
+                        }
+                    }
+                }
+            }
+            return undefined;
+        };
+        // Helper function to build function signature
+        const buildSignature = (params, paramTypes, returnType, isAsync) => {
+            const paramParts = params.map((name, i) => {
+                const type = paramTypes[i] || 'any';
+                // Handle rest params
+                if (name.startsWith('...')) {
+                    return `${name}: ${type}`;
+                }
+                // Handle optional params (with ?)
+                if (name.endsWith('?')) {
+                    return `${name}: ${type}`;
+                }
+                return `${name}: ${type}`;
+            });
+            const paramsStr = `(${paramParts.join(', ')})`;
+            const retStr = isAsync && !returnType.startsWith('Promise')
+                ? `Promise<${returnType}>`
+                : returnType;
+            return `${paramsStr} => ${retStr}`;
         };
         return {
             // Regular function declarations
@@ -95,21 +128,36 @@ export class FunctionVisitor extends ASTVisitor {
                 const node = path.node;
                 if (!node.id)
                     return; // Skip anonymous function declarations
-                const functionId = `FUNCTION#${node.id.name}#${module.file}#${node.loc.start.line}`;
+                const isAsync = node.async || false;
+                const line = getLine(node);
+                // Generate ID using centralized IdGenerator
+                const idGenerator = new IdGenerator(scopeTracker);
+                const functionId = idGenerator.generateSimple('FUNCTION', node.id.name, module.file, line);
+                // Extract type info
+                const { names: paramNames, types: paramTypes } = extractParamInfo(node.params);
+                const returnType = extractReturnType(node);
+                const jsdocSummary = extractJsdocSummary(node);
+                const signature = buildSignature(paramNames, paramTypes, returnType, isAsync);
                 functions.push({
                     id: functionId,
-                    stableId: functionId,
                     type: 'FUNCTION',
                     name: node.id.name,
                     file: module.file,
-                    line: node.loc.start.line,
-                    async: node.async || false,
-                    generator: node.generator || false
+                    line,
+                    async: isAsync,
+                    generator: node.generator || false,
+                    params: paramNames,
+                    paramTypes,
+                    returnType,
+                    signature,
+                    jsdocSummary
                 });
+                // Enter function scope BEFORE creating parameters (semantic IDs need function context)
+                scopeTracker.enterScope(node.id.name, 'FUNCTION');
                 // Create PARAMETER nodes for function parameters
-                createParameterNodes(node.params, functionId, module.file, node.loc.start.line);
+                createParameterNodes(node.params, functionId, module.file, getLine(node), parameters, scopeTracker);
                 // Create SCOPE for function body
-                const functionBodyScopeId = `SCOPE#${node.id.name}:body#${module.file}#${node.loc.start.line}`;
+                const functionBodyScopeId = idGenerator.generateScope('body', `${node.id.name}:body`, module.file, line);
                 scopes.push({
                     id: functionBodyScopeId,
                     type: 'SCOPE',
@@ -117,19 +165,22 @@ export class FunctionVisitor extends ASTVisitor {
                     name: `${node.id.name}:body`,
                     conditional: false,
                     file: module.file,
-                    line: node.loc.start.line,
+                    line,
                     parentFunctionId: functionId
                 });
                 // Analyze function body
                 analyzeFunctionBody(path, functionBodyScopeId, module, collections);
+                // Exit function scope
+                scopeTracker.exitScope();
                 // Stop traversal - analyzeFunctionBody already processed contents
                 path.skip();
             },
             // Arrow functions (module-level, assigned to variables or as callbacks)
             ArrowFunctionExpression: (path) => {
                 const node = path.node;
-                const line = node.loc.start.line;
-                const column = node.loc.start.column;
+                const line = getLine(node);
+                const column = getColumn(node);
+                const isAsync = node.async || false;
                 // Determine arrow function name (use scope-level counter for stable semanticId)
                 let functionName = generateAnonymousName();
                 // If arrow function is assigned to variable: const add = () => {}
@@ -140,22 +191,35 @@ export class FunctionVisitor extends ASTVisitor {
                         functionName = declarator.id.name;
                     }
                 }
-                const functionId = `FUNCTION#${functionName}#${module.file}#${line}:${column}:${functionCounterRef.value++}`;
+                // Generate ID using centralized IdGenerator
+                const idGenerator = new IdGenerator(scopeTracker);
+                const functionId = idGenerator.generate('FUNCTION', functionName, module.file, line, column, functionCounterRef);
+                // Extract type info
+                const { names: paramNames, types: paramTypes } = extractParamInfo(node.params);
+                const returnType = extractReturnType(node);
+                const jsdocSummary = extractJsdocSummary(node);
+                const signature = buildSignature(paramNames, paramTypes, returnType, isAsync);
                 functions.push({
                     id: functionId,
-                    stableId: functionId,
                     type: 'FUNCTION',
                     name: functionName,
                     file: module.file,
                     line,
                     column,
-                    async: node.async || false,
-                    arrowFunction: true
+                    async: isAsync,
+                    arrowFunction: true,
+                    params: paramNames,
+                    paramTypes,
+                    returnType,
+                    signature,
+                    jsdocSummary
                 });
+                // Enter function scope BEFORE creating parameters (semantic IDs need function context)
+                scopeTracker.enterScope(functionName, 'FUNCTION');
                 // Create PARAMETER nodes for arrow function parameters
-                createParameterNodes(node.params, functionId, module.file, line);
+                createParameterNodes(node.params, functionId, module.file, line, parameters, scopeTracker);
                 // Create SCOPE for arrow function body
-                const bodyScope = `SCOPE#${functionName}:body#${module.file}#${line}:${column}`;
+                const bodyScope = idGenerator.generateScope('body', `${functionName}:body`, module.file, line, column);
                 scopes.push({
                     id: bodyScope,
                     type: 'SCOPE',
@@ -165,8 +229,71 @@ export class FunctionVisitor extends ASTVisitor {
                     scopeType: 'function-body',
                     parentFunctionId: functionId
                 });
+                // REG-334: Detect Promise executor context BEFORE analyzing body
+                // This must happen before analyzeFunctionBody so resolve/reject calls can be linked
+                this.detectPromiseExecutorContext(path, node, module, collections);
                 analyzeFunctionBody(path, bodyScope, module, collections);
+                // Exit function scope
+                scopeTracker.exitScope();
+                // Stop traversal - analyzeFunctionBody already processed contents
+                // Without this, babel traverse continues into arrow body and finds
+                // nested arrow functions, causing duplicate FUNCTION nodes
+                path.skip();
             }
         };
     }
+    /**
+     * REG-334: Detect if this function is a Promise executor callback.
+     * If so, register the context so resolve/reject calls can be linked.
+     *
+     * Pattern: new Promise((resolve, reject) => { ... })
+     *
+     * Must be called BEFORE analyzeFunctionBody so the context is available
+     * when resolve/reject calls are processed.
+     */
+    detectPromiseExecutorContext(path, node, module, collections) {
+        // Check if this function is the first argument to new Promise()
+        const parent = path.parent;
+        if (parent?.type !== 'NewExpression')
+            return;
+        const newExpr = parent;
+        // Check it's Promise constructor
+        if (newExpr.callee.type !== 'Identifier')
+            return;
+        if (newExpr.callee.name !== 'Promise')
+            return;
+        // Check this function is the first argument
+        if (newExpr.arguments.length === 0)
+            return;
+        if (newExpr.arguments[0] !== node)
+            return;
+        // Extract resolve/reject parameter names
+        let resolveName;
+        let rejectName;
+        if (node.params.length > 0 && node.params[0].type === 'Identifier') {
+            resolveName = node.params[0].name;
+        }
+        if (node.params.length > 1 && node.params[1].type === 'Identifier') {
+            rejectName = node.params[1].name;
+        }
+        if (!resolveName)
+            return; // No resolve parameter, nothing to track
+        // Generate the CONSTRUCTOR_CALL ID for linking
+        const line = getLine(newExpr);
+        const column = getColumn(newExpr);
+        const constructorCallId = ConstructorCallNode.generateId('Promise', module.file, line, column);
+        // Initialize promiseExecutorContexts if not exists
+        if (!collections.promiseExecutorContexts) {
+            collections.promiseExecutorContexts = new Map();
+        }
+        // Key by function node position to allow nested Promise detection
+        const funcKey = `${node.start}:${node.end}`;
+        collections.promiseExecutorContexts.set(funcKey, {
+            constructorCallId,
+            resolveName,
+            rejectName,
+            file: module.file,
+            line: getLine(node)
+        });
+    }
 }

package/dist/plugins/analysis/ast/visitors/ImportExportVisitor.d.ts

@@ -23,6 +23,10 @@ export declare class ImportExportVisitor extends ASTVisitor {
      */
     constructor(module: VisitorModule, collections: VisitorCollections, extractVariableNamesFromPattern: ExtractVariableNamesCallback);
     getImportHandlers(): VisitorHandlers;
+    /**
+     * Convert a TemplateLiteral to a string representation for debugging
+     */
+    private templateLiteralToString;
     getExportHandlers(): VisitorHandlers;
     getHandlers(): VisitorHandlers;
 }

package/dist/plugins/analysis/ast/visitors/ImportExportVisitor.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ImportExportVisitor.d.ts","sourceRoot":"","sources":["../../../../../src/plugins/analysis/ast/visitors/ImportExportVisitor.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,KAAK,EAaV,IAAI,EACL,MAAM,cAAc,CAAC;AAEtB,OAAO,EAAE,UAAU,EAAE,KAAK,aAAa,EAAE,KAAK,kBAAkB,EAAE,KAAK,eAAe,EAAE,MAAM,iBAAiB,CAAC;AAChH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAC;AAEzD;;GAEG;AACH,MAAM,MAAM,4BAA4B,GAAG,CAAC,OAAO,EAAE,IAAI,KAAK,YAAY,EAAE,CAAC;AAuC7E,qBAAa,mBAAoB,SAAQ,UAAU;IACjD,OAAO,CAAC,+BAA+B,CAA+B;IAEtE;;;;OAIG;gBAED,MAAM,EAAE,aAAa,EACrB,WAAW,EAAE,kBAAkB,EAC/B,+BAA+B,EAAE,4BAA4B;IAM/D,iBAAiB,IAAI,eAAe;IA+CpC,iBAAiB,IAAI,eAAe;IAqHpC,WAAW,IAAI,eAAe;CAM/B"}
+{"version":3,"file":"ImportExportVisitor.d.ts","sourceRoot":"","sources":["../../../../../src/plugins/analysis/ast/visitors/ImportExportVisitor.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,KAAK,EAaV,IAAI,EAGL,MAAM,cAAc,CAAC;AAEtB,OAAO,EAAE,UAAU,EAAE,KAAK,aAAa,EAAE,KAAK,kBAAkB,EAAE,KAAK,eAAe,EAAE,MAAM,iBAAiB,CAAC;AAChH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAC;AAGzD;;GAEG;AACH,MAAM,MAAM,4BAA4B,GAAG,CAAC,OAAO,EAAE,IAAI,KAAK,YAAY,EAAE,CAAC;AA2C7E,qBAAa,mBAAoB,SAAQ,UAAU;IACjD,OAAO,CAAC,+BAA+B,CAA+B;IAEtE;;;;OAIG;gBAED,MAAM,EAAE,aAAa,EACrB,WAAW,EAAE,kBAAkB,EAC/B,+BAA+B,EAAE,4BAA4B;IAM/D,iBAAiB,IAAI,eAAe;IAuIpC;;OAEG;IACH,OAAO,CAAC,uBAAuB;IAgB/B,iBAAiB,IAAI,eAAe;IAsHpC,WAAW,IAAI,eAAe;CAM/B"}

package/dist/plugins/analysis/ast/visitors/ImportExportVisitor.js

@@ -8,6 +8,7 @@
  * - ExportAllDeclaration: export * from './module'
  */
 import { ASTVisitor } from './ASTVisitor.js';
+import { getLine, getColumn } from '../utils/location.js';
 export class ImportExportVisitor extends ASTVisitor {
     extractVariableNamesFromPattern;
     /**
@@ -59,11 +60,113 @@ export class ImportExportVisitor extends ASTVisitor {
                 imports.push({
                     source,
                     specifiers,
-                    line: node.loc.start.line
+                    line: getLine(node),
+                    column: getColumn(node)
+                });
+            },
+            /**
+             * Handle dynamic import() expressions
+             * Examples:
+             * - import('./module.js')                    -> isResolvable: true
+             * - import(`./plugins/${name}.js`)           -> isResolvable: false, source: './plugins/'
+             * - import(modulePath)                       -> isResolvable: false, source: '<dynamic>'
+             */
+            CallExpression: (path) => {
+                const node = path.node;
+                // Check if this is an import() call
+                if (node.callee.type !== 'Import') {
+                    return;
+                }
+                const arg = node.arguments[0];
+                if (!arg)
+                    return;
+                let source;
+                let isResolvable;
+                let dynamicPath;
+                if (arg.type === 'StringLiteral') {
+                    // import('./module.js') - literal path, fully resolvable
+                    source = arg.value;
+                    isResolvable = true;
+                }
+                else if (arg.type === 'TemplateLiteral') {
+                    // import(`./plugins/${name}.js`) - template literal
+                    const templateArg = arg;
+                    const firstQuasi = templateArg.quasis[0];
+                    // Extract static prefix (part before first expression)
+                    const prefix = firstQuasi?.value?.raw || '';
+                    if (prefix) {
+                        source = prefix;
+                    }
+                    else {
+                        // No static prefix - e.g., import(`${baseDir}/loader.js`)
+                        source = '<dynamic>';
+                    }
+                    isResolvable = false;
+                    // Capture the original template for debugging/analysis
+                    dynamicPath = this.templateLiteralToString(templateArg);
+                }
+                else if (arg.type === 'Identifier') {
+                    // import(modulePath) - variable path
+                    source = '<dynamic>';
+                    isResolvable = false;
+                    dynamicPath = arg.name;
+                }
+                else {
+                    // Other expressions (e.g., function calls, member expressions)
+                    source = '<dynamic>';
+                    isResolvable = false;
+                }
+                // Find the receiving variable name from parent
+                // Patterns: const mod = await import(...) or const mod = import(...)
+                let localName = '*'; // Default for side-effect imports
+                const parent = path.parent;
+                if (parent?.type === 'AwaitExpression') {
+                    // const mod = await import(...)
+                    const awaitParent = path.parentPath?.parent;
+                    if (awaitParent?.type === 'VariableDeclarator' &&
+                        awaitParent.id?.type === 'Identifier') {
+                        localName = awaitParent.id.name;
+                    }
+                }
+                else if (parent?.type === 'VariableDeclarator' &&
+                    parent.id?.type === 'Identifier') {
+                    // const mod = import(...) (without await)
+                    localName = parent.id.name;
+                }
+                imports.push({
+                    source,
+                    specifiers: [{
+                            imported: '*', // Dynamic imports are always namespace imports
+                            local: localName
+                        }],
+                    line: getLine(node),
+                    column: getColumn(node),
+                    isDynamic: true,
+                    isResolvable,
+                    dynamicPath
                 });
             }
         };
     }
+    /**
+     * Convert a TemplateLiteral to a string representation for debugging
+     */
+    templateLiteralToString(template) {
+        let result = '';
+        for (let i = 0; i < template.quasis.length; i++) {
+            result += template.quasis[i].value.raw;
+            if (i < template.expressions.length) {
+                const expr = template.expressions[i];
+                if (expr.type === 'Identifier') {
+                    result += `\${${expr.name}}`;
+                }
+                else {
+                    result += '${...}';
+                }
+            }
+        }
+        return result;
+    }
     getExportHandlers() {
         const { exports } = this.collections;
         const extractVariableNamesFromPattern = this.extractVariableNamesFromPattern;
@@ -72,12 +175,13 @@ export class ImportExportVisitor extends ASTVisitor {
                 const node = path.node;
                 exports.push({
                     type: 'default',
-                    line: node.loc.start.line,
+                    line: getLine(node),
                     declaration: node.declaration
                 });
             },
             ExportNamedDeclaration: (path) => {
                 const node = path.node;
+                const exportLine = getLine(node);
                 // export { foo, bar } from './module'
                 if (node.source) {
                     const specifiers = node.specifiers.map((spec) => {
@@ -95,7 +199,7 @@ export class ImportExportVisitor extends ASTVisitor {
                     });
                     exports.push({
                         type: 'named',
-                        line: node.loc.start.line,
+                        line: exportLine,
                         specifiers,
                         source: node.source.value
                     });
@@ -114,7 +218,7 @@ export class ImportExportVisitor extends ASTVisitor {
                     });
                     exports.push({
                         type: 'named',
-                        line: node.loc.start.line,
+                        line: exportLine,
                         specifiers
                     });
                 }
@@ -127,7 +231,7 @@ export class ImportExportVisitor extends ASTVisitor {
                         if (funcDecl.id) {
                             exports.push({
                                 type: 'named',
-                                line: node.loc.start.line,
+                                line: exportLine,
                                 name: funcDecl.id.name
                             });
                         }
@@ -141,7 +245,7 @@ export class ImportExportVisitor extends ASTVisitor {
                             variables.forEach((varInfo) => {
                                 exports.push({
                                     type: 'named',
-                                    line: node.loc.start.line,
+                                    line: exportLine,
                                     name: varInfo.name
                                 });
                             });
@@ -153,7 +257,7 @@ export class ImportExportVisitor extends ASTVisitor {
                         if (classDecl.id) {
                             exports.push({
                                 type: 'named',
-                                line: node.loc.start.line,
+                                line: exportLine,
                                 name: classDecl.id.name
                             });
                         }
@@ -165,7 +269,7 @@ export class ImportExportVisitor extends ASTVisitor {
                 // export * from './module'
                 exports.push({
                     type: 'all',
-                    line: node.loc.start.line,
+                    line: getLine(node),
                     source: node.source.value
                 });
             }

package/dist/plugins/analysis/ast/visitors/TypeScriptVisitor.d.ts

@@ -7,8 +7,19 @@
  * - TSEnumDeclaration
  */
 import { ASTVisitor, type VisitorModule, type VisitorCollections, type VisitorHandlers } from './ASTVisitor.js';
+import { ScopeTracker } from '../../../../core/ScopeTracker.js';
+/**
+ * Extracts a string representation of a TypeScript type node
+ */
+export declare function typeNodeToString(node: unknown): string;
 export declare class TypeScriptVisitor extends ASTVisitor {
-    constructor(module: VisitorModule, collections: VisitorCollections);
+    private scopeTracker?;
+    /**
+     * @param module - Current module being analyzed
+     * @param collections - Must contain interfaces, typeAliases, enums arrays
+     * @param scopeTracker - Optional ScopeTracker for semantic ID generation
+     */
+    constructor(module: VisitorModule, collections: VisitorCollections, scopeTracker?: ScopeTracker);
     getHandlers(): VisitorHandlers;
 }
 //# sourceMappingURL=TypeScriptVisitor.d.ts.map

package/dist/plugins/analysis/ast/visitors/TypeScriptVisitor.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"TypeScriptVisitor.d.ts","sourceRoot":"","sources":["../../../../../src/plugins/analysis/ast/visitors/TypeScriptVisitor.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAaH,OAAO,EAAE,UAAU,EAAE,KAAK,aAAa,EAAE,KAAK,kBAAkB,EAAE,KAAK,eAAe,EAAE,MAAM,iBAAiB,CAAC;AA8EhH,qBAAa,iBAAkB,SAAQ,UAAU;gBACnC,MAAM,EAAE,aAAa,EAAE,WAAW,EAAE,kBAAkB;IAIlE,WAAW,IAAI,eAAe;CAmI/B"}
+{"version":3,"file":"TypeScriptVisitor.d.ts","sourceRoot":"","sources":["../../../../../src/plugins/analysis/ast/visitors/TypeScriptVisitor.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAaH,OAAO,EAAE,UAAU,EAAE,KAAK,aAAa,EAAE,KAAK,kBAAkB,EAAE,KAAK,eAAe,EAAE,MAAM,iBAAiB,CAAC;AAQhH,OAAO,EAAE,YAAY,EAAE,MAAM,kCAAkC,CAAC;AAIhE;;GAEG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,OAAO,GAAG,MAAM,CAgEtD;AAED,qBAAa,iBAAkB,SAAQ,UAAU;IAC/C,OAAO,CAAC,YAAY,CAAC,CAAe;IAEpC;;;;OAIG;gBACS,MAAM,EAAE,aAAa,EAAE,WAAW,EAAE,kBAAkB,EAAE,YAAY,CAAC,EAAE,YAAY;IAK/F,WAAW,IAAI,eAAe;CAmJ/B"}