Pages Rendering

Copyexport class PagesRouteModule extends RouteModule<
  PagesRouteDefinition,
  PagesUserlandModule
> {
  private readonly components: PagesComponents
 
  constructor(options: PagesRouteModuleOptions) {
    super(options)
 
    this.components = options.components
  }
 
  public render(
    req: IncomingMessage,
    res: ServerResponse,
    context: PagesRouteHandlerContext
  ): Promise<RenderResult> {
    return renderToHTMLImpl(
      req,
      res,
      context.page,
      context.query,
      context.renderOpts,
      {
        App: this.components.App,
        Document: this.components.Document,
      },
      context.sharedContext,
      context.renderContext
    )
  }
}

Copy// Create and export the route module that will be consumed.
export const routeModule = new PagesRouteModule({
  definition: {
    kind: RouteKind.PAGES,
    page: 'VAR_DEFINITION_PAGE',
    pathname: 'VAR_DEFINITION_PATHNAME',
    // The following aren't used in production.
    bundlePath: '',
    filename: '',
  },
  distDir: process.env.__NEXT_RELATIVE_DIST_DIR || '',
  relativeProjectDir: process.env.__NEXT_RELATIVE_PROJECT_DIR || '',
  components: {
    // default export might not exist when optimized for data only
    App: app.default,
    Document: document.default,
  },
  userland,
})

Copy// Re-export the component (should be the default export).
export default hoist(userland, 'default')
 
// 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'
)

Copyconst BuiltinFunctionalDocument: DocumentType | undefined = (
  Document as any
)[NEXT_BUILTIN_DOCUMENT]
 
if (process.env.NEXT_RUNTIME === 'edge' && Document.getInitialProps) {
  // In the Edge runtime, `Document.getInitialProps` isn't supported.
  // We throw an error here if it's customized.
  if (BuiltinFunctionalDocument) {
    Document = BuiltinFunctionalDocument
  } else {
    throw new Error(
      '`getInitialProps` in Document component is not supported with the Edge Runtime.'
    )
  }
}

Copylet DocumentMod = {}
let AppMod = {}
if (!isAppPath) {
  ;[DocumentMod, AppMod] = await Promise.all([
    requirePage('/_document', distDir, false),
    requirePage('/_app', distDir, false),
  ])
}

Copyif (needsManifestsForLegacyReasons) {
  // In dev mode we retry loading a manifest file to handle a race condition
  // that can occur while app and pages are compiling at the same time, and the
  // build-manifest is still being written to disk while an app path is
  // attempting to load.
  const manifestLoadAttempts = isDev ? 3 : 1
 

Copyif (!process.env.TURBOPACK) {
  reactLoadableManifestPath = join(
    /* turbopackIgnore: true */ distDir,
    REACT_LOADABLE_MANIFEST
  )
} else if (isAppPath) {
  reactLoadableManifestPath = join(
    /* turbopackIgnore: true */ distDir,
    'server',
    'app',
    page,
    REACT_LOADABLE_MANIFEST
  )
} else {
  reactLoadableManifestPath = join(
    /* turbopackIgnore: true */ distDir,
    'server',
    'pages',
    normalizePagePath(page),
    REACT_LOADABLE_MANIFEST
  )
}

Copy// Make sure to avoid loading the manifest for static metadata routes for better performance.
const hasClientManifest = !isStaticMetadataRoute(page)
 

Copyexport type BuildManifest = {
  devFiles: readonly string[]
  polyfillFiles: readonly string[]
  lowPriorityFiles: readonly string[]
  rootMainFiles: readonly string[]
  // this is a separate field for flying shuttle to allow
  // different root main files per entries/build (ideally temporary)
  // until we can stitch the runtime chunks together safely
  rootMainFilesTree: { [appRoute: string]: readonly string[] }
  pages: {
    '/_app': readonly string[]
    [page: string]: readonly string[]
  }
  // Per-page Turbopack chunk-group bootstrap params, stored as raw JSON.
  pagesChunkGroupBootstrapParams?: { [page: string]: object }
  // The chunk-loading global the runtime drains (default "TURBOPACK").
  chunkLoadingGlobal?: string
}

Copyexport function getPageFiles(
  buildManifest: BuildManifest,
  page: string
): readonly string[] {
  const normalizedPage = denormalizePagePath(normalizePagePath(page))
  let files = buildManifest.pages[normalizedPage]
 
  if (!files) {
    console.warn(
      `Could not find files for ${normalizedPage} in .next/build-manifest.json`
    )
    return []
  }
 
  return files
}

Copy *  - `/` -> `/index`
 *  - `/index/foo` -> `/index/index/foo`
 *  - `/index` -> `/index/index`
 */
export function normalizePagePath(page: string): string {
  const normalized =
    /^\/index(\/|$)/.test(page) && !isDynamicRoute(page)
      ? `/index${page}`
      : page === '/'
        ? '/index'
        : ensureLeadingSlash(page)

Copy/**
 * Takes a page and transforms it into its file counterpart ensuring that the
 * output is normalized. Note this function is not idempotent because a page
 * `/index` can be referencing `/index/index.js` and `/index/index` could be
 * referencing `/index/index/index.js`. Examples:
 *  - `/` -> `/index`
 *  - `/index/foo` -> `/index/index/foo`
 *  - `/index` -> `/index/index`
 */

Copyexport async function loadGetInitialProps<
  C extends BaseContext,
  IP = {},
  P = {},
>(App: NextComponentType<C, IP, P>, ctx: C): Promise<IP> {
  if (process.env.NODE_ENV !== 'production') {
    if (App.prototype?.getInitialProps) {
      const message = `"${getDisplayName(
        App
      )}.getInitialProps()" is defined as an instance method - visit https://nextjs.org/docs/messages/get-initial-props-as-an-instance-method for more information.`
      throw new Error(message)
    }
  }
  // when called from _app `ctx` is nested in `ctx`
  const res = ctx.res || (ctx.ctx && ctx.ctx.res)
 
  if (!App.getInitialProps) {
    if (ctx.ctx && ctx.Component) {
      // @ts-ignore pageProps default
      return {
        pageProps: await loadGetInitialProps(ctx.Component, ctx.ctx),
      }
    }
    return {} as IP
  }
 
  const props = await App.getInitialProps(ctx)
 
  if (res && isResSent(res)) {
    return props
  }
 
  if (!props) {
    const message = `"${getDisplayName(
      App
    )}.getInitialProps()" should resolve to an object. But found "${props}" instead.`
    throw new Error(message)
  }
 
  if (process.env.NODE_ENV !== 'production') {
    if (Object.keys(props).length === 0 && !ctx.ctx) {
      console.warn(
        `${getDisplayName(
          App
        )} returned an empty object from \`getInitialProps\`. This de-optimizes and prevents automatic static optimization. https://nextjs.org/docs/messages/empty-object-getInitialProps`
      )
    }
  }
 
  return props
}

Copyif (process.env.NODE_ENV !== 'production') {
  if (App.prototype?.getInitialProps) {
    const message = `"${getDisplayName(
      App
    )}.getInitialProps()" is defined as an instance method - visit https://nextjs.org/docs/messages/get-initial-props-as-an-instance-method for more information.`
    throw new Error(message)
  }
}

Copyasync function appGetInitialProps({
  Component,
  ctx,
}: AppContext): Promise<AppInitialProps> {
  const pageProps = await loadGetInitialProps(Component, ctx)
  return { pageProps }
}

Copyif (process.env.NODE_ENV !== 'production') {
  if (App.prototype?.getInitialProps) {
    const message = `"${getDisplayName(
      App
    )}.getInitialProps()" is defined as an instance method - visit https://nextjs.org/docs/messages/get-initial-props-as-an-instance-method for more information.`
    throw new Error(message)
  }
}
// when called from _app `ctx` is nested in `ctx`
const res = ctx.res || (ctx.ctx && ctx.ctx.res)
 
if (!App.getInitialProps) {
  if (ctx.ctx && ctx.Component) {
    // @ts-ignore pageProps default
    return {
      pageProps: await loadGetInitialProps(ctx.Component, ctx.ctx),
    }
  }
  return {} as IP
}
 
const props = await App.getInitialProps(ctx)
 
if (res && isResSent(res)) {
  return props
}
 
if (!props) {
  const message = `"${getDisplayName(
    App
  )}.getInitialProps()" should resolve to an object. But found "${props}" instead.`
  throw new Error(message)
}
 
if (process.env.NODE_ENV !== 'production') {
  if (Object.keys(props).length === 0 && !ctx.ctx) {
    console.warn(
      `${getDisplayName(
        App
      )} returned an empty object from \`getInitialProps\`. This de-optimizes and prevents automatic static optimization. https://nextjs.org/docs/messages/empty-object-getInitialProps`
    )
  }
}
 

Copyconst renderContent = (_App: AppType, _Component: NextComponentType) => {
  const EnhancedApp = _App || App
  const EnhancedComponent = _Component || Component
 
  return ctx.err && ErrorDebug ? (
    <Body>
      <ErrorDebug />
    </Body>
  ) : (
    <Body>
      <AppContainerWithIsomorphicFiberStructure>
        {renderPageTree(EnhancedApp, EnhancedComponent, {
          ...props,
          router,
        })}
      </AppContainerWithIsomorphicFiberStructure>
    </Body>
  )
}

Copyexport default class App<P = any, CP = {}, S = {}> extends React.Component<
  P & AppProps<CP>,
  S
> {
  static origGetInitialProps = appGetInitialProps
  static getInitialProps = appGetInitialProps
 
  render() {
    const { Component, pageProps } = this.props as AppProps<CP>
 
    return <Component {...pageProps} />
  }

Copyif (
  process.env.__NEXT_DEV_SERVER &&
  (props.router || props.Component)
) {
  throw new Error(
    `'router' and 'Component' can not be returned in getInitialProps from _app.js https://nextjs.org/docs/messages/cant-override-next-props`
  )
}

Copyconst BuiltinFunctionalDocument: DocumentType | undefined = (
  Document as any
)[NEXT_BUILTIN_DOCUMENT]
 
if (process.env.NEXT_RUNTIME === 'edge' && Document.getInitialProps) {
  // In the Edge runtime, `Document.getInitialProps` isn't supported.
  // We throw an error here if it's customized.
  if (BuiltinFunctionalDocument) {
    Document = BuiltinFunctionalDocument
  } else {
    throw new Error(
      '`getInitialProps` in Document component is not supported with the Edge Runtime.'
    )
  }
}

Copyconst hasDocumentGetInitialProps =
  process.env.NEXT_RUNTIME !== 'edge' && !!Document.getInitialProps
 

Copyif (process.env.NEXT_RUNTIME === 'edge' && Document.getInitialProps) {
  // In the Edge runtime, `Document.getInitialProps` isn't supported.
  // We throw an error here if it's customized.
  if (BuiltinFunctionalDocument) {
    Document = BuiltinFunctionalDocument
  } else {
    throw new Error(
      '`getInitialProps` in Document component is not supported with the Edge Runtime.'
    )
  }

Copyexport function Html(
  props: React.DetailedHTMLProps<
    React.HtmlHTMLAttributes<HTMLHtmlElement>,
    HTMLHtmlElement
  >
) {
  const {
    docComponentsRendered,
    locale,
    scriptLoader,
    deploymentId,
    __NEXT_DATA__,
  } = useHtmlContext()
 
  docComponentsRendered.Html = true
  handleDocumentScriptLoaderItems(scriptLoader, __NEXT_DATA__, props)
 
  return (
    <html
      {...props}
      lang={props.lang || locale || undefined}
      data-dpl-id={deploymentId || undefined}
    />
  )
}
 
export function Main() {
  const { docComponentsRendered } = useHtmlContext()
  docComponentsRendered.Main = true
  // @ts-ignore
  return <next-js-internal-body-render-target />
}

Copyfunction getDocumentFiles(
  buildManifest: BuildManifest,
  pathname: string
): DocumentFiles {
  const sharedFiles: readonly string[] = getPageFiles(buildManifest, '/_app')
  const pageFiles: readonly string[] = getPageFiles(buildManifest, pathname)
 
  return {
    sharedFiles,
    pageFiles,
    allFiles: [...new Set([...sharedFiles, ...pageFiles])],
  }
}
 
function getPolyfillScripts(context: HtmlProps, props: OriginProps) {
  // polyfills.js has to be rendered as nomodule without async
  // It also has to be the first script to load
  const {
    assetPrefix,
    buildManifest,
    assetQueryString,
    disableOptimizedLoading,
    crossOrigin,
  } = context
 
  return buildManifest.polyfillFiles
    .filter(
      (polyfill) => polyfill.endsWith('.js') && !polyfill.endsWith('.module.js')
    )
    .map((polyfill) => (
      <script
        key={polyfill}
        defer={!disableOptimizedLoading}
        nonce={props.nonce}
        crossOrigin={props.crossOrigin || crossOrigin}
        noModule={true}
        src={`${assetPrefix}/_next/${encodeURIPath(
          polyfill
        )}${assetQueryString}`}
      />
    ))
}

Copyfunction getScripts(
  context: HtmlProps,
  props: OriginProps,
  files: DocumentFiles
) {
  const {
    assetPrefix,
    buildManifest,
    isDevelopment,
    assetQueryString,
    mutableAssetQueryString,
    disableOptimizedLoading,
    crossOrigin,
  } = context
 
  const normalScripts = files.allFiles.filter((file) => file.endsWith('.js'))
  const lowPriorityScripts = buildManifest.lowPriorityFiles?.filter((file) =>
    file.endsWith('.js')
  )
 
  const scripts = [...normalScripts, ...lowPriorityScripts].map((file) => {
    // static/immutable/chunks/51e975e7b637a580.js should use the immutable id, while
    // static/Yj152X97rfGgF7NPcJEZs/_ssgManifest.js should use the deployment id
    const query = file.startsWith('static/immutable/chunks')
      ? assetQueryString
      : mutableAssetQueryString
    return (
      <script
        key={file}
        src={`${assetPrefix}/_next/${encodeURIPath(file)}${query}`}
        nonce={props.nonce}
        async={!isDevelopment && disableOptimizedLoading}
        defer={!disableOptimizedLoading}
        crossOrigin={props.crossOrigin || crossOrigin}
      />
    )
  })

Copyfunction getInlineBootstrapScript(context: HtmlProps, props: OriginProps) {
  const { buildManifest, __NEXT_DATA__, crossOrigin } = context
  // Only Turbopack production builds populate these; nothing to inline otherwise.
  if (
    !buildManifest.pagesChunkGroupBootstrapParams ||
    !buildManifest.chunkLoadingGlobal
  ) {
    return null
  }
  const bootstrap = getTurbopackChunkGroupBootstrap(
    buildManifest.pagesChunkGroupBootstrapParams,
    buildManifest.chunkLoadingGlobal,
    ['/_app', __NEXT_DATA__.page]
  )
  if (!bootstrap) return null
 
  const html = htmlEscapeJsonString(bootstrap)
  return (
    <script
      key="turbopack-bootstrap"
      nonce={props.nonce}
      crossOrigin={props.crossOrigin || crossOrigin}
      dangerouslySetInnerHTML={{ __html: html }}
    />
  )
}

Copyexport function getTurbopackChunkGroupBootstrap(
  paramsByPage: { [page: string]: object },
  chunkLoadingGlobal: string,
  pages: readonly string[]
): string | undefined {
  const g = JSON.stringify(chunkLoadingGlobal)
  const statements = pages
    .map((page) => paramsByPage[page])
    .filter(Boolean)
    .map(
      (params) =>
        `(globalThis[${g}] || (globalThis[${g}] = [])).push(${JSON.stringify(
          params
        )});`
    )
 
  return statements.length > 0 ? statements.join('\n') : undefined
}

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
}

Copyif (components.getServerSideProps) {
  throw new Error(`Error for page ${page}: ${SERVER_PROPS_EXPORT_ERROR}`)
}

Copyconst searchAndDynamicParams = {
  ...query,
  ...params,
}

Copyif (renderOpts.optimizeCss) {
  process.env.__NEXT_OPTIMIZE_CSS = JSON.stringify(true)
}

Copyconst ssgNotFound = renderResult?.metadata.isNotFound
 
const html =
  renderResult && !renderResult.isNull ? renderResult.toUnchunkedString() : ''
 
const metadata = renderResult?.metadata || {}
if (metadata.pageData && !ssgNotFound) {
  const dataFile = join(
    pagesDataDir,
    htmlFilename.replace(/\.html$/, NEXT_DATA_SUFFIX)
  )
 
  fileWriter.append(dataFile, JSON.stringify(metadata.pageData))
}

Copyif (!ssgNotFound) {
  // don't attempt writing to disk if getStaticProps returned not found
  fileWriter.append(htmlFilepath, html)
  if (routeCache) {
    fileWriter.append(
      htmlFilepath.replace(/\.html$/, '.meta'),
      JSON.stringify({ routeCache })
    )
  }
}