@tanstack/start-plugin-core 1.121.0-alpha.25 → 1.121.0-alpha.26

package/dist/cjs/start-server-routes-plugin/plugin.cjs

@@ -1,614 +0,0 @@
-"use strict";
-Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const path = require("node:path");
-const fs = require("node:fs");
-const fsp = require("node:fs/promises");
-const routerGenerator = require("@tanstack/router-generator");
-const routerCore = require("@tanstack/router-core");
-const template = require("./template.cjs");
-let lock = false;
-const checkLock = () => lock;
-const setLock = (bool) => {
-  lock = bool;
-};
-function TanStackStartServerRoutesVite(config) {
-  let ROOT = process.cwd();
-  const moduleId = "tanstack-start-server-routes-manifest:v";
-  const getRoutesDirectoryPath = () => {
-    return path.isAbsolute(config.routesDirectory) ? config.routesDirectory : path.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 = path.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 === moduleId) {
-        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 = template.getTargetTemplate(config.target);
-  const logger = routerGenerator.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 routerGenerator.virtualGetRouteNodes(config, root);
-  } else {
-    getRouteNodesResult = await routerGenerator.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 "${routerGenerator.rootPathId}.tsx" file to your routes directory.
-Add the file in: "${config.routesDirectory}/${routerGenerator.rootPathId}.tsx"`;
-    }
-    throw new Error(errorMessage);
-  }
-  const preRouteNodes = routerGenerator.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) => ![`/${routerGenerator.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 template.fillTemplate(config, _rootTemplate.template(), {
-        tsrImports: _rootTemplate.imports.tsrImports(),
-        tsrPath: routerGenerator.rootPathId,
-        tsrExportStart: _rootTemplate.imports.tsrExportStart(),
-        tsrExportEnd: _rootTemplate.imports.tsrExportEnd()
-      });
-      await routerGenerator.writeIfDifferent(
-        node.fullPath,
-        "",
-        // Empty string because the file doesn't exist yet
-        replaced,
-        {
-          beforeWrite: () => {
-          }
-        }
-      );
-    }
-  };
-  await handleRootNode(rootRouteNode);
-  const handleNode = async (node) => {
-    var _a;
-    routerGenerator.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 = routerGenerator.trimPathLeft(node.path ?? "");
-    const split = trimmedPath.split("/");
-    const lastRouteSegment = split[split.length - 1] ?? trimmedPath;
-    node.isNonPath = lastRouteSegment.startsWith("_") || routeGroupPatternRegex.test(lastRouteSegment);
-    node.cleanedPath = removeGroups(
-      routerGenerator.removeUnderscores(removeLayoutSegments(node.path)) ?? ""
-    );
-    const stats = fs.statSync(node.fullPath);
-    const routeCode = stats.isFile() ? 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 = routerGenerator.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 = routerGenerator.multiSortBy(routeNodes, [
-    (d) => {
-      var _a;
-      return ((_a = d.routePath) == null ? void 0 : _a.includes(`/${routerGenerator.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 routerGenerator.replaceBackslash(
-      routerGenerator.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 {
-  '${routerCore.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: ${[`'${routerCore.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 = {
-      [routerCore.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 routerGenerator.writeIfDifferent(
-    path.resolve(generatedServerRouteTreePath),
-    await routerGenerator.format(existingRouteTreeContent, config),
-    await routerGenerator.format(routeConfigFileContent, config),
-    {
-      beforeWrite: () => {
-      }
-    }
-  );
-  const startDeclarationFilePath = path.join(
-    path.resolve(root, config.srcDirectory),
-    "tanstack-start.d.ts"
-  );
-  const serverRoutesRelativePath = routerGenerator.removeExt(
-    path.relative(
-      path.dirname(startDeclarationFilePath),
-      generatedServerRouteTreePath
-    )
-  );
-  const startDeclarationFileContent = buildStartDeclarationFile({
-    serverRoutesRelativePath
-  });
-  if (!fs.existsSync(startDeclarationFilePath)) {
-    await routerGenerator.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 routerGenerator.writeIfDifferent(
-      startDeclarationFilePath,
-      existingDeclarationFileContent,
-      startDeclarationFileContent,
-      {
-        beforeWrite: () => {
-          logger.log(`🟡 Updating tanstack-start.d.ts`);
-        }
-      }
-    );
-  }
-  if (routeTreeWriteResult && !checkLatest()) {
-    return;
-  }
-}
-function buildStartDeclarationFile({
-  serverRoutesRelativePath
-}) {
-  const serverRoutesPath = routerGenerator.replaceBackslash(serverRoutesRelativePath);
-  return [
-    '/// <reference types="vite/client" />',
-    `import '${serverRoutesPath}'`
-  ].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 = routerGenerator.multiSortBy(routes, [
-    (d) => d.routePath.length * -1,
-    (d) => d.variableName
-  ]).filter((d) => d.routePath !== `/${routerGenerator.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(
-    routerGenerator.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);
-  }
-}
-exports.TanStackStartServerRoutesVite = TanStackStartServerRoutesVite;
-//# sourceMappingURL=plugin.cjs.map