@kasperrt/smolter 0.4.2 → 0.4.4

package/dist/core/resources.js

@@ -1,345 +0,0 @@
-import { safeWrapAsync } from "./errors.js";
-//#region .generated/core/resources.ts
-var IDLE_ROUTE_STATE = {
-	actionData: null,
-	actionError: "",
-	actionState: "idle",
-	loaderData: null,
-	loaderError: "",
-	loaderInitialized: false,
-	loaderState: "idle",
-	navigationState: "idle",
-	unexpectedError: false
-};
-var ResourceRouter = class {
-	#cleanupTimers = /* @__PURE__ */ new Map();
-	#controllers = /* @__PURE__ */ new Map();
-	#inFlightLoads = /* @__PURE__ */ new Map();
-	#listeners = /* @__PURE__ */ new Map();
-	#persistentRoutes = /* @__PURE__ */ new Set();
-	#routes;
-	#states = /* @__PURE__ */ new Map();
-	constructor(routes) {
-		this.#routes = routes;
-	}
-	dispose() {
-		for (const controller of this.#controllers.values()) controller.abort();
-		this.#controllers.clear();
-		for (const timer of this.#cleanupTimers.values()) clearTimeout(timer);
-		this.#cleanupTimers.clear();
-		this.#inFlightLoads.clear();
-		this.#listeners.clear();
-		this.#persistentRoutes.clear();
-	}
-	getRoute(routeId) {
-		return this.#routes.get(routeId) ?? null;
-	}
-	getSnapshot(routeId, params) {
-		return this.#states.get(createRouteKey(routeId, params)) ?? IDLE_ROUTE_STATE;
-	}
-	hydrateRoute(routeId, data, params = {}) {
-		const routeKey = createRouteKey(routeId, params);
-		const currentState = this.#states.get(routeKey) ?? IDLE_ROUTE_STATE;
-		this.#setState(routeKey, {
-			...currentState,
-			loaderData: data,
-			loaderError: "",
-			loaderInitialized: true,
-			loaderState: "idle",
-			navigationState: currentState.actionState === "submitting" ? "submitting" : "idle",
-			unexpectedError: false
-		});
-	}
-	persist(routeId, params = {}) {
-		const routeKey = createRouteKey(routeId, params);
-		this.#persistentRoutes.add(routeKey);
-		const cleanupTimer = this.#cleanupTimers.get(routeKey);
-		if (!cleanupTimer) return;
-		clearTimeout(cleanupTimer);
-		this.#cleanupTimers.delete(routeKey);
-	}
-	disposeRoute(routeId, params = {}) {
-		this.#disposeRouteKey(createRouteKey(routeId, params));
-	}
-	#disposeRouteKey(routeKey) {
-		this.#persistentRoutes.delete(routeKey);
-		const cleanupTimer = this.#cleanupTimers.get(routeKey);
-		if (cleanupTimer) clearTimeout(cleanupTimer);
-		this.#cleanupTimers.delete(routeKey);
-		this.#controllers.get(routeKey)?.abort();
-		this.#controllers.get(`${routeKey}:action`)?.abort();
-		this.#controllers.delete(routeKey);
-		this.#controllers.delete(`${routeKey}:action`);
-		this.#inFlightLoads.delete(routeKey);
-		this.#states.delete(routeKey);
-		this.#notify(routeKey);
-	}
-	load(routeId, params = {}, force = false) {
-		const routeKey = createRouteKey(routeId, params);
-		const route = this.#routes.get(routeId);
-		if (!route?.loader) return Promise.resolve({
-			data: null,
-			error: "Route loader not found."
-		});
-		const currentState = this.#states.get(routeKey);
-		if (!force && currentState?.loaderInitialized) return Promise.resolve({
-			data: currentState?.loaderData,
-			error: currentState?.loaderError ?? ""
-		});
-		const currentLoad = this.#inFlightLoads.get(routeKey);
-		if (force && currentLoad) {
-			this.#controllers.get(routeKey)?.abort();
-			this.#inFlightLoads.delete(routeKey);
-		}
-		if (!force && currentLoad) return currentLoad;
-		const controller = this.#replaceController(routeKey);
-		this.#setState(routeKey, {
-			...currentState ?? IDLE_ROUTE_STATE,
-			loaderError: "",
-			loaderState: "loading",
-			navigationState: currentState?.actionState === "submitting" ? "submitting" : "loading",
-			unexpectedError: false
-		});
-		const load = this.#runLoader(route, routeKey, params, controller);
-		this.#inFlightLoads.set(routeKey, load);
-		return load;
-	}
-	subscribe(routeId, params, listener) {
-		const routeKey = createRouteKey(routeId, params);
-		const cleanupTimer = this.#cleanupTimers.get(routeKey);
-		if (cleanupTimer) {
-			clearTimeout(cleanupTimer);
-			this.#cleanupTimers.delete(routeKey);
-		}
-		const listeners = this.#listeners.get(routeKey) ?? /* @__PURE__ */ new Set();
-		listeners.add(listener);
-		this.#listeners.set(routeKey, listeners);
-		return () => {
-			if (!listeners.delete(listener) || listeners.size > 0) return;
-			this.#listeners.delete(routeKey);
-			if (this.#persistentRoutes.has(routeKey)) return;
-			const timer = setTimeout(() => this.#disposeRouteKey(routeKey), routeCleanupGraceMs);
-			this.#cleanupTimers.set(routeKey, timer);
-		};
-	}
-	async submit(routeId, input, params = {}) {
-		const routeKey = createRouteKey(routeId, params);
-		const route = this.#routes.get(routeId);
-		if (!route?.action) return {
-			data: null,
-			error: "Route action not found."
-		};
-		const controllerKey = `${routeKey}:action`;
-		const controller = this.#replaceController(controllerKey);
-		const currentState = this.#states.get(routeKey) ?? IDLE_ROUTE_STATE;
-		this.#setState(routeKey, {
-			...currentState,
-			actionError: "",
-			actionState: "submitting",
-			navigationState: "submitting",
-			unexpectedError: false
-		});
-		const { error, data: result } = await safeWrapAsync(() => route.action?.({
-			input,
-			params,
-			signal: controller.signal
-		}));
-		if (this.#controllers.get(controllerKey) === controller) this.#controllers.delete(controllerKey);
-		if (controller.signal.aborted) return {
-			data: null,
-			error: ""
-		};
-		const latestState = this.#states.get(routeKey) ?? IDLE_ROUTE_STATE;
-		if (error || !result) {
-			const publicError = "The request could not be completed.";
-			this.#setState(routeKey, {
-				...latestState,
-				actionData: null,
-				actionError: publicError,
-				actionState: "idle",
-				navigationState: latestState.loaderState === "loading" ? "loading" : "idle",
-				unexpectedError: true
-			});
-			return {
-				data: null,
-				error: publicError,
-				unexpected: true
-			};
-		}
-		this.#setState(routeKey, {
-			...latestState,
-			actionData: result.data,
-			actionError: result.error,
-			actionState: "idle",
-			navigationState: latestState.loaderState === "loading" ? "loading" : "idle",
-			unexpectedError: false
-		});
-		const actionResult = {
-			data: result.data,
-			error: result.error
-		};
-		const { error: revalidationError, data: shouldRevalidate } = await safeWrapAsync(() => route.shouldRevalidate?.({
-			actionResult: result,
-			defaultShouldRevalidate: Boolean(route.loader),
-			params
-		}) ?? Boolean(route.loader));
-		if (revalidationError) {
-			const publicError = "The request could not be completed.";
-			this.#setState(routeKey, {
-				...this.#states.get(routeKey) ?? IDLE_ROUTE_STATE,
-				actionError: publicError,
-				actionState: "idle",
-				unexpectedError: true
-			});
-			return {
-				data: null,
-				error: publicError,
-				unexpected: true
-			};
-		}
-		if (shouldRevalidate) await this.load(routeId, params, true);
-		return actionResult;
-	}
-	async fetchLoader(routeId, params, signal) {
-		const route = this.#routes.get(routeId);
-		if (!route?.loader) return {
-			data: null,
-			error: "Route loader not found."
-		};
-		const { error, data: result } = await safeWrapAsync(() => route.loader?.({
-			params,
-			signal
-		}));
-		if (signal.aborted) return {
-			data: null,
-			error: ""
-		};
-		if (error || !result) return {
-			data: null,
-			error: "The route could not be loaded.",
-			unexpected: true
-		};
-		return result;
-	}
-	async fetchAction(routeId, input, params, signal) {
-		const route = this.#routes.get(routeId);
-		if (!route?.action) return {
-			data: null,
-			error: "Route action not found."
-		};
-		const { error, data: result } = await safeWrapAsync(() => route.action?.({
-			input,
-			params,
-			signal
-		}));
-		if (signal.aborted) return {
-			data: null,
-			error: ""
-		};
-		if (error || !result) return {
-			data: null,
-			error: "The request could not be completed.",
-			unexpected: true
-		};
-		const { error: revalidationError, data: shouldRevalidate } = await safeWrapAsync(() => route.shouldRevalidate?.({
-			actionResult: result,
-			defaultShouldRevalidate: Boolean(route.loader),
-			params
-		}) ?? Boolean(route.loader));
-		if (signal.aborted) return {
-			data: null,
-			error: ""
-		};
-		if (revalidationError) return {
-			data: null,
-			error: "The request could not be completed.",
-			unexpected: true
-		};
-		if (shouldRevalidate) await this.load(routeId, params, true);
-		return result;
-	}
-	retry(routeId, params) {
-		const routeKey = createRouteKey(routeId, params);
-		this.#states.set(routeKey, IDLE_ROUTE_STATE);
-		this.#notify(routeKey);
-		return this.load(routeId, params, true);
-	}
-	reportUnexpected(routeId, params) {
-		const routeKey = createRouteKey(routeId, params);
-		const currentState = this.#states.get(routeKey) ?? IDLE_ROUTE_STATE;
-		this.#setState(routeKey, {
-			...currentState,
-			unexpectedError: true
-		});
-	}
-	async #runLoader(route, routeKey, params, controller) {
-		const { error, data: result } = await safeWrapAsync(() => route.loader?.({
-			params,
-			signal: controller.signal
-		}) ?? Promise.resolve({
-			data: null,
-			error: ""
-		}));
-		if (this.#controllers.get(routeKey) === controller) {
-			this.#controllers.delete(routeKey);
-			this.#inFlightLoads.delete(routeKey);
-		}
-		if (controller.signal.aborted) return {
-			data: null,
-			error: ""
-		};
-		if (error || !result) {
-			const publicError = "The route could not be loaded.";
-			this.#setState(routeKey, {
-				actionData: null,
-				actionError: "",
-				actionState: "idle",
-				loaderData: null,
-				loaderError: publicError,
-				loaderInitialized: true,
-				loaderState: "idle",
-				navigationState: "idle",
-				unexpectedError: true
-			});
-			return {
-				data: null,
-				error: publicError,
-				unexpected: true
-			};
-		}
-		const currentState = this.#states.get(routeKey) ?? IDLE_ROUTE_STATE;
-		this.#setState(routeKey, {
-			...currentState,
-			loaderData: result.data,
-			loaderError: result.error,
-			loaderInitialized: true,
-			loaderState: "idle",
-			navigationState: currentState.actionState === "submitting" ? "submitting" : "idle",
-			unexpectedError: false
-		});
-		return result;
-	}
-	#replaceController(key) {
-		this.#controllers.get(key)?.abort();
-		const controller = new AbortController();
-		this.#controllers.set(key, controller);
-		return controller;
-	}
-	#setState(routeKey, state) {
-		this.#states.set(routeKey, state);
-		this.#notify(routeKey);
-	}
-	#notify(routeKey) {
-		for (const listener of this.#listeners.get(routeKey) ?? []) listener();
-	}
-};
-function createResourceRouter(routes) {
-	return new ResourceRouter(routes);
-}
-function createRouteKey(routeId, params) {
-	const normalizedParams = Object.entries(params).sort(([left], [right]) => left.localeCompare(right));
-	return `${routeId}:${JSON.stringify(normalizedParams)}`;
-}
-var routeCleanupGraceMs = 100;
-//#endregion
-export { ResourceRouter, createResourceRouter };

