111 lines
4.6 KiB
JavaScript
111 lines
4.6 KiB
JavaScript
'use client';
|
|
import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
|
|
import React 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';
|
|
import { isBot } from '../../shared/lib/router/utils/is-bot';
|
|
const isBotUserAgent = typeof window !== 'undefined' && isBot(window.navigator.userAgent);
|
|
export class ErrorBoundaryHandler extends React.Component {
|
|
constructor(props){
|
|
super(props), this.reset = ()=>{
|
|
this.setState({
|
|
error: null
|
|
});
|
|
};
|
|
this.state = {
|
|
error: null,
|
|
previousPathname: this.props.pathname
|
|
};
|
|
}
|
|
static getDerivedStateFromError(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, state) {
|
|
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
|
|
};
|
|
}
|
|
// 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() {
|
|
//When it's bot request, segment level error boundary will keep rendering the children,
|
|
// the final error will be caught by the root error boundary and determine wether need to apply graceful degrade.
|
|
if (this.state.error && !isBotUserAgent) {
|
|
return /*#__PURE__*/ _jsxs(_Fragment, {
|
|
children: [
|
|
/*#__PURE__*/ _jsx(HandleISRError, {
|
|
error: this.state.error
|
|
}),
|
|
this.props.errorStyles,
|
|
this.props.errorScripts,
|
|
/*#__PURE__*/ _jsx(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 }) {
|
|
// 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 /*#__PURE__*/ _jsx(ErrorBoundaryHandler, {
|
|
pathname: pathname,
|
|
errorComponent: errorComponent,
|
|
errorStyles: errorStyles,
|
|
errorScripts: errorScripts,
|
|
children: children
|
|
});
|
|
}
|
|
return /*#__PURE__*/ _jsx(_Fragment, {
|
|
children: children
|
|
});
|
|
}
|
|
|
|
//# sourceMappingURL=error-boundary.js.map
|