@dcoder-x/plugin-shared 0.1.8 → 0.1.10

package/dist/extractors/RouteExtractor.d.ts

@@ -7,6 +7,10 @@ export declare class RouteExtractor {
     private walkPagesDir;
     private walkTanStackDir;
     private extractReactRouterRoutes;
+    private buildImportMap;
+    private resolveRouteComponentFile;
+    private collectJSXComponentNames;
+    private resolveImportToFile;
     private findFilesContaining;
     private extractParams;
     private findNearestLayout;

package/dist/extractors/RouteExtractor.js

@@ -131,6 +131,7 @@ class RouteExtractor {
             catch {
                 continue;
             }
+            const importMap = this.buildImportMap(ast, filePath);
             traverse(ast, {
                 JSXOpeningElement: (nodePath) => {
                     const name = nodePath.node.name?.name;
@@ -138,21 +139,110 @@ class RouteExtractor {
                         return;
                     const pathAttr = nodePath.node.attributes.find((a) => a.name?.name === 'path');
                     const routePath = pathAttr?.value?.value;
-                    if (routePath) {
-                        results.push({
-                            path: routePath,
-                            filePath,
-                            isDynamic: routePath.includes(':'),
-                            params: (routePath.match(/:(\w+)/g) || []).map((p) => p.slice(1)),
-                            layout: null,
-                            routerType: 'react-router',
-                            semantic: this.deriveSemanticMeaning(routePath),
-                        });
-                    }
+                    if (!routePath)
+                        return;
+                    const resolvedFilePath = this.resolveRouteComponentFile(nodePath, importMap) ?? filePath;
+                    results.push({
+                        path: routePath,
+                        filePath: resolvedFilePath,
+                        isDynamic: routePath.includes(':'),
+                        params: (routePath.match(/:(\w+)/g) || []).map((p) => p.slice(1)),
+                        layout: null,
+                        routerType: 'react-router',
+                        semantic: this.deriveSemanticMeaning(routePath),
+                    });
                 },
             });
         }
-        return results;
+        // Deduplicate: same path + filePath can appear if multiple router files
+        // re-export or nest the same routes (e.g. AppProviders wrapping routerConfig).
+        const seen = new Set();
+        return results.filter((r) => {
+            const key = `${r.path}::${r.filePath}`;
+            if (seen.has(key))
+                return false;
+            seen.add(key);
+            return true;
+        });
+    }
+    buildImportMap(ast, fromFile) {
+        const map = new Map();
+        for (const node of ast.program.body) {
+            if (node.type !== 'ImportDeclaration')
+                continue;
+            const importSource = node.source?.value;
+            if (!importSource)
+                continue;
+            const resolved = this.resolveImportToFile(importSource, fromFile);
+            if (!resolved)
+                continue;
+            for (const specifier of node.specifiers ?? []) {
+                if (specifier.type === 'ImportDefaultSpecifier' ||
+                    specifier.type === 'ImportSpecifier') {
+                    const localName = specifier.local?.name;
+                    if (localName)
+                        map.set(localName, resolved);
+                }
+            }
+        }
+        return map;
+    }
+    resolveRouteComponentFile(routeOpeningPath, importMap) {
+        const elementAttr = routeOpeningPath.node.attributes.find((a) => a.name?.name === 'element');
+        if (!elementAttr)
+            return null;
+        const expr = elementAttr.value?.expression;
+        if (!expr)
+            return null;
+        // Try each JSX component name in document order; first match in the import map wins.
+        // Wrapper components like <Can> or <RouteGuard> won't be in the map, so we fall
+        // through to the actual page component nested inside them.
+        const componentNames = this.collectJSXComponentNames(expr);
+        for (const componentName of componentNames) {
+            const resolved = importMap.get(componentName);
+            if (resolved)
+                return resolved;
+        }
+        return null;
+    }
+    collectJSXComponentNames(node) {
+        if (!node)
+            return [];
+        if (node.type === 'JSXElement') {
+            const tagName = node.openingElement?.name?.name ?? '';
+            const names = [];
+            if (tagName && /^[A-Z]/.test(tagName))
+                names.push(tagName);
+            for (const child of node.children ?? []) {
+                names.push(...this.collectJSXComponentNames(child));
+            }
+            return names;
+        }
+        return [];
+    }
+    resolveImportToFile(importSource, fromFile) {
+        if (!importSource.startsWith('.') && !importSource.startsWith('/'))
+            return null;
+        const base = importSource.startsWith('/')
+            ? path_1.default.normalize(importSource)
+            : path_1.default.resolve(path_1.default.dirname(fromFile), importSource);
+        const candidates = [
+            base,
+            `${base}.ts`,
+            `${base}.tsx`,
+            `${base}.js`,
+            `${base}.jsx`,
+            path_1.default.join(base, 'index.ts'),
+            path_1.default.join(base, 'index.tsx'),
+            path_1.default.join(base, 'index.js'),
+            path_1.default.join(base, 'index.jsx'),
+        ];
+        for (const candidate of candidates) {
+            if (fs_1.default.existsSync(candidate) && fs_1.default.statSync(candidate).isFile()) {
+                return path_1.default.normalize(candidate);
+            }
+        }
+        return null;
     }
     findFilesContaining(dir, pattern) {
         const results = [];

package/dist/injection/ClippyIdInjector.js

@@ -157,10 +157,10 @@ function findAttributeInsertIndex(source, range) {
     if (!range)
         return null;
     const end = range[1];
-    const closeCharIndex = source.lastIndexOf('>', end - 1);
-    if (closeCharIndex === -1)
-        return null;
-    return closeCharIndex;
+    // Avoid searching backwards with lastIndexOf('>') — it hits '>' inside JSX expression
+    // containers (e.g. onClick={() => navigate('/')}). Use the AST range end directly.
+    const isSelfClosing = source[end - 2] === '/';
+    return isSelfClosing ? end - 2 : end - 1;
 }
 function applyEdits(source, edits) {
     const sorted = edits.slice().sort((a, b) => b.index - a.index);

package/dist/upload/BackendAdapter.d.ts

@@ -24,6 +24,13 @@ export interface SiteComponentRegistryUpload {
             effects?: any[];
             contextUsages?: any[];
         }>;
+        flows?: Array<{
+            name: string;
+            start_component: string;
+            end_component: string;
+            steps: string[];
+            user_intent: string;
+        }>;
     };
 }
 export declare function mapArtifactsToSiteRegistry(artifacts: PolicyArtifacts, domain: string): SiteComponentRegistryUpload;

package/dist/upload/BackendAdapter.js

@@ -20,15 +20,28 @@ function mapArtifactsToSiteRegistry(artifacts, domain) {
         file: c.filePath,
         stateVariables: c.stateVariables || [],
         interactions: c.interactions || [],
-        // Best-effort placeholders: preserve array shape expected by backend.
         conditionalRenders: [],
-        effects: (c.interactions || []).map((it) => ({
+        effects: (c.interactions || []).map(() => ({
             dependencies: [],
             asyncCalls: [],
             runsOnMount: false,
         })),
         contextUsages: [],
     }));
+    const flows = (artifacts.policy.flows || []).map((f) => {
+        // Map internal PolicyFlow -> spec FlowEntry shape.
+        // steps[] in PolicyFlow are route paths; use first/last as start/end component.
+        const stepTargets = f.steps.map((s) => s.target);
+        const startComponent = f.steps[0]?.target ?? f.page;
+        const endComponent = f.steps[f.steps.length - 1]?.target ?? f.page;
+        return {
+            name: f.flowId,
+            start_component: startComponent,
+            end_component: endComponent,
+            steps: stepTargets,
+            user_intent: f.intentPatterns?.[0] ?? '',
+        };
+    });
     return {
         domain,
         components: {
@@ -36,6 +49,7 @@ function mapArtifactsToSiteRegistry(artifacts, domain) {
             generatedAt,
             selectors,
             components,
+            ...(flows.length > 0 ? { flows } : {}),
         },
     };
 }

package/package.json

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