@tanstack/start-plugin-core 1.20.3-alpha.1

package/dist/esm/start-server-routes-plugin/plugin.js

@@ -0,0 +1,608 @@
+import path, { normalize, join, isAbsolute } from "node:path";
+import fs from "node:fs";
+import fsp from "node:fs/promises";
+import { logging, virtualGetRouteNodes, physicalGetRouteNodes, rootPathId, multiSortBy, writeIfDifferent, format, removeExt, resetRegex, trimPathLeft, removeUnderscores, routePathToVariable, replaceBackslash } from "@tanstack/router-generator";
+import { rootRouteId } from "@tanstack/router-core";
+import { getTargetTemplate, fillTemplate } from "./template.js";
+let lock = false;
+const checkLock = () => lock;
+const setLock = (bool) => {
+  lock = bool;
+};
+function TanStackStartServerRoutesVite(config) {
+  let ROOT = process.cwd();
+  const getRoutesDirectoryPath = () => {
+    return isAbsolute(config.routesDirectory) ? config.routesDirectory : join(ROOT, config.routesDirectory);
+  };
+  const generate = async () => {
+    if (checkLock()) {
+      return;
+    }
+    setLock(true);
+    try {
+      await generator(config, ROOT);
+    } catch (err) {
+      console.error(err);
+      console.info();
+    } finally {
+      setLock(false);
+    }
+  };
+  const handleFile = async (file) => {
+    const filePath = normalize(file);
+    const routesDirectoryPath = getRoutesDirectoryPath();
+    if (filePath.startsWith(routesDirectoryPath)) {
+      await generate();
+    }
+  };
+  return {
+    name: "tanstack-start-server-routes-plugin",
+    configureServer(server) {
+      server.watcher.on("all", (event, path2) => {
+        handleFile(path2);
+      });
+    },
+    configResolved(config2) {
+      ROOT = config2.root;
+    },
+    async buildStart() {
+      await generate();
+    },
+    sharedDuringBuild: true,
+    resolveId(id) {
+      if (id === "tanstack:server-routes") {
+        const generatedRouteTreePath = getGeneratedRouteTreePath(ROOT);
+        return generatedRouteTreePath;
+      }
+      return null;
+    }
+  };
+}
+let latestTask = 0;
+const routeGroupPatternRegex = /\(.+\)/g;
+const possiblyNestedRouteGroupPatternRegex = /\([^/]+\)\/?/g;
+function getGeneratedRouteTreePath(root) {
+  return path.resolve(root, ".tanstack-start/server-routes/routeTree.gen.ts");
+}
+async function generator(config, root) {
+  const generatedServerRouteTreePath = getGeneratedRouteTreePath(root);
+  const ROUTE_TEMPLATE = getTargetTemplate(config.target);
+  const logger = logging({ disabled: config.disableLogging });
+  const taskId = latestTask + 1;
+  latestTask = taskId;
+  const checkLatest = () => {
+    if (latestTask !== taskId) {
+      return false;
+    }
+    return true;
+  };
+  let getRouteNodesResult;
+  if (config.virtualRouteConfig) {
+    getRouteNodesResult = await virtualGetRouteNodes(config, root);
+  } else {
+    getRouteNodesResult = await physicalGetRouteNodes(config, root);
+  }
+  const { rootRouteNode, routeNodes: beforeRouteNodes } = getRouteNodesResult;
+  if (rootRouteNode === void 0) {
+    let errorMessage = `rootRouteNode must not be undefined. Make sure you've added your root route into the route-tree.`;
+    if (!config.virtualRouteConfig) {
+      errorMessage += `
+Make sure that you add a "${rootPathId}.tsx" file to your routes directory.
+Add the file in: "${config.routesDirectory}/${rootPathId}.tsx"`;
+    }
+    throw new Error(errorMessage);
+  }
+  const preRouteNodes = multiSortBy(beforeRouteNodes, [
+    (d) => d.routePath === "/" ? -1 : 1,
+    (d) => {
+      var _a;
+      return (_a = d.routePath) == null ? void 0 : _a.split("/").length;
+    },
+    (d) => d.filePath.match(new RegExp(`[./]${config.indexToken}[.]`)) ? 1 : -1,
+    (d) => d.filePath.match(
+      /[./](component|errorComponent|pendingComponent|loader|lazy)[.]/
+    ) ? 1 : -1,
+    (d) => d.filePath.match(new RegExp(`[./]${config.routeToken}[.]`)) ? -1 : 1,
+    (d) => {
+      var _a;
+      return ((_a = d.routePath) == null ? void 0 : _a.endsWith("/")) ? -1 : 1;
+    },
+    (d) => d.routePath
+  ]).filter((d) => ![`/${rootPathId}`].includes(d.routePath || ""));
+  const routeTree = [];
+  const routeNodes = [];
+  const handleRootNode = async (node) => {
+    if (!node) {
+      return;
+    }
+    const routeCode = fs.readFileSync(node.fullPath, "utf-8");
+    if (!routeCode) {
+      const _rootTemplate = ROUTE_TEMPLATE.rootRoute;
+      const replaced = await fillTemplate(config, _rootTemplate.template(), {
+        tsrImports: _rootTemplate.imports.tsrImports(),
+        tsrPath: rootPathId,
+        tsrExportStart: _rootTemplate.imports.tsrExportStart(),
+        tsrExportEnd: _rootTemplate.imports.tsrExportEnd()
+      });
+      await writeIfDifferent(
+        node.fullPath,
+        "",
+        // Empty string because the file doesn't exist yet
+        replaced,
+        {
+          beforeWrite: () => {
+          }
+        }
+      );
+    }
+  };
+  await handleRootNode(rootRouteNode);
+  const handleNode = async (node) => {
+    var _a;
+    resetRegex(routeGroupPatternRegex);
+    let parentRoute = hasParentRoute(routeNodes, node, node.routePath);
+    if ((parentRoute == null ? void 0 : parentRoute.isVirtualParentRoute) && ((_a = parentRoute.children) == null ? void 0 : _a.length)) {
+      const possibleParentRoute = hasParentRoute(
+        parentRoute.children,
+        node,
+        node.routePath
+      );
+      if (possibleParentRoute) {
+        parentRoute = possibleParentRoute;
+      }
+    }
+    if (parentRoute) node.parent = parentRoute;
+    node.path = determineNodePath(node);
+    const trimmedPath = trimPathLeft(node.path ?? "");
+    const split = trimmedPath.split("/");
+    const lastRouteSegment = split[split.length - 1] ?? trimmedPath;
+    node.isNonPath = lastRouteSegment.startsWith("_") || routeGroupPatternRegex.test(lastRouteSegment);
+    node.cleanedPath = removeGroups(
+      removeUnderscores(removeLayoutSegments(node.path)) ?? ""
+    );
+    const routeCode = fs.readFileSync(node.fullPath, "utf-8");
+    if (!node.isVirtualParentRoute && !node.isVirtual) ;
+    const cleanedPathIsEmpty = (node.cleanedPath || "").length === 0;
+    const nonPathRoute = node._fsRouteType === "pathless_layout" && node.isNonPath;
+    node.isVirtualParentRequired = node._fsRouteType === "pathless_layout" || nonPathRoute ? !cleanedPathIsEmpty : false;
+    if (!node.isVirtual && node.isVirtualParentRequired) {
+      const parentRoutePath = removeLastSegmentFromPath(node.routePath) || "/";
+      const parentVariableName = routePathToVariable(parentRoutePath);
+      const anchorRoute = routeNodes.find(
+        (d) => d.routePath === parentRoutePath
+      );
+      if (!anchorRoute) {
+        const parentNode = {
+          ...node,
+          path: removeLastSegmentFromPath(node.path) || "/",
+          filePath: removeLastSegmentFromPath(node.filePath) || "/",
+          fullPath: removeLastSegmentFromPath(node.fullPath) || "/",
+          routePath: parentRoutePath,
+          variableName: parentVariableName,
+          isVirtual: true,
+          _fsRouteType: "layout",
+          // layout since this route will wrap other routes
+          isVirtualParentRoute: true,
+          isVirtualParentRequired: false
+        };
+        parentNode.children = parentNode.children ?? [];
+        parentNode.children.push(node);
+        node.parent = parentNode;
+        if (node._fsRouteType === "pathless_layout") {
+          node.path = determineNodePath(node);
+        }
+        await handleNode(parentNode);
+      } else {
+        anchorRoute.children = anchorRoute.children ?? [];
+        anchorRoute.children.push(node);
+        node.parent = anchorRoute;
+      }
+    }
+    if (!routeCode.split("\n").some((line) => line.trim().startsWith("export const ServerRoute"))) {
+      return;
+    }
+    if (node.parent) {
+      if (!node.isVirtualParentRequired) {
+        node.parent.children = node.parent.children ?? [];
+        node.parent.children.push(node);
+      }
+    } else {
+      routeTree.push(node);
+    }
+    routeNodes.push(node);
+  };
+  for (const node of preRouteNodes) {
+    await handleNode(node);
+  }
+  checkRouteFullPathUniqueness(routeNodes, config);
+  function buildRouteTreeConfig(nodes, depth = 1) {
+    const children = nodes.map((node) => {
+      var _a, _b;
+      if (node._fsRouteType === "__root") {
+        return;
+      }
+      if (node._fsRouteType === "pathless_layout" && !((_a = node.children) == null ? void 0 : _a.length)) {
+        return;
+      }
+      const route = `${node.variableName}Route`;
+      if ((_b = node.children) == null ? void 0 : _b.length) {
+        const childConfigs = buildRouteTreeConfig(node.children, depth + 1);
+        const childrenDeclaration = `interface ${route}Children {
+  ${node.children.map((child) => `${child.variableName}Route: typeof ${getResolvedRouteNodeVariableName(child)}`).join(",")}
+}`;
+        const children2 = `const ${route}Children: ${route}Children = {
+  ${node.children.map((child) => `${child.variableName}Route: ${getResolvedRouteNodeVariableName(child)}`).join(",")}
+}`;
+        const routeWithChildren = `const ${route}WithChildren = ${route}._addFileChildren(${route}Children)`;
+        return [
+          childConfigs,
+          childrenDeclaration,
+          children2,
+          routeWithChildren
+        ].join("\n\n");
+      }
+      return void 0;
+    });
+    return children.filter(Boolean).join("\n\n");
+  }
+  const routeConfigChildrenText = buildRouteTreeConfig(routeTree);
+  const sortedRouteNodes = multiSortBy(routeNodes, [
+    (d) => {
+      var _a;
+      return ((_a = d.routePath) == null ? void 0 : _a.includes(`/${rootPathId}`)) ? -1 : 1;
+    },
+    (d) => {
+      var _a;
+      return (_a = d.routePath) == null ? void 0 : _a.split("/").length;
+    },
+    (d) => {
+      var _a;
+      return ((_a = d.routePath) == null ? void 0 : _a.endsWith(config.indexToken)) ? -1 : 1;
+    },
+    (d) => d
+  ]);
+  const imports = Object.entries({
+    createFileRoute: sortedRouteNodes.some((d) => d.isVirtual)
+  }).filter((d) => d[1]).map((d) => d[0]);
+  const virtualRouteNodes = sortedRouteNodes.filter((d) => d.isVirtual);
+  function getImportPath(node) {
+    return replaceBackslash(
+      removeExt(
+        path.relative(
+          path.dirname(generatedServerRouteTreePath),
+          path.resolve(config.routesDirectory, node.filePath)
+        )
+      )
+    );
+  }
+  const rootRouteExists = fs.existsSync(rootRouteNode.fullPath);
+  const rootRouteCode = rootRouteExists ? fs.readFileSync(rootRouteNode.fullPath, "utf-8") : "";
+  const hasServerRootRoute = rootRouteExists && rootRouteCode.includes("export const ServerRoute");
+  const routeImports = [
+    ...config.routeTreeFileHeader,
+    `// This file was automatically generated by TanStack Router.
+// You should NOT make any changes in this file as it will be overwritten.
+// Additionally, you should also exclude this file from your linter and/or formatter to prevent it from being checked or modified.`,
+    imports.length ? `import { ${imports.join(", ")} } from '${ROUTE_TEMPLATE.fullPkg}'
+` : "",
+    "// Import Routes",
+    [
+      `import type { FileRoutesByPath, CreateServerFileRoute } from '${ROUTE_TEMPLATE.fullPkg}'`,
+      `import { createServerRoute, createServerFileRoute } from '${ROUTE_TEMPLATE.fullPkg}'`,
+      hasServerRootRoute ? `import { ServerRoute as rootRouteImport } from './${getImportPath(rootRouteNode)}'` : "",
+      ...sortedRouteNodes.filter((d) => !d.isVirtual).map((node) => {
+        return `import { ServerRoute as ${node.variableName}RouteImport } from './${getImportPath(node)}'`;
+      })
+    ].join("\n"),
+    virtualRouteNodes.length ? "// Create Virtual Routes" : "",
+    virtualRouteNodes.map((node) => {
+      return `const ${node.variableName}RouteImport = createFileRoute('${node.routePath}')()`;
+    }).join("\n"),
+    "// Create/Update Routes",
+    !hasServerRootRoute ? `
+      const rootRoute = createServerRoute()
+    ` : "",
+    sortedRouteNodes.map((node) => {
+      var _a;
+      return [
+        [
+          `const ${node.variableName}Route = ${node.variableName}RouteImport.update({
+          ${[
+            `id: '${node.path}'`,
+            !node.isNonPath ? `path: '${node.cleanedPath}'` : void 0,
+            `getParentRoute: () => ${((_a = node.parent) == null ? void 0 : _a.variableName) ?? "root"}Route`
+          ].filter(Boolean).join(",")}
+        } as any)`
+        ].join("")
+      ].join("\n\n");
+    }).join("\n\n"),
+    "",
+    "// Populate the FileRoutesByPath interface",
+    `declare module '${ROUTE_TEMPLATE.fullPkg}' {
+  interface FileRoutesByPath {
+    ${routeNodes.map((routeNode) => {
+      var _a, _b;
+      const filePathId = routeNode.routePath;
+      return `'${filePathId}': {
+          id: '${filePathId}'
+          path: '${inferPath(routeNode)}'
+          fullPath: '${inferFullPath(routeNode)}'
+          preLoaderRoute: typeof ${routeNode.variableName}RouteImport
+          parentRoute: typeof ${routeNode.isVirtualParentRequired ? `${(_a = routeNode.parent) == null ? void 0 : _a.variableName}Route` : ((_b = routeNode.parent) == null ? void 0 : _b.variableName) ? `${routeNode.parent.variableName}RouteImport` : "rootRoute"}
+        }`;
+    }).join("\n")}
+  }
+}`,
+    `// Add type-safety to the createFileRoute function across the route tree`,
+    routeNodes.map((routeNode) => {
+      var _a;
+      return `declare module './${getImportPath(routeNode)}' {
+const createServerFileRoute: CreateServerFileRoute<
+FileRoutesByPath['${routeNode.routePath}']['parentRoute'],
+FileRoutesByPath['${routeNode.routePath}']['id'],
+FileRoutesByPath['${routeNode.routePath}']['path'],
+FileRoutesByPath['${routeNode.routePath}']['fullPath'],
+${((_a = routeNode.children) == null ? void 0 : _a.length) ? `${routeNode.variableName}RouteChildren` : "unknown"}
+>
+}`;
+    }).join("\n"),
+    "// Create and export the route tree",
+    routeConfigChildrenText,
+    `export interface FileRoutesByFullPath {
+  ${[...createRouteNodesByFullPath(routeNodes).entries()].map(
+      ([fullPath, routeNode]) => {
+        return `'${fullPath}': typeof ${getResolvedRouteNodeVariableName(routeNode)}`;
+      }
+    )}
+}`,
+    `export interface FileRoutesByTo {
+  ${[...createRouteNodesByTo(routeNodes).entries()].map(([to, routeNode]) => {
+      return `'${to}': typeof ${getResolvedRouteNodeVariableName(routeNode)}`;
+    })}
+}`,
+    `export interface FileRoutesById {
+  '${rootRouteId}': typeof rootRoute,
+  ${[...createRouteNodesById(routeNodes).entries()].map(([id, routeNode]) => {
+      return `'${id}': typeof ${getResolvedRouteNodeVariableName(routeNode)}`;
+    })}
+}`,
+    `export interface FileRouteTypes {
+  fileRoutesByFullPath: FileRoutesByFullPath
+  fullPaths: ${routeNodes.length > 0 ? [...createRouteNodesByFullPath(routeNodes).keys()].map((fullPath) => `'${fullPath}'`).join("|") : "never"}
+  fileRoutesByTo: FileRoutesByTo
+  to: ${routeNodes.length > 0 ? [...createRouteNodesByTo(routeNodes).keys()].map((to) => `'${to}'`).join("|") : "never"}
+  id: ${[`'${rootRouteId}'`, ...[...createRouteNodesById(routeNodes).keys()].map((id) => `'${id}'`)].join("|")}
+  fileRoutesById: FileRoutesById
+}`,
+    `export interface RootRouteChildren {
+  ${routeTree.map((child) => `${child.variableName}Route: typeof ${getResolvedRouteNodeVariableName(child)}`).join(",")}
+}`,
+    `const rootRouteChildren: RootRouteChildren = {
+  ${routeTree.map((child) => `${child.variableName}Route: ${getResolvedRouteNodeVariableName(child)}`).join(",")}
+}`,
+    `export const routeTree = rootRoute._addFileChildren(rootRouteChildren)._addFileTypes<FileRouteTypes>()`
+  ].filter(Boolean).join("\n\n");
+  const createRouteManifest = () => {
+    const routesManifest = {
+      [rootRouteId]: {
+        filePath: rootRouteNode.filePath,
+        children: routeTree.map((d) => d.routePath)
+      },
+      ...Object.fromEntries(
+        routeNodes.map((d) => {
+          var _a, _b;
+          const filePathId = d.routePath;
+          return [
+            filePathId,
+            {
+              filePath: d.filePath,
+              parent: ((_a = d.parent) == null ? void 0 : _a.routePath) ? d.parent.routePath : void 0,
+              children: (_b = d.children) == null ? void 0 : _b.map((childRoute) => childRoute.routePath)
+            }
+          ];
+        })
+      )
+    };
+    return JSON.stringify(
+      {
+        routes: routesManifest
+      },
+      null,
+      2
+    );
+  };
+  const includeManifest = ["react", "solid"];
+  const routeConfigFileContent = !includeManifest.includes(config.target) ? routeImports : [
+    routeImports,
+    "\n",
+    "/* ROUTE_MANIFEST_START",
+    createRouteManifest(),
+    "ROUTE_MANIFEST_END */"
+  ].join("\n");
+  if (!checkLatest()) return;
+  const existingRouteTreeContent = await fsp.readFile(path.resolve(generatedServerRouteTreePath), "utf-8").catch((err) => {
+    if (err.code === "ENOENT") {
+      return "";
+    }
+    throw err;
+  });
+  if (!checkLatest()) return;
+  await fsp.mkdir(path.dirname(path.resolve(generatedServerRouteTreePath)), {
+    recursive: true
+  });
+  if (!checkLatest()) return;
+  const routeTreeWriteResult = await writeIfDifferent(
+    path.resolve(generatedServerRouteTreePath),
+    await format(existingRouteTreeContent, config),
+    await format(routeConfigFileContent, config),
+    {
+      beforeWrite: () => {
+      }
+    }
+  );
+  const startDeclarationFilePath = path.join(
+    path.resolve(root, config.srcDirectory),
+    "tanstack-start.d.ts"
+  );
+  const serverRoutesRelativePath = removeExt(
+    path.relative(
+      path.dirname(startDeclarationFilePath),
+      generatedServerRouteTreePath
+    )
+  );
+  const startDeclarationFileContent = buildStartDeclarationFile({
+    serverRoutesRelativePath
+  });
+  if (!fs.existsSync(startDeclarationFilePath)) {
+    await writeIfDifferent(
+      startDeclarationFilePath,
+      "",
+      startDeclarationFileContent,
+      {
+        beforeWrite: () => {
+          logger.log(`🟡 Creating tanstack-start.d.ts`);
+        }
+      }
+    );
+  } else {
+    const existingDeclarationFileContent = await fsp.readFile(startDeclarationFilePath, "utf-8").catch((err) => {
+      if (err.code === "ENOENT") {
+        return "";
+      }
+      throw err;
+    });
+    await writeIfDifferent(
+      startDeclarationFilePath,
+      existingDeclarationFileContent,
+      startDeclarationFileContent,
+      {
+        beforeWrite: () => {
+          logger.log(`🟡 Updating tanstack-start.d.ts`);
+        }
+      }
+    );
+  }
+  if (routeTreeWriteResult && !checkLatest()) {
+    return;
+  }
+}
+function buildStartDeclarationFile({
+  serverRoutesRelativePath
+}) {
+  return [`import '${serverRoutesRelativePath}'`].join("\n") + "\n";
+}
+function removeGroups(s) {
+  return s.replace(possiblyNestedRouteGroupPatternRegex, "");
+}
+function determineNodePath(node) {
+  var _a;
+  return node.path = node.parent ? ((_a = node.routePath) == null ? void 0 : _a.replace(node.parent.routePath ?? "", "")) || "/" : node.routePath;
+}
+function removeLastSegmentFromPath(routePath = "/") {
+  const segments = routePath.split("/");
+  segments.pop();
+  return segments.join("/");
+}
+function removeLayoutSegments(routePath = "/") {
+  const segments = routePath.split("/");
+  const newSegments = segments.filter((segment) => !segment.startsWith("_"));
+  return newSegments.join("/");
+}
+function hasParentRoute(routes, node, routePathToCheck) {
+  if (!routePathToCheck || routePathToCheck === "/") {
+    return null;
+  }
+  const sortedNodes = multiSortBy(routes, [
+    (d) => d.routePath.length * -1,
+    (d) => d.variableName
+  ]).filter((d) => d.routePath !== `/${rootPathId}`);
+  for (const route of sortedNodes) {
+    if (route.routePath === "/") continue;
+    if (routePathToCheck.startsWith(`${route.routePath}/`) && route.routePath !== routePathToCheck) {
+      return route;
+    }
+  }
+  const segments = routePathToCheck.split("/");
+  segments.pop();
+  const parentRoutePath = segments.join("/");
+  return hasParentRoute(routes, node, parentRoutePath);
+}
+const getResolvedRouteNodeVariableName = (routeNode) => {
+  var _a;
+  return ((_a = routeNode.children) == null ? void 0 : _a.length) ? `${routeNode.variableName}RouteWithChildren` : `${routeNode.variableName}Route`;
+};
+const createRouteNodesByFullPath = (routeNodes) => {
+  return new Map(
+    routeNodes.map((routeNode) => [inferFullPath(routeNode), routeNode])
+  );
+};
+const createRouteNodesByTo = (routeNodes) => {
+  return new Map(
+    dedupeBranchesAndIndexRoutes(routeNodes).map((routeNode) => [
+      inferTo(routeNode),
+      routeNode
+    ])
+  );
+};
+const createRouteNodesById = (routeNodes) => {
+  return new Map(
+    routeNodes.map((routeNode) => {
+      const id = routeNode.routePath ?? "";
+      return [id, routeNode];
+    })
+  );
+};
+const inferFullPath = (routeNode) => {
+  const fullPath = removeGroups(
+    removeUnderscores(removeLayoutSegments(routeNode.routePath)) ?? ""
+  );
+  return routeNode.cleanedPath === "/" ? fullPath : fullPath.replace(/\/$/, "");
+};
+const inferPath = (routeNode) => {
+  var _a;
+  return routeNode.cleanedPath === "/" ? routeNode.cleanedPath : ((_a = routeNode.cleanedPath) == null ? void 0 : _a.replace(/\/$/, "")) ?? "";
+};
+const inferTo = (routeNode) => {
+  const fullPath = inferFullPath(routeNode);
+  if (fullPath === "/") return fullPath;
+  return fullPath.replace(/\/$/, "");
+};
+const dedupeBranchesAndIndexRoutes = (routes) => {
+  return routes.filter((route) => {
+    var _a;
+    if ((_a = route.children) == null ? void 0 : _a.find((child) => child.cleanedPath === "/")) return false;
+    return true;
+  });
+};
+function checkUnique(routes, key) {
+  const keys = routes.map((d) => d[key]);
+  const uniqueKeys = new Set(keys);
+  if (keys.length !== uniqueKeys.size) {
+    const duplicateKeys = keys.filter((d, i) => keys.indexOf(d) !== i);
+    const conflictingFiles = routes.filter(
+      (d) => duplicateKeys.includes(d[key])
+    );
+    return conflictingFiles;
+  }
+  return void 0;
+}
+function checkRouteFullPathUniqueness(_routes, config) {
+  const routes = _routes.map((d) => {
+    const inferredFullPath = inferFullPath(d);
+    return { ...d, inferredFullPath };
+  });
+  const conflictingFiles = checkUnique(routes, "inferredFullPath");
+  if (conflictingFiles !== void 0) {
+    const errorMessage = `Conflicting configuration paths were found for the following route${conflictingFiles.length > 1 ? "s" : ""}: ${conflictingFiles.map((p) => `"${p.inferredFullPath}"`).join(", ")}.
+Please ensure each Server Route has a unique full path.
+Conflicting files: 
+ ${conflictingFiles.map((d) => path.resolve(config.routesDirectory, d.filePath)).join("\n ")}
+`;
+    console.error(errorMessage);
+    process.exit(1);
+  }
+}
+export {
+  TanStackStartServerRoutesVite
+};
+//# sourceMappingURL=plugin.js.map