next-route-graph 1.0.1 → 1.0.2

package/dist/core/analyzer.js

@@ -1,81 +1,117 @@
 import path from "node:path";
 import { detectRenderingType, getSegmentType, parseRoutePath, parseSpecialFileType, } from "./parser.js";
-export async function analyzeRoutes(files, projectPath, displayRoot) {
-    const startTime = Date.now();
+function groupFilesByDirectory(files) {
     const dirMap = new Map();
     for (const file of files) {
         const dir = path.dirname(file.relativePath).replace(/\\/g, "/");
-        if (!dirMap.has(dir)) {
-            dirMap.set(dir, []);
+        const dirFiles = dirMap.get(dir);
+        if (dirFiles) {
+            dirFiles.push(file);
+        }
+        else {
+            dirMap.set(dir, [file]);
+        }
+    }
+    return dirMap;
+}
+async function processDirectoryFiles(dirFiles) {
+    const routeFiles = [];
+    let layouts = 0;
+    let loading = 0;
+    let errors = 0;
+    for (const file of dirFiles) {
+        const specialType = parseSpecialFileType(file.fileName);
+        if (!specialType) {
+            continue;
+        }
+        const rendering = await detectRenderingType(file.fullPath);
+        routeFiles.push({
+            type: specialType,
+            fileName: file.fileName,
+            relativePath: file.relativePath,
+            rendering,
+        });
+        if (specialType === "layout") {
+            layouts++;
         }
-        dirMap.get(dir).push(file);
+        if (specialType === "loading") {
+            loading++;
+        }
+        if (specialType === "error") {
+            errors++;
+        }
+    }
+    return {
+        routeFiles,
+        layouts,
+        loading,
+        errors,
+    };
+}
+function createRouteEntry(routeFiles) {
+    const pageFile = routeFiles.find((file) => file.type === "page");
+    const routeHandlerFile = routeFiles.find((file) => file.type === "route");
+    const primaryFile = pageFile ?? routeHandlerFile;
+    if (!primaryFile) {
+        return null;
     }
+    const computedPath = parseRoutePath(primaryFile.relativePath);
+    return {
+        path: computedPath,
+        type: pageFile ? "page" : "route",
+        file: primaryFile.relativePath,
+        segmentType: getSegmentType(computedPath),
+        rendering: primaryFile.rendering,
+        files: routeFiles,
+    };
+}
+async function analyzeDirectories(dirMap) {
     const routesMap = new Map();
     let totalLayouts = 0;
     let totalLoading = 0;
     let totalErrors = 0;
-    for (const [dir, dirFiles] of dirMap.entries()) {
-        const routeFiles = [];
-        for (const file of dirFiles) {
-            const specialType = parseSpecialFileType(file.fileName);
-            if (specialType) {
-                const rendering = await detectRenderingType(file.fullPath);
-                routeFiles.push({
-                    type: specialType,
-                    fileName: file.fileName,
-                    relativePath: file.relativePath,
-                    rendering,
-                });
-                if (specialType === "layout")
-                    totalLayouts++;
-                if (specialType === "loading")
-                    totalLoading++;
-                if (specialType === "error")
-                    totalErrors++;
-            }
-        }
-        const pageFile = routeFiles.find((f) => f.type === "page");
-        const routeHandlerFile = routeFiles.find((f) => f.type === "route");
-        if (pageFile || routeHandlerFile) {
-            const primaryFile = (pageFile || routeHandlerFile);
-            const computedPath = parseRoutePath(primaryFile.relativePath);
-            routesMap.set(computedPath, {
-                path: computedPath,
-                type: pageFile ? "page" : "route",
-                file: primaryFile.relativePath,
-                segmentType: getSegmentType(computedPath),
-                rendering: primaryFile.rendering,
-                files: routeFiles,
-            });
+    for (const dirFiles of dirMap.values()) {
+        const result = await processDirectoryFiles(dirFiles);
+        totalLayouts += result.layouts;
+        totalLoading += result.loading;
+        totalErrors += result.errors;
+        const route = createRouteEntry(result.routeFiles);
+        if (route) {
+            routesMap.set(route.path, route);
         }
     }
-    const routes = Array.from(routesMap.values()).sort((a, b) => a.path.localeCompare(b.path));
-    let dynamicCount = 0;
-    let clientCount = 0;
-    let serverCount = 0;
+    return {
+        routesMap,
+        totalLayouts,
+        totalLoading,
+        totalErrors,
+    };
+}
+function getRoutesSummary(routes, layouts, loading, errors) {
+    let dynamic = 0;
+    let client = 0;
     for (const route of routes) {
-        if (route.segmentType !== "static") {
-            dynamicCount++;
-        }
-        if (route.rendering === "client") {
-            clientCount++;
-        }
-        else {
-            serverCount++;
-        }
+        dynamic += route.segmentType !== "static" ? 1 : 0;
+        client += route.rendering === "client" ? 1 : 0;
     }
-    const projectName = path.basename(path.resolve(projectPath));
-    const summary = {
+    return {
         routes: routes.length,
-        dynamic: dynamicCount,
-        client: clientCount,
-        server: serverCount,
-        layouts: totalLayouts,
-        loading: totalLoading,
-        errors: totalErrors,
+        dynamic,
+        client,
+        server: routes.length - client,
+        layouts,
+        loading,
+        errors,
     };
+}
+export async function analyzeRoutes(files, projectPath, displayRoot) {
+    const startTime = Date.now();
+    const dirMap = groupFilesByDirectory(files);
+    const { routesMap, totalLayouts, totalLoading, totalErrors } = await analyzeDirectories(dirMap);
+    const routes = Array.from(routesMap.values()).sort((a, b) => a.path.localeCompare(b.path));
+    const summary = getRoutesSummary(routes, totalLayouts, totalLoading, totalErrors);
     return {
-        project: projectName,
+        project: path.basename(path.resolve(projectPath)),
         router: "App Router",
         root: displayRoot,
         routes,

package/dist/core/parser.js

@@ -21,43 +21,36 @@ export async function detectRenderingType(filePath) {
     try {
         const content = await fs.readFile(filePath, "utf-8");
         const firstLines = content.slice(0, 500);
-        const clientDirectiveRegex = /^\s*(?:\/\/.*?\n|\/\*[\s\S]*?\*\/)*\s*["']use client["']/m;
+        const clientDirectiveRegex = /^(?:(?:\s*\/\/.*?\n)|(?:\s*\/\*[\s\S]*?\*\/)|(?:\s*))["']use client["']/m;
         if (clientDirectiveRegex.test(firstLines)) {
             return "client";
         }
     }
-    catch {
-        // Default to server if unreadable
-    }
+    catch { }
     return "server";
 }
 export function parseRoutePath(relativePath) {
     const parts = relativePath.split("/");
-    // Remove the file name at the end
     parts.pop();
     const urlSegments = [];
     for (const part of parts) {
         if (!part)
             continue;
-        // Route groups are ignored in URL matching
         if (part.startsWith("(") && part.endsWith(")")) {
             const inner = part.slice(1, -1);
-            // Exclude intercepting routes which also start with '('
             if (!inner.startsWith(".") && inner !== "...") {
                 continue;
             }
         }
-        // Parallel routes are ignored in URL pathing
         if (part.startsWith("@")) {
             continue;
         }
-        // Intercepting routes clean-up for display path
         let cleanedPart = part;
         if (cleanedPart.startsWith("(.)") ||
             cleanedPart.startsWith("(..)") ||
             cleanedPart.startsWith("(...)") ||
             cleanedPart.startsWith("(..)(..)")) {
-            cleanedPart = cleanedPart.replace(/^\(\.\.\.\)|\(\.\.\)|\(\.\)/, "");
+            cleanedPart = cleanedPart.replace(/^(?:\(\.\.\.\)|\(\.\.\)|\(\.\))/, "");
         }
         urlSegments.push(cleanedPart);
     }

package/dist/render/tree.js

@@ -4,9 +4,9 @@ export function renderTree(result) {
     lines.push("");
     lines.push(pc.bold("next-route-graph"));
     lines.push("");
-    lines.push(`${pc.dim("Project    ")} ${result.project}`);
-    lines.push(`${pc.dim("Router     ")} ${result.router}`);
-    lines.push(`${pc.dim("Root       ")} ${result.root}`);
+    lines.push(`${pc.dim("Project    ")}${result.project}`);
+    lines.push(`${pc.dim("Router     ")}${result.router}`);
+    lines.push(`${pc.dim("Root       ")}${result.root}`);
     lines.push("");
     lines.push(pc.bold("Routes"));
     lines.push(pc.dim("────────────────────────────────────────"));
@@ -18,12 +18,15 @@ export function renderTree(result) {
         const fileStr = pc.dim(route.file.split("/").pop() || "");
         let badge = "";
         if (route.rendering === "client") {
-            badge = `  ${pc.cyan("[client]")}`;
+            const clientBadge = pc.cyan("[client]");
+            badge = `  ${clientBadge}`;
         }
         else if (route.segmentType !== "static") {
-            badge = `  ${pc.yellow(`[${route.segmentType}]`)}`;
+            const segmentBadge = `[${route.segmentType}]`;
+            badge = `  ${pc.yellow(segmentBadge)}`;
         }
-        lines.push(`${pc.dim(prefix)}${pc.bold(pathStr)} ${fileStr}${badge}`);
+        const routeLine = `${pc.dim(prefix)}${pc.bold(pathStr)} ${fileStr}${badge}`;
+        lines.push(routeLine);
     });
     if (routes.length === 0) {
         lines.push(pc.dim("  (No routes found)"));
@@ -31,13 +34,13 @@ export function renderTree(result) {
     lines.push("");
     lines.push(pc.bold("Summary"));
     lines.push(pc.dim("────────────────────────────────────────"));
-    lines.push(`${pc.dim("Routes      ")} ${result.summary.routes}`);
-    lines.push(`${pc.dim("Dynamic     ")} ${result.summary.dynamic}`);
-    lines.push(`${pc.dim("Client      ")} ${result.summary.client}`);
-    lines.push(`${pc.dim("Server      ")} ${result.summary.server}`);
-    lines.push(`${pc.dim("Layouts     ")} ${result.summary.layouts}`);
-    lines.push(`${pc.dim("Loading     ")} ${result.summary.loading}`);
-    lines.push(`${pc.dim("Errors      ")} ${result.summary.errors}`);
+    lines.push(`${pc.dim("Routes       ")}${result.summary.routes}`);
+    lines.push(`${pc.dim("Dynamic      ")}${result.summary.dynamic}`);
+    lines.push(`${pc.dim("Client       ")}${result.summary.client}`);
+    lines.push(`${pc.dim("Server       ")}${result.summary.server}`);
+    lines.push(`${pc.dim("Layouts      ")}${result.summary.layouts}`);
+    lines.push(`${pc.dim("Loading      ")}${result.summary.loading}`);
+    lines.push(`${pc.dim("Errors       ")}${result.summary.errors}`);
     lines.push("");
     lines.push(pc.green(`✓ Analysis completed in ${result.executionTimeMs}ms`));
     lines.push("");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "next-route-graph",
-  "version": "1.0.1",
+  "version": "1.0.2",
   "description": "Visualize and inspect the structure of a Next.js App Router project from the terminal",
   "type": "module",
   "bin": {