Unverified Commit cd7fa800 authored by Josh Story's avatar Josh Story Committed by GitHub

Resolve metadata independently across parallel routes (#97345)

## Motivation

Parallel routes are separate rendering branches, but the existing
metadata resolver collects every matched slot into one shared chain. As
a result, traversal order can decide which slot supplies the document
head, and metadata errors from one slot can interfere with another.

## What this does

This adds a fork-aware resolver behind
`experimental.parallelRouteMetadata` while retaining the existing
resolver as the default. Each slot resolves metadata and viewport
independently, with isolated accumulators, and a single branch is
selected for the document head at every fork.

The built-in selector prefers real routes over implicit fallbacks and
prefers `children` when it contributes head data. Otherwise it chooses
the branch with the deepest head definition, using route depth and
lexical slot order only as stable tie-breakers.

Head selection is separate from rendering outcomes. Every slot gets its
own `MetadataOutlet`, which replays navigation and regular errors for
that slot regardless of which branch supplied the head.

## Review notes

- `generateMetadata`, `generateViewport`, and generated static metadata
still start eagerly; a fork does not serialize sibling branches or
parent/child generation.
- Branch state is isolated only where the tree forks, preventing
metadata mutation from crossing between slots.
- An outlet rejects as soon as either metadata or viewport rejects, but
resolves only after both succeed. This lets one failing result reach the
slot boundary even if the other never settles.
- Existing navigation convention metadata is preserved for the selected
branch. Errors from unselected branches remain observable only through
their own rendered outlets.
- The old resolver remains available behind an explicit flag so this
implementation can be compared or disabled during rollout.

## Verification

- `pnpm --filter=next types`
- Metadata resolver unit coverage
- Parallel-route metadata, navigation, and not-found coverage in
development and production with Turbopack and webpack

<!-- NEXT_JS_LLM -->
parent 2aaa6e81
......@@ -169,6 +169,9 @@ export function getDefineEnv({
'process.env.__NEXT_APP_NAV_FAIL_HANDLING': Boolean(
config.experimental.appNavFailHandling
),
'process.env.__NEXT_PARALLEL_ROUTE_METADATA': Boolean(
config.experimental.parallelRouteMetadata
),
'process.env.__NEXT_TURBOPACK_SHARED_RUNTIME': Boolean(
config.experimental.turbopackSharedRuntime
),
......
......@@ -937,6 +937,9 @@ export function createAppPageEntrypoint({
optimisticRouting: Boolean(
nextConfig.experimental.optimisticRouting
),
parallelRouteMetadata: Boolean(
nextConfig.experimental.parallelRouteMetadata
),
inlineCss: Boolean(nextConfig.experimental.inlineCss),
prefetchInlining:
nextConfig.experimental.prefetchInlining ?? false,
......
......@@ -170,6 +170,9 @@ async function requestHandler(
staleTimes: nextConfig.experimental.staleTimes,
dynamicOnHover: Boolean(nextConfig.experimental.dynamicOnHover),
optimisticRouting: Boolean(nextConfig.experimental.optimisticRouting),
parallelRouteMetadata: Boolean(
nextConfig.experimental.parallelRouteMetadata
),
inlineCss: Boolean(nextConfig.experimental.inlineCss),
prefetchInlining: nextConfig.experimental.prefetchInlining ?? false,
authInterrupts: Boolean(nextConfig.experimental.authInterrupts),
......
......@@ -520,6 +520,8 @@ async function exportAppImpl(
nextConfig.experimental.clientParamParsingOrigins,
dynamicOnHover: nextConfig.experimental.dynamicOnHover ?? false,
optimisticRouting: nextConfig.experimental.optimisticRouting ?? false,
parallelRouteMetadata:
nextConfig.experimental.parallelRouteMetadata ?? false,
inlineCss: nextConfig.experimental.inlineCss ?? false,
prefetchInlining: nextConfig.experimental.prefetchInlining ?? false,
authInterrupts: !!nextConfig.experimental.authInterrupts,
......
type CreateMetadataComponents =
typeof import('./metadata').createMetadataComponents
let createMetadataComponentsImpl: CreateMetadataComponents
if (process.env.__NEXT_PARALLEL_ROUTE_METADATA) {
createMetadataComponentsImpl = (
require('./metadata-parallel') as typeof import('./metadata-parallel')
).createMetadataComponents
} else {
createMetadataComponentsImpl = (
require('./metadata') as typeof import('./metadata')
).createMetadataComponents
}
export { createMetadataComponentsImpl as createMetadataComponents }
import React from 'react'
import type { SelectedMetadata } from './metadata-resolution-primitives'
import type { ResolvedViewport } from './types/metadata-interface'
import { getOrigin } from './generate/utils'
import { IconMark } from './generate/icon-mark'
// ---------------------------------------------------------------------------
// Viewport tag rendering
// ---------------------------------------------------------------------------
export function createViewportElements(
viewport: ResolvedViewport
): React.ReactElement[] {
const tags: React.ReactElement[] = []
let i = 0
tags.push(<meta key={i++} charSet="utf-8" />)
// Build viewport content string from layout properties
const viewportParts: string[] = []
if (viewport.width != null) {
viewportParts.push(`width=${viewport.width}`)
}
if (viewport.height != null) {
viewportParts.push(`height=${viewport.height}`)
}
if (viewport.initialScale != null) {
viewportParts.push(`initial-scale=${viewport.initialScale}`)
}
if (viewport.minimumScale != null) {
viewportParts.push(`minimum-scale=${viewport.minimumScale}`)
}
if (viewport.maximumScale != null) {
viewportParts.push(`maximum-scale=${viewport.maximumScale}`)
}
if (viewport.userScalable != null) {
viewportParts.push(`user-scalable=${viewport.userScalable ? 'yes' : 'no'}`)
}
if (viewport.viewportFit) {
viewportParts.push(`viewport-fit=${viewport.viewportFit}`)
}
if (viewport.interactiveWidget) {
viewportParts.push(`interactive-widget=${viewport.interactiveWidget}`)
}
if (viewportParts.length) {
tags.push(
<meta key={i++} name="viewport" content={viewportParts.join(', ')} />
)
}
if (viewport.themeColor) {
for (const themeColor of viewport.themeColor) {
if (themeColor.media) {
tags.push(
<meta
key={i++}
name="theme-color"
content={themeColor.color}
media={themeColor.media}
/>
)
} else {
tags.push(
<meta key={i++} name="theme-color" content={themeColor.color} />
)
}
}
}
if (viewport.colorScheme) {
tags.push(
<meta key={i++} name="color-scheme" content={viewport.colorScheme} />
)
}
return tags
}
// ---------------------------------------------------------------------------
// Metadata tag rendering
// ---------------------------------------------------------------------------
export function createMetadataElements(
metadata: SelectedMetadata
): React.ReactElement[] {
const tags: React.ReactElement[] = []
let i = 0
// --- Title ---
if (metadata.title) {
tags.push(<title key={i++}>{metadata.title}</title>)
}
// --- Basic meta tags ---
if (metadata.description) {
tags.push(
<meta key={i++} name="description" content={metadata.description} />
)
}
if (metadata.applicationName) {
tags.push(
<meta
key={i++}
name="application-name"
content={metadata.applicationName}
/>
)
}
// --- Authors ---
if (metadata.authors) {
for (const author of metadata.authors) {
if (author.url) {
tags.push(<link key={i++} rel="author" href={author.url.toString()} />)
}
if (author.name) {
tags.push(<meta key={i++} name="author" content={author.name} />)
}
}
}
// --- Manifest ---
if (metadata.manifest) {
const manifestOrigin = getOrigin(metadata.manifest)
tags.push(
<link
key={i++}
rel="manifest"
href={metadata.manifest.toString()}
crossOrigin={
!manifestOrigin && process.env.VERCEL_ENV === 'preview'
? 'use-credentials'
: undefined
}
/>
)
}
if (metadata.generator) {
tags.push(<meta key={i++} name="generator" content={metadata.generator} />)
}
if (metadata.keywords && metadata.keywords.length) {
tags.push(
<meta key={i++} name="keywords" content={metadata.keywords.join(',')} />
)
}
if (metadata.referrer) {
tags.push(<meta key={i++} name="referrer" content={metadata.referrer} />)
}
if (metadata.creator) {
tags.push(<meta key={i++} name="creator" content={metadata.creator} />)
}
if (metadata.publisher) {
tags.push(<meta key={i++} name="publisher" content={metadata.publisher} />)
}
if (metadata.robots?.basic) {
tags.push(<meta key={i++} name="robots" content={metadata.robots.basic} />)
}
if (metadata.robots?.googleBot) {
tags.push(
<meta key={i++} name="googlebot" content={metadata.robots.googleBot} />
)
}
if (metadata.abstract) {
tags.push(<meta key={i++} name="abstract" content={metadata.abstract} />)
}
// --- Link rel arrays ---
if (metadata.archives) {
for (const archive of metadata.archives) {
tags.push(<link key={i++} rel="archives" href={archive} />)
}
}
if (metadata.assets) {
for (const asset of metadata.assets) {
tags.push(<link key={i++} rel="assets" href={asset} />)
}
}
if (metadata.bookmarks) {
for (const bookmark of metadata.bookmarks) {
tags.push(<link key={i++} rel="bookmarks" href={bookmark} />)
}
}
// --- Pagination ---
if (metadata.pagination) {
if (metadata.pagination.previous) {
tags.push(
<link key={i++} rel="prev" href={metadata.pagination.previous} />
)
}
if (metadata.pagination.next) {
tags.push(<link key={i++} rel="next" href={metadata.pagination.next} />)
}
}
if (metadata.category) {
tags.push(<meta key={i++} name="category" content={metadata.category} />)
}
if (metadata.classification) {
tags.push(
<meta key={i++} name="classification" content={metadata.classification} />
)
}
// --- Other (arbitrary name/value pairs) ---
if (metadata.other) {
for (const [name, content] of Object.entries(metadata.other)) {
if (Array.isArray(content)) {
for (const contentItem of content) {
if (contentItem != null && contentItem !== '') {
tags.push(
<meta key={i++} name={name} content={String(contentItem)} />
)
}
}
} else if (content != null && content !== '') {
tags.push(<meta key={i++} name={name} content={String(content)} />)
}
}
}
// --- Alternates ---
if (metadata.alternates) {
const { canonical, languages, media, types } = metadata.alternates
if (canonical && canonical.url) {
tags.push(
<link
key={i++}
rel="canonical"
href={canonical.url.toString()}
{...(canonical.title ? { title: canonical.title } : undefined)}
/>
)
}
if (languages) {
for (const [locale, descriptors] of Object.entries(languages)) {
if (descriptors) {
for (const descriptor of descriptors) {
if (descriptor.url) {
tags.push(
<link
key={i++}
rel="alternate"
hrefLang={locale}
href={descriptor.url.toString()}
{...(descriptor.title
? { title: descriptor.title }
: undefined)}
/>
)
}
}
}
}
}
if (media) {
for (const [mediaName, descriptors] of Object.entries(media)) {
if (descriptors) {
for (const descriptor of descriptors) {
if (descriptor.url) {
tags.push(
<link
key={i++}
rel="alternate"
media={mediaName}
href={descriptor.url.toString()}
{...(descriptor.title
? { title: descriptor.title }
: undefined)}
/>
)
}
}
}
}
}
if (types) {
for (const [type, descriptors] of Object.entries(types)) {
if (descriptors) {
for (const descriptor of descriptors) {
if (descriptor.url) {
tags.push(
<link
key={i++}
rel="alternate"
type={type}
href={descriptor.url.toString()}
{...(descriptor.title
? { title: descriptor.title }
: undefined)}
/>
)
}
}
}
}
}
}
// --- iTunes ---
if (metadata.itunes) {
const { appId, appArgument } = metadata.itunes
let itunesContent = `app-id=${appId}`
if (appArgument) {
itunesContent += `, app-argument=${appArgument}`
}
tags.push(
<meta key={i++} name="apple-itunes-app" content={itunesContent} />
)
}
// --- Facebook ---
if (metadata.facebook) {
if (metadata.facebook.appId) {
tags.push(
<meta
key={i++}
property="fb:app_id"
content={metadata.facebook.appId}
/>
)
}
if (metadata.facebook.admins) {
for (const admin of metadata.facebook.admins) {
tags.push(<meta key={i++} property="fb:admins" content={admin} />)
}
}
}
// --- Pinterest ---
if (metadata.pinterest && metadata.pinterest.richPin !== undefined) {
tags.push(
<meta
key={i++}
property="pinterest-rich-pin"
content={metadata.pinterest.richPin.toString()}
/>
)
}
// --- Format Detection ---
if (metadata.formatDetection) {
const formatDetectionKeys = [
'telephone',
'date',
'address',
'email',
'url',
] as const
let formatContent = ''
for (const key of formatDetectionKeys) {
if (metadata.formatDetection[key] === false) {
if (formatContent) formatContent += ', '
formatContent += `${key}=no`
}
}
if (formatContent) {
tags.push(
<meta key={i++} name="format-detection" content={formatContent} />
)
}
}
// --- Verification ---
if (metadata.verification) {
const verification = metadata.verification
if (verification.google) {
for (const value of verification.google) {
if (value != null && value !== '') {
tags.push(
<meta
key={i++}
name="google-site-verification"
content={String(value)}
/>
)
}
}
}
if (verification.yahoo) {
for (const value of verification.yahoo) {
if (value != null && value !== '') {
tags.push(<meta key={i++} name="y_key" content={String(value)} />)
}
}
}
if (verification.yandex) {
for (const value of verification.yandex) {
if (value != null && value !== '') {
tags.push(
<meta
key={i++}
name="yandex-verification"
content={String(value)}
/>
)
}
}
}
if (verification.me) {
for (const value of verification.me) {
if (value != null && value !== '') {
tags.push(<meta key={i++} name="me" content={String(value)} />)
}
}
}
if (verification.other) {
for (const [name, values] of Object.entries(verification.other)) {
for (const value of values) {
if (value != null && value !== '') {
tags.push(<meta key={i++} name={name} content={String(value)} />)
}
}
}
}
}
// --- Apple Web App ---
if (metadata.appleWebApp) {
const { capable, title, startupImage, statusBarStyle } =
metadata.appleWebApp
if (capable) {
tags.push(<meta key={i++} name="mobile-web-app-capable" content="yes" />)
}
if (title) {
tags.push(
<meta key={i++} name="apple-mobile-web-app-title" content={title} />
)
}
if (startupImage) {
for (const image of startupImage) {
if (image.media) {
tags.push(
<link
key={i++}
href={image.url}
media={image.media}
rel="apple-touch-startup-image"
/>
)
} else {
tags.push(
<link key={i++} href={image.url} rel="apple-touch-startup-image" />
)
}
}
}
if (statusBarStyle) {
tags.push(
<meta
key={i++}
name="apple-mobile-web-app-status-bar-style"
content={statusBarStyle}
/>
)
}
}
// --- Open Graph ---
if (metadata.openGraph) {
const og = metadata.openGraph
if (og.determiner) {
tags.push(
<meta key={i++} property="og:determiner" content={og.determiner} />
)
}
if (og.title) {
tags.push(<meta key={i++} property="og:title" content={og.title} />)
}
if (og.description) {
tags.push(
<meta key={i++} property="og:description" content={og.description} />
)
}
if (og.url) {
tags.push(
<meta key={i++} property="og:url" content={og.url.toString()} />
)
}
if (og.siteName) {
tags.push(
<meta key={i++} property="og:site_name" content={og.siteName} />
)
}
if (og.locale) {
tags.push(<meta key={i++} property="og:locale" content={og.locale} />)
}
if (og.countryName) {
tags.push(
<meta key={i++} property="og:country_name" content={og.countryName} />
)
}
if (og.ttl != null) {
tags.push(
<meta key={i++} property="og:ttl" content={og.ttl.toString()} />
)
}
// OG images
if (og.images) {
for (const image of og.images) {
if (typeof image === 'string') {
tags.push(<meta key={i++} property="og:image" content={image} />)
} else {
if (image.url) {
tags.push(
<meta key={i++} property="og:image" content={String(image.url)} />
)
}
if (image.secureUrl) {
tags.push(
<meta
key={i++}
property="og:image:secure_url"
content={String(image.secureUrl)}
/>
)
}
if (image.type) {
tags.push(
<meta key={i++} property="og:image:type" content={image.type} />
)
}
if (image.width) {
tags.push(
<meta
key={i++}
property="og:image:width"
content={String(image.width)}
/>
)
}
if (image.height) {
tags.push(
<meta
key={i++}
property="og:image:height"
content={String(image.height)}
/>
)
}
if (image.alt) {
tags.push(
<meta key={i++} property="og:image:alt" content={image.alt} />
)
}
}
}
}
// OG videos
if (og.videos) {
for (const video of og.videos) {
if (typeof video === 'string') {
tags.push(<meta key={i++} property="og:video" content={video} />)
} else {
if (video.url) {
tags.push(
<meta key={i++} property="og:video" content={String(video.url)} />
)
}
if (video.secureUrl) {
tags.push(
<meta
key={i++}
property="og:video:secure_url"
content={String(video.secureUrl)}
/>
)
}
if (video.type) {
tags.push(
<meta key={i++} property="og:video:type" content={video.type} />
)
}
if (video.width) {
tags.push(
<meta
key={i++}
property="og:video:width"
content={String(video.width)}
/>
)
}
if (video.height) {
tags.push(
<meta
key={i++}
property="og:video:height"
content={String(video.height)}
/>
)
}
}
}
}
// OG audio
if (og.audio) {
for (const audio of og.audio) {
if (typeof audio === 'string') {
tags.push(<meta key={i++} property="og:audio" content={audio} />)
} else {
if (audio.url) {
tags.push(
<meta key={i++} property="og:audio" content={String(audio.url)} />
)
}
if (audio.secureUrl) {
tags.push(
<meta
key={i++}
property="og:audio:secure_url"
content={String(audio.secureUrl)}
/>
)
}
if (audio.type) {
tags.push(
<meta key={i++} property="og:audio:type" content={audio.type} />
)
}
}
}
}
// OG simple array properties
if (og.emails) {
for (const email of og.emails) {
tags.push(<meta key={i++} property="og:email" content={email} />)
}
}
if (og.phoneNumbers) {
for (const phone of og.phoneNumbers) {
tags.push(<meta key={i++} property="og:phone_number" content={phone} />)
}
}
if (og.faxNumbers) {
for (const fax of og.faxNumbers) {
tags.push(<meta key={i++} property="og:fax_number" content={fax} />)
}
}
if (og.alternateLocale) {
for (const locale of og.alternateLocale) {
tags.push(
<meta key={i++} property="og:locale:alternate" content={locale} />
)
}
}
// OG type-specific tags
if ('type' in og) {
const ogType = og.type
switch (ogType) {
case 'website':
tags.push(<meta key={i++} property="og:type" content="website" />)
break
case 'article':
tags.push(<meta key={i++} property="og:type" content="article" />)
if (og.publishedTime) {
tags.push(
<meta
key={i++}
property="article:published_time"
content={og.publishedTime.toString()}
/>
)
}
if (og.modifiedTime) {
tags.push(
<meta
key={i++}
property="article:modified_time"
content={og.modifiedTime.toString()}
/>
)
}
if (og.expirationTime) {
tags.push(
<meta
key={i++}
property="article:expiration_time"
content={og.expirationTime.toString()}
/>
)
}
if (og.authors) {
for (const author of og.authors) {
tags.push(
<meta
key={i++}
property="article:author"
content={String(author)}
/>
)
}
}
if (og.section) {
tags.push(
<meta key={i++} property="article:section" content={og.section} />
)
}
if (og.tags) {
for (const tag of og.tags) {
tags.push(<meta key={i++} property="article:tag" content={tag} />)
}
}
break
case 'book':
tags.push(<meta key={i++} property="og:type" content="book" />)
if (og.isbn) {
tags.push(<meta key={i++} property="book:isbn" content={og.isbn} />)
}
if (og.releaseDate) {
tags.push(
<meta
key={i++}
property="book:release_date"
content={og.releaseDate}
/>
)
}
if (og.authors) {
for (const author of og.authors) {
tags.push(
<meta
key={i++}
property="book:author"
content={String(author)}
/>
)
}
}
if (og.tags) {
for (const tag of og.tags) {
tags.push(<meta key={i++} property="book:tag" content={tag} />)
}
}
break
case 'profile':
tags.push(<meta key={i++} property="og:type" content="profile" />)
if (og.firstName) {
tags.push(
<meta
key={i++}
property="profile:first_name"
content={og.firstName}
/>
)
}
if (og.lastName) {
tags.push(
<meta
key={i++}
property="profile:last_name"
content={og.lastName}
/>
)
}
if (og.username) {
tags.push(
<meta
key={i++}
property="profile:username"
content={og.username}
/>
)
}
if (og.gender) {
tags.push(
<meta key={i++} property="profile:gender" content={og.gender} />
)
}
break
case 'music.song':
tags.push(<meta key={i++} property="og:type" content="music.song" />)
if (og.duration != null) {
tags.push(
<meta
key={i++}
property="music:duration"
content={og.duration.toString()}
/>
)
}
if (og.albums) {
for (const album of og.albums) {
if (typeof album === 'string') {
tags.push(
<meta key={i++} property="music:album" content={album} />
)
} else {
if (album.url) {
tags.push(
<meta
key={i++}
property="music:album"
content={String(album.url)}
/>
)
}
if (album.disc != null) {
tags.push(
<meta
key={i++}
property="music:album:disc"
content={String(album.disc)}
/>
)
}
if (album.track != null) {
tags.push(
<meta
key={i++}
property="music:album:track"
content={String(album.track)}
/>
)
}
}
}
}
if (og.musicians) {
for (const musician of og.musicians) {
tags.push(
<meta
key={i++}
property="music:musician"
content={String(musician)}
/>
)
}
}
break
case 'music.album':
tags.push(<meta key={i++} property="og:type" content="music.album" />)
if (og.songs) {
for (const song of og.songs) {
if (typeof song === 'string') {
tags.push(
<meta key={i++} property="music:song" content={song} />
)
} else {
if (song.url) {
tags.push(
<meta
key={i++}
property="music:song"
content={String(song.url)}
/>
)
}
if (song.disc != null) {
tags.push(
<meta
key={i++}
property="music:song:disc"
content={String(song.disc)}
/>
)
}
if (song.track != null) {
tags.push(
<meta
key={i++}
property="music:song:track"
content={String(song.track)}
/>
)
}
}
}
}
if (og.musicians) {
for (const musician of og.musicians) {
tags.push(
<meta
key={i++}
property="music:musician"
content={String(musician)}
/>
)
}
}
if (og.releaseDate) {
tags.push(
<meta
key={i++}
property="music:release_date"
content={og.releaseDate}
/>
)
}
break
case 'music.playlist':
tags.push(
<meta key={i++} property="og:type" content="music.playlist" />
)
if (og.songs) {
for (const song of og.songs) {
if (typeof song === 'string') {
tags.push(
<meta key={i++} property="music:song" content={song} />
)
} else {
if (song.url) {
tags.push(
<meta
key={i++}
property="music:song"
content={String(song.url)}
/>
)
}
if (song.disc != null) {
tags.push(
<meta
key={i++}
property="music:song:disc"
content={String(song.disc)}
/>
)
}
if (song.track != null) {
tags.push(
<meta
key={i++}
property="music:song:track"
content={String(song.track)}
/>
)
}
}
}
}
if (og.creators) {
for (const creator of og.creators) {
tags.push(
<meta
key={i++}
property="music:creator"
content={String(creator)}
/>
)
}
}
break
case 'music.radio_station':
tags.push(
<meta key={i++} property="og:type" content="music.radio_station" />
)
if (og.creators) {
for (const creator of og.creators) {
tags.push(
<meta
key={i++}
property="music:creator"
content={String(creator)}
/>
)
}
}
break
case 'video.movie':
tags.push(<meta key={i++} property="og:type" content="video.movie" />)
if (og.actors) {
for (const actor of og.actors) {
if (typeof actor === 'string') {
tags.push(
<meta key={i++} property="video:actor" content={actor} />
)
} else {
if (actor.url) {
tags.push(
<meta
key={i++}
property="video:actor"
content={String(actor.url)}
/>
)
}
if (actor.role) {
tags.push(
<meta
key={i++}
property="video:actor:role"
content={actor.role}
/>
)
}
}
}
}
if (og.directors) {
for (const director of og.directors) {
tags.push(
<meta
key={i++}
property="video:director"
content={String(director)}
/>
)
}
}
if (og.writers) {
for (const writer of og.writers) {
tags.push(
<meta
key={i++}
property="video:writer"
content={String(writer)}
/>
)
}
}
if (og.duration != null) {
tags.push(
<meta
key={i++}
property="video:duration"
content={String(og.duration)}
/>
)
}
if (og.releaseDate) {
tags.push(
<meta
key={i++}
property="video:release_date"
content={og.releaseDate}
/>
)
}
if (og.tags) {
for (const tag of og.tags) {
tags.push(<meta key={i++} property="video:tag" content={tag} />)
}
}
break
case 'video.episode':
tags.push(
<meta key={i++} property="og:type" content="video.episode" />
)
if (og.actors) {
for (const actor of og.actors) {
if (typeof actor === 'string') {
tags.push(
<meta key={i++} property="video:actor" content={actor} />
)
} else {
if (actor.url) {
tags.push(
<meta
key={i++}
property="video:actor"
content={String(actor.url)}
/>
)
}
if (actor.role) {
tags.push(
<meta
key={i++}
property="video:actor:role"
content={actor.role}
/>
)
}
}
}
}
if (og.directors) {
for (const director of og.directors) {
tags.push(
<meta
key={i++}
property="video:director"
content={String(director)}
/>
)
}
}
if (og.writers) {
for (const writer of og.writers) {
tags.push(
<meta
key={i++}
property="video:writer"
content={String(writer)}
/>
)
}
}
if (og.duration != null) {
tags.push(
<meta
key={i++}
property="video:duration"
content={String(og.duration)}
/>
)
}
if (og.releaseDate) {
tags.push(
<meta
key={i++}
property="video:release_date"
content={og.releaseDate}
/>
)
}
if (og.tags) {
for (const tag of og.tags) {
tags.push(<meta key={i++} property="video:tag" content={tag} />)
}
}
if (og.series) {
tags.push(
<meta
key={i++}
property="video:series"
content={String(og.series)}
/>
)
}
break
case 'video.tv_show':
tags.push(
<meta key={i++} property="og:type" content="video.tv_show" />
)
break
case 'video.other':
tags.push(<meta key={i++} property="og:type" content="video.other" />)
break
default:
const _exhaustiveCheck: never = ogType
throw new Error(`Invalid OpenGraph type: ${_exhaustiveCheck}`)
}
}
}
// --- Twitter ---
if (metadata.twitter) {
const tw = metadata.twitter
const { card } = tw
if (card) {
tags.push(<meta key={i++} name="twitter:card" content={card} />)
}
if (tw.site) {
tags.push(<meta key={i++} name="twitter:site" content={tw.site} />)
}
if (tw.siteId) {
tags.push(<meta key={i++} name="twitter:site:id" content={tw.siteId} />)
}
if (tw.creator) {
tags.push(<meta key={i++} name="twitter:creator" content={tw.creator} />)
}
if (tw.creatorId) {
tags.push(
<meta key={i++} name="twitter:creator:id" content={tw.creatorId} />
)
}
if (tw.title) {
tags.push(<meta key={i++} name="twitter:title" content={tw.title} />)
}
if (tw.description) {
tags.push(
<meta key={i++} name="twitter:description" content={tw.description} />
)
}
// Twitter images
if (tw.images) {
for (const image of tw.images) {
if (typeof image === 'string') {
tags.push(<meta key={i++} name="twitter:image" content={image} />)
} else {
if (image.url) {
tags.push(
<meta
key={i++}
name="twitter:image"
content={String(image.url)}
/>
)
}
if (image.alt) {
tags.push(
<meta key={i++} name="twitter:image:alt" content={image.alt} />
)
}
if (image.secureUrl) {
tags.push(
<meta
key={i++}
name="twitter:image:secure_url"
content={String(image.secureUrl)}
/>
)
}
if (image.type) {
tags.push(
<meta key={i++} name="twitter:image:type" content={image.type} />
)
}
if (image.width) {
tags.push(
<meta
key={i++}
name="twitter:image:width"
content={String(image.width)}
/>
)
}
if (image.height) {
tags.push(
<meta
key={i++}
name="twitter:image:height"
content={String(image.height)}
/>
)
}
}
}
}
// Twitter player cards
if (card === 'player') {
for (const player of tw.players) {
tags.push(
<meta
key={i++}
name="twitter:player"
content={player.playerUrl.toString()}
/>
)
tags.push(
<meta
key={i++}
name="twitter:player:stream"
content={player.streamUrl.toString()}
/>
)
tags.push(
<meta
key={i++}
name="twitter:player:width"
content={String(player.width)}
/>
)
tags.push(
<meta
key={i++}
name="twitter:player:height"
content={String(player.height)}
/>
)
}
}
// Twitter app cards
if (card === 'app') {
const { app } = tw
for (const platform of ['iphone', 'ipad', 'googleplay'] as const) {
if (app.name) {
tags.push(
<meta
key={i++}
name={`twitter:app:name:${platform}`}
content={app.name}
/>
)
}
if (app.id[platform]) {
tags.push(
<meta
key={i++}
name={`twitter:app:id:${platform}`}
content={String(app.id[platform])}
/>
)
}
if (app.url?.[platform]) {
tags.push(
<meta
key={i++}
name={`twitter:app:url:${platform}`}
content={app.url[platform]!.toString()}
/>
)
}
}
}
}
// --- App Links ---
if (metadata.appLinks) {
const appLinks = metadata.appLinks
// iOS / iPhone / iPad (AppLinksApple: url, app_store_id, app_name)
if (appLinks.ios) {
for (const item of appLinks.ios) {
if (item.url) {
tags.push(
<meta key={i++} property="al:ios:url" content={String(item.url)} />
)
}
if (item.app_store_id) {
tags.push(
<meta
key={i++}
property="al:ios:app_store_id"
content={String(item.app_store_id)}
/>
)
}
if (item.app_name) {
tags.push(
<meta
key={i++}
property="al:ios:app_name"
content={item.app_name}
/>
)
}
}
}
if (appLinks.iphone) {
for (const item of appLinks.iphone) {
if (item.url) {
tags.push(
<meta
key={i++}
property="al:iphone:url"
content={String(item.url)}
/>
)
}
if (item.app_store_id) {
tags.push(
<meta
key={i++}
property="al:iphone:app_store_id"
content={String(item.app_store_id)}
/>
)
}
if (item.app_name) {
tags.push(
<meta
key={i++}
property="al:iphone:app_name"
content={item.app_name}
/>
)
}
}
}
if (appLinks.ipad) {
for (const item of appLinks.ipad) {
if (item.url) {
tags.push(
<meta key={i++} property="al:ipad:url" content={String(item.url)} />
)
}
if (item.app_store_id) {
tags.push(
<meta
key={i++}
property="al:ipad:app_store_id"
content={String(item.app_store_id)}
/>
)
}
if (item.app_name) {
tags.push(
<meta
key={i++}
property="al:ipad:app_name"
content={item.app_name}
/>
)
}
}
}
// Android (AppLinksAndroid: package, url, class, app_name)
if (appLinks.android) {
for (const item of appLinks.android) {
if (item.package) {
tags.push(
<meta
key={i++}
property="al:android:package"
content={item.package}
/>
)
}
if (item.url) {
tags.push(
<meta
key={i++}
property="al:android:url"
content={String(item.url)}
/>
)
}
if (item.class) {
tags.push(
<meta key={i++} property="al:android:class" content={item.class} />
)
}
if (item.app_name) {
tags.push(
<meta
key={i++}
property="al:android:app_name"
content={item.app_name}
/>
)
}
}
}
// Windows Phone (AppLinksWindows: url, app_id, app_name)
if (appLinks.windows_phone) {
for (const item of appLinks.windows_phone) {
if (item.url) {
tags.push(
<meta
key={i++}
property="al:windows_phone:url"
content={String(item.url)}
/>
)
}
if (item.app_id) {
tags.push(
<meta
key={i++}
property="al:windows_phone:app_id"
content={item.app_id}
/>
)
}
if (item.app_name) {
tags.push(
<meta
key={i++}
property="al:windows_phone:app_name"
content={item.app_name}
/>
)
}
}
}
// Windows (AppLinksWindows: url, app_id, app_name)
if (appLinks.windows) {
for (const item of appLinks.windows) {
if (item.url) {
tags.push(
<meta
key={i++}
property="al:windows:url"
content={String(item.url)}
/>
)
}
if (item.app_id) {
tags.push(
<meta
key={i++}
property="al:windows:app_id"
content={item.app_id}
/>
)
}
if (item.app_name) {
tags.push(
<meta
key={i++}
property="al:windows:app_name"
content={item.app_name}
/>
)
}
}
}
// Windows Universal (AppLinksWindows: url, app_id, app_name)
if (appLinks.windows_universal) {
for (const item of appLinks.windows_universal) {
if (item.url) {
tags.push(
<meta
key={i++}
property="al:windows_universal:url"
content={String(item.url)}
/>
)
}
if (item.app_id) {
tags.push(
<meta
key={i++}
property="al:windows_universal:app_id"
content={item.app_id}
/>
)
}
if (item.app_name) {
tags.push(
<meta
key={i++}
property="al:windows_universal:app_name"
content={item.app_name}
/>
)
}
}
}
// Web (AppLinksWeb: url, should_fallback)
if (appLinks.web) {
for (const item of appLinks.web) {
if (item.url) {
tags.push(
<meta key={i++} property="al:web:url" content={String(item.url)} />
)
}
if (item.should_fallback != null) {
tags.push(
<meta
key={i++}
property="al:web:should_fallback"
content={String(item.should_fallback)}
/>
)
}
}
}
}
// --- Icons ---
if (metadata.icons) {
const { shortcut, icon, apple, other } = metadata.icons
const hasIcon = Boolean(
shortcut?.length || icon?.length || apple?.length || other?.length
)
if (shortcut) {
for (const ic of shortcut) {
const { url, rel, ...props } = ic
tags.push(
<link
key={i++}
rel={rel || 'shortcut icon'}
href={url.toString()}
{...props}
/>
)
}
}
if (icon) {
for (const ic of icon) {
const { url, rel, ...props } = ic
tags.push(
<link
key={i++}
rel={rel || 'icon'}
href={url.toString()}
{...props}
/>
)
}
}
if (apple) {
for (const ic of apple) {
const { url, rel, ...props } = ic
tags.push(
<link
key={i++}
rel={rel || 'apple-touch-icon'}
href={url.toString()}
{...props}
/>
)
}
}
if (other) {
for (const ic of other) {
const { url, rel, ...props } = ic
tags.push(
<link
key={i++}
rel={rel || 'icon'}
href={url.toString()}
{...props}
/>
)
}
}
if (hasIcon) {
tags.push(<IconMark key={i++} />)
}
}
return tags
}
import React, { Suspense, cache } from 'react'
import type { ParsedUrlQuery } from 'querystring'
import type { Params } from '../../server/request/params'
import type { LoaderTree } from '../../server/lib/app-dir-module'
import type { SearchParams } from '../../server/request/search-params'
import { createServerSearchParamsForMetadata } from '../../server/request/search-params'
import { createServerPathnameForMetadata } from '../../server/request/pathname'
import type { MetadataErrorType } from './metadata-resolution-primitives'
import {
resolveMetadataForBranch,
resolveMetadataResolution,
resolveViewportForBranch,
} from './resolve-metadata-parallel'
import type { MetadataContext } from './types/resolvers'
import {
createMetadataElements,
createViewportElements,
} from './metadata-elements'
import {
MetadataBoundary,
ViewportBoundary,
OutletBoundary,
} from '../framework/boundary-components'
export function createMetadataComponents({
tree,
pathname,
parsedQuery,
metadataContext,
interpolatedParams,
errorType,
serveStreamingMetadata,
}: {
tree: LoaderTree
pathname: string
parsedQuery: SearchParams
metadataContext: MetadataContext
interpolatedParams: Params
errorType?: MetadataErrorType | 'redirect'
serveStreamingMetadata: boolean
}): {
Viewport: React.ComponentType
Metadata: React.ComponentType
MetadataOutlet: React.ComponentType<{ tree: LoaderTree }>
} {
const searchParams = createServerSearchParamsForMetadata(parsedQuery)
const pathnameForMetadata = createServerPathnameForMetadata(pathname)
async function Viewport() {
const tags = await getMetadataResolution(
tree,
pathnameForMetadata,
searchParams,
interpolatedParams,
metadataContext,
errorType
)
.then(async (resolution) => {
const selected = await resolution.selectedViewport
if (selected.status === 'resolved') {
return <>{createViewportElements(selected.value)}</>
}
if (
!errorType &&
(selected.status === 'not-found' ||
selected.status === 'forbidden' ||
selected.status === 'unauthorized')
) {
const convention = await getViewportForBranch(
tree,
pathnameForMetadata,
searchParams,
selected.status,
interpolatedParams,
metadataContext,
resolution.selectedKeyPath
)
if (convention.status === 'resolved') {
return <>{createViewportElements(convention.value)}</>
}
}
return null
})
.catch(() => {
// We're going to throw the error from the metadata outlet so we just render null here instead
return null
})
return tags
}
Viewport.displayName = 'Next.Viewport'
function ViewportWrapper() {
return (
<ViewportBoundary>
<Viewport />
</ViewportBoundary>
)
}
async function Metadata() {
const tags = await getResolvedParallelMetadata(
tree,
pathnameForMetadata,
searchParams,
interpolatedParams,
metadataContext,
errorType
).catch(() => {
// We're going to throw the error from the metadata outlet so we just render null here instead
return null
})
return tags
}
Metadata.displayName = 'Next.Metadata'
function MetadataWrapper() {
// TODO: We shouldn't change what we render based on whether we are streaming or not.
// If we aren't streaming we should just block the response until we have resolved the
// metadata.
if (!serveStreamingMetadata) {
return (
<MetadataBoundary>
<Metadata />
</MetadataBoundary>
)
}
return (
<div hidden>
<MetadataBoundary>
<Suspense name="Next.Metadata">
<Metadata />
</Suspense>
</MetadataBoundary>
</div>
)
}
function MetadataOutlet({ tree: outletTree }: { tree: LoaderTree }) {
const metadataResolution = getMetadataResolution(
tree,
pathnameForMetadata,
searchParams,
interpolatedParams,
metadataContext,
errorType
)
const pendingOutlet = metadataResolution.then(
(resolution) => resolution.outlets.get(outletTree) ?? null
)
// TODO: We shouldn't change what we render based on whether we are streaming or not.
// If we aren't streaming we should just block the response until we have resolved the
// metadata.
if (!serveStreamingMetadata) {
return <OutletBoundary>{pendingOutlet}</OutletBoundary>
}
return (
<OutletBoundary>
<Suspense name="Next.MetadataOutlet">{pendingOutlet}</Suspense>
</OutletBoundary>
)
}
MetadataOutlet.displayName = 'Next.MetadataOutlet'
return {
Viewport: ViewportWrapper,
Metadata: MetadataWrapper,
MetadataOutlet,
}
}
const getResolvedParallelMetadata = cache(getResolvedParallelMetadataImpl)
async function getResolvedParallelMetadataImpl(
tree: LoaderTree,
pathname: Promise<string>,
searchParams: Promise<ParsedUrlQuery>,
interpolatedParams: Params,
metadataContext: MetadataContext,
errorType: MetadataErrorType | 'redirect' | undefined
): Promise<React.ReactNode> {
const resolution = await getMetadataResolution(
tree,
pathname,
searchParams,
interpolatedParams,
metadataContext,
errorType
)
const selected = await resolution.selectedMetadata
if (selected.status === 'resolved') {
return <>{createMetadataElements(selected.value)}</>
}
if (
!errorType &&
(selected.status === 'not-found' ||
selected.status === 'forbidden' ||
selected.status === 'unauthorized')
) {
const convention = await getMetadataForBranch(
tree,
pathname,
searchParams,
selected.status,
interpolatedParams,
metadataContext,
resolution.selectedKeyPath
)
if (convention.status === 'resolved') {
return <>{createMetadataElements(convention.value)}</>
}
}
return null
}
const getMetadataResolution = cache(resolveMetadataResolutionImpl)
async function resolveMetadataResolutionImpl(
tree: LoaderTree,
pathname: Promise<string>,
searchParams: Promise<ParsedUrlQuery>,
interpolatedParams: Params,
metadataContext: MetadataContext,
errorType?: MetadataErrorType | 'redirect'
) {
const errorConvention = errorType === 'redirect' ? undefined : errorType
return resolveMetadataResolution(
tree,
pathname,
searchParams,
errorConvention,
interpolatedParams,
metadataContext
)
}
const getMetadataForBranch = cache(resolveMetadataForBranch)
const getViewportForBranch = cache(resolveViewportForBranch)
......@@ -50,20 +50,16 @@ import type {
export type StaticIcons = Pick<ResolvedIcons, 'icon' | 'apple'>
export type Resolved<T> = T extends Metadata
? ResolvedMetadata
: ResolvedViewport
export type InstrumentedResolver<TData> = ((
parent: Promise<Resolved<TData>>
export type InstrumentedResolver<TData, TResolved> = ((
parent: Promise<TResolved>
) => TData | Promise<TData>) & {
$$original: (
props: unknown,
parent: Promise<Resolved<TData>>
parent: Promise<TResolved>
) => TData | Promise<TData>
}
export type MetadataResolver = InstrumentedResolver<Metadata>
export type ViewportResolver = InstrumentedResolver<Viewport>
export type MetadataResolver = InstrumentedResolver<Metadata, ResolvedMetadata>
export type ViewportResolver = InstrumentedResolver<Viewport, ResolvedViewport>
export type MetadataErrorType = 'not-found' | 'forbidden' | 'unauthorized'
......@@ -227,6 +223,7 @@ export async function mergeMetadata(
metadataContext,
buildState,
leafSegmentStaticIcons,
cloneResolvedMetadata = true,
}: {
metadata: Metadata | null
resolvedMetadata: ResolvedMetadata
......@@ -235,9 +232,12 @@ export async function mergeMetadata(
metadataContext: MetadataContext
buildState: BuildState
leafSegmentStaticIcons: StaticIcons
cloneResolvedMetadata?: boolean
}
): Promise<ResolvedMetadata> {
const newResolvedMetadata = structuredClone(resolvedMetadata)
const newResolvedMetadata = cloneResolvedMetadata
? structuredClone(resolvedMetadata)
: resolvedMetadata
const metadataBase = normalizeMetadataBase(
metadata?.metadataBase !== undefined
......@@ -457,11 +457,15 @@ export async function mergeMetadata(
export function mergeViewport({
resolvedViewport,
viewport,
cloneResolvedViewport = true,
}: {
resolvedViewport: ResolvedViewport
viewport: Viewport | null
cloneResolvedViewport?: boolean
}): ResolvedViewport {
const newResolvedViewport = structuredClone(resolvedViewport)
const newResolvedViewport = cloneResolvedViewport
? structuredClone(resolvedViewport)
: resolvedViewport
if (viewport) {
for (const key_ in viewport) {
......
......@@ -5,12 +5,10 @@ import type { LoaderTree } from '../../server/lib/app-dir-module'
import type { SearchParams } from '../../server/request/search-params'
import {
type MetadataErrorType,
type SelectedMetadata,
createSelectedMetadata,
resolveMetadata,
resolveViewport,
} from './resolve-metadata'
import type { ResolvedViewport } from './types/metadata-interface'
import { isHTTPAccessFallbackError } from '../../client/components/http-access-fallback/http-access-fallback'
import type { MetadataContext } from './types/resolvers'
import { createServerSearchParamsForMetadata } from '../../server/request/search-params'
......@@ -21,9 +19,10 @@ import {
ViewportBoundary,
OutletBoundary,
} from '../framework/boundary-components'
import { getOrigin } from './generate/utils'
import { IconMark } from './generate/icon-mark'
import {
createMetadataElements,
createViewportElements,
} from './metadata-elements'
// Use a promise to share the status of the metadata resolving,
// returning two components `MetadataTree` and `MetadataOutlet`
......@@ -50,7 +49,7 @@ export function createMetadataComponents({
}): {
Viewport: React.ComponentType
Metadata: React.ComponentType
MetadataOutlet: React.ComponentType
MetadataOutlet: React.ComponentType<{ tree: LoaderTree }>
} {
const searchParams = createServerSearchParamsForMetadata(parsedQuery)
const pathnameForMetadata = createServerPathnameForMetadata(pathname)
......@@ -265,1631 +264,3 @@ async function renderViewport(
)
return <>{createViewportElements(resolvedViewport)}</>
}
// ---------------------------------------------------------------------------
// Viewport tag rendering
// ---------------------------------------------------------------------------
function createViewportElements(
viewport: ResolvedViewport
): React.ReactElement[] {
const tags: React.ReactElement[] = []
let i = 0
tags.push(<meta key={i++} charSet="utf-8" />)
// Build viewport content string from layout properties
const viewportParts: string[] = []
if (viewport.width != null) {
viewportParts.push(`width=${viewport.width}`)
}
if (viewport.height != null) {
viewportParts.push(`height=${viewport.height}`)
}
if (viewport.initialScale != null) {
viewportParts.push(`initial-scale=${viewport.initialScale}`)
}
if (viewport.minimumScale != null) {
viewportParts.push(`minimum-scale=${viewport.minimumScale}`)
}
if (viewport.maximumScale != null) {
viewportParts.push(`maximum-scale=${viewport.maximumScale}`)
}
if (viewport.userScalable != null) {
viewportParts.push(`user-scalable=${viewport.userScalable ? 'yes' : 'no'}`)
}
if (viewport.viewportFit) {
viewportParts.push(`viewport-fit=${viewport.viewportFit}`)
}
if (viewport.interactiveWidget) {
viewportParts.push(`interactive-widget=${viewport.interactiveWidget}`)
}
if (viewportParts.length) {
tags.push(
<meta key={i++} name="viewport" content={viewportParts.join(', ')} />
)
}
if (viewport.themeColor) {
for (const themeColor of viewport.themeColor) {
if (themeColor.media) {
tags.push(
<meta
key={i++}
name="theme-color"
content={themeColor.color}
media={themeColor.media}
/>
)
} else {
tags.push(
<meta key={i++} name="theme-color" content={themeColor.color} />
)
}
}
}
if (viewport.colorScheme) {
tags.push(
<meta key={i++} name="color-scheme" content={viewport.colorScheme} />
)
}
return tags
}
// ---------------------------------------------------------------------------
// Metadata tag rendering
// ---------------------------------------------------------------------------
function createMetadataElements(
metadata: SelectedMetadata
): React.ReactElement[] {
const tags: React.ReactElement[] = []
let i = 0
// --- Title ---
if (metadata.title) {
tags.push(<title key={i++}>{metadata.title}</title>)
}
// --- Basic meta tags ---
if (metadata.description) {
tags.push(
<meta key={i++} name="description" content={metadata.description} />
)
}
if (metadata.applicationName) {
tags.push(
<meta
key={i++}
name="application-name"
content={metadata.applicationName}
/>
)
}
// --- Authors ---
if (metadata.authors) {
for (const author of metadata.authors) {
if (author.url) {
tags.push(<link key={i++} rel="author" href={author.url.toString()} />)
}
if (author.name) {
tags.push(<meta key={i++} name="author" content={author.name} />)
}
}
}
// --- Manifest ---
if (metadata.manifest) {
const manifestOrigin = getOrigin(metadata.manifest)
tags.push(
<link
key={i++}
rel="manifest"
href={metadata.manifest.toString()}
crossOrigin={
!manifestOrigin && process.env.VERCEL_ENV === 'preview'
? 'use-credentials'
: undefined
}
/>
)
}
if (metadata.generator) {
tags.push(<meta key={i++} name="generator" content={metadata.generator} />)
}
if (metadata.keywords && metadata.keywords.length) {
tags.push(
<meta key={i++} name="keywords" content={metadata.keywords.join(',')} />
)
}
if (metadata.referrer) {
tags.push(<meta key={i++} name="referrer" content={metadata.referrer} />)
}
if (metadata.creator) {
tags.push(<meta key={i++} name="creator" content={metadata.creator} />)
}
if (metadata.publisher) {
tags.push(<meta key={i++} name="publisher" content={metadata.publisher} />)
}
if (metadata.robots?.basic) {
tags.push(<meta key={i++} name="robots" content={metadata.robots.basic} />)
}
if (metadata.robots?.googleBot) {
tags.push(
<meta key={i++} name="googlebot" content={metadata.robots.googleBot} />
)
}
if (metadata.abstract) {
tags.push(<meta key={i++} name="abstract" content={metadata.abstract} />)
}
// --- Link rel arrays ---
if (metadata.archives) {
for (const archive of metadata.archives) {
tags.push(<link key={i++} rel="archives" href={archive} />)
}
}
if (metadata.assets) {
for (const asset of metadata.assets) {
tags.push(<link key={i++} rel="assets" href={asset} />)
}
}
if (metadata.bookmarks) {
for (const bookmark of metadata.bookmarks) {
tags.push(<link key={i++} rel="bookmarks" href={bookmark} />)
}
}
// --- Pagination ---
if (metadata.pagination) {
if (metadata.pagination.previous) {
tags.push(
<link key={i++} rel="prev" href={metadata.pagination.previous} />
)
}
if (metadata.pagination.next) {
tags.push(<link key={i++} rel="next" href={metadata.pagination.next} />)
}
}
if (metadata.category) {
tags.push(<meta key={i++} name="category" content={metadata.category} />)
}
if (metadata.classification) {
tags.push(
<meta key={i++} name="classification" content={metadata.classification} />
)
}
// --- Other (arbitrary name/value pairs) ---
if (metadata.other) {
for (const [name, content] of Object.entries(metadata.other)) {
if (Array.isArray(content)) {
for (const contentItem of content) {
if (contentItem != null && contentItem !== '') {
tags.push(
<meta key={i++} name={name} content={String(contentItem)} />
)
}
}
} else if (content != null && content !== '') {
tags.push(<meta key={i++} name={name} content={String(content)} />)
}
}
}
// --- Alternates ---
if (metadata.alternates) {
const { canonical, languages, media, types } = metadata.alternates
if (canonical && canonical.url) {
tags.push(
<link
key={i++}
rel="canonical"
href={canonical.url.toString()}
{...(canonical.title ? { title: canonical.title } : undefined)}
/>
)
}
if (languages) {
for (const [locale, descriptors] of Object.entries(languages)) {
if (descriptors) {
for (const descriptor of descriptors) {
if (descriptor.url) {
tags.push(
<link
key={i++}
rel="alternate"
hrefLang={locale}
href={descriptor.url.toString()}
{...(descriptor.title
? { title: descriptor.title }
: undefined)}
/>
)
}
}
}
}
}
if (media) {
for (const [mediaName, descriptors] of Object.entries(media)) {
if (descriptors) {
for (const descriptor of descriptors) {
if (descriptor.url) {
tags.push(
<link
key={i++}
rel="alternate"
media={mediaName}
href={descriptor.url.toString()}
{...(descriptor.title
? { title: descriptor.title }
: undefined)}
/>
)
}
}
}
}
}
if (types) {
for (const [type, descriptors] of Object.entries(types)) {
if (descriptors) {
for (const descriptor of descriptors) {
if (descriptor.url) {
tags.push(
<link
key={i++}
rel="alternate"
type={type}
href={descriptor.url.toString()}
{...(descriptor.title
? { title: descriptor.title }
: undefined)}
/>
)
}
}
}
}
}
}
// --- iTunes ---
if (metadata.itunes) {
const { appId, appArgument } = metadata.itunes
let itunesContent = `app-id=${appId}`
if (appArgument) {
itunesContent += `, app-argument=${appArgument}`
}
tags.push(
<meta key={i++} name="apple-itunes-app" content={itunesContent} />
)
}
// --- Facebook ---
if (metadata.facebook) {
if (metadata.facebook.appId) {
tags.push(
<meta
key={i++}
property="fb:app_id"
content={metadata.facebook.appId}
/>
)
}
if (metadata.facebook.admins) {
for (const admin of metadata.facebook.admins) {
tags.push(<meta key={i++} property="fb:admins" content={admin} />)
}
}
}
// --- Pinterest ---
if (metadata.pinterest && metadata.pinterest.richPin !== undefined) {
tags.push(
<meta
key={i++}
property="pinterest-rich-pin"
content={metadata.pinterest.richPin.toString()}
/>
)
}
// --- Format Detection ---
if (metadata.formatDetection) {
const formatDetectionKeys = [
'telephone',
'date',
'address',
'email',
'url',
] as const
let formatContent = ''
for (const key of formatDetectionKeys) {
if (metadata.formatDetection[key] === false) {
if (formatContent) formatContent += ', '
formatContent += `${key}=no`
}
}
if (formatContent) {
tags.push(
<meta key={i++} name="format-detection" content={formatContent} />
)
}
}
// --- Verification ---
if (metadata.verification) {
const verification = metadata.verification
if (verification.google) {
for (const value of verification.google) {
if (value != null && value !== '') {
tags.push(
<meta
key={i++}
name="google-site-verification"
content={String(value)}
/>
)
}
}
}
if (verification.yahoo) {
for (const value of verification.yahoo) {
if (value != null && value !== '') {
tags.push(<meta key={i++} name="y_key" content={String(value)} />)
}
}
}
if (verification.yandex) {
for (const value of verification.yandex) {
if (value != null && value !== '') {
tags.push(
<meta
key={i++}
name="yandex-verification"
content={String(value)}
/>
)
}
}
}
if (verification.me) {
for (const value of verification.me) {
if (value != null && value !== '') {
tags.push(<meta key={i++} name="me" content={String(value)} />)
}
}
}
if (verification.other) {
for (const [name, values] of Object.entries(verification.other)) {
for (const value of values) {
if (value != null && value !== '') {
tags.push(<meta key={i++} name={name} content={String(value)} />)
}
}
}
}
}
// --- Apple Web App ---
if (metadata.appleWebApp) {
const { capable, title, startupImage, statusBarStyle } =
metadata.appleWebApp
if (capable) {
tags.push(<meta key={i++} name="mobile-web-app-capable" content="yes" />)
}
if (title) {
tags.push(
<meta key={i++} name="apple-mobile-web-app-title" content={title} />
)
}
if (startupImage) {
for (const image of startupImage) {
if (image.media) {
tags.push(
<link
key={i++}
href={image.url}
media={image.media}
rel="apple-touch-startup-image"
/>
)
} else {
tags.push(
<link key={i++} href={image.url} rel="apple-touch-startup-image" />
)
}
}
}
if (statusBarStyle) {
tags.push(
<meta
key={i++}
name="apple-mobile-web-app-status-bar-style"
content={statusBarStyle}
/>
)
}
}
// --- Open Graph ---
if (metadata.openGraph) {
const og = metadata.openGraph
if (og.determiner) {
tags.push(
<meta key={i++} property="og:determiner" content={og.determiner} />
)
}
if (og.title) {
tags.push(<meta key={i++} property="og:title" content={og.title} />)
}
if (og.description) {
tags.push(
<meta key={i++} property="og:description" content={og.description} />
)
}
if (og.url) {
tags.push(
<meta key={i++} property="og:url" content={og.url.toString()} />
)
}
if (og.siteName) {
tags.push(
<meta key={i++} property="og:site_name" content={og.siteName} />
)
}
if (og.locale) {
tags.push(<meta key={i++} property="og:locale" content={og.locale} />)
}
if (og.countryName) {
tags.push(
<meta key={i++} property="og:country_name" content={og.countryName} />
)
}
if (og.ttl != null) {
tags.push(
<meta key={i++} property="og:ttl" content={og.ttl.toString()} />
)
}
// OG images
if (og.images) {
for (const image of og.images) {
if (typeof image === 'string') {
tags.push(<meta key={i++} property="og:image" content={image} />)
} else {
if (image.url) {
tags.push(
<meta key={i++} property="og:image" content={String(image.url)} />
)
}
if (image.secureUrl) {
tags.push(
<meta
key={i++}
property="og:image:secure_url"
content={String(image.secureUrl)}
/>
)
}
if (image.type) {
tags.push(
<meta key={i++} property="og:image:type" content={image.type} />
)
}
if (image.width) {
tags.push(
<meta
key={i++}
property="og:image:width"
content={String(image.width)}
/>
)
}
if (image.height) {
tags.push(
<meta
key={i++}
property="og:image:height"
content={String(image.height)}
/>
)
}
if (image.alt) {
tags.push(
<meta key={i++} property="og:image:alt" content={image.alt} />
)
}
}
}
}
// OG videos
if (og.videos) {
for (const video of og.videos) {
if (typeof video === 'string') {
tags.push(<meta key={i++} property="og:video" content={video} />)
} else {
if (video.url) {
tags.push(
<meta key={i++} property="og:video" content={String(video.url)} />
)
}
if (video.secureUrl) {
tags.push(
<meta
key={i++}
property="og:video:secure_url"
content={String(video.secureUrl)}
/>
)
}
if (video.type) {
tags.push(
<meta key={i++} property="og:video:type" content={video.type} />
)
}
if (video.width) {
tags.push(
<meta
key={i++}
property="og:video:width"
content={String(video.width)}
/>
)
}
if (video.height) {
tags.push(
<meta
key={i++}
property="og:video:height"
content={String(video.height)}
/>
)
}
}
}
}
// OG audio
if (og.audio) {
for (const audio of og.audio) {
if (typeof audio === 'string') {
tags.push(<meta key={i++} property="og:audio" content={audio} />)
} else {
if (audio.url) {
tags.push(
<meta key={i++} property="og:audio" content={String(audio.url)} />
)
}
if (audio.secureUrl) {
tags.push(
<meta
key={i++}
property="og:audio:secure_url"
content={String(audio.secureUrl)}
/>
)
}
if (audio.type) {
tags.push(
<meta key={i++} property="og:audio:type" content={audio.type} />
)
}
}
}
}
// OG simple array properties
if (og.emails) {
for (const email of og.emails) {
tags.push(<meta key={i++} property="og:email" content={email} />)
}
}
if (og.phoneNumbers) {
for (const phone of og.phoneNumbers) {
tags.push(<meta key={i++} property="og:phone_number" content={phone} />)
}
}
if (og.faxNumbers) {
for (const fax of og.faxNumbers) {
tags.push(<meta key={i++} property="og:fax_number" content={fax} />)
}
}
if (og.alternateLocale) {
for (const locale of og.alternateLocale) {
tags.push(
<meta key={i++} property="og:locale:alternate" content={locale} />
)
}
}
// OG type-specific tags
if ('type' in og) {
const ogType = og.type
switch (ogType) {
case 'website':
tags.push(<meta key={i++} property="og:type" content="website" />)
break
case 'article':
tags.push(<meta key={i++} property="og:type" content="article" />)
if (og.publishedTime) {
tags.push(
<meta
key={i++}
property="article:published_time"
content={og.publishedTime.toString()}
/>
)
}
if (og.modifiedTime) {
tags.push(
<meta
key={i++}
property="article:modified_time"
content={og.modifiedTime.toString()}
/>
)
}
if (og.expirationTime) {
tags.push(
<meta
key={i++}
property="article:expiration_time"
content={og.expirationTime.toString()}
/>
)
}
if (og.authors) {
for (const author of og.authors) {
tags.push(
<meta
key={i++}
property="article:author"
content={String(author)}
/>
)
}
}
if (og.section) {
tags.push(
<meta key={i++} property="article:section" content={og.section} />
)
}
if (og.tags) {
for (const tag of og.tags) {
tags.push(<meta key={i++} property="article:tag" content={tag} />)
}
}
break
case 'book':
tags.push(<meta key={i++} property="og:type" content="book" />)
if (og.isbn) {
tags.push(<meta key={i++} property="book:isbn" content={og.isbn} />)
}
if (og.releaseDate) {
tags.push(
<meta
key={i++}
property="book:release_date"
content={og.releaseDate}
/>
)
}
if (og.authors) {
for (const author of og.authors) {
tags.push(
<meta
key={i++}
property="book:author"
content={String(author)}
/>
)
}
}
if (og.tags) {
for (const tag of og.tags) {
tags.push(<meta key={i++} property="book:tag" content={tag} />)
}
}
break
case 'profile':
tags.push(<meta key={i++} property="og:type" content="profile" />)
if (og.firstName) {
tags.push(
<meta
key={i++}
property="profile:first_name"
content={og.firstName}
/>
)
}
if (og.lastName) {
tags.push(
<meta
key={i++}
property="profile:last_name"
content={og.lastName}
/>
)
}
if (og.username) {
tags.push(
<meta
key={i++}
property="profile:username"
content={og.username}
/>
)
}
if (og.gender) {
tags.push(
<meta key={i++} property="profile:gender" content={og.gender} />
)
}
break
case 'music.song':
tags.push(<meta key={i++} property="og:type" content="music.song" />)
if (og.duration != null) {
tags.push(
<meta
key={i++}
property="music:duration"
content={og.duration.toString()}
/>
)
}
if (og.albums) {
for (const album of og.albums) {
if (typeof album === 'string') {
tags.push(
<meta key={i++} property="music:album" content={album} />
)
} else {
if (album.url) {
tags.push(
<meta
key={i++}
property="music:album"
content={String(album.url)}
/>
)
}
if (album.disc != null) {
tags.push(
<meta
key={i++}
property="music:album:disc"
content={String(album.disc)}
/>
)
}
if (album.track != null) {
tags.push(
<meta
key={i++}
property="music:album:track"
content={String(album.track)}
/>
)
}
}
}
}
if (og.musicians) {
for (const musician of og.musicians) {
tags.push(
<meta
key={i++}
property="music:musician"
content={String(musician)}
/>
)
}
}
break
case 'music.album':
tags.push(<meta key={i++} property="og:type" content="music.album" />)
if (og.songs) {
for (const song of og.songs) {
if (typeof song === 'string') {
tags.push(
<meta key={i++} property="music:song" content={song} />
)
} else {
if (song.url) {
tags.push(
<meta
key={i++}
property="music:song"
content={String(song.url)}
/>
)
}
if (song.disc != null) {
tags.push(
<meta
key={i++}
property="music:song:disc"
content={String(song.disc)}
/>
)
}
if (song.track != null) {
tags.push(
<meta
key={i++}
property="music:song:track"
content={String(song.track)}
/>
)
}
}
}
}
if (og.musicians) {
for (const musician of og.musicians) {
tags.push(
<meta
key={i++}
property="music:musician"
content={String(musician)}
/>
)
}
}
if (og.releaseDate) {
tags.push(
<meta
key={i++}
property="music:release_date"
content={og.releaseDate}
/>
)
}
break
case 'music.playlist':
tags.push(
<meta key={i++} property="og:type" content="music.playlist" />
)
if (og.songs) {
for (const song of og.songs) {
if (typeof song === 'string') {
tags.push(
<meta key={i++} property="music:song" content={song} />
)
} else {
if (song.url) {
tags.push(
<meta
key={i++}
property="music:song"
content={String(song.url)}
/>
)
}
if (song.disc != null) {
tags.push(
<meta
key={i++}
property="music:song:disc"
content={String(song.disc)}
/>
)
}
if (song.track != null) {
tags.push(
<meta
key={i++}
property="music:song:track"
content={String(song.track)}
/>
)
}
}
}
}
if (og.creators) {
for (const creator of og.creators) {
tags.push(
<meta
key={i++}
property="music:creator"
content={String(creator)}
/>
)
}
}
break
case 'music.radio_station':
tags.push(
<meta key={i++} property="og:type" content="music.radio_station" />
)
if (og.creators) {
for (const creator of og.creators) {
tags.push(
<meta
key={i++}
property="music:creator"
content={String(creator)}
/>
)
}
}
break
case 'video.movie':
tags.push(<meta key={i++} property="og:type" content="video.movie" />)
if (og.actors) {
for (const actor of og.actors) {
if (typeof actor === 'string') {
tags.push(
<meta key={i++} property="video:actor" content={actor} />
)
} else {
if (actor.url) {
tags.push(
<meta
key={i++}
property="video:actor"
content={String(actor.url)}
/>
)
}
if (actor.role) {
tags.push(
<meta
key={i++}
property="video:actor:role"
content={actor.role}
/>
)
}
}
}
}
if (og.directors) {
for (const director of og.directors) {
tags.push(
<meta
key={i++}
property="video:director"
content={String(director)}
/>
)
}
}
if (og.writers) {
for (const writer of og.writers) {
tags.push(
<meta
key={i++}
property="video:writer"
content={String(writer)}
/>
)
}
}
if (og.duration != null) {
tags.push(
<meta
key={i++}
property="video:duration"
content={String(og.duration)}
/>
)
}
if (og.releaseDate) {
tags.push(
<meta
key={i++}
property="video:release_date"
content={og.releaseDate}
/>
)
}
if (og.tags) {
for (const tag of og.tags) {
tags.push(<meta key={i++} property="video:tag" content={tag} />)
}
}
break
case 'video.episode':
tags.push(
<meta key={i++} property="og:type" content="video.episode" />
)
if (og.actors) {
for (const actor of og.actors) {
if (typeof actor === 'string') {
tags.push(
<meta key={i++} property="video:actor" content={actor} />
)
} else {
if (actor.url) {
tags.push(
<meta
key={i++}
property="video:actor"
content={String(actor.url)}
/>
)
}
if (actor.role) {
tags.push(
<meta
key={i++}
property="video:actor:role"
content={actor.role}
/>
)
}
}
}
}
if (og.directors) {
for (const director of og.directors) {
tags.push(
<meta
key={i++}
property="video:director"
content={String(director)}
/>
)
}
}
if (og.writers) {
for (const writer of og.writers) {
tags.push(
<meta
key={i++}
property="video:writer"
content={String(writer)}
/>
)
}
}
if (og.duration != null) {
tags.push(
<meta
key={i++}
property="video:duration"
content={String(og.duration)}
/>
)
}
if (og.releaseDate) {
tags.push(
<meta
key={i++}
property="video:release_date"
content={og.releaseDate}
/>
)
}
if (og.tags) {
for (const tag of og.tags) {
tags.push(<meta key={i++} property="video:tag" content={tag} />)
}
}
if (og.series) {
tags.push(
<meta
key={i++}
property="video:series"
content={String(og.series)}
/>
)
}
break
case 'video.tv_show':
tags.push(
<meta key={i++} property="og:type" content="video.tv_show" />
)
break
case 'video.other':
tags.push(<meta key={i++} property="og:type" content="video.other" />)
break
default:
const _exhaustiveCheck: never = ogType
throw new Error(`Invalid OpenGraph type: ${_exhaustiveCheck}`)
}
}
}
// --- Twitter ---
if (metadata.twitter) {
const tw = metadata.twitter
const { card } = tw
if (card) {
tags.push(<meta key={i++} name="twitter:card" content={card} />)
}
if (tw.site) {
tags.push(<meta key={i++} name="twitter:site" content={tw.site} />)
}
if (tw.siteId) {
tags.push(<meta key={i++} name="twitter:site:id" content={tw.siteId} />)
}
if (tw.creator) {
tags.push(<meta key={i++} name="twitter:creator" content={tw.creator} />)
}
if (tw.creatorId) {
tags.push(
<meta key={i++} name="twitter:creator:id" content={tw.creatorId} />
)
}
if (tw.title) {
tags.push(<meta key={i++} name="twitter:title" content={tw.title} />)
}
if (tw.description) {
tags.push(
<meta key={i++} name="twitter:description" content={tw.description} />
)
}
// Twitter images
if (tw.images) {
for (const image of tw.images) {
if (typeof image === 'string') {
tags.push(<meta key={i++} name="twitter:image" content={image} />)
} else {
if (image.url) {
tags.push(
<meta
key={i++}
name="twitter:image"
content={String(image.url)}
/>
)
}
if (image.alt) {
tags.push(
<meta key={i++} name="twitter:image:alt" content={image.alt} />
)
}
if (image.secureUrl) {
tags.push(
<meta
key={i++}
name="twitter:image:secure_url"
content={String(image.secureUrl)}
/>
)
}
if (image.type) {
tags.push(
<meta key={i++} name="twitter:image:type" content={image.type} />
)
}
if (image.width) {
tags.push(
<meta
key={i++}
name="twitter:image:width"
content={String(image.width)}
/>
)
}
if (image.height) {
tags.push(
<meta
key={i++}
name="twitter:image:height"
content={String(image.height)}
/>
)
}
}
}
}
// Twitter player cards
if (card === 'player') {
for (const player of tw.players) {
tags.push(
<meta
key={i++}
name="twitter:player"
content={player.playerUrl.toString()}
/>
)
tags.push(
<meta
key={i++}
name="twitter:player:stream"
content={player.streamUrl.toString()}
/>
)
tags.push(
<meta
key={i++}
name="twitter:player:width"
content={String(player.width)}
/>
)
tags.push(
<meta
key={i++}
name="twitter:player:height"
content={String(player.height)}
/>
)
}
}
// Twitter app cards
if (card === 'app') {
const { app } = tw
for (const platform of ['iphone', 'ipad', 'googleplay'] as const) {
if (app.name) {
tags.push(
<meta
key={i++}
name={`twitter:app:name:${platform}`}
content={app.name}
/>
)
}
if (app.id[platform]) {
tags.push(
<meta
key={i++}
name={`twitter:app:id:${platform}`}
content={String(app.id[platform])}
/>
)
}
if (app.url?.[platform]) {
tags.push(
<meta
key={i++}
name={`twitter:app:url:${platform}`}
content={app.url[platform]!.toString()}
/>
)
}
}
}
}
// --- App Links ---
if (metadata.appLinks) {
const appLinks = metadata.appLinks
// iOS / iPhone / iPad (AppLinksApple: url, app_store_id, app_name)
if (appLinks.ios) {
for (const item of appLinks.ios) {
if (item.url) {
tags.push(
<meta key={i++} property="al:ios:url" content={String(item.url)} />
)
}
if (item.app_store_id) {
tags.push(
<meta
key={i++}
property="al:ios:app_store_id"
content={String(item.app_store_id)}
/>
)
}
if (item.app_name) {
tags.push(
<meta
key={i++}
property="al:ios:app_name"
content={item.app_name}
/>
)
}
}
}
if (appLinks.iphone) {
for (const item of appLinks.iphone) {
if (item.url) {
tags.push(
<meta
key={i++}
property="al:iphone:url"
content={String(item.url)}
/>
)
}
if (item.app_store_id) {
tags.push(
<meta
key={i++}
property="al:iphone:app_store_id"
content={String(item.app_store_id)}
/>
)
}
if (item.app_name) {
tags.push(
<meta
key={i++}
property="al:iphone:app_name"
content={item.app_name}
/>
)
}
}
}
if (appLinks.ipad) {
for (const item of appLinks.ipad) {
if (item.url) {
tags.push(
<meta key={i++} property="al:ipad:url" content={String(item.url)} />
)
}
if (item.app_store_id) {
tags.push(
<meta
key={i++}
property="al:ipad:app_store_id"
content={String(item.app_store_id)}
/>
)
}
if (item.app_name) {
tags.push(
<meta
key={i++}
property="al:ipad:app_name"
content={item.app_name}
/>
)
}
}
}
// Android (AppLinksAndroid: package, url, class, app_name)
if (appLinks.android) {
for (const item of appLinks.android) {
if (item.package) {
tags.push(
<meta
key={i++}
property="al:android:package"
content={item.package}
/>
)
}
if (item.url) {
tags.push(
<meta
key={i++}
property="al:android:url"
content={String(item.url)}
/>
)
}
if (item.class) {
tags.push(
<meta key={i++} property="al:android:class" content={item.class} />
)
}
if (item.app_name) {
tags.push(
<meta
key={i++}
property="al:android:app_name"
content={item.app_name}
/>
)
}
}
}
// Windows Phone (AppLinksWindows: url, app_id, app_name)
if (appLinks.windows_phone) {
for (const item of appLinks.windows_phone) {
if (item.url) {
tags.push(
<meta
key={i++}
property="al:windows_phone:url"
content={String(item.url)}
/>
)
}
if (item.app_id) {
tags.push(
<meta
key={i++}
property="al:windows_phone:app_id"
content={item.app_id}
/>
)
}
if (item.app_name) {
tags.push(
<meta
key={i++}
property="al:windows_phone:app_name"
content={item.app_name}
/>
)
}
}
}
// Windows (AppLinksWindows: url, app_id, app_name)
if (appLinks.windows) {
for (const item of appLinks.windows) {
if (item.url) {
tags.push(
<meta
key={i++}
property="al:windows:url"
content={String(item.url)}
/>
)
}
if (item.app_id) {
tags.push(
<meta
key={i++}
property="al:windows:app_id"
content={item.app_id}
/>
)
}
if (item.app_name) {
tags.push(
<meta
key={i++}
property="al:windows:app_name"
content={item.app_name}
/>
)
}
}
}
// Windows Universal (AppLinksWindows: url, app_id, app_name)
if (appLinks.windows_universal) {
for (const item of appLinks.windows_universal) {
if (item.url) {
tags.push(
<meta
key={i++}
property="al:windows_universal:url"
content={String(item.url)}
/>
)
}
if (item.app_id) {
tags.push(
<meta
key={i++}
property="al:windows_universal:app_id"
content={item.app_id}
/>
)
}
if (item.app_name) {
tags.push(
<meta
key={i++}
property="al:windows_universal:app_name"
content={item.app_name}
/>
)
}
}
}
// Web (AppLinksWeb: url, should_fallback)
if (appLinks.web) {
for (const item of appLinks.web) {
if (item.url) {
tags.push(
<meta key={i++} property="al:web:url" content={String(item.url)} />
)
}
if (item.should_fallback != null) {
tags.push(
<meta
key={i++}
property="al:web:should_fallback"
content={String(item.should_fallback)}
/>
)
}
}
}
}
// --- Icons ---
if (metadata.icons) {
const { shortcut, icon, apple, other } = metadata.icons
const hasIcon = Boolean(
shortcut?.length || icon?.length || apple?.length || other?.length
)
if (shortcut) {
for (const ic of shortcut) {
const { url, rel, ...props } = ic
tags.push(
<link
key={i++}
rel={rel || 'shortcut icon'}
href={url.toString()}
{...props}
/>
)
}
}
if (icon) {
for (const ic of icon) {
const { url, rel, ...props } = ic
tags.push(
<link
key={i++}
rel={rel || 'icon'}
href={url.toString()}
{...props}
/>
)
}
}
if (apple) {
for (const ic of apple) {
const { url, rel, ...props } = ic
tags.push(
<link
key={i++}
rel={rel || 'apple-touch-icon'}
href={url.toString()}
{...props}
/>
)
}
}
if (other) {
for (const ic of other) {
const { url, rel, ...props } = ic
tags.push(
<link
key={i++}
rel={rel || 'icon'}
href={url.toString()}
{...props}
/>
)
}
}
if (hasIcon) {
tags.push(<IconMark key={i++} />)
}
}
return tags
}
import type {
Metadata,
ResolvedMetadata,
ResolvedViewport,
Viewport,
} from './types/metadata-interface'
import type { MetadataContext } from './types/resolvers'
import type { LoaderTree } from '../../server/lib/app-dir-module'
import type { ParsedUrlQuery } from 'querystring'
import type { StaticMetadata } from './types/icons'
import type { Params } from '../../server/request/params'
import type { IconDescriptor } from './types/metadata-types'
// eslint-disable-next-line import/no-extraneous-dependencies
import 'server-only'
import {
createDefaultMetadata,
createDefaultViewport,
} from './default-metadata'
import { getSegmentParam } from '../../shared/lib/router/utils/get-segment-param'
import {
getComponentTypeModule,
getLayoutOrPageModule,
} from '../../server/lib/app-dir-module'
import { createServerParamsForMetadata } from '../../server/request/params'
import { DEFAULT_SEGMENT_KEY, PAGE_SEGMENT_KEY } from '../../shared/lib/segment'
import { PARALLEL_ROUTE_DEFAULT_PATH } from '../../client/components/builtin/default'
import { PARALLEL_ROUTE_DEFAULT_NULL_PATH } from '../../client/components/builtin/default-null'
import { workAsyncStorage } from '../../server/app-render/work-async-storage.external'
import { InvariantError } from '../../shared/lib/invariant-error'
import * as Log from '../../build/output/log'
import { getUseCacheFunctionInfo } from '../client-and-server-references'
import { createLazyResult } from '../../server/lib/lazy-result'
import {
getAccessFallbackErrorTypeByStatus,
getAccessFallbackHTTPStatus,
isHTTPAccessFallbackError,
} from '../../client/components/http-access-fallback/http-access-fallback'
import { isRedirectError } from '../../client/components/redirect-error'
import {
type BuildState,
type InstrumentedResolver,
type MetadataErrorType,
type MetadataResolver,
type SegmentProps,
type SelectedMetadata,
type StaticIcons,
type TitleTemplates,
type ViewportResolver,
convertUrlsToStrings,
createSelectedMetadata,
getDefinedMetadata,
getDefinedViewport,
isFavicon,
mergeMetadata,
mergeViewport,
postProcessMetadata,
resolveStaticMetadata,
} from './metadata-resolution-primitives'
const METADATA = 0b01 as const
const VIEWPORT = 0b10 as const
const METADATA_AND_VIEWPORT = 0b11 as const
type ResolutionTarget =
| typeof METADATA
| typeof VIEWPORT
| typeof METADATA_AND_VIEWPORT
type RejectedMetadataResolutionStatus = MetadataErrorType | 'redirect' | 'error'
type ResolvedOutcome<T> = {
status: 'resolved'
value: T
}
type RejectedOutcome = {
status: RejectedMetadataResolutionStatus
reason: unknown
}
type ResolutionOutcome<T> = ResolvedOutcome<T> | RejectedOutcome
type MetadataBranchOutcome =
| (ResolvedOutcome<SelectedMetadata> & { warnings: Set<string> })
| RejectedOutcome
type ViewportBranchOutcome = ResolutionOutcome<ResolvedViewport>
type MetadataResolution = {
selectedKeyPath: string[]
selectedMetadata: Promise<MetadataBranchOutcome>
selectedViewport: Promise<ViewportBranchOutcome>
outlets: Map<LoaderTree, Promise<null>>
}
type MetadataAccumulator = {
metadata: ResolvedMetadata
titleTemplates: TitleTemplates
favicon: IconDescriptor | null
leafSegmentStaticIcons: StaticIcons
buildState: BuildState
}
// Keep viewport state in an accumulator so its layer and fork handling stays
// structurally parallel to metadata, even though it currently has one field.
type ViewportAccumulator = {
viewport: ResolvedViewport
}
type MetadataLayer = {
metadata: Metadata | MetadataResolver | null
viewport: Viewport | ViewportResolver | null
staticFilesMetadata: Promise<StaticMetadata>
hasStaticFilesMetadata: boolean
}
type MetadataBranch = {
metadata: Promise<MetadataBranchOutcome>
viewport: Promise<ViewportBranchOutcome>
keyPath: string[]
definitionDepth: number
isBuiltinFallback: boolean
}
type CollectedMetadata = MetadataLayer & {
errorLayer: MetadataLayer | null
}
async function collectMetadataAndViewport({
tree,
props,
route,
errorConvention,
resolutionTarget,
}: {
tree: LoaderTree
props: SegmentProps
route: string
errorConvention: MetadataErrorType | undefined
resolutionTarget: ResolutionTarget
}): Promise<CollectedMetadata> {
const shouldResolveMetadata = Boolean(resolutionTarget & METADATA)
const shouldResolveViewport = Boolean(resolutionTarget & VIEWPORT)
const moduleResultPromise = errorConvention
? getComponentTypeModule(tree, 'layout').then((mod) => ({
mod,
modType: errorConvention,
}))
: getLayoutOrPageModule(tree)
const staticFilesMetadata = shouldResolveMetadata
? resolveStaticMetadata(tree[2], props)
: Promise.resolve(null)
// Static metadata is resolved eagerly, but its rejection belongs to this
// branch and will be replayed through the branch's metadata outlet.
staticFilesMetadata.catch(() => null)
const moduleResult = await moduleResultPromise
const hasStaticFilesMetadata =
shouldResolveMetadata && hasStaticMetadataFiles(tree)
if (moduleResult.modType) {
route += `/${moduleResult.modType}`
}
const metadata =
shouldResolveMetadata && moduleResult.mod
? getDefinedMetadata(moduleResult.mod, props, { route })
: null
const viewport =
shouldResolveViewport && moduleResult.mod
? getDefinedViewport(moduleResult.mod, props, { route })
: null
let errorLayer: MetadataLayer | null = null
if (errorConvention && tree[2][errorConvention]) {
const errorMod = await getComponentTypeModule(tree, errorConvention)
errorLayer = {
metadata:
shouldResolveMetadata && errorMod
? getDefinedMetadata(errorMod, props, { route })
: null,
viewport:
shouldResolveViewport && errorMod
? getDefinedViewport(errorMod, props, { route })
: null,
staticFilesMetadata,
hasStaticFilesMetadata,
}
}
return {
metadata,
viewport,
staticFilesMetadata,
hasStaticFilesMetadata,
errorLayer,
}
}
type Result<T> = null | T | Promise<null | T> | PromiseLike<null | T>
type PrerenderedResult<TData extends object, TResolved> = {
resolveParent: ((value: TResolved) => void) | null
result: Result<TData>
}
function callResolver<T>(resolver: () => T | Promise<T>): T | Promise<T> {
let result: T | Promise<T>
try {
result = resolver()
} catch (error) {
result = Promise.reject(error)
}
if (result instanceof Promise) {
// Generators are eagerly executed, so attach a rejection handler before
// an earlier layer can suspend or fail.
result.catch(() => null)
}
return result
}
function getResult<TData extends object, TResolved>(
exportForResult: null | TData | InstrumentedResolver<TData, TResolved>
): PrerenderedResult<TData, TResolved> {
if (typeof exportForResult === 'function') {
// If the function is a 'use cache' function that uses the parent data as
// the second argument, we don't want to eagerly execute it during
// metadata/viewport pre-rendering, as the parent data might also be
// computed from another 'use cache' function. To ensure that the hanging
// input abort signal handling works in this case (i.e. the depending
// function waits for the cached input to resolve while encoding its args),
// they must be called sequentially. This can be accomplished by wrapping
// the call in a lazy promise, so that the original function is only called
// when the result is actually awaited.
const useCacheFunctionInfo = getUseCacheFunctionInfo(
exportForResult.$$original
)
if (useCacheFunctionInfo && !useCacheFunctionInfo.usedArgs[1]) {
return {
resolveParent: null,
result: callResolver(() => {
// @ts-expect-error We intentionally omit the parent argument, because
// we know this 'use cache' function does not use it.
return exportForResult()
}),
}
}
let resolveParent: (value: TResolved) => void
const parent = new Promise<TResolved>((resolve) => {
resolveParent = resolve
})
return {
resolveParent: resolveParent!,
result: useCacheFunctionInfo
? createLazyResult(() => exportForResult(parent))
: callResolver(() => exportForResult(parent)),
}
}
return {
resolveParent: null,
result: typeof exportForResult === 'object' ? exportForResult : null,
}
}
function resolveParentResult<T extends object>(
parentResult: T,
resolveParent: (value: T) => void
): void {
if (process.env.NODE_ENV === 'development') {
parentResult = (
require('../../shared/lib/deep-freeze') as typeof import('../../shared/lib/deep-freeze')
).deepFreeze(structuredClone(parentResult)) as T
}
resolveParent(parentResult)
}
function cloneStaticMetadata(metadata: StaticMetadata): StaticMetadata {
if (!metadata) return null
return {
...metadata,
icon: metadata.icon ? [...metadata.icon] : undefined,
apple: metadata.apple ? [...metadata.apple] : undefined,
openGraph: metadata.openGraph ? [...metadata.openGraph] : undefined,
twitter: metadata.twitter ? [...metadata.twitter] : undefined,
}
}
function createMetadataAccumulator(): MetadataAccumulator {
return {
metadata: createDefaultMetadata(),
titleTemplates: {
title: null,
twitter: null,
openGraph: null,
},
favicon: null,
leafSegmentStaticIcons: {
icon: [],
apple: [],
},
buildState: {
warnings: new Set<string>(),
},
}
}
function cloneMetadataAccumulator(
accumulator: MetadataAccumulator
): MetadataAccumulator {
return {
metadata: structuredClone(accumulator.metadata),
titleTemplates: { ...accumulator.titleTemplates },
favicon: accumulator.favicon ? structuredClone(accumulator.favicon) : null,
leafSegmentStaticIcons: {
icon: structuredClone(accumulator.leafSegmentStaticIcons.icon),
apple: structuredClone(accumulator.leafSegmentStaticIcons.apple),
},
buildState: {
warnings: new Set(accumulator.buildState.warnings),
},
}
}
function cloneViewportAccumulator(
accumulator: ViewportAccumulator
): ViewportAccumulator {
return {
viewport: structuredClone(accumulator.viewport),
}
}
async function accumulateMetadataLayer(
parent: Promise<MetadataAccumulator>,
prerendered: PrerenderedResult<Metadata, ResolvedMetadata>,
staticMetadata: Promise<StaticMetadata>,
route: string,
layerIndex: number,
pathname: Promise<string>,
metadataContext: MetadataContext
): Promise<MetadataAccumulator> {
const accumulator = await parent
const staticFilesMetadata = cloneStaticMetadata(await staticMetadata)
// Treat favicon as a special case. It should be the first icon in the list.
// layerIndex <= 1 represents the root layout and a page at the root.
if (layerIndex <= 1 && isFavicon(staticFilesMetadata?.icon?.[0])) {
const icon = staticFilesMetadata?.icon?.shift()
if (layerIndex === 0 && icon) {
accumulator.favicon = convertUrlsToStrings(icon)
}
}
if (prerendered.resolveParent) {
resolveParentResult(accumulator.metadata, prerendered.resolveParent)
}
let metadata: Metadata | null
if (isPromiseLike(prerendered.result)) {
metadata = await prerendered.result
} else {
metadata = prerendered.result
}
await mergeMetadata(route, pathname, {
metadata,
resolvedMetadata: accumulator.metadata,
staticFilesMetadata,
titleTemplates: accumulator.titleTemplates,
metadataContext,
buildState: accumulator.buildState,
leafSegmentStaticIcons: accumulator.leafSegmentStaticIcons,
cloneResolvedMetadata: false,
})
return accumulator
}
async function accumulateViewportLayer(
parent: Promise<ViewportAccumulator>,
prerendered: PrerenderedResult<Viewport, ResolvedViewport>
): Promise<ViewportAccumulator> {
const accumulator = await parent
if (prerendered.resolveParent) {
resolveParentResult(accumulator.viewport, prerendered.resolveParent)
}
let viewport: Viewport | null
if (isPromiseLike(prerendered.result)) {
viewport = await prerendered.result
} else {
viewport = prerendered.result
}
mergeViewport({
resolvedViewport: accumulator.viewport,
viewport,
cloneResolvedViewport: false,
})
return accumulator
}
function prepareMetadataAccumulatorForChild(
parent: Promise<MetadataAccumulator>,
clone: boolean,
childIsPage: boolean,
errorConvention: MetadataErrorType | undefined
): Promise<MetadataAccumulator> {
return parent.then((parentAccumulator) => {
const accumulator = clone
? cloneMetadataAccumulator(parentAccumulator)
: parentAccumulator
// A title template applies to a descendant segment, but not to a page in
// the same segment. Error convention metadata is an additional terminal
// layer, so the leaf layout's template does apply to it.
if (!childIsPage || errorConvention) {
accumulator.titleTemplates = {
title: accumulator.metadata.title?.template || null,
openGraph: accumulator.metadata.openGraph?.title.template || null,
twitter: accumulator.metadata.twitter?.title.template || null,
}
}
return accumulator
})
}
function prepareViewportAccumulatorForChild(
parent: Promise<ViewportAccumulator>,
clone: boolean
): Promise<ViewportAccumulator> {
return clone ? parent.then(cloneViewportAccumulator) : parent
}
function completeMetadataAccumulator(
accumulator: MetadataAccumulator,
metadataContext: MetadataContext
): ResolvedMetadata {
const { leafSegmentStaticIcons, metadata } = accumulator
if (
(leafSegmentStaticIcons.icon.length > 0 ||
leafSegmentStaticIcons.apple.length > 0) &&
!metadata.icons
) {
metadata.icons = {
icon: [],
apple: [],
}
if (leafSegmentStaticIcons.icon.length > 0) {
metadata.icons.icon.unshift(
...convertUrlsToStrings(leafSegmentStaticIcons.icon)
)
}
if (leafSegmentStaticIcons.apple.length > 0) {
metadata.icons.apple.unshift(
...convertUrlsToStrings(leafSegmentStaticIcons.apple)
)
}
}
return postProcessMetadata(
metadata,
accumulator.favicon,
accumulator.titleTemplates,
metadataContext
)
}
type MetadataTreeContext = {
pathname: Promise<string>
searchParams: Promise<ParsedUrlQuery>
errorConvention: MetadataErrorType | undefined
interpolatedParams: Params
metadataContext: MetadataContext
route: string
selectedKeyPath: string[] | null
resolutionTarget: ResolutionTarget
outlets: Map<LoaderTree, Promise<null>>
}
type MetadataTreeState = {
tree: LoaderTree
treeRoute: string | null
parentParams: Params
parentOptionalCatchAllParamName: string | null
metadataParent: Promise<MetadataAccumulator>
viewportParent: Promise<ViewportAccumulator>
errorLayer: MetadataLayer | null
definitionDepth: number
keyPath: string[]
}
type MetadataBranchAtFork = {
key: string
branch: MetadataBranch
}
function getResolutionStatus(
reason: unknown
): RejectedMetadataResolutionStatus {
if (isHTTPAccessFallbackError(reason)) {
return (
getAccessFallbackErrorTypeByStatus(getAccessFallbackHTTPStatus(reason)) ||
'error'
)
}
if (isRedirectError(reason)) {
return 'redirect'
}
return 'error'
}
function createRejectedOutcome(reason: unknown): RejectedOutcome {
return {
status: getResolutionStatus(reason),
reason,
}
}
function createMetadataBranchOutcome(
pendingAccumulator: Promise<MetadataAccumulator>,
metadataContext: MetadataContext
): Promise<MetadataBranchOutcome> {
const completed = pendingAccumulator.then((accumulator) => ({
value: createSelectedMetadata(
completeMetadataAccumulator(accumulator, metadataContext)
),
warnings: accumulator.buildState.warnings,
}))
return completed.then(
({ value, warnings }) => ({
status: 'resolved',
value,
warnings,
}),
createRejectedOutcome
)
}
function createViewportBranchOutcome(
pendingAccumulator: Promise<ViewportAccumulator>
): Promise<ViewportBranchOutcome> {
return pendingAccumulator.then(
(accumulator) => ({
status: 'resolved',
value: accumulator.viewport,
}),
createRejectedOutcome
)
}
function createOutletPromise(
metadataOutcome: Promise<MetadataBranchOutcome>,
viewportOutcome: Promise<ViewportBranchOutcome>
): Promise<null> {
let pendingOutcomes = 2
const outlet = new Promise<null>((resolve, reject) => {
function settle(outcome: ResolutionOutcome<unknown>) {
if (outcome.status !== 'resolved') {
reject(outcome.reason)
} else if (--pendingOutcomes === 0) {
resolve(null)
}
}
metadataOutcome.then(settle, reject)
viewportOutcome.then(settle, reject)
})
// Outlet promises can reject before React renders the corresponding slot.
// Observe the rejection immediately while preserving it for React to replay.
outlet.catch(() => null)
return outlet
}
function appendTreeRoute(
parentRoute: string | null,
segment: string
): string | null {
if (segment === PAGE_SEGMENT_KEY) return parentRoute
if (parentRoute === null) return segment
return `${parentRoute}/${segment}`
}
function isPageTree(tree: LoaderTree): boolean {
const { layout, page, defaultPage } = tree[2]
return (
layout === undefined &&
(page !== undefined ||
(defaultPage !== undefined && tree[0] === DEFAULT_SEGMENT_KEY))
)
}
function isBuiltinFallback(tree: LoaderTree): boolean {
const { defaultPage } = tree[2]
return (
defaultPage?.[1].endsWith(PARALLEL_ROUTE_DEFAULT_PATH) === true ||
defaultPage?.[1].endsWith(PARALLEL_ROUTE_DEFAULT_NULL_PATH) === true
)
}
function hasHeadDefinition(layer: MetadataLayer | null): boolean {
if (layer === null) return false
return (
layer.metadata !== null ||
layer.viewport !== null ||
layer.hasStaticFilesMetadata
)
}
function hasStaticMetadataFiles(tree: LoaderTree): boolean {
const metadata = tree[2].metadata
return Boolean(
metadata &&
((metadata.icon?.length ?? 0) > 0 ||
(metadata.apple?.length ?? 0) > 0 ||
(metadata.openGraph?.length ?? 0) > 0 ||
(metadata.twitter?.length ?? 0) > 0 ||
metadata.manifest !== undefined)
)
}
function selectDefaultMetadataBranch(
branches: MetadataBranchAtFork[],
forkDepth: number
): MetadataBranch {
if (branches.length === 0) {
throw new InvariantError('Expected at least one metadata branch')
}
let selected = branches[0]
for (let i = 1; i < branches.length; i++) {
const candidate = branches[i]
if (
selected.branch.isBuiltinFallback !== candidate.branch.isBuiltinFallback
) {
if (!candidate.branch.isBuiltinFallback) {
selected = candidate
}
continue
}
const selectedIsChildren = selected.key === 'children'
const candidateIsChildren = candidate.key === 'children'
if (selectedIsChildren !== candidateIsChildren) {
const childrenBranch = selectedIsChildren ? selected : candidate
const namedBranch = selectedIsChildren ? candidate : selected
const childrenDefinesHead =
childrenBranch.branch.definitionDepth > forkDepth
const namedDefinesHead = namedBranch.branch.definitionDepth > forkDepth
// Prefer children when it contributes to the head. Otherwise, allow a
// named slot with its own definition to provide the selected metadata.
selected =
childrenDefinesHead || !namedDefinesHead ? childrenBranch : namedBranch
continue
}
if (candidate.branch.definitionDepth > selected.branch.definitionDepth) {
selected = candidate
continue
}
if (candidate.branch.definitionDepth < selected.branch.definitionDepth) {
continue
}
const selectedDepth = selected.branch.keyPath.length
const candidateDepth = candidate.branch.keyPath.length
if (candidateDepth > selectedDepth) {
selected = candidate
continue
}
if (candidateDepth === selectedDepth && candidate.key < selected.key) {
selected = candidate
}
}
return selected.branch
}
async function walkMetadataTree(
context: MetadataTreeContext,
state: MetadataTreeState
): Promise<MetadataBranch> {
const [segment, parallelRoutes, { page }] = state.tree
const treeRoute = appendTreeRoute(state.treeRoute, segment)
const isPage = page !== undefined
const depth = state.keyPath.length
const shouldResolveMetadata = Boolean(context.resolutionTarget & METADATA)
const shouldResolveViewport = Boolean(context.resolutionTarget & VIEWPORT)
let currentParams = state.parentParams
const segmentParam = getSegmentParam(segment)
if (segmentParam) {
const value = context.interpolatedParams[segmentParam.paramName]
if (value !== null && value !== undefined) {
currentParams = {
...state.parentParams,
[segmentParam.paramName]: value,
}
}
}
const optionalCatchAllParamName: string | null =
segmentParam?.paramType === 'optional-catchall' &&
(context.interpolatedParams[segmentParam.paramName] === null ||
context.interpolatedParams[segmentParam.paramName] === undefined)
? segmentParam.paramName
: state.parentOptionalCatchAllParamName
const params = createServerParamsForMetadata(
currentParams,
optionalCatchAllParamName
)
const props: SegmentProps = isPage
? { params, searchParams: context.searchParams }
: { params }
const layer = await collectMetadataAndViewport({
tree: state.tree,
props,
route: treeRoute ?? '',
errorConvention: context.errorConvention,
resolutionTarget: context.resolutionTarget,
})
let definitionDepth = hasHeadDefinition(layer) ? depth : state.definitionDepth
// Invoke each active generator as soon as this layer is discovered. Its
// parent promise is resolved later when the preceding accumulator is ready.
let metadata = state.metadataParent
if (shouldResolveMetadata) {
const prerenderedMetadata = getResult<Metadata, ResolvedMetadata>(
layer.metadata
)
metadata = accumulateMetadataLayer(
metadata,
prerenderedMetadata,
layer.staticFilesMetadata,
context.route,
depth,
context.pathname,
context.metadataContext
)
}
let viewport = state.viewportParent
if (shouldResolveViewport) {
const prerenderedViewport = getResult<Viewport, ResolvedViewport>(
layer.viewport
)
viewport = accumulateViewportLayer(viewport, prerenderedViewport)
}
const errorLayer = layer.errorLayer || state.errorLayer
let parallelRouteKeys = Object.keys(parallelRoutes)
if (context.selectedKeyPath !== null) {
const selectedKey = context.selectedKeyPath[depth]
if (parallelRouteKeys.length === 0) {
if (selectedKey !== undefined) {
throw new InvariantError(
'Expected selected metadata branch to end at a leaf'
)
}
} else {
if (selectedKey === undefined || !parallelRoutes[selectedKey]) {
throw new InvariantError(
'Expected selected metadata branch to match loader tree'
)
}
parallelRouteKeys = [selectedKey]
}
}
if (parallelRouteKeys.length === 0) {
if (context.errorConvention) {
if (hasHeadDefinition(errorLayer)) {
definitionDepth = depth + 1
}
if (shouldResolveMetadata) {
const errorMetadata = getResult<Metadata, ResolvedMetadata>(
errorLayer?.metadata || null
)
metadata = accumulateMetadataLayer(
metadata,
errorMetadata,
errorLayer?.staticFilesMetadata || Promise.resolve(null),
context.route,
depth + 1,
context.pathname,
context.metadataContext
)
}
if (shouldResolveViewport) {
const errorViewport = getResult<Viewport, ResolvedViewport>(
errorLayer?.viewport || null
)
viewport = accumulateViewportLayer(viewport, errorViewport)
}
}
const metadataOutcome = createMetadataBranchOutcome(
metadata,
context.metadataContext
)
const viewportOutcome = createViewportBranchOutcome(viewport)
context.outlets.set(
state.tree,
createOutletPromise(metadataOutcome, viewportOutcome)
)
return {
metadata: metadataOutcome,
viewport: viewportOutcome,
keyPath: state.keyPath,
definitionDepth,
isBuiltinFallback: isBuiltinFallback(state.tree),
}
}
const cloneAtFork = parallelRouteKeys.length > 1
const pendingChildBranches: Array<{
key: string
branch: Promise<MetadataBranch>
}> = []
for (const parallelRouteKey of parallelRouteKeys) {
const childTree = parallelRoutes[parallelRouteKey]
const childKeyPath = [...state.keyPath, parallelRouteKey]
const branch = walkMetadataTree(context, {
tree: childTree,
treeRoute,
parentParams: currentParams,
parentOptionalCatchAllParamName: optionalCatchAllParamName,
metadataParent: prepareMetadataAccumulatorForChild(
metadata,
cloneAtFork && shouldResolveMetadata,
isPageTree(childTree),
context.errorConvention
),
viewportParent: prepareViewportAccumulatorForChild(
viewport,
cloneAtFork && shouldResolveViewport
),
errorLayer,
definitionDepth,
keyPath: childKeyPath,
})
// Child walks start eagerly, but are awaited in order below. Observe each
// rejection now so a failure in one branch cannot leave a later sibling's
// rejection unhandled.
branch.catch(() => null)
pendingChildBranches.push({
key: parallelRouteKey,
branch,
})
}
const childBranches: MetadataBranchAtFork[] = []
for (const pendingChildBranch of pendingChildBranches) {
childBranches.push({
key: pendingChildBranch.key,
branch: await pendingChildBranch.branch,
})
}
return selectDefaultMetadataBranch(childBranches, depth)
}
async function resolveMetadataTree(
tree: LoaderTree,
pathname: Promise<string>,
searchParams: Promise<ParsedUrlQuery>,
errorConvention: MetadataErrorType | undefined,
interpolatedParams: Params,
metadataContext: MetadataContext,
selectedKeyPath: string[] | null,
resolutionTarget: ResolutionTarget
): Promise<MetadataResolution> {
const workStore = workAsyncStorage.getStore()
if (!workStore) {
throw new InvariantError('Expected workStore to be initialized')
}
const outlets = new Map<LoaderTree, Promise<null>>()
const selectedBranch = await walkMetadataTree(
{
pathname,
searchParams,
errorConvention,
interpolatedParams,
metadataContext,
route: workStore.route,
selectedKeyPath,
resolutionTarget,
outlets,
},
{
tree,
treeRoute: null,
parentParams: {},
parentOptionalCatchAllParamName: null,
metadataParent: Promise.resolve(createMetadataAccumulator()),
viewportParent: Promise.resolve({
viewport: createDefaultViewport(),
}),
errorLayer: null,
definitionDepth: -1,
keyPath: [],
}
)
const selected = selectedBranch.metadata.then((outcome) => {
if (outcome.status === 'resolved') {
for (const warning of outcome.warnings) {
Log.warn(warning)
}
}
return outcome
})
return {
selectedKeyPath: selectedBranch.keyPath,
selectedMetadata: selected,
selectedViewport: selectedBranch.viewport,
outlets,
}
}
export function resolveMetadataResolution(
tree: LoaderTree,
pathname: Promise<string>,
searchParams: Promise<ParsedUrlQuery>,
errorConvention: MetadataErrorType | undefined,
interpolatedParams: Params,
metadataContext: MetadataContext
): Promise<MetadataResolution> {
return resolveMetadataTree(
tree,
pathname,
searchParams,
errorConvention,
interpolatedParams,
metadataContext,
null,
METADATA_AND_VIEWPORT
)
}
export async function resolveMetadataForBranch(
tree: LoaderTree,
pathname: Promise<string>,
searchParams: Promise<ParsedUrlQuery>,
errorConvention: MetadataErrorType,
interpolatedParams: Params,
metadataContext: MetadataContext,
selectedKeyPath: string[]
): Promise<MetadataBranchOutcome> {
const resolution = await resolveMetadataTree(
tree,
pathname,
searchParams,
errorConvention,
interpolatedParams,
metadataContext,
selectedKeyPath,
METADATA
)
return resolution.selectedMetadata
}
export async function resolveViewportForBranch(
tree: LoaderTree,
pathname: Promise<string>,
searchParams: Promise<ParsedUrlQuery>,
errorConvention: MetadataErrorType,
interpolatedParams: Params,
metadataContext: MetadataContext,
selectedKeyPath: string[]
): Promise<ViewportBranchOutcome> {
const resolution = await resolveMetadataTree(
tree,
pathname,
searchParams,
errorConvention,
interpolatedParams,
metadataContext,
selectedKeyPath,
VIEWPORT
)
return resolution.selectedViewport
}
function isPromiseLike<T>(
value: unknown | PromiseLike<T>
): value is PromiseLike<T> {
return (
typeof value === 'object' &&
value !== null &&
typeof (value as PromiseLike<unknown>).then === 'function'
)
}
......@@ -35,7 +35,6 @@ import {
type MetadataErrorType,
type MetadataItems,
type PageProps,
type Resolved,
type SegmentProps,
type SelectedMetadata,
type TitleTemplates,
......@@ -390,7 +389,7 @@ function prerenderMetadata(metadataItems: MetadataItems) {
> = []
for (let i = 0; i < metadataItems.length; i++) {
const metadataExport = metadataItems[i][0]
getResult<Metadata>(resolversAndResults, metadataExport)
getResult<Metadata, ResolvedMetadata>(resolversAndResults, metadataExport)
}
return resolversAndResults
}
......@@ -404,18 +403,16 @@ function prerenderViewport(viewportItems: ViewportItems) {
> = []
for (let i = 0; i < viewportItems.length; i++) {
const viewportExport = viewportItems[i]
getResult<Viewport>(resolversAndResults, viewportExport)
getResult<Viewport, ResolvedViewport>(resolversAndResults, viewportExport)
}
return resolversAndResults
}
const noop = () => {}
function getResult<TData extends object>(
resolversAndResults: Array<
((value: Resolved<TData>) => void) | Result<TData>
>,
exportForResult: null | TData | InstrumentedResolver<TData>
function getResult<TData extends object, TResolved>(
resolversAndResults: Array<((value: TResolved) => void) | Result<TData>>,
exportForResult: null | TData | InstrumentedResolver<TData, TResolved>
) {
if (typeof exportForResult === 'function') {
// If the function is a 'use cache' function that uses the parent data as
......@@ -431,7 +428,7 @@ function getResult<TData extends object>(
exportForResult.$$original
)
if (useCacheFunctionInfo && useCacheFunctionInfo.usedArgs[1]) {
const promise = new Promise<Resolved<TData>>((resolve) =>
const promise = new Promise<TResolved>((resolve) =>
resolversAndResults.push(resolve)
)
resolversAndResults.push(
......@@ -447,9 +444,7 @@ function getResult<TData extends object>(
result = exportForResult()
} else {
result = exportForResult(
new Promise<Resolved<TData>>((resolve) =>
resolversAndResults.push(resolve)
)
new Promise<TResolved>((resolve) => resolversAndResults.push(resolve))
)
}
resolversAndResults.push(result)
......
......@@ -72,7 +72,7 @@ type CreateComponentTreeProps = {
missingSlots?: Set<string>
preloadCallbacks: PreloadCallbacks
authInterrupts: boolean
MetadataOutlet: ComponentType
MetadataOutlet: ComponentType<{ tree: LoaderTree }>
isPrerendering: boolean
hintTree: PrefetchHints | null
}
......@@ -153,7 +153,7 @@ async function createComponentTreeInternal(
missingSlots?: Set<string>
preloadCallbacks: PreloadCallbacks
authInterrupts: boolean
MetadataOutlet: ComponentType | null
MetadataOutlet: ComponentType<{ tree: LoaderTree }> | null
isPrerendering: boolean
hintTree: PrefetchHints | null
},
......@@ -630,9 +630,10 @@ async function createComponentTreeInternal(
missingSlots,
preloadCallbacks,
authInterrupts,
// `StreamingMetadataOutlet` is used to conditionally throw. In the case of parallel routes we will have more than one page
// but we only want to throw on the first one.
MetadataOutlet: isChildrenRouteKey ? MetadataOutlet : null,
MetadataOutlet:
experimental.parallelRouteMetadata || isChildrenRouteKey
? MetadataOutlet
: null,
isPrerendering,
hintTree: childHintTree,
},
......@@ -924,7 +925,7 @@ async function createComponentTreeInternal(
},
wrappedPageElement,
layerAssets,
MetadataOutlet ? createElement(MetadataOutlet, null) : null
MetadataOutlet ? createElement(MetadataOutlet, { tree }) : null
),
parallelRouteNodes,
loadingData,
......
......@@ -58,7 +58,7 @@ export {
} from '../request/params'
export * as serverHooks from '../../client/components/hooks-server-context'
export { HTTPAccessFallbackBoundary } from '../../client/components/http-access-fallback/error-boundary'
export { createMetadataComponents } from '../../lib/metadata/metadata'
export { createMetadataComponents } from '../../lib/metadata'
export { RootLayoutBoundary } from '../../lib/framework/boundary-components'
export { preloadStyle, preloadFont, preconnect } from './rsc/preloads'
......
......@@ -163,6 +163,7 @@ export interface RenderOptsPartial {
clientParamParsingOrigins: string[] | undefined
dynamicOnHover: boolean
optimisticRouting: boolean
parallelRouteMetadata: boolean
inlineCss: boolean
prefetchInlining: PrefetchInliningConfig
authInterrupts: boolean
......
......@@ -70,7 +70,7 @@ export async function walkTreeWithFlightRouterState({
rootLayoutIncluded: boolean
ctx: AppRenderContext
preloadCallbacks: PreloadCallbacks
MetadataOutlet: React.ComponentType
MetadataOutlet: React.ComponentType<{ tree: LoaderTree }>
hintTree: PrefetchHints | null
}): Promise<NavigationResponseTree | null> {
const {
......@@ -355,7 +355,7 @@ export async function createFullTreeForNavigation({
injectedFontPreloadTags: Set<string>
ctx: AppRenderContext
preloadCallbacks: PreloadCallbacks
MetadataOutlet: React.ComponentType
MetadataOutlet: React.ComponentType<{ tree: LoaderTree }>
}): Promise<NavigationResponseTree> {
const {
renderOpts: { experimental },
......
......@@ -605,6 +605,8 @@ export default abstract class Server<
dynamicOnHover: this.nextConfig.experimental.dynamicOnHover ?? false,
optimisticRouting:
this.nextConfig.experimental.optimisticRouting ?? false,
parallelRouteMetadata:
this.nextConfig.experimental.parallelRouteMetadata ?? false,
inlineCss: this.nextConfig.experimental.inlineCss ?? false,
prefetchInlining:
this.nextConfig.experimental.prefetchInlining ?? false,
......
......@@ -196,6 +196,7 @@ export const experimentalSchema = {
useSkewCookie: z.boolean().optional(),
after: z.boolean().optional(),
appNavFailHandling: z.boolean().optional(),
parallelRouteMetadata: z.boolean().optional(),
coldCacheBadge: z.boolean().optional(),
collapseAdapterRoutes: z.boolean().optional(),
preloadEntriesOnStart: z.boolean().optional(),
......
......@@ -515,6 +515,7 @@ export interface ExperimentalConfig {
cacheHandlers?: NextConfig['cacheHandlers']
multiZoneDraftMode?: boolean
appNavFailHandling?: boolean
parallelRouteMetadata?: boolean
prerenderEarlyExit?: boolean
linkNoTouchStart?: boolean
caseSensitiveRoutes?: boolean
......@@ -2283,6 +2284,7 @@ export const defaultConfig = Object.freeze({
cssChunking: true,
multiZoneDraftMode: false,
appNavFailHandling: false,
parallelRouteMetadata: false,
prerenderEarlyExit: true,
serverMinification: true,
linkNoTouchStart: false,
......@@ -2454,6 +2456,7 @@ export interface NextConfigRuntime {
| 'dynamicOnHover'
| 'useOffline'
| 'optimisticRouting'
| 'parallelRouteMetadata'
| 'inlineCss'
| 'prefetchInlining'
| 'authInterrupts'
......@@ -2523,6 +2526,7 @@ export function getNextConfigRuntime(
dynamicOnHover: ex.dynamicOnHover,
useOffline: ex.useOffline,
optimisticRouting: ex.optimisticRouting,
parallelRouteMetadata: ex.parallelRouteMetadata,
inlineCss: ex.inlineCss,
prefetchInlining: ex.prefetchInlining,
authInterrupts: ex.authInterrupts,
......
export async function generateMetadata() {
await Promise.resolve()
throw new Error('unrendered slot metadata error')
}
export default function ErrorSlot() {
return <div>error slot</div>
}
import { ImageResponse } from 'next/og'
export function generateImageMetadata() {
if (process.env.NEXT_PHASE === 'phase-production-build') {
return [
{
id: 'image',
size: { width: 1200, height: 630 },
contentType: 'image/png',
},
]
}
throw new Error('unrendered slot image metadata error')
}
export default function OpenGraphImage() {
return new ImageResponse(<div>image error slot</div>)
}
export default function ImageErrorSlot() {
return <div>image error slot</div>
}
import { notFound } from 'next/navigation'
export function generateMetadata() {
notFound()
}
export default function Login() {
return <div>login</div>
}
export async function generateViewport() {
await Promise.resolve()
throw new Error('unrendered slot viewport error')
}
export default function ViewportErrorSlot() {
return <div>viewport error slot</div>
}
import type { ReactNode } from 'react'
import { connection } from 'next/server'
export const metadata = {
title: {
default: 'conditional layout title',
template: '[%s]',
},
}
export default async function Layout({
children,
}: {
children: ReactNode
error: ReactNode
imageError: ReactNode
login: ReactNode
viewportError: ReactNode
}) {
// This route intentionally contains a regular metadata error in an
// unrendered slot. Keep it request-rendered so the production build can
// exercise the outlet behavior at request time.
await connection()
return children
}
export const metadata = {
title: 'conditional children title',
}
export default function Page() {
return <div id="conditional-children">conditional children</div>
}
import { markGeneratorStarted } from '../state'
export function generateMetadata() {
markGeneratorStarted('slot')
return { title: 'eager slot title' }
}
export function generateViewport() {
markGeneratorStarted('slot-viewport')
return { width: 'device-width' }
}
export default function Page() {
return <div id="eager-slot">eager slot</div>
}
import type { ReactNode } from 'react'
import { waitForGenerator } from './state'
export async function generateMetadata() {
let timeout: NodeJS.Timeout
const generatorsStartedEagerly = await Promise.race([
Promise.all([waitForGenerator('children'), waitForGenerator('slot')]).then(
() => true
),
new Promise<boolean>((resolve) => {
timeout = setTimeout(() => resolve(false), 5000)
}),
])
clearTimeout(timeout!)
return {
description: generatorsStartedEagerly
? 'parallel generators started eagerly'
: 'parallel generators were serialized',
}
}
export async function generateViewport() {
let timeout: NodeJS.Timeout
const generatorsStartedEagerly = await Promise.race([
Promise.all([
waitForGenerator('children-viewport'),
waitForGenerator('slot-viewport'),
]).then(() => true),
new Promise<boolean>((resolve) => {
timeout = setTimeout(() => resolve(false), 5000)
}),
])
clearTimeout(timeout!)
return {
colorScheme: generatorsStartedEagerly
? ('dark' as const)
: ('light' as const),
}
}
export default function Layout({
children,
slot,
}: {
children: ReactNode
slot: ReactNode
}) {
return (
<main>
{children}
{slot}
</main>
)
}
import { markGeneratorStarted } from './state'
export function generateMetadata() {
markGeneratorStarted('children')
return { title: 'eager children title' }
}
export function generateViewport() {
markGeneratorStarted('children-viewport')
return { width: 'device-width' }
}
export default function Page() {
return <div id="eager-children">eager children</div>
}
type EagerGenerationState = {
started: Set<string>
waiters: Map<string, Array<() => void>>
}
const stateKey = Symbol.for('next.metadata.eager-generation')
const globalWithState = globalThis as typeof globalThis & {
[stateKey]?: EagerGenerationState
}
function getState(): EagerGenerationState {
return (globalWithState[stateKey] ||= {
started: new Set(),
waiters: new Map(),
})
}
export function markGeneratorStarted(name: string) {
const state = getState()
state.started.add(name)
const waiters = state.waiters.get(name)
if (waiters) {
state.waiters.delete(name)
for (const resolve of waiters) {
resolve()
}
}
}
export function waitForGenerator(name: string): Promise<void> {
const state = getState()
if (state.started.has(name)) {
return Promise.resolve()
}
return new Promise((resolve) => {
const waiters = state.waiters.get(name)
if (waiters) {
waiters.push(resolve)
} else {
state.waiters.set(name, [resolve])
}
})
}
export function generateMetadata(): Promise<never> {
return new Promise<never>(() => {})
}
export async function generateViewport() {
await Promise.resolve()
throw new Error('rendered slot viewport error')
}
export default function SlotPage() {
return <div>slot page</div>
}
'use client'
export default function Error() {
return <div id="outlet-viewport-error">viewport error reached boundary</div>
}
export const dynamic = 'force-dynamic'
export default function Layout({ children, slot }) {
return (
<>
{children}
{slot}
</>
)
}
export const metadata = {
title: 'independent outlet errors',
}
export default function Page() {
return <div>children page</div>
}
export default function Page() {
return <div>bar shallower page</div>
}
export const metadata = {
title: 'bar shallower title',
}
export default function Page() {
return <div>bar lexical page</div>
}
export const metadata = {
title: 'bar lexical title',
}
export default function Page() {
return <div>foo deeper page</div>
}
export const metadata = {
title: 'foo deeper title',
}
export default function Page() {
return <div>foo lexical page</div>
}
export const metadata = {
title: 'foo lexical title',
}
export default function Layout({ bar, foo }) {
return (
<main>
<div id="bar-slot">{bar}</div>
<div id="foo-slot">{foo}</div>
</main>
)
}
import Link from 'next/link'
export default function Page() {
return (
<Link
id="independent-outlet-errors-link"
href="/independent-outlet-errors"
prefetch={false}
>
open independent outlet errors
</Link>
)
}
export default function Page() {
return <div id="bar-conflict-page">bar slot page</div>
}
export const metadata = {
title: 'bar slot title',
}
<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 16 16">
<circle cx="8" cy="8" r="8" fill="black" />
</svg>
export default function Page() {
return <div id="slot-with-metadata">slot with metadata</div>
}
export default function Page() {
return <div id="foo-conflict-page">foo slot page</div>
}
export const metadata = {
title: 'foo slot title',
}
export default function Page() {
return <div id="children-page">children page</div>
}
export const metadata = {
title: 'children title',
}
export default function Page() {
return <div id="children-without-metadata">children without metadata</div>
}
import { promises as fs } from 'fs'
import { join } from 'path'
import { nextTestSetup } from 'e2e-utils'
import { retry } from 'next-test-utils'
describe('app-dir - metadata-streaming', () => {
const { next } = nextTestSetup({
const parallelMetadataBundleMarker = 'Expected at least one metadata branch'
const legacyMetadataBundleMarker = '__nextError'
async function directoryContains(
directory: string,
expected: string
): Promise<boolean> {
for (const entry of await fs.readdir(directory, { withFileTypes: true })) {
const entryPath = join(directory, entry.name)
if (entry.isDirectory()) {
if (await directoryContains(entryPath, expected)) {
return true
}
} else if (
entry.isFile() &&
(entry.name.endsWith('.js') || entry.name.endsWith('.map')) &&
(await fs.readFile(entryPath, 'utf8')).includes(expected)
) {
return true
}
}
return false
}
function runMetadataStreamingTests(parallelRouteMetadata: boolean) {
const { next, isNextDeploy } = nextTestSetup({
files: __dirname,
nextConfig: {
experimental: {
parallelRouteMetadata,
},
},
})
// The deploy harness does not expose the emitted server bundle.
// @gate !deploy
it('should only bundle the selected metadata resolution implementation', async () => {
await next.fetch('/parallel-routes')
const serverDirectory = join(next.testDir, next.distDir, 'server')
const [hasParallelMetadata, hasLegacyMetadata] = await Promise.all([
directoryContains(serverDirectory, parallelMetadataBundleMarker),
directoryContains(serverDirectory, legacyMetadataBundleMarker),
])
expect(hasParallelMetadata).toBe(parallelRouteMetadata)
expect(hasLegacyMetadata).toBe(!parallelRouteMetadata)
})
it('should only insert metadata once for parallel routes when slots match', async () => {
......@@ -56,10 +103,85 @@ describe('app-dir - metadata-streaming', () => {
const $ = await next.render$('/parallel-routes-default')
expect($('title').length).toBe(1)
expect($('body title').text()).toBe('parallel-routes-default layout title')
expect($('title').text()).toBe('parallel-routes-default layout title')
})
if (!parallelRouteMetadata) return
it('should prefer children when it defines metadata', async () => {
const $ = await next.render$('/parallel-routes/metadata-conflict')
expect($('title').text()).toBe('children title')
const browser = await next.browser('/parallel-routes/metadata-conflict')
expect(await browser.elementByCss('title').text()).toBe('children title')
expect((await browser.elementsByCss('title')).length).toBe(1)
})
it('should change metadata when navigating between two pages under a slot when children is not rendered', async () => {
it('should prefer a named slot when children does not define metadata', async () => {
const $ = await next.render$('/parallel-routes/metadata-slot-only')
const icons = $('link[rel="icon"]')
.map((_, element) => $(element).attr('href'))
.get()
expect(icons).toContainEqual(
expect.stringContaining('/parallel-routes/metadata-slot-only/icon')
)
})
it('should ignore metadata errors from unrendered slots', async () => {
const outputIndex = next.cliOutput.length
const $ = await next.render$('/conditional-slot')
expect($('title').text()).toBe('conditional children title')
expect($('#conditional-children').text()).toBe('conditional children')
expect($('.next-error-h1').length).toBe(0)
if (!isNextDeploy) {
await retry(() => {
const output = next.cliOutput.slice(outputIndex)
expect(output).toContain('unrendered slot metadata error')
expect(output).toContain('unrendered slot image metadata error')
expect(output).toContain('unrendered slot viewport error')
expect(output).not.toContain('Array.map (<anonymous>)')
expect(output).not.toContain('Function.all (<anonymous>)')
})
}
})
it('should start generators in every branch before their parent resolves', async () => {
const $ = await next.render$('/eager-generation')
expect($('title').text()).toBe('eager children title')
expect($('meta[name="description"]').attr('content')).toBe(
'parallel generators started eagerly'
)
expect($('meta[name="color-scheme"]').attr('content')).toBe('dark')
expect($('#eager-children').text()).toBe('eager children')
expect($('#eager-slot').text()).toBe('eager slot')
})
it('should replay a viewport error without waiting for metadata in the same outlet', async () => {
const browser = await next.browser('/outlet-error-start')
await browser.elementByCss('#independent-outlet-errors-link').click()
await retry(async () => {
expect(await browser.elementByCss('#outlet-viewport-error').text()).toBe(
'viewport error reached boundary'
)
})
})
it('should prefer the deeper named slot metadata', async () => {
const $ = await next.render$('/metadata-selection/deepest')
expect($('title').text()).toBe('foo deeper title')
})
it('should use lexical slot order to break depth ties', async () => {
const $ = await next.render$('/metadata-selection/lexical')
expect($('title').text()).toBe('bar lexical title')
})
it('should prefer a real named slot over an implicit children fallback', async () => {
// first page is /parallel-routes-no-children/first,
// second page is /parallel-routes-no-children/second
// navigating between them should change the title metadata
......@@ -83,4 +205,11 @@ describe('app-dir - metadata-streaming', () => {
'second page - @bar'
)
})
})
}
describe.each([false, true])(
'app-dir - metadata-streaming (parallelRouteMetadata: %s)',
(parallelRouteMetadata) => {
runMetadataStreamingTests(parallelRouteMetadata)
}
)
/**
* @type {import('next').NextConfig}
*/
const nextConfig = {}
module.exports = nextConfig
import { nextTestSetup } from 'e2e-utils'
describe('parallel-route-not-found', () => {
function runParallelRouteNotFoundTests(parallelRouteMetadata: boolean) {
const { next, isNextDev } = nextTestSetup({
files: __dirname,
nextConfig: {
experimental: {
parallelRouteMetadata,
},
},
})
// TODO: adjust the test to work with the new error
......@@ -81,27 +86,37 @@ describe('parallel-route-not-found', () => {
)
})
it('should handle `notFound()` in a slot', async () => {
const browser = await next.browser('/not-found-metadata/slot-error')
if (parallelRouteMetadata) {
it('should throw `notFound()` from a rendered slot outlet', async () => {
const browser = await next.browser('/not-found-metadata/slot-error')
// The page's `generateMetadata` function threw a `notFound()` error,
// so we should see the not found page.
expect(await browser.elementByCss('body').text()).toContain(
'Custom Not Found!'
)
})
// The rendered @bar outlet is outside the children route that owns the
// custom not-found boundary, so the error reaches the global boundary.
expect(await browser.elementByCss('body').text()).toContain(
'This page could not be found'
)
})
// TODO-APP: This test should probably work. But we only provide a not-found boundary for the children slot.
// This means that if a parallel route throws a notFound() in generateMetadata, it won't be properly handled.
it.skip('should handle `notFound()` in a slot with no `children` slot', async () => {
const browser = await next.browser('/not-found-metadata/no-page')
it('should handle `notFound()` in a slot with no `children` slot', async () => {
const browser = await next.browser('/not-found-metadata/no-page')
// The page's `generateMetadata` function threw a `notFound()` error,
// so we should see the not found page.
expect(await browser.elementByCss('body').text()).toContain(
'Custom Not Found!'
)
})
// The slot's `generateMetadata` function threw a `notFound()` error,
// so we should see the not found page.
expect(await browser.elementByCss('body').text()).toContain(
'Custom Not Found!'
)
})
} else {
it('should handle `notFound()` in a slot', async () => {
const browser = await next.browser('/not-found-metadata/slot-error')
// The page's `generateMetadata` function threw a `notFound()` error,
// so we should see the not found page.
expect(await browser.elementByCss('body').text()).toContain(
'Custom Not Found!'
)
})
}
if (isNextDev) {
it('should not log any warnings for a regular not found page', async () => {
......@@ -114,4 +129,11 @@ describe('parallel-route-not-found', () => {
expect(warnings.length).toBe(0)
})
}
})
}
describe.each([false, true])(
'parallel-route-not-found (parallelRouteMetadata: %s)',
(parallelRouteMetadata) => {
runParallelRouteNotFoundTests(parallelRouteMetadata)
}
)
......@@ -297,10 +297,14 @@ async function readNormalizedNFT(next, name) {
"/node_modules/next/dist/lib/metadata/generate/icon-mark.js",
"/node_modules/next/dist/lib/metadata/generate/utils.js",
"/node_modules/next/dist/lib/metadata/get-metadata-route.js",
"/node_modules/next/dist/lib/metadata/index.js",
"/node_modules/next/dist/lib/metadata/is-metadata-route.js",
"/node_modules/next/dist/lib/metadata/metadata-context.js",
"/node_modules/next/dist/lib/metadata/metadata-elements.js",
"/node_modules/next/dist/lib/metadata/metadata-parallel.js",
"/node_modules/next/dist/lib/metadata/metadata-resolution-primitives.js",
"/node_modules/next/dist/lib/metadata/metadata.js",
"/node_modules/next/dist/lib/metadata/resolve-metadata-parallel.js",
"/node_modules/next/dist/lib/metadata/resolve-metadata.js",
"/node_modules/next/dist/lib/metadata/resolvers/resolve-basics.js",
"/node_modules/next/dist/lib/metadata/resolvers/resolve-icons.js",
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment