File size: 4,507 Bytes
1e92f2d |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 |
'use client'
import React, { type JSX } from 'react'
import { useUntrackedPathname } from './navigation-untracked'
import { isNextRouterError } from './is-next-router-error'
import { handleHardNavError } from './nav-failure-handler'
import { HandleISRError } from './handle-isr-error'
export type ErrorComponent = React.ComponentType<{
error: Error
// global-error, there's no `reset` function;
// regular error boundary, there's a `reset` function.
reset?: () => void
}>
export interface ErrorBoundaryProps {
children?: React.ReactNode
errorComponent: ErrorComponent | undefined
errorStyles?: React.ReactNode | undefined
errorScripts?: React.ReactNode | undefined
}
interface ErrorBoundaryHandlerProps extends ErrorBoundaryProps {
pathname: string | null
errorComponent: ErrorComponent
}
interface ErrorBoundaryHandlerState {
error: Error | null
previousPathname: string | null
}
export class ErrorBoundaryHandler extends React.Component<
ErrorBoundaryHandlerProps,
ErrorBoundaryHandlerState
> {
constructor(props: ErrorBoundaryHandlerProps) {
super(props)
this.state = { error: null, previousPathname: this.props.pathname }
}
static getDerivedStateFromError(error: Error) {
if (isNextRouterError(error)) {
// Re-throw if an expected internal Next.js router error occurs
// this means it should be handled by a different boundary (such as a NotFound boundary in a parent segment)
throw error
}
return { error }
}
static getDerivedStateFromProps(
props: ErrorBoundaryHandlerProps,
state: ErrorBoundaryHandlerState
): ErrorBoundaryHandlerState | null {
const { error } = state
// if we encounter an error while
// a navigation is pending we shouldn't render
// the error boundary and instead should fallback
// to a hard navigation to attempt recovering
if (process.env.__NEXT_APP_NAV_FAIL_HANDLING) {
if (error && handleHardNavError(error)) {
// clear error so we don't render anything
return {
error: null,
previousPathname: props.pathname,
}
}
}
/**
* Handles reset of the error boundary when a navigation happens.
* Ensures the error boundary does not stay enabled when navigating to a new page.
* Approach of setState in render is safe as it checks the previous pathname and then overrides
* it as outlined in https://react.dev/reference/react/useState#storing-information-from-previous-renders
*/
if (props.pathname !== state.previousPathname && state.error) {
return {
error: null,
previousPathname: props.pathname,
}
}
return {
error: state.error,
previousPathname: props.pathname,
}
}
reset = () => {
this.setState({ error: null })
}
// Explicit type is needed to avoid the generated `.d.ts` having a wide return type that could be specific to the `@types/react` version.
render(): React.ReactNode {
if (this.state.error) {
return (
<>
<HandleISRError error={this.state.error} />
{this.props.errorStyles}
{this.props.errorScripts}
<this.props.errorComponent
error={this.state.error}
reset={this.reset}
/>
</>
)
}
return this.props.children
}
}
/**
* Handles errors through `getDerivedStateFromError`.
* Renders the provided error component and provides a way to `reset` the error boundary state.
*/
/**
* Renders error boundary with the provided "errorComponent" property as the fallback.
* If no "errorComponent" property is provided it renders the children without an error boundary.
*/
export function ErrorBoundary({
errorComponent,
errorStyles,
errorScripts,
children,
}: ErrorBoundaryProps & {
children: React.ReactNode
}): JSX.Element {
// When we're rendering the missing params shell, this will return null. This
// is because we won't be rendering any not found boundaries or error
// boundaries for the missing params shell. When this runs on the client
// (where these errors can occur), we will get the correct pathname.
const pathname = useUntrackedPathname()
if (errorComponent) {
return (
<ErrorBoundaryHandler
pathname={pathname}
errorComponent={errorComponent}
errorStyles={errorStyles}
errorScripts={errorScripts}
>
{children}
</ErrorBoundaryHandler>
)
}
return <>{children}</>
}
|