@rayburst/cli 0.3.8 → 0.4.1

package/dist/{chunk-KOAVTHSN.js → chunk-4YULNVZV.js}

@@ -531,6 +531,33 @@ function analyzeJsxPropsForComponents(jsxElement, propName, projectPath, project
   }
   return componentPaths;
 }
+function extractRouterConfigFromJsx(jsxElement, propName) {
+  try {
+    const jsxAttributes = jsxElement.getChildrenOfKind(SyntaxKind.JsxAttributes)[0];
+    if (!jsxAttributes) return null;
+    const attributes = jsxAttributes.getChildrenOfKind(SyntaxKind.JsxAttribute);
+    for (const attr of attributes) {
+      const attrName = attr.getChildrenOfKind(SyntaxKind.Identifier)[0]?.getText();
+      if (attrName !== propName) continue;
+      const initializer = attr.getChildrenOfKind(SyntaxKind.JsxExpression)[0];
+      if (!initializer) continue;
+      const identifier = initializer.getChildrenOfKind(SyntaxKind.Identifier)[0];
+      if (!identifier) continue;
+      const declaration = traceIdentifierToDeclaration(identifier);
+      if (!declaration || !isVariableDeclaration(declaration)) continue;
+      const dataFlow = traceVariableDataFlow(declaration);
+      if (!dataFlow || !isCallExpression(dataFlow)) continue;
+      const args = dataFlow.getChildrenOfKind(SyntaxKind.SyntaxList)[0];
+      if (!args) continue;
+      const configArg = args.getChildrenOfKind(SyntaxKind.ObjectLiteralExpression)[0];
+      if (!configArg) continue;
+      return extractRouterConfig(configArg);
+    }
+  } catch (error) {
+    console.error("[extractRouterConfigFromJsx] Error:", error);
+  }
+  return null;
+}
 function traceConfigToComponentPaths(configObject, propertyName, projectPath, project) {
   try {
     const propertyNode = traceConfigProperty(configObject, propertyName);
@@ -667,12 +694,21 @@ function detectConfigBasedComponents(sourceFile, nodes, nodeMap, edges, projectP
         if (componentPaths.length > 0) {
           if (propName === "router") {
             console.log(`[DEBUG] Creating router decision node for ${componentPaths.length} routes`);
+            const routerConfig = extractRouterConfigFromJsx(jsxElement, propName);
+            console.log(`[DEBUG] Router config extracted:`, routerConfig);
+            if (routerConfig) {
+              routerConfig.routeTree = componentPaths.length;
+            }
             const relativePath = sourceFile.getFilePath().replace(projectPath + "/", "");
             const routerNode = createRouterDecisionNode(relativePath, gitHash, componentPaths.length);
             nodes.push(routerNode);
             nodeMap.set(routerNode.id, routerNode);
             const routerProviderExternalId = "external::@tanstack/react-router::RouterProvider";
-            const routerProviderNode = externalNodeMap.get(routerProviderExternalId);
+            let routerProviderNode = externalNodeMap.get(routerProviderExternalId);
+            if (routerProviderNode && routerConfig) {
+              console.log(`[DEBUG] Updating RouterProvider node with config`);
+              routerProviderNode.data.providerItems = formatRouterConfigAsProviderItems(routerConfig);
+            }
             if (routerProviderNode) {
               const providerToRouterEdgeId = `e-${routerProviderNode.id}-${routerNode.id}`;
               if (!edges.find((e) => e.id === providerToRouterEdgeId)) {
@@ -706,16 +742,58 @@ function detectConfigBasedComponents(sourceFile, nodes, nodeMap, edges, projectP
                 totalEdgesCreated++;
               }
             }
-            const routerToRoutesEdges = createConfigBasedEdges(
-              routerNode,
-              componentPaths,
-              nodeMap,
-              edges,
-              "route",
-              true
-              // Use route path labels
-            );
-            totalEdgesCreated += routerToRoutesEdges;
+            let decisionNodesCreated = 0;
+            let decisionEdgesCreated = 0;
+            for (const routeFilePath of componentPaths) {
+              const routePath = extractRoutePathFromFile(routeFilePath);
+              const isDynamic = routePath.includes(":");
+              const decisionNodeId = `${routerNode.id}::decision::${routePath.replace(/[/:]/g, "_")}`;
+              const decisionNode = {
+                id: decisionNodeId,
+                type: "conditional",
+                position: { x: 800, y: 400 + decisionNodesCreated * 100 },
+                data: {
+                  label: isDynamic ? `matches "${routePath}"` : `path === "${routePath}"`,
+                  description: `Route condition for ${routePath}`,
+                  condition: isDynamic ? `pathname.matches("${routePath}")` : `pathname === "${routePath}"`,
+                  trueLabel: "render",
+                  falseLabel: "skip"
+                }
+              };
+              nodes.push(decisionNode);
+              nodeMap.set(decisionNode.id, decisionNode);
+              decisionNodesCreated++;
+              const routerToDecisionEdgeId = `e-${routerNode.id}-${decisionNode.id}`;
+              if (!edges.find((e) => e.id === routerToDecisionEdgeId)) {
+                edges.push({
+                  id: routerToDecisionEdgeId,
+                  source: routerNode.id,
+                  target: decisionNode.id,
+                  type: "floating",
+                  label: routePath
+                });
+                decisionEdgesCreated++;
+              }
+              const targetNodes = findNodesInFile(routeFilePath, nodeMap);
+              for (const targetNode of targetNodes) {
+                if (targetNode.type !== "component") {
+                  continue;
+                }
+                const decisionToComponentEdgeId = `e-${decisionNode.id}-${targetNode.id}`;
+                if (!edges.find((e) => e.id === decisionToComponentEdgeId)) {
+                  edges.push({
+                    id: decisionToComponentEdgeId,
+                    source: decisionNode.id,
+                    target: targetNode.id,
+                    type: "floating",
+                    label: "true"
+                  });
+                  decisionEdgesCreated++;
+                }
+              }
+            }
+            console.log(`[ROUTER] Created ${decisionNodesCreated} decision nodes and ${decisionEdgesCreated} edges`);
+            totalEdgesCreated += decisionEdgesCreated;
           } else {
             console.log(`[DEBUG] Creating edges for ${componentPaths.length} components`);
             const edgesCreated = createConfigBasedEdges(
@@ -1312,17 +1390,110 @@ function resolveImportSource(sourceFile, identifierName) {
   }
   return null;
 }
-function createExternalComponentNode(componentName, packageName, sourceFilePath, nodes, nodeMap, externalNodeMap) {
+function formatRouterConfigAsProviderItems(config) {
+  const items = [];
+  if (config.routeTree !== void 0) {
+    items.push({
+      name: "routeTree",
+      type: typeof config.routeTree === "number" ? `RouteTree (${config.routeTree} routes)` : "RouteTree",
+      icon: "Other",
+      connections: typeof config.routeTree === "number" ? config.routeTree : 0
+    });
+  }
+  if (config.context !== void 0) {
+    items.push({
+      name: "context",
+      type: typeof config.context === "string" ? config.context : "object",
+      icon: "State",
+      connections: 0
+    });
+  }
+  if (config.defaultPreload !== void 0) {
+    items.push({
+      name: "defaultPreload",
+      type: `'${config.defaultPreload}'`,
+      icon: "Other",
+      connections: 0
+    });
+  }
+  if (config.scrollRestoration !== void 0) {
+    items.push({
+      name: "scrollRestoration",
+      type: String(config.scrollRestoration),
+      icon: "Other",
+      connections: 0
+    });
+  }
+  if (config.defaultStructuralSharing !== void 0) {
+    items.push({
+      name: "defaultStructuralSharing",
+      type: String(config.defaultStructuralSharing),
+      icon: "Other",
+      connections: 0
+    });
+  }
+  if (config.defaultPreloadStaleTime !== void 0) {
+    items.push({
+      name: "defaultPreloadStaleTime",
+      type: `${config.defaultPreloadStaleTime}ms`,
+      icon: "Other",
+      connections: 0
+    });
+  }
+  return items;
+}
+function extractRouterConfig(configArg) {
+  const config = {};
+  try {
+    if (!Node.isObjectLiteralExpression(configArg)) {
+      return config;
+    }
+    const properties = configArg.getProperties();
+    for (const prop of properties) {
+      if (Node.isPropertyAssignment(prop) || Node.isShorthandPropertyAssignment(prop)) {
+        const name = prop.getName();
+        if (Node.isPropertyAssignment(prop)) {
+          const initializer = prop.getInitializer();
+          if (initializer) {
+            if (Node.isStringLiteral(initializer)) {
+              config[name] = initializer.getLiteralValue();
+            } else if (Node.isNumericLiteral(initializer)) {
+              config[name] = initializer.getLiteralValue();
+            } else if (initializer.getKind() === SyntaxKind.TrueKeyword || initializer.getKind() === SyntaxKind.FalseKeyword) {
+              config[name] = initializer.getText() === "true";
+            } else if (Node.isObjectLiteralExpression(initializer)) {
+              config[name] = "{}";
+            } else {
+              config[name] = initializer.getText();
+            }
+          }
+        } else if (Node.isShorthandPropertyAssignment(prop)) {
+          config[name] = prop.getName();
+        }
+      }
+    }
+  } catch (error) {
+    console.error("[extractRouterConfig] Error:", error);
+  }
+  return config;
+}
+function createExternalComponentNode(componentName, packageName, sourceFilePath, nodes, nodeMap, externalNodeMap, routerConfig) {
   const externalId = `external::${packageName}::${componentName}`;
   if (externalNodeMap.has(externalId)) {
     return externalNodeMap.get(externalId);
   }
+  const isRouterProvider = componentName === "RouterProvider" && packageName === "@tanstack/react-router";
   const node = {
     id: externalId,
-    type: "component",
+    type: isRouterProvider ? "provider" : "component",
     position: { x: 1200, y: nodes.length * 150 },
     // Position externals to the right
-    data: {
+    data: isRouterProvider ? {
+      providerName: componentName,
+      label: componentName,
+      description: `External: ${packageName}`,
+      providerItems: routerConfig ? formatRouterConfigAsProviderItems(routerConfig) : []
+    } : {
       componentName,
       props: "external",
       label: componentName,

package/dist/index.js

@@ -9,7 +9,7 @@ import {
   readLocalMeta,
   writeLocalAnalysis,
   writeLocalMeta
-} from "./chunk-KOAVTHSN.js";
+} from "./chunk-4YULNVZV.js";
 export {
   addGitignoreEntry,
   analyzeProject,

package/dist/vite-plugin.js

@@ -1,6 +1,6 @@
 import {
   rayburstPlugin
-} from "./chunk-KOAVTHSN.js";
+} from "./chunk-4YULNVZV.js";
 export {
   rayburstPlugin
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rayburst/cli",
-  "version": "0.3.8",
+  "version": "0.4.1",
   "description": "Rayburst - Automatic code analysis for TypeScript/JavaScript projects via Vite plugin",
   "type": "module",
   "main": "./dist/index.js",