@tanstack/router-generator 1.121.0-alpha.5 → 1.121.0

package/src/utils.ts

@@ -1,5 +1,9 @@
 import * as fsp from 'node:fs/promises'
+import path from 'node:path'
 import * as prettier from 'prettier'
+import { rootPathId } from './filesystem/physical/rootPathId'
+import type { Config } from './config'
+import type { ImportDeclaration, RouteNode } from './types'
 
 export function multiSortBy<T>(
   arr: Array<T>,
@@ -40,42 +44,6 @@ export function trimPathLeft(path: string) {
   return path === '/' ? path : path.replace(/^\/{1,}/, '')
 }
 
-export function logging(config: { disabled: boolean }) {
-  function stripEmojis(str: string) {
-    return str.replace(
-      /[\p{Emoji_Presentation}\p{Extended_Pictographic}]/gu,
-      '',
-    )
-  }
-
-  function formatLogArgs(args: Array<any>): Array<any> {
-    if (process.env.CI) {
-      return args.map((arg) =>
-        typeof arg === 'string' ? stripEmojis(arg) : arg,
-      )
-    }
-    return args
-  }
-
-  return {
-    log: (...args: Array<any>) => {
-      if (!config.disabled) console.log(...formatLogArgs(args))
-    },
-    debug: (...args: Array<any>) => {
-      if (!config.disabled) console.debug(...formatLogArgs(args))
-    },
-    info: (...args: Array<any>) => {
-      if (!config.disabled) console.info(...formatLogArgs(args))
-    },
-    warn: (...args: Array<any>) => {
-      if (!config.disabled) console.warn(...formatLogArgs(args))
-    },
-    error: (...args: Array<any>) => {
-      if (!config.disabled) console.error(...formatLogArgs(args))
-    },
-  }
-}
-
 export function removeLeadingSlash(path: string): string {
   return path.replace(/^\//, '')
 }
@@ -268,3 +236,350 @@ export async function checkFileExists(file: string) {
     return false
   }
 }
+
+const possiblyNestedRouteGroupPatternRegex = /\([^/]+\)\/?/g
+export function removeGroups(s: string) {
+  return s.replace(possiblyNestedRouteGroupPatternRegex, '')
+}
+
+/**
+ * Removes all segments from a given path that start with an underscore ('_').
+ *
+ * @param {string} routePath - The path from which to remove segments. Defaults to '/'.
+ * @returns {string} The path with all underscore-prefixed segments removed.
+ * @example
+ * removeLayoutSegments('/workspace/_auth/foo') // '/workspace/foo'
+ */
+export function removeLayoutSegments(routePath: string = '/'): string {
+  const segments = routePath.split('/')
+  const newSegments = segments.filter((segment) => !segment.startsWith('_'))
+  return newSegments.join('/')
+}
+
+/**
+ * The `node.path` is used as the `id` in the route definition.
+ * This function checks if the given node has a parent and if so, it determines the correct path for the given node.
+ * @param node - The node to determine the path for.
+ * @returns The correct path for the given node.
+ */
+export function determineNodePath(node: RouteNode) {
+  return (node.path = node.parent
+    ? node.routePath?.replace(node.parent.routePath ?? '', '') || '/'
+    : node.routePath)
+}
+
+/**
+ * Removes the last segment from a given path. Segments are considered to be separated by a '/'.
+ *
+ * @param {string} routePath - The path from which to remove the last segment. Defaults to '/'.
+ * @returns {string} The path with the last segment removed.
+ * @example
+ * removeLastSegmentFromPath('/workspace/_auth/foo') // '/workspace/_auth'
+ */
+export function removeLastSegmentFromPath(routePath: string = '/'): string {
+  const segments = routePath.split('/')
+  segments.pop() // Remove the last segment
+  return segments.join('/')
+}
+
+export function hasParentRoute(
+  routes: Array<RouteNode>,
+  node: RouteNode,
+  routePathToCheck: string | undefined,
+): RouteNode | null {
+  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() // Remove the last segment
+  const parentRoutePath = segments.join('/')
+
+  return hasParentRoute(routes, node, parentRoutePath)
+}
+
+/**
+ * Gets the final variable name for a route
+ */
+export const getResolvedRouteNodeVariableName = (
+  routeNode: RouteNode,
+  variableNameSuffix: string,
+): string => {
+  return routeNode.children?.length
+    ? `${routeNode.variableName}${variableNameSuffix}WithChildren`
+    : `${routeNode.variableName}${variableNameSuffix}`
+}
+
+/**
+ * Checks if a given RouteNode is valid for augmenting it with typing based on conditions.
+ * Also asserts that the RouteNode is defined.
+ *
+ * @param routeNode - The RouteNode to check.
+ * @returns A boolean indicating whether the RouteNode is defined.
+ */
+export function isRouteNodeValidForAugmentation(
+  routeNode?: RouteNode,
+): routeNode is RouteNode {
+  if (!routeNode || routeNode.isVirtual) {
+    return false
+  }
+  return true
+}
+
+/**
+ * Infers the path for use by TS
+ */
+export const inferPath = (routeNode: RouteNode): string => {
+  return routeNode.cleanedPath === '/'
+    ? routeNode.cleanedPath
+    : (routeNode.cleanedPath?.replace(/\/$/, '') ?? '')
+}
+
+/**
+ * Infers the full path for use by TS
+ */
+export const inferFullPath = (routeNode: RouteNode): string => {
+  const fullPath = removeGroups(
+    removeUnderscores(removeLayoutSegments(routeNode.routePath)) ?? '',
+  )
+
+  return routeNode.cleanedPath === '/' ? fullPath : fullPath.replace(/\/$/, '')
+}
+
+/**
+ * Creates a map from fullPath to routeNode
+ */
+export const createRouteNodesByFullPath = (
+  routeNodes: Array<RouteNode>,
+): Map<string, RouteNode> => {
+  return new Map(
+    routeNodes.map((routeNode) => [inferFullPath(routeNode), routeNode]),
+  )
+}
+
+/**
+ * Create a map from 'to' to a routeNode
+ */
+export const createRouteNodesByTo = (
+  routeNodes: Array<RouteNode>,
+): Map<string, RouteNode> => {
+  return new Map(
+    dedupeBranchesAndIndexRoutes(routeNodes).map((routeNode) => [
+      inferTo(routeNode),
+      routeNode,
+    ]),
+  )
+}
+
+/**
+ * Create a map from 'id' to a routeNode
+ */
+export const createRouteNodesById = (
+  routeNodes: Array<RouteNode>,
+): Map<string, RouteNode> => {
+  return new Map(
+    routeNodes.map((routeNode) => {
+      const id = routeNode.routePath ?? ''
+      return [id, routeNode]
+    }),
+  )
+}
+
+/**
+ * Infers to path
+ */
+export const inferTo = (routeNode: RouteNode): string => {
+  const fullPath = inferFullPath(routeNode)
+
+  if (fullPath === '/') return fullPath
+
+  return fullPath.replace(/\/$/, '')
+}
+
+/**
+ * Dedupes branches and index routes
+ */
+export const dedupeBranchesAndIndexRoutes = (
+  routes: Array<RouteNode>,
+): Array<RouteNode> => {
+  return routes.filter((route) => {
+    if (route.children?.find((child) => child.cleanedPath === '/')) return false
+    return true
+  })
+}
+
+function checkUnique<TElement>(routes: Array<TElement>, key: keyof TElement) {
+  // Check no two routes have the same `key`
+  // if they do, throw an error with the conflicting filePaths
+  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 undefined
+}
+
+export function checkRouteFullPathUniqueness(
+  _routes: Array<RouteNode>,
+  config: Config,
+) {
+  const routes = _routes.map((d) => {
+    const inferredFullPath = inferFullPath(d)
+    return { ...d, inferredFullPath }
+  })
+
+  const conflictingFiles = checkUnique(routes, 'inferredFullPath')
+
+  if (conflictingFiles !== undefined) {
+    const errorMessage = `Conflicting configuration paths were found for the following route${conflictingFiles.length > 1 ? 's' : ''}: ${conflictingFiles
+      .map((p) => `"${p.inferredFullPath}"`)
+      .join(', ')}.
+Please ensure each Route has a unique full path.
+Conflicting files: \n ${conflictingFiles.map((d) => path.resolve(config.routesDirectory, d.filePath)).join('\n ')}\n`
+    throw new Error(errorMessage)
+  }
+}
+
+export function buildRouteTreeConfig(
+  nodes: Array<RouteNode>,
+  exportName: string,
+  disableTypes: boolean,
+  depth = 1,
+): Array<string> {
+  const children = nodes.map((node) => {
+    if (node._fsRouteType === '__root') {
+      return
+    }
+
+    if (node._fsRouteType === 'pathless_layout' && !node.children?.length) {
+      return
+    }
+
+    const route = `${node.variableName}`
+
+    if (node.children?.length) {
+      const childConfigs = buildRouteTreeConfig(
+        node.children,
+        exportName,
+        disableTypes,
+        depth + 1,
+      )
+
+      const childrenDeclaration = disableTypes
+        ? ''
+        : `interface ${route}${exportName}Children {
+  ${node.children.map((child) => `${child.variableName}${exportName}: typeof ${getResolvedRouteNodeVariableName(child, exportName)}`).join(',')}
+}`
+
+      const children = `const ${route}${exportName}Children${disableTypes ? '' : `: ${route}${exportName}Children`} = {
+  ${node.children.map((child) => `${child.variableName}${exportName}: ${getResolvedRouteNodeVariableName(child, exportName)}`).join(',')}
+}`
+
+      const routeWithChildren = `const ${route}${exportName}WithChildren = ${route}${exportName}._addFileChildren(${route}${exportName}Children)`
+
+      return [
+        childConfigs.join('\n'),
+        childrenDeclaration,
+        children,
+        routeWithChildren,
+      ].join('\n\n')
+    }
+
+    return undefined
+  })
+
+  return children.filter((x) => x !== undefined)
+}
+
+export function buildImportString(
+  importDeclaration: ImportDeclaration,
+): string {
+  const { source, specifiers, importKind } = importDeclaration
+  return specifiers.length
+    ? `import ${importKind === 'type' ? 'type ' : ''}{ ${specifiers.map((s) => (s.local ? `${s.imported} as ${s.local}` : s.imported)).join(', ')} } from '${source}'`
+    : ''
+}
+
+export function lowerCaseFirstChar(value: string) {
+  if (!value[0]) {
+    return value
+  }
+
+  return value[0].toLowerCase() + value.slice(1)
+}
+
+export function mergeImportDeclarations(
+  imports: Array<ImportDeclaration>,
+): Array<ImportDeclaration> {
+  const merged: Record<string, ImportDeclaration> = {}
+
+  for (const imp of imports) {
+    const key = `${imp.source}-${imp.importKind}`
+    if (!merged[key]) {
+      merged[key] = { ...imp, specifiers: [] }
+    }
+    for (const specifier of imp.specifiers) {
+      // check if the specifier already exists in the merged import
+      if (
+        !merged[key].specifiers.some(
+          (existing) =>
+            existing.imported === specifier.imported &&
+            existing.local === specifier.local,
+        )
+      ) {
+        merged[key].specifiers.push(specifier)
+      }
+    }
+  }
+
+  return Object.values(merged)
+}
+
+export function hasChildWithExport(
+  node: RouteNode,
+  exportName: string,
+): boolean {
+  return (
+    node.children?.some((child) => hasChildWithExport(child, exportName)) ??
+    false
+  )
+}
+
+export const findParent = (
+  node: RouteNode | undefined,
+  exportName: string,
+): string => {
+  if (!node) {
+    return `root${exportName}Import`
+  }
+  if (node.parent) {
+    if (node.parent.exports?.includes(exportName)) {
+      if (node.isVirtualParentRequired) {
+        return `${node.parent.variableName}${exportName}`
+      } else {
+        return `${node.parent.variableName}${exportName}`
+      }
+    }
+  }
+  return findParent(node.parent, exportName)
+}