@superblocksteam/vite-plugin-file-sync 1.99.99-next.2 → 2.0.0-SNAPSHOT.84af65cd215b6ca1

package/dist/router-parser.js

@@ -0,0 +1,859 @@
+import { readFile, access, stat, readdir } from "node:fs/promises";
+import { join, resolve, dirname, relative } from "node:path";
+import { parse } from "@babel/parser";
+import { findStaticImports, parseStaticImport } from "mlly";
+import { joinURL } from "ufo";
+import { getFullImportPath } from "./resolver.js";
+import { traverse } from "./traverse.js";
+import { getLogger } from "./util/logger.js";
+const CONVENTIONAL_ROUTER_PATHS = [
+    "router.tsx",
+    "router.ts",
+    "src/router.tsx",
+    "src/router.ts",
+];
+let cachedRouterFileLocation = null;
+/**
+ * Resolve a .js import path to the actual source file (.ts, .tsx, .jsx)
+ *
+ * In development, imports may reference .js files but the actual source files
+ * have TypeScript extensions. This function tries to find the actual source file.
+ */
+async function resolveSourceFile(jsPath) {
+    let isDirectory = false;
+    // If the file exists as-is, return it
+    try {
+        const stats = await stat(jsPath);
+        if (stats.isFile()) {
+            return jsPath;
+        }
+        if (stats.isDirectory()) {
+            isDirectory = true;
+            // Extensionless directory import (e.g. "./pages/Dashboard"). Returning
+            // the directory itself would make the page read fail with EISDIR and
+            // silently drop the route (ENG-4805) — resolve to its index file.
+            // Note: a sibling file (pages/Dashboard.tsx) alongside the directory is
+            // not considered here; this fallback only runs when Vite's resolver
+            // already returned null, so the directory's index file is the best bet.
+            for (const indexFile of [
+                "index.tsx",
+                "index.ts",
+                "index.jsx",
+                "index.js",
+            ]) {
+                const indexPath = join(jsPath, indexFile);
+                try {
+                    if ((await stat(indexPath)).isFile()) {
+                        return indexPath;
+                    }
+                }
+                catch {
+                    // Try next index variant
+                }
+            }
+        }
+    }
+    catch {
+        // Path doesn't exist, try TypeScript variants
+    }
+    // Try different extensions
+    const extensions = [".ts", ".tsx", ".jsx"];
+    const pathWithoutExt = jsPath.replace(/\.js$/, "");
+    for (const ext of extensions) {
+        const tsPath = pathWithoutExt + ext;
+        try {
+            await access(tsPath);
+            return tsPath;
+        }
+        catch {
+            // Try next extension
+        }
+    }
+    if (isDirectory) {
+        // A directory with no index file can never be read as a page — returning
+        // it would EISDIR downstream. Return "" so the caller
+        // (extractRouteFromObject's `if (pageFilePath)` check) drops the route
+        // with an explicit resolution error instead.
+        return "";
+    }
+    // If none found, return original path (will error later)
+    return jsPath;
+}
+/**
+ * Extract local names that refer to createBrowserRouter from react-router imports
+ * Handles import aliasing like: import { createBrowserRouter as createRouter } from "react-router"
+ */
+function extractReactRouterImports(content) {
+    const createBrowserRouterAliases = new Set();
+    const namespaceImports = new Set();
+    try {
+        // find the react-router import statement
+        const reactRouterImport = findStaticImports(content).find((x) => x.specifier === "react-router");
+        if (!reactRouterImport) {
+            throw new Error("react-router import not found");
+        }
+        const parsedReactRouterImport = parseStaticImport(reactRouterImport);
+        // loop over named imports
+        if (parsedReactRouterImport.namedImports) {
+            // for each named import
+            for (const [name, alias] of Object.entries(parsedReactRouterImport.namedImports)) {
+                // add either the name or the alias (eg. import { createBrowserRouter as createRouter } from 'react-router') to the set
+                if (name === "createBrowserRouter") {
+                    createBrowserRouterAliases.add(name === alias ? name : alias);
+                }
+            }
+        }
+        if (parsedReactRouterImport.namespacedImport) {
+            namespaceImports.add(parsedReactRouterImport.namespacedImport);
+        }
+    }
+    catch (e) {
+        getLogger().debug(`Error extracting react-router imports: ${e}`);
+    }
+    return { createBrowserRouterAliases, namespaceImports };
+}
+/**
+ * Check if content contains createBrowserRouter call, accounting for import aliases
+ */
+function hasCreateBrowserRouter(content) {
+    const { createBrowserRouterAliases, namespaceImports } = extractReactRouterImports(content);
+    // Quick substring check first for performance
+    if (!content.includes("createBrowserRouter") &&
+        createBrowserRouterAliases.size === 0 &&
+        namespaceImports.size === 0) {
+        return false;
+    }
+    try {
+        const ast = parse(content, {
+            sourceType: "module",
+            plugins: ["typescript", "jsx"],
+        });
+        let found = false;
+        traverse(ast, {
+            CallExpression(path) {
+                const node = path.node;
+                // Check for direct call: createBrowserRouter() or alias()
+                if (node.callee.type === "Identifier") {
+                    if (createBrowserRouterAliases.has(node.callee.name)) {
+                        found = true;
+                        path.stop();
+                    }
+                }
+                // Check for namespace call: ReactRouter.createBrowserRouter()
+                else if (node.callee.type === "MemberExpression") {
+                    if (node.callee.object.type === "Identifier" &&
+                        namespaceImports.has(node.callee.object.name) &&
+                        node.callee.property.type === "Identifier" &&
+                        node.callee.property.name === "createBrowserRouter") {
+                        found = true;
+                        path.stop();
+                    }
+                }
+            },
+        });
+        return found;
+    }
+    catch {
+        // If parsing fails, fall back to substring check
+        return content.includes("createBrowserRouter");
+    }
+}
+/**
+ * Find all TypeScript/TSX files in rootDir
+ */
+async function findAllTsFiles(rootDir) {
+    const files = [];
+    async function scan(dir, depth = 0) {
+        // Limit depth to avoid deep recursion
+        if (depth > 3)
+            return;
+        try {
+            const entries = await readdir(dir, { withFileTypes: true });
+            for (const entry of entries) {
+                const fullPath = join(dir, entry.name);
+                // Skip node_modules and hidden directories
+                if (entry.name === "node_modules" || entry.name.startsWith(".")) {
+                    continue;
+                }
+                if (entry.isDirectory()) {
+                    await scan(fullPath, depth + 1);
+                }
+                else if (entry.isFile() &&
+                    (entry.name.endsWith(".ts") || entry.name.endsWith(".tsx"))) {
+                    files.push(fullPath);
+                }
+            }
+        }
+        catch (e) {
+            // Ignore permission errors or missing directories
+            getLogger().debug(`Error scanning directory ${dir}: ${e}`);
+        }
+    }
+    await scan(rootDir);
+    return files;
+}
+/**
+ * React Router v7 Support
+ *
+ * This implementation parses createBrowserRouter route configurations to extract page components.
+ *
+ * Check the test file for supported route configurations.
+ *
+ * Import Aliasing:
+ * - Handles: import { createBrowserRouter as createRouter } from "react-router"
+ * - Handles: import * as ReactRouter from "react-router"
+ *
+ * Excluded Routes:
+ * - Catch-all routes with path: "*"
+ * - Routes with inline components (not imported from files)
+ * - Layout/wrapper components that aren't page components
+ *
+ * File Organization:
+ * - No assumptions about directory structure
+ * - Page components can be located anywhere in the project
+ * - Only imports with relative paths (starting with . or /) are tracked
+ */
+/**
+ * Find the router file in the project (React Router v7)
+ */
+export async function findRouterFile(rootDir) {
+    // Check cache first with mtime validation
+    if (cachedRouterFileLocation) {
+        try {
+            const stats = await stat(cachedRouterFileLocation.path);
+            if (stats.mtimeMs === cachedRouterFileLocation.mtime) {
+                return cachedRouterFileLocation.path;
+            }
+            else {
+                cachedRouterFileLocation = null;
+            }
+        }
+        catch {
+            cachedRouterFileLocation = null;
+        }
+    }
+    // Try conventional locations first
+    for (const conventionalPath of CONVENTIONAL_ROUTER_PATHS) {
+        const fullPath = join(rootDir, conventionalPath);
+        try {
+            await access(fullPath);
+            const content = await readFile(fullPath, "utf-8");
+            if (hasCreateBrowserRouter(content)) {
+                const stats = await stat(fullPath);
+                cachedRouterFileLocation = { path: fullPath, mtime: stats.mtimeMs };
+                getLogger().info(`Found router file at: ${conventionalPath}`);
+                return fullPath;
+            }
+        }
+        catch {
+            continue;
+        }
+    }
+    // Fall back to scanning all TypeScript files in rootDir
+    getLogger().info("Router not found in conventional locations, scanning TypeScript files…");
+    const allTsFiles = await findAllTsFiles(rootDir);
+    for (const file of allTsFiles) {
+        try {
+            const content = await readFile(file, "utf-8");
+            if (hasCreateBrowserRouter(content)) {
+                const stats = await stat(file);
+                cachedRouterFileLocation = { path: file, mtime: stats.mtimeMs };
+                getLogger().info(`Found router file: ${relative(rootDir, file)}`);
+                return file;
+            }
+        }
+        catch {
+            continue;
+        }
+    }
+    throw new Error("Could not find router file with createBrowserRouter in project");
+}
+/**
+ * True for project-relative or alias imports (./, ../, /, @/) — i.e. paths
+ * we can resolve to a file in this repo. Filters out npm packages.
+ */
+function isRelativeOrAliasImport(specifier) {
+    return (specifier.startsWith(".") ||
+        specifier.startsWith("/") ||
+        specifier.startsWith("@/"));
+}
+/**
+ * Debug log emitted when `Component:` / `element:` references a value the
+ * parser couldn't resolve to an import, usually because the user wrote a
+ * binding shape we don't recognise.
+ */
+function logUnresolvedComponent(kind, reference, routerFilePath) {
+    getLogger().debug(`Router parser: could not resolve ${kind} "${reference}" to an import in ${routerFilePath}. ` +
+        `Supported page-component bindings: \`import X from "..."\`, ` +
+        `\`import { X } from "..."\`, or \`const X = lazy(() => import("..."))\`.`);
+}
+/**
+ * Extract the string specifier from `import("...")` or `import("...").then(...)`.
+ *
+ * When `callableImportMap` is provided, also resolves `obj.prop()` and
+ * `obj.prop().then(...)` patterns where `obj.prop` is a known import-returning
+ * callable (e.g. `const pageChunks = { Home: () => import("./pages/Home.tsx") }`).
+ */
+function extractImportSpecifierFromExpression(node, callableImportMap) {
+    if (!node)
+        return null;
+    // Direct import("...")
+    if (node.type === "CallExpression" &&
+        node.callee.type === "Import" &&
+        node.arguments[0]?.type === "StringLiteral") {
+        return node.arguments[0].value;
+    }
+    // import("...").then(...)
+    if (node.type === "CallExpression" &&
+        node.callee.type === "MemberExpression" &&
+        node.callee.object.type === "CallExpression" &&
+        node.callee.object.callee.type === "Import" &&
+        node.callee.object.arguments[0]?.type === "StringLiteral") {
+        return node.callee.object.arguments[0].value;
+    }
+    if (callableImportMap && callableImportMap.size > 0) {
+        // obj.prop() — direct call to a known import-returning function
+        if (node.type === "CallExpression" &&
+            node.callee.type === "MemberExpression") {
+            const resolved = resolveCallableMemberExpression(node.callee, callableImportMap);
+            if (resolved)
+                return resolved;
+        }
+        // obj.prop().then(...) — call to a known import-returning function followed by .then()
+        if (node.type === "CallExpression" &&
+            node.callee.type === "MemberExpression" &&
+            !node.callee.computed &&
+            node.callee.property.type === "Identifier" &&
+            node.callee.property.name === "then" &&
+            node.callee.object.type === "CallExpression" &&
+            node.callee.object.callee.type === "MemberExpression") {
+            const resolved = resolveCallableMemberExpression(node.callee.object.callee, callableImportMap);
+            if (resolved)
+                return resolved;
+        }
+    }
+    return null;
+}
+/**
+ * Resolve a `MemberExpression` against a callable-import map, supporting both
+ * dot access (`obj.foo`) and computed string-literal access (`obj["foo"]`).
+ *
+ * Computed access with a dynamic key (e.g. `obj[name]`) is intentionally not
+ * resolved — there is no way to know the property name at parse time.
+ */
+function resolveCallableMemberExpression(member, callableImportMap) {
+    if (member.object.type !== "Identifier")
+        return null;
+    let propName = null;
+    if (!member.computed && member.property.type === "Identifier") {
+        propName = member.property.name;
+    }
+    else if (member.computed && member.property.type === "StringLiteral") {
+        propName = member.property.value;
+    }
+    if (!propName)
+        return null;
+    return callableImportMap.get(member.object.name)?.get(propName) ?? null;
+}
+/**
+ * Extract the dynamic import specifier from the body of an importer function —
+ * an arrow (`() => ...`), a plain `function () { ... }` expression, or an
+ * object method shorthand (`Home() { ... }`).
+ *
+ * Recognized shapes:
+ *   () => import("./Page.tsx")
+ *   () => import("./Page.tsx").then(mod => ({ Component: mod.default }))
+ *   async () => await import("./Page.tsx")
+ *   async () => { const m = await import("./Page.tsx"); return { Component: m.default }; }
+ *   () => { return import("./Page.tsx"); }
+ *   function () { return import("./Page.tsx"); }
+ *   Home() { return import("./Page.tsx"); }   (object method shorthand)
+ *   () => obj.prop()                      (when obj.prop is a known import-returning callable)
+ *   () => obj.prop().then(mod => (...))   (same, with .then() chained)
+ */
+function extractImportPathFromFunction(node, callableImportMap) {
+    const body = node.body;
+    if (body.type === "BlockStatement") {
+        for (const statement of body.body) {
+            if (statement.type === "VariableDeclaration") {
+                for (const decl of statement.declarations) {
+                    let init = decl.init;
+                    if (init?.type === "AwaitExpression")
+                        init = init.argument;
+                    const path = extractImportSpecifierFromExpression(init, callableImportMap);
+                    if (path)
+                        return path;
+                }
+            }
+            else if (statement.type === "ReturnStatement") {
+                let arg = statement.argument;
+                if (arg?.type === "AwaitExpression")
+                    arg = arg.argument;
+                const path = extractImportSpecifierFromExpression(arg, callableImportMap);
+                if (path)
+                    return path;
+            }
+        }
+        return null;
+    }
+    // Expression body — possibly wrapped in `await`
+    const expr = body.type === "AwaitExpression" && body.argument ? body.argument : body;
+    return extractImportSpecifierFromExpression(expr, callableImportMap);
+}
+/**
+ * Extract the page import specifier from a `lazy:` route property value.
+ *
+ * Handles the direct arrow form the template ships with
+ * (`lazy: () => import("...")`, `lazy: () => import("...").then(...)`), a plain
+ * `function () { return import("..."); }` importer, and helper-wrapped
+ * importers nested to any depth — including a `.then(...)` chained on the
+ * wrapper's result (`lazy: lazyPage(() => import("...")).then(...)`),
+ * `lazy: lazyPage(() => import("..."))`, and
+ * `lazy: withAuth(lazyPage(() => import("...")))`. Clark and several
+ * third-party migration sources factor the
+ * `.then(mod => ({ Component: mod.default }))` boilerplate into a small
+ * `lazyPage`/`lazyRoute` helper, sometimes behind further wrappers. The wrapped
+ * value is a `CallExpression`, so without unwrapping it the parser drops every
+ * route and the editor renders the "404 / route has been deleted" overlay over
+ * an app that actually works.
+ *
+ * An `Identifier` resolves through `lazyLoaderBindings` (a const bound to a
+ * loader, e.g. `const overview = lazyPage(...); { lazy: overview }`), at any
+ * nesting depth — `overview`, `(overview as any)`, `withAuth(overview)`.
+ *
+ * Limitation: when a helper receives multiple import-bearing arguments (e.g.
+ * `withFallback(() => import("./a"), () => import("./b"))`), the first import
+ * found wins. Every real/tested loader shape carries exactly one importer.
+ */
+function extractImportPathFromLazyValue(node, callableImportMap, lazyLoaderBindings) {
+    // `lazy: overview` — a const bound to a loader elsewhere in the file.
+    if (node.type === "Identifier") {
+        return lazyLoaderBindings?.get(node.name) ?? null;
+    }
+    // See through TS type wrappers (`... as any`, `... satisfies T`, `...!`).
+    // They are transparent at runtime, so the importer lives on `.expression`.
+    if (node.type === "TSAsExpression" ||
+        node.type === "TSSatisfiesExpression" ||
+        node.type === "TSNonNullExpression") {
+        return extractImportPathFromLazyValue(node.expression, callableImportMap, lazyLoaderBindings);
+    }
+    if (node.type === "ArrowFunctionExpression" ||
+        node.type === "FunctionExpression") {
+        return extractImportPathFromFunction(node, callableImportMap);
+    }
+    if (node.type === "CallExpression") {
+        // The call itself may already resolve to an import: `import("...")`,
+        // `import("...").then(...)`, or a known `obj.prop()` callable.
+        const direct = extractImportSpecifierFromExpression(node, callableImportMap);
+        if (direct)
+            return direct;
+        // `.then()` (or any method) chained on a wrapper's *return value*:
+        // `lazyPage(() => import("...")).then(...)`. The importer lives in the
+        // callee's object (the wrapper call), not in this call's arguments.
+        if (node.callee.type === "MemberExpression" &&
+            node.callee.object.type === "CallExpression") {
+            const fromWrapper = extractImportPathFromLazyValue(node.callee.object, callableImportMap, lazyLoaderBindings);
+            if (fromWrapper)
+                return fromWrapper;
+        }
+        // Helper-wrapped importer, possibly nested (e.g.
+        // `withAuth(lazyPage(() => import("...")))`). Recurse into each argument so
+        // any depth of wrapping still yields the underlying import.
+        for (const arg of node.arguments) {
+            const path = extractImportPathFromLazyValue(arg, callableImportMap, lazyLoaderBindings);
+            if (path)
+                return path;
+        }
+    }
+    return null;
+}
+/**
+ * Recognize `lazy(() => import("..."))` / `React.lazy(() => import("..."))`
+ * (arrow or plain `function () { return import("..."); }` importer) and return
+ * the import specifier.
+ *
+ * Top-level `const X = lazy(...)` declarations are commonly emitted by
+ * Lovable, Replit and v0 source apps and are idiomatic React. Without this,
+ * routers that bind such consts via `Component: X` would silently drop the
+ * route, since `findStaticImports()` does not see runtime variable bindings.
+ */
+function extractLazyImportPath(node) {
+    if (node.type !== "CallExpression")
+        return null;
+    const callee = node.callee;
+    const isLazy = (callee.type === "Identifier" && callee.name === "lazy") ||
+        (callee.type === "MemberExpression" &&
+            !callee.computed &&
+            callee.object.type === "Identifier" &&
+            callee.object.name === "React" &&
+            callee.property.type === "Identifier" &&
+            callee.property.name === "lazy");
+    if (!isLazy)
+        return null;
+    const arg = node.arguments[0];
+    if (!arg ||
+        (arg.type !== "ArrowFunctionExpression" &&
+            arg.type !== "FunctionExpression")) {
+        return null;
+    }
+    return extractImportPathFromFunction(arg);
+}
+/**
+ * Extract all static imports
+ * Maps component identifier names to their import paths
+ * We track ALL imports because any import can be used as a page Component
+ */
+function extractAllImports(content) {
+    const imports = new Map();
+    try {
+        const staticImports = findStaticImports(content);
+        for (const staticImport of staticImports) {
+            const parsed = parseStaticImport(staticImport);
+            // Skip imports from node_modules and react-router
+            if (!isRelativeOrAliasImport(parsed.specifier)) {
+                continue;
+            }
+            // Handle default imports: import Page1 from "./components/Page1.tsx"
+            if (parsed.defaultImport) {
+                imports.set(parsed.defaultImport, parsed.specifier);
+            }
+            // Handle named imports: import { Page1 } from "./components/Page1.tsx"
+            if (parsed.namedImports) {
+                for (const [name, alias] of Object.entries(parsed.namedImports)) {
+                    const localName = name === alias ? name : alias;
+                    imports.set(localName, parsed.specifier);
+                }
+            }
+        }
+    }
+    catch (e) {
+        getLogger().debug(`Error extracting imports: ${e}`);
+    }
+    return imports;
+}
+function resolveElementImportPath(node, allImports) {
+    let componentName = null;
+    if (node.type === "JSXElement" &&
+        node.openingElement.name.type === "JSXIdentifier") {
+        componentName = node.openingElement.name.name;
+    }
+    else if (node.type === "CallExpression" &&
+        node.callee.type === "Identifier" &&
+        node.arguments.length === 1 &&
+        node.arguments[0]?.type === "Identifier") {
+        componentName = node.arguments[0].name;
+    }
+    return componentName ? (allImports.get(componentName) ?? null) : null;
+}
+/**
+ * Parse the router file to extract route definitions (React Router v7)
+ */
+export async function parseRouterFile(routerFilePath, rootDir) {
+    try {
+        const content = await readFile(routerFilePath, "utf-8");
+        const { createBrowserRouterAliases, namespaceImports } = extractReactRouterImports(content);
+        const allImports = extractAllImports(content);
+        const ast = parse(content, {
+            sourceType: "module",
+            plugins: ["typescript", "jsx"],
+        });
+        const routes = [];
+        let routesArray = null;
+        // Collect top-level variable declarations so we can resolve identifier references
+        const variableDeclarations = new Map();
+        // Collect top-level objects whose properties are import-returning arrow functions.
+        // e.g. const pageChunks = { Home: () => import("./pages/Home.tsx") }
+        // Maps objectName → (propertyName → importPath)
+        const callableImportMap = new Map();
+        // Collect top-level consts bound to a lazy loader so `lazy: overview`
+        // (Identifier) resolves. e.g. const overview = lazyPage(() => import("..."))
+        // Maps loaderName → importPath.
+        const lazyLoaderBindings = new Map();
+        traverse(ast, {
+            VariableDeclarator(astPath) {
+                const node = astPath.node;
+                if (node.id.type !== "Identifier" || !node.init)
+                    return;
+                if (node.init.type === "ArrayExpression") {
+                    variableDeclarations.set(node.id.name, node.init);
+                }
+                else if (node.init.type === "TSAsExpression" &&
+                    node.init.expression.type === "ArrayExpression") {
+                    variableDeclarations.set(node.id.name, node.init.expression);
+                }
+                else if (node.init.type === "TSSatisfiesExpression" &&
+                    node.init.expression.type === "ArrayExpression") {
+                    variableDeclarations.set(node.id.name, node.init.expression);
+                }
+                // Only register top-level lazy bindings (Program > VarDecl or
+                // Program > ExportNamedDecl > VarDecl) and never overwrite a
+                // static import — prevents nested/helper-scoped rebindings.
+                const declarationParent = astPath.parentPath?.parentPath;
+                const isTopLevel = declarationParent
+                    ? declarationParent.isProgram() ||
+                        (declarationParent.isExportNamedDeclaration() &&
+                            (declarationParent.parentPath?.isProgram() ?? false))
+                    : false;
+                // Collect top-level object expressions with arrow-function properties
+                // that contain import() calls (e.g. preload/chunk maps).
+                // Unwrap `as const` / `satisfies T` wrappers the same way we do for arrays.
+                if (isTopLevel) {
+                    let objectExpr = null;
+                    if (node.init.type === "ObjectExpression") {
+                        objectExpr = node.init;
+                    }
+                    else if (node.init.type === "TSAsExpression" &&
+                        node.init.expression.type === "ObjectExpression") {
+                        objectExpr = node.init.expression;
+                    }
+                    else if (node.init.type === "TSSatisfiesExpression" &&
+                        node.init.expression.type === "ObjectExpression") {
+                        objectExpr = node.init.expression;
+                    }
+                    if (objectExpr) {
+                        const propMap = new Map();
+                        for (const prop of objectExpr.properties) {
+                            // Accept arrow/function-expression values (`Home: () => import(...)`)
+                            // and method shorthands (`Home() { return import(...); }`).
+                            let fn = null;
+                            if (prop.type === "ObjectProperty" &&
+                                (prop.value.type === "ArrowFunctionExpression" ||
+                                    prop.value.type === "FunctionExpression")) {
+                                fn = prop.value;
+                            }
+                            else if (prop.type === "ObjectMethod" &&
+                                prop.kind === "method") {
+                                fn = prop;
+                            }
+                            else {
+                                continue;
+                            }
+                            // Accept both identifier keys (`Welcome:`) and string-literal
+                            // keys (`"my-page":`); both look up the same way at call sites.
+                            let propName = null;
+                            if (prop.key.type === "Identifier" && !prop.computed) {
+                                propName = prop.key.name;
+                            }
+                            else if (prop.key.type === "StringLiteral") {
+                                propName = prop.key.value;
+                            }
+                            if (!propName)
+                                continue;
+                            const importPath = extractImportPathFromFunction(fn);
+                            if (importPath && isRelativeOrAliasImport(importPath)) {
+                                propMap.set(propName, importPath);
+                            }
+                        }
+                        if (propMap.size > 0) {
+                            callableImportMap.set(node.id.name, propMap);
+                        }
+                    }
+                }
+                if (isTopLevel && !allImports.has(node.id.name)) {
+                    const lazyImportPath = extractLazyImportPath(node.init);
+                    if (lazyImportPath && isRelativeOrAliasImport(lazyImportPath)) {
+                        allImports.set(node.id.name, lazyImportPath);
+                    }
+                }
+                // A const bound to any lazy loader shape (helper-wrapped, arrow, etc.)
+                // so a later `lazy: <name>` Identifier reference resolves. Kept separate
+                // from allImports so Component/element identifier resolution stays
+                // limited to actual component bindings.
+                if (isTopLevel && !lazyLoaderBindings.has(node.id.name)) {
+                    const loaderImportPath = extractImportPathFromLazyValue(node.init, callableImportMap, lazyLoaderBindings);
+                    if (loaderImportPath && isRelativeOrAliasImport(loaderImportPath)) {
+                        lazyLoaderBindings.set(node.id.name, loaderImportPath);
+                    }
+                }
+            },
+        });
+        traverse(ast, {
+            CallExpression(astPath) {
+                const node = astPath.node;
+                let isCreateBrowserRouterCall = false;
+                // Check for direct call: createBrowserRouter() or alias()
+                if (node.callee.type === "Identifier") {
+                    if (createBrowserRouterAliases.has(node.callee.name)) {
+                        isCreateBrowserRouterCall = true;
+                    }
+                }
+                // Check for namespace call: ReactRouter.createBrowserRouter()
+                else if (node.callee.type === "MemberExpression") {
+                    if (node.callee.object.type === "Identifier" &&
+                        namespaceImports.has(node.callee.object.name) &&
+                        node.callee.property.type === "Identifier" &&
+                        node.callee.property.name === "createBrowserRouter") {
+                        isCreateBrowserRouterCall = true;
+                    }
+                }
+                if (isCreateBrowserRouterCall && node.arguments.length > 0) {
+                    const firstArg = node.arguments[0];
+                    if (firstArg?.type === "ArrayExpression") {
+                        routesArray = firstArg;
+                    }
+                    else if (firstArg?.type === "Identifier") {
+                        const resolved = variableDeclarations.get(firstArg.name);
+                        if (resolved) {
+                            routesArray = resolved;
+                        }
+                    }
+                }
+            },
+        });
+        // Process routes asynchronously after traverse
+        if (routesArray) {
+            await extractRoutesFromArray(routesArray, routes, routerFilePath, rootDir, "", allImports, callableImportMap, lazyLoaderBindings);
+        }
+        return routes;
+    }
+    catch (e) {
+        getLogger().error(`Error parsing router file: ${e}`);
+        return [];
+    }
+}
+async function extractRoutesFromArray(node, routes, routerFilePath, rootDir, parentPath, allImports, callableImportMap, lazyLoaderBindings) {
+    for (const element of node.elements) {
+        if (element && element.type === "ObjectExpression") {
+            await extractRouteFromObject(element, routes, routerFilePath, rootDir, parentPath, allImports, callableImportMap, lazyLoaderBindings);
+        }
+    }
+}
+async function extractRouteFromObject(node, routes, routerFilePath, rootDir, parentPath, allImports, callableImportMap, lazyLoaderBindings) {
+    let routePath = null;
+    let pageImportPath = null;
+    let children = null;
+    let hasIndex = false;
+    for (const prop of node.properties) {
+        if (prop.type !== "ObjectProperty")
+            continue;
+        const key = prop.key.type === "Identifier" ? prop.key.name : null;
+        if (key === "path" && prop.value.type === "StringLiteral") {
+            routePath = prop.value.value;
+        }
+        else if (key === "index" && prop.value.type === "BooleanLiteral") {
+            hasIndex = prop.value.value;
+        }
+        else if (key === "lazy") {
+            const path = extractImportPathFromLazyValue(prop.value, callableImportMap, lazyLoaderBindings);
+            if (path)
+                pageImportPath = path;
+        }
+        else if (key === "Component" && prop.value.type === "Identifier") {
+            // Component property uses an identifier: Component: HomePage
+            const componentName = prop.value.name;
+            if (allImports.has(componentName)) {
+                pageImportPath = allImports.get(componentName);
+            }
+            else {
+                logUnresolvedComponent("Component", componentName, routerFilePath);
+            }
+        }
+        else if (key === "element") {
+            const elementImportPath = resolveElementImportPath(prop.value, allImports);
+            if (elementImportPath) {
+                pageImportPath = elementImportPath;
+            }
+            else if (prop.value.type === "CallExpression") {
+                const callee = prop.value.callee.type === "Identifier"
+                    ? prop.value.callee.name
+                    : prop.value.callee.type;
+                const argumentTypes = prop.value.arguments
+                    .map((argument) => argument.type)
+                    .join(", ");
+                logUnresolvedComponent("element call", `${callee}(${argumentTypes})`, routerFilePath);
+            }
+            else if (prop.value.type === "JSXElement" &&
+                prop.value.openingElement.name.type === "JSXIdentifier") {
+                logUnresolvedComponent("element", prop.value.openingElement.name.name, routerFilePath);
+            }
+        }
+        else if (key === "children" && prop.value.type === "ArrayExpression") {
+            children = prop.value;
+        }
+    }
+    // Check if any children have index: true
+    let hasIndexChild = false;
+    if (children) {
+        for (const child of children.elements) {
+            if (child && child.type === "ObjectExpression") {
+                for (const prop of child.properties) {
+                    if (prop.type === "ObjectProperty" &&
+                        prop.key.type === "Identifier" &&
+                        prop.key.name === "index" &&
+                        prop.value.type === "BooleanLiteral" &&
+                        prop.value.value === true) {
+                        hasIndexChild = true;
+                        break;
+                    }
+                }
+            }
+            if (hasIndexChild)
+                break;
+        }
+    }
+    // Add route if we found a page import (either lazy or static)
+    // Skip routes with:
+    // - path "*" (catch-all routes)
+    // - no path and no index (path-less layout routes)
+    // - routes that have an index child (layout routes)
+    if (pageImportPath &&
+        routePath !== "*" &&
+        (routePath || hasIndex) &&
+        !hasIndexChild) {
+        // Build the full route path:
+        // 1. If routePath is explicitly set, use it (takes precedence over index)
+        // 2. If only index: true (no explicit path), use parent path
+        let fullRoutePath;
+        if (routePath) {
+            fullRoutePath = joinURL(parentPath, routePath);
+        }
+        else if (hasIndex) {
+            fullRoutePath = parentPath;
+        }
+        else {
+            // This shouldn't happen due to our check above, but handle it anyway
+            fullRoutePath = parentPath;
+        }
+        // Normalize empty path to "/"
+        if (!fullRoutePath) {
+            fullRoutePath = "/";
+        }
+        // Resolve the import path to an absolute file path, try Vite's resolver first, fall back to manual
+        let pageFilePath = null;
+        const viteResolved = await getFullImportPath(pageImportPath);
+        if (viteResolved) {
+            pageFilePath = viteResolved;
+        }
+        else {
+            const isRelativePath = pageImportPath.startsWith("./") || pageImportPath.startsWith("../");
+            if (isRelativePath) {
+                const resolvedPath = resolve(dirname(routerFilePath), pageImportPath);
+                pageFilePath = await resolveSourceFile(resolvedPath);
+            }
+        }
+        if (pageFilePath) {
+            routes.push({
+                path: fullRoutePath,
+                pageImportPath,
+                pageFilePath,
+            });
+        }
+        else {
+            const errorMessage = `Failed to resolve import path "${pageImportPath}" for route "${fullRoutePath}". This route will not be available.`;
+            getLogger().error(errorMessage, {
+                error: {
+                    kind: "ImportResolutionError",
+                    message: `Import: ${pageImportPath}, Route: ${fullRoutePath}, Router: ${routerFilePath}`,
+                },
+            });
+        }
+    }
+    // Recursively process children
+    if (children) {
+        const currentPath = routePath ? joinURL(parentPath, routePath) : parentPath;
+        // Normalize empty path to "/" before passing to children
+        const normalizedCurrentPath = currentPath || "/";
+        await extractRoutesFromArray(children, routes, routerFilePath, rootDir, normalizedCurrentPath, allImports, callableImportMap, lazyLoaderBindings);
+    }
+}
+//# sourceMappingURL=router-parser.js.map