@react-router/dev 0.0.0-experimental-2bfe0a2f2 → 0.0.0-experimental-345f1da12

package/dist/cli/index.js

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 /**
- * @react-router/dev v0.0.0-experimental-2bfe0a2f2
+ * @react-router/dev v0.0.0-experimental-345f1da12
  *
  * Copyright (c) Remix Software Inc.
  *
@@ -55,26 +55,55 @@ var init_invariant = __esm({
   }
 });
 
-// vite/import-vite-esm-sync.ts
-async function preloadViteEsm() {
-  vite = await import("vite");
+// config/is-react-router-repo.ts
+function isReactRouterRepo() {
+  let serverRuntimePath = import_pathe.default.dirname(
+    require.resolve("@react-router/node/package.json")
+  );
+  let serverRuntimeParentDir = import_pathe.default.basename(
+    import_pathe.default.resolve(serverRuntimePath, "..")
+  );
+  return serverRuntimeParentDir === "packages";
+}
+var import_pathe;
+var init_is_react_router_repo = __esm({
+  "config/is-react-router-repo.ts"() {
+    "use strict";
+    import_pathe = __toESM(require("pathe"));
+  }
+});
+
+// vite/vite.ts
+async function preloadVite() {
+  vite = await import(viteImportSpecifier);
 }
-function importViteEsmSync() {
-  invariant(vite, "importViteEsmSync() called before preloadViteEsm()");
+function getVite() {
+  invariant(vite, "getVite() called before preloadVite()");
   return vite;
 }
-var vite;
-var init_import_vite_esm_sync = __esm({
-  "vite/import-vite-esm-sync.ts"() {
+var import_pathe2, vite, viteImportSpecifier;
+var init_vite = __esm({
+  "vite/vite.ts"() {
     "use strict";
+    import_pathe2 = __toESM(require("pathe"));
     init_invariant();
+    init_is_react_router_repo();
+    viteImportSpecifier = isReactRouterRepo() ? (
+      // Support testing against different versions of Vite by ensuring that Vite
+      // is resolved from the current working directory when running within this
+      // repo. If we don't do this, Vite will always be imported relative to this
+      // file, which means that it will always resolve to Vite 6.
+      `file:///${import_pathe2.default.normalize(
+        require.resolve("vite/package.json", { paths: [process.cwd()] })
+      ).replace("package.json", "dist/node/index.js")}`
+    ) : "vite";
   }
 });
 
 // vite/vite-node.ts
 async function createContext(viteConfig = {}) {
-  await preloadViteEsm();
-  const vite2 = importViteEsmSync();
+  await preloadVite();
+  const vite2 = getVite();
   const devServer = await vite2.createServer(
     vite2.mergeConfig(
       {
@@ -100,11 +129,11 @@ async function createContext(viteConfig = {}) {
   const runner = new import_client.ViteNodeRunner({
     root: devServer.config.root,
     base: devServer.config.base,
-    fetchModule(id2) {
-      return server.fetchModule(id2);
+    fetchModule(id) {
+      return server.fetchModule(id);
     },
-    resolveId(id2, importer) {
-      return server.resolveId(id2, importer);
+    resolveId(id, importer) {
+      return server.resolveId(id, importer);
     }
   });
   return { devServer, server, runner };
@@ -116,7 +145,7 @@ var init_vite_node = __esm({
     import_server = require("vite-node/server");
     import_client = require("vite-node/client");
     import_source_map = require("vite-node/source-map");
-    init_import_vite_esm_sync();
+    init_vite();
   }
 });
 
@@ -149,7 +178,7 @@ function validateRouteConfig({
         `Route config in "${routeConfigFile}" is invalid.`,
         root ? `${root}` : [],
         nested ? Object.entries(nested).map(
-          ([path8, message]) => `Path: routes.${path8}
+          ([path10, message]) => `Path: routes.${path10}
 ${message}`
         ) : []
       ].flat().join("\n\n")
@@ -160,24 +189,24 @@ ${message}`
 function configRoutesToRouteManifest(appDirectory, routes2, rootId = "root") {
   let routeManifest = {};
   function walk(route, parentId) {
-    let id2 = route.id || createRouteId(route.file);
+    let id = route.id || createRouteId(route.file);
     let manifestItem = {
-      id: id2,
+      id,
       parentId,
       file: Path.isAbsolute(route.file) ? Path.relative(appDirectory, route.file) : route.file,
       path: route.path,
       index: route.index,
       caseSensitive: route.caseSensitive
     };
-    if (routeManifest.hasOwnProperty(id2)) {
+    if (routeManifest.hasOwnProperty(id)) {
       throw new Error(
-        `Unable to define routes with duplicate route id: "${id2}"`
+        `Unable to define routes with duplicate route id: "${id}"`
       );
     }
-    routeManifest[id2] = manifestItem;
+    routeManifest[id] = manifestItem;
     if (route.children) {
       for (let child of route.children) {
-        walk(child, id2);
+        walk(child, id);
       }
     }
   }
@@ -307,13 +336,13 @@ async function resolveConfig({
       "The `prerender` config must be a boolean, an array of string paths, or a function returning a boolean or array of string paths"
     );
   }
-  let appDirectory = import_pathe.default.resolve(root, userAppDirectory || "app");
-  let buildDirectory = import_pathe.default.resolve(root, userBuildDirectory);
+  let appDirectory = import_pathe3.default.resolve(root, userAppDirectory || "app");
+  let buildDirectory = import_pathe3.default.resolve(root, userBuildDirectory);
   let rootRouteFile = findEntry(appDirectory, "root");
   if (!rootRouteFile) {
-    let rootRouteDisplayPath = import_pathe.default.relative(
+    let rootRouteDisplayPath = import_pathe3.default.relative(
       root,
-      import_pathe.default.join(appDirectory, "root.tsx")
+      import_pathe3.default.join(appDirectory, "root.tsx")
     );
     return err(
       `Could not find a root route module in the app directory as "${rootRouteDisplayPath}"`
@@ -325,15 +354,15 @@ async function resolveConfig({
   let routeConfigFile = findEntry(appDirectory, "routes");
   try {
     if (!routeConfigFile) {
-      let routeConfigDisplayPath = import_pathe.default.relative(
+      let routeConfigDisplayPath = import_pathe3.default.relative(
         root,
-        import_pathe.default.join(appDirectory, "routes.ts")
+        import_pathe3.default.join(appDirectory, "routes.ts")
       );
       return err(`Route config file not found at "${routeConfigDisplayPath}".`);
     }
     setAppDirectory(appDirectory);
     let routeConfigExport = (await viteNodeContext.runner.executeFile(
-      import_pathe.default.join(appDirectory, routeConfigFile)
+      import_pathe3.default.join(appDirectory, routeConfigFile)
     )).default;
     let routeConfig = await routeConfigExport;
     let result = validateRouteConfig({
@@ -353,7 +382,7 @@ async function resolveConfig({
         import_picocolors.default.red(`Route config in "${routeConfigFile}" is invalid.`),
         "",
         error.loc?.file && error.loc?.column && error.frame ? [
-          import_pathe.default.relative(appDirectory, error.loc.file) + ":" + error.loc.line + ":" + error.loc.column,
+          import_pathe3.default.relative(appDirectory, error.loc.file) + ":" + error.loc.line + ":" + error.loc.column,
           error.frame.trim?.()
         ] : error.stack
       ].flat().join("\n")
@@ -425,8 +454,8 @@ async function createConfigLoader({
         );
         fsWatcher.on("all", async (...args) => {
           let [event, rawFilepath] = args;
-          let filepath = import_pathe.default.normalize(rawFilepath);
-          let appFileAddedOrRemoved = appDirectory && (event === "add" || event === "unlink") && filepath.startsWith(import_pathe.default.normalize(appDirectory));
+          let filepath = import_pathe3.default.normalize(rawFilepath);
+          let appFileAddedOrRemoved = appDirectory && (event === "add" || event === "unlink") && filepath.startsWith(import_pathe3.default.normalize(appDirectory));
           let configCodeUpdated = Boolean(
             viteNodeContext.devServer?.moduleGraph.getModuleById(filepath)
           );
@@ -467,25 +496,16 @@ async function createConfigLoader({
     }
   };
 }
-function isInReactRouterMonorepo() {
-  let serverRuntimePath = import_pathe.default.dirname(
-    require.resolve("@react-router/node/package.json")
-  );
-  let serverRuntimeParentDir = import_pathe.default.basename(
-    import_pathe.default.resolve(serverRuntimePath, "..")
-  );
-  return serverRuntimeParentDir === "packages";
-}
 function findEntry(dir, basename2, options) {
   for (let ext of entryExts) {
-    let file = import_pathe.default.resolve(dir, basename2 + ext);
+    let file = import_pathe3.default.resolve(dir, basename2 + ext);
     if (import_node_fs.default.existsSync(file)) {
-      return options?.absolute ?? false ? file : import_pathe.default.relative(dir, file);
+      return options?.absolute ?? false ? file : import_pathe3.default.relative(dir, file);
     }
   }
   return void 0;
 }
-var import_node_fs, import_node_child_process, import_package_json, import_pathe, import_chokidar, import_picocolors, import_pick2, import_omit, import_cloneDeep, import_isEqual, excludedConfigPresetKeys, branchRouteProperties, configRouteToBranchRoute, mergeReactRouterConfig, deepFreeze, ssrExternals, entryExts;
+var import_node_fs, import_node_child_process, import_package_json, import_pathe3, import_chokidar, import_picocolors, import_pick2, import_omit, import_cloneDeep, import_isEqual, excludedConfigPresetKeys, branchRouteProperties, configRouteToBranchRoute, mergeReactRouterConfig, deepFreeze, ssrExternals, entryExts;
 var init_config = __esm({
   "config/config.ts"() {
     "use strict";
@@ -493,7 +513,7 @@ var init_config = __esm({
     import_node_child_process = require("child_process");
     import_package_json = __toESM(require("@npmcli/package-json"));
     init_vite_node();
-    import_pathe = __toESM(require("pathe"));
+    import_pathe3 = __toESM(require("pathe"));
     import_chokidar = __toESM(require("chokidar"));
     import_picocolors = __toESM(require("picocolors"));
     import_pick2 = __toESM(require("lodash/pick"));
@@ -502,6 +522,7 @@ var init_config = __esm({
     import_isEqual = __toESM(require("lodash/isEqual"));
     init_routes();
     init_detectPackageManager();
+    init_is_react_router_repo();
     excludedConfigPresetKeys = ["presets"];
     branchRouteProperties = [
       "id",
@@ -548,7 +569,7 @@ var init_config = __esm({
       });
       return o;
     };
-    ssrExternals = isInReactRouterMonorepo() ? [
+    ssrExternals = isReactRouterRepo() ? [
       // This is only needed within this repo because these packages
       // are linked to a directory outside of node_modules so Vite
       // treats them as internal code by default.
@@ -565,139 +586,67 @@ var init_config = __esm({
   }
 });
 
-// typegen/paths.ts
-function getTypesDir(ctx) {
-  return Path2.join(ctx.rootDirectory, ".react-router/types");
-}
-function getTypesPath(ctx, route) {
-  return Path2.join(
-    getTypesDir(ctx),
-    Path2.relative(ctx.rootDirectory, ctx.config.appDirectory),
-    Path2.dirname(route.file),
-    "+types/" + Pathe.filename(route.file) + ".ts"
-  );
-}
-var Path2, Pathe;
-var init_paths = __esm({
-  "typegen/paths.ts"() {
-    "use strict";
-    Path2 = __toESM(require("pathe"));
-    Pathe = __toESM(require("pathe/utils"));
-  }
-});
-
 // typegen/generate.ts
-function generate(ctx, route) {
-  const lineage = getRouteLineage(ctx.config.routes, route);
-  const urlpath = lineage.map((route2) => route2.path).join("/");
-  const typesPath = getTypesPath(ctx, route);
-  const parents = lineage.slice(0, -1);
-  const parentTypeImports = parents.map((parent, i) => {
-    const rel = Path3.relative(
-      Path3.dirname(typesPath),
-      getTypesPath(ctx, parent)
-    );
-    const indent = i === 0 ? "" : "  ".repeat(2);
-    let source = noExtension(rel);
-    if (!source.startsWith("../")) source = "./" + source;
-    return `${indent}import type { Info as Parent${i} } from "${source}.js"`;
-  }).join("\n");
+function generate(route) {
   return import_dedent.default`
     // React Router generated types for route:
     // ${route.file}
 
-    import type * as T from "react-router/route-module"
-
-    ${parentTypeImports}
+    import type { RouteExports, Routes } from "react-router/types";
 
-    type Module = typeof import("../${Pathe2.filename(route.file)}.js")
+    type RouteId = "${route.id}"
+    export type Info = Routes[RouteId];
 
-    export type Info = {
-      parents: [${parents.map((_, i) => `Parent${i}`).join(", ")}],
-      id: "${route.id}"
-      file: "${route.file}"
-      path: "${route.path}"
-      params: {${formatParamProperties(
-    urlpath
-  )}} & { [key: string]: string | undefined }
-      module: Module
-      loaderData: T.CreateLoaderData<Module>
-      actionData: T.CreateActionData<Module>
-    }
+    type Exports = RouteExports[RouteId];
 
     export namespace Route {
-      export type LinkDescriptors = T.LinkDescriptors
-      export type LinksFunction = () => LinkDescriptors
+      export type LinkDescriptors = Exports["links"]["return"];
+      export type LinksFunction = () => LinkDescriptors;
 
-      export type MetaArgs = T.CreateMetaArgs<Info>
-      export type MetaDescriptors = T.MetaDescriptors
-      export type MetaFunction = (args: MetaArgs) => MetaDescriptors
+      export type MetaArgs = Exports["meta"]["args"];
+      export type MetaDescriptors = Exports["meta"]["return"];
+      export type MetaFunction = (args: MetaArgs) => MetaDescriptors;
 
-      export type HeadersArgs = T.HeadersArgs
-      export type HeadersFunction = (args: HeadersArgs) => Headers | HeadersInit
+      export type HeadersArgs = Exports["headers"]["args"];
+      export type HeadersFunction = (args: HeadersArgs) => Headers | HeadersInit;
 
-      export type MiddlewareArgs = T.CreateServerMiddlewareArgs<Info>
-      export type ClientMiddlewareArgs = T.CreateClientMiddlewareArgs<Info>
-      export type LoaderArgs = T.CreateServerLoaderArgs<Info>
-      export type ClientLoaderArgs = T.CreateClientLoaderArgs<Info>
-      export type ActionArgs = T.CreateServerActionArgs<Info>
-      export type ClientActionArgs = T.CreateClientActionArgs<Info>
+      export type LoaderArgs = Exports["loader"]["args"];
+      export type ClientLoaderArgs = Exports["clientLoader"]["args"];
+      export type ActionArgs = Exports["action"]["args"];
+      export type ClientActionArgs = Exports["clientAction"]["args"];
 
-      export type HydrateFallbackProps = T.CreateHydrateFallbackProps<Info>
-      export type ComponentProps = T.CreateComponentProps<Info>
-      export type ErrorBoundaryProps = T.CreateErrorBoundaryProps<Info>
+      export type HydrateFallbackProps = Exports["HydrateFallback"]["args"];
+      export type ComponentProps = Exports["default"]["args"];
+      export type ErrorBoundaryProps = Exports["ErrorBoundary"]["args"];
     }
   `;
 }
-function getRouteLineage(routes2, route) {
-  const result = [];
-  while (route) {
-    result.push(route);
-    if (!route.parentId) break;
-    route = routes2[route.parentId];
-  }
-  result.reverse();
-  return result;
-}
-function formatParamProperties(urlpath) {
-  const params = parseParams(urlpath);
-  const properties = Object.entries(params).map(([name, values]) => {
-    if (values.length === 1) {
-      const isOptional = values[0];
-      return isOptional ? `"${name}"?: string` : `"${name}": string`;
-    }
-    const items = values.map(
-      (isOptional) => isOptional ? "string | undefined" : "string"
-    );
-    return `"${name}": [${items.join(", ")}]`;
-  });
-  return properties.join("; ");
-}
-function parseParams(urlpath) {
-  const result = {};
-  let segments = urlpath.split("/");
-  segments.forEach((segment) => {
-    const match = segment.match(/^:([\w-]+)(\?)?/);
-    if (!match) return;
-    const param = match[1];
-    const isOptional = match[2] !== void 0;
-    result[param] ??= [];
-    result[param].push(isOptional);
-    return;
-  });
-  const hasSplat = segments.at(-1) === "*";
-  if (hasSplat) result["*"] = [false];
-  return result;
-}
-var import_dedent, Path3, Pathe2, noExtension;
+var import_dedent;
 var init_generate = __esm({
   "typegen/generate.ts"() {
     "use strict";
     import_dedent = __toESM(require("dedent"));
-    Path3 = __toESM(require("pathe"));
-    Pathe2 = __toESM(require("pathe/utils"));
-    init_paths();
-    noExtension = (path8) => Path3.join(Path3.dirname(path8), Pathe2.filename(path8));
+  }
+});
+
+// typegen/paths.ts
+function getTypesDir(ctx) {
+  return Path2.join(ctx.rootDirectory, ".react-router/types");
+}
+function getTypesPath(ctx, route) {
+  return Path2.join(
+    getTypesDir(ctx),
+    Path2.relative(ctx.rootDirectory, ctx.config.appDirectory),
+    Path2.dirname(route.file),
+    "+types/" + Pathe.filename(route.file) + ".ts"
+  );
+}
+var Path2, Pathe;
+var init_paths = __esm({
+  "typegen/paths.ts"() {
+    "use strict";
+    Path2 = __toESM(require("pathe"));
+    Pathe = __toESM(require("pathe/utils"));
   }
 });
 
@@ -744,22 +693,100 @@ async function createContext2({
     config
   };
 }
+function asJS(path10) {
+  return path10.replace(/\.(js|ts)x?$/, ".js");
+}
+function formatRoute({ id, path: path10, file, parentId }) {
+  return [
+    `"${id}": {`,
+    `  parentId: ${JSON.stringify(parentId)}`,
+    `  path: ${JSON.stringify(path10)}`,
+    `  module: typeof import("./app/${asJS(file)}")`,
+    `}`
+  ].map((line) => `  ${line}`).join("\n");
+}
 async function writeAll(ctx) {
+  let routes2 = Object.values(ctx.config.routes);
+  let pathsToParams = /* @__PURE__ */ new Map();
+  for (let route of routes2) {
+    if (route.path === void 0) continue;
+    let lineage = getRouteLineage(ctx.config.routes, route);
+    let path10 = lineage.filter((route2) => route2.path !== void 0).map((route2) => route2.path).join("/");
+    if (path10 === "") path10 = "/";
+    pathsToParams.set(path10, parseParams(path10));
+  }
+  let formattedPaths = `type Paths = {`;
+  for (let [path10, params] of pathsToParams.entries()) {
+    let formattedParams = Object.entries(params).map(
+      ([param, required]) => `"${param}"${required ? "" : "?"}: string`
+    );
+    let formattedEntry = `"${path10}": {${formattedParams.join(",")}},
+`;
+    formattedPaths += formattedEntry;
+  }
+  formattedPaths += `}`;
   const typegenDir = getTypesDir(ctx);
   import_node_fs2.default.rmSync(typegenDir, { recursive: true, force: true });
