@qzsy/vinext 0.1.7

package/dist/shims/error-boundary.d.ts

@@ -0,0 +1,155 @@
+import React from "react";
+
+//#region src/shims/error-boundary.d.ts
+type ErrorBoundaryProps = {
+  fallback: React.ComponentType<{
+    error: unknown;
+    reset: () => void;
+  }>;
+  children: React.ReactNode;
+  resetKey?: string | null;
+};
+type CapturedError = {
+  thrownValue: unknown;
+};
+type RedirectBoundaryState = {
+  redirect: string | null;
+  redirectType: "push" | "replace" | null;
+};
+type ErrorBoundaryInnerProps = {
+  isImplicitRootErrorBoundary?: boolean;
+  pathname: string | null;
+} & ErrorBoundaryProps;
+type ErrorBoundaryState = {
+  error: CapturedError | null;
+  previousPathname: string | null;
+  previousResetKey: string | null;
+};
+declare class RedirectErrorBoundary extends React.Component<{
+  children?: React.ReactNode;
+}, RedirectBoundaryState> {
+  constructor(props: {
+    children?: React.ReactNode;
+  });
+  static getDerivedStateFromError(error: unknown): RedirectBoundaryState;
+  render(): string | number | bigint | boolean | Iterable<React.ReactNode> | Promise<string | number | bigint | boolean | React.ReactPortal | React.ReactElement<unknown, string | React.JSXElementConstructor<any>> | Iterable<React.ReactNode> | null | undefined> | React.JSX.Element | null | undefined;
+}
+declare function RedirectBoundary({
+  children
+}: {
+  children?: React.ReactNode;
+}): React.JSX.Element;
+/**
+ * Generic ErrorBoundary used to wrap route segments with error.tsx.
+ * This must be a client component since error boundaries use
+ * componentDidCatch / getDerivedStateFromError.
+ */
+declare class ErrorBoundaryInner extends React.Component<ErrorBoundaryInnerProps, ErrorBoundaryState> {
+  constructor(props: ErrorBoundaryInnerProps);
+  static getDerivedStateFromProps(props: ErrorBoundaryInnerProps, state: ErrorBoundaryState): ErrorBoundaryState | null;
+  static getDerivedStateFromError(error: unknown): Partial<ErrorBoundaryState>;
+  handleDevErrorRecovery: () => void;
+  componentDidMount(): void;
+  componentWillUnmount(): void;
+  reset: () => void;
+  render(): string | number | bigint | boolean | Iterable<React.ReactNode> | Promise<string | number | bigint | boolean | React.ReactPortal | React.ReactElement<unknown, string | React.JSXElementConstructor<any>> | Iterable<React.ReactNode> | null | undefined> | React.JSX.Element | null | undefined;
+}
+declare function ErrorBoundary({
+  fallback,
+  children,
+  resetKey
+}: ErrorBoundaryProps): React.JSX.Element;
+declare function GlobalErrorBoundary({
+  fallback,
+  children
+}: {
+  fallback: React.ComponentType<{
+    error: unknown;
+    reset: () => void;
+  }>;
+  children: React.ReactNode;
+}): React.JSX.Element;
+type NotFoundBoundaryProps = {
+  fallback: React.ReactNode;
+  children: React.ReactNode;
+  resetKey?: string | null;
+};
+/**
+ * Wrapper that reads the current pathname and passes it to the inner class
+ * component. Segment reset keys own App Router remount semantics when present.
+ */
+declare function NotFoundBoundary({
+  fallback,
+  children,
+  resetKey
+}: NotFoundBoundaryProps): React.JSX.Element;
+type ForbiddenBoundaryProps = {
+  fallback: React.ReactNode;
+  children: React.ReactNode;
+  resetKey?: string | null;
+};
+type ForbiddenBoundaryInnerProps = {
+  pathname: string | null;
+} & ForbiddenBoundaryProps;
+type ForbiddenBoundaryState = {
+  forbidden: boolean;
+  previousPathname: string | null;
+  previousResetKey: string | null;
+};
+declare class ForbiddenBoundaryInner extends React.Component<ForbiddenBoundaryInnerProps, ForbiddenBoundaryState> {
+  constructor(props: ForbiddenBoundaryInnerProps);
+  static getDerivedStateFromProps(props: ForbiddenBoundaryInnerProps, state: ForbiddenBoundaryState): ForbiddenBoundaryState | null;
+  static getDerivedStateFromError(error: unknown): Partial<ForbiddenBoundaryState>;
+  render(): string | number | bigint | boolean | Iterable<React.ReactNode> | Promise<string | number | bigint | boolean | React.ReactPortal | React.ReactElement<unknown, string | React.JSXElementConstructor<any>> | Iterable<React.ReactNode> | null | undefined> | React.JSX.Element | null | undefined;
+}
+declare function ForbiddenBoundary({
+  fallback,
+  children,
+  resetKey
+}: ForbiddenBoundaryProps): React.JSX.Element;
+type UnauthorizedBoundaryProps = {
+  fallback: React.ReactNode;
+  children: React.ReactNode;
+  resetKey?: string | null;
+};
+type UnauthorizedBoundaryInnerProps = {
+  pathname: string | null;
+} & UnauthorizedBoundaryProps;
+type UnauthorizedBoundaryState = {
+  unauthorized: boolean;
+  previousPathname: string | null;
+  previousResetKey: string | null;
+};
+declare class UnauthorizedBoundaryInner extends React.Component<UnauthorizedBoundaryInnerProps, UnauthorizedBoundaryState> {
+  constructor(props: UnauthorizedBoundaryInnerProps);
+  static getDerivedStateFromProps(props: UnauthorizedBoundaryInnerProps, state: UnauthorizedBoundaryState): UnauthorizedBoundaryState | null;
+  static getDerivedStateFromError(error: unknown): Partial<UnauthorizedBoundaryState>;
+  render(): string | number | bigint | boolean | Iterable<React.ReactNode> | Promise<string | number | bigint | boolean | React.ReactPortal | React.ReactElement<unknown, string | React.JSXElementConstructor<any>> | Iterable<React.ReactNode> | null | undefined> | React.JSX.Element | null | undefined;
+}
+declare function UnauthorizedBoundary({
+  fallback,
+  children,
+  resetKey
+}: UnauthorizedBoundaryProps): React.JSX.Element;
+type DevRecoveryBoundaryProps = {
+  isImplicitRootErrorBoundary?: boolean;
+  resetKey: number;
+  onCatch?: (resetKey: number) => void;
+  children?: React.ReactNode;
+};
+type DevRecoveryBoundaryState = {
+  error: CapturedError | null;
+  previousResetKey: number;
+};
+declare class DevRecoveryBoundary extends React.Component<DevRecoveryBoundaryProps, DevRecoveryBoundaryState> {
+  constructor(props: DevRecoveryBoundaryProps);
+  static getDerivedStateFromProps(props: DevRecoveryBoundaryProps, state: DevRecoveryBoundaryState): DevRecoveryBoundaryState | null;
+  static getDerivedStateFromError(error: unknown): Partial<DevRecoveryBoundaryState>;
+  handleDevErrorRecovery: () => void;
+  componentDidMount(): void;
+  componentWillUnmount(): void;
+  componentDidCatch(): void;
+  render(): React.ReactNode;
+}
+//#endregion
+export { DevRecoveryBoundary, DevRecoveryBoundaryProps, ErrorBoundary, ErrorBoundaryInner, ErrorBoundaryProps, ErrorBoundaryState, ForbiddenBoundary, ForbiddenBoundaryInner, GlobalErrorBoundary, NotFoundBoundary, RedirectBoundary, RedirectErrorBoundary, UnauthorizedBoundary, UnauthorizedBoundaryInner };

package/dist/shims/error-boundary.js

@@ -0,0 +1,342 @@
+"use client";
+import { decodeRedirectError, isRedirectError } from "./navigation-errors.js";
+import "./navigation-server.js";
+import { useErrorBoundaryPathname, useErrorBoundaryRouter } from "./error-boundary-navigation.js";
+import DefaultGlobalError from "./default-global-error.js";
+import { handleAppNavigationFailure } from "../client/app-nav-failure-handler.js";
+import { VINEXT_DEV_ERROR_RECOVERY_EVENT } from "../utils/dev-error-recovery-event.js";
+import { isNavigationSignalError } from "../utils/navigation-signal.js";
+import React from "react";
+import { Fragment as Fragment$1, jsx, jsxs } from "react/jsx-runtime";
+//#region src/shims/error-boundary.tsx
+function normalizeBoundaryResetKey(resetKey) {
+	return resetKey === void 0 || resetKey === null || resetKey === "" ? null : resetKey;
+}
+function readBoundaryResetState(props) {
+	return {
+		previousPathname: props.pathname,
+		previousResetKey: normalizeBoundaryResetKey(props.resetKey)
+	};
+}
+function shouldResetBoundary(nextResetState, previousResetState) {
+	const nextResetKey = normalizeBoundaryResetKey(nextResetState.previousResetKey);
+	const previousResetKey = normalizeBoundaryResetKey(previousResetState.previousResetKey);
+	if (nextResetKey !== null || previousResetKey !== null) return nextResetKey !== previousResetKey;
+	return nextResetState.previousPathname !== previousResetState.previousPathname;
+}
+function addDevErrorRecoveryListener(listener) {
+	if (typeof window === "undefined") return;
+	window.addEventListener(VINEXT_DEV_ERROR_RECOVERY_EVENT, listener);
+}
+function removeDevErrorRecoveryListener(listener) {
+	if (typeof window === "undefined") return;
+	window.removeEventListener(VINEXT_DEV_ERROR_RECOVERY_EVENT, listener);
+}
+function HandleRedirect({ redirect, redirectType, reset }) {
+	const router = useErrorBoundaryRouter();
+	React.useEffect(() => {
+		React.startTransition(() => {
+			if (redirectType === "push") router.push(redirect);
+			else router.replace(redirect);
+			reset();
+		});
+	}, [
+		redirect,
+		redirectType,
+		reset,
+		router
+	]);
+	return null;
+}
+var RedirectErrorBoundary = class extends React.Component {
+	constructor(props) {
+		super(props);
+		this.state = {
+			redirect: null,
+			redirectType: null
+		};
+	}
+	static getDerivedStateFromError(error) {
+		if (isRedirectError(error)) {
+			if ("handled" in error && error.handled) return {
+				redirect: null,
+				redirectType: null
+			};
+			const result = decodeRedirectError(error.digest);
+			if (!result) throw error;
+			return {
+				redirect: result.url,
+				redirectType: result.type
+			};
+		}
+		throw error;
+	}
+	render() {
+		const { redirect, redirectType } = this.state;
+		if (redirect !== null && redirectType !== null) return /* @__PURE__ */ jsx(HandleRedirect, {
+			redirect,
+			redirectType,
+			reset: () => this.setState({
+				redirect: null,
+				redirectType: null
+			})
+		});
+		return this.props.children;
+	}
+};
+function RedirectBoundary({ children }) {
+	return /* @__PURE__ */ jsx(RedirectErrorBoundary, { children });
+}
+/**
+* Generic ErrorBoundary used to wrap route segments with error.tsx.
+* This must be a client component since error boundaries use
+* componentDidCatch / getDerivedStateFromError.
+*/
+var ErrorBoundaryInner = class extends React.Component {
+	constructor(props) {
+		super(props);
+		this.state = {
+			error: null,
+			...readBoundaryResetState(props)
+		};
+	}
+	static getDerivedStateFromProps(props, state) {
+		const nextResetState = readBoundaryResetState(props);
+		if (state.error && handleAppNavigationFailure(state.error.thrownValue)) return {
+			error: null,
+			...nextResetState
+		};
+		if (state.error && shouldResetBoundary(nextResetState, state)) return {
+			error: null,
+			...nextResetState
+		};
+		return {
+			error: state.error,
+			...nextResetState
+		};
+	}
+	static getDerivedStateFromError(error) {
+		if (isNavigationSignalError(error)) throw error;
+		return { error: { thrownValue: error } };
+	}
+	handleDevErrorRecovery = () => {
+		if (!this.state.error) return;
+		this.setState({
+			error: null,
+			...readBoundaryResetState(this.props)
+		});
+	};
+	componentDidMount() {
+		addDevErrorRecoveryListener(this.handleDevErrorRecovery);
+	}
+	componentWillUnmount() {
+		removeDevErrorRecoveryListener(this.handleDevErrorRecovery);
+	}
+	reset = () => {
+		this.setState({ error: null });
+	};
+	render() {
+		if (this.state.error) {
+			const FallbackComponent = this.props.fallback;
+			return /* @__PURE__ */ jsx(FallbackComponent, {
+				error: this.state.error.thrownValue,
+				reset: this.reset
+			});
+		}
+		return this.props.children;
+	}
+};
+function ErrorBoundary({ fallback, children, resetKey }) {
+	return /* @__PURE__ */ jsx(ErrorBoundaryInner, {
+		pathname: useErrorBoundaryPathname(),
+		resetKey,
+		fallback,
+		children
+	});
+}
+function GlobalErrorBoundary({ fallback, children }) {
+	return /* @__PURE__ */ jsx(ErrorBoundaryInner, {
+		pathname: useErrorBoundaryPathname(),
+		fallback,
+		isImplicitRootErrorBoundary: fallback === DefaultGlobalError,
+		children
+	});
+}
+/**
+* Inner class component that catches notFound() errors and renders the
+* not-found.tsx fallback. Resets on the caller's segment reset key when one is
+* provided, otherwise falls back to pathname changes for legacy callers.
+*
+* The ErrorBoundary above re-throws notFound errors so they propagate up to this
+* boundary. This must be placed above the ErrorBoundary in the component tree.
+*/
+var NotFoundBoundaryInner = class extends React.Component {
+	constructor(props) {
+		super(props);
+		this.state = {
+			notFound: false,
+			...readBoundaryResetState(props)
+		};
+	}
+	static getDerivedStateFromProps(props, state) {
+		const nextResetState = readBoundaryResetState(props);
+		if (state.notFound && shouldResetBoundary(nextResetState, state)) return {
+			notFound: false,
+			...nextResetState
+		};
+		return {
+			notFound: state.notFound,
+			...nextResetState
+		};
+	}
+	static getDerivedStateFromError(error) {
+		if (error && typeof error === "object" && "digest" in error) {
+			const digest = String(error.digest);
+			if (digest === "NEXT_NOT_FOUND" || digest === "NEXT_HTTP_ERROR_FALLBACK;404") return { notFound: true };
+		}
+		throw error;
+	}
+	render() {
+		if (this.state.notFound) return /* @__PURE__ */ jsxs(Fragment$1, { children: [/* @__PURE__ */ jsx("meta", {
+			name: "robots",
+			content: "noindex"
+		}), this.props.fallback] });
+		return this.props.children;
+	}
+};
+/**
+* Wrapper that reads the current pathname and passes it to the inner class
+* component. Segment reset keys own App Router remount semantics when present.
+*/
+function NotFoundBoundary({ fallback, children, resetKey }) {
+	return /* @__PURE__ */ jsx(NotFoundBoundaryInner, {
+		pathname: useErrorBoundaryPathname(),
+		resetKey,
+		fallback,
+		children
+	});
+}
+var ForbiddenBoundaryInner = class extends React.Component {
+	constructor(props) {
+		super(props);
+		this.state = {
+			forbidden: false,
+			...readBoundaryResetState(props)
+		};
+	}
+	static getDerivedStateFromProps(props, state) {
+		const nextResetState = readBoundaryResetState(props);
+		if (state.forbidden && shouldResetBoundary(nextResetState, state)) return {
+			forbidden: false,
+			...nextResetState
+		};
+		return {
+			forbidden: state.forbidden,
+			...nextResetState
+		};
+	}
+	static getDerivedStateFromError(error) {
+		if (error && typeof error === "object" && "digest" in error) {
+			if (String(error.digest) === "NEXT_HTTP_ERROR_FALLBACK;403") return { forbidden: true };
+		}
+		throw error;
+	}
+	render() {
+		if (this.state.forbidden) return /* @__PURE__ */ jsxs(Fragment$1, { children: [/* @__PURE__ */ jsx("meta", {
+			name: "robots",
+			content: "noindex"
+		}), this.props.fallback] });
+		return this.props.children;
+	}
+};
+function ForbiddenBoundary({ fallback, children, resetKey }) {
+	return /* @__PURE__ */ jsx(ForbiddenBoundaryInner, {
+		pathname: useErrorBoundaryPathname(),
+		resetKey,
+		fallback,
+		children
+	});
+}
+var UnauthorizedBoundaryInner = class extends React.Component {
+	constructor(props) {
+		super(props);
+		this.state = {
+			unauthorized: false,
+			...readBoundaryResetState(props)
+		};
+	}
+	static getDerivedStateFromProps(props, state) {
+		const nextResetState = readBoundaryResetState(props);
+		if (state.unauthorized && shouldResetBoundary(nextResetState, state)) return {
+			unauthorized: false,
+			...nextResetState
+		};
+		return {
+			unauthorized: state.unauthorized,
+			...nextResetState
+		};
+	}
+	static getDerivedStateFromError(error) {
+		if (error && typeof error === "object" && "digest" in error) {
+			if (String(error.digest) === "NEXT_HTTP_ERROR_FALLBACK;401") return { unauthorized: true };
+		}
+		throw error;
+	}
+	render() {
+		if (this.state.unauthorized) return /* @__PURE__ */ jsxs(Fragment$1, { children: [/* @__PURE__ */ jsx("meta", {
+			name: "robots",
+			content: "noindex"
+		}), this.props.fallback] });
+		return this.props.children;
+	}
+};
+function UnauthorizedBoundary({ fallback, children, resetKey }) {
+	return /* @__PURE__ */ jsx(UnauthorizedBoundaryInner, {
+		pathname: useErrorBoundaryPathname(),
+		resetKey,
+		fallback,
+		children
+	});
+}
+var DevRecoveryBoundary = class extends React.Component {
+	constructor(props) {
+		super(props);
+		this.state = {
+			error: null,
+			previousResetKey: props.resetKey
+		};
+	}
+	static getDerivedStateFromProps(props, state) {
+		if (props.resetKey === state.previousResetKey) return null;
+		return {
+			error: null,
+			previousResetKey: props.resetKey
+		};
+	}
+	static getDerivedStateFromError(error) {
+		if (isNavigationSignalError(error)) throw error;
+		return { error: { thrownValue: error } };
+	}
+	handleDevErrorRecovery = () => {
+		if (!this.state.error) return;
+		this.setState({
+			error: null,
+			previousResetKey: this.props.resetKey
+		});
+	};
+	componentDidMount() {
+		addDevErrorRecoveryListener(this.handleDevErrorRecovery);
+	}
+	componentWillUnmount() {
+		removeDevErrorRecoveryListener(this.handleDevErrorRecovery);
+	}
+	componentDidCatch() {
+		this.props.onCatch?.(this.props.resetKey);
+	}
+	render() {
+		if (this.state.error) return null;
+		return this.props.children;
+	}
+};
+//#endregion
+export { DevRecoveryBoundary, ErrorBoundary, ErrorBoundaryInner, ForbiddenBoundary, ForbiddenBoundaryInner, GlobalErrorBoundary, NotFoundBoundary, RedirectBoundary, RedirectErrorBoundary, UnauthorizedBoundary, UnauthorizedBoundaryInner };

package/dist/shims/error.d.ts

@@ -0,0 +1,31 @@
+import React from "react";
+
+//#region src/shims/error.d.ts
+type ErrorProps = {
+  statusCode: number;
+  title?: string;
+  withDarkMode?: boolean;
+};
+declare function ErrorComponent({
+  statusCode,
+  title
+}: ErrorProps): React.ReactElement;
+type ErrorInfo = {
+  error: unknown;
+  reset: () => void;
+  unstable_retry: () => void;
+};
+type _UserProps = Record<string, unknown>;
+/**
+ * Wrap a fallback render function in a Component-level error boundary.
+ * Returns a Component that renders `children` and, on error, renders the
+ * supplied fallback with an `ErrorInfo` value.
+ *
+ * Ported from Next.js:
+ *   https://github.com/vercel/next.js/blob/canary/packages/next/src/client/components/catch-error.tsx
+ */
+declare function unstable_catchError<P extends _UserProps>(fallback: (props: P, errorInfo: ErrorInfo) => React.ReactNode): React.ComponentType<P & {
+  children?: React.ReactNode;
+}>;
+//#endregion
+export { ErrorInfo, ErrorComponent as default, unstable_catchError };

package/dist/shims/error.js

@@ -0,0 +1,123 @@
+import { AppRouterContext } from "./internal/app-router-context.js";
+import { RouterContext } from "./internal/router-context.js";
+import { isNextRouterError } from "./navigation-errors.js";
+import "./navigation.js";
+import { useUntrackedPathname } from "./internal/navigation-untracked.js";
+import React from "react";
+//#region src/shims/error.tsx
+/**
+* next/error shim
+*
+* Provides the default Next.js error page component.
+* Used by apps that import `import Error from 'next/error'` for
+* custom error handling in getServerSideProps or API routes.
+*
+* Also re-exports the unstable App Router error-boundary HOC
+* (`unstable_catchError`) and its `ErrorInfo` type, mirroring
+* `next/error`'s public surface.
+*/
+function ErrorComponent({ statusCode, title }) {
+	const displayTitle = title ?? (statusCode === 404 ? "This page could not be found" : "Internal Server Error");
+	return React.createElement("div", { style: {
+		fontFamily: "-apple-system, BlinkMacSystemFont, \"Segoe UI\", Roboto, \"Helvetica Neue\", Arial, sans-serif",
+		height: "100vh",
+		textAlign: "center",
+		display: "flex",
+		flexDirection: "column",
+		alignItems: "center",
+		justifyContent: "center"
+	} }, React.createElement("div", null, React.createElement("h1", { style: {
+		display: "inline-block",
+		margin: "0 20px 0 0",
+		padding: "0 23px 0 0",
+		fontSize: 24,
+		fontWeight: 500,
+		verticalAlign: "top",
+		lineHeight: "49px",
+		borderRight: "1px solid rgba(0, 0, 0, .3)"
+	} }, statusCode), React.createElement("div", { style: { display: "inline-block" } }, React.createElement("h2", { style: {
+		fontSize: 14,
+		fontWeight: 400,
+		lineHeight: "49px",
+		margin: 0
+	} }, displayTitle + "."))));
+}
+const _CatchErrorAppRouterContext = AppRouterContext ?? React.createContext(null);
+var _CatchError = class extends React.Component {
+	static contextType = _CatchErrorAppRouterContext;
+	static displayName = "unstable_catchError(Next.CatchError)";
+	constructor(props) {
+		super(props);
+		this.state = {
+			error: null,
+			previousPathname: props.pathname
+		};
+	}
+	static getDerivedStateFromError(thrownValue) {
+		if (isNextRouterError(thrownValue)) throw thrownValue;
+		return { error: { thrownValue } };
+	}
+	static getDerivedStateFromProps(props, state) {
+		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 });
+	};
+	unstable_retry = () => {
+		if (this.props.isPagesRouter) throw new Error("`unstable_retry()` can only be used in the App Router. Use `reset()` in the Pages Router.");
+		React.startTransition(() => {
+			this.context?.refresh();
+			this.reset();
+		});
+	};
+	render() {
+		if (this.state.error) {
+			const Fallback = this.props.fallback;
+			const errorInfo = {
+				error: this.state.error.thrownValue,
+				reset: this.reset,
+				unstable_retry: this.unstable_retry
+			};
+			return React.createElement(Fallback, {
+				props: this.props.props,
+				errorInfo
+			});
+		}
+		return this.props.children;
+	}
+};
+/**
+* Wrap a fallback render function in a Component-level error boundary.
+* Returns a Component that renders `children` and, on error, renders the
+* supplied fallback with an `ErrorInfo` value.
+*
+* Ported from Next.js:
+*   https://github.com/vercel/next.js/blob/canary/packages/next/src/client/components/catch-error.tsx
+*/
+function unstable_catchError(fallback) {
+	const Fallback = ({ props, errorInfo }) => fallback(props, errorInfo);
+	Fallback.displayName = fallback.name || "CatchErrorFallback";
+	function CatchErrorBoundary(allProps) {
+		const { children, ...rest } = allProps;
+		const pathname = useUntrackedPathname();
+		const isPagesRouter = React.useContext(RouterContext) !== null;
+		const forwardedProps = rest;
+		return React.createElement(_CatchError, {
+			fallback: Fallback,
+			isPagesRouter,
+			pathname,
+			props: forwardedProps
+		}, children);
+	}
+	CatchErrorBoundary.displayName = `unstable_catchError(${fallback.name || "CatchErrorFallback"})`;
+	return CatchErrorBoundary;
+}
+//#endregion
+export { ErrorComponent as default, unstable_catchError };

package/dist/shims/error.react-server.d.ts

@@ -0,0 +1,9 @@
+//#region src/shims/error.react-server.d.ts
+type ErrorInfo = {
+  error: unknown;
+  reset: () => void;
+  unstable_retry: () => void;
+};
+declare function unstable_catchError(): never;
+//#endregion
+export { ErrorInfo, unstable_catchError };

package/dist/shims/error.react-server.js

@@ -0,0 +1,6 @@
+//#region src/shims/error.react-server.ts
+function unstable_catchError() {
+	throw new Error("`unstable_catchError` can only be used in Client Components.");
+}
+//#endregion
+export { unstable_catchError };