@dcoder-x/plugin-shared 0.1.15 → 0.1.16

package/dist/extractors/ComponentExtractor.js

@@ -12,6 +12,24 @@ const InteractionGraphExtractor_1 = require("./InteractionGraphExtractor");
 const ComponentContextResolver_1 = require("./ComponentContextResolver");
 const HtmlTagGuards_1 = require("../injection/HtmlTagGuards");
 const IdStrategy_1 = require("../injection/IdStrategy");
+// ---------------------------------------------------------------------------
+// Content-based structural file detection (Options A and B)
+// These mirror the helpers in RouteExtractor but live here so ComponentExtractor
+// can run them independently without importing across extractor boundaries.
+// ---------------------------------------------------------------------------
+function looksLikeRouterConfigContent(content) {
+    return /createBrowserRouter|createHashRouter|createMemoryRouter/.test(content) ||
+        /<Routes[\s>]/.test(content);
+}
+function looksLikeOutletOnlyWrapper(content) {
+    if (!/<Outlet[\s/>]/.test(content))
+        return false;
+    const stripped = content.replace(/\/\/.*$/gm, '').replace(/\/\*[\s\S]*?\*\//g, '');
+    const componentTags = stripped.match(/<([A-Z][A-Za-z0-9]*)/g) ?? [];
+    const uniqueTags = new Set(componentTags.map((t) => t.slice(1)));
+    const structural = new Set(['Outlet', 'Suspense', 'Fragment', 'ErrorBoundary', 'StrictMode']);
+    return [...uniqueTags].filter((t) => !structural.has(t)).length === 0;
+}
 /**
  * A route is a usable module-graph entry point only when its filePath
  * points to an actual page component, not a layout/guard/wrapper/router file.
@@ -30,6 +48,18 @@ function isPageRoute(route) {
     if (/(provider|context|guard|layout|redirect|catchall|catch-all)/.test(base) ||
         /^(router|routes|routerconfig|approuter|routesconfig|routingconfig|routeconfig|approviders|appwrapper)$/i.test(base))
         return false;
+    // Option A: content-based — file defines routes, it is not a page
+    // Option B: file only renders <Outlet>, it is a pure layout wrapper
+    try {
+        const content = fs_1.default.readFileSync(route.filePath, 'utf-8');
+        if (looksLikeRouterConfigContent(content))
+            return false;
+        if (looksLikeOutletOnlyWrapper(content))
+            return false;
+    }
+    catch {
+        // file unreadable — fall through to default true
+    }
     return true;
 }
 class ComponentExtractor {

package/dist/extractors/RouteExtractor.js

@@ -20,8 +20,11 @@ const traverse = typeof traverse_1.default === 'function' ? traverse_1.default :
  * 3 = pages/views/screens directory → definitely a page
  * 1 = unknown / ambiguous
  * 0 = structural file (provider, guard, layout, context, router config, …)
+ *
+ * routerFiles: optional set of files known to contain createBrowserRouter/<Route
+ * (Option A — content-based router config detection)
  */
-function scoreFilePath(filePath) {
+function scoreFilePath(filePath, routerFiles) {
     const p = filePath.replace(/\\/g, '/').toLowerCase();
     const base = path_1.default.basename(p).replace(/\.(tsx?|jsx?)$/, '');
     if (p.includes('/pages/') || p.includes('/views/') || p.includes('/screens/'))
@@ -33,8 +36,35 @@ function scoreFilePath(filePath) {
     if (/(provider|context|guard|layout|redirect|catchall|catch-all)/.test(base) ||
         /^(router|routes|routerconfig|approuter|routesconfig|routingconfig|routeconfig|approviders|appwrapper)$/i.test(base))
         return 0;
+    // Option A: content-based — this file defines routes, it is not a page
+    if (routerFiles?.has(path_1.default.normalize(filePath)))
+        return 0;
     return 1;
 }
+/**
+ * Option A: returns true if the file content contains router definition patterns.
+ * Used to populate the routerFiles set passed to scoreFilePath().
+ */
+function looksLikeRouterConfigContent(content) {
+    return /createBrowserRouter|createHashRouter|createMemoryRouter/.test(content) ||
+        /<Routes[\s>]/.test(content);
+}
+/**
+ * Option B: returns true if the file renders only <Outlet> with no other
+ * substantive JSX component tags. These are pure layout wrappers.
+ */
+function looksLikeOutletOnlyWrapper(content) {
+    if (!/<Outlet[\s/>]/.test(content))
+        return false;
+    // Strip comments and string literals (rough), then count distinct JSX component tags
+    const stripped = content.replace(/\/\/.*$/gm, '').replace(/\/\*[\s\S]*?\*\//g, '');
+    const componentTags = stripped.match(/<([A-Z][A-Za-z0-9]*)/g) ?? [];
+    const uniqueTags = new Set(componentTags.map((t) => t.slice(1)));
+    // Allow Outlet plus a small set of structural primitives (Suspense, Fragment, ErrorBoundary)
+    const structural = new Set(['Outlet', 'Suspense', 'Fragment', 'ErrorBoundary', 'StrictMode']);
+    const nonStructural = [...uniqueTags].filter((t) => !structural.has(t));
+    return nonStructural.length === 0;
+}
 // ---------------------------------------------------------------------------
 // RouteExtractor
 // ---------------------------------------------------------------------------
@@ -150,6 +180,10 @@ class RouteExtractor {
             return [];
         const results = [];
         const routerFiles = this.findFilesContaining(srcDir, /createBrowserRouter|<Route/);
+        // Option A: build a normalised set of all files that contain router-definition
+        // patterns. scoreFilePath() uses this to score any such file as 0 regardless
+        // of its filename, so arbitrarily-named router config files are excluded.
+        const routerFileSet = new Set(routerFiles.map((f) => path_1.default.normalize(f)));
         for (const filePath of routerFiles) {
             const source = fs_1.default.readFileSync(filePath, 'utf-8');
             let ast;
@@ -162,7 +196,7 @@ class RouteExtractor {
             const importMap = this.buildImportMap(ast, filePath);
             // Walk the entire AST looking for JSX Route trees and
             // createBrowserRouter([…]) / createHashRouter([…]) call expressions.
-            this.extractFromAst(ast, filePath, importMap, results);
+            this.extractFromAst(ast, filePath, importMap, results, routerFileSet);
         }
         // Deduplicate: same (path + filePath) pair can appear when multiple router
         // files re-export or re-nest the same routes.
@@ -182,7 +216,7 @@ class RouteExtractor {
      * 2. createBrowserRouter / createHashRouter call arguments — delegates to
      *    walkObjectRouteConfig which handles the object-literal route config style.
      */
-    extractFromAst(ast, filePath, importMap, results) {
+    extractFromAst(ast, filePath, importMap, results, routerFileSet) {
         // Track which JSX Route nodes we have already processed as children of a
         // parent Route so we don't double-emit them from the flat visitor pass.
         const processedNodes = new WeakSet();
@@ -202,7 +236,7 @@ class RouteExtractor {
                 const routeObjects = firstArg.type === 'ArrayExpression' ? firstArg.elements : [];
                 for (const el of routeObjects) {
                     if (el)
-                        this.walkObjectRouteConfig(el, '', filePath, importMap, results);
+                        this.walkObjectRouteConfig(el, '', filePath, importMap, results, routerFileSet);
                 }
             },
             // JSX style: <Routes><Route path="…" element={…}>…</Route></Routes>
@@ -221,7 +255,7 @@ class RouteExtractor {
                 const grandparentOpening = parentJsx?.openingElement?.name?.name;
                 if (grandparentOpening === 'Route')
                     return;
-                this.walkJsxRouteNode(jsxElement, '', filePath, importMap, results, processedNodes);
+                this.walkJsxRouteNode(jsxElement, '', filePath, importMap, results, processedNodes, routerFileSet);
             },
         });
     }
@@ -229,7 +263,7 @@ class RouteExtractor {
      * Recursively walk a JSX <Route> element and its JSX children.
      * pathPrefix is the accumulated path from ancestor <Route path> segments.
      */
-    walkJsxRouteNode(jsxElement, pathPrefix, filePath, importMap, results, processedNodes) {
+    walkJsxRouteNode(jsxElement, pathPrefix, filePath, importMap, results, processedNodes, routerFileSet) {
         if (!jsxElement)
             return;
         processedNodes.add(jsxElement);
@@ -251,11 +285,21 @@ class RouteExtractor {
         // Resolve the component file for this route's element prop.
         const resolvedFile = this.resolveRouteComponentFile(openingEl, importMap);
         const effectiveFile = resolvedFile ?? filePath;
-        const fileScore = scoreFilePath(effectiveFile);
+        // Option A+B: pass routerFileSet for content-based router config detection;
+        // also check if the resolved file is an outlet-only wrapper (Option B).
+        const fileScore = scoreFilePath(effectiveFile, routerFileSet);
+        const isOutletOnly = resolvedFile !== null && (() => {
+            try {
+                return looksLikeOutletOnlyWrapper(fs_1.default.readFileSync(resolvedFile, 'utf-8'));
+            }
+            catch {
+                return false;
+            }
+        })();
         // A route is a layout container when:
         // - it has child routes (it is a branch, not a leaf), AND
-        // - its resolved file is a structural wrapper (score 0) or it fell back to the router file
-        const isLayoutRoute = hasChildRoutes && (fileScore === 0 || resolvedFile === null);
+        // - its resolved file scores 0, is an outlet-only wrapper, or fell back to the router file
+        const isLayoutRoute = hasChildRoutes && (fileScore === 0 || isOutletOnly || resolvedFile === null);
         // Only emit routes that have an explicit path segment — index routes with
         // no path are structural placeholders.
         if (routeSegment || (!hasChildRoutes && fullPath)) {
@@ -272,14 +316,14 @@ class RouteExtractor {
         }
         // Recurse into child <Route> elements, passing the accumulated path.
         for (const child of childRouteElements) {
-            this.walkJsxRouteNode(child, fullPath, filePath, importMap, results, processedNodes);
+            this.walkJsxRouteNode(child, fullPath, filePath, importMap, results, processedNodes, routerFileSet);
         }
     }
     /**
      * Walk an object-literal route config node as produced by createBrowserRouter.
      * Handles: { path, element, Component, children: [...] }
      */
-    walkObjectRouteConfig(node, pathPrefix, filePath, importMap, results) {
+    walkObjectRouteConfig(node, pathPrefix, filePath, importMap, results, routerFileSet) {
         if (!node || node.type !== 'ObjectExpression')
             return;
         let routeSegment = '';
@@ -316,8 +360,17 @@ class RouteExtractor {
             ? this.resolveElementNodeToFile(elementNode, importMap)
             : null;
         const effectiveFile = resolvedFile ?? filePath;
-        const fileScore = scoreFilePath(effectiveFile);
-        const isLayoutRoute = hasChildRoutes && (fileScore === 0 || resolvedFile === null);
+        // Option A+B: content-based router config detection + outlet-only wrapper check.
+        const fileScore = scoreFilePath(effectiveFile, routerFileSet);
+        const isOutletOnly = resolvedFile !== null && (() => {
+            try {
+                return looksLikeOutletOnlyWrapper(fs_1.default.readFileSync(resolvedFile, 'utf-8'));
+            }
+            catch {
+                return false;
+            }
+        })();
+        const isLayoutRoute = hasChildRoutes && (fileScore === 0 || isOutletOnly || resolvedFile === null);
         if (routeSegment || (!hasChildRoutes && fullPath)) {
             results.push({
                 path: fullPath,
@@ -332,7 +385,7 @@ class RouteExtractor {
         }
         for (const child of childElements) {
             if (child)
-                this.walkObjectRouteConfig(child, fullPath, filePath, importMap, results);
+                this.walkObjectRouteConfig(child, fullPath, filePath, importMap, results, routerFileSet);
         }
     }
     // ---------------------------------------------------------------------------

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dcoder-x/plugin-shared",
-  "version": "0.1.15",
+  "version": "0.1.16",
   "private": false,
   "main": "dist/index.js",
   "types": "dist/index.d.ts",