Unverified Commit 2bf2c9c5 authored by Josh Story's avatar Josh Story Committed by GitHub

Simplify metadata tag rendering to flat imperative style (#90209)

Replace the layered abstraction (Meta, MetaFilter, MultiMeta,
ExtendMeta, and 12 category component functions across 5 files) with a
single flat function that builds a tags array using explicit if-checks
and for-loops. Every meta/link tag is now visible as literal JSX at the
call site. OG image/video/audio properties and AppLinks fields are
enumerated explicitly rather than iterated generically from object keys.
Keys are assigned directly on each element at push time, eliminating the
cloneElement keying pass.
parent 56adc02e
import type { ResolvedMetadata } from '../types/metadata-interface'
import type { AlternateLinkDescriptor } from '../types/alternative-urls-types'
import React from 'react'
import { MetaFilter } from './meta'
function AlternateLink({
descriptor,
...props
}: {
descriptor: AlternateLinkDescriptor
} & React.LinkHTMLAttributes<HTMLLinkElement>) {
if (!descriptor.url) return null
return (
<link
{...props}
{...(descriptor.title && { title: descriptor.title })}
href={descriptor.url.toString()}
/>
)
}
export function AlternatesMetadata({
alternates,
}: {
alternates: ResolvedMetadata['alternates']
}) {
if (!alternates) return null
const { canonical, languages, media, types } = alternates
return MetaFilter([
canonical
? AlternateLink({ rel: 'canonical', descriptor: canonical })
: null,
languages
? Object.entries(languages).flatMap(([locale, descriptors]) =>
descriptors?.map((descriptor) =>
AlternateLink({ rel: 'alternate', hrefLang: locale, descriptor })
)
)
: null,
media
? Object.entries(media).flatMap(([mediaName, descriptors]) =>
descriptors?.map((descriptor) =>
AlternateLink({ rel: 'alternate', media: mediaName, descriptor })
)
)
: null,
types
? Object.entries(types).flatMap(([type, descriptors]) =>
descriptors?.map((descriptor) =>
AlternateLink({ rel: 'alternate', type, descriptor })
)
)
: null,
])
}
import type {
ResolvedMetadata,
ResolvedViewport,
Viewport,
} from '../types/metadata-interface'
import type { ViewportLayout } from '../types/extra-types'
import { Meta, MetaFilter, MultiMeta } from './meta'
import { ViewportMetaKeys } from '../constants'
import { getOrigin } from './utils'
// convert viewport object to string for viewport meta tag
function resolveViewportLayout(viewport: Viewport) {
let resolved: string | null = null
if (viewport && typeof viewport === 'object') {
resolved = ''
for (const viewportKey_ in ViewportMetaKeys) {
const viewportKey = viewportKey_ as keyof ViewportLayout
if (viewportKey in viewport) {
let value = viewport[viewportKey]
if (typeof value === 'boolean') {
value = value ? 'yes' : 'no'
} else if (!value && viewportKey === 'initialScale') {
value = undefined
}
if (value) {
if (resolved) resolved += ', '
resolved += `${ViewportMetaKeys[viewportKey]}=${value}`
}
}
}
}
return resolved
}
export function ViewportMeta({ viewport }: { viewport: ResolvedViewport }) {
return MetaFilter([
<meta charSet="utf-8" />,
Meta({ name: 'viewport', content: resolveViewportLayout(viewport) }),
...(viewport.themeColor
? viewport.themeColor.map((themeColor) =>
Meta({
name: 'theme-color',
content: themeColor.color,
media: themeColor.media,
})
)
: []),
Meta({ name: 'color-scheme', content: viewport.colorScheme }),
])
}
export function BasicMeta({ metadata }: { metadata: ResolvedMetadata }) {
const manifestOrigin = metadata.manifest
? getOrigin(metadata.manifest)
: undefined
return MetaFilter([
metadata.title !== null && metadata.title.absolute ? (
<title>{metadata.title.absolute}</title>
) : null,
Meta({ name: 'description', content: metadata.description }),
Meta({ name: 'application-name', content: metadata.applicationName }),
...(metadata.authors
? metadata.authors.map((author) => [
author.url ? (
<link rel="author" href={author.url.toString()} />
) : null,
Meta({ name: 'author', content: author.name }),
])
: []),
metadata.manifest ? (
<link
rel="manifest"
href={metadata.manifest.toString()}
// If it's same origin, and it's a preview deployment,
// including credentials for manifest request.
crossOrigin={
!manifestOrigin && process.env.VERCEL_ENV === 'preview'
? 'use-credentials'
: undefined
}
/>
) : null,
Meta({ name: 'generator', content: metadata.generator }),
Meta({ name: 'keywords', content: metadata.keywords?.join(',') }),
Meta({ name: 'referrer', content: metadata.referrer }),
Meta({ name: 'creator', content: metadata.creator }),
Meta({ name: 'publisher', content: metadata.publisher }),
Meta({ name: 'robots', content: metadata.robots?.basic }),
Meta({ name: 'googlebot', content: metadata.robots?.googleBot }),
Meta({ name: 'abstract', content: metadata.abstract }),
...(metadata.archives
? metadata.archives.map((archive) => (
<link rel="archives" href={archive} />
))
: []),
...(metadata.assets
? metadata.assets.map((asset) => <link rel="assets" href={asset} />)
: []),
...(metadata.bookmarks
? metadata.bookmarks.map((bookmark) => (
<link rel="bookmarks" href={bookmark} />
))
: []),
...(metadata.pagination
? [
metadata.pagination.previous ? (
<link rel="prev" href={metadata.pagination.previous} />
) : null,
metadata.pagination.next ? (
<link rel="next" href={metadata.pagination.next} />
) : null,
]
: []),
Meta({ name: 'category', content: metadata.category }),
Meta({ name: 'classification', content: metadata.classification }),
...(metadata.other
? Object.entries(metadata.other).map(([name, content]) => {
if (Array.isArray(content)) {
return content.map((contentItem) =>
Meta({ name, content: contentItem })
)
} else {
return Meta({ name, content })
}
})
: []),
])
}
export function ItunesMeta({ itunes }: { itunes: ResolvedMetadata['itunes'] }) {
if (!itunes) return null
const { appId, appArgument } = itunes
let content = `app-id=${appId}`
if (appArgument) {
content += `, app-argument=${appArgument}`
}
return <meta name="apple-itunes-app" content={content} />
}
export function FacebookMeta({
facebook,
}: {
facebook: ResolvedMetadata['facebook']
}) {
if (!facebook) return null
const { appId, admins } = facebook
return MetaFilter([
appId ? <meta property="fb:app_id" content={appId} /> : null,
...(admins
? admins.map((admin) => <meta property="fb:admins" content={admin} />)
: []),
])
}
export function PinterestMeta({
pinterest,
}: {
pinterest: ResolvedMetadata['pinterest']
}) {
if (!pinterest || pinterest.richPin === undefined) return null
const { richPin } = pinterest
return <meta property="pinterest-rich-pin" content={richPin.toString()} />
}
const formatDetectionKeys = [
'telephone',
'date',
'address',
'email',
'url',
] as const
export function FormatDetectionMeta({
formatDetection,
}: {
formatDetection: ResolvedMetadata['formatDetection']
}) {
if (!formatDetection) return null
let content = ''
for (const key of formatDetectionKeys) {
if (formatDetection[key] === false) {
if (content) content += ', '
content += `${key}=no`
}
}
return content ? <meta name="format-detection" content={content} /> : null
}
export function AppleWebAppMeta({
appleWebApp,
}: {
appleWebApp: ResolvedMetadata['appleWebApp']
}) {
if (!appleWebApp) return null
const { capable, title, startupImage, statusBarStyle } = appleWebApp
return MetaFilter([
capable ? Meta({ name: 'mobile-web-app-capable', content: 'yes' }) : null,
Meta({ name: 'apple-mobile-web-app-title', content: title }),
startupImage
? startupImage.map((image) => (
<link
href={image.url}
media={image.media}
rel="apple-touch-startup-image"
/>
))
: null,
statusBarStyle
? Meta({
name: 'apple-mobile-web-app-status-bar-style',
content: statusBarStyle,
})
: null,
])
}
export function VerificationMeta({
verification,
}: {
verification: ResolvedMetadata['verification']
}) {
if (!verification) return null
return MetaFilter([
MultiMeta({
namePrefix: 'google-site-verification',
contents: verification.google,
}),
MultiMeta({ namePrefix: 'y_key', contents: verification.yahoo }),
MultiMeta({
namePrefix: 'yandex-verification',
contents: verification.yandex,
}),
MultiMeta({ namePrefix: 'me', contents: verification.me }),
...(verification.other
? Object.entries(verification.other).map(([key, value]) =>
MultiMeta({ namePrefix: key, contents: value })
)
: []),
])
}
import type { ResolvedMetadata } from '../types/metadata-interface'
import type { Icon, IconDescriptor } from '../types/metadata-types'
import { IconMark } from './icon-mark'
import { MetaFilter } from './meta'
function IconDescriptorLink({ icon }: { icon: IconDescriptor }) {
const { url, rel = 'icon', ...props } = icon
return <link rel={rel} href={url.toString()} {...props} />
}
function IconLink({ rel, icon }: { rel?: string; icon: Icon }) {
if (typeof icon === 'object' && !(icon instanceof URL)) {
if (!icon.rel && rel) icon.rel = rel
return IconDescriptorLink({ icon })
} else {
const href = icon.toString()
return <link rel={rel} href={href} />
}
}
export function IconsMetadata({ icons }: { icons: ResolvedMetadata['icons'] }) {
if (!icons) return null
const shortcutList = icons.shortcut
const iconList = icons.icon
const appleList = icons.apple
const otherList = icons.other
const hasIcon = Boolean(
shortcutList?.length ||
iconList?.length ||
appleList?.length ||
otherList?.length
)
if (!hasIcon) return null
return MetaFilter([
shortcutList
? shortcutList.map((icon) => IconLink({ rel: 'shortcut icon', icon }))
: null,
iconList ? iconList.map((icon) => IconLink({ rel: 'icon', icon })) : null,
appleList
? appleList.map((icon) => IconLink({ rel: 'apple-touch-icon', icon }))
: null,
otherList ? otherList.map((icon) => IconDescriptorLink({ icon })) : null,
hasIcon ? <IconMark /> : null,
])
}
import React from 'react'
import { nonNullable } from '../../non-nullable'
export function Meta({
name,
property,
content,
media,
}: {
name?: string
property?: string
media?: string
content: string | number | URL | null | undefined
}): React.ReactElement | null {
if (typeof content !== 'undefined' && content !== null && content !== '') {
return (
<meta
{...(name ? { name } : { property })}
{...(media ? { media } : undefined)}
content={typeof content === 'string' ? content : content.toString()}
/>
)
}
return null
}
export function MetaFilter<T extends {} | {}[]>(
items: (T | null)[]
): NonNullable<T>[] {
const acc: NonNullable<T>[] = []
for (const item of items) {
if (Array.isArray(item)) {
acc.push(...item.filter(nonNullable))
} else if (nonNullable(item)) {
acc.push(item)
}
}
return acc
}
type ExtendMetaContent = Record<
string,
undefined | string | URL | number | boolean | null | undefined
>
type MultiMetaContent =
| (ExtendMetaContent | string | URL | number)[]
| null
| undefined
function camelToSnake(camelCaseStr: string) {
return camelCaseStr.replace(/([A-Z])/g, function (match) {
return '_' + match.toLowerCase()
})
}
const aliasPropPrefixes = new Set([
'og:image',
'twitter:image',
'og:video',
'og:audio',
])
function getMetaKey(prefix: string, key: string) {
// Use `twitter:image` and `og:image` instead of `twitter:image:url` and `og:image:url`
// to be more compatible as it's a more common format.
// `og:video` & `og:audio` do not have a `:url` suffix alias
if (aliasPropPrefixes.has(prefix) && key === 'url') {
return prefix
}
if (prefix.startsWith('og:') || prefix.startsWith('twitter:')) {
key = camelToSnake(key)
}
return prefix + ':' + key
}
function ExtendMeta({
content,
namePrefix,
propertyPrefix,
}: {
content?: ExtendMetaContent
namePrefix?: string
propertyPrefix?: string
}) {
if (!content) return null
return MetaFilter(
Object.entries(content).map(([k, v]) => {
return typeof v === 'undefined'
? null
: Meta({
...(propertyPrefix && { property: getMetaKey(propertyPrefix, k) }),
...(namePrefix && { name: getMetaKey(namePrefix, k) }),
content: typeof v === 'string' ? v : v?.toString(),
})
})
)
}
export function MultiMeta({
propertyPrefix,
namePrefix,
contents,
}: {
propertyPrefix?: string
namePrefix?: string
contents?: MultiMetaContent | null
}) {
if (typeof contents === 'undefined' || contents === null) {
return null
}
return MetaFilter(
contents.map((content) => {
if (
typeof content === 'string' ||
typeof content === 'number' ||
content instanceof URL
) {
return Meta({
...(propertyPrefix
? { property: propertyPrefix }
: { name: namePrefix }),
content,
})
} else {
return ExtendMeta({
namePrefix,
propertyPrefix,
content,
})
}
})
)
}
This diff is collapsed.
This diff is collapsed.
...@@ -283,12 +283,7 @@ async function readNormalizedNFT(next, name) { ...@@ -283,12 +283,7 @@ async function readNormalizedNFT(next, name) {
"/node_modules/next/dist/lib/memory/trace.js", "/node_modules/next/dist/lib/memory/trace.js",
"/node_modules/next/dist/lib/metadata/constants.js", "/node_modules/next/dist/lib/metadata/constants.js",
"/node_modules/next/dist/lib/metadata/default-metadata.js", "/node_modules/next/dist/lib/metadata/default-metadata.js",
"/node_modules/next/dist/lib/metadata/generate/alternate.js",
"/node_modules/next/dist/lib/metadata/generate/basic.js",
"/node_modules/next/dist/lib/metadata/generate/icon-mark.js", "/node_modules/next/dist/lib/metadata/generate/icon-mark.js",
"/node_modules/next/dist/lib/metadata/generate/icons.js",
"/node_modules/next/dist/lib/metadata/generate/meta.js",
"/node_modules/next/dist/lib/metadata/generate/opengraph.js",
"/node_modules/next/dist/lib/metadata/generate/utils.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/get-metadata-route.js",
"/node_modules/next/dist/lib/metadata/is-metadata-route.js", "/node_modules/next/dist/lib/metadata/is-metadata-route.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