@choi2021/next-route-visualizer/dist/parser/routeParser.js

🗺️ Visualize Next.js routes as an interactive diagram with advanced function analysis. Supports dynamic route detection, function-based navigation patterns, and comprehensive Next.js route mapping. Generate JSON data and beautiful HTML reports to explore

"use strict";
var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
    return new (P || (P = Promise))(function (resolve, reject) {
        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
        step((generator = generator.apply(thisArg, _arguments || [])).next());
    });
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.RouteParser = void 0;
exports.parseNextJsRoutes = parseNextJsRoutes;
const glob_1 = require("glob");
const path_1 = require("path");
const fs_1 = require("fs");
class RouteParser {
    constructor(projectPath, options = {}) {
        this.componentUsages = new Map();
        this.hookUsages = new Map();
        this.routeConstants = new Map();
        this.projectPath = (0, path_1.resolve)(projectPath);
        this.options = Object.assign({ depth: 10, exclude: ["node_modules", ".git", ".next", "build", "dist"], includeMetadata: true, analyzeNavigation: true }, options);
        this.excludePatterns = this.options.exclude || [];
    }
    parse() {
        return __awaiter(this, void 0, void 0, function* () {
            console.log(`🔍 Parsing Next.js project at: ${this.projectPath}`);
            // 1. Next.js 프로젝트 유효성 검사
            if (!this.isValidNextJsProject()) {
                throw new Error("Invalid Next.js project: package.json or next.config.js not found");
            }
            // 2. 실제 페이지 파일들만 스캔 (우선순위: pages/ > src/pages/)
            const pageFiles = yield this.scanPageFiles();
            console.log(`📂 Found ${pageFiles.length} page files`);
            // 3. 페이지 노드들 생성
            const nodes = yield this.createPageNodes(pageFiles);
            console.log(`🌳 Created ${nodes.length} page nodes`);
            // 4. 컴포넌트 사용 관계 분석
            if (this.options.analyzeNavigation) {
                yield this.analyzeComponentUsages(pageFiles);
                // 5. Routes 상수 파일 분석 (우선순위: 사용자 지정 > 자동 감지)
                if (this.options.routesFile) {
                    yield this.analyzeSpecificRouteFile(this.options.routesFile);
                }
                else {
                    yield this.analyzeRouteConstants();
                }
                // 6. 훅 사용 관계 분석
                yield this.analyzeHookUsages(pageFiles);
            }
            // 7. 네비게이션 관계 분석
            const edges = this.options.analyzeNavigation
                ? yield this.analyzeNavigation(pageFiles)
                : [];
            console.log(`🔗 Found ${edges.length} navigation connections`);
            // 8. 통계 계산
            const summary = this.calculateSummary(nodes, edges);
            return {
                nodes,
                edges,
                summary,
            };
        });
    }
    isValidNextJsProject() {
        const packageJsonPath = (0, path_1.join)(this.projectPath, "package.json");
        const nextConfigPaths = [
            (0, path_1.join)(this.projectPath, "next.config.js"),
            (0, path_1.join)(this.projectPath, "next.config.ts"),
            (0, path_1.join)(this.projectPath, "next.config.mjs"),
        ];
        if (!(0, fs_1.existsSync)(packageJsonPath)) {
            return false;
        }
        // Check if Next.js is in dependencies
        try {
            const packageJson = JSON.parse((0, fs_1.readFileSync)(packageJsonPath, "utf-8"));
            const hasNext = (packageJson.dependencies && packageJson.dependencies.next) ||
                (packageJson.devDependencies && packageJson.devDependencies.next);
            if (hasNext)
                return true;
        }
        catch (error) {
            console.warn("Could not parse package.json:", error.message);
        }
        // Check for next.config files
        return nextConfigPaths.some((configPath) => (0, fs_1.existsSync)(configPath));
    }
    scanPageFiles() {
        return __awaiter(this, void 0, void 0, function* () {
            // 우선순위에 따라 pages 디렉토리 결정
            const pagesRoot = (0, fs_1.existsSync)((0, path_1.join)(this.projectPath, "pages"))
                ? "pages"
                : "src/pages";
            const patterns = [`${pagesRoot}/**/*.{js,jsx,ts,tsx}`];
            const allFiles = [];
            for (const pattern of patterns) {
                const files = yield (0, glob_1.glob)(pattern, {
                    cwd: this.projectPath,
                    absolute: true,
                    ignore: [
                        ...this.excludePatterns.map((p) => `**/${p}/**`),
                        "**/api/**", // API 라우트 제외
                        "**/**/api/**",
                    ],
                });
                allFiles.push(...files);
            }
            // Remove duplicates and filter valid page files
            const uniqueFiles = [...new Set(allFiles)];
            const validFiles = uniqueFiles.filter((file) => this.isValidPageFile(file));
            return validFiles;
        });
    }
    scanComponentFiles() {
        return __awaiter(this, void 0, void 0, function* () {
            const patterns = [
                "components/**/*.{js,jsx,ts,tsx}",
                "src/components/**/*.{js,jsx,ts,tsx}",
                "lib/**/*.{js,jsx,ts,tsx}",
                "src/lib/**/*.{js,jsx,ts,tsx}",
                "utils/**/*.{js,jsx,ts,tsx}",
                "src/utils/**/*.{js,jsx,ts,tsx}",
            ];
            const allFiles = [];
            for (const pattern of patterns) {
                const files = yield (0, glob_1.glob)(pattern, {
                    cwd: this.projectPath,
                    absolute: true,
                    ignore: this.excludePatterns.map((p) => `**/${p}/**`),
                });
                allFiles.push(...files);
            }
            return [...new Set(allFiles)];
        });
    }
    isValidPageFile(filePath) {
        const relativePath = (0, path_1.relative)(this.projectPath, filePath);
        const fileName = (0, path_1.basename)(filePath, (0, path_1.extname)(filePath));
        // API 라우트 제외
        if (relativePath.includes("/api/") || relativePath.includes("\\api\\")) {
            return false;
        }
        // Next.js 특수 파일들 제외
        const excludeFiles = [
            "_app",
            "_document",
            "_error",
            "404",
            "500",
            "middleware",
        ];
        if (excludeFiles.includes(fileName)) {
            return false;
        }
        return true;
    }
    createPageNodes(files) {
        return __awaiter(this, void 0, void 0, function* () {
            const nodes = [];
            for (const filePath of files) {
                const node = yield this.createPageNode(filePath);
                if (node) {
                    nodes.push(node);
                }
            }
            // Sort by path for consistent ordering
            return nodes.sort((a, b) => a.path.localeCompare(b.path));
        });
    }
    createPageNode(filePath) {
        return __awaiter(this, void 0, void 0, function* () {
            try {
                const relativePath = (0, path_1.relative)(this.projectPath, filePath);
                const stats = (0, fs_1.statSync)(filePath);
                // Convert file path to route path
                const routePath = this.filePathToRoute(relativePath);
                const routeType = this.determineRouteType(routePath);
                const segments = this.extractRouteSegments(routePath);
                return {
                    id: routePath,
                    path: routePath,
                    label: routePath,
                    type: routeType,
                    filePath: relativePath,
                    fileSize: stats.size,
                    lastModified: stats.mtime,
                    children: [],
                    metadata: {
                        hasParams: this.hasRouteParams(routePath),
                        isCatchAll: this.isCatchAllRoute(routePath),
                        isOptionalCatchAll: this.isOptionalCatchAllRoute(routePath),
                        depth: segments.length,
                        segments,
                    },
                };
            }
            catch (error) {
                console.warn(`Warning: Could not process file ${filePath}:`, error.message);
                return null;
            }
        });
    }
    filePathToRoute(filePath) {
        let routePath = filePath;
        // Remove pages/ or src/pages/ prefix
        routePath = routePath.replace(/^(src\/)?pages\//, "");
        // Remove file extension
        routePath = routePath.replace(/\.(js|jsx|ts|tsx)$/, "");
        // Handle index files
        if (routePath === "index") {
            return "/";
        }
        if (routePath.endsWith("/index")) {
            routePath = routePath.replace(/\/index$/, "");
        }
        // Ensure starts with /
        if (!routePath.startsWith("/")) {
            routePath = "/" + routePath;
        }
        // Handle empty string case (from index processing)
        if (routePath === "/" || routePath === "") {
            return "/";
        }
        return routePath;
    }
    determineRouteType(routePath) {
        if (this.hasRouteParams(routePath)) {
            return "dynamic";
        }
        return "page";
    }
    extractRouteSegments(routePath) {
        if (routePath === "/")
            return [""];
        return routePath.split("/").filter(Boolean);
    }
    hasRouteParams(routePath) {
        return routePath.includes("[") && routePath.includes("]");
    }
    isCatchAllRoute(routePath) {
        return routePath.includes("[...") && routePath.includes("]");
    }
    isOptionalCatchAllRoute(routePath) {
        return routePath.includes("[[...") && routePath.includes("]]");
    }
    analyzeComponentUsages(pageFiles) {
        return __awaiter(this, void 0, void 0, function* () {
            const componentFiles = yield this.scanComponentFiles();
            // 각 컴포넌트에 대해 사용처와 네비게이션 분석
            for (const componentPath of componentFiles) {
                const relativePath = (0, path_1.relative)(this.projectPath, componentPath);
                const componentName = (0, path_1.basename)(componentPath, (0, path_1.extname)(componentPath));
                try {
                    const content = (0, fs_1.readFileSync)(componentPath, "utf-8");
                    // 컴포넌트에서 네비게이션 타겟 추출
                    const navigationTargets = this.extractNavigationTargets(content);
                    // 이 컴포넌트를 사용하는 페이지들 찾기
                    const usedInPages = [];
                    for (const pageFile of pageFiles) {
                        const pageContent = (0, fs_1.readFileSync)(pageFile, "utf-8");
                        const pageRelativePath = (0, path_1.relative)(this.projectPath, pageFile);
                        // 컴포넌트 import 또는 사용 확인
                        if (this.isComponentUsedInPage(pageContent, componentName)) {
                            const routePath = this.filePathToRoute(pageRelativePath);
                            usedInPages.push(routePath);
                        }
                    }
                    if (navigationTargets.length > 0 && usedInPages.length > 0) {
                        this.componentUsages.set(relativePath, {
                            componentPath: relativePath,
                            usedInPages,
                            navigationTargets,
                        });
                    }
                }
                catch (error) {
                    console.warn(`Warning: Could not analyze component ${relativePath}:`, error.message);
                }
            }
        });
    }
    isComponentUsedInPage(pageContent, componentName) {
        // import 문 확인
        const importPatterns = [
            new RegExp(`import.*${componentName}.*from`, "i"),
            new RegExp(`import.*{[^}]*${componentName}[^}]*}.*from`, "i"),
        ];
        // JSX 사용 확인
        const usagePatterns = [
            new RegExp(`<${componentName}[\\s>]`, "i"),
            new RegExp(`<${componentName}/>`, "i"),
        ];
        // import 확인
        const hasImport = importPatterns.some((pattern) => pattern.test(pageContent));
        // 사용 확인
        const hasUsage = usagePatterns.some((pattern) => pattern.test(pageContent));
        return hasImport && hasUsage;
    }
    extractNavigationTargets(content) {
        const targets = [];
        const lines = content.split("\n");
        lines.forEach((line) => {
            // Link components
            const linkMatches = line.matchAll(/<Link\s+href=["']([^"']+)["']/g);
            for (const match of linkMatches) {
                targets.push(match[1]);
            }
            // router.push calls
            const pushMatches = line.matchAll(/router\.push\(["']([^"']+)["']\)/g);
            for (const match of pushMatches) {
                targets.push(match[1]);
            }
            // router.replace calls
            const replaceMatches = line.matchAll(/router\.replace\(["']([^"']+)["']\)/g);
            for (const match of replaceMatches) {
                targets.push(match[1]);
            }
            // useRouter().push calls
            const useRouterPushMatches = line.matchAll(/\.push\(["']([^"']+)["']\)/g);
            for (const match of useRouterPushMatches) {
                targets.push(match[1]);
            }
            // useRouter().replace calls
            const useRouterReplaceMatches = line.matchAll(/\.replace\(["']([^"']+)["']\)/g);
            for (const match of useRouterReplaceMatches) {
                targets.push(match[1]);
            }
        });
        return [...new Set(targets)]; // 중복 제거
    }
    analyzeRouteConstants() {
        return __awaiter(this, void 0, void 0, function* () {
            const routeFiles = yield this.scanRouteConstantFiles();
            // 각 routes 상수 파일에 대해 분석
            for (const routeFilePath of routeFiles) {
                const relativePath = (0, path_1.relative)(this.projectPath, routeFilePath);
                const fileName = (0, path_1.basename)(routeFilePath, (0, path_1.extname)(routeFilePath));
                try {
                    const content = (0, fs_1.readFileSync)(routeFilePath, "utf-8");
                    // 상수 객체들을 추출
                    const routeConstants = this.extractRouteConstants(content);
                    if (routeConstants.size > 0) {
                        // 가장 가능성 높은 export 객체명 추론
                        const exportedObject = this.inferExportedObjectName(content, fileName);
                        this.routeConstants.set(relativePath, {
                            filePath: relativePath,
                            constants: routeConstants,
                            exportedObject,
                        });
                    }
                }
                catch (error) {
                    console.warn(`Warning: Could not analyze route constants ${relativePath}:`, error.message);
                }
            }
        });
    }
    /**
     * Routes 상수 파일들을 스캔합니다.
     */
    scanRouteConstantFiles() {
        return __awaiter(this, void 0, void 0, function* () {
            const patterns = [
                "constants/**/*.{js,jsx,ts,tsx}",
                "src/constants/**/*.{js,jsx,ts,tsx}",
                "config/**/*.{js,jsx,ts,tsx}",
                "src/config/**/*.{js,jsx,ts,tsx}",
                "routes/**/*.{js,jsx,ts,tsx}",
                "src/routes/**/*.{js,jsx,ts,tsx}",
                "lib/routes/**/*.{js,jsx,ts,tsx}",
                "src/lib/routes/**/*.{js,jsx,ts,tsx}",
                "utils/routes/**/*.{js,jsx,ts,tsx}",
                "src/utils/routes/**/*.{js,jsx,ts,tsx}",
                // 추가: src 폴더의 routes 관련 파일들
                "src/**/*route*.{js,jsx,ts,tsx}",
                "src/**/*path*.{js,jsx,ts,tsx}",
                "src/**/*url*.{js,jsx,ts,tsx}",
            ];
            const allFiles = [];
            for (const pattern of patterns) {
                const files = yield (0, glob_1.glob)(pattern, {
                    cwd: this.projectPath,
                    absolute: true,
                    ignore: this.excludePatterns.map((p) => `**/${p}/**`),
                });
                allFiles.push(...files);
            }
            // routes 관련 키워드가 포함된 파일들만 필터링 (더 포괄적으로)
            const routeFiles = [...new Set(allFiles)].filter((file) => {
                const fileName = (0, path_1.basename)(file, (0, path_1.extname)(file)).toLowerCase();
                const fileContent = this.tryReadFileContent(file);
                // 파일명 기반 필터링
                const routeKeywords = ["route", "path", "url", "endpoint", "navigation"];
                const hasRouteKeyword = routeKeywords.some((keyword) => fileName.includes(keyword));
                // 파일 내용 기반 필터링 - ROUTES, PATHS 등의 export 확인
                const hasRouteExport = fileContent &&
                    fileContent.includes("export") &&
                    (fileContent.includes("ROUTES") ||
                        fileContent.includes("PATHS") ||
                        fileContent.includes("URLS") ||
                        /export\s+const\s+\w*[Rr]oute/i.test(fileContent) ||
                        // V2_Routes, ApiRoutes 등 추가 패턴 (NEW)
                        /export\s+const\s+\w*Routes/i.test(fileContent) ||
                        /export\s+const\s+V\d+_\w*/i.test(fileContent) ||
                        /export\s+const\s+Api\w*/i.test(fileContent));
                return hasRouteKeyword || hasRouteExport;
            });
            return routeFiles;
        });
    }
    /**
     * 파일 내용을 안전하게 읽어오는 헬퍼 메서드
     */
    tryReadFileContent(filePath) {
        try {
            return (0, fs_1.readFileSync)(filePath, "utf-8");
        }
        catch (_a) {
            return null;
        }
    }
    /**
     * 파일 내용에서 route 상수들을 추출합니다.
     */
    extractRouteConstants(content) {
        const constants = new Map();
        // 객체 정의 패턴들 - 여러 export된 객체 모두 감지 (NEW)
        const objectPatterns = [
            // export const ROUTES = { HOME: '/', ... }
            /export\s+const\s+(\w+)\s*=\s*\{([\s\S]*?)\}/g,
            // const ROUTES = { HOME: '/', ... }; export { ROUTES };
            /const\s+(\w+)\s*=\s*\{([\s\S]*?)\}/g,
            // export default { HOME: '/', ... }
            /export\s+default\s*\{([\s\S]*?)\}/g,
        ];
        objectPatterns.forEach((pattern) => {
            const matches = content.matchAll(pattern);
            for (const match of matches) {
                let objectBody = "";
                let objectName = "DEFAULT";
                if (match.length === 3) {
                    // Named export: export const ROUTES = { ... }
                    objectName = match[1];
                    objectBody = match[2];
                    // Routes 관련 객체인지 확인 (NEW)
                    const normalizedName = objectName.toLowerCase();
                    const isRoutesObject = normalizedName.includes("route") ||
                        normalizedName.includes("path") ||
                        normalizedName.includes("url") ||
                        normalizedName.includes("api") ||
                        normalizedName.includes("endpoint");
                    // Routes 관련 객체가 아니면 건너뛰기
                    if (!isRoutesObject) {
                        console.log(`⏭️ 건너뛰기: ${objectName} (Routes 객체가 아님)`);
                        continue;
                    }
                    console.log(`🔍 Routes 객체 발견: ${objectName}`);
                }
                else if (match.length === 2) {
                    // Default export: export default { ... }
                    objectBody = match[1];
                }
                // 객체 내부의 key-value 쌍들을 추출
                const keyValuePairs = this.extractKeyValuePairs(objectBody);
                keyValuePairs.forEach((value, key) => {
                    const fullKey = objectName === "DEFAULT" ? key : `${objectName}.${key}`;
                    constants.set(fullKey, value);
                    // 단순 키로도 저장 (중복 방지를 위해 기존 값이 없을 때만)
                    if (!constants.has(key)) {
                        constants.set(key, value);
                    }
                    console.log(`✅ 상수 등록: ${fullKey} = ${value}`);
                });
            }
        });
        return constants;
    }
    /**
     * 객체 내부의 key-value 쌍들을 추출합니다.
     */
    extractKeyValuePairs(objectBody) {
        const pairs = new Map();
        // key: 'value' 또는 key: "value" 패턴 (기존)
        const keyValuePattern = /(\w+)\s*:\s*['"`]([^'"`]+)['"`]/g;
        const matches = objectBody.matchAll(keyValuePattern);
        for (const match of matches) {
            const key = match[1];
            const value = match[2];
            // 경로처럼 보이는 값들만 수집 (/ 로 시작하거나 포함)
            if (value.includes("/") || value.startsWith("/")) {
                pairs.set(key, value);
                console.log(`✅ 리터럴 상수: ${key} = ${value}`);
            }
        }
        // 화살표 함수 패턴 (NEW): key: () => 'path'
        const arrowFunctionPattern = /(\w+)\s*:\s*\([^)]*\)\s*=>\s*['"`]([^'"`]+)['"`]/g;
        const arrowMatches = objectBody.matchAll(arrowFunctionPattern);
        for (const match of arrowMatches) {
            const key = match[1];
            const value = match[2];
            if (value.includes("/") || value.startsWith("/")) {
                pairs.set(key, value);
                console.log(`✅ 화살표 함수 상수: ${key} = ${value}`);
            }
        }
        // 함수 호출 패턴 (기존): key: functionName("path", ...)
        const functionCallPattern = /(\w+)\s*:\s*(\w+)\s*\(\s*['"`]([^'"`]+)['"`][^)]*\)/g;
        const functionMatches = objectBody.matchAll(functionCallPattern);
        for (const match of functionMatches) {
            const key = match[1];
            const firstArg = match[3];
            // 함수의 첫 번째 인자가 경로인 경우 (createRoute, buildPath 등)
            if (firstArg.includes("/") || firstArg.startsWith("/")) {
                pairs.set(key, firstArg);
                pairs.set(`${key}`, firstArg); // 함수형 Routes를 위해 객체.키 형태도 저장
                console.log(`✅ 함수 호출 상수: ${key} = ${firstArg}`);
            }
        }
        // 더 복잡한 함수 호출 패턴: key: createRoute("/path", {...})
        const complexFunctionPattern = /(\w+)\s*:\s*\w+\s*\(\s*['"`]([^'"`]+)['"`]\s*,\s*\{[^}]*\}\s*\)/g;
        const complexMatches = objectBody.matchAll(complexFunctionPattern);
        for (const match of complexMatches) {
            const key = match[1];
            const pathArg = match[2];
            if (pathArg.includes("/") || pathArg.startsWith("/")) {
                pairs.set(key, pathArg);
                console.log(`✅ 복잡한 함수 상수: ${key} = ${pathArg}`);
            }
        }
        return pairs;
    }
    /**
     * Export된 객체명을 추론합니다.
     */
    inferExportedObjectName(content, fileName) {
        // Named export 패턴 확인
        const namedExportMatch = content.match(/export\s+const\s+(\w+)\s*=/);
        if (namedExportMatch) {
            return namedExportMatch[1];
        }
        // export { ROUTES } 패턴 확인
        const exportedNameMatch = content.match(/export\s*\{\s*(\w+)\s*\}/);
        if (exportedNameMatch) {
            return exportedNameMatch[1];
        }
        // 파일명 기반 추론
        const upperFileName = fileName.toUpperCase();
        if (upperFileName.includes("ROUTE"))
            return "ROUTES";
        if (upperFileName.includes("PATH"))
            return "PATHS";
        if (upperFileName.includes("URL"))
            return "URLS";
        if (upperFileName.includes("ENDPOINT"))
            return "ENDPOINTS";
        return "ROUTES"; // 기본값
    }
    analyzeNavigation(pageFiles) {
        return __awaiter(this, void 0, void 0, function* () {
            const edges = [];
            console.log(`🔍 Analyzing navigation in ${pageFiles.length} page files`);
            // 1. 페이지에서 직접 네비게이션 분석
            for (const filePath of pageFiles) {
                try {
                    const content = (0, fs_1.readFileSync)(filePath, "utf-8");
                    const pageEdges = this.extractNavigationFromFile(filePath, content);
                    edges.push(...pageEdges);
                }
                catch (error) {
                    console.warn(`Warning: Could not analyze navigation in ${filePath}:`, error.message);
                }
            }
            // 2. 컴포넌트 사용으로 인한 간접 네비게이션 추가
            for (const [componentPath, usage] of this.componentUsages) {
                for (const sourcePage of usage.usedInPages) {
                    for (const target of usage.navigationTargets) {
                        edges.push({
                            source: sourcePage,
                            target: target,
                            method: "component",
                            codeSnippet: `via ${(0, path_1.basename)(componentPath)}`,
                            lineNumber: 0,
                            fileName: componentPath,
                        });
                    }
                }
            }
            // 3. 훅 사용으로 인한 네비게이션 추가 (새로 추가)
            for (const [hookPath, usage] of this.hookUsages) {
                for (const sourcePage of usage.usedInPages) {
                    for (const [functionName, targets] of usage.navigationFunctions) {
                        for (const target of targets) {
                            edges.push({
                                source: sourcePage,
                                target: target,
                                method: "push", // 훅의 네비게이션은 일반적으로 push
                                codeSnippet: `via ${(0, path_1.basename)(hookPath)}.${functionName}()`,
                                lineNumber: 0,
                                fileName: hookPath,
                            });
                        }
                    }
                }
            }
            // 4. 실제 존재하는 페이지로의 링크만 유지
            const validPages = new Set(pageFiles.map((file) => {
                const relativePath = (0, path_1.relative)(this.projectPath, file);
                return this.filePathToRoute(relativePath);
            }));
            const validEdges = edges.filter((edge) => {
                const sourceExists = validPages.has(edge.source);
                const targetExists = validPages.has(edge.target) ||
                    this.isValidDynamicRoute(edge.target, validPages);
                return sourceExists && targetExists;
            });
            return this.deduplicateEdges(validEdges);
        });
    }
    isValidDynamicRoute(targetPath, validPages) {
        // 동적 라우트 패턴과 매칭되는지 확인
        for (const validPage of validPages) {
            if (validPage.includes("[") && validPage.includes("]")) {
                const pattern = validPage.replace(/\[[\w.[\]]*\]/g, "[^/]+");
                const regex = new RegExp(`^${pattern}$`);
                if (regex.test(targetPath)) {
                    return true;
                }
            }
        }
        return false;
    }
    extractNavigationFromFile(filePath, content, processedFiles) {
        if (!content.trim())
            return [];
        const relativePath = (0, path_1.relative)(this.projectPath, filePath);
        const sourceRoute = this.filePathToRoute(relativePath);
        const edges = [];
        // 무한 재귀 방지
        if (!processedFiles) {
            processedFiles = new Set();
        }
        if (processedFiles.has(filePath)) {
            console.log(`🔄 Circular re-export detected, skipping: ${filePath}`);
            return edges;
        }
        processedFiles.add(filePath);
        // re-export 패턴 감지 및 실제 파일 분석
        const isReExport = content.includes("export { default } from") ||
            content.includes("export {default} from");
        if (isReExport) {
            // 단순 문자열 파싱으로 경로 추출
            let reExportPath = "";
            const fromIndex = content.indexOf(" from ");
            if (fromIndex !== -1) {
                const afterFrom = content.substring(fromIndex + 6).trim();
                const quoteMatch = afterFrom.match(/["']([^"']+)["']/);
                if (quoteMatch) {
                    reExportPath = quoteMatch[1];
                }
            }
            if (reExportPath) {
                // 현재 파일의 디렉터리 경로 구하기
                const currentDir = filePath.substring(0, filePath.lastIndexOf("/"));
                // .tsx, .ts, .jsx, .js 확장자로 시도
                const possibleExtensions = [".tsx", ".ts", ".jsx", ".js"];
                let actualPath = null;
                for (const ext of possibleExtensions) {
                    const tryPath = reExportPath.includes(".")
                        ? (0, path_1.resolve)(currentDir, reExportPath)
                        : (0, path_1.resolve)(currentDir, reExportPath + ext);
                    try {
                        if ((0, fs_1.existsSync)(tryPath)) {
                            actualPath = tryPath;
                            break;
                        }
                    }
                    catch (_a) {
                        // 계속 시도
                    }
                }
                if (actualPath) {
                    try {
                        const actualContent = (0, fs_1.readFileSync)(actualPath, "utf-8");
                        const actualEdges = this.extractNavigationFromFile(actualPath, actualContent, processedFiles);
                        // 소스 경로를 원래 페이지 파일로 변경
                        const correctedEdges = actualEdges.map((edge) => (Object.assign(Object.assign({}, edge), { source: sourceRoute, fileName: relativePath })));
                        edges.push(...correctedEdges);
                        return edges;
                    }
                    catch (error) {
                        console.warn(`Warning: Could not read re-exported file ${actualPath}:`, error.message);
                    }
                }
            }
        }
        // 멀티라인 Link 컴포넌트 감지 (ES2015 호환)
        const linkComponentRegex = /<Link\s+[^>]*href=["']([^"']+)["'][^>]*>/g;
        const multilineContent = content.replace(/\n/g, " ");
        let linkMatch;
        while ((linkMatch = linkComponentRegex.exec(multilineContent)) !== null) {
            const originalIndex = linkMatch.index;
            const lineNumber = this.getLineNumber(content, originalIndex);
            edges.push({
                source: sourceRoute,
                target: linkMatch[1],
                method: "link",
                codeSnippet: `Link href="${linkMatch[1]}"`,
                lineNumber,
                fileName: relativePath,
            });
        }
        // 멀티라인 Link 컴포넌트에서 routes 상수 참조 감지 (NEW)
        const linkConstantRegex = /<Link\s+[^>]*href=\{([A-Z_][A-Z0-9_]*(?:\.[A-Z_][A-Z0-9_]*)*)\}[^>]*>/g;
        let linkConstantMatch;
        while ((linkConstantMatch = linkConstantRegex.exec(multilineContent)) !== null) {
            const variableName = linkConstantMatch[1];
            const resolvedPath = this.resolveRouteConstant(variableName);
            if (resolvedPath) {
                const originalIndex = linkConstantMatch.index;
                const lineNumber = this.getLineNumber(content, originalIndex);
                edges.push({
                    source: sourceRoute,
                    target: resolvedPath,
                    method: "link",
                    codeSnippet: `Link href={${variableName}}`,
                    lineNumber,
                    fileName: relativePath,
                    routeVariable: variableName,
                });
            }
        }
        // 멀티라인 Link 컴포넌트에서 함수형 routes 상수 참조 감지 (NEW)
        const linkFunctionRegex = /<Link\s+[^>]*href=\{([A-Za-z][A-Za-z0-9_]*\.[a-zA-Z][a-zA-Z0-9_]*)\(\s*\)\}[^>]*>/g;
        let linkFunctionMatch;
        while ((linkFunctionMatch = linkFunctionRegex.exec(multilineContent)) !== null) {
            const functionCall = linkFunctionMatch[1];
            const resolvedPath = this.resolveRouteConstant(functionCall);
            if (resolvedPath) {
                const originalIndex = linkFunctionMatch.index;
                const lineNumber = this.getLineNumber(content, originalIndex);
                edges.push({
                    source: sourceRoute,
                    target: resolvedPath,
                    method: "link",
                    codeSnippet: `Link href={${functionCall}()}`,
                    lineNumber,
                    fileName: relativePath,
                    routeVariable: functionCall,
                });
            }
        }
        const lines = content.split("\n");
        // 기본 패턴들 (기존 로직)
        lines.forEach((line, index) => {
            const lineNumber = index + 1;
            // Extract router.push calls (기본 및 조건부)
            const pushMatches = line.matchAll(/(?:router|Router)\.push\(["']([^"']+)["']\)/g);
            for (const match of pushMatches) {
                edges.push({
                    source: sourceRoute,
                    target: match[1],
                    method: "push",
                    codeSnippet: match[0],
                    lineNumber,
                    fileName: relativePath,
                });
            }
            // Extract router.push with route constants (NEW)
            const pushConstantMatches = line.matchAll(/(?:router|Router)\.push\(([A-Z_][A-Z0-9_]*(?:\.[A-Z_][A-Z0-9_]*)*)\)/g);
            for (const match of pushConstantMatches) {
                const variableName = match[1];
                const resolvedPath = this.resolveRouteConstant(variableName);
                if (resolvedPath) {
                    edges.push({
                        source: sourceRoute,
                        target: resolvedPath,
                        method: "push",
                        codeSnippet: match[0],
                        lineNumber,
                        fileName: relativePath,
                        routeVariable: variableName,
                    });
                }
            }
            // Extract router.push with route constants - 더 포괄적인 패턴 (NEW)
            const pushVariableMatches = line.matchAll(/(?:router|Router)\.push\(([A-Za-z][A-Za-z0-9_]*\.[a-zA-Z][a-zA-Z0-9_]*)\)/g);
            for (const match of pushVariableMatches) {
                const variableName = match[1];
                const resolvedPath = this.resolveRouteConstant(variableName);
                if (resolvedPath) {
                    console.log(`🎯 Routes 변수 해석: ${variableName} → ${resolvedPath}`);
                    edges.push({
                        source: sourceRoute,
                        target: resolvedPath,
                        method: "push",
                        codeSnippet: match[0],
                        lineNumber,
                        fileName: relativePath,
                        routeVariable: variableName,
                    });
                }
            }
            // Extract Router.push with function calls - 함수 내부 분석하여 가능한 모든 경로 추출
            const pushFunctionCallMatches = line.matchAll(/(?:router|Router)\.push\((\w+)\(\s*\)\)/g);
            for (const match of pushFunctionCallMatches) {
                const functionName = match[1];
                // 해당 함수 정의를 찾아서 내부에서 반환되는 모든 경로 추출
                const possiblePaths = this.analyzeFunctionReturns(content, functionName);
                for (const path of possiblePaths) {
                    edges.push({
                        source: sourceRoute,
                        target: path,
                        method: "push",
                        codeSnippet: `${match[0]} → ${functionName}() returns ${path}`,
                        lineNumber,
                        fileName: relativePath,
                    });
                }
            }
            // Extract router.push with function-style route constants (Routes.FUNC())
            const pushRouteFunctionMatches = line.matchAll(/(?:router|Router)\.push\(([A-Za-z][A-Za-z0-9_]*\.[a-zA-Z][a-zA-Z0-9_]*)\(\s*\)\)/g);
            for (const match of pushRouteFunctionMatches) {
                const functionCall = match[1]; // Routes.DASHBOARD
                const resolvedPath = this.resolveRouteConstant(functionCall);
                if (resolvedPath) {
                    console.log(`🎯 Routes 함수 해석: ${functionCall}() → ${resolvedPath}`);
                    edges.push({
                        source: sourceRoute,
                        target: resolvedPath,
                        method: "push",
                        codeSnippet: match[0],
                        lineNumber,
                        fileName: relativePath,
                        routeVariable: functionCall,
                    });
                }
            }
            // Extract router.replace calls
            const replaceMatches = line.matchAll(/(?:router|Router)\.replace\(["']([^"']+)["']\)/g);
            for (const match of replaceMatches) {
                edges.push({
                    source: sourceRoute,
                    target: match[1],
                    method: "replace",
                    codeSnippet: match[0],
                    lineNumber,
                    fileName: relativePath,
                });
            }
            // Extract router.replace with route constants (NEW)
            const replaceConstantMatches = line.matchAll(/(?:router|Router)\.replace\(([A-Z_][A-Z0-9_]*(?:\.[A-Z_][A-Z0-9_]*)*)\)/g);
            for (const match of replaceConstantMatches) {
                const variableName = match[1];
                const resolvedPath = this.resolveRouteConstant(variableName);
                if (resolvedPath) {
                    edges.push({
                        source: sourceRoute,
                        target: resolvedPath,
                        method: "replace",
                        codeSnippet: match[0],
                        lineNumber,
                        fileName: relativePath,
                        routeVariable: variableName,
                    });
                }
            }
            // Extract useRouter().push calls
            const useRouterPushMatches = line.matchAll(/\.push\(["']([^"']+)["']\)/g);
            for (const match of useRouterPushMatches) {
                edges.push({
                    source: sourceRoute,
                    target: match[1],
                    method: "push",
                    codeSnippet: match[0],
                    lineNumber,
                    fileName: relativePath,
                });
            }
            // Extract useRouter().replace calls
            const useRouterReplaceMatches = line.matchAll(/\.replace\(["']([^"']+)["']\)/g);
            for (const match of useRouterReplaceMatches) {
                edges.push({
                    source: sourceRoute,
                    target: match[1],
                    method: "replace",
                    codeSnippet: match[0],
                    lineNumber,
                    fileName: relativePath,
                });
            }
            // 훅 함수 호출 패턴 감지 (새로 추가)
            const hookFunctionMatches = line.matchAll(/(\w+)\s*\([^)]*\)/g);
            for (const match of hookFunctionMatches) {
                const functionName = match[1];
                // 이 함수가 사용 중인 훅에서 정의된 네비게이션 함수인지 확인
                for (const [hookPath, usage] of this.hookUsages) {
                    if (usage.usedInPages.includes(sourceRoute) &&
                        usage.navigationFunctions.has(functionName)) {
                        const targets = usage.navigationFunctions.get(functionName) || [];
                        for (const target of targets) {
                            edges.push({
                                source: sourceRoute,
                                target: target,
                                method: "push",
                                codeSnippet: `${functionName}() from ${(0, path_1.basename)(hookPath)}`,
                                lineNumber,
                                fileName: relativePath,
                            });
                        }
                    }
                }
            }
        });
        // 추가: 구조분해할당으로 가져온 훅 함수 호출 감지
        const destructuredHookCalls = this.analyzeDestructuredHookCalls(content, sourceRoute, relativePath);
        edges.push(...destructuredHookCalls);
        // 고급 패턴 분석: 멀티라인 조건부 네비게이션, 템플릿 리터럴, 동적 경로
        const enhancedEdges = this.analyzeComplexNavigationPatterns(content, sourceRoute, relativePath);
        edges.push(...enhancedEdges);
        // 1. getServerSideProps에서의 redirect 분석
        edges.push(...this.analyzeServerSideRedirects(content, sourceRoute, relativePath));
        // 2. 기본 네비게이션 패턴들
        const basicPatterns = [
            // Router push/replace
            /(?:router|Router)\.(?:push|replace)\s*\(\s*[`'""]([^`'""]+)[`'""]\s*\)/g,
            // Link href
            /<Link[^>]+href\s*=\s*[`'""]([^`'""]+)[`'""]/g,
            // Template literals
            /(?:router|Router)\.(?:push|replace)\s*\(\s*`([^`]+)`\s*\)/g,
        ];
        basicPatterns.forEach((pattern) => {
            let match;
            while ((match = pattern.exec(content)) !== null) {
                const targetPath = match[1];
                // 템플릿 리터럴에서 기본 경로 추출
                const basePath = this.extractBasePathFromTemplate(targetPath);
                const resolvedPath = this.resolveRouteConstant(basePath || targetPath) ||
                    basePath ||
                    targetPath;
                if (resolvedPath && this.isValidRoute(resolvedPath)) {
                    edges.push({
                        source: sourceRoute,
                        target: resolvedPath,
                        method: "push",
                        lineNumber: this.getLineNumber(content, match.index),
                        codeSnippet: match[0],
                        fileName: relativePath,
                    });
                }
            }
        });
        // 3. 함수 내부 및 조건부 네비게이션 패턴 분석
        edges.push(...this.analyzeFunctionBasedNavigation(content, sourceRoute, relativePath));
        // 4. 복잡한 네비게이션 패턴 분석 (기존)
        edges.push(...this.analyzeComplexNavigationPatterns(content, sourceRoute, relativePath));
        return edges;
    }
    /**
     * 복잡한 네비게이션 패턴을 분석합니다.
     * - 조건부 네비게이션 (if/else 블록)
     * - 템플릿 리터럴 사용
     * - useEffect 내부의 네비게이션
     * - 보호된 경로 로직
     */
    analyzeComplexNavigationPatterns(content, sourceRoute, relativePath) {
        const edges = [];
        // 1. 템플릿 리터럴 패턴 감지
        const templateLiteralPatterns = [
            /router\.push\(`([^`]+)`\)/g,
            /router\.replace\(`([^`]+)`\)/g,
            /\.push\(`([^`]+)`\)/g,
            /\.replace\(`([^`]+)`\)/g,
        ];
        templateLiteralPatterns.forEach((pattern) => {
            const matches = content.matchAll(pattern);
            for (const match of matches) {
                const template = match[1];
                // 간단한 템플릿을 경로로 변환 (예: `/login?redirect=${path}` -> `/login`)
                const basePath = this.extractBasePathFromTemplate(template);
                if (basePath) {
                    const lineNumber = this.getLineNumber(content, match.index || 0);
                    edges.push({
                        source: sourceRoute,
                        target: basePath,
                        method: "push",
                        codeSnippet: match[0],
                        lineNumber,
                        fileName: relativePath,
                    });
                }
            }
        });
        // 2. 조건부 네비게이션 블록 분석
        const conditionalBlocks = this.extractConditionalNavigationBlocks(content);
        conditionalBlocks.forEach((block) => {
            const blockEdges = this.analyzeNavigationInBlock(block, sourceRoute, relativePath);
            edges.push(...blockEdges);
        });
        // 3. useEffect 내부 네비게이션 분석
        const useEffectBlocks = this.extractUseEffectBlocks(content);
        useEffectBlocks.forEach((block) => {
            const effectEdges = this.analyzeNavigationInBlock(block, sourceRoute, relativePath);
            edges.push(...effectEdges);
        });
        // 4. 보호된 경로 패턴 분석
        const protectedRouteEdges = this.analyzeProtectedRoutePatterns(content, sourceRoute, relativePath);
        edges.push(...protectedRouteEdges);
        return edges;
    }
    /**
     * 템플릿 리터럴에서 기본 경로를 추출합니다.
     */
    extractBasePathFromTemplate(template) {
        // `/login?redirect=${path}` -> `/login`
        // `/dashboard?userId=${userId}` -> `/dashboard`
        // `/analytics#${section}` -> `/analytics`
        const basePathMatch = template.match(/^([^?#$]+)/);
        if (basePathMatch) {
            const basePath = basePathMatch[1];
            // 변수 참조가 포함된 경우 무시
            if (basePath.includes("${")) {
                return null;
            }
            return basePath;
        }
        return null;
    }
    /**
     * 조건부 네비게이션 블록을 추출합니다.
     */
    extractConditionalNavigationBlocks(content) {
        const blocks = [];
        // if 블록 패턴 매칭
        const ifBlockPattern = /if\s*\([^)]+\)\s*\{[^}]*router\.[^}]+\}/g;
        const ifMatches = content.matchAll(ifBlockPattern);
        for (const match of ifMatches) {
            blocks.push(match[0]);
        }
        // else 블록 패턴 매칭
        const elseBlockPattern = /else\s*\{[^}]*router\.[^}]+\}/g;
        const elseMatches = content.matchAll(elseBlockPattern);
        for (const match of elseMatches) {
            blocks.push(match[0]);
        }
        return blocks;
    }
    /**
     * useEffect 블록을 추출합니다.
     */
    extractUseEffectBlocks(content) {
        const blocks = [];
        // useEffect 패턴 매칭 (간단한 버전)
        const useEffectPattern = /useEffect\s*\(\s*\(\s*\)\s*=>\s*\{[^}]*router\.[^}]+\}/g;
        const matches = content.matchAll(useEffectPattern);
        for (const match of matches) {
            blocks.push(match[0]);
        }
        return blocks;
    }
    /**
     * 보호된 경로 패턴을 분석합니다.
     */
    analyzeProtectedRoutePatterns(content, sourceRoute, relativePath) {
        const edges = [];
        // 보호된 경로 배열 패턴 감지
        const protectedArrayPattern = /protectedRoutes\s*=\s*\[([\s\S]*?)\]/;
        const protectedMatch = content.match(protectedArrayPattern);
        if (protectedMatch) {
            // 배열 내의 경로들을 추출
            const routesString = protectedMatch[1];
            const routeMatches = routesString.matchAll(/["']([^"']+)["']/g);
            for (const routeMatch of routeMatches) {
                const route = routeMatch[1];
                // 보호된 경로로의 간접적 연결을 의미하므로 login 페이지로의 연결로 표현
                const lineNumber = this.getLineNumber(content, protectedMatch.index || 0);
                edges.push({
                    source: sourceRoute,
                    target: "/login",
                    method: "push",
                    codeSnippet: `protected route: ${route}`,
                    lineNumber,
                    fileName: relativePath,
                });
            }
        }
        return edges;
    }
    /**
     * 코드 블록 내의 네비게이션을 분석합니다.
     */
    analyzeNavigationInBlock(block, sourceRoute, relativePath) {
        const edges = [];
        // 블록 내의 router.push/replace 패턴 분석
        const patterns = [
            { regex: /router\.push\(["']([^"']+)["']\)/g, method: "push" },
            {
                regex: /router\.replace\(["']([^"']+)["']\)/g,
                method: "replace",
            },
            { regex: /\.push\(["']([^"']+)["']\)/g, method: "push" },
            { regex: /\.replace\(["']([^"']+)["']\)/g, method: "replace" },
        ];
        patterns.forEach(({ regex, method }) => {
            const matches = block.matchAll(regex);
            for (const match of matches) {
                edges.push({
                    source: sourceRoute,
                    target: match[1],
                    method: method,
                    codeSnippet: match[0],
                    lineNumber: 0, // 블록 내에서는 정확한 라인 번호 계산이 복잡
                    fileName: relativePath,
                });
            }
        });
        // 템플릿 리터럴 패턴도 블록 내에서 분석
        const templatePatterns = [
            { regex: /router\.push\(`([^`]+)`\)/g, method: "push" },
            { regex: /router\.replace\(`([^`]+)`\)/g, method: "replace" },
            { regex: /\.push\(`([^`]+)`\)/g, method: "push" },
            { regex: /\.replace\(`([^`]+)`\)/g, method: "replace" },
        ];
        templatePatterns.forEach(({ regex, method }) => {
            const matches = block.matchAll(regex);
            for (const match of matches) {
                const template = match[1];
                const basePath = this.extractBasePathFromTemplate(template);
                if (basePath) {
                    edges.push({
                        source: sourceRoute,
                        target: basePath,
                        method: method,
                        codeSnippet: match[0],
                        lineNumber: 0,
                        fileName: relativePath,
                    });
                }
            }
        });
        return edges;
    }
    /**
     * 코드 블록에서 구조분해할당으로 가져온 훅 함수 호출을 분석합니다.
     */
    analyzeDestructuredHookCalls(content, sourceRoute, relativePath) {
        const edges = [];
        // 1. 구조분해할당된 훅 함