Unverified Commit 035f161c authored by Jiwon Choi's avatar Jiwon Choi Committed by GitHub

Fork `react-dev-overlay` for new UI (#74017)

This PR forked the UI essentials of react dev overlay to `_experimental` dir (`_` underscore to keep it displayed at the top).

Also, modified the existing `ReactDevOverlay` component to conditionally render the New and Old component based on the given `__NEXT_EXPERIMENTAL_NEW_DEV_OVERLAY` env.

Please note that there might be redundant forks within `_experimental/internal`, but will continue to reduce them on the following PRs.

Closes NDX-589
parent a2d221b9
import type { OverlayState } from '../../shared'
import type { Dispatcher } from '../../app/hot-reloader-client'
import React from 'react'
import { ShadowPortal } from '../internal/components/ShadowPortal'
import { BuildError } from '../internal/container/BuildError'
import { Errors } from '../internal/container/Errors'
import { StaticIndicator } from '../internal/container/StaticIndicator'
import { Base } from '../internal/styles/Base'
import { ComponentStyles } from '../internal/styles/ComponentStyles'
import { CssReset } from '../internal/styles/CssReset'
import { RootLayoutMissingTagsError } from '../internal/container/root-layout-missing-tags-error'
import { RuntimeErrorHandler } from '../internal/helpers/runtime-error-handler'
interface ReactDevOverlayState {
isReactError: boolean
}
export default class ReactDevOverlay extends React.PureComponent<
{
state: OverlayState
dispatcher?: Dispatcher
children: React.ReactNode
},
ReactDevOverlayState
> {
state = { isReactError: false }
static getDerivedStateFromError(error: Error): ReactDevOverlayState {
if (!error.stack) return { isReactError: false }
RuntimeErrorHandler.hadRuntimeError = true
return {
isReactError: true,
}
}
render() {
const { state, children, dispatcher } = this.props
const { isReactError } = this.state
const hasBuildError = state.buildError != null
const hasRuntimeErrors = Boolean(state.errors.length)
const hasStaticIndicator = state.staticIndicator
const debugInfo = state.debugInfo
return (
<>
{isReactError ? (
<html>
<head></head>
<body></body>
</html>
) : (
children
)}
<ShadowPortal>
<CssReset />
<Base />
<ComponentStyles />
{state.rootLayoutMissingTags?.length ? (
<RootLayoutMissingTagsError
missingTags={state.rootLayoutMissingTags}
/>
) : hasBuildError ? (
<BuildError
message={state.buildError!}
versionInfo={state.versionInfo}
/>
) : (
<>
{hasRuntimeErrors ? (
<Errors
isAppDir={true}
initialDisplayState={
isReactError ? 'fullscreen' : 'minimized'
}
errors={state.errors}
versionInfo={state.versionInfo}
hasStaticIndicator={hasStaticIndicator}
debugInfo={debugInfo}
/>
) : null}
{hasStaticIndicator && (
<StaticIndicator dispatcher={dispatcher} />
)}
</>
)}
</ShadowPortal>
</>
)
}
}
import Anser from 'next/dist/compiled/anser'
import * as React from 'react'
import type { StackFrame } from 'next/dist/compiled/stacktrace-parser'
import stripAnsi from 'next/dist/compiled/strip-ansi'
import { getFrameSource } from '../../helpers/stack-frame'
import { useOpenInEditor } from '../../helpers/use-open-in-editor'
import { HotlinkedText } from '../hot-linked-text'
export type CodeFrameProps = { stackFrame: StackFrame; codeFrame: string }
export const CodeFrame: React.FC<CodeFrameProps> = function CodeFrame({
stackFrame,
codeFrame,
}) {
// Strip leading spaces out of the code frame:
const formattedFrame = React.useMemo<string>(() => {
const lines = codeFrame.split(/\r?\n/g)
// Find the minimum length of leading spaces after `|` in the code frame
const miniLeadingSpacesLength = lines
.map((line) =>
/^>? +\d+ +\| [ ]+/.exec(stripAnsi(line)) === null
? null
: /^>? +\d+ +\| ( *)/.exec(stripAnsi(line))
)
.filter(Boolean)
.map((v) => v!.pop()!)
.reduce((c, n) => (isNaN(c) ? n.length : Math.min(c, n.length)), NaN)
// When the minimum length of leading spaces is greater than 1, remove them
// from the code frame to help the indentation looks better when there's a lot leading spaces.
if (miniLeadingSpacesLength > 1) {
return lines
.map((line, a) =>
~(a = line.indexOf('|'))
? line.substring(0, a) +
line.substring(a).replace(`^\\ {${miniLeadingSpacesLength}}`, '')
: line
)
.join('\n')
}
return lines.join('\n')
}, [codeFrame])
const decoded = React.useMemo(() => {
return Anser.ansiToJson(formattedFrame, {
json: true,
use_classes: true,
remove_empty: true,
})
}, [formattedFrame])
const open = useOpenInEditor({
file: stackFrame.file,
lineNumber: stackFrame.lineNumber,
column: stackFrame.column,
})
// TODO: make the caret absolute
return (
<div data-nextjs-codeframe>
<div>
<p
role="link"
onClick={open}
tabIndex={1}
title="Click to open in your editor"
>
<span>
{getFrameSource(stackFrame)} @{' '}
<HotlinkedText text={stackFrame.methodName} />
</span>
<svg
xmlns="http://www.w3.org/2000/svg"
viewBox="0 0 24 24"
fill="none"
stroke="currentColor"
strokeWidth="2"
strokeLinecap="round"
strokeLinejoin="round"
>
<path d="M18 13v6a2 2 0 0 1-2 2H5a2 2 0 0 1-2-2V8a2 2 0 0 1 2-2h6"></path>
<polyline points="15 3 21 3 21 9"></polyline>
<line x1="10" y1="14" x2="21" y2="3"></line>
</svg>
</p>
</div>
<pre>
{decoded.map((entry, index) => (
<span
key={`frame-${index}`}
style={{
color: entry.fg ? `var(--color-${entry.fg})` : undefined,
...(entry.decoration === 'bold'
? { fontWeight: 800 }
: entry.decoration === 'italic'
? { fontStyle: 'italic' }
: undefined),
}}
>
{entry.content}
</span>
))}
</pre>
</div>
)
}
import { noop as css } from '../../helpers/noop-template'
const styles = css`
[data-nextjs-codeframe] {
overflow: auto;
border-radius: var(--size-gap-half);
background-color: var(--color-ansi-bg);
color: var(--color-ansi-fg);
margin-bottom: var(--size-gap-double);
}
[data-nextjs-codeframe]::selection,
[data-nextjs-codeframe] *::selection {
background-color: var(--color-ansi-selection);
}
[data-nextjs-codeframe] * {
color: inherit;
background-color: transparent;
font-family: var(--font-stack-monospace);
}
[data-nextjs-codeframe] > * {
margin: 0;
padding: calc(var(--size-gap) + var(--size-gap-half))
calc(var(--size-gap-double) + var(--size-gap-half));
}
[data-nextjs-codeframe] > div {
display: inline-block;
width: auto;
min-width: 100%;
border-bottom: 1px solid var(--color-ansi-bright-black);
}
[data-nextjs-codeframe] > div > p {
display: flex;
align-items: center;
justify-content: space-between;
cursor: pointer;
margin: 0;
}
[data-nextjs-codeframe] > div > p:hover {
text-decoration: underline dotted;
}
[data-nextjs-codeframe] div > p > svg {
width: auto;
height: 1em;
margin-left: 8px;
}
[data-nextjs-codeframe] div > pre {
overflow: hidden;
display: inline-block;
}
`
export { styles }
import * as React from 'react'
import { useOnClickOutside } from '../../hooks/use-on-click-outside'
export type DialogProps = {
children?: React.ReactNode
type: 'error' | 'warning'
'aria-labelledby': string
'aria-describedby': string
onClose?: () => void
}
const Dialog: React.FC<DialogProps> = function Dialog({
children,
type,
onClose,
...props
}) {
const [dialog, setDialog] = React.useState<HTMLDivElement | null>(null)
const [role, setRole] = React.useState<string | undefined>(
typeof document !== 'undefined' && document.hasFocus()
? 'dialog'
: undefined
)
const onDialog = React.useCallback((node: HTMLDivElement | null) => {
setDialog(node)
}, [])
useOnClickOutside(dialog, (e) => {
e.preventDefault()
return onClose?.()
})
// Make HTMLElements with `role=link` accessible to be triggered by the
// keyboard, i.e. [Enter].
React.useEffect(() => {
if (dialog == null) {
return
}
const root = dialog.getRootNode()
// Always true, but we do this for TypeScript:
if (!(root instanceof ShadowRoot)) {
return
}
const shadowRoot = root
function handler(e: KeyboardEvent) {
const el = shadowRoot.activeElement
if (
e.key === 'Enter' &&
el instanceof HTMLElement &&
el.getAttribute('role') === 'link'
) {
e.preventDefault()
e.stopPropagation()
el.click()
}
}
function handleFocus() {
// safari will force itself as the active application when a background page triggers any sort of autofocus
// this is a workaround to only set the dialog role if the document has focus
setRole(document.hasFocus() ? 'dialog' : undefined)
}
shadowRoot.addEventListener('keydown', handler as EventListener)
window.addEventListener('focus', handleFocus)
window.addEventListener('blur', handleFocus)
return () => {
shadowRoot.removeEventListener('keydown', handler as EventListener)
window.removeEventListener('focus', handleFocus)
window.removeEventListener('blur', handleFocus)
}
}, [dialog])
return (
<div
ref={onDialog}
data-nextjs-dialog
tabIndex={-1}
role={role}
aria-labelledby={props['aria-labelledby']}
aria-describedby={props['aria-describedby']}
aria-modal="true"
>
<div data-nextjs-dialog-banner className={`banner-${type}`} />
{children}
</div>
)
}
export { Dialog }
import * as React from 'react'
export type DialogBodyProps = {
children?: React.ReactNode
className?: string
}
const DialogBody: React.FC<DialogBodyProps> = function DialogBody({
children,
className,
}) {
return (
<div data-nextjs-dialog-body className={className}>
{children}
</div>
)
}
export { DialogBody }
import * as React from 'react'
export type DialogContentProps = {
children?: React.ReactNode
className?: string
}
const DialogContent: React.FC<DialogContentProps> = function DialogContent({
children,
className,
}) {
return (
<div data-nextjs-dialog-content className={className}>
{children}
</div>
)
}
export { DialogContent }
import * as React from 'react'
export type DialogHeaderProps = {
children?: React.ReactNode
className?: string
}
const DialogHeader: React.FC<DialogHeaderProps> = function DialogHeader({
children,
className,
}) {
return (
<div data-nextjs-dialog-header className={className}>
{children}
</div>
)
}
export { DialogHeader }
export { Dialog } from './Dialog'
export { DialogBody } from './DialogBody'
export { DialogContent } from './DialogContent'
export { DialogHeader } from './DialogHeader'
export { styles } from './styles'
import { noop as css } from '../../helpers/noop-template'
const styles = css`
[data-nextjs-dialog] {
display: flex;
flex-direction: column;
width: 100%;
margin-right: auto;
margin-left: auto;
outline: none;
background: var(--color-background);
border-radius: var(--size-gap);
box-shadow: 0 var(--size-gap-half) var(--size-gap-double)
rgba(0, 0, 0, 0.25);
max-height: calc(100% - 56px);
overflow-y: hidden;
}
@media (max-height: 812px) {
[data-nextjs-dialog-overlay] {
max-height: calc(100% - 15px);
}
}
@media (min-width: 576px) {
[data-nextjs-dialog] {
max-width: 540px;
box-shadow: 0 var(--size-gap) var(--size-gap-quad) rgba(0, 0, 0, 0.25);
}
}
@media (min-width: 768px) {
[data-nextjs-dialog] {
max-width: 720px;
}
}
@media (min-width: 992px) {
[data-nextjs-dialog] {
max-width: 960px;
}
}
[data-nextjs-dialog-banner] {
position: relative;
}
[data-nextjs-dialog-banner].banner-warning {
border-color: var(--color-ansi-yellow);
}
[data-nextjs-dialog-banner].banner-error {
border-color: var(--color-ansi-red);
}
[data-nextjs-dialog-banner]::after {
z-index: 2;
content: '';
position: absolute;
top: 0;
right: 0;
width: 100%;
/* banner width: */
border-top-width: var(--size-gap-half);
border-bottom-width: 0;
border-top-style: solid;
border-bottom-style: solid;
border-top-color: inherit;
border-bottom-color: transparent;
}
[data-nextjs-dialog-content] {
overflow-y: auto;
border: none;
margin: 0;
/* calc(padding + banner width offset) */
padding: calc(var(--size-gap-double) + var(--size-gap-half))
var(--size-gap-double);
height: 100%;
display: flex;
flex-direction: column;
}
[data-nextjs-dialog-content] > [data-nextjs-dialog-header] {
flex-shrink: 0;
margin-bottom: var(--size-gap-double);
}
[data-nextjs-dialog-content] > [data-nextjs-dialog-body] {
position: relative;
flex: 1 1 auto;
}
`
export { styles }
import * as React from 'react'
import { CloseIcon } from '../../icons/CloseIcon'
export type LeftRightDialogHeaderProps = {
children?: React.ReactNode
className?: string
previous: (() => void) | null
next: (() => void) | null
close?: () => void
}
const LeftRightDialogHeader: React.FC<LeftRightDialogHeaderProps> =
function LeftRightDialogHeader({
children,
className,
previous,
next,
close,
}) {
const buttonLeft = React.useRef<HTMLButtonElement | null>(null)
const buttonRight = React.useRef<HTMLButtonElement | null>(null)
const buttonClose = React.useRef<HTMLButtonElement | null>(null)
const [nav, setNav] = React.useState<HTMLElement | null>(null)
const onNav = React.useCallback((el: HTMLElement) => {
setNav(el)
}, [])
React.useEffect(() => {
if (nav == null) {
return
}
const root = nav.getRootNode()
const d = self.document
function handler(e: KeyboardEvent) {
if (e.key === 'ArrowLeft') {
e.preventDefault()
e.stopPropagation()
if (buttonLeft.current) {
buttonLeft.current.focus()
}
previous && previous()
} else if (e.key === 'ArrowRight') {
e.preventDefault()
e.stopPropagation()
if (buttonRight.current) {
buttonRight.current.focus()
}
next && next()
} else if (e.key === 'Escape') {
e.preventDefault()
e.stopPropagation()
if (root instanceof ShadowRoot) {
const a = root.activeElement
if (a && a !== buttonClose.current && a instanceof HTMLElement) {
a.blur()
return
}
}
close?.()
}
}
root.addEventListener('keydown', handler as EventListener)
if (root !== d) {
d.addEventListener('keydown', handler)
}
return function () {
root.removeEventListener('keydown', handler as EventListener)
if (root !== d) {
d.removeEventListener('keydown', handler)
}
}
}, [close, nav, next, previous])
// Unlock focus for browsers like Firefox, that break all user focus if the
// currently focused item becomes disabled.
React.useEffect(() => {
if (nav == null) {
return
}
const root = nav.getRootNode()
// Always true, but we do this for TypeScript:
if (root instanceof ShadowRoot) {
const a = root.activeElement
if (previous == null) {
if (buttonLeft.current && a === buttonLeft.current) {
buttonLeft.current.blur()
}
} else if (next == null) {
if (buttonRight.current && a === buttonRight.current) {
buttonRight.current.blur()
}
}
}
}, [nav, next, previous])
return (
<div data-nextjs-dialog-left-right className={className}>
<nav ref={onNav}>
<button
ref={buttonLeft}
type="button"
disabled={previous == null ? true : undefined}
aria-disabled={previous == null ? true : undefined}
onClick={previous ?? undefined}
>
<svg
viewBox="0 0 14 14"
fill="none"
xmlns="http://www.w3.org/2000/svg"
>
<title>previous</title>
<path
d="M6.99996 1.16666L1.16663 6.99999L6.99996 12.8333M12.8333 6.99999H1.99996H12.8333Z"
stroke="currentColor"
strokeWidth="2"
strokeLinecap="round"
strokeLinejoin="round"
/>
</svg>
</button>
<button
ref={buttonRight}
type="button"
disabled={next == null ? true : undefined}
aria-disabled={next == null ? true : undefined}
onClick={next ?? undefined}
>
<svg
viewBox="0 0 14 14"
fill="none"
xmlns="http://www.w3.org/2000/svg"
>
<title>next</title>
<path
d="M6.99996 1.16666L12.8333 6.99999L6.99996 12.8333M1.16663 6.99999H12H1.16663Z"
stroke="currentColor"
strokeWidth="2"
strokeLinecap="round"
strokeLinejoin="round"
/>
</svg>
</button>
{children}
</nav>
{close ? (
<button
data-nextjs-errors-dialog-left-right-close-button
ref={buttonClose}
type="button"
onClick={close}
aria-label="Close"
>
<span aria-hidden="true">
<CloseIcon />
</span>
</button>
) : null}
</div>
)
}
export { LeftRightDialogHeader }
export { LeftRightDialogHeader } from './LeftRightDialogHeader'
export { styles } from './styles'
import { noop as css } from '../../helpers/noop-template'
const styles = css`
[data-nextjs-dialog-left-right] {
display: flex;
flex-direction: row;
align-content: center;
align-items: center;
justify-content: space-between;
}
[data-nextjs-dialog-left-right] > nav {
flex: 1;
display: flex;
align-items: center;
margin-right: var(--size-gap);
}
[data-nextjs-dialog-left-right] > nav > button {
display: inline-flex;
align-items: center;
justify-content: center;
width: calc(var(--size-gap-double) + var(--size-gap));
height: calc(var(--size-gap-double) + var(--size-gap));
font-size: 0;
border: none;
background-color: rgba(255, 85, 85, 0.1);
color: var(--color-ansi-red);
cursor: pointer;
transition: background-color 0.25s ease;
}
[data-nextjs-dialog-left-right] > nav > button > svg {
width: auto;
height: calc(var(--size-gap) + var(--size-gap-half));
}
[data-nextjs-dialog-left-right] > nav > button:hover {
background-color: rgba(255, 85, 85, 0.2);
}
[data-nextjs-dialog-left-right] > nav > button:disabled {
background-color: rgba(255, 85, 85, 0.1);
color: rgba(255, 85, 85, 0.4);
cursor: not-allowed;
}
[data-nextjs-dialog-left-right] > nav > button:first-of-type {
border-radius: var(--size-gap-half) 0 0 var(--size-gap-half);
margin-right: 1px;
}
[data-nextjs-dialog-left-right] > nav > button:last-of-type {
border-radius: 0 var(--size-gap-half) var(--size-gap-half) 0;
}
[data-nextjs-dialog-left-right] > button:last-of-type {
border: 0;
padding: 0;
background-color: transparent;
appearance: none;
opacity: 0.4;
transition: opacity 0.25s ease;
color: var(--color-font);
}
[data-nextjs-dialog-left-right] > button:last-of-type:hover {
opacity: 0.7;
}
`
export { styles }
import allyTrap from './maintain--tab-focus'
import * as React from 'react'
import { lock, unlock } from './body-locker'
export type OverlayProps = {
children?: React.ReactNode
className?: string
fixed?: boolean
}
const Overlay: React.FC<OverlayProps> = function Overlay({
className,
children,
fixed,
}) {
React.useEffect(() => {
lock()
return () => {
unlock()
}
}, [])
const [overlay, setOverlay] = React.useState<HTMLDivElement | null>(null)
const onOverlay = React.useCallback((el: HTMLDivElement) => {
setOverlay(el)
}, [])
React.useEffect(() => {
if (overlay == null) {
return
}
const handle2 = allyTrap({ context: overlay })
return () => {
handle2.disengage()
}
}, [overlay])
return (
<div data-nextjs-dialog-overlay className={className} ref={onOverlay}>
<div
data-nextjs-dialog-backdrop
data-nextjs-dialog-backdrop-fixed={fixed ? true : undefined}
/>
{children}
</div>
)
}
export { Overlay }
let previousBodyPaddingRight: string | undefined
let previousBodyOverflowSetting: string | undefined
let activeLocks = 0
export function lock() {
setTimeout(() => {
if (activeLocks++ > 0) {
return
}
const scrollBarGap =
window.innerWidth - document.documentElement.clientWidth
if (scrollBarGap > 0) {
previousBodyPaddingRight = document.body.style.paddingRight
document.body.style.paddingRight = `${scrollBarGap}px`
}
previousBodyOverflowSetting = document.body.style.overflow
document.body.style.overflow = 'hidden'
})
}
export function unlock() {
setTimeout(() => {
if (activeLocks === 0 || --activeLocks !== 0) {
return
}
if (previousBodyPaddingRight !== undefined) {
document.body.style.paddingRight = previousBodyPaddingRight
previousBodyPaddingRight = undefined
}
if (previousBodyOverflowSetting !== undefined) {
document.body.style.overflow = previousBodyOverflowSetting
previousBodyOverflowSetting = undefined
}
})
}
import { noop as css } from '../../helpers/noop-template'
const styles = css`
[data-nextjs-dialog-overlay] {
position: fixed;
top: 0;
right: 0;
bottom: 0;
left: 0;
overflow: auto;
z-index: 9000;
display: flex;
align-content: center;
align-items: center;
flex-direction: column;
padding: 10vh 15px 0;
}
@media (max-height: 812px) {
[data-nextjs-dialog-overlay] {
padding: 15px 15px 0;
}
}
[data-nextjs-dialog-backdrop] {
position: fixed;
top: 0;
right: 0;
bottom: 0;
left: 0;
background-color: var(--color-backdrop);
pointer-events: all;
z-index: -1;
}
[data-nextjs-dialog-backdrop-fixed] {
cursor: not-allowed;
-webkit-backdrop-filter: blur(8px);
backdrop-filter: blur(8px);
}
`
export { styles }
import * as React from 'react'
import { createPortal } from 'react-dom'
export function ShadowPortal({ children }: { children: React.ReactNode }) {
let portalNode = React.useRef<HTMLElement | null>(null)
let shadowNode = React.useRef<ShadowRoot | null>(null)
let [, forceUpdate] = React.useState<{} | undefined>()
React.useLayoutEffect(() => {
const ownerDocument = document
portalNode.current = ownerDocument.createElement('nextjs-portal')
shadowNode.current = portalNode.current.attachShadow({ mode: 'open' })
ownerDocument.body.appendChild(portalNode.current)
forceUpdate({})
return () => {
if (portalNode.current && portalNode.current.ownerDocument) {
portalNode.current.ownerDocument.body.removeChild(portalNode.current)
}
}
}, [])
return shadowNode.current
? createPortal(children, shadowNode.current as any)
: null
}
import React from 'react'
import { useOpenInEditor } from '../../helpers/use-open-in-editor'
type EditorLinkProps = {
file: string
isSourceFile: boolean
location?: {
line: number
column: number
}
}
export function EditorLink({ file, isSourceFile, location }: EditorLinkProps) {
const open = useOpenInEditor({
file,
lineNumber: location?.line ?? 1,
column: location?.column ?? 0,
})
return (
<div
data-with-open-in-editor-link
data-with-open-in-editor-link-source-file={
isSourceFile ? true : undefined
}
data-with-open-in-editor-link-import-trace={
isSourceFile ? undefined : true
}
tabIndex={10}
role={'link'}
onClick={open}
title={'Click to open in your editor'}
>
{file}
{location ? `:${location.line}:${location.column}` : null}
<svg
xmlns="http://www.w3.org/2000/svg"
viewBox="0 0 24 24"
fill="none"
stroke="currentColor"
strokeWidth="2"
strokeLinecap="round"
strokeLinejoin="round"
>
<path d="M18 13v6a2 2 0 0 1-2 2H5a2 2 0 0 1-2-2V8a2 2 0 0 1 2-2h6"></path>
<polyline points="15 3 21 3 21 9"></polyline>
<line x1="10" y1="14" x2="21" y2="3"></line>
</svg>
</div>
)
}
import Anser from 'next/dist/compiled/anser'
import * as React from 'react'
import { HotlinkedText } from '../hot-linked-text'
import { EditorLink } from './EditorLink'
export type TerminalProps = { content: string }
function getFile(lines: string[]) {
const contentFileName = lines.shift()
if (!contentFileName) return null
const [fileName, line, column] = contentFileName.split(':', 3)
const parsedLine = Number(line)
const parsedColumn = Number(column)
const hasLocation = !Number.isNaN(parsedLine) && !Number.isNaN(parsedColumn)
return {
fileName: hasLocation ? fileName : contentFileName,
location: hasLocation
? {
line: parsedLine,
column: parsedColumn,
}
: undefined,
}
}
function getImportTraceFiles(lines: string[]) {
if (
lines.some((line) => /ReactServerComponentsError:/.test(line)) ||
lines.some((line) => /Import trace for requested module:/.test(line))
) {
// Grab the lines at the end containing the files
const files = []
while (
/.+\..+/.test(lines[lines.length - 1]) &&
!lines[lines.length - 1].includes(':')
) {
const file = lines.pop()!.trim()
files.unshift(file)
}
return files
}
return []
}
function getEditorLinks(content: string) {
const lines = content.split('\n')
const file = getFile(lines)
const importTraceFiles = getImportTraceFiles(lines)
return { file, source: lines.join('\n'), importTraceFiles }
}
export const Terminal: React.FC<TerminalProps> = function Terminal({
content,
}) {
const { file, source, importTraceFiles } = React.useMemo(
() => getEditorLinks(content),
[content]
)
const decoded = React.useMemo(() => {
return Anser.ansiToJson(source, {
json: true,
use_classes: true,
remove_empty: true,
})
}, [source])
return (
<div data-nextjs-terminal>
{file && (
<EditorLink
isSourceFile
key={file.fileName}
file={file.fileName}
location={file.location}
/>
)}
<pre>
{decoded.map((entry, index) => (
<span
key={`terminal-entry-${index}`}
style={{
color: entry.fg ? `var(--color-${entry.fg})` : undefined,
...(entry.decoration === 'bold'
? { fontWeight: 800 }
: entry.decoration === 'italic'
? { fontStyle: 'italic' }
: undefined),
}}
>
<HotlinkedText text={entry.content} />
</span>
))}
{importTraceFiles.map((importTraceFile) => (
<EditorLink
isSourceFile={false}
key={importTraceFile}
file={importTraceFile}
/>
))}
</pre>
</div>
)
}
import { noop as css } from '../../helpers/noop-template'
const styles = css`
[data-nextjs-terminal] {
border-radius: var(--size-gap-half);
background-color: var(--color-ansi-bg);
color: var(--color-ansi-fg);
}
[data-nextjs-terminal]::selection,
[data-nextjs-terminal] *::selection {
background-color: var(--color-ansi-selection);
}
[data-nextjs-terminal] * {
color: inherit;
background-color: transparent;
font-family: var(--font-stack-monospace);
}
[data-nextjs-terminal] > * {
margin: 0;
padding: calc(var(--size-gap) + var(--size-gap-half))
calc(var(--size-gap-double) + var(--size-gap-half));
}
[data-nextjs-terminal] pre {
white-space: pre-wrap;
word-break: break-word;
}
[data-with-open-in-editor-link] svg {
width: auto;
height: var(--size-font-small);
margin-left: var(--size-gap);
}
[data-with-open-in-editor-link] {
cursor: pointer;
}
[data-with-open-in-editor-link]:hover {
text-decoration: underline dotted;
}
[data-with-open-in-editor-link-source-file] {
border-bottom: 1px solid var(--color-ansi-bright-black);
display: flex;
align-items: center;
justify-content: space-between;
line-break: anywhere;
}
[data-with-open-in-editor-link-import-trace] {
margin-left: var(--size-gap-double);
}
[data-nextjs-terminal] a {
color: inherit;
}
`
export { styles }
import * as React from 'react'
export type ToastProps = React.HTMLProps<HTMLDivElement> & {
children?: React.ReactNode
onClick?: () => void
className?: string
}
export const Toast: React.FC<ToastProps> = function Toast({
onClick,
children,
className,
...props
}) {
return (
<div
{...props}
onClick={(e) => {
e.preventDefault()
return onClick?.()
}}
className={`nextjs-toast${className ? ' ' + className : ''}`}
>
<div data-nextjs-toast-wrapper>{children}</div>
</div>
)
}
import { noop as css } from '../../helpers/noop-template'
const styles = css`
.nextjs-toast {
position: fixed;
bottom: var(--size-gap-double);
left: var(--size-gap-double);
max-width: 420px;
z-index: 9000;
box-shadow: 0px var(--size-gap-double) var(--size-gap-quad)
rgba(0, 0, 0, 0.25);
}
@media (max-width: 440px) {
.nextjs-toast {
max-width: 90vw;
left: 5vw;
}
}
.nextjs-toast-errors-parent {
padding: 16px;
border-radius: var(--size-gap-quad);
font-weight: 500;
color: var(--color-ansi-bright-white);
background-color: var(--color-ansi-red);
}
.nextjs-static-indicator-toast-wrapper {
width: 30px;
height: 30px;
overflow: hidden;
border: 0;
border-radius: var(--size-gap-triple);
background: var(--color-background);
color: var(--color-font);
transition: all 0.3s ease-in-out;
box-shadow:
inset 0 0 0 1px var(--color-border-shadow),
0 11px 40px 0 rgba(0, 0, 0, 0.25),
0 2px 10px 0 rgba(0, 0, 0, 0.12);
}
.nextjs-static-indicator-toast-wrapper:hover {
width: 140px;
}
.nextjs-static-indicator-toast-icon {
display: flex;
align-items: center;
justify-content: center;
width: 30px;
height: 30px;
}
.nextjs-static-indicator-toast-text {
font-size: 14px;
display: flex;
align-items: center;
justify-content: center;
opacity: 0;
white-space: nowrap;
transition: opacity 0.3s ease-in-out;
line-height: 30px;
position: absolute;
left: 30px;
top: 0;
}
.nextjs-static-indicator-toast-wrapper:hover
.nextjs-static-indicator-toast-text {
opacity: 1;
}
.nextjs-static-indicator-toast-wrapper button {
color: var(--color-font);
opacity: 0.8;
background: none;
border: none;
margin-left: 6px;
margin-top: -2px;
outline: 0;
}
.nextjs-static-indicator-toast-wrapper button:focus {
opacity: 1;
}
.nextjs-static-indicator-toast-wrapper button > svg {
width: 16px;
height: 16px;
}
`
export { styles }
import type { VersionInfo } from '../../../../../../../server/dev/parse-version-info'
export function VersionStalenessInfo({
versionInfo,
}: {
versionInfo: VersionInfo | undefined
}) {
if (!versionInfo) return null
const { staleness } = versionInfo
let { text, indicatorClass, title } = getStaleness(versionInfo)
if (!text) return null
return (
<span className="nextjs-container-build-error-version-status">
<span className={indicatorClass} />
<small data-nextjs-version-checker title={title}>
{text}
</small>{' '}
{staleness === 'fresh' ||
staleness === 'newer-than-npm' ||
staleness === 'unknown' ? null : (
<a
target="_blank"
rel="noopener noreferrer"
href="https://nextjs.org/docs/messages/version-staleness"
>
(learn more)
</a>
)}
{process.env.TURBOPACK ? ' (Turbopack)' : ''}
</span>
)
}
export function getStaleness({ installed, staleness, expected }: VersionInfo) {
let text = ''
let title = ''
let indicatorClass = ''
const versionLabel = `Next.js (${installed})`
switch (staleness) {
case 'newer-than-npm':
case 'fresh':
text = versionLabel
title = `Latest available version is detected (${installed}).`
indicatorClass = 'fresh'
break
case 'stale-patch':
case 'stale-minor':
text = `${versionLabel} out of date`
title = `There is a newer version (${expected}) available, upgrade recommended! `
indicatorClass = 'stale'
break
case 'stale-major': {
text = `${versionLabel} is outdated`
title = `An outdated version detected (latest is ${expected}), upgrade is highly recommended!`
indicatorClass = 'outdated'
break
}
case 'stale-prerelease': {
text = `${versionLabel} is outdated`
title = `There is a newer canary version (${expected}) available, please upgrade! `
indicatorClass = 'stale'
break
}
case 'unknown':
break
default:
break
}
return { text, indicatorClass, title }
}
export { styles } from './styles'
export { VersionStalenessInfo } from './VersionStalenessInfo'
import { noop as css } from '../../helpers/noop-template'
const styles = css`
.nextjs-container-build-error-version-status {
flex: 1;
text-align: right;
font-size: var(--size-font-small);
}
.nextjs-container-build-error-version-status span {
display: inline-block;
width: 10px;
height: 10px;
border-radius: 5px;
background: var(--color-ansi-bright-black);
}
.nextjs-container-build-error-version-status span.fresh {
background: var(--color-ansi-green);
}
.nextjs-container-build-error-version-status span.stale {
background: var(--color-ansi-yellow);
}
.nextjs-container-build-error-version-status span.outdated {
background: var(--color-ansi-red);
}
`
export { styles }
import * as React from 'react'
function useCopyLegacy(content: string) {
type CopyState =
| {
state: 'initial'
}
| {
state: 'error'
error: unknown
}
| { state: 'success' }
| { state: 'pending' }
// This would be simpler with useActionState but we need to support React 18 here.
// React 18 also doesn't have async transitions.
const [copyState, dispatch] = React.useReducer(
(
state: CopyState,
action:
| { type: 'reset' | 'copied' | 'copying' }
| { type: 'error'; error: unknown }
): CopyState => {
if (action.type === 'reset') {
return { state: 'initial' }
}
if (action.type === 'copied') {
return { state: 'success' }
}
if (action.type === 'copying') {
return { state: 'pending' }
}
if (action.type === 'error') {
return { state: 'error', error: action.error }
}
return state
},
{
state: 'initial',
}
)
function copy() {
if (isPending) {
return
}
if (!navigator.clipboard) {
dispatch({
type: 'error',
error: new Error('Copy to clipboard is not supported in this browser'),
})
} else {
dispatch({ type: 'copying' })
navigator.clipboard.writeText(content).then(
() => {
dispatch({ type: 'copied' })
},
(error) => {
dispatch({ type: 'error', error })
}
)
}
}
const reset = React.useCallback(() => {
dispatch({ type: 'reset' })
}, [])
const isPending = copyState.state === 'pending'
return [copyState, copy, reset, isPending] as const
}
function useCopyModern(content: string) {
type CopyState =
| {
state: 'initial'
}
| {
state: 'error'
error: unknown
}
| { state: 'success' }
const [copyState, dispatch, isPending] = React.useActionState(
(
state: CopyState,
action: 'reset' | 'copy'
): CopyState | Promise<CopyState> => {
if (action === 'reset') {
return { state: 'initial' }
}
if (action === 'copy') {
if (!navigator.clipboard) {
return {
state: 'error',
error: new Error(
'Copy to clipboard is not supported in this browser'
),
}
}
return navigator.clipboard.writeText(content).then(
() => {
return { state: 'success' }
},
(error) => {
return { state: 'error', error }
}
)
}
return state
},
{
state: 'initial',
}
)
function copy() {
React.startTransition(() => {
dispatch('copy')
})
}
const reset = React.useCallback(() => {
dispatch('reset')
}, [
// TODO: `dispatch` from `useActionState` is not reactive.
// Remove from dependencies once https://github.com/facebook/react/pull/29665 is released.
dispatch,
])
return [copyState, copy, reset, isPending] as const
}
const useCopy =
typeof React.useActionState === 'function' ? useCopyModern : useCopyLegacy
export function CopyButton({
actionLabel,
successLabel,
content,
icon,
disabled,
...props
}: React.HTMLProps<HTMLButtonElement> & {
actionLabel: string
successLabel: string
content: string
icon?: React.ReactNode
}) {
const [copyState, copy, reset, isPending] = useCopy(content)
const error = copyState.state === 'error' ? copyState.error : null
React.useEffect(() => {
if (error !== null) {
// Additional console.error to get the stack.
console.error(error)
}
}, [error])
React.useEffect(() => {
if (copyState.state === 'success') {
const timeoutId = setTimeout(() => {
reset()
}, 2000)
return () => {
clearTimeout(timeoutId)
}
}
}, [isPending, copyState.state, reset])
const isDisabled = isPending || disabled
const label = copyState.state === 'success' ? successLabel : actionLabel
// Assign default icon
const renderedIcon =
copyState.state === 'success' ? <CopySuccessIcon /> : icon || <CopyIcon />
return (
<button
{...props}
type="button"
title={label}
aria-label={label}
aria-disabled={isDisabled}
data-nextjs-data-runtime-error-copy-button
className={`nextjs-data-runtime-error-copy-button nextjs-data-runtime-error-copy-button--${copyState.state}`}
onClick={() => {
if (!isDisabled) {
copy()
}
}}
>
{renderedIcon}
{copyState.state === 'error' ? ` ${copyState.error}` : null}
</button>
)
}
function CopyIcon() {
return (
<svg
width="16"
height="16"
viewBox="0 0 24 24"
fill="transparent"
stroke="currentColor"
strokeWidth="1.5"
strokeLinecap="round"
strokeLinejoin="round"
>
<rect width="14" height="14" x="8" y="8" rx="2" ry="2" />
<path d="M4 16c-1.1 0-2-.9-2-2V4c0-1.1.9-2 2-2h10c1.1 0 2 .9 2 2" />
</svg>
)
}
function CopySuccessIcon() {
return (
<svg
height="16"
xlinkTitle="copied"
viewBox="0 0 16 16"
width="16"
stroke="currentColor"
fill="currentColor"
>
<path d="M13.78 4.22a.75.75 0 0 1 0 1.06l-7.25 7.25a.75.75 0 0 1-1.06 0L2.22 9.28a.751.751 0 0 1 .018-1.042.751.751 0 0 1 1.042-.018L6 10.94l6.72-6.72a.75.75 0 0 1 1.06 0Z" />
</svg>
)
}
import React from 'react'
import {
decodeMagicIdentifier,
MAGIC_IDENTIFIER_REGEX,
} from '../../../../../../../shared/lib/magic-identifier'
const linkRegex = /https?:\/\/[^\s/$.?#].[^\s)'"]*/i
const splitRegexp = new RegExp(`(${MAGIC_IDENTIFIER_REGEX.source}|\\s+)`)
export const HotlinkedText: React.FC<{
text: string
matcher?: (text: string) => boolean
}> = function HotlinkedText(props) {
const { text, matcher } = props
const wordsAndWhitespaces = text.split(splitRegexp)
return (
<>
{wordsAndWhitespaces.map((word, index) => {
if (linkRegex.test(word)) {
const link = linkRegex.exec(word)!
const href = link[0]
// If link matcher is present but the link doesn't match, don't turn it into a link
if (typeof matcher === 'function' && !matcher(href)) {
return word
}
return (
<React.Fragment key={`link-${index}`}>
<a href={href} target="_blank" rel="noreferrer noopener">
{word}
</a>
</React.Fragment>
)
}
try {
const decodedWord = decodeMagicIdentifier(word)
if (decodedWord !== word) {
return (
<i key={`ident-${index}`}>
{'{'}
{decodedWord}
{'}'}
</i>
)
}
} catch (e) {
return (
<i key={`ident-${index}`}>
{'{'}
{word} (decoding failed: {'' + e}){'}'}
</i>
)
}
return <React.Fragment key={`text-${index}`}>{word}</React.Fragment>
})}
</>
)
}
import { CopyButton } from './copy-button'
// Inline this helper to avoid widely used across the codebase,
// as for this feature the Chrome detector doesn't need to be super accurate.
function isChrome() {
if (typeof window === 'undefined') return false
const isChromium = 'chrome' in window && window.chrome
const vendorName = window.navigator.vendor
return (
isChromium !== null &&
isChromium !== undefined &&
vendorName === 'Google Inc.'
)
}
const isChromeBrowser = isChrome()
function NodeJsIcon(props: any) {
return (
<svg
width="44"
height="44"
viewBox="0 0 44 44"
fill="none"
xmlns="http://www.w3.org/2000/svg"
{...props}
>
<g clipPath="url(#clip0_1546_2)">
<path
d="M22 0L41.0526 11V33L22 44L2.94744 33V11L22 0Z"
fill="#71BD55"
/>
<path
d="M41.0493 11.0001L41.0493 33L22 1.5583e-07L41.0493 11.0001Z"
fill="#A1DF83"
/>
</g>
<defs>
<clipPath id="clip0_1546_2">
<rect width="44" height="44" fill="white" />
</clipPath>
</defs>
</svg>
)
}
function NodeJsDisabledIcon(props: any) {
return (
<svg
width="44"
height="44"
viewBox="0 0 44 44"
fill="none"
xmlns="http://www.w3.org/2000/svg"
{...props}
>
<path
d="M4.44744 11.866L22 1.73205L39.5526 11.866V32.134L22 42.2679L4.44744 32.134V11.866Z"
stroke="currentColor"
fill="transparent"
strokeWidth="3"
strokeLinejoin="round"
/>
<path
d="M22 2L39 32"
stroke="currentColor"
strokeWidth="3"
strokeLinecap="round"
/>
</svg>
)
}
const label =
'Learn more about enabling Node.js inspector for server code with Chrome DevTools'
export function NodejsInspectorCopyButton({
devtoolsFrontendUrl,
}: {
devtoolsFrontendUrl: string | undefined
}) {
const content = devtoolsFrontendUrl || ''
const disabled = !content || !isChromeBrowser
if (disabled) {
return (
<a
title={label}
aria-label={label}
className="nextjs-data-runtime-error-inspect-link"
href={`https://nextjs.org/docs/app/building-your-application/configuring/debugging#server-side-code`}
target="_blank"
rel="noopener noreferrer"
>
<NodeJsDisabledIcon width={16} height={16} />
</a>
)
}
return (
<CopyButton
data-nextjs-data-runtime-error-copy-devtools-url
actionLabel={'Copy Chrome DevTools URL'}
successLabel="Copied"
content={content}
icon={<NodeJsIcon width={16} height={16} />}
/>
)
}
import * as React from 'react'
import type { VersionInfo } from '../../../../../../server/dev/parse-version-info'
import {
Dialog,
DialogBody,
DialogContent,
DialogHeader,
} from '../components/Dialog'
import { Overlay } from '../components/Overlay'
import { Terminal } from '../components/Terminal'
import { VersionStalenessInfo } from '../components/VersionStalenessInfo'
import { noop as css } from '../helpers/noop-template'
export type BuildErrorProps = { message: string; versionInfo?: VersionInfo }
export const BuildError: React.FC<BuildErrorProps> = function BuildError({
message,
versionInfo,
}) {
const noop = React.useCallback(() => {}, [])
return (
<Overlay fixed>
<Dialog
type="error"
aria-labelledby="nextjs__container_error_label"
aria-describedby="nextjs__container_error_desc"
onClose={noop}
>
<DialogContent>
<DialogHeader className="nextjs-container-errors-header">
<h1
id="nextjs__container_errors_label"
className="nextjs__container_errors_label"
>
{'Build Error'}
</h1>
<VersionStalenessInfo versionInfo={versionInfo} />
<p
id="nextjs__container_errors_desc"
className="nextjs__container_errors_desc"
>
Failed to compile
</p>
</DialogHeader>
<DialogBody className="nextjs-container-errors-body">
<Terminal content={message} />
<footer>
<p id="nextjs__container_build_error_desc">
<small>
This error occurred during the build process and can only be
dismissed by fixing the error.
</small>
</p>
</footer>
</DialogBody>
</DialogContent>
</Dialog>
</Overlay>
)
}
export const styles = css`
h1.nextjs__container_errors_label {
font-size: var(--size-font-big);
line-height: var(--size-font-bigger);
font-weight: bold;
margin: var(--size-gap-double) 0;
}
.nextjs-container-errors-header p {
font-size: var(--size-font-small);
line-height: var(--size-font-big);
white-space: pre-wrap;
}
.nextjs-container-errors-body footer {
margin-top: var(--size-gap);
}
.nextjs-container-errors-body footer p {
margin: 0;
}
.nextjs-container-errors-body small {
color: var(--color-font);
}
`
import type { StackFrame } from 'next/dist/compiled/stacktrace-parser'
import {
getFrameSource,
type OriginalStackFrame,
} from '../../helpers/stack-frame'
import { useOpenInEditor } from '../../helpers/use-open-in-editor'
import { HotlinkedText } from '../../components/hot-linked-text'
export const CallStackFrame: React.FC<{
frame: OriginalStackFrame
}> = function CallStackFrame({ frame }) {
// TODO: ability to expand resolved frames
// TODO: render error or external indicator
const f: StackFrame = frame.originalStackFrame ?? frame.sourceStackFrame
const hasSource = Boolean(frame.originalCodeFrame)
const open = useOpenInEditor(
hasSource
? {
file: f.file,
lineNumber: f.lineNumber,
column: f.column,
}
: undefined
)
// Format method to strip out the webpack layer prefix.
// e.g. (app-pages-browser)/./app/page.tsx -> ./app/page.tsx
const formattedMethod = f.methodName.replace(/^\([\w-]+\)\//, '')
// Formatted file source could be empty. e.g. <anonymous> will be formatted to empty string,
// we'll skip rendering the frame in this case.
const fileSource = getFrameSource(f)
if (!fileSource) {
return null
}
return (
<div data-nextjs-call-stack-frame>
<h3 data-nextjs-frame-expanded={!frame.ignored}>
<HotlinkedText text={formattedMethod} />
</h3>
<div
data-has-source={hasSource ? 'true' : undefined}
data-no-source={hasSource ? undefined : 'true'}
tabIndex={hasSource ? 10 : undefined}
role={hasSource ? 'link' : undefined}
onClick={open}
title={hasSource ? 'Click to open in your editor' : undefined}
>
<span>{fileSource}</span>
<svg
xmlns="http://www.w3.org/2000/svg"
viewBox="0 0 24 24"
fill="none"
stroke="currentColor"
strokeWidth="2"
strokeLinecap="round"
strokeLinejoin="round"
>
<path d="M18 13v6a2 2 0 0 1-2 2H5a2 2 0 0 1-2-2V8a2 2 0 0 1 2-2h6"></path>
<polyline points="15 3 21 3 21 9"></polyline>
<line x1="10" y1="14" x2="21" y2="3"></line>
</svg>
</div>
</div>
)
}
import React from 'react'
import type { ComponentStackFrame } from '../../helpers/parse-component-stack'
import { useOpenInEditor } from '../../helpers/use-open-in-editor'
import { HotlinkedText } from '../../components/hot-linked-text'
function EditorLink({
children,
componentStackFrame: { file, column, lineNumber },
}: {
children: React.ReactNode
componentStackFrame: ComponentStackFrame
}) {
const open = useOpenInEditor({
file,
column,
lineNumber,
})
return (
<div
tabIndex={10} // match CallStackFrame
role={'link'}
onClick={open}
title={'Click to open in your editor'}
>
{children}
<svg
xmlns="http://www.w3.org/2000/svg"
viewBox="0 0 24 24"
fill="none"
stroke="currentColor"
strokeWidth="2"
strokeLinecap="round"
strokeLinejoin="round"
>
<path d="M18 13v6a2 2 0 0 1-2 2H5a2 2 0 0 1-2-2V8a2 2 0 0 1 2-2h6"></path>
<polyline points="15 3 21 3 21 9"></polyline>
<line x1="10" y1="14" x2="21" y2="3"></line>
</svg>
</div>
)
}
function formatLineNumber(lineNumber: number, column: number | undefined) {
if (!column) {
return lineNumber
}
return `${lineNumber}:${column}`
}
function LocationLine({
componentStackFrame,
}: {
componentStackFrame: ComponentStackFrame
}) {
const { file, lineNumber, column } = componentStackFrame
return (
<>
{file} {lineNumber ? `(${formatLineNumber(lineNumber, column)})` : ''}
</>
)
}
function SourceLocation({
componentStackFrame,
}: {
componentStackFrame: ComponentStackFrame
}) {
const { file, canOpenInEditor } = componentStackFrame
if (file && canOpenInEditor) {
return (
<EditorLink componentStackFrame={componentStackFrame}>
<span>
<LocationLine componentStackFrame={componentStackFrame} />
</span>
</EditorLink>
)
}
return (
<div>
<LocationLine componentStackFrame={componentStackFrame} />
</div>
)
}
export function ComponentStackFrameRow({
componentStackFrame,
}: {
componentStackFrame: ComponentStackFrame
}) {
const { component } = componentStackFrame
return (
<div data-nextjs-component-stack-frame>
<h3>
<HotlinkedText text={component} />
</h3>
<SourceLocation componentStackFrame={componentStackFrame} />
</div>
)
}
import { useMemo, Fragment, useState } from 'react'
import type { ComponentStackFrame } from '../../helpers/parse-component-stack'
import { CollapseIcon } from '../../icons/CollapseIcon'
function getAdjacentProps(isAdj: boolean) {
return { 'data-nextjs-container-errors-pseudo-html--tag-adjacent': isAdj }
}
/**
*
* Format component stack into pseudo HTML
* component stack is an array of strings, e.g.: ['p', 'p', 'Page', ...]
*
* For html tags mismatch, it will render it for the code block
*
* ```
* <pre>
* <code>{`
* <Page>
* <p red>
* <p red>
* `}</code>
* </pre>
* ```
*
* For text mismatch, it will render it for the code block
*
* ```
* <pre>
* <code>{`
* <Page>
* <p>
* "Server Text" (green)
* "Client Text" (red)
* </p>
* </Page>
* `}</code>
* ```
*
* For bad text under a tag it will render it for the code block,
* e.g. "Mismatched Text" under <p>
*
* ```
* <pre>
* <code>{`
* <Page>
* <div>
* <p>
* "Mismatched Text" (red)
* </p>
* </div>
* </Page>
* `}</code>
* ```
*
*/
export function PseudoHtmlDiff({
componentStackFrames,
firstContent,
secondContent,
hydrationMismatchType,
reactOutputComponentDiff,
...props
}: {
componentStackFrames: ComponentStackFrame[]
firstContent: string
secondContent: string
reactOutputComponentDiff: string | undefined
hydrationMismatchType: 'tag' | 'text' | 'text-in-tag'
} & React.HTMLAttributes<HTMLPreElement>) {
const isHtmlTagsWarning = hydrationMismatchType === 'tag'
const isReactHydrationDiff = !!reactOutputComponentDiff
// For text mismatch, mismatched text will take 2 rows, so we display 4 rows of component stack
const MAX_NON_COLLAPSED_FRAMES = isHtmlTagsWarning ? 6 : 4
const [isHtmlCollapsed, toggleCollapseHtml] = useState(true)
const htmlComponents = useMemo(() => {
const componentStacks: React.ReactNode[] = []
// React 19 unified mismatch
if (isReactHydrationDiff) {
let currentComponentIndex = componentStackFrames.length - 1
const reactComponentDiffLines = reactOutputComponentDiff.split('\n')
const diffHtmlStack: React.ReactNode[] = []
reactComponentDiffLines.forEach((line, index) => {
let trimmedLine = line.trim()
const isDiffLine = trimmedLine[0] === '+' || trimmedLine[0] === '-'
const spaces = ' '.repeat(Math.max(componentStacks.length * 2, 1))
if (isDiffLine) {
const sign = trimmedLine[0]
trimmedLine = trimmedLine.slice(1).trim() // trim spaces after sign
diffHtmlStack.push(
<span
key={'comp-diff' + index}
data-nextjs-container-errors-pseudo-html--diff={
sign === '+' ? 'add' : 'remove'
}
>
{sign}
{spaces}
{trimmedLine}
{'\n'}
</span>
)
} else if (currentComponentIndex >= 0) {
const isUserLandComponent = trimmedLine.startsWith(
'<' + componentStackFrames[currentComponentIndex].component
)
// If it's matched userland component or it's ... we will keep the component stack in diff
if (isUserLandComponent || trimmedLine === '...') {
currentComponentIndex--
componentStacks.push(
<span key={'comp-diff' + index}>
{spaces}
{trimmedLine}
{'\n'}
</span>
)
} else if (!isHtmlCollapsed) {
componentStacks.push(
<span key={'comp-diff' + index}>
{spaces}
{trimmedLine}
{'\n'}
</span>
)
}
} else if (!isHtmlCollapsed) {
// In general, if it's not collapsed, show the whole diff
componentStacks.push(
<span key={'comp-diff' + index}>
{spaces}
{trimmedLine}
{'\n'}
</span>
)
}
})
return componentStacks.concat(diffHtmlStack)
}
const nestedHtmlStack: React.ReactNode[] = []
const tagNames = isHtmlTagsWarning
? // tags could have < or > in the name, so we always remove them to match
[firstContent.replace(/<|>/g, ''), secondContent.replace(/<|>/g, '')]
: []
let lastText = ''
const componentStack = componentStackFrames
.map((frame) => frame.component)
.reverse()
// [child index, parent index]
const matchedIndex = [-1, -1]
if (isHtmlTagsWarning) {
// Reverse search for the child tag
for (let i = componentStack.length - 1; i >= 0; i--) {
if (componentStack[i] === tagNames[0]) {
matchedIndex[0] = i
break
}
}
// Start searching parent tag from child tag above
for (let i = matchedIndex[0] - 1; i >= 0; i--) {
if (componentStack[i] === tagNames[1]) {
matchedIndex[1] = i
break
}
}
}
componentStack.forEach((component, index, componentList) => {
const spaces = ' '.repeat(nestedHtmlStack.length * 2)
// When component is the server or client tag name, highlight it
const isHighlightedTag = isHtmlTagsWarning
? index === matchedIndex[0] || index === matchedIndex[1]
: tagNames.includes(component)
const isAdjacentTag =
isHighlightedTag ||
Math.abs(index - matchedIndex[0]) <= 1 ||
Math.abs(index - matchedIndex[1]) <= 1
const isLastFewFrames =
!isHtmlTagsWarning && index >= componentList.length - 6
const adjProps = getAdjacentProps(isAdjacentTag)
if ((isHtmlTagsWarning && isAdjacentTag) || isLastFewFrames) {
const codeLine = (
<span>
{spaces}
<span
{...adjProps}
{...{
...(isHighlightedTag
? {
'data-nextjs-container-errors-pseudo-html--tag-error':
true,
}
: undefined),
}}
>
{`<${component}>\n`}
</span>
</span>
)
lastText = component
const wrappedCodeLine = (
<Fragment key={nestedHtmlStack.length}>
{codeLine}
{/* Add ^^^^ to the target tags used for snapshots but not displayed for users */}
{isHighlightedTag && (
<span data-nextjs-container-errors-pseudo-html--hint>
{spaces + '^'.repeat(component.length + 2) + '\n'}
</span>
)}
</Fragment>
)
nestedHtmlStack.push(wrappedCodeLine)
} else {
if (
nestedHtmlStack.length >= MAX_NON_COLLAPSED_FRAMES &&
isHtmlCollapsed
) {
return
}
if (!isHtmlCollapsed || isLastFewFrames) {
nestedHtmlStack.push(
<span {...adjProps} key={nestedHtmlStack.length}>
{spaces}
{'<' + component + '>\n'}
</span>
)
} else if (isHtmlCollapsed && lastText !== '...') {
lastText = '...'
nestedHtmlStack.push(
<span {...adjProps} key={nestedHtmlStack.length}>
{spaces}
{'...\n'}
</span>
)
}
}
})
// Hydration mismatch: text or text-tag
if (!isHtmlTagsWarning) {
const spaces = ' '.repeat(nestedHtmlStack.length * 2)
let wrappedCodeLine
if (hydrationMismatchType === 'text') {
// hydration type is "text", represent [server content, client content]
wrappedCodeLine = (
<Fragment key={nestedHtmlStack.length}>
<span data-nextjs-container-errors-pseudo-html--diff="remove">
{spaces + `"${firstContent}"\n`}
</span>
<span data-nextjs-container-errors-pseudo-html--diff="add">
{spaces + `"${secondContent}"\n`}
</span>
</Fragment>
)
} else if (hydrationMismatchType === 'text-in-tag') {
// hydration type is "text-in-tag", represent [parent tag, mismatch content]
wrappedCodeLine = (
<Fragment key={nestedHtmlStack.length}>
<span data-nextjs-container-errors-pseudo-html--tag-adjacent>
{spaces + `<${secondContent}>\n`}
</span>
<span data-nextjs-container-errors-pseudo-html--diff="remove">
{spaces + ` "${firstContent}"\n`}
</span>
</Fragment>
)
}
nestedHtmlStack.push(wrappedCodeLine)
}
return nestedHtmlStack
}, [
componentStackFrames,
isHtmlCollapsed,
firstContent,
secondContent,
isHtmlTagsWarning,
hydrationMismatchType,
MAX_NON_COLLAPSED_FRAMES,
isReactHydrationDiff,
reactOutputComponentDiff,
])
return (
<div data-nextjs-container-errors-pseudo-html>
<button
tabIndex={10} // match CallStackFrame
data-nextjs-container-errors-pseudo-html-collapse
onClick={() => toggleCollapseHtml(!isHtmlCollapsed)}
>
<CollapseIcon collapsed={isHtmlCollapsed} />
</button>
<pre {...props}>
<code>{htmlComponents}</code>
</pre>
</div>
)
}
import * as React from 'react'
import { CodeFrame } from '../../components/CodeFrame'
import type { ReadyRuntimeError } from '../../helpers/get-error-by-type'
import { noop as css } from '../../helpers/noop-template'
import { CallStackFrame } from './CallStackFrame'
export type RuntimeErrorProps = { error: ReadyRuntimeError }
export function RuntimeError({ error }: RuntimeErrorProps) {
const [isIgnoredExpanded, setIsIgnoredExpanded] = React.useState(false)
const {
firstFrame,
allLeadingFrames,
trailingCallStackFrames,
displayedFramesCount,
} = React.useMemo(() => {
const filteredFrames = error.frames.filter((frame) =>
isIgnoredExpanded ? true : !frame.ignored
)
const firstFirstPartyFrameIndex = filteredFrames.findIndex(
(entry) =>
!entry.ignored &&
Boolean(entry.originalCodeFrame) &&
Boolean(entry.originalStackFrame)
)
return {
displayedFramesCount: filteredFrames.length,
firstFrame: filteredFrames[firstFirstPartyFrameIndex] ?? null,
allLeadingFrames:
firstFirstPartyFrameIndex < 0
? []
: filteredFrames.slice(0, firstFirstPartyFrameIndex),
trailingCallStackFrames: filteredFrames.slice(
firstFirstPartyFrameIndex + 1
),
}
}, [error.frames, isIgnoredExpanded])
return (
<React.Fragment>
{firstFrame ? (
<>
<h2>Source</h2>
{allLeadingFrames.map((frame, frameIndex) => (
<CallStackFrame
key={`call-stack-leading-${frameIndex}`}
frame={frame}
/>
))}
<CodeFrame
stackFrame={firstFrame.originalStackFrame!}
codeFrame={firstFrame.originalCodeFrame!}
/>
</>
) : undefined}
{trailingCallStackFrames.map((frame, frameIndex) => (
<CallStackFrame
key={`call-stack-leading-${frameIndex}`}
frame={frame}
/>
))}
{
// if the default displayed ignored frames count is equal equal to the total frames count, hide the button
displayedFramesCount === error.frames.length &&
!isIgnoredExpanded ? null : (
<button
data-expand-ignore-button={isIgnoredExpanded}
onClick={() => setIsIgnoredExpanded(!isIgnoredExpanded)}
>
{`${isIgnoredExpanded ? 'Hide' : 'Show'} ignored frames`}
</button>
)
}
</React.Fragment>
)
}
export const styles = css`
[data-nextjs-call-stack-frame]:not(:last-child),
[data-nextjs-component-stack-frame]:not(:last-child) {
margin-bottom: var(--size-gap-double);
}
[data-expand-ignore-button]:focus:not(:focus-visible),
[data-expand-ignore-button] {
background: none;
border: none;
color: var(--color-font);
cursor: pointer;
font-size: var(--size-font);
margin: var(--size-gap) 0;
padding: 0;
text-decoration: underline;
outline: none;
}
[data-nextjs-data-runtime-error-copy-button],
[data-nextjs-data-runtime-error-copy-button]:focus:not(:focus-visible) {
position: relative;
margin-left: var(--size-gap);
padding: 0;
border: none;
background: none;
outline: none;
}
[data-nextjs-data-runtime-error-copy-button] > svg {
vertical-align: middle;
}
.nextjs-data-runtime-error-copy-button {
color: inherit;
}
.nextjs-data-runtime-error-copy-button--initial:hover {
cursor: pointer;
}
.nextjs-data-runtime-error-copy-button[aria-disabled='true'] {
opacity: 0.3;
cursor: not-allowed;
}
.nextjs-data-runtime-error-copy-button--error,
.nextjs-data-runtime-error-copy-button--error:hover {
color: var(--color-ansi-red);
}
.nextjs-data-runtime-error-copy-button--success {
color: var(--color-ansi-green);
}
[data-nextjs-call-stack-frame] > h3,
[data-nextjs-component-stack-frame] > h3 {
margin-top: 0;
margin-bottom: 0;
font-family: var(--font-stack-monospace);
font-size: var(--size-font);
}
[data-nextjs-call-stack-frame] > h3[data-nextjs-frame-expanded='false'] {
color: #666;
display: inline-block;
}
[data-nextjs-call-stack-frame] > div,
[data-nextjs-component-stack-frame] > div {
display: flex;
align-items: center;
padding-left: calc(var(--size-gap) + var(--size-gap-half));
font-size: var(--size-font-small);
color: #999;
}
[data-nextjs-call-stack-frame] > div > svg,
[data-nextjs-component-stack-frame] > [role='link'] > svg {
width: auto;
height: var(--size-font-small);
margin-left: var(--size-gap);
flex-shrink: 0;
display: none;
}
[data-nextjs-call-stack-frame] > div[data-has-source],
[data-nextjs-component-stack-frame] > [role='link'] {
cursor: pointer;
}
[data-nextjs-call-stack-frame] > div[data-has-source]:hover,
[data-nextjs-component-stack-frame] > [role='link']:hover {
text-decoration: underline dotted;
}
[data-nextjs-call-stack-frame] > div[data-has-source] > svg,
[data-nextjs-component-stack-frame] > [role='link'] > svg {
display: unset;
}
[data-nextjs-call-stack-framework-icon] {
margin-right: var(--size-gap);
}
[data-nextjs-call-stack-framework-icon='next'] > mask {
mask-type: alpha;
}
[data-nextjs-call-stack-framework-icon='react'] {
color: rgb(20, 158, 202);
}
[data-nextjs-collapsed-call-stack-details][open]
[data-nextjs-call-stack-chevron-icon] {
transform: rotate(90deg);
}
[data-nextjs-collapsed-call-stack-details] summary {
display: flex;
align-items: center;
margin-bottom: var(--size-gap);
list-style: none;
}
[data-nextjs-collapsed-call-stack-details] summary::-webkit-details-marker {
display: none;
}
[data-nextjs-collapsed-call-stack-details] h3 {
color: #666;
}
[data-nextjs-collapsed-call-stack-details] [data-nextjs-call-stack-frame] {
margin-bottom: var(--size-gap-double);
}
[data-nextjs-container-errors-pseudo-html] {
position: relative;
}
[data-nextjs-container-errors-pseudo-html-collapse] {
position: absolute;
left: 10px;
top: 10px;
color: inherit;
background: none;
border: none;
padding: 0;
}
[data-nextjs-container-errors-pseudo-html--diff='add'] {
color: var(--color-ansi-green);
}
[data-nextjs-container-errors-pseudo-html--diff='remove'] {
color: var(--color-ansi-red);
}
[data-nextjs-container-errors-pseudo-html--tag-error] {
color: var(--color-ansi-red);
font-weight: bold;
}
/* hide but text are still accessible in DOM */
[data-nextjs-container-errors-pseudo-html--hint] {
display: inline-block;
font-size: 0;
}
[data-nextjs-container-errors-pseudo-html--tag-adjacent='false'] {
color: var(--color-accents-1);
}
`
import * as React from 'react'
import { Toast } from '../components/Toast'
import { LightningBolt } from '../icons/LightningBolt'
import { CloseIcon } from '../icons/CloseIcon'
import type { Dispatcher } from '../../../app/hot-reloader-client'
export function StaticIndicator({ dispatcher }: { dispatcher?: Dispatcher }) {
return (
<Toast role="status" className={`nextjs-static-indicator-toast-wrapper`}>
<div className="nextjs-static-indicator-toast-icon">
<LightningBolt />
</div>
<div className="nextjs-static-indicator-toast-text">
Static route
<button
onClick={() => {
// When dismissed, we hide the indicator for 1 hour. Store the
// timestamp for when to show it again.
const oneHourAway = Date.now() + 1 * 60 * 60 * 1000
localStorage?.setItem(
'__NEXT_DISMISS_PRERENDER_INDICATOR',
oneHourAway.toString()
)
dispatcher?.onStaticIndicator(false)
}}
className="nextjs-toast-hide-button"
aria-label="Hide static indicator"
>
<CloseIcon />
</button>
</div>
</Toast>
)
}
import * as React from 'react'
import type { VersionInfo } from '../../../../../../server/dev/parse-version-info'
import { Dialog, DialogContent, DialogHeader } from '../components/Dialog'
import { Overlay } from '../components/Overlay'
import { VersionStalenessInfo } from '../components/VersionStalenessInfo'
import { HotlinkedText } from '../components/hot-linked-text'
type RootLayoutMissingTagsErrorProps = {
missingTags: string[]
versionInfo?: VersionInfo
}
export const RootLayoutMissingTagsError: React.FC<RootLayoutMissingTagsErrorProps> =
function RootLayoutMissingTagsError({ missingTags, versionInfo }) {
const noop = React.useCallback(() => {}, [])
return (
<Overlay>
<Dialog
type="error"
aria-labelledby="nextjs__container_errors_label"
aria-describedby="nextjs__container_errors_desc"
onClose={noop}
>
<DialogContent>
<DialogHeader className="nextjs-container-errors-header">
<VersionStalenessInfo versionInfo={versionInfo} />
<h1
id="nextjs__container_errors_label"
className="nextjs__container_errors_label"
>
Missing required html tags
</h1>
<p
id="nextjs__container_errors_desc"
className="nextjs__container_errors_desc"
>
<HotlinkedText
text={`The following tags are missing in the Root Layout: ${missingTags
.map((tagName) => `<${tagName}>`)
.join(
', '
)}.\nRead more at https://nextjs.org/docs/messages/missing-root-layout-tags`}
/>
</p>
</DialogHeader>
</DialogContent>
</Dialog>
</Overlay>
)
}
import {
isHydrationError,
getDefaultHydrationErrorMessage,
} from '../../../../is-hydration-error'
import {
hydrationErrorState,
getReactHydrationDiffSegments,
} from './hydration-error-info'
export function attachHydrationErrorState(error: Error) {
if (
isHydrationError(error) &&
!error.message.includes(
'https://nextjs.org/docs/messages/react-hydration-error'
)
) {
const reactHydrationDiffSegments = getReactHydrationDiffSegments(
error.message
)
let parsedHydrationErrorState: typeof hydrationErrorState = {}
if (reactHydrationDiffSegments) {
parsedHydrationErrorState = {
...(error as any).details,
...hydrationErrorState,
warning: hydrationErrorState.warning || [
getDefaultHydrationErrorMessage(),
],
notes: reactHydrationDiffSegments[0],
reactOutputComponentDiff: reactHydrationDiffSegments[1],
}
} else {
// If there's any extra information in the error message to display,
// append it to the error message details property
if (hydrationErrorState.warning) {
// The patched console.error found hydration errors logged by React
// Append the logged warning to the error message
parsedHydrationErrorState = {
...(error as any).details,
// It contains the warning, component stack, server and client tag names
...hydrationErrorState,
}
}
}
;(error as any).details = parsedHydrationErrorState
}
}
// To distinguish from React error.digest, we use a different symbol here to determine if the error is from console.error or unhandled promise rejection.
const digestSym = Symbol.for('next.console.error.digest')
const consoleTypeSym = Symbol.for('next.console.error.type')
// Represent non Error shape unhandled promise rejections or console.error errors.
// Those errors will be captured and displayed in Error Overlay.
type UnhandledError = Error & {
[digestSym]: 'NEXT_UNHANDLED_ERROR'
[consoleTypeSym]: 'string' | 'error'
}
export function createUnhandledError(message: string | Error): UnhandledError {
const error = (
typeof message === 'string' ? new Error(message) : message
) as UnhandledError
error[digestSym] = 'NEXT_UNHANDLED_ERROR'
error[consoleTypeSym] = typeof message === 'string' ? 'string' : 'error'
return error
}
export const isUnhandledConsoleOrRejection = (
error: any
): error is UnhandledError => {
return error && error[digestSym] === 'NEXT_UNHANDLED_ERROR'
}
export const getUnhandledErrorType = (error: UnhandledError) => {
return error[consoleTypeSym]
}
import { isHydrationError } from '../../../../is-hydration-error'
// Dedupe the two consecutive errors: If the previous one is same as current one, ignore the current one.
export function enqueueConsecutiveDedupedError(
queue: Array<Error>,
error: Error
) {
const isFront = isHydrationError(error)
const previousError = isFront ? queue[0] : queue[queue.length - 1]
// Compare the error stack to dedupe the consecutive errors
if (previousError && previousError.stack === error.stack) {
return
}
// TODO: change all to push error into errorQueue,
// currently there's a async api error is always erroring while hydration error showing up.
// Move hydration error to the front of the queue to unblock.
if (isFront) {
queue.unshift(error)
} else {
queue.push(error)
}
}
/**
MIT License
Copyright (c) 2015-present, Facebook, Inc.
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
*/
import stripAnsi from 'next/dist/compiled/strip-ansi'
// This file is based on https://github.com/facebook/create-react-app/blob/7b1a32be6ec9f99a6c9a3c66813f3ac09c4736b9/packages/react-dev-utils/formatWebpackMessages.js
// It's been edited to remove chalk and CRA-specific logic
const friendlySyntaxErrorLabel = 'Syntax error:'
const WEBPACK_BREAKING_CHANGE_POLYFILLS =
'\n\nBREAKING CHANGE: webpack < 5 used to include polyfills for node.js core modules by default.'
function isLikelyASyntaxError(message: string) {
return stripAnsi(message).includes(friendlySyntaxErrorLabel)
}
let hadMissingSassError = false
// Cleans up webpack error messages.
function formatMessage(
message: any,
verbose?: boolean,
importTraceNote?: boolean
) {
// TODO: Replace this once webpack 5 is stable
if (typeof message === 'object' && message.message) {
const filteredModuleTrace =
message.moduleTrace &&
message.moduleTrace.filter(
(trace: any) =>
!/next-(middleware|client-pages|route|edge-function)-loader\.js/.test(
trace.originName
)
)
let body = message.message
const breakingChangeIndex = body.indexOf(WEBPACK_BREAKING_CHANGE_POLYFILLS)
if (breakingChangeIndex >= 0) {
body = body.slice(0, breakingChangeIndex)
}
message =
(message.moduleName ? stripAnsi(message.moduleName) + '\n' : '') +
(message.file ? stripAnsi(message.file) + '\n' : '') +
body +
(message.details && verbose ? '\n' + message.details : '') +
(filteredModuleTrace && filteredModuleTrace.length
? (importTraceNote || '\n\nImport trace for requested module:') +
filteredModuleTrace
.map((trace: any) => `\n${trace.moduleName}`)
.join('')
: '') +
(message.stack && verbose ? '\n' + message.stack : '')
}
let lines = message.split('\n')
// Strip Webpack-added headers off errors/warnings
// https://github.com/webpack/webpack/blob/master/lib/ModuleError.js
lines = lines.filter((line: string) => !/Module [A-z ]+\(from/.test(line))
// Transform parsing error into syntax error
// TODO: move this to our ESLint formatter?
lines = lines.map((line: string) => {
const parsingError = /Line (\d+):(?:(\d+):)?\s*Parsing error: (.+)$/.exec(
line
)
if (!parsingError) {
return line
}
const [, errorLine, errorColumn, errorMessage] = parsingError
return `${friendlySyntaxErrorLabel} ${errorMessage} (${errorLine}:${errorColumn})`
})
message = lines.join('\n')
// Smoosh syntax errors (commonly found in CSS)
message = message.replace(
/SyntaxError\s+\((\d+):(\d+)\)\s*(.+?)\n/g,
`${friendlySyntaxErrorLabel} $3 ($1:$2)\n`
)
// Clean up export errors
message = message.replace(
/^.*export '(.+?)' was not found in '(.+?)'.*$/gm,
`Attempted import error: '$1' is not exported from '$2'.`
)
message = message.replace(
/^.*export 'default' \(imported as '(.+?)'\) was not found in '(.+?)'.*$/gm,
`Attempted import error: '$2' does not contain a default export (imported as '$1').`
)
message = message.replace(
/^.*export '(.+?)' \(imported as '(.+?)'\) was not found in '(.+?)'.*$/gm,
`Attempted import error: '$1' is not exported from '$3' (imported as '$2').`
)
lines = message.split('\n')
// Remove leading newline
if (lines.length > 2 && lines[1].trim() === '') {
lines.splice(1, 1)
}
// Cleans up verbose "module not found" messages for files and packages.
if (lines[1] && lines[1].startsWith('Module not found: ')) {
lines = [
lines[0],
lines[1]
.replace('Error: ', '')
.replace('Module not found: Cannot find file:', 'Cannot find file:'),
...lines.slice(2),
]
}
// Add helpful message for users trying to use Sass for the first time
if (lines[1] && lines[1].match(/Cannot find module.+sass/)) {
// ./file.module.scss (<<loader info>>) => ./file.module.scss
const firstLine = lines[0].split('!')
lines[0] = firstLine[firstLine.length - 1]
lines[1] =
"To use Next.js' built-in Sass support, you first need to install `sass`.\n"
lines[1] += 'Run `npm i sass` or `yarn add sass` inside your workspace.\n'
lines[1] += '\nLearn more: https://nextjs.org/docs/messages/install-sass'
// dispose of unhelpful stack trace
lines = lines.slice(0, 2)
hadMissingSassError = true
} else if (
hadMissingSassError &&
message.match(/(sass-loader|resolve-url-loader: CSS error)/)
) {
// dispose of unhelpful stack trace following missing sass module
lines = []
}
if (!verbose) {
message = lines.join('\n')
// Internal stacks are generally useless so we strip them... with the
// exception of stacks containing `webpack:` because they're normally
// from user code generated by Webpack. For more information see
// https://github.com/facebook/create-react-app/pull/1050
message = message.replace(
/^\s*at\s((?!webpack:).)*:\d+:\d+[\s)]*(\n|$)/gm,
''
) // at ... ...:x:y
message = message.replace(/^\s*at\s<anonymous>(\n|$)/gm, '') // at <anonymous>
message = message.replace(
/File was processed with these loaders:\n(.+[\\/](next[\\/]dist[\\/].+|@next[\\/]react-refresh-utils[\\/]loader)\.js\n)*You may need an additional loader to handle the result of these loaders.\n/g,
''
)
lines = message.split('\n')
}
// Remove duplicated newlines
lines = (lines as string[]).filter(
(line, index, arr) =>
index === 0 || line.trim() !== '' || line.trim() !== arr[index - 1].trim()
)
// Reassemble the message
message = lines.join('\n')
return message.trim()
}
export default function formatWebpackMessages(json: any, verbose?: boolean) {
const formattedErrors = json.errors.map((message: any) => {
const isUnknownNextFontError = message.message.includes(
'An error occurred in `next/font`.'
)
return formatMessage(message, isUnknownNextFontError || verbose)
})
const formattedWarnings = json.warnings.map((message: any) => {
return formatMessage(message, verbose)
})
// Reorder errors to put the most relevant ones first.
let reactServerComponentsError = -1
for (let i = 0; i < formattedErrors.length; i++) {
const error = formattedErrors[i]
if (error.includes('ReactServerComponentsError')) {
reactServerComponentsError = i
break
}
}
// Move the reactServerComponentsError to the top if it exists
if (reactServerComponentsError !== -1) {
const error = formattedErrors.splice(reactServerComponentsError, 1)
formattedErrors.unshift(error[0])
}
const result = {
...json,
errors: formattedErrors,
warnings: formattedWarnings,
}
if (!verbose && result.errors.some(isLikelyASyntaxError)) {
// If there are any syntax errors, show just them.
result.errors = result.errors.filter(isLikelyASyntaxError)
result.warnings = []
}
return result
}
import {
ACTION_UNHANDLED_ERROR,
ACTION_UNHANDLED_REJECTION,
} from '../../../shared'
import type { SupportedErrorEvent } from '../container/Errors'
import { getOriginalStackFrames } from './stack-frame'
import type { OriginalStackFrame } from './stack-frame'
import type { ComponentStackFrame } from './parse-component-stack'
import { getErrorSource } from '../../../../../../shared/lib/error-source'
export type ReadyRuntimeError = {
id: number
runtime: true
error: Error
frames: OriginalStackFrame[]
componentStackFrames?: ComponentStackFrame[]
}
export async function getErrorByType(
ev: SupportedErrorEvent,
isAppDir: boolean
): Promise<ReadyRuntimeError> {
const { id, event } = ev
switch (event.type) {
case ACTION_UNHANDLED_ERROR:
case ACTION_UNHANDLED_REJECTION: {
const readyRuntimeError: ReadyRuntimeError = {
id,
runtime: true,
error: event.reason,
frames: await getOriginalStackFrames(
event.frames,
getErrorSource(event.reason),
isAppDir,
event.reason.toString()
),
}
if (event.type === ACTION_UNHANDLED_ERROR) {
readyRuntimeError.componentStackFrames = event.componentStackFrames
}
return readyRuntimeError
}
default: {
break
}
}
// eslint-disable-next-line @typescript-eslint/no-unused-vars
const _: never = event as never
throw new Error('type system invariant violation')
}
import { normalizedAssetPrefix } from '../../../../../../shared/lib/normalized-asset-prefix'
function getSocketProtocol(assetPrefix: string): string {
let protocol = window.location.protocol
try {
// assetPrefix is a url
protocol = new URL(assetPrefix).protocol
} catch {}
return protocol === 'http:' ? 'ws:' : 'wss:'
}
export function getSocketUrl(assetPrefix: string | undefined): string {
const prefix = normalizedAssetPrefix(assetPrefix)
const protocol = getSocketProtocol(assetPrefix || '')
if (URL.canParse(prefix)) {
// since normalized asset prefix is ensured to be a URL format,
// we can safely replace the protocol
return prefix.replace(/^http/, 'ws')
}
const { hostname, port } = window.location
return `${protocol}//${hostname}${port ? `:${port}` : ''}${prefix}`
}
import fs from 'fs/promises'
import path from 'path'
import url from 'url'
import type { RawSourceMap } from 'next/dist/compiled/source-map08'
import dataUriToBuffer from 'next/dist/compiled/data-uri-to-buffer'
import { getSourceMapUrl } from './get-source-map-url'
export async function getSourceMapFromFile(
filename: string
): Promise<RawSourceMap | undefined> {
filename = filename.startsWith('file://')
? url.fileURLToPath(filename)
: filename
let fileContents: string
try {
fileContents = await fs.readFile(filename, 'utf-8')
} catch (error) {
throw new Error(`Failed to read file contents of ${filename}.`, {
cause: error,
})
}
const sourceUrl = getSourceMapUrl(fileContents)
if (!sourceUrl) {
return undefined
}
if (sourceUrl.startsWith('data:')) {
let buffer: dataUriToBuffer.MimeBuffer
try {
buffer = dataUriToBuffer(sourceUrl)
} catch (error) {
throw new Error(`Failed to parse source map URL for ${filename}.`, {
cause: error,
})
}
if (buffer.type !== 'application/json') {
throw new Error(
`Unknown source map type for ${filename}: ${buffer.typeFull}.`
)
}
try {
return JSON.parse(buffer.toString())
} catch (error) {
throw new Error(`Failed to parse source map for ${filename}.`, {
cause: error,
})
}
}
const sourceMapFilename = path.resolve(
path.dirname(filename),
decodeURIComponent(sourceUrl)
)
try {
const sourceMapContents = await fs.readFile(sourceMapFilename, 'utf-8')
return JSON.parse(sourceMapContents.toString())
} catch (error) {
throw new Error(`Failed to parse source map ${sourceMapFilename}.`, {
cause: error,
})
}
}
export function getSourceMapUrl(fileContents: string): string | null {
const regex = /\/\/[#@] ?sourceMappingURL=([^\s'"]+)\s*$/gm
let match = null
for (;;) {
let next = regex.exec(fileContents)
if (next == null) {
break
}
match = next
}
if (!(match && match[1])) {
return null
}
return match[1].toString()
}
import { getHydrationErrorStackInfo } from '../../../../is-hydration-error'
export type HydrationErrorState = {
// Hydration warning template format: <message> <serverContent> <clientContent>
warning?: [string, string, string]
componentStack?: string
serverContent?: string
clientContent?: string
// React 19 hydration diff format: <notes> <link> <component diff?>
notes?: string
reactOutputComponentDiff?: string
}
type NullableText = string | null | undefined
export const hydrationErrorState: HydrationErrorState = {}
// https://github.com/facebook/react/blob/main/packages/react-dom/src/__tests__/ReactDOMHydrationDiff-test.js used as a reference
const htmlTagsWarnings = new Set([
'Warning: In HTML, %s cannot be a child of <%s>.%s\nThis will cause a hydration error.%s',
'Warning: In HTML, %s cannot be a descendant of <%s>.\nThis will cause a hydration error.%s',
'Warning: In HTML, text nodes cannot be a child of <%s>.\nThis will cause a hydration error.',
"Warning: In HTML, whitespace text nodes cannot be a child of <%s>. Make sure you don't have any extra whitespace between tags on each line of your source code.\nThis will cause a hydration error.",
'Warning: Expected server HTML to contain a matching <%s> in <%s>.%s',
'Warning: Did not expect server HTML to contain a <%s> in <%s>.%s',
])
const textAndTagsMismatchWarnings = new Set([
'Warning: Expected server HTML to contain a matching text node for "%s" in <%s>.%s',
'Warning: Did not expect server HTML to contain the text node "%s" in <%s>.%s',
])
const textMismatchWarning =
'Warning: Text content did not match. Server: "%s" Client: "%s"%s'
export const getHydrationWarningType = (
message: NullableText
): 'tag' | 'text' | 'text-in-tag' => {
if (typeof message !== 'string') {
// TODO: Doesn't make sense to treat no message as a hydration error message.
// We should bail out somewhere earlier.
return 'text'
}
const normalizedMessage = message.startsWith('Warning: ')
? message
: `Warning: ${message}`
if (isHtmlTagsWarning(normalizedMessage)) return 'tag'
if (isTextInTagsMismatchWarning(normalizedMessage)) return 'text-in-tag'
return 'text'
}
const isHtmlTagsWarning = (message: string) => htmlTagsWarnings.has(message)
const isTextMismatchWarning = (message: string) =>
textMismatchWarning === message
const isTextInTagsMismatchWarning = (msg: string) =>
textAndTagsMismatchWarnings.has(msg)
const isKnownHydrationWarning = (message: NullableText) => {
if (typeof message !== 'string') {
return false
}
// React 18 has the `Warning: ` prefix.
// React 19 does not.
const normalizedMessage = message.startsWith('Warning: ')
? message
: `Warning: ${message}`
return (
isHtmlTagsWarning(normalizedMessage) ||
isTextInTagsMismatchWarning(normalizedMessage) ||
isTextMismatchWarning(normalizedMessage)
)
}
export const getReactHydrationDiffSegments = (msg: NullableText) => {
if (msg) {
const { message, diff } = getHydrationErrorStackInfo(msg)
if (message) return [message, diff]
}
return undefined
}
/**
* Patch console.error to capture hydration errors.
* If any of the knownHydrationWarnings are logged, store the message and component stack.
* When the hydration runtime error is thrown, the message and component stack are added to the error.
* This results in a more helpful error message in the error overlay.
*/
export function storeHydrationErrorStateFromConsoleArgs(...args: any[]) {
const [msg, serverContent, clientContent, componentStack] = args
if (isKnownHydrationWarning(msg)) {
hydrationErrorState.warning = [
// remove the last %s from the message
msg,
serverContent,
clientContent,
]
hydrationErrorState.componentStack = componentStack
hydrationErrorState.serverContent = serverContent
hydrationErrorState.clientContent = clientContent
}
}
import { parse } from 'next/dist/compiled/stacktrace-parser'
import type { StackFrame } from 'next/dist/compiled/stacktrace-parser'
import {
decorateServerError,
type ErrorSourceType,
} from '../../../../../../shared/lib/error-source'
export function getFilesystemFrame(frame: StackFrame): StackFrame {
const f: StackFrame = { ...frame }
if (typeof f.file === 'string') {
if (
// Posix:
f.file.startsWith('/') ||
// Win32:
/^[a-z]:\\/i.test(f.file) ||
// Win32 UNC:
f.file.startsWith('\\\\')
) {
f.file = `file://${f.file}`
}
}
return f
}
export function getServerError(error: Error, type: ErrorSourceType): Error {
if (error.name === 'TurbopackInternalError') {
// If this is an internal Turbopack error we shouldn't show internal details
// to the user. These are written to a log file instead.
const turbopackInternalError = new Error(
'An unexpected Turbopack error occurred. Please see the output of `next dev` for more details.'
)
decorateServerError(turbopackInternalError, type)
return turbopackInternalError
}
let n: Error
try {
throw new Error(error.message)
} catch (e) {
n = e as Error
}
n.name = error.name
try {
n.stack = `${n.toString()}\n${parse(error.stack!)
.map(getFilesystemFrame)
.map((f) => {
let str = ` at ${f.methodName}`
if (f.file) {
let loc = f.file
if (f.lineNumber) {
loc += `:${f.lineNumber}`
if (f.column) {
loc += `:${f.column}`
}
}
str += ` (${loc})`
}
return str
})
.join('\n')}`
} catch {
n.stack = error.stack
}
decorateServerError(n, type)
return n
}
export function noop(
strings: TemplateStringsArray,
...keys: readonly string[]
) {
const lastIndex = strings.length - 1
return (
strings.slice(0, lastIndex).reduce((p, s, i) => p + s + keys[i], '') +
strings[lastIndex]
)
}
export type ComponentStackFrame = {
canOpenInEditor: boolean
component: string
file?: string
lineNumber?: number
column?: number
}
enum LocationType {
FILE = 'file',
WEBPACK_INTERNAL = 'webpack-internal',
HTTP = 'http',
PROTOCOL_RELATIVE = 'protocol-relative',
UNKNOWN = 'unknown',
}
/**
* Get the type of frame line based on the location
*/
function getLocationType(location: string): LocationType {
if (location.startsWith('file://')) {
return LocationType.FILE
}
if (location.includes('webpack-internal://')) {
return LocationType.WEBPACK_INTERNAL
}
if (location.startsWith('http://') || location.startsWith('https://')) {
return LocationType.HTTP
}
if (location.startsWith('//')) {
return LocationType.PROTOCOL_RELATIVE
}
return LocationType.UNKNOWN
}
function parseStackFrameLocation(
location: string
): Omit<ComponentStackFrame, 'component'> {
const locationType = getLocationType(location)
const modulePath = location?.replace(
/^(webpack-internal:\/\/\/|file:\/\/)(\(.*\)\/)?/,
''
)
const [, file, lineNumber, column] =
modulePath?.match(/^(.+):(\d+):(\d+)/) ?? []
switch (locationType) {
case LocationType.FILE:
case LocationType.WEBPACK_INTERNAL:
return {
canOpenInEditor: true,
file,
lineNumber: lineNumber ? Number(lineNumber) : undefined,
column: column ? Number(column) : undefined,
}
// When the location is a URL we only show the file
// TODO: Resolve http(s) URLs through sourcemaps
case LocationType.HTTP:
case LocationType.PROTOCOL_RELATIVE:
case LocationType.UNKNOWN:
default: {
return {
canOpenInEditor: false,
}
}
}
}
export function parseComponentStack(
componentStack: string
): ComponentStackFrame[] {
const componentStackFrames: ComponentStackFrame[] = []
for (const line of componentStack.trim().split('\n')) {
// TODO: support safari stack trace
// Get component and file from the component stack line
const match = /at ([^ ]+)( \((.*)\))?/.exec(line)
if (match?.[1]) {
const component = match[1]
const location = match[3]
if (!location) {
componentStackFrames.push({
canOpenInEditor: false,
component,
})
continue
}
// Stop parsing the component stack if we reach a Next.js component
if (location?.includes('next/dist')) {
break
}
const frameLocation = parseStackFrameLocation(location)
componentStackFrames.push({
component,
...frameLocation,
})
}
}
return componentStackFrames
}
import { parse } from 'next/dist/compiled/stacktrace-parser'
import type { StackFrame } from 'next/dist/compiled/stacktrace-parser'
import {
getHydrationErrorStackInfo,
isReactHydrationErrorMessage,
} from '../../../../is-hydration-error'
const regexNextStatic = /\/_next(\/static\/.+)/
export function parseStack(stack: string | undefined): StackFrame[] {
if (!stack) return []
const messageAndStack = stack.replace(/^Error: /, '')
if (isReactHydrationErrorMessage(messageAndStack)) {
const { stack: parsedStack } = getHydrationErrorStackInfo(messageAndStack)
if (parsedStack) {
stack = parsedStack
}
}
// throw away eval information that stacktrace-parser doesn't support
// adapted from https://github.com/stacktracejs/error-stack-parser/blob/9f33c224b5d7b607755eb277f9d51fcdb7287e24/error-stack-parser.js#L59C33-L59C62
stack = stack
.split('\n')
.map((line) => {
if (line.includes('(eval ')) {
line = line
.replace(/eval code/g, 'eval')
.replace(/\(eval at [^()]* \(/, '(file://')
.replace(/\),.*$/g, ')')
}
return line
})
.join('\n')
const frames = parse(stack)
return frames.map((frame) => {
try {
const url = new URL(frame.file!)
const res = regexNextStatic.exec(url.pathname)
if (res) {
const distDir = process.env.__NEXT_DIST_DIR
?.replace(/\\/g, '/')
?.replace(/\/$/, '')
if (distDir) {
frame.file = 'file://' + distDir.concat(res.pop()!) + url.search
}
}
} catch {}
return frame
})
}
import type { StackFrame } from 'next/dist/compiled/stacktrace-parser'
import type { OriginalStackFrameResponse } from '../../../server/shared'
import {
isWebpackInternalResource,
formatFrameSourceFile,
} from './webpack-module-path'
export interface OriginalStackFrame extends OriginalStackFrameResponse {
error: boolean
reason: string | null
external: boolean
ignored: boolean
sourceStackFrame: StackFrame
}
function getOriginalStackFrame(
source: StackFrame,
type: 'server' | 'edge-server' | null,
isAppDir: boolean,
errorMessage: string
): Promise<OriginalStackFrame> {
async function _getOriginalStackFrame(): Promise<OriginalStackFrame> {
const params = new URLSearchParams()
params.append('isServer', String(type === 'server'))
params.append('isEdgeServer', String(type === 'edge-server'))
params.append('isAppDirectory', String(isAppDir))
params.append('errorMessage', errorMessage)
for (const key in source) {
params.append(key, ((source as any)[key] ?? '').toString())
}
const controller = new AbortController()
const tm = setTimeout(() => controller.abort(), 3000)
const res = await self
.fetch(
`${
process.env.__NEXT_ROUTER_BASEPATH || ''
}/__nextjs_original-stack-frame?${params.toString()}`,
{ signal: controller.signal }
)
.finally(() => {
clearTimeout(tm)
})
if (!res.ok || res.status === 204) {
return Promise.reject(new Error(await res.text()))
}
const body: OriginalStackFrameResponse = await res.json()
return {
error: false,
reason: null,
external: false,
sourceStackFrame: source,
originalStackFrame: body.originalStackFrame,
originalCodeFrame: body.originalCodeFrame || null,
sourcePackage: body.sourcePackage,
ignored: body.originalStackFrame?.ignored || false,
}
}
// TODO: merge this section into ignoredList handling
if (
source.file === 'file://' ||
source.file?.match(/^node:/) ||
source.file?.match(/https?:\/\//)
) {
return Promise.resolve({
error: false,
reason: null,
external: true,
sourceStackFrame: source,
originalStackFrame: null,
originalCodeFrame: null,
sourcePackage: null,
ignored: true,
})
}
return _getOriginalStackFrame().catch((err: Error) => ({
error: true,
reason: err?.message ?? err?.toString() ?? 'Unknown Error',
external: false,
sourceStackFrame: source,
originalStackFrame: null,
originalCodeFrame: null,
sourcePackage: null,
ignored: false,
}))
}
export function getOriginalStackFrames(
frames: StackFrame[],
type: 'server' | 'edge-server' | null,
isAppDir: boolean,
errorMessage: string
) {
return Promise.all(
frames.map((frame) =>
getOriginalStackFrame(frame, type, isAppDir, errorMessage)
)
)
}
export function getFrameSource(frame: StackFrame): string {
if (!frame.file) return ''
const isWebpackFrame = isWebpackInternalResource(frame.file)
let str = ''
// Skip URL parsing for webpack internal file paths.
if (isWebpackFrame) {
str = formatFrameSourceFile(frame.file)
} else {
try {
const u = new URL(frame.file)
let parsedPath = ''
// Strip the origin for same-origin scripts.
if (globalThis.location?.origin !== u.origin) {
// URLs can be valid without an `origin`, so long as they have a
// `protocol`. However, `origin` is preferred.
if (u.origin === 'null') {
parsedPath += u.protocol
} else {
parsedPath += u.origin
}
}
// Strip query string information as it's typically too verbose to be
// meaningful.
parsedPath += u.pathname
str = formatFrameSourceFile(parsedPath)
} catch {
str = formatFrameSourceFile(frame.file)
}
}
if (!isWebpackInternalResource(frame.file) && frame.lineNumber != null) {
if (str) {
if (frame.column != null) {
str += ` (${frame.lineNumber}:${frame.column})`
} else {
str += ` (${frame.lineNumber})`
}
}
}
return str
}
import React from 'react'
import isError from '../../../../../../lib/is-error'
const REACT_ERROR_STACK_BOTTOM_FRAME = 'react-stack-bottom-frame'
const REACT_ERROR_STACK_BOTTOM_FRAME_REGEX = new RegExp(
`(at ${REACT_ERROR_STACK_BOTTOM_FRAME} )|(${REACT_ERROR_STACK_BOTTOM_FRAME}\\@)`
)
const captureOwnerStack = (React as any).captureOwnerStack
? (React as any).captureOwnerStack
: () => ''
export function getReactStitchedError<T = unknown>(err: T): Error | T {
if (typeof (React as any).captureOwnerStack !== 'function') {
return err
}
const isErrorInstance = isError(err)
const originStack = isErrorInstance ? err.stack || '' : ''
const originMessage = isErrorInstance ? err.message : ''
const stackLines = originStack.split('\n')
const indexOfSplit = stackLines.findIndex((line) =>
REACT_ERROR_STACK_BOTTOM_FRAME_REGEX.test(line)
)
const isOriginalReactError = indexOfSplit >= 0 // has the react-stack-bottom-frame
let newStack = isOriginalReactError
? stackLines.slice(0, indexOfSplit).join('\n')
: originStack
const newError = new Error(originMessage)
// Copy all enumerable properties, e.g. digest
Object.assign(newError, err)
newError.stack = newStack
// Avoid duplicate overriding stack frames
appendOwnerStack(newError)
return newError
}
function appendOwnerStack(error: Error) {
let stack = error.stack || ''
// Avoid duplicate overriding stack frames
const ownerStack = captureOwnerStack()
if (ownerStack && stack.endsWith(ownerStack) === false) {
stack += ownerStack
// Override stack
error.stack = stack
}
}
import { useEffect } from 'react'
import { attachHydrationErrorState } from './attach-hydration-error-state'
import { isNextRouterError } from '../../../../is-next-router-error'
import { storeHydrationErrorStateFromConsoleArgs } from './hydration-error-info'
import { formatConsoleArgs } from '../../../../../lib/console'
import isError from '../../../../../../lib/is-error'
import { createUnhandledError } from './console-error'
import { enqueueConsecutiveDedupedError } from './enqueue-client-error'
import { getReactStitchedError } from './stitched-error'
const queueMicroTask =
globalThis.queueMicrotask || ((cb: () => void) => Promise.resolve().then(cb))
export type ErrorHandler = (error: Error) => void
const errorQueue: Array<Error> = []
const errorHandlers: Array<ErrorHandler> = []
const rejectionQueue: Array<Error> = []
const rejectionHandlers: Array<ErrorHandler> = []
export function handleClientError(
originError: unknown,
consoleErrorArgs: any[],
capturedFromConsole: boolean = false
) {
let error: Error
if (!originError || !isError(originError)) {
// If it's not an error, format the args into an error
const formattedErrorMessage = formatConsoleArgs(consoleErrorArgs)
error = createUnhandledError(formattedErrorMessage)
} else {
error = capturedFromConsole
? createUnhandledError(originError)
: originError
}
error = getReactStitchedError(error)
storeHydrationErrorStateFromConsoleArgs(...consoleErrorArgs)
attachHydrationErrorState(error)
enqueueConsecutiveDedupedError(errorQueue, error)
for (const handler of errorHandlers) {
// Delayed the error being passed to React Dev Overlay,
// avoid the state being synchronously updated in the component.
queueMicroTask(() => {
handler(error)
})
}
}
export function useErrorHandler(
handleOnUnhandledError: ErrorHandler,
handleOnUnhandledRejection: ErrorHandler
) {
useEffect(() => {
// Handle queued errors.
errorQueue.forEach(handleOnUnhandledError)
rejectionQueue.forEach(handleOnUnhandledRejection)
// Listen to new errors.
errorHandlers.push(handleOnUnhandledError)
rejectionHandlers.push(handleOnUnhandledRejection)
return () => {
// Remove listeners.
errorHandlers.splice(errorHandlers.indexOf(handleOnUnhandledError), 1)
rejectionHandlers.splice(
rejectionHandlers.indexOf(handleOnUnhandledRejection),
1
)
}
}, [handleOnUnhandledError, handleOnUnhandledRejection])
}
function onUnhandledError(event: WindowEventMap['error']): void | boolean {
if (isNextRouterError(event.error)) {
event.preventDefault()
return false
}
handleClientError(event.error, [])
}
function onUnhandledRejection(ev: WindowEventMap['unhandledrejection']): void {
const reason = ev?.reason
if (isNextRouterError(reason)) {
ev.preventDefault()
return
}
let error = reason
if (error && !isError(error)) {
error = createUnhandledError(error + '')
}
rejectionQueue.push(error)
for (const handler of rejectionHandlers) {
handler(error)
}
}
export function handleGlobalErrors() {
if (typeof window !== 'undefined') {
try {
// Increase the number of stack frames on the client
Error.stackTraceLimit = 50
} catch {}
window.addEventListener('error', onUnhandledError)
window.addEventListener('unhandledrejection', onUnhandledRejection)
}
}
import { useCallback } from 'react'
export function useOpenInEditor({
file,
lineNumber,
column,
}: {
file?: string | null
lineNumber?: number | null
column?: number | null
} = {}) {
const openInEditor = useCallback(() => {
if (file == null || lineNumber == null || column == null) return
const params = new URLSearchParams()
params.append('file', file)
params.append('lineNumber', String(lineNumber))
params.append('column', String(column))
self
.fetch(
`${
process.env.__NEXT_ROUTER_BASEPATH || ''
}/__nextjs_launch-editor?${params.toString()}`
)
.then(
() => {},
() => {
console.error('There was an issue opening this code in your editor.')
}
)
}, [file, lineNumber, column])
return openInEditor
}
import { useCallback, useContext, useEffect, useRef } from 'react'
import { GlobalLayoutRouterContext } from '../../../../../../shared/lib/app-router-context.shared-runtime'
import { getSocketUrl } from './get-socket-url'
import type { TurbopackMsgToBrowser } from '../../../../../../server/dev/hot-reloader-types'
export function useWebsocket(assetPrefix: string) {
const webSocketRef = useRef<WebSocket>(undefined)
useEffect(() => {
if (webSocketRef.current) {
return
}
const url = getSocketUrl(assetPrefix)
webSocketRef.current = new window.WebSocket(`${url}/_next/webpack-hmr`)
}, [assetPrefix])
return webSocketRef
}
export function useSendMessage(webSocketRef: ReturnType<typeof useWebsocket>) {
const sendMessage = useCallback(
(data: string) => {
const socket = webSocketRef.current
if (!socket || socket.readyState !== socket.OPEN) {
return
}
return socket.send(data)
},
[webSocketRef]
)
return sendMessage
}
export function useTurbopack(
sendMessage: ReturnType<typeof useSendMessage>,
onUpdateError: (err: unknown) => void
) {
const turbopackState = useRef<{
init: boolean
queue: Array<TurbopackMsgToBrowser> | undefined
callback: ((msg: TurbopackMsgToBrowser) => void) | undefined
}>({
init: false,
// Until the dynamic import resolves, queue any turbopack messages which will be replayed.
queue: [],
callback: undefined,
})
const processTurbopackMessage = useCallback((msg: TurbopackMsgToBrowser) => {
const { callback, queue } = turbopackState.current
if (callback) {
callback(msg)
} else {
queue!.push(msg)
}
}, [])
useEffect(() => {
const { current: initCurrent } = turbopackState
// TODO(WEB-1589): only install if `process.turbopack` set.
if (initCurrent.init) {
return
}
initCurrent.init = true
import(
// @ts-expect-error requires "moduleResolution": "node16" in tsconfig.json and not .ts extension
'@vercel/turbopack-ecmascript-runtime/browser/dev/hmr-client/hmr-client.ts'
).then(({ connect }) => {
const { current } = turbopackState
connect({
addMessageListener(cb: (msg: TurbopackMsgToBrowser) => void) {
current.callback = cb
// Replay all Turbopack messages before we were able to establish the HMR client.
for (const msg of current.queue!) {
cb(msg)
}
current.queue = undefined
},
sendMessage,
onUpdateError,
})
})
}, [sendMessage, onUpdateError])
return processTurbopackMessage
}
export function useWebsocketPing(
websocketRef: ReturnType<typeof useWebsocket>
) {
const sendMessage = useSendMessage(websocketRef)
const { tree } = useContext(GlobalLayoutRouterContext)
useEffect(() => {
// Taken from on-demand-entries-client.js
const interval = setInterval(() => {
sendMessage(
JSON.stringify({
event: 'ping',
tree,
appDirRoute: true,
})
)
}, 2500)
return () => clearInterval(interval)
}, [tree, sendMessage])
}
import {
formatFrameSourceFile,
isWebpackInternalResource,
} from './webpack-module-path'
describe('webpack-module-path', () => {
describe('isWebpackInternalResource', () => {
it('should return true for webpack-internal paths', () => {
expect(
isWebpackInternalResource('webpack-internal:///./src/hello.tsx')
).toBe(true)
expect(
isWebpackInternalResource(
'rsc://React/Server/webpack-internal:///(rsc)/./src/hello.tsx?42'
)
).toBe(true)
expect(
isWebpackInternalResource(
'rsc://React/Server/webpack:///(rsc)/./src/hello.tsx?42'
)
).toBe(true)
expect(
isWebpackInternalResource(
'rsc://React/Server/webpack:///(app-pages-browser)/./src/hello.tsx?42'
)
).toBe(true)
expect(
isWebpackInternalResource(
'rsc://React/Server/webpack:///(app-pages-browser)/./src/hello.tsx?42dc'
)
).toBe(true)
expect(isWebpackInternalResource('webpack://_N_E/./src/hello.tsx')).toBe(
true
)
expect(isWebpackInternalResource('webpack://./src/hello.tsx')).toBe(true)
expect(isWebpackInternalResource('webpack:///./src/hello.tsx')).toBe(true)
})
it('should return false for non-webpack-internal paths', () => {
expect(isWebpackInternalResource('<anonymous>')).toBe(false)
expect(isWebpackInternalResource('file:///src/hello.tsx')).toBe(false)
})
})
describe('formatFrameSourceFile', () => {
it('should return the original file path', () => {
expect(formatFrameSourceFile('webpack-internal:///./src/hello.tsx')).toBe(
'./src/hello.tsx'
)
expect(
formatFrameSourceFile(
'rsc://React/Server/webpack-internal:///(rsc)/./src/hello.tsx?42'
)
).toBe('./src/hello.tsx')
expect(
formatFrameSourceFile(
'rsc://React/Server/webpack:///(rsc)/./src/hello.tsx?42'
)
).toBe('./src/hello.tsx')
expect(
formatFrameSourceFile(
'rsc://React/Server/webpack:///(app-pages-browser)/./src/hello.tsx?42'
)
).toBe('./src/hello.tsx')
expect(
formatFrameSourceFile(
'rsc://React/Server/webpack:///(app-pages-browser)/./src/hello.tsx?42?0'
)
).toBe('./src/hello.tsx')
expect(
formatFrameSourceFile(
'rsc://React/Server/webpack:///(app-pages-browser)/./src/hello.tsx?42dc'
)
).toBe('./src/hello.tsx')
expect(formatFrameSourceFile('webpack://_N_E/./src/hello.tsx')).toBe(
'./src/hello.tsx'
)
expect(formatFrameSourceFile('webpack://./src/hello.tsx')).toBe(
'./src/hello.tsx'
)
expect(formatFrameSourceFile('webpack:///./src/hello.tsx')).toBe(
'./src/hello.tsx'
)
})
})
})
const replacementRegExes = [
/^(rsc:\/\/React\/[^/]+\/)/,
/^webpack-internal:\/\/\/(\([\w-]+\)\/)?/,
/^(webpack:\/\/\/|webpack:\/\/(_N_E\/)?)(\([\w-]+\)\/)?/,
/\?\w+(\?\d+)?$/, // React replay error query param, .e.g. ?c69d?0, ?c69d
/\?\d+$/, // React's fakeFunctionIdx query param
]
export function isWebpackInternalResource(file: string) {
for (const regex of replacementRegExes) {
if (regex.test(file)) return true
file = file.replace(regex, '')
}
return false
}
/**
* Format the webpack internal id to original file path
*
* webpack-internal:///./src/hello.tsx => ./src/hello.tsx
* rsc://React/Server/webpack-internal:///(rsc)/./src/hello.tsx?42 => ./src/hello.tsx
* rsc://React/Server/webpack:///app/indirection.tsx?14cb?0 => app/indirection.tsx
* webpack://_N_E/./src/hello.tsx => ./src/hello.tsx
* webpack://./src/hello.tsx => ./src/hello.tsx
* webpack:///./src/hello.tsx => ./src/hello.tsx
*/
export function formatFrameSourceFile(file: string) {
for (const regex of replacementRegExes) {
file = file.replace(regex, '')
}
return file
}
import * as React from 'react'
const CloseIcon = () => {
return (
<svg
width="24"
height="24"
viewBox="0 0 24 24"
fill="none"
xmlns="http://www.w3.org/2000/svg"
>
<path
d="M18 6L6 18"
stroke="currentColor"
strokeWidth="2"
strokeLinecap="round"
strokeLinejoin="round"
/>
<path
d="M6 6L18 18"
stroke="currentColor"
strokeWidth="2"
strokeLinecap="round"
strokeLinejoin="round"
/>
</svg>
)
}
export { CloseIcon }
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