Static Generation

Copyconst isPageStaticSpan = trace('is-page-static-utils', parentId)
return isPageStaticSpan
  .traceAsyncFn(async (): Promise<PageIsStaticResult> => {
    setHttpClientAndAgentOptions({
      httpAgentOptions,
    })
 
    let componentsResult: LoadComponentsReturnType
    let prerenderedRoutes: PrerenderedRoute[] | undefined
    let prerenderRouteMatchers: PrerenderRouteMatcher[] | undefined
    let paramMatching: ParamMatching | undefined
    let prerenderFallbackMode: FallbackMode | undefined
    let appConfig: AppSegmentConfig = {}
    let rootParamKeys: readonly string[] | undefined
    const pathIsEdgeRuntime = isEdgeRuntime(pageRuntime)
 
    if (pathIsEdgeRuntime) {
      const runtime = await getRuntimeContext({
        paths: edgeInfo.files.map((file: string) => path.join(distDir, file)),
        edgeFunctionEntry: {
          ...edgeInfo,
          wasm: (edgeInfo.wasm ?? []).map((binding: AssetBinding) => ({
            ...binding,
            filePath: path.join(distDir, binding.filePath),
          })),
        },
        name: edgeInfo.name,
        useCache: true,
        distDir,
        clientAssetToken,
      })
      const mod = (
        await runtime.context._ENTRIES[`middleware_${edgeInfo.name}`]
      ).ComponentMod
 
      // This is not needed during require.
      const buildManifest = {} as BuildManifest
 
      componentsResult = {
        Component: mod.default,
        Document: mod.Document,
        App: mod.App,
        routeModule: mod.routeModule,
        page,
        ComponentMod: mod,
        pageConfig: mod.config || {},
        buildManifest,
        reactLoadableManifest: {},
        getServerSideProps: mod.getServerSideProps,
        getStaticPaths: mod.getStaticPaths,
        getStaticProps: mod.getStaticProps,
      }
    } else {
      componentsResult = await loadComponents({
        distDir,
        page: originalAppPath || page,
        isAppPath: pageType === 'app',
        isDev: false,
        sriEnabled,
        needsManifestsForLegacyReasons: true,
      })
    }
 
    const { Component, routeModule } = componentsResult

Copyif (pageType === 'app') {
  // @ts-expect-error pageType is app, so we can assume AppPageModule | AppRouteModule
  const ComponentMod: AppPageModule | AppRouteModule =
    componentsResult.ComponentMod
 
  let collectedSegments: Awaited<ReturnType<typeof collectSegments>>
  try {
    collectedSegments = await collectSegments(
      // We know this is an app page or app route module because we
      // checked above that the page type is 'app'.
      routeModule as AppPageRouteModule | AppRouteRouteModule,
      { cacheComponents, partialPrefetching }
    )
  } catch (err) {
    throw new Error(`Failed to collect configuration for ${page}`, {
      cause: err,
    })
  }

Copy// Re-export methods.
export const getStaticProps = hoist(userland, 'getStaticProps')
export const getStaticPaths = hoist(userland, 'getStaticPaths')
export const getServerSideProps = hoist(userland, 'getServerSideProps')
export const config = hoist(userland, 'config')
export const reportWebVitals = hoist(userland, 'reportWebVitals')
 
// Re-export legacy methods.
export const unstable_getStaticProps = hoist(
  userland,
  'unstable_getStaticProps'
)
export const unstable_getStaticPaths = hoist(
  userland,
  'unstable_getStaticPaths'
)
export const unstable_getStaticParams = hoist(
  userland,
  'unstable_getStaticParams'
)
export const unstable_getServerProps = hoist(
  userland,
  'unstable_getServerProps'
)
export const unstable_getServerSideProps = hoist(
  userland,
  'unstable_getServerSideProps'
)

Copyexport const handler = getHandler({
  srcPage: 'VAR_DEFINITION_PAGE',
  config,
  userland,
  routeModule,
  getStaticPaths,
  getStaticProps,
  getServerSideProps,
})

Copyexport function extractPathnameRouteParamSegmentsFromLoaderTree(
  loaderTree: LoaderTree,
  route: NormalizedAppRoute
): {
  pathnameRouteParamSegments: Array<{
    readonly name: string
    readonly paramName: string
    readonly paramType: DynamicParamTypes
  }>
  params: Params
} {
  const segmentsByDepth = new Map<
    number,
    {
      readonly name: string
      readonly paramName: string
      readonly paramType: DynamicParamTypes
    }
  >()
  const params: Params = {}
 
  // BFS traversal with depth and path tracking
  const queue: Array<{
    tree: LoaderTree
    depth: number
    currentPath: NormalizedAppRouteSegment[]
  }> = [{ tree: loaderTree, depth: 0, currentPath: [] }]

Copywhile (queue.length > 0) {
  const { tree, depth, currentPath } = queue.shift()!
  const { segment, parallelRoutes } = parseLoaderTree(tree)
 
  // Build the path for the current node
  let updatedPath = currentPath
  let nextDepth = depth
 
  const appSegment = parseAppRouteSegment(segment)
 
  // Only add to path if it's a real segment that appears in the URL
  // Route groups and parallel markers don't contribute to URL pathname
  if (
    appSegment &&
    appSegment.type !== 'route-group' &&
    appSegment.type !== 'parallel-route'
  ) {
    updatedPath = [...currentPath, appSegment]
    nextDepth = depth + 1
  }

Copyfunction validatePrefixMatch(
  currentPath: NormalizedAppRouteSegment[],
  route: NormalizedAppRoute
): boolean {
  for (let i = 0; i < currentPath.length; i++) {
    const pathSegment = currentPath[i]
    const targetPathSegment = route.segments[i]
 
    // Type mismatch - one is static, one is dynamic
    if (pathSegment.type !== targetPathSegment.type) {
      return false
    }
 
    // One has an interception marker, the other doesn't.
    if (
      pathSegment.interceptionMarker !== targetPathSegment.interceptionMarker
    ) {
      return false
    }
 
    // Both are static but names don't match
    if (
      pathSegment.type === 'static' &&
      targetPathSegment.type === 'static' &&
      pathSegment.name !== targetPathSegment.name
    ) {
      return false
    }
    // Both are dynamic but param names don't match
    else if (
      pathSegment.type === 'dynamic' &&
      targetPathSegment.type === 'dynamic' &&
      pathSegment.param.paramType !== targetPathSegment.param.paramType &&
      pathSegment.param.paramName !== targetPathSegment.param.paramName
    ) {
      return false
    }
  }
 
  return true
}

Copyexport function extractPathnameRouteParamSegmentsFromSegments(
  segments: readonly Readonly<AppSegment>[]
): Array<{
  readonly name: string
  readonly paramName: string
  readonly paramType: DynamicParamTypes
}> {
  // TODO: should we consider what values are already present in the page?
 
  // For AppRouteRouteModule, filter the segments array to get the route params
  // that contribute to the pathname.
  const result: Array<{
    readonly name: string
    readonly paramName: string
    readonly paramType: DynamicParamTypes
  }> = []
 
  for (const segment of segments) {
    // Skip segments without param info.
    if (!segment.paramName || !segment.paramType) continue
 
    // Collect all the route param keys that contribute to the pathname.
    result.push({
      name: segment.name,
      paramName: segment.paramName,
      paramType: segment.paramType,
    })
  }
 
  return result
}

Copyif (
  segments.some((generate) => generate.config?.dynamicParams === true) &&
  nextConfigOutput === 'export'
) {
  throw new Error(
    '"dynamicParams: true" cannot be used with "output: export". See more info here: https://nextjs.org/docs/app/building-your-application/deploying/static-exports'
  )
}

Copyconst staticPathsResult = await getStaticPaths({
  // We create a copy here to avoid having the types of `getStaticPaths`
  // change. This ensures that users can't mutate this array and have it
  // poison the reference.
  locales: [...(locales ?? [])],
  defaultLocale,
})
 
const expectedReturnVal =
  `Expected: { paths: [], fallback: boolean }\n` +
  `See here for more info: https://nextjs.org/docs/messages/invalid-getstaticpaths-value`
 
if (
  !staticPathsResult ||
  typeof staticPathsResult !== 'object' ||
  Array.isArray(staticPathsResult)
) {
  throw new Error(
    `Invalid value returned from getStaticPaths in ${page}. Received ${typeof staticPathsResult} ${expectedReturnVal}`
  )
}
 
const invalidStaticPathKeys = Object.keys(staticPathsResult).filter(
  (key) => !(key === 'paths' || key === 'fallback')
)
 
if (invalidStaticPathKeys.length > 0) {
  throw new Error(
    `Extra keys returned from getStaticPaths in ${page} (${invalidStaticPathKeys.join(
      ', '
    )}) ${expectedReturnVal}`
  )
}
 
if (
  !(
    typeof staticPathsResult.fallback === 'boolean' ||
    staticPathsResult.fallback === 'blocking'
  )
) {
  throw new Error(
    `The \`fallback\` key must be returned from getStaticPaths in ${page}.\n` +
      expectedReturnVal
  )
}

Copyconst invalidKeys = Object.keys(entry).filter(
  (key) => key !== 'params' && key !== 'locale'
)
 
if (invalidKeys.length) {
  throw new Error(
    `Additional keys were returned from \`getStaticPaths\` in page "${page}". ` +
      `URL Parameters intended for this dynamic route must be nested under the \`params\` key, i.e.:` +
      `\n\n\treturn { params: { ${routeParameterKeys
        .map((k) => `${k}: ...`)
        .join(', ')} } }` +
      `\n\nKeys that need to be moved: ${invalidKeys.join(', ')}.\n`
  )
}
 
const { params = {} } = entry
let builtPage = page
let encodedBuiltPage = page
 
routeParameterKeys.forEach((validParamKey) => {
  const { repeat, optional } = _routeRegex.groups[validParamKey]
  let paramValue = params[validParamKey]
  if (
    optional &&
    params.hasOwnProperty(validParamKey) &&
    (paramValue === null ||
      paramValue === undefined ||
      (paramValue as any) === false)
  ) {
    paramValue = []
  }
 
  if (
    (repeat && !Array.isArray(paramValue)) ||
    (!repeat && typeof paramValue !== 'string') ||
    typeof paramValue === 'undefined'
  ) {
    throw new Error(
      `A required parameter (${validParamKey}) was not provided as ${
        repeat ? 'an array' : 'a string'
      } received ${typeof paramValue} in getStaticPaths for ${page}`
    )
  }

Copy  routeParameterKeys.forEach((validParamKey) => {
    const { repeat, optional } = _routeRegex.groups[validParamKey]
    let paramValue = params[validParamKey]
    if (
      optional &&
      params.hasOwnProperty(validParamKey) &&
      (paramValue === null ||
        paramValue === undefined ||
        (paramValue as any) === false)
    ) {
      paramValue = []
    }
 
    if (
      (repeat && !Array.isArray(paramValue)) ||
      (!repeat && typeof paramValue !== 'string') ||
      typeof paramValue === 'undefined'
    ) {
      throw new Error(
        `A required parameter (${validParamKey}) was not provided as ${
          repeat ? 'an array' : 'a string'
        } received ${typeof paramValue} in getStaticPaths for ${page}`
      )
    }
 
    let replaced = `[${repeat ? '...' : ''}${validParamKey}]`
    if (optional) {
      replaced = `[${replaced}]`
    }
 
    builtPage = builtPage.replace(
      replaced,
      encodeParam(paramValue, (value) => escapePathDelimiters(value, true))
    )
 
    encodedBuiltPage = encodedBuiltPage.replace(
      replaced,
      encodeParam(paramValue, encodeURIComponent)
    )
  })
 
  if (!builtPage && !encodedBuiltPage) {
    return
  }
 
  if (entry.locale && !locales?.includes(entry.locale)) {
    throw new Error(
      `Invalid locale returned from getStaticPaths for ${page}, the locale ${entry.locale} is not specified in ${configFileName}`
    )
  }
  const curLocale = entry.locale || defaultLocale || ''
 
  const pathname = normalizePathname(
    `${curLocale ? `/${curLocale}` : ''}${curLocale && builtPage === '/' ? '' : builtPage}`
  )
 
  if (!prerenderedRoutesByPathname.has(pathname)) {
    prerenderedRoutesByPathname.set(pathname, {
      params,
      pathname,
      encodedPathname: normalizePathname(
        `${curLocale ? `/${curLocale}` : ''}${
          curLocale && encodedBuiltPage === '/' ? '' : encodedBuiltPage
        }`
      ),
      fallbackRouteParams: undefined,
      fallbackMode: parseStaticPathsResult(staticPathsResult.fallback),
      fallbackRootParams: undefined,
      throwOnEmptyStaticShell: undefined,
    })
  }
}

Copy;(globalThis as any).__NEXT_DATA__ = {
  nextExport: true,
}

Copyif (components.getServerSideProps) {
  throw new Error(`Error for page ${page}: ${SERVER_PROPS_EXPORT_ERROR}`)
}
 
// for non-dynamic SSG pages we should have already
// prerendered the file
if (!buildExport && components.getStaticProps && !isDynamic) {
  return
}

Copyexport async function createIncrementalCache({
  cacheHandler,
  cacheMaxMemorySize,
  fetchCacheKeyPrefix,
  distDir,
  dir,
  flushToDisk,
  cacheHandlers,
  requestHeaders,
}: {
  cacheHandler?: string
  cacheMaxMemorySize: number
  fetchCacheKeyPrefix?: string
  distDir: string
  dir: string
  flushToDisk?: boolean
  requestHeaders?: Record<string, string | string[] | undefined>
  cacheHandlers?: Record<string, string | undefined>
}) {
  // Custom cache handler overrides.
  let CacheHandler: any
  if (cacheHandler) {
    CacheHandler = interopDefault(
      await import(formatDynamicImportPath(dir, cacheHandler)).then(
        (mod) => mod.default || mod
      )
    )
  }

Copyexport function createPrerenderWorkStore(context: WorkStoreContext): WorkStore {
  return createWorkStoreImpl(
    context,
    !!process.env.__NEXT_DEV_SERVER ||
      !!process.env.NEXT_DEBUG_BUILD ||
      process.env.NEXT_SSG_FETCH_METRICS === '1'
  )
}
 
function createWorkStoreImpl(
  {
    page,
    renderOpts,
    isPrefetchRequest,
    buildId,
    deploymentId,
    previouslyRevalidatedTags,
    nonce,
  }: WorkStoreContext,
  shouldTrackFetchMetrics: boolean
): WorkStore {
  const store: WorkStore = {
    page,
    route: normalizeAppPath(page),
    incrementalCache:
      // we fallback to a global incremental cache for edge-runtime locally
      // so that it can access the fs cache without mocks
      renderOpts.incrementalCache || (globalThis as any).__incrementalCache,

Copyif (nextConfig.output === 'export') {
  const routesManifest = require(join(distDir, ROUTES_MANIFEST))
 
  // We already prevent rewrites earlier in the process, however Next.js will insert rewrites
  // for interception routes so we need to check for that here.
  if (routesManifest?.rewrites?.beforeFiles?.length > 0) {
    const hasInterceptionRouteRewrite =
      routesManifest.rewrites.beforeFiles.some(isInterceptionRouteRewrite)
 
    if (hasInterceptionRouteRewrite) {
      throw new ExportError(
        `Intercepting routes are not supported with static export.\nRead more: https://nextjs.org/docs/app/building-your-application/deploying/static-exports#unsupported-features`
      )
    }
  }
 
  const actionIds = [
    ...Object.keys(serverActionsManifest.node),
    ...Object.keys(serverActionsManifest.edge),
  ]
 
  if (
    actionIds.some(
      (actionId) =>
        extractInfoFromServerReferenceId(actionId).type === 'server-action'
    )
  ) {
    throw new ExportError(
      `Server Actions are not supported with static export.\nRead more: https://nextjs.org/docs/app/building-your-application/deploying/static-exports#unsupported-features`
    )
  }

Copyif (config.i18n) {
  for (const locale of config.i18n.locales || []) {
    const localePage =
      page === '/' ? `/${locale}` : addPathPrefix(page, `/${locale}`)
 
    const localeOutput = {
      id: localePage,
      pathname: localePage,
      type: AdapterOutputType.STATIC_FILE,
      filePath: path.join(
        pagesDistDir,
        `${normalizePagePath(localePage)}.html`
      ),
      immutableHash: undefined,
    } satisfies AdapterOutput['STATIC_FILE']
 
    outputs.staticFiles.push(localeOutput)
    emittedStaticFilePathnames.add(localeOutput.pathname)
 
    if (appPageKeys && appPageKeys.length > 0) {
      outputs.staticFiles.push({
        id: `${localePage}.rsc`,
        pathname: `${localePage}.rsc`,
        type: AdapterOutputType.STATIC_FILE,
        filePath: rscFallbackPath,
        immutableHash: undefined,
      })
    }
  }
} else {
  const staticOutput = {
    id: page,
    pathname: route,
    type: AdapterOutputType.STATIC_FILE,
    filePath: pageFile.replace(/\.js$/, '.html'),
    immutableHash: undefined,
  } satisfies AdapterOutput['STATIC_FILE']
 
  outputs.staticFiles.push(staticOutput)
  emittedStaticFilePathnames.add(staticOutput.pathname)
 
  if (appPageKeys && appPageKeys.length > 0) {
    outputs.staticFiles.push({
      id: `${page}.rsc`,
      pathname: `${route}.rsc`,
      type: AdapterOutputType.STATIC_FILE,
      filePath: rscFallbackPath,
      immutableHash: undefined,
    })
  }
}