+  const newTypes = Path3.join(typegenDir, "routes.ts");
+  import_node_fs2.default.mkdirSync(Path3.dirname(newTypes), { recursive: true });
+  import_node_fs2.default.writeFileSync(
+    newTypes,
+    formattedPaths + `
+
+type Routes = {
+${routes2.map(formatRoute).join("\n")}
+}
+
+` + import_dedent2.default`
+        declare module "react-router/types" {
+          interface Register {
+            paths: Paths
+            routes: Routes
+          }
+        }
+
+        export {}
+    `
+  );
   Object.values(ctx.config.routes).forEach((route) => {
     const typesPath = getTypesPath(ctx, route);
-    const content = generate(ctx, route);
-    import_node_fs2.default.mkdirSync(Path4.dirname(typesPath), { recursive: true });
+    const content = generate(route);
+    import_node_fs2.default.mkdirSync(Path3.dirname(typesPath), { recursive: true });
     import_node_fs2.default.writeFileSync(typesPath, content);
   });
 }
-var import_node_fs2, Path4, import_picocolors2;
+function getRouteLineage(routes2, route) {
+  const result = [];
+  while (route) {
+    result.push(route);
+    if (!route.parentId) break;
+    route = routes2[route.parentId];
+  }
+  result.reverse();
+  return result;
+}
+function parseParams(urlpath) {
+  const result = {};
+  let segments = urlpath.split("/");
+  segments.forEach((segment) => {
+    const match = segment.match(/^:([\w-]+)(\?)?/);
+    if (!match) return;
+    const param = match[1];
+    const isRequired = match[2] === void 0;
+    result[param] ||= isRequired;
+    return;
+  });
+  const hasSplat = segments.at(-1) === "*";
+  if (hasSplat) result["*"] = true;
+  return result;
+}
+var import_node_fs2, import_dedent2, Path3, import_picocolors2;
 var init_typegen = __esm({
   "typegen/index.ts"() {
     "use strict";
     import_node_fs2 = __toESM(require("fs"));
-    Path4 = __toESM(require("pathe"));
+    import_dedent2 = __toESM(require("dedent"));
+    Path3 = __toESM(require("pathe"));
     import_picocolors2 = __toESM(require("picocolors"));
     init_config();
     init_generate();
@@ -793,34 +820,41 @@ var init_node_adapter = __esm({
 });
 
 // vite/resolve-file-url.ts
-var path2;
+var path4;
 var init_resolve_file_url = __esm({
   "vite/resolve-file-url.ts"() {
     "use strict";
-    path2 = __toESM(require("path"));
-    init_import_vite_esm_sync();
+    path4 = __toESM(require("path"));
+    init_vite();
   }
 });
 
 // vite/styles.ts
-var path3, import_react_router, cssFileRegExp, cssModulesRegExp;
+var path5, import_react_router, cssFileRegExp, cssModulesRegExp;
 var init_styles = __esm({
   "vite/styles.ts"() {
     "use strict";
-    path3 = __toESM(require("path"));
+    path5 = __toESM(require("path"));
     import_react_router = require("react-router");
     init_resolve_file_url();
+    init_vite();
     cssFileRegExp = /\.(css|less|sass|scss|styl|stylus|pcss|postcss|sss)(?:$|\?)/;
     cssModulesRegExp = new RegExp(`\\.module${cssFileRegExp.source}`);
   }
 });
 
-// vite/vmod.ts
-var id;
-var init_vmod = __esm({
-  "vite/vmod.ts"() {
+// vite/virtual-module.ts
+function create(name) {
+  let id = `virtual:react-router/${name}`;
+  return {
+    id,
+    resolvedId: `\0${id}`,
+    url: `/@id/__x00__${id}`
+  };
+}
+var init_virtual_module = __esm({
+  "vite/virtual-module.ts"() {
     "use strict";
-    id = (name) => `virtual:react-router/${name}`;
   }
 });
 
@@ -842,14 +876,14 @@ var init_remove_exports = __esm({
 });
 
 // vite/with-props.ts
-var import_dedent2, vmodId;
+var import_dedent3, vmod;
 var init_with_props = __esm({
   "vite/with-props.ts"() {
     "use strict";
-    import_dedent2 = __toESM(require("dedent"));
+    import_dedent3 = __toESM(require("dedent"));
     init_babel();
-    init_vmod();
-    vmodId = id("with-props");
+    init_virtual_module();
+    vmod = create("with-props");
   }
 });
 
@@ -859,7 +893,7 @@ async function resolveViteConfig({
   mode,
   root
 }) {
-  let vite2 = await import("vite");
+  let vite2 = getVite();
   let viteConfig = await vite2.resolveConfig(
     { mode, configFile, root },
     "build",
@@ -909,17 +943,17 @@ async function loadPluginContext({
 function findConfig(dir, basename2, extensions) {
   for (let ext of extensions) {
     let name = basename2 + ext;
-    let file = path4.join(dir, name);
+    let file = path6.join(dir, name);
     if (fse.existsSync(file)) return file;
   }
   return void 0;
 }
-var import_node_crypto, path4, url, fse, babel, import_react_router2, import_es_module_lexer, import_jsesc, import_picocolors3, serverBuildId, serverManifestId, browserManifestId, hmrRuntimeId, injectHmrRuntimeId, getServerBuildDirectory, defaultEntriesDir, defaultEntries, REACT_REFRESH_HEADER, REACT_REFRESH_FOOTER;
+var import_node_crypto, path6, url, fse, babel, import_react_router2, import_es_module_lexer, import_jsesc, import_picocolors3, virtualHmrRuntime, virtualInjectHmrRuntime, virtual, getServerBuildDirectory, defaultEntriesDir, defaultEntries, REACT_REFRESH_HEADER;
 var init_plugin = __esm({
   "vite/plugin.ts"() {
     "use strict";
     import_node_crypto = require("crypto");
-    path4 = __toESM(require("path"));
+    path6 = __toESM(require("path"));
     url = __toESM(require("url"));
     fse = __toESM(require("fs-extra"));
     babel = __toESM(require("@babel/core"));
@@ -932,33 +966,35 @@ var init_plugin = __esm({
     init_babel();
     init_node_adapter();
     init_styles();
-    init_vmod();
+    init_virtual_module();
     init_resolve_file_url();
     init_combine_urls();
     init_remove_exports();
-    init_import_vite_esm_sync();
+    init_vite();
     init_config();
     init_with_props();
-    serverBuildId = id("server-build");
-    serverManifestId = id("server-manifest");
-    browserManifestId = id("browser-manifest");
-    hmrRuntimeId = id("hmr-runtime");
-    injectHmrRuntimeId = id("inject-hmr-runtime");
-    getServerBuildDirectory = (ctx) => path4.join(
+    virtualHmrRuntime = create("hmr-runtime");
+    virtualInjectHmrRuntime = create("inject-hmr-runtime");
+    virtual = {
+      serverBuild: create("server-build"),
+      serverManifest: create("server-manifest"),
+      browserManifest: create("browser-manifest")
+    };
+    getServerBuildDirectory = (ctx) => path6.join(
       ctx.reactRouterConfig.buildDirectory,
       "server",
       ...ctx.serverBundleBuildConfig ? [ctx.serverBundleBuildConfig.serverBundleId] : []
     );
-    defaultEntriesDir = path4.resolve(
-      path4.dirname(require.resolve("@react-router/dev/package.json")),
+    defaultEntriesDir = path6.resolve(
+      path6.dirname(require.resolve("@react-router/dev/package.json")),
       "dist",
       "config",
       "defaults"
     );
-    defaultEntries = fse.readdirSync(defaultEntriesDir).map((filename3) => path4.join(defaultEntriesDir, filename3));
+    defaultEntries = fse.readdirSync(defaultEntriesDir).map((filename2) => path6.join(defaultEntriesDir, filename2));
     invariant(defaultEntries.length > 0, "No default entries found");
     REACT_REFRESH_HEADER = `
-import RefreshRuntime from "${hmrRuntimeId}";
+import RefreshRuntime from "${virtualHmrRuntime.id}";
 
 const inWebWorker = typeof WorkerGlobalScope !== 'undefined' && self instanceof WorkerGlobalScope;
 let prevRefreshReg;
@@ -977,21 +1013,7 @@ if (import.meta.hot && !inWebWorker) {
     RefreshRuntime.register(type, __SOURCE__ + " " + id)
   };
   window.$RefreshSig$ = RefreshRuntime.createSignatureFunctionForTransform;
-}`.trim();
-    REACT_REFRESH_FOOTER = `
-if (import.meta.hot && !inWebWorker) {
-  window.$RefreshReg$ = prevRefreshReg;
-  window.$RefreshSig$ = prevRefreshSig;
-  RefreshRuntime.__hmr_import(import.meta.url).then((currentExports) => {
-    RefreshRuntime.registerExportsForReactRefresh(__SOURCE__, currentExports);
-    import.meta.hot.accept((nextExports) => {
-      if (!nextExports) return;
-      __ROUTE_ID__ && window.__reactRouterRouteModuleUpdates.set(__ROUTE_ID__, nextExports);
-      const invalidateMessage = RefreshRuntime.validateRefreshBoundaryAndEnqueueUpdate(currentExports, nextExports, __ACCEPT_EXPORTS__);
-      if (invalidateMessage) import.meta.hot.invalidate(invalidateMessage);
-    });
-  });
-}`.trim();
+}`.replaceAll("\n", "");
   }
 });
 
@@ -1041,8 +1063,8 @@ __export(build_exports, {
 });
 function getAddressableRoutes(routes2) {
   let nonAddressableIds = /* @__PURE__ */ new Set();
-  for (let id2 in routes2) {
-    let route = routes2[id2];
+  for (let id in routes2) {
+    let route = routes2[id];
     if (route.index) {
       invariant(
         route.parentId,
@@ -1051,7 +1073,7 @@ function getAddressableRoutes(routes2) {
       nonAddressableIds.add(route.parentId);
     }
     if (typeof route.path !== "string" && !route.index) {
-      nonAddressableIds.add(id2);
+      nonAddressableIds.add(id);
     }
   }
   return Object.values(routes2).filter(
@@ -1082,12 +1104,12 @@ async function getServerBuilds(ctx) {
   let { normalizePath } = await import("vite");
   let resolvedAppDirectory = import_node_path2.default.resolve(rootDirectory, appDirectory);
   let rootRelativeRoutes = Object.fromEntries(
-    Object.entries(routes2).map(([id2, route]) => {
+    Object.entries(routes2).map(([id, route]) => {
       let filePath = import_node_path2.default.join(resolvedAppDirectory, route.file);
       let rootRelativeFilePath = normalizePath(
         import_node_path2.default.relative(rootDirectory, filePath)
       );
-      return [id2, { ...route, file: rootRelativeFilePath }];
+      return [id, { ...route, file: rootRelativeFilePath }];
     })
   );
   let buildManifest = {
@@ -1188,7 +1210,7 @@ async function build(root, {
   sourcemapClient,
   sourcemapServer
 }) {
-  await preloadViteEsm();
+  await preloadVite();
   let viteConfig = await resolveViteConfig({ configFile, mode, root });
   const ctx = await extractPluginContext(viteConfig);
   if (!ctx) {
@@ -1198,7 +1220,7 @@ async function build(root, {
     process.exit(1);
   }
   let { reactRouterConfig } = ctx;
-  let vite2 = await import("vite");
+  let vite2 = getVite();
   async function viteBuild({
     ssr,
     serverBundleBuildConfig
@@ -1255,7 +1277,7 @@ var init_build = __esm({
     init_plugin();
     init_config();
     init_invariant();
-    init_import_vite_esm_sync();
+    init_vite();
   }
 });
 
@@ -1276,8 +1298,8 @@ async function dev(root, {
   port,
   strictPort
 }) {
-  await preloadViteEsm();
-  let vite2 = await import("vite");
+  await preloadVite();
+  let vite2 = getVite();
   let server = await vite2.createServer({
     root,
     mode,
@@ -1317,7 +1339,7 @@ var init_dev = __esm({
   "vite/dev.ts"() {
     "use strict";
     import_picocolors6 = __toESM(require("picocolors"));
-    init_import_vite_esm_sync();
+    init_vite();
     init_profiler();
   }
 });
@@ -1328,7 +1350,7 @@ var import_semver = __toESM(require("semver"));
 var import_picocolors8 = __toESM(require("picocolors"));
 
 // cli/commands.ts
-var path7 = __toESM(require("path"));
+var path9 = __toESM(require("path"));
 var import_fs_extra2 = __toESM(require("fs-extra"));
 var import_package_json2 = __toESM(require("@npmcli/package-json"));
 var import_exit_hook = __toESM(require("exit-hook"));
@@ -1414,7 +1436,7 @@ function transpile(tsx, options = {}) {
 // cli/commands.ts
 init_profiler();
 init_typegen();
-init_import_vite_esm_sync();
+init_vite();
 async function routes(reactRouterRoot, flags = {}) {
   let ctx = await loadPluginContext({
     root: reactRouterRoot,
@@ -1486,14 +1508,14 @@ async function generateEntry(entry, reactRouterRoot, flags = {}) {
     console.error(import_picocolors7.default.red(`No default server entry detected.`));
     return;
   }
-  let defaultsDirectory = path7.resolve(
-    path7.dirname(require.resolve("@react-router/dev/package.json")),
+  let defaultsDirectory = path9.resolve(
+    path9.dirname(require.resolve("@react-router/dev/package.json")),
     "dist",
     "config",
     "defaults"
   );
-  let defaultEntryClient = path7.resolve(defaultsDirectory, "entry.client.tsx");
-  let defaultEntryServer = path7.resolve(
+  let defaultEntryClient = path9.resolve(defaultsDirectory, "entry.client.tsx");
+  let defaultEntryServer = path9.resolve(
     defaultsDirectory,
     `entry.server.node.tsx`
   );
@@ -1502,7 +1524,7 @@ async function generateEntry(entry, reactRouterRoot, flags = {}) {
   let useTypeScript = flags.typescript ?? true;
   let outputExtension = useTypeScript ? "tsx" : "jsx";
   let outputEntry = `${entry}.${outputExtension}`;
-  let outputFile2 = path7.resolve(appDirectory, outputEntry);
+  let outputFile2 = path9.resolve(appDirectory, outputEntry);
   if (!useTypeScript) {
     let javascript = transpile(contents, {
       cwd: rootDirectory,
@@ -1514,7 +1536,7 @@ async function generateEntry(entry, reactRouterRoot, flags = {}) {
   }
   console.log(
     import_picocolors7.default.blue(
-      `Entry file ${entry} created at ${path7.relative(
+      `Entry file ${entry} created at ${path9.relative(
         rootDirectory,
         outputFile2
       )}.`
@@ -1523,11 +1545,11 @@ async function generateEntry(entry, reactRouterRoot, flags = {}) {
 }
 async function checkForEntry(rootDirectory, appDirectory, entries2) {
   for (let entry of entries2) {
-    let entryPath = path7.resolve(appDirectory, entry);
+    let entryPath = path9.resolve(appDirectory, entry);
     let exists = await import_fs_extra2.default.pathExists(entryPath);
     if (exists) {
-      let relative8 = path7.relative(rootDirectory, entryPath);
-      console.error(import_picocolors7.default.red(`Entry file ${relative8} already exists.`));
+      let relative7 = path9.relative(rootDirectory, entryPath);
+      console.error(import_picocolors7.default.red(`Entry file ${relative7} already exists.`));
       return process.exit(1);
     }
   }
@@ -1545,8 +1567,8 @@ async function createClientEntry(rootDirectory, appDirectory, inputFile) {
 async function typegen(root, flags) {
   root ??= process.cwd();
   if (flags.watch) {
-    await preloadViteEsm();
-    const vite2 = importViteEsmSync();
+    await preloadVite();
+    const vite2 = getVite();
     const logger = vite2.createLogger("info", { prefix: "[react-router]" });
     await watch(root, { logger });
     await new Promise(() => {