package/dist/react/data.d.ts

@@ -1,5 +0,0 @@
-/** Resource subscriptions independent of URL navigation. @module */
-export type { ActionFunctionArgs as ResourceActionArgs, DataResult as ResourceResult, LoaderFunctionArgs as ResourceLoaderArgs, ShouldRevalidateFunctionArgs as ResourceRevalidationArgs, } from "../core/resource-types.ts";
-export { createResourceRouter, ResourceRouter, } from "../core/resources.ts";
-export type { ResourceRouteModule } from "./resources/components.tsx";
-export { Form as ResourceForm, Route as Resource, RouterProvider as ResourceProvider, useActionData as useResourceActionData, useFetcher as useResourceFetcher, useLoaderData as useResourceData, useNavigation as useResourceNavigation, useRevalidator as useResourceRevalidator, useRouteLoaderData, useRouter as useResourceRouter, useSubmit as useResourceSubmit, } from "./resources/components.tsx";

package/dist/react/data.js

@@ -1,3 +0,0 @@
-import { ResourceRouter, createResourceRouter } from "../core/resources.js";
-import { Form, Route, RouterProvider, useActionData, useFetcher, useLoaderData, useNavigation, useRevalidator, useRouteLoaderData, useRouter, useSubmit } from "./resources/components.js";
-export { Route as Resource, Form as ResourceForm, RouterProvider as ResourceProvider, ResourceRouter, createResourceRouter, useActionData as useResourceActionData, useLoaderData as useResourceData, useFetcher as useResourceFetcher, useNavigation as useResourceNavigation, useRevalidator as useResourceRevalidator, useRouter as useResourceRouter, useSubmit as useResourceSubmit, useRouteLoaderData };

package/dist/react/link.js

@@ -1,27 +0,0 @@
-import { internalURL, navigationClick } from "../core/url.js";
-import { createElement } from "./runtime.js";
-import { useRouter } from "./context.js";
-//#region .generated/react/link.ts
-/**
-* React components and typed data hooks. Import from @kasperrt/smolter/react.
-* @module
-*/
-/** Render an anchor that handles internal navigation and preserves native modified clicks. */
-function Link(options) {
-	const { href, replace, onClick, ...props } = options;
-	const router = useRouter();
-	const click = (event) => {
-		onClick?.(event);
-		if (!navigationClick(event, event.currentTarget)) return;
-		if (!internalURL(router.getSnapshot().url, href)) return;
-		event.preventDefault();
-		router.navigate(href, options);
-	};
-	return createElement("a", {
-		...props,
-		href,
-		onClick: click
-	});
-}
-//#endregion
-export { Link };

package/dist/react/resources/components.d.ts

@@ -1,64 +0,0 @@
-/** @jsxImportSource react */
-import type { DataResult, NavigationState, Params, ResourceModule, RouteState } from "../../core/resource-types.ts";
-import type { ResourceRouter } from "../../core/resources.ts";
-import { type ComponentType, type PropsWithChildren } from "react";
-export interface ResourceRouteModule extends ResourceModule {
-    default?: ComponentType;
-    ErrorBoundary?: ComponentType<{
-        retry: () => void;
-    }>;
-    HydrateFallback?: ComponentType;
-}
-interface RouterProviderProps extends PropsWithChildren {
-    initialMatches?: readonly {
-        params?: Params;
-        routeId: string;
-    }[];
-    router: ResourceRouter;
-}
-export declare function RouterProvider({ children, initialMatches, router, }: RouterProviderProps): import("react").JSX.Element;
-interface RouteProps extends PropsWithChildren {
-    params?: Params;
-    persistent?: boolean;
-    routeId: string;
-}
-export declare function Route({ children, params, persistent, routeId, }: RouteProps): import("react").JSX.Element;
-export declare function useLoaderData<Data>(): Data | null;
-export declare function useRouteLoaderData<Data>(routeId: string, params?: Params): Data | null;
-export declare function useActionData<Data>(): Data | null;
-export declare function useNavigation(): {
-    state: NavigationState;
-};
-export declare function useRevalidator(): {
-    revalidate: () => Promise<DataResult<unknown>>;
-    state: string;
-};
-interface FetcherOptions {
-    params?: Params;
-    routeId?: string;
-}
-interface FetcherTarget {
-    params?: Params;
-    routeId?: string;
-}
-interface FormProps extends PropsWithChildren {
-    action?: string;
-    input?: unknown;
-    params?: Params;
-}
-export declare function Form({ action, children, input, params, }: FormProps): import("react").JSX.Element;
-export declare function useSubmit(): (input?: unknown) => Promise<DataResult<unknown>>;
-export declare function useFetcher<Data = unknown>(options?: FetcherOptions): readonly [
-    {
-        data: Data | null;
-        error: string;
-        state: NavigationState;
-    },
-    {
-        Form: ({ children, input, }: Pick<FormProps, "children" | "input">) => import("react").JSX.Element;
-        load: (target?: FetcherTarget) => Promise<DataResult<Data>>;
-        submit: (input: unknown, target?: FetcherTarget) => Promise<DataResult<Data>>;
-    }
-];
-export declare function useRouter(): ResourceRouter;
-export type { NavigationState, RouteState };

package/dist/react/resources/components.js

@@ -1,239 +0,0 @@
-import { Component, createContext, useCallback, useContext, useEffect, useMemo, useRef, useState, useSyncExternalStore } from "react";
-import { jsx } from "react/jsx-runtime";
-//#region .generated/react/resources/components.tsx
-var RouterContext = createContext(null);
-var RouteContext = createContext(null);
-var FormContext = createContext(null);
-function RouterProvider({ children, initialMatches = EMPTY_MATCHES, router }) {
-	useEffect(() => {
-		for (const match of initialMatches) router.load(match.routeId, match.params ?? {});
-		return () => router.dispose();
-	}, [initialMatches, router]);
-	return /* @__PURE__ */ jsx(RouterContext.Provider, {
-		value: router,
-		children
-	});
-}
-function Route({ children, params = {}, persistent = false, routeId }) {
-	const router = useRouter();
-	const stableParams = useStableParams(params);
-	const state = useRouteState(routeId, stableParams, true);
-	const route = router.getRoute(routeId);
-	const retry = useCallback(() => void router.retry(routeId, stableParams), [
-		routeId,
-		router,
-		stableParams
-	]);
-	const contextValue = useMemo(() => ({
-		params: stableParams,
-		routeId
-	}), [routeId, stableParams]);
-	useEffect(() => {
-		if (persistent) router.persist(routeId, stableParams);
-	}, [
-		persistent,
-		routeId,
-		router,
-		stableParams
-	]);
-	let content = children;
-	if (children === void 0 && route?.default) {
-		const RouteComponent = route.default;
-		content = /* @__PURE__ */ jsx(RouteComponent, {});
-	}
-	if (state.unexpectedError && route?.ErrorBoundary) {
-		const ErrorBoundary = route.ErrorBoundary;
-		content = /* @__PURE__ */ jsx(ErrorBoundary, { retry });
-	}
-	if (!state.unexpectedError && !state.loaderInitialized && route?.HydrateFallback) {
-		const HydrateFallback = route.HydrateFallback;
-		content = /* @__PURE__ */ jsx(HydrateFallback, {});
-	}
-	return /* @__PURE__ */ jsx(RouteContext.Provider, {
-		value: contextValue,
-		children: /* @__PURE__ */ jsx(RenderErrorBoundary, {
-			onRetry: retry,
-			resetKey: `${routeId}:${JSON.stringify(stableParams)}`,
-			...route?.ErrorBoundary ? { fallback: route.ErrorBoundary } : {},
-			children: content
-		})
-	});
-}
-function useLoaderData() {
-	const route = useCurrentRoute();
-	return useRouteLoaderData(route.routeId, route.params);
-}
-function useRouteLoaderData(routeId, params = {}) {
-	return useRouteState(routeId, useStableParams(params), true).loaderData;
-}
-function useActionData() {
-	const route = useCurrentRoute();
-	return useRouteState(route.routeId, route.params, false).actionData;
-}
-function useNavigation() {
-	const route = useCurrentRoute();
-	return { state: useRouteState(route.routeId, route.params, false).navigationState };
-}
-function useRevalidator() {
-	const route = useCurrentRoute();
-	const router = useRouter();
-	const state = useRouteState(route.routeId, route.params, false);
-	return useMemo(() => ({
-		revalidate: () => router.load(route.routeId, route.params, true),
-		state: state.navigationState === "loading" ? "loading" : "idle"
-	}), [
-		route,
-		router,
-		state.navigationState
-	]);
-}
-function Form({ action, children, input, params }) {
-	const currentRoute = useContext(RouteContext);
-	const router = useRouter();
-	const routeId = action ?? currentRoute?.routeId ?? "";
-	const routeParams = useStableParams(params ?? currentRoute?.params ?? {});
-	const submit = useCallback((override) => router.submit(routeId, override === void 0 ? input : override, routeParams), [
-		input,
-		routeId,
-		routeParams,
-		router
-	]);
-	if (!routeId) throw new Error("Form requires an action or a parent Route.");
-	return /* @__PURE__ */ jsx(FormContext.Provider, {
-		value: submit,
-		children
-	});
-}
-function useSubmit() {
-	const submit = useContext(FormContext);
-	if (!submit) throw new Error("useSubmit must be used inside Form.");
-	return submit;
-}
-function useFetcher(options = {}) {
-	const currentRoute = useContext(RouteContext);
-	const router = useRouter();
-	const routeId = options.routeId ?? currentRoute?.routeId ?? "";
-	const params = useStableParams(options.params ?? currentRoute?.params ?? {});
-	const [data, setData] = useState(null);
-	const [error, setError] = useState("");
-	const [state, setState] = useState("idle");
-	const controller = useRef(null);
-	useEffect(() => () => {
-		controller.current?.abort();
-	}, []);
-	const run = useCallback(async (mutating, input, target) => {
-		controller.current?.abort();
-		const nextController = new AbortController();
-		const { signal } = nextController;
-		const targetId = target.routeId ?? routeId;
-		const targetParams = target.params ?? params;
-		controller.current = nextController;
-		setError("");
-		setState(mutating ? "submitting" : "loading");
-		const result = await (mutating ? router.fetchAction(targetId, input, targetParams, signal) : router.fetchLoader(targetId, targetParams, signal));
-		if (signal.aborted) return result;
-		controller.current = null;
-		setData(result.data);
-		setError(result.error);
-		setState("idle");
-		if (result.unexpected && currentRoute) router.reportUnexpected(currentRoute.routeId, currentRoute.params);
-		return result;
-	}, [
-		currentRoute,
-		params,
-		routeId,
-		router
-	]);
-	const submit = useCallback((input, target = {}) => run(true, input, target), [run]);
-	const load = useCallback((target = {}) => run(false, void 0, target), [run]);
-	const BoundForm = useCallback(({ children, input }) => /* @__PURE__ */ jsx(FormContext.Provider, {
-		value: (override) => submit(override === void 0 ? input : override),
-		children
-	}), [submit]);
-	if (!routeId) throw new Error("useFetcher requires a routeId or a parent Route.");
-	return [useMemo(() => ({
-		data,
-		error,
-		state
-	}), [
-		data,
-		error,
-		state
-	]), useMemo(() => ({
-		Form: BoundForm,
-		load,
-		submit
-	}), [
-		BoundForm,
-		load,
-		submit
-	])];
-}
-function useRouter() {
-	const router = useContext(RouterContext);
-	if (!router) throw new Error("RouterProvider is missing.");
-	return router;
-}
-function useCurrentRoute() {
-	const route = useContext(RouteContext);
-	if (!route) throw new Error("This hook requires a parent Route.");
-	return route;
-}
-function useRouteState(routeId, params, loadOnMount) {
-	const router = useRouter();
-	const subscribe = useCallback((listener) => router.subscribe(routeId, params, listener), [
-		params,
-		routeId,
-		router
-	]);
-	const getSnapshot = useCallback(() => router.getSnapshot(routeId, params), [
-		params,
-		routeId,
-		router
-	]);
-	const state = useSyncExternalStore(subscribe, getSnapshot, getSnapshot);
-	useEffect(() => {
-		if (loadOnMount) router.load(routeId, params);
-	}, [
-		loadOnMount,
-		params,
-		routeId,
-		router
-	]);
-	return state;
-}
-function useStableParams(params) {
-	const key = JSON.stringify(Object.entries(params).sort(([left], [right]) => left.localeCompare(right)));
-	const ref = useRef({
-		key,
-		value: params
-	});
-	if (ref.current.key !== key) ref.current = {
-		key,
-		value: params
-	};
-	return ref.current.value;
-}
-var RenderErrorBoundary = class extends Component {
-	state = { error: null };
-	static getDerivedStateFromError(error) {
-		return { error };
-	}
-	componentDidUpdate(previousProps) {
-		if (this.state.error && previousProps.resetKey !== this.props.resetKey) this.setState({ error: null });
-	}
-	render() {
-		if (this.state.error && this.props.fallback) {
-			const ErrorBoundary = this.props.fallback;
-			return /* @__PURE__ */ jsx(ErrorBoundary, { retry: () => {
-				this.setState({ error: null });
-				this.props.onRetry();
-			} });
-		}
-		if (this.state.error) throw this.state.error;
-		return this.props.children;
-	}
-};
-var EMPTY_MATCHES = [];
-//#endregion
-export { Form, Route, RouterProvider, useActionData, useFetcher, useLoaderData, useNavigation, useRevalidator, useRouteLoaderData, useRouter, useSubmit };