vinext 0.0.30 → 0.0.31

package/dist/shims/dynamic.js

@@ -1,149 +1,135 @@
 "use client";
+import React, { Suspense, lazy, useEffect, useState } from "react";
+//#region src/shims/dynamic.ts
 /**
- * next/dynamic shim
- *
- * SSR-safe dynamic imports. On the server, uses React.lazy + Suspense so that
- * renderToReadableStream suspends until the dynamically-imported component is
- * available. On the client, also uses React.lazy for code splitting.
- *
- * Supports:
- * - dynamic(() => import('./Component'))
- * - dynamic(() => import('./Component'), { loading: () => <Spinner /> })
- * - dynamic(() => import('./Component'), { ssr: false })
- */
-import React, { lazy, Suspense, useState, useEffect } from "react";
+* next/dynamic shim
+*
+* SSR-safe dynamic imports. On the server, uses React.lazy + Suspense so that
+* renderToReadableStream suspends until the dynamically-imported component is
+* available. On the client, also uses React.lazy for code splitting.
+*
+* Supports:
+* - dynamic(() => import('./Component'))
+* - dynamic(() => import('./Component'), { loading: () => <Spinner /> })
+* - dynamic(() => import('./Component'), { ssr: false })
+*/
 /**
- * Lightweight error boundary that renders the loading component with the error
- * when a dynamic() loader rejects. Without this, loader failures would propagate
- * uncaught through React's rendering — this preserves the Next.js behavior where
- * the `loading` component can display errors.
- *
- * Lazily created because React.Component is not available in the RSC environment
- * (server components use a slimmed-down React that doesn't include class components).
- */
+* Lightweight error boundary that renders the loading component with the error
+* when a dynamic() loader rejects. Without this, loader failures would propagate
+* uncaught through React's rendering — this preserves the Next.js behavior where
+* the `loading` component can display errors.
+*
+* Lazily created because React.Component is not available in the RSC environment
+* (server components use a slimmed-down React that doesn't include class components).
+*/
 let DynamicErrorBoundary;
 function getDynamicErrorBoundary() {
-    if (DynamicErrorBoundary)
-        return DynamicErrorBoundary;
-    if (!React.Component)
-        return null;
-    DynamicErrorBoundary = class extends (React.Component) {
-        constructor(props) {
-            super(props);
-            this.state = { error: null };
-        }
-        static getDerivedStateFromError(error) {
-            return { error: error instanceof Error ? error : new Error(String(error)) };
-        }
-        render() {
-            if (this.state.error) {
-                return React.createElement(this.props.fallback, {
-                    isLoading: false,
-                    pastDelay: true,
-                    error: this.state.error,
-                });
-            }
-            return this.props.children;
-        }
-    };
-    return DynamicErrorBoundary;
+	if (DynamicErrorBoundary) return DynamicErrorBoundary;
+	if (!React.Component) return null;
+	DynamicErrorBoundary = class extends React.Component {
+		constructor(props) {
+			super(props);
+			this.state = { error: null };
+		}
+		static getDerivedStateFromError(error) {
+			return { error: error instanceof Error ? error : new Error(String(error)) };
+		}
+		render() {
+			if (this.state.error) return React.createElement(this.props.fallback, {
+				isLoading: false,
+				pastDelay: true,
+				error: this.state.error
+			});
+			return this.props.children;
+		}
+	};
+	return DynamicErrorBoundary;
 }
-// Detect server vs client
 const isServer = typeof window === "undefined";
-// Legacy preload queue — kept for backward compatibility with Pages Router
-// which calls flushPreloads() before rendering. The App Router uses React.lazy
-// + Suspense instead, so this queue is no longer populated.
 const preloadQueue = [];
 /**
- * Wait for all pending dynamic() preloads to resolve, then clear the queue.
- * Called by the Pages Router SSR handler before rendering.
- * No-op for the App Router path which uses React.lazy + Suspense.
- */
-export function flushPreloads() {
-    const pending = preloadQueue.splice(0);
-    return Promise.all(pending);
+* Wait for all pending dynamic() preloads to resolve, then clear the queue.
+* Called by the Pages Router SSR handler before rendering.
+* No-op for the App Router path which uses React.lazy + Suspense.
+*/
+function flushPreloads() {
+	const pending = preloadQueue.splice(0);
+	return Promise.all(pending);
 }
 function dynamic(loader, options) {
-    const { loading: LoadingComponent, ssr = true } = options ?? {};
-    // ssr: false — render nothing on the server, lazy-load on client
-    if (!ssr) {
-        if (isServer) {
-            // On the server, just render the loading state or nothing
-            const SSRFalse = (_props) => {
-                return LoadingComponent
-                    ? React.createElement(LoadingComponent, { isLoading: true, pastDelay: true, error: null })
-                    : null;
-            };
-            SSRFalse.displayName = "DynamicSSRFalse";
-            return SSRFalse;
-        }
-        // Client: use lazy with Suspense
-        const LazyComponent = lazy(async () => {
-            const mod = await loader();
-            if ("default" in mod)
-                return mod;
-            return { default: mod };
-        });
-        const ClientSSRFalse = (props) => {
-            const [mounted, setMounted] = useState(false);
-            useEffect(() => setMounted(true), []);
-            if (!mounted) {
-                return LoadingComponent
-                    ? React.createElement(LoadingComponent, { isLoading: true, pastDelay: true, error: null })
-                    : null;
-            }
-            const fallback = LoadingComponent
-                ? React.createElement(LoadingComponent, { isLoading: true, pastDelay: true, error: null })
-                : null;
-            return React.createElement(Suspense, { fallback }, React.createElement(LazyComponent, props));
-        };
-        ClientSSRFalse.displayName = "DynamicClientSSRFalse";
-        return ClientSSRFalse;
-    }
-    // SSR-enabled path
-    if (isServer) {
-        // Use React.lazy so that renderToReadableStream can suspend until the
-        // dynamically-imported component is available. The previous eager-load
-        // pattern relied on flushPreloads() being called before rendering, which
-        // works for the Pages Router but not the App Router where client modules
-        // are loaded lazily during RSC stream deserialization (issue #75).
-        const LazyServer = lazy(async () => {
-            const mod = await loader();
-            if ("default" in mod)
-                return mod;
-            return { default: mod };
-        });
-        const ServerDynamic = (props) => {
-            const fallback = LoadingComponent
-                ? React.createElement(LoadingComponent, { isLoading: true, pastDelay: true, error: null })
-                : null;
-            const lazyElement = React.createElement(LazyServer, props);
-            // Wrap with error boundary so loader rejections render the loading
-            // component with the error instead of propagating uncaught.
-            const ErrorBoundary = LoadingComponent ? getDynamicErrorBoundary() : null;
-            const content = ErrorBoundary
-                ? React.createElement(ErrorBoundary, { fallback: LoadingComponent }, lazyElement)
-                : lazyElement;
-            return React.createElement(Suspense, { fallback }, content);
-        };
-        ServerDynamic.displayName = "DynamicServer";
-        return ServerDynamic;
-    }
-    // Client path: standard React.lazy with Suspense
-    const LazyComponent = lazy(async () => {
-        const mod = await loader();
-        if ("default" in mod)
-            return mod;
-        return { default: mod };
-    });
-    const ClientDynamic = (props) => {
-        const fallback = LoadingComponent
-            ? React.createElement(LoadingComponent, { isLoading: true, pastDelay: true, error: null })
-            : null;
-        return React.createElement(Suspense, { fallback }, React.createElement(LazyComponent, props));
-    };
-    ClientDynamic.displayName = "DynamicClient";
-    return ClientDynamic;
+	const { loading: LoadingComponent, ssr = true } = options ?? {};
+	if (!ssr) {
+		if (isServer) {
+			const SSRFalse = (_props) => {
+				return LoadingComponent ? React.createElement(LoadingComponent, {
+					isLoading: true,
+					pastDelay: true,
+					error: null
+				}) : null;
+			};
+			SSRFalse.displayName = "DynamicSSRFalse";
+			return SSRFalse;
+		}
+		const LazyComponent = lazy(async () => {
+			const mod = await loader();
+			if ("default" in mod) return mod;
+			return { default: mod };
+		});
+		const ClientSSRFalse = (props) => {
+			const [mounted, setMounted] = useState(false);
+			useEffect(() => setMounted(true), []);
+			if (!mounted) return LoadingComponent ? React.createElement(LoadingComponent, {
+				isLoading: true,
+				pastDelay: true,
+				error: null
+			}) : null;
+			const fallback = LoadingComponent ? React.createElement(LoadingComponent, {
+				isLoading: true,
+				pastDelay: true,
+				error: null
+			}) : null;
+			return React.createElement(Suspense, { fallback }, React.createElement(LazyComponent, props));
+		};
+		ClientSSRFalse.displayName = "DynamicClientSSRFalse";
+		return ClientSSRFalse;
+	}
+	if (isServer) {
+		const LazyServer = lazy(async () => {
+			const mod = await loader();
+			if ("default" in mod) return mod;
+			return { default: mod };
+		});
+		const ServerDynamic = (props) => {
+			const fallback = LoadingComponent ? React.createElement(LoadingComponent, {
+				isLoading: true,
+				pastDelay: true,
+				error: null
+			}) : null;
+			const lazyElement = React.createElement(LazyServer, props);
+			const ErrorBoundary = LoadingComponent ? getDynamicErrorBoundary() : null;
+			const content = ErrorBoundary ? React.createElement(ErrorBoundary, { fallback: LoadingComponent }, lazyElement) : lazyElement;
+			return React.createElement(Suspense, { fallback }, content);
+		};
+		ServerDynamic.displayName = "DynamicServer";
+		return ServerDynamic;
+	}
+	const LazyComponent = lazy(async () => {
+		const mod = await loader();
+		if ("default" in mod) return mod;
+		return { default: mod };
+	});
+	const ClientDynamic = (props) => {
+		const fallback = LoadingComponent ? React.createElement(LoadingComponent, {
+			isLoading: true,
+			pastDelay: true,
+			error: null
+		}) : null;
+		return React.createElement(Suspense, { fallback }, React.createElement(LazyComponent, props));
+	};
+	ClientDynamic.displayName = "DynamicClient";
+	return ClientDynamic;
 }
-export default dynamic;
+//#endregion
+export { dynamic as default, flushPreloads };
+
 //# sourceMappingURL=dynamic.js.map

package/dist/shims/dynamic.js.map

@@ -1 +1 @@
-{"version":3,"file":"dynamic.js","sourceRoot":"","sources":["../../src/shims/dynamic.ts"],"names":[],"mappings":"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","sourcesContent":["\"use client\";\n/**\n * next/dynamic shim\n *\n * SSR-safe dynamic imports. On the server, uses React.lazy + Suspense so that\n * renderToReadableStream suspends until the dynamically-imported component is\n * available. On the client, also uses React.lazy for code splitting.\n *\n * Supports:\n * - dynamic(() => import('./Component'))\n * - dynamic(() => import('./Component'), { loading: () => <Spinner /> })\n * - dynamic(() => import('./Component'), { ssr: false })\n */\nimport React, { lazy, Suspense, type ComponentType, useState, useEffect } from \"react\";\n\ninterface DynamicOptions {\n  loading?: ComponentType<{ error?: Error | null; isLoading?: boolean; pastDelay?: boolean }>;\n  ssr?: boolean;\n}\n\ntype Loader<P> = () => Promise<{ default: ComponentType<P> } | ComponentType<P>>;\n\n/**\n * Lightweight error boundary that renders the loading component with the error\n * when a dynamic() loader rejects. Without this, loader failures would propagate\n * uncaught through React's rendering — this preserves the Next.js behavior where\n * the `loading` component can display errors.\n *\n * Lazily created because React.Component is not available in the RSC environment\n * (server components use a slimmed-down React that doesn't include class components).\n */\nlet DynamicErrorBoundary: any;\nfunction getDynamicErrorBoundary() {\n  if (DynamicErrorBoundary) return DynamicErrorBoundary;\n  if (!React.Component) return null;\n  DynamicErrorBoundary = class extends (\n    React.Component<\n      {\n        fallback: ComponentType<{ error?: Error | null; isLoading?: boolean; pastDelay?: boolean }>;\n        children: React.ReactNode;\n      },\n      { error: Error | null }\n    >\n  ) {\n    constructor(props: any) {\n      super(props);\n      this.state = { error: null };\n    }\n    static getDerivedStateFromError(error: unknown) {\n      return { error: error instanceof Error ? error : new Error(String(error)) };\n    }\n    render() {\n      if (this.state.error) {\n        return React.createElement(this.props.fallback, {\n          isLoading: false,\n          pastDelay: true,\n          error: this.state.error,\n        });\n      }\n      return this.props.children;\n    }\n  };\n  return DynamicErrorBoundary;\n}\n\n// Detect server vs client\nconst isServer = typeof window === \"undefined\";\n\n// Legacy preload queue — kept for backward compatibility with Pages Router\n// which calls flushPreloads() before rendering. The App Router uses React.lazy\n// + Suspense instead, so this queue is no longer populated.\nconst preloadQueue: Promise<void>[] = [];\n\n/**\n * Wait for all pending dynamic() preloads to resolve, then clear the queue.\n * Called by the Pages Router SSR handler before rendering.\n * No-op for the App Router path which uses React.lazy + Suspense.\n */\nexport function flushPreloads(): Promise<void[]> {\n  const pending = preloadQueue.splice(0);\n  return Promise.all(pending);\n}\n\nfunction dynamic<P extends object = object>(\n  loader: Loader<P>,\n  options?: DynamicOptions,\n): ComponentType<P> {\n  const { loading: LoadingComponent, ssr = true } = options ?? {};\n\n  // ssr: false — render nothing on the server, lazy-load on client\n  if (!ssr) {\n    if (isServer) {\n      // On the server, just render the loading state or nothing\n      const SSRFalse = (_props: P) => {\n        return LoadingComponent\n          ? React.createElement(LoadingComponent, { isLoading: true, pastDelay: true, error: null })\n          : null;\n      };\n      SSRFalse.displayName = \"DynamicSSRFalse\";\n      return SSRFalse;\n    }\n\n    // Client: use lazy with Suspense\n    const LazyComponent = lazy(async () => {\n      const mod = await loader();\n      if (\"default\" in mod) return mod as { default: ComponentType<P> };\n      return { default: mod as ComponentType<P> };\n    });\n\n    const ClientSSRFalse = (props: P) => {\n      const [mounted, setMounted] = useState(false);\n      useEffect(() => setMounted(true), []);\n\n      if (!mounted) {\n        return LoadingComponent\n          ? React.createElement(LoadingComponent, { isLoading: true, pastDelay: true, error: null })\n          : null;\n      }\n\n      const fallback = LoadingComponent\n        ? React.createElement(LoadingComponent, { isLoading: true, pastDelay: true, error: null })\n        : null;\n      return React.createElement(Suspense, { fallback }, React.createElement(LazyComponent, props));\n    };\n\n    ClientSSRFalse.displayName = \"DynamicClientSSRFalse\";\n    return ClientSSRFalse;\n  }\n\n  // SSR-enabled path\n  if (isServer) {\n    // Use React.lazy so that renderToReadableStream can suspend until the\n    // dynamically-imported component is available. The previous eager-load\n    // pattern relied on flushPreloads() being called before rendering, which\n    // works for the Pages Router but not the App Router where client modules\n    // are loaded lazily during RSC stream deserialization (issue #75).\n    const LazyServer = lazy(async () => {\n      const mod = await loader();\n      if (\"default\" in mod) return mod as { default: ComponentType<P> };\n      return { default: mod as ComponentType<P> };\n    });\n\n    const ServerDynamic = (props: P) => {\n      const fallback = LoadingComponent\n        ? React.createElement(LoadingComponent, { isLoading: true, pastDelay: true, error: null })\n        : null;\n      const lazyElement = React.createElement(LazyServer, props);\n      // Wrap with error boundary so loader rejections render the loading\n      // component with the error instead of propagating uncaught.\n      const ErrorBoundary = LoadingComponent ? getDynamicErrorBoundary() : null;\n      const content = ErrorBoundary\n        ? React.createElement(ErrorBoundary, { fallback: LoadingComponent }, lazyElement)\n        : lazyElement;\n      return React.createElement(Suspense, { fallback }, content);\n    };\n\n    ServerDynamic.displayName = \"DynamicServer\";\n    return ServerDynamic;\n  }\n\n  // Client path: standard React.lazy with Suspense\n  const LazyComponent = lazy(async () => {\n    const mod = await loader();\n    if (\"default\" in mod) return mod as { default: ComponentType<P> };\n    return { default: mod as ComponentType<P> };\n  });\n\n  const ClientDynamic = (props: P) => {\n    const fallback = LoadingComponent\n      ? React.createElement(LoadingComponent, { isLoading: true, pastDelay: true, error: null })\n      : null;\n    return React.createElement(Suspense, { fallback }, React.createElement(LazyComponent, props));\n  };\n\n  ClientDynamic.displayName = \"DynamicClient\";\n  return ClientDynamic;\n}\n\nexport default dynamic;\n"]}
+{"version":3,"file":"dynamic.js","names":[],"sources":["../../src/shims/dynamic.ts"],"sourcesContent":["\"use client\";\n/**\n * next/dynamic shim\n *\n * SSR-safe dynamic imports. On the server, uses React.lazy + Suspense so that\n * renderToReadableStream suspends until the dynamically-imported component is\n * available. On the client, also uses React.lazy for code splitting.\n *\n * Supports:\n * - dynamic(() => import('./Component'))\n * - dynamic(() => import('./Component'), { loading: () => <Spinner /> })\n * - dynamic(() => import('./Component'), { ssr: false })\n */\nimport React, { lazy, Suspense, type ComponentType, useState, useEffect } from \"react\";\n\ninterface DynamicOptions {\n  loading?: ComponentType<{ error?: Error | null; isLoading?: boolean; pastDelay?: boolean }>;\n  ssr?: boolean;\n}\n\ntype Loader<P> = () => Promise<{ default: ComponentType<P> } | ComponentType<P>>;\n\n/**\n * Lightweight error boundary that renders the loading component with the error\n * when a dynamic() loader rejects. Without this, loader failures would propagate\n * uncaught through React's rendering — this preserves the Next.js behavior where\n * the `loading` component can display errors.\n *\n * Lazily created because React.Component is not available in the RSC environment\n * (server components use a slimmed-down React that doesn't include class components).\n */\nlet DynamicErrorBoundary: any;\nfunction getDynamicErrorBoundary() {\n  if (DynamicErrorBoundary) return DynamicErrorBoundary;\n  if (!React.Component) return null;\n  DynamicErrorBoundary = class extends (\n    React.Component<\n      {\n        fallback: ComponentType<{ error?: Error | null; isLoading?: boolean; pastDelay?: boolean }>;\n        children: React.ReactNode;\n      },\n      { error: Error | null }\n    >\n  ) {\n    constructor(props: any) {\n      super(props);\n      this.state = { error: null };\n    }\n    static getDerivedStateFromError(error: unknown) {\n      return { error: error instanceof Error ? error : new Error(String(error)) };\n    }\n    render() {\n      if (this.state.error) {\n        return React.createElement(this.props.fallback, {\n          isLoading: false,\n          pastDelay: true,\n          error: this.state.error,\n        });\n      }\n      return this.props.children;\n    }\n  };\n  return DynamicErrorBoundary;\n}\n\n// Detect server vs client\nconst isServer = typeof window === \"undefined\";\n\n// Legacy preload queue — kept for backward compatibility with Pages Router\n// which calls flushPreloads() before rendering. The App Router uses React.lazy\n// + Suspense instead, so this queue is no longer populated.\nconst preloadQueue: Promise<void>[] = [];\n\n/**\n * Wait for all pending dynamic() preloads to resolve, then clear the queue.\n * Called by the Pages Router SSR handler before rendering.\n * No-op for the App Router path which uses React.lazy + Suspense.\n */\nexport function flushPreloads(): Promise<void[]> {\n  const pending = preloadQueue.splice(0);\n  return Promise.all(pending);\n}\n\nfunction dynamic<P extends object = object>(\n  loader: Loader<P>,\n  options?: DynamicOptions,\n): ComponentType<P> {\n  const { loading: LoadingComponent, ssr = true } = options ?? {};\n\n  // ssr: false — render nothing on the server, lazy-load on client\n  if (!ssr) {\n    if (isServer) {\n      // On the server, just render the loading state or nothing\n      const SSRFalse = (_props: P) => {\n        return LoadingComponent\n          ? React.createElement(LoadingComponent, { isLoading: true, pastDelay: true, error: null })\n          : null;\n      };\n      SSRFalse.displayName = \"DynamicSSRFalse\";\n      return SSRFalse;\n    }\n\n    // Client: use lazy with Suspense\n    const LazyComponent = lazy(async () => {\n      const mod = await loader();\n      if (\"default\" in mod) return mod as { default: ComponentType<P> };\n      return { default: mod as ComponentType<P> };\n    });\n\n    const ClientSSRFalse = (props: P) => {\n      const [mounted, setMounted] = useState(false);\n      useEffect(() => setMounted(true), []);\n\n      if (!mounted) {\n        return LoadingComponent\n          ? React.createElement(LoadingComponent, { isLoading: true, pastDelay: true, error: null })\n          : null;\n      }\n\n      const fallback = LoadingComponent\n        ? React.createElement(LoadingComponent, { isLoading: true, pastDelay: true, error: null })\n        : null;\n      return React.createElement(Suspense, { fallback }, React.createElement(LazyComponent, props));\n    };\n\n    ClientSSRFalse.displayName = \"DynamicClientSSRFalse\";\n    return ClientSSRFalse;\n  }\n\n  // SSR-enabled path\n  if (isServer) {\n    // Use React.lazy so that renderToReadableStream can suspend until the\n    // dynamically-imported component is available. The previous eager-load\n    // pattern relied on flushPreloads() being called before rendering, which\n    // works for the Pages Router but not the App Router where client modules\n    // are loaded lazily during RSC stream deserialization (issue #75).\n    const LazyServer = lazy(async () => {\n      const mod = await loader();\n      if (\"default\" in mod) return mod as { default: ComponentType<P> };\n      return { default: mod as ComponentType<P> };\n    });\n\n    const ServerDynamic = (props: P) => {\n      const fallback = LoadingComponent\n        ? React.createElement(LoadingComponent, { isLoading: true, pastDelay: true, error: null })\n        : null;\n      const lazyElement = React.createElement(LazyServer, props);\n      // Wrap with error boundary so loader rejections render the loading\n      // component with the error instead of propagating uncaught.\n      const ErrorBoundary = LoadingComponent ? getDynamicErrorBoundary() : null;\n      const content = ErrorBoundary\n        ? React.createElement(ErrorBoundary, { fallback: LoadingComponent }, lazyElement)\n        : lazyElement;\n      return React.createElement(Suspense, { fallback }, content);\n    };\n\n    ServerDynamic.displayName = \"DynamicServer\";\n    return ServerDynamic;\n  }\n\n  // Client path: standard React.lazy with Suspense\n  const LazyComponent = lazy(async () => {\n    const mod = await loader();\n    if (\"default\" in mod) return mod as { default: ComponentType<P> };\n    return { default: mod as ComponentType<P> };\n  });\n\n  const ClientDynamic = (props: P) => {\n    const fallback = LoadingComponent\n      ? React.createElement(LoadingComponent, { isLoading: true, pastDelay: true, error: null })\n      : null;\n    return React.createElement(Suspense, { fallback }, React.createElement(LazyComponent, props));\n  };\n\n  ClientDynamic.displayName = \"DynamicClient\";\n  return ClientDynamic;\n}\n\nexport default dynamic;\n"],"mappings":"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"}

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

@@ -1,33 +1,40 @@
 import React from "react";
+import * as react_jsx_runtime0 from "react/jsx-runtime";
+
+//#region src/shims/error-boundary.d.ts
 interface ErrorBoundaryProps {
-    fallback: React.ComponentType<{
-        error: Error;
-        reset: () => void;
-    }>;
-    children: React.ReactNode;
+  fallback: React.ComponentType<{
+    error: Error;
+    reset: () => void;
+  }>;
+  children: React.ReactNode;
 }
 interface ErrorBoundaryState {
-    error: Error | null;
+  error: Error | null;
 }
 /**
  * Generic ErrorBoundary used to wrap route segments with error.tsx.
  * This must be a client component since error boundaries use
  * componentDidCatch / getDerivedStateFromError.
  */
-export declare class ErrorBoundary extends React.Component<ErrorBoundaryProps, ErrorBoundaryState> {
-    constructor(props: ErrorBoundaryProps);
-    static getDerivedStateFromError(error: Error): ErrorBoundaryState;
-    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> | import("react/jsx-runtime").JSX.Element | null | undefined;
+declare class ErrorBoundary extends React.Component<ErrorBoundaryProps, ErrorBoundaryState> {
+  constructor(props: ErrorBoundaryProps);
+  static getDerivedStateFromError(error: Error): ErrorBoundaryState;
+  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_runtime0.JSX.Element | null | undefined;
 }
 interface NotFoundBoundaryProps {
-    fallback: React.ReactNode;
-    children: React.ReactNode;
+  fallback: React.ReactNode;
+  children: React.ReactNode;
 }
 /**
  * Wrapper that reads the current pathname and passes it to the inner class
  * component. This enables automatic reset on client-side navigation.
  */
-export declare function NotFoundBoundary({ fallback, children }: NotFoundBoundaryProps): import("react/jsx-runtime").JSX.Element;
-export {};
+declare function NotFoundBoundary({
+  fallback,
+  children
+}: NotFoundBoundaryProps): react_jsx_runtime0.JSX.Element;
+//#endregion
+export { ErrorBoundary, NotFoundBoundary };
 //# sourceMappingURL=error-boundary.d.ts.map

package/dist/shims/error-boundary.js

@@ -1,87 +1,89 @@
 "use client";
-import { jsx as _jsx } from "react/jsx-runtime";
 import React from "react";
-// eslint-disable-next-line @typescript-eslint/no-require-imports -- next/navigation is shimmed
+import { jsx } from "react/jsx-runtime";
 import { usePathname } from "next/navigation";
+//#region src/shims/error-boundary.tsx
 /**
- * Generic ErrorBoundary used to wrap route segments with error.tsx.
- * This must be a client component since error boundaries use
- * componentDidCatch / getDerivedStateFromError.
- */
-export class ErrorBoundary extends React.Component {
-    constructor(props) {
-        super(props);
-        this.state = { error: null };
-    }
-    static getDerivedStateFromError(error) {
-        // notFound(), forbidden(), unauthorized(), and redirect() must propagate
-        // past error boundaries. Re-throw them so they bubble up to the
-        // framework's HTTP access fallback / redirect handler.
-        if (error && typeof error === "object" && "digest" in error) {
-            const digest = String(error.digest);
-            if (digest === "NEXT_NOT_FOUND" || // legacy compat
-                digest.startsWith("NEXT_HTTP_ERROR_FALLBACK;") ||
-                digest.startsWith("NEXT_REDIRECT;")) {
-                throw error;
-            }
-        }
-        return { error };
-    }
-    reset = () => {
-        this.setState({ error: null });
-    };
-    render() {
-        if (this.state.error) {
-            const FallbackComponent = this.props.fallback;
-            return _jsx(FallbackComponent, { error: this.state.error, reset: this.reset });
-        }
-        return this.props.children;
-    }
-}
+* Generic ErrorBoundary used to wrap route segments with error.tsx.
+* This must be a client component since error boundaries use
+* componentDidCatch / getDerivedStateFromError.
+*/
+var ErrorBoundary = class extends React.Component {
+	constructor(props) {
+		super(props);
+		this.state = { error: null };
+	}
+	static getDerivedStateFromError(error) {
+		if (error && typeof error === "object" && "digest" in error) {
+			const digest = String(error.digest);
+			if (digest === "NEXT_NOT_FOUND" || digest.startsWith("NEXT_HTTP_ERROR_FALLBACK;") || digest.startsWith("NEXT_REDIRECT;")) throw error;
+		}
+		return { error };
+	}
+	reset = () => {
+		this.setState({ error: null });
+	};
+	render() {
+		if (this.state.error) {
+			const FallbackComponent = this.props.fallback;
+			return /* @__PURE__ */ jsx(FallbackComponent, {
+				error: this.state.error,
+				reset: this.reset
+			});
+		}
+		return this.props.children;
+	}
+};
 /**
- * Inner class component that catches notFound() errors and renders the
- * not-found.tsx fallback. Resets when the pathname changes (client navigation)
- * so a previous notFound() doesn't permanently stick.
- *
- * 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.
- */
-class NotFoundBoundaryInner extends React.Component {
-    constructor(props) {
-        super(props);
-        this.state = { notFound: false, previousPathname: props.pathname };
-    }
-    static getDerivedStateFromProps(props, state) {
-        // Reset the boundary when the route changes so a previous notFound()
-        // doesn't permanently stick after client-side navigation.
-        if (props.pathname !== state.previousPathname && state.notFound) {
-            return { notFound: false, previousPathname: props.pathname };
-        }
-        return { notFound: state.notFound, previousPathname: props.pathname };
-    }
-    static getDerivedStateFromError(error) {
-        if (error && typeof error === "object" && "digest" in error) {
-            const digest = String(error.digest);
-            if (digest === "NEXT_NOT_FOUND" || digest.startsWith("NEXT_HTTP_ERROR_FALLBACK;404")) {
-                return { notFound: true };
-            }
-        }
-        // Not a notFound error — re-throw so it reaches an ErrorBoundary or propagates
-        throw error;
-    }
-    render() {
-        if (this.state.notFound) {
-            return this.props.fallback;
-        }
-        return this.props.children;
-    }
-}
+* Inner class component that catches notFound() errors and renders the
+* not-found.tsx fallback. Resets when the pathname changes (client navigation)
+* so a previous notFound() doesn't permanently stick.
+*
+* 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,
+			previousPathname: props.pathname
+		};
+	}
+	static getDerivedStateFromProps(props, state) {
+		if (props.pathname !== state.previousPathname && state.notFound) return {
+			notFound: false,
+			previousPathname: props.pathname
+		};
+		return {
+			notFound: state.notFound,
+			previousPathname: props.pathname
+		};
+	}
+	static getDerivedStateFromError(error) {
+		if (error && typeof error === "object" && "digest" in error) {
+			const digest = String(error.digest);
+			if (digest === "NEXT_NOT_FOUND" || digest.startsWith("NEXT_HTTP_ERROR_FALLBACK;404")) return { notFound: true };
+		}
+		throw error;
+	}
+	render() {
+		if (this.state.notFound) return this.props.fallback;
+		return this.props.children;
+	}
+};
 /**
- * Wrapper that reads the current pathname and passes it to the inner class
- * component. This enables automatic reset on client-side navigation.
- */
-export function NotFoundBoundary({ fallback, children }) {
-    const pathname = usePathname();
-    return (_jsx(NotFoundBoundaryInner, { pathname: pathname, fallback: fallback, children: children }));
+* Wrapper that reads the current pathname and passes it to the inner class
+* component. This enables automatic reset on client-side navigation.
+*/
+function NotFoundBoundary({ fallback, children }) {
+	return /* @__PURE__ */ jsx(NotFoundBoundaryInner, {
+		pathname: usePathname(),
+		fallback,
+		children
+	});
 }
+//#endregion
+export { ErrorBoundary, NotFoundBoundary };
+
 //# sourceMappingURL=error-boundary.js.map

package/dist/shims/error-boundary.js.map

@@ -1 +1 @@
-{"version":3,"file":"error-boundary.js","sourceRoot":"","sources":["../../src/shims/error-boundary.tsx"],"names":[],"mappings":"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","sourcesContent":["\"use client\";\n\nimport React from \"react\";\n// eslint-disable-next-line @typescript-eslint/no-require-imports -- next/navigation is shimmed\nimport { usePathname } from \"next/navigation\";\n\ninterface ErrorBoundaryProps {\n  fallback: React.ComponentType<{ error: Error; reset: () => void }>;\n  children: React.ReactNode;\n}\n\ninterface ErrorBoundaryState {\n  error: Error | null;\n}\n\n/**\n * Generic ErrorBoundary used to wrap route segments with error.tsx.\n * This must be a client component since error boundaries use\n * componentDidCatch / getDerivedStateFromError.\n */\nexport class ErrorBoundary extends React.Component<ErrorBoundaryProps, ErrorBoundaryState> {\n  constructor(props: ErrorBoundaryProps) {\n    super(props);\n    this.state = { error: null };\n  }\n\n  static getDerivedStateFromError(error: Error): ErrorBoundaryState {\n    // notFound(), forbidden(), unauthorized(), and redirect() must propagate\n    // past error boundaries. Re-throw them so they bubble up to the\n    // framework's HTTP access fallback / redirect handler.\n    if (error && typeof error === \"object\" && \"digest\" in error) {\n      const digest = String((error as any).digest);\n      if (\n        digest === \"NEXT_NOT_FOUND\" || // legacy compat\n        digest.startsWith(\"NEXT_HTTP_ERROR_FALLBACK;\") ||\n        digest.startsWith(\"NEXT_REDIRECT;\")\n      ) {\n        throw error;\n      }\n    }\n    return { error };\n  }\n\n  reset = () => {\n    this.setState({ error: null });\n  };\n\n  render() {\n    if (this.state.error) {\n      const FallbackComponent = this.props.fallback;\n      return <FallbackComponent error={this.state.error} reset={this.reset} />;\n    }\n    return this.props.children;\n  }\n}\n\n// ---------------------------------------------------------------------------\n// NotFoundBoundary — catches notFound() on the client and renders not-found.tsx\n// ---------------------------------------------------------------------------\n\ninterface NotFoundBoundaryProps {\n  fallback: React.ReactNode;\n  children: React.ReactNode;\n}\n\ninterface NotFoundBoundaryInnerProps extends NotFoundBoundaryProps {\n  pathname: string;\n}\n\ninterface NotFoundBoundaryState {\n  notFound: boolean;\n  previousPathname: string;\n}\n\n/**\n * Inner class component that catches notFound() errors and renders the\n * not-found.tsx fallback. Resets when the pathname changes (client navigation)\n * so a previous notFound() doesn't permanently stick.\n *\n * The ErrorBoundary above re-throws notFound errors so they propagate up to this\n * boundary. This must be placed above the ErrorBoundary in the component tree.\n */\nclass NotFoundBoundaryInner extends React.Component<\n  NotFoundBoundaryInnerProps,\n  NotFoundBoundaryState\n> {\n  constructor(props: NotFoundBoundaryInnerProps) {\n    super(props);\n    this.state = { notFound: false, previousPathname: props.pathname };\n  }\n\n  static getDerivedStateFromProps(\n    props: NotFoundBoundaryInnerProps,\n    state: NotFoundBoundaryState,\n  ): NotFoundBoundaryState | null {\n    // Reset the boundary when the route changes so a previous notFound()\n    // doesn't permanently stick after client-side navigation.\n    if (props.pathname !== state.previousPathname && state.notFound) {\n      return { notFound: false, previousPathname: props.pathname };\n    }\n    return { notFound: state.notFound, previousPathname: props.pathname };\n  }\n\n  static getDerivedStateFromError(error: Error): Partial<NotFoundBoundaryState> {\n    if (error && typeof error === \"object\" && \"digest\" in error) {\n      const digest = String((error as any).digest);\n      if (digest === \"NEXT_NOT_FOUND\" || digest.startsWith(\"NEXT_HTTP_ERROR_FALLBACK;404\")) {\n        return { notFound: true };\n      }\n    }\n    // Not a notFound error — re-throw so it reaches an ErrorBoundary or propagates\n    throw error;\n  }\n\n  render() {\n    if (this.state.notFound) {\n      return this.props.fallback;\n    }\n    return this.props.children;\n  }\n}\n\n/**\n * Wrapper that reads the current pathname and passes it to the inner class\n * component. This enables automatic reset on client-side navigation.\n */\nexport function NotFoundBoundary({ fallback, children }: NotFoundBoundaryProps) {\n  const pathname = usePathname();\n  return (\n    <NotFoundBoundaryInner pathname={pathname} fallback={fallback}>\n      {children}\n    </NotFoundBoundaryInner>\n  );\n}\n"]}
+{"version":3,"file":"error-boundary.js","names":[],"sources":["../../src/shims/error-boundary.tsx"],"sourcesContent":["\"use client\";\n\nimport React from \"react\";\n// eslint-disable-next-line @typescript-eslint/no-require-imports -- next/navigation is shimmed\nimport { usePathname } from \"next/navigation\";\n\ninterface ErrorBoundaryProps {\n  fallback: React.ComponentType<{ error: Error; reset: () => void }>;\n  children: React.ReactNode;\n}\n\ninterface ErrorBoundaryState {\n  error: Error | null;\n}\n\n/**\n * Generic ErrorBoundary used to wrap route segments with error.tsx.\n * This must be a client component since error boundaries use\n * componentDidCatch / getDerivedStateFromError.\n */\nexport class ErrorBoundary extends React.Component<ErrorBoundaryProps, ErrorBoundaryState> {\n  constructor(props: ErrorBoundaryProps) {\n    super(props);\n    this.state = { error: null };\n  }\n\n  static getDerivedStateFromError(error: Error): ErrorBoundaryState {\n    // notFound(), forbidden(), unauthorized(), and redirect() must propagate\n    // past error boundaries. Re-throw them so they bubble up to the\n    // framework's HTTP access fallback / redirect handler.\n    if (error && typeof error === \"object\" && \"digest\" in error) {\n      const digest = String((error as any).digest);\n      if (\n        digest === \"NEXT_NOT_FOUND\" || // legacy compat\n        digest.startsWith(\"NEXT_HTTP_ERROR_FALLBACK;\") ||\n        digest.startsWith(\"NEXT_REDIRECT;\")\n      ) {\n        throw error;\n      }\n    }\n    return { error };\n  }\n\n  reset = () => {\n    this.setState({ error: null });\n  };\n\n  render() {\n    if (this.state.error) {\n      const FallbackComponent = this.props.fallback;\n      return <FallbackComponent error={this.state.error} reset={this.reset} />;\n    }\n    return this.props.children;\n  }\n}\n\n// ---------------------------------------------------------------------------\n// NotFoundBoundary — catches notFound() on the client and renders not-found.tsx\n// ---------------------------------------------------------------------------\n\ninterface NotFoundBoundaryProps {\n  fallback: React.ReactNode;\n  children: React.ReactNode;\n}\n\ninterface NotFoundBoundaryInnerProps extends NotFoundBoundaryProps {\n  pathname: string;\n}\n\ninterface NotFoundBoundaryState {\n  notFound: boolean;\n  previousPathname: string;\n}\n\n/**\n * Inner class component that catches notFound() errors and renders the\n * not-found.tsx fallback. Resets when the pathname changes (client navigation)\n * so a previous notFound() doesn't permanently stick.\n *\n * The ErrorBoundary above re-throws notFound errors so they propagate up to this\n * boundary. This must be placed above the ErrorBoundary in the component tree.\n */\nclass NotFoundBoundaryInner extends React.Component<\n  NotFoundBoundaryInnerProps,\n  NotFoundBoundaryState\n> {\n  constructor(props: NotFoundBoundaryInnerProps) {\n    super(props);\n    this.state = { notFound: false, previousPathname: props.pathname };\n  }\n\n  static getDerivedStateFromProps(\n    props: NotFoundBoundaryInnerProps,\n    state: NotFoundBoundaryState,\n  ): NotFoundBoundaryState | null {\n    // Reset the boundary when the route changes so a previous notFound()\n    // doesn't permanently stick after client-side navigation.\n    if (props.pathname !== state.previousPathname && state.notFound) {\n      return { notFound: false, previousPathname: props.pathname };\n    }\n    return { notFound: state.notFound, previousPathname: props.pathname };\n  }\n\n  static getDerivedStateFromError(error: Error): Partial<NotFoundBoundaryState> {\n    if (error && typeof error === \"object\" && \"digest\" in error) {\n      const digest = String((error as any).digest);\n      if (digest === \"NEXT_NOT_FOUND\" || digest.startsWith(\"NEXT_HTTP_ERROR_FALLBACK;404\")) {\n        return { notFound: true };\n      }\n    }\n    // Not a notFound error — re-throw so it reaches an ErrorBoundary or propagates\n    throw error;\n  }\n\n  render() {\n    if (this.state.notFound) {\n      return this.props.fallback;\n    }\n    return this.props.children;\n  }\n}\n\n/**\n * Wrapper that reads the current pathname and passes it to the inner class\n * component. This enables automatic reset on client-side navigation.\n */\nexport function NotFoundBoundary({ fallback, children }: NotFoundBoundaryProps) {\n  const pathname = usePathname();\n  return (\n    <NotFoundBoundaryInner pathname={pathname} fallback={fallback}>\n      {children}\n    </NotFoundBoundaryInner>\n  );\n}\n"],"mappings":";;;;;;;;;;AAoBA,IAAa,gBAAb,cAAmC,MAAM,UAAkD;CACzF,YAAY,OAA2B;AACrC,QAAM,MAAM;AACZ,OAAK,QAAQ,EAAE,OAAO,MAAM;;CAG9B,OAAO,yBAAyB,OAAkC;AAIhE,MAAI,SAAS,OAAO,UAAU,YAAY,YAAY,OAAO;GAC3D,MAAM,SAAS,OAAQ,MAAc,OAAO;AAC5C,OACE,WAAW,oBACX,OAAO,WAAW,4BAA4B,IAC9C,OAAO,WAAW,iBAAiB,CAEnC,OAAM;;AAGV,SAAO,EAAE,OAAO;;CAGlB,cAAc;AACZ,OAAK,SAAS,EAAE,OAAO,MAAM,CAAC;;CAGhC,SAAS;AACP,MAAI,KAAK,MAAM,OAAO;GACpB,MAAM,oBAAoB,KAAK,MAAM;AACrC,UAAO,oBAAC,mBAAD;IAAmB,OAAO,KAAK,MAAM;IAAO,OAAO,KAAK;IAAS,CAAA;;AAE1E,SAAO,KAAK,MAAM;;;;;;;;;;;AA8BtB,IAAM,wBAAN,cAAoC,MAAM,UAGxC;CACA,YAAY,OAAmC;AAC7C,QAAM,MAAM;AACZ,OAAK,QAAQ;GAAE,UAAU;GAAO,kBAAkB,MAAM;GAAU;;CAGpE,OAAO,yBACL,OACA,OAC8B;AAG9B,MAAI,MAAM,aAAa,MAAM,oBAAoB,MAAM,SACrD,QAAO;GAAE,UAAU;GAAO,kBAAkB,MAAM;GAAU;AAE9D,SAAO;GAAE,UAAU,MAAM;GAAU,kBAAkB,MAAM;GAAU;;CAGvE,OAAO,yBAAyB,OAA8C;AAC5E,MAAI,SAAS,OAAO,UAAU,YAAY,YAAY,OAAO;GAC3D,MAAM,SAAS,OAAQ,MAAc,OAAO;AAC5C,OAAI,WAAW,oBAAoB,OAAO,WAAW,+BAA+B,CAClF,QAAO,EAAE,UAAU,MAAM;;AAI7B,QAAM;;CAGR,SAAS;AACP,MAAI,KAAK,MAAM,SACb,QAAO,KAAK,MAAM;AAEpB,SAAO,KAAK,MAAM;;;;;;;AAQtB,SAAgB,iBAAiB,EAAE,UAAU,YAAmC;AAE9E,QACE,oBAAC,uBAAD;EAAuB,UAFR,aAAa;EAEyB;EAClD;EACqB,CAAA"}

package/dist/shims/error.d.ts

@@ -1,16 +1,15 @@
-/**
- * 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.
- */
 import React from "react";
+
+//#region src/shims/error.d.ts
 interface ErrorProps {
-    statusCode: number;
-    title?: string;
-    withDarkMode?: boolean;
+  statusCode: number;
+  title?: string;
+  withDarkMode?: boolean;
 }
-declare function ErrorComponent({ statusCode, title }: ErrorProps): React.ReactElement;
-export default ErrorComponent;
+declare function ErrorComponent({
+  statusCode,
+  title
+}: ErrorProps): React.ReactElement;
+//#endregion
+export { ErrorComponent as default };
 //# sourceMappingURL=error.d.ts.map