@dcoder-x/plugin-shared 0.1.14 → 0.1.16

package/dist/extractors/ComponentExtractor.js

@@ -12,20 +12,54 @@ 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.
- * Score 0 = structural wrapper → skip as entry point.
+ * points to an actual page component, not a layout/guard/wrapper/router file.
  */
 function isPageRoute(route) {
     if (route.isLayoutRoute)
         return false;
     const p = route.filePath.replace(/\\/g, '/').toLowerCase();
+    const base = path_1.default.basename(p).replace(/\.(tsx?|jsx?)$/, '');
     if (p.includes('/pages/') || p.includes('/views/') || p.includes('/screens/'))
         return true;
-    if (/\/(contexts?|providers?|guards?|layouts?|wrappers?|hoc|utils?|helpers?)\//.test(p) ||
-        /(provider|context|guard|layout|redirect|catchall|catch-all)/.test(path_1.default.basename(p)))
+    // Directory-based structural patterns
+    if (/\/(contexts?|providers?|guards?|layouts?|wrappers?|hoc|utils?|helpers?)\//.test(p))
         return false;
+    // Basename-based structural patterns: wrapper, router config, and provider files
+    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 {
@@ -413,10 +447,21 @@ function extractStaticProps(attributes) {
             continue;
         if (attr.value?.type === 'StringLiteral') {
             props[key] = attr.value.value;
+            continue;
         }
-        if (attr.value?.type === 'JSXExpressionContainer' &&
-            attr.value.expression?.type === 'StringLiteral') {
-            props[key] = attr.value.expression.value;
+        if (attr.value?.type === 'JSXExpressionContainer') {
+            const expr = attr.value.expression;
+            if (expr?.type === 'StringLiteral') {
+                props[key] = expr.value;
+            }
+            else if (expr?.type === 'TemplateLiteral' &&
+                expr.quasis?.length === 1 &&
+                expr.expressions?.length === 0) {
+                // Pure template literal with no interpolations: `to="/some/path"`
+                const raw = expr.quasis[0].value.cooked ?? expr.quasis[0].value.raw;
+                if (raw)
+                    props[key] = raw;
+            }
         }
     }
     return props;

package/dist/extractors/FlowInferrer.d.ts

@@ -14,6 +14,12 @@ export declare class FlowInferrer {
      */
     private isCoherentChain;
     private detectInteractionFlows;
+    /**
+     * Deduplicate interaction flows by (page, trigger event, effect target).
+     * Shared components used on multiple routes produce one flow per component
+     * interaction. After dedup, each distinct interaction appears once.
+     */
+    private deduplicateInteractionFlows;
     private buildChain;
     private generateIntentPatterns;
     /**

package/dist/extractors/FlowInferrer.js

@@ -45,10 +45,9 @@ class FlowInferrer {
     infer() {
         const edges = this.buildEdgeGraph();
         const routeFlows = this.detectLinearFlows(edges);
-        const interactionFlows = this.detectInteractionFlows();
+        const interactionFlows = this.deduplicateInteractionFlows(this.detectInteractionFlows());
         const combined = [...routeFlows, ...interactionFlows];
-        // Fix 4: remove patterns that appear in too many flows — they are structural
-        // navigation chrome (sidebars, footers) rather than user intent signals
+        // Remove patterns that appear in too many flows — structural nav chrome
         return this.deduplicateCrossFlowNoise(combined);
     }
     // ---------------------------------------------------------------------------
@@ -56,13 +55,21 @@ class FlowInferrer {
     // ---------------------------------------------------------------------------
     buildEdgeGraph() {
         const edges = [];
+        // Index routes both with and without leading slash to handle mixed conventions
         const routePaths = new Set(this.routes.map((r) => r.path));
+        const normalizeHref = (href) => href.replace(/^\//, '');
         for (const el of this.elements) {
             const isNav = el.tag === 'a' || el.isNavigationLink === true;
-            const href = el.staticProps['href'] || el.staticProps['to'];
-            if (!isNav || !href)
+            const rawHref = el.staticProps['href'] || el.staticProps['to'];
+            if (!isNav || !rawHref)
                 continue;
-            if (!routePaths.has(href))
+            // Match against both the raw href and the normalized (no leading slash) form
+            const href = routePaths.has(rawHref)
+                ? rawHref
+                : routePaths.has(normalizeHref(rawHref))
+                    ? normalizeHref(rawHref)
+                    : null;
+            if (!href)
                 continue;
             const triggerText = el.staticProps['aria-label'] ||
                 el.label ||
@@ -162,6 +169,26 @@ class FlowInferrer {
         return flows;
     }
     // ---------------------------------------------------------------------------
+    // Interaction flow deduplication
+    // ---------------------------------------------------------------------------
+    /**
+     * Deduplicate interaction flows by (page, trigger event, effect target).
+     * Shared components used on multiple routes produce one flow per component
+     * interaction. After dedup, each distinct interaction appears once.
+     */
+    deduplicateInteractionFlows(flows) {
+        const seen = new Set();
+        return flows.filter((f) => {
+            const trigger = f.edges[0]?.trigger ?? '';
+            const step = f.steps[0] ?? '';
+            const sig = `${f.page}::${trigger}::${step}`;
+            if (seen.has(sig))
+                return false;
+            seen.add(sig);
+            return true;
+        });
+    }
+    // ---------------------------------------------------------------------------
     // Chain builder
     // ---------------------------------------------------------------------------
     buildChain(start, adjacency, seen) {

package/dist/extractors/RouteExtractor.js

@@ -18,19 +18,53 @@ const traverse = typeof traverse_1.default === 'function' ? traverse_1.default :
 /**
  * Score a resolved file path: higher = more likely to be an actual page component.
  * 3 = pages/views/screens directory → definitely a page
- * 2 = named after a recognisable page pattern but not in a pages dir
  * 1 = unknown / ambiguous
- * 0 = structural wrapper (provider, guard, layout, context, …)
+ * 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/'))
         return 3;
-    if (/\/(contexts?|providers?|guards?|layouts?|wrappers?|hoc|utils?|helpers?)\//.test(p) ||
-        /(provider|context|guard|layout|redirect|catchall|catch-all)/.test(path_1.default.basename(p)))
+    // Directory-based structural patterns
+    if (/\/(contexts?|providers?|guards?|layouts?|wrappers?|hoc|utils?|helpers?)\//.test(p))
+        return 0;
+    // Basename-based structural patterns: wrapper/config/router files
+    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
 // ---------------------------------------------------------------------------
@@ -146,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;
@@ -158,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.
@@ -178,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();
@@ -198,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>
@@ -217,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);
             },
         });
     }
@@ -225,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);
@@ -247,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)) {
@@ -268,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 = '';
@@ -312,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,
@@ -328,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.14",
+  "version": "0.1.16",
   "private": false,
   "main": "dist/index.js",
   "types": "dist/index.d.ts",