@tanstack/router-generator 1.133.20 → 1.133.27

package/src/utils.ts

@@ -53,8 +53,12 @@ export function removeTrailingSlash(s: string) {
 }
 
 const BRACKET_CONTENT_RE = /\[(.*?)\]/g
+const SPLIT_REGEX = /(?<!\[)\.(?!\])/g
 
-export function determineInitialRoutePath(routePath: string) {
+export function determineInitialRoutePath(
+  routePath: string,
+  config?: Pick<Config, 'experimental' | 'routeToken' | 'indexToken'>,
+) {
   const DISALLOWED_ESCAPE_CHARS = new Set([
     '/',
     '\\',
@@ -70,9 +74,39 @@ export function determineInitialRoutePath(routePath: string) {
     '%',
   ])
 
-  const parts = routePath.split(/(?<!\[)\.(?!\])/g)
+  const originalRoutePath =
+    cleanPath(
+      `/${(cleanPath(routePath) || '').split(SPLIT_REGEX).join('/')}`,
+    ) || ''
+
+  // check if the route path is a valid non-nested path,
+  // TODO with new major rename to reflect not experimental anymore
+  const isExperimentalNonNestedRoute = isValidNonNestedRoute(
+    originalRoutePath,
+    config,
+  )
+
+  let cleanedRoutePath = routePath
+
+  // we already identified the path as non-nested and can now remove the trailing underscores
+  // we need to do this now before we encounter any escaped trailing underscores
+  // this way we can be sure any remaining trailing underscores should remain
+  // TODO with new major we can remove check and always remove leading underscores
+  if (config?.experimental?.nonNestedRoutes) {
+    // we should leave trailing underscores if the route path is the root path
+    if (originalRoutePath !== `/${rootPathId}`) {
+      // remove trailing underscores on various path segments
+      cleanedRoutePath = removeTrailingUnderscores(
+        originalRoutePath,
+        config.routeToken,
+      )
+    }
+  }
+
+  const parts = cleanedRoutePath.split(SPLIT_REGEX)
 
   // Escape any characters that in square brackets
+  // we keep the original path untouched
   const escapedParts = parts.map((part) => {
     // Check if any disallowed characters are used in brackets
 
@@ -102,7 +136,11 @@ export function determineInitialRoutePath(routePath: string) {
 
   const final = cleanPath(`/${escapedParts.join('/')}`) || ''
 
-  return final
+  return {
+    routePath: final,
+    isExperimentalNonNestedRoute,
+    originalRoutePath,
+  }
 }
 
 export function replaceBackslash(s: string) {
@@ -155,6 +193,46 @@ export function removeUnderscores(s?: string) {
   return s?.replaceAll(/(^_|_$)/gi, '').replaceAll(/(\/_|_\/)/gi, '/')
 }
 
+function escapeRegExp(s: string): string {
+  return s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
+}
+
+export function removeLeadingUnderscores(s: string, routeToken: string) {
+  if (!s) return s
+
+  const hasLeadingUnderscore = routeToken[0] === '_'
+
+  const routeTokenToExclude = hasLeadingUnderscore
+    ? routeToken.slice(1)
+    : routeToken
+
+  const escapedRouteToken = escapeRegExp(routeTokenToExclude)
+
+  const leadingUnderscoreRegex = hasLeadingUnderscore
+    ? new RegExp(`(?<=^|\\/)_(?!${escapedRouteToken})`, 'g')
+    : new RegExp(`(?<=^|\\/)_`, 'g')
+
+  return s.replaceAll(leadingUnderscoreRegex, '')
+}
+
+export function removeTrailingUnderscores(s: string, routeToken: string) {
+  if (!s) return s
+
+  const hasTrailingUnderscore = routeToken.slice(-1) === '_'
+
+  const routeTokenToExclude = hasTrailingUnderscore
+    ? routeToken.slice(0, -1)
+    : routeToken
+
+  const escapedRouteToken = escapeRegExp(routeTokenToExclude)
+
+  const trailingUnderscoreRegex = hasTrailingUnderscore
+    ? new RegExp(`(?<!${escapedRouteToken})_(?=\\/|$)`, 'g')
+    : new RegExp(`_(?=\\/)|_$`, 'g')
+
+  return s.replaceAll(trailingUnderscoreRegex, '')
+}
+
 export function capitalize(s: string) {
   if (typeof s !== 'string') return ''
   return s.charAt(0).toUpperCase() + s.slice(1)
@@ -287,7 +365,22 @@ export function hasParentRoute(
   routes: Array<RouteNode>,
   node: RouteNode,
   routePathToCheck: string | undefined,
+  originalRoutePathToCheck?: string,
 ): RouteNode | null {
+  const getNonNestedSegments = (routePath: string) => {
+    const regex = /_(?=\/|$)/g
+
+    return [...routePath.matchAll(regex)]
+      .filter((match) => {
+        const beforeStr = routePath.substring(0, match.index)
+        const openBrackets = (beforeStr.match(/\[/g) || []).length
+        const closeBrackets = (beforeStr.match(/\]/g) || []).length
+        return openBrackets === closeBrackets
+      })
+      .map((match) => routePath.substring(0, match.index + 1))
+      .reverse()
+  }
+
   if (!routePathToCheck || routePathToCheck === '/') {
     return null
   }
@@ -297,7 +390,42 @@ export function hasParentRoute(
     (d) => d.variableName,
   ]).filter((d) => d.routePath !== `/${rootPathId}`)
 
-  for (const route of sortedNodes) {
+  const filteredNodes = node._isExperimentalNonNestedRoute
+    ? []
+    : [...sortedNodes]
+
+  if (node._isExperimentalNonNestedRoute) {
+    const nonNestedSegments = getNonNestedSegments(
+      originalRoutePathToCheck ?? '',
+    )
+
+    for (const route of sortedNodes) {
+      if (route.routePath === '/') continue
+
+      if (
+        routePathToCheck.startsWith(`${route.routePath}/`) &&
+        route._isExperimentalNonNestedRoute &&
+        route.routePath !== routePathToCheck
+      ) {
+        return route
+      }
+
+      if (
+        nonNestedSegments.find((seg) => seg === `${route.routePath}_`) ||
+        !(
+          route._fsRouteType === 'pathless_layout' ||
+          route._fsRouteType === 'layout' ||
+          route._fsRouteType === '__root'
+        )
+      ) {
+        continue
+      }
+
+      filteredNodes.push(route)
+    }
+  }
+
+  for (const route of filteredNodes) {
     if (route.routePath === '/') continue
 
     if (
@@ -312,7 +440,7 @@ export function hasParentRoute(
   segments.pop() // Remove the last segment
   const parentRoutePath = segments.join('/')
 
-  return hasParentRoute(routes, node, parentRoutePath)
+  return hasParentRoute(routes, node, parentRoutePath, originalRoutePathToCheck)
 }
 
 /**
@@ -354,9 +482,16 @@ export const inferPath = (routeNode: RouteNode): string => {
 /**
  * Infers the full path for use by TS
  */
-export const inferFullPath = (routeNode: RouteNode): string => {
+export const inferFullPath = (
+  routeNode: RouteNode,
+  config?: Pick<Config, 'experimental' | 'routeToken'>,
+): string => {
+  // with new nonNestedPaths feature we can be sure any remaining trailing underscores are escaped and should remain
+  // TODO with new major we can remove check and only remove leading underscores
   const fullPath = removeGroups(
-    removeUnderscores(removeLayoutSegments(routeNode.routePath)) ?? '',
+    (config?.experimental?.nonNestedRoutes
+      ? removeLayoutSegments(routeNode.routePath)
+      : removeUnderscores(removeLayoutSegments(routeNode.routePath))) ?? '',
   )
 
   return routeNode.cleanedPath === '/' ? fullPath : fullPath.replace(/\/$/, '')
@@ -367,9 +502,13 @@ export const inferFullPath = (routeNode: RouteNode): string => {
  */
 export const createRouteNodesByFullPath = (
   routeNodes: Array<RouteNode>,
+  config?: Pick<Config, 'experimental' | 'routeToken'>,
 ): Map<string, RouteNode> => {
   return new Map(
-    routeNodes.map((routeNode) => [inferFullPath(routeNode), routeNode]),
+    routeNodes.map((routeNode) => [
+      inferFullPath(routeNode, config),
+      routeNode,
+    ]),
   )
 }
 
@@ -378,10 +517,11 @@ export const createRouteNodesByFullPath = (
  */
 export const createRouteNodesByTo = (
   routeNodes: Array<RouteNode>,
+  config?: Pick<Config, 'experimental' | 'routeToken'>,
 ): Map<string, RouteNode> => {
   return new Map(
     dedupeBranchesAndIndexRoutes(routeNodes).map((routeNode) => [
-      inferTo(routeNode),
+      inferTo(routeNode, config),
       routeNode,
     ]),
   )
@@ -404,8 +544,11 @@ export const createRouteNodesById = (
 /**
  * Infers to path
  */
-export const inferTo = (routeNode: RouteNode): string => {
-  const fullPath = inferFullPath(routeNode)
+export const inferTo = (
+  routeNode: RouteNode,
+  config?: Pick<Config, 'experimental' | 'routeToken'>,
+): string => {
+  const fullPath = inferFullPath(routeNode, config)
 
   if (fullPath === '/') return fullPath
 
@@ -444,7 +587,7 @@ export function checkRouteFullPathUniqueness(
   config: Config,
 ) {
   const routes = _routes.map((d) => {
-    const inferredFullPath = inferFullPath(d)
+    const inferredFullPath = inferFullPath(d, config)
     return { ...d, inferredFullPath }
   })
 
@@ -581,6 +724,7 @@ export function buildFileRoutesByPathInterface(opts: {
   routeNodes: Array<RouteNode>
   module: string
   interfaceName: string
+  config?: Pick<Config, 'experimental' | 'routeToken'>
 }): string {
   return `declare module '${opts.module}' {
   interface ${opts.interfaceName} {
@@ -594,7 +738,7 @@ export function buildFileRoutesByPathInterface(opts: {
         return `'${filePathId}': {
           id: '${filePathId}'
           path: '${inferPath(routeNode)}'
-          fullPath: '${inferFullPath(routeNode)}'
+          fullPath: '${inferFullPath(routeNode, opts.config)}'
           preLoaderRoute: ${preloaderRoute}
           parentRoute: typeof ${parent}
         }`
@@ -647,3 +791,51 @@ export function getImportForRouteNode(
     ],
   } satisfies ImportDeclaration
 }
+
+/**
+ * Used to validate if a route is a pathless layout route
+ * @param normalizedRoutePath Normalized route path, i.e `/foo/_layout/route.tsx` and `/foo._layout.route.tsx` to `/foo/_layout/route`
+ * @param config The `router-generator` configuration object
+ * @returns Boolean indicating if the route is a pathless layout route
+ */
+export function isValidNonNestedRoute(
+  normalizedRoutePath: string,
+  config?: Pick<Config, 'experimental' | 'routeToken' | 'indexToken'>,
+): boolean {
+  if (!config?.experimental?.nonNestedRoutes) {
+    return false
+  }
+
+  const segments = normalizedRoutePath.split('/').filter(Boolean)
+
+  if (segments.length === 0) {
+    return false
+  }
+
+  const lastRouteSegment = segments[segments.length - 1]!
+
+  // If segment === __root, then exit as false
+  if (lastRouteSegment === rootPathId) {
+    return false
+  }
+
+  if (
+    lastRouteSegment !== config.indexToken &&
+    lastRouteSegment !== config.routeToken &&
+    lastRouteSegment.endsWith('_')
+  ) {
+    return true
+  }
+
+  for (const segment of segments.slice(0, -1).reverse()) {
+    if (segment === config.routeToken) {
+      return false
+    }
+
+    if (segment.endsWith('_')) {
+      return true
+    }
+  }
+
+  return false
+}