refactor: cleanup unused code

Author: wyattjoh

packages/next/errors.json

@@ -926,5 +926,6 @@
   "925": "You cannot define a route with the same specificity as an optional catch-all route (\"%s\" and \"/[[...%s]]\").",
   "926": "Optional route parameters are not yet supported (\"[%s]\") in route \"%s\".",
   "927": "Expected a dynamic route, but got a static route: %s",
-  "928": "Unexpected empty path segments match for a route \"%s\" with param \"%s\" of type \"%s\""
+  "928": "Unexpected empty path segments match for a route \"%s\" with param \"%s\" of type \"%s\"",
+  "929": "Could not resolve param value for segment: %s"
 }

packages/next/src/build/segment-config/app/app-segments.ts

@@ -12,15 +12,11 @@ import {
   isAppPageRouteModule,
 } from '../../../server/route-modules/checks'
 import { isClientReference } from '../../../lib/client-and-server-references'
-import {
-  getSegmentParam,
-  type SegmentParam,
-} from '../../../shared/lib/router/utils/get-segment-param'
+import { getSegmentParam } from '../../../shared/lib/router/utils/get-segment-param'
 import {
   getLayoutOrPageModule,
   type LoaderTree,
 } from '../../../server/lib/app-dir-module'
-import { PAGE_SEGMENT_KEY } from '../../../shared/lib/segment'
 import type { DynamicParamTypes } from '../../../shared/lib/app-router-types'
 
 type GenerateStaticParams = (options: { params?: Params }) => Promise<Params[]>
@@ -64,14 +60,7 @@ export type AppSegment = {
   paramType: DynamicParamTypes | undefined
   filePath: string | undefined
   config: AppSegmentConfig | undefined
-  isDynamicSegment: boolean
   generateStaticParams: GenerateStaticParams | undefined
-
-  /**
-   * Whether this segment is a parallel route segment or descends from a
-   * parallel route segment.
-   */
-  isParallelRouteSegment: boolean | undefined
 }
 
 /**
@@ -83,79 +72,57 @@ export type AppSegment = {
 async function collectAppPageSegments(routeModule: AppPageRouteModule) {
   // We keep track of unique segments, since with parallel routes, it's possible
   // to see the same segment multiple times.
-  const uniqueSegments = new Map<string, AppSegment>()
+  const segments: AppSegment[] = []
 
-  // Queue will store tuples of [loaderTree, currentSegments, isParallelRouteSegment]
-  type QueueItem = [
-    loaderTree: LoaderTree,
-    currentSegments: AppSegment[],
-    isParallelRouteSegment: boolean,
-  ]
-  const queue: QueueItem[] = [[routeModule.userland.loaderTree, [], false]]
+  // Queue will store loader trees.
+  const queue: LoaderTree[] = [routeModule.userland.loaderTree]
 
   while (queue.length > 0) {
-    const [loaderTree, currentSegments, isParallelRouteSegment] = queue.shift()!
+    const loaderTree = queue.shift()!
     const [name, parallelRoutes] = loaderTree
 
     // Process current node
     const { mod: userland, filePath } = await getLayoutOrPageModule(loaderTree)
     const isClientComponent = userland && isClientReference(userland)
 
-    const { param: paramName, type: paramType } = getSegmentParam(name) ?? {}
+    const param = getSegmentParam(name)
 
     const segment: AppSegment = {
       name,
-      paramName,
-      paramType,
+      paramName: param?.paramName,
+      paramType: param?.paramType,
       filePath,
       config: undefined,
-      isDynamicSegment: !!paramName,
       generateStaticParams: undefined,
-      isParallelRouteSegment,
     }
 
     // Only server components can have app segment configurations
     if (!isClientComponent) {
       attach(segment, userland, routeModule.definition.pathname)
     }
 
-    // Create a unique key for the segment
-    const segmentKey = getSegmentKey(segment)
-    if (!uniqueSegments.has(segmentKey)) {
-      uniqueSegments.set(segmentKey, segment)
-    }
-
-    const updatedSegments = [...currentSegments, segment]
-
-    // If this is a page segment, we've reached a leaf node
-    if (name === PAGE_SEGMENT_KEY) {
-      // Add all segments in the current path, preferring non-parallel segments
-      updatedSegments.forEach((seg) => {
-        const key = getSegmentKey(seg)
-        if (!uniqueSegments.has(key)) {
-          uniqueSegments.set(key, seg)
-        }
-      })
+    // If this segment doesn't already exist, then add it to the segments array.
+    // The list of segments is short so we just use a list traversal to check
+    // for duplicates and spare us needing to maintain the string key.
+    if (
+      segments.every(
+        (s) =>
+          s.name !== segment.name ||
+          s.paramName !== segment.paramName ||
+          s.paramType !== segment.paramType ||
+          s.filePath !== segment.filePath
+      )
+    ) {
+      segments.push(segment)
     }
 
     // Add all parallel routes to the queue
-    for (const parallelRouteKey in parallelRoutes) {
-      const parallelRoute = parallelRoutes[parallelRouteKey]
-      queue.push([
-        parallelRoute,
-        updatedSegments,
-        // A parallel route segment is one that descends from a segment that is
-        // not children or descends from a parallel route segment.
-        isParallelRouteSegment || parallelRouteKey !== 'children',
-      ])
+    for (const parallelRoute of Object.values(parallelRoutes)) {
+      queue.push(parallelRoute)
     }
   }
 
-  return Array.from(uniqueSegments.values())
-}
-
-function getSegmentKey(segment: AppSegment) {
-  return `${segment.name}-${segment.filePath ?? ''}-${segment.paramName ?? ''}-${segment.isParallelRouteSegment ? 'pr' : 'np'}`
+  return segments
 }
 
 /**
@@ -175,17 +142,15 @@ function collectAppRouteSegments(
 
   // Generate all the segments.
   const segments: AppSegment[] = parts.map((name) => {
-    const { param: paramName, type: paramType } = getSegmentParam(name) ?? {}
+    const param = getSegmentParam(name)
 
     return {
       name,
-      paramName,
-      paramType,
+      paramName: param?.paramName,
+      paramType: param?.paramType,
       filePath: undefined,
-      isDynamicSegment: !!paramName,
       config: undefined,
       generateStaticParams: undefined,
-      isParallelRouteSegment: undefined,
     } satisfies AppSegment
   })
 
@@ -222,48 +187,3 @@ export function collectSegments(
     'Expected a route module to be one of app route or page'
   )
 }
-
-/**
- * Collects the segment params for a given app page route module. This is
- * a variant of the `collectSegments` function that only collects the segment
- * params without importing anything.
- *
- * @param routeModule the app page route module
- * @returns the segment params for the app page route module
- */
-export function collectSegmentParams(
-  routeModule: AppPageRouteModule
-): readonly SegmentParam[] {
-  const uniqueSegments = new Map<string, SegmentParam>()
-
-  // Queue will store tuples of [loaderTree, isParallelRouteSegment]
-  type QueueItem = [loaderTree: LoaderTree, isParallelRouteSegment: boolean]
-  const queue: QueueItem[] = [[routeModule.userland.loaderTree, false]]
-
-  while (queue.length > 0) {
-    const [loaderTree, isParallelRouteSegment] = queue.shift()!
-    const [name, parallelRoutes] = loaderTree
-
-    // Handle this segment (if it's a dynamic segment param).
-    const segmentParam = getSegmentParam(name)
-    if (segmentParam) {
-      const key = `${name}-${segmentParam.param}-${isParallelRouteSegment ? 'pr' : 'np'}`
-      if (!uniqueSegments.has(key)) {
-        uniqueSegments.set(key, segmentParam)
-      }
-    }
-
-    // Add all of this segment's parallel routes to the queue.
-    for (const parallelRouteKey in parallelRoutes) {
-      const parallelRoute = parallelRoutes[parallelRouteKey]
-      queue.push([
-        parallelRoute,
-        // A parallel route segment is one that descends from a segment that is
-        // not children or descends from a parallel route segment.
-        isParallelRouteSegment || parallelRouteKey !== 'children',
-      ])
-    }
-  }
-
-  return Array.from(uniqueSegments.values())
-}

packages/next/src/build/segment-config/app/collect-root-param-keys.ts

@@ -17,9 +17,9 @@ function collectAppPageRootParamKeys(
     const [name, parallelRoutes, modules] = current
 
     // If this is a dynamic segment, then we collect the param.
-    const param = getSegmentParam(name)?.param
-    if (param) {
-      rootParams.push(param)
+    const paramName = getSegmentParam(name)?.paramName
+    if (paramName) {
+      rootParams.push(paramName)
     }
 
     // If this has a layout module, then we've found the root layout because

packages/next/src/build/static-paths/app.ts

@@ -17,6 +17,7 @@ import {
   encodeParam,
   extractPathnameRouteParamSegments,
   resolveRouteParamsFromTree,
+  interceptionPrefixFromParamType,
 } from './utils'
 import escapePathDelimiters from '../../shared/lib/router/utils/escape-path-delimiters'
 import { createIncrementalCache } from '../../export/helpers/create-incremental-cache'
@@ -644,30 +645,7 @@ function createReplacements(
   // Determine the prefix to use for the interception marker.
   let prefix: string
   if (segment.paramType) {
-    switch (segment.paramType) {
-      case 'catchall-intercepted-(.)':
-      case 'dynamic-intercepted-(.)':
-        prefix = '(.)'
-        break
-      case 'catchall-intercepted-(..)(..)':
-      case 'dynamic-intercepted-(..)(..)':
-        prefix = '(..)(..)'
-        break
-      case 'catchall-intercepted-(..)':
-      case 'dynamic-intercepted-(..)':
-        prefix = '(..)'
-        break
-      case 'catchall-intercepted-(...)':
-      case 'dynamic-intercepted-(...)':
-        prefix = '(...)'
-        break
-      case 'catchall':
-      case 'dynamic':
-      case 'optional-catchall':
-      default:
-        prefix = ''
-        break
-    }
+    prefix = interceptionPrefixFromParamType(segment.paramType) ?? ''
   } else {
     prefix = ''
   }
@@ -811,7 +789,7 @@ export async function buildAppStaticPaths({
     // dynamicParams set to false.
     if (
       segment.paramName &&
-      segment.isDynamicSegment &&
+      segment.paramType &&
       segment.config?.dynamicParams === false
     ) {
       for (const params of routeParams) {
@@ -828,7 +806,8 @@ export async function buildAppStaticPaths({
     }
 
     if (
-      segment.isDynamicSegment &&
+      segment.paramName &&
+      segment.paramType &&
       typeof segment.generateStaticParams !== 'function'
     ) {
       lastDynamicSegmentHadGenerateStaticParams = false