@kasperrt/smolter 0.2.0 → 0.3.1

package/dist/preact/form.js

@@ -0,0 +1,21 @@
+import { submitForm } from "../core/submission.js";
+import { createElement } from "./runtime.js";
+import { useRouter } from "./context.js";
+//#region .generated/preact/form.ts
+/** Submit form data to a registered route without a document reload. */
+function Form(options) {
+	const { action, method, fetcher, onSubmit, reloadDocument, preventScrollReset, replace, ...props } = options;
+	const router = useRouter();
+	const submit = (event) => {
+		onSubmit?.(event);
+		submitForm(router, event, event.submitter, options, fetcher);
+	};
+	return createElement("form", {
+		...props,
+		action,
+		method: method === "get" ? "get" : "post",
+		onSubmit: submit
+	});
+}
+//#endregion
+export { Form };

package/dist/{internal/preact → preact}/hooks.d.ts

@@ -2,19 +2,20 @@
  * Preact components and typed data hooks. Import from @kasperrt/smolter/preact.
  * @module
  */
-import type { AnyDataFunction, DataOf, RouteModule, Router, Snapshot } from "../core/index.ts";
+import type { AnyDataFunction, RouteModule, Router, Snapshot } from "../core/index.ts";
+import type { RouteData } from "./route-types.ts";
 /** A route module or loader function used for data inference. */
 export type LoaderSource = RouteModule | AnyDataFunction;
 /** Infer server and client loader data from a route module or function. */
-export type LoaderData<T> = T extends AnyDataFunction ? DataOf<T> : T extends RouteModule ? DataOf<Extract<T["loader"] | T["clientLoader"], AnyDataFunction>> : unknown;
+export type LoaderData<T> = T extends AnyDataFunction ? RouteData<T> : T extends RouteModule ? RouteData<Extract<T["loader"] | T["clientLoader"], AnyDataFunction>> : RouteData<T>;
 /** Infer server and client action data from a route module or function. */
-export type ActionData<T> = T extends AnyDataFunction ? DataOf<T> : T extends RouteModule ? DataOf<Extract<T["action"] | T["clientAction"], AnyDataFunction>> : unknown;
+export type ActionData<T> = T extends AnyDataFunction ? RouteData<T> : T extends RouteModule ? RouteData<Extract<T["action"] | T["clientAction"], AnyDataFunction>> : RouteData<T>;
 /** Pass a route for inference, or use useLoaderData<typeof loader>() in its module. */
-export declare function useLoaderData<T extends LoaderSource = RouteModule>(route?: T): LoaderData<T> | undefined;
+export declare function useLoaderData<T = RouteModule>(route?: T & LoaderSource): LoaderData<T>;
 /** Read the last page action result, optionally inferring its type from a route. */
-export declare function useActionData<T extends LoaderSource = RouteModule>(route?: T): ActionData<T> | undefined;
+export declare function useActionData<T = RouteModule>(route?: T & LoaderSource): ActionData<T> | undefined;
 /** Read path parameters for the active route. */
-export declare function useParams(): Snapshot["params"];
+export declare function useParams<T extends Snapshot["params"] = Snapshot["params"]>(): T;
 /** Read the current path, search, and hash together with the navigate function. */
 export declare function useLocation(): readonly [string, Router["navigate"]];
 /** Get the function that revalidates the current loader subject to shouldRevalidate. */

package/dist/preact/hooks.js

@@ -0,0 +1,25 @@
+import { useRouter, useSnapshot } from "./context.js";
+//#region .generated/preact/hooks.ts
+/** Pass a route for inference, or use useLoaderData<typeof loader>() in its module. */
+function useLoaderData(route) {
+	return useSnapshot("data", route?.path);
+}
+/** Read the last page action result, optionally inferring its type from a route. */
+function useActionData(route) {
+	return useSnapshot("actionData", route?.path);
+}
+/** Read path parameters for the active route. */
+function useParams() {
+	return useSnapshot("params");
+}
+/** Read the current path, search, and hash together with the navigate function. */
+function useLocation() {
+	const router = useRouter();
+	return [useSnapshot("url").replace(/^\w+:\/\/[^/]+/, ""), router.navigate];
+}
+/** Get the function that revalidates the current loader subject to shouldRevalidate. */
+function useRevalidator() {
+	return useRouter().revalidate;
+}
+//#endregion
+export { useActionData, useLoaderData, useLocation, useParams, useRevalidator };

package/dist/preact/index.d.ts

@@ -0,0 +1,18 @@
+/** Framework components and typed data hooks. @module */
+export type * from "../core/index.ts";
+export { createDataRouter, createRouter, defineRoute, } from "../core/index.ts";
+export type { ApplicationEnvironment } from "../core/environment.ts";
+export * from "../core/responses.ts";
+export type { Submission, SubmissionOptions } from "../core/submission.ts";
+export { readSubmission } from "../core/submission.ts";
+export { Await } from "./await.tsx";
+export { RouterProvider, type RouterProviderProps, useRouter, } from "./context.ts";
+export * from "./fetcher.ts";
+export * from "./form.ts";
+export * from "./hooks.ts";
+export type { NavigateOptions } from "./navigation.tsx";
+export * from "./navigation.tsx";
+export { useMatches, useNavigation, useOutletContext, useRootData, useRouteError, useRouteLoaderData, useSubmit, } from "./route-hooks.tsx";
+export * from "./route-types.ts";
+export { Outlet, RouterApplication } from "./router.tsx";
+export * from "./routes.ts";

package/dist/preact/index.js

@@ -0,0 +1,15 @@
+import { defineRoute } from "../core/match.js";
+import { createRouter } from "../core/navigation-router.js";
+import { createDataRouter } from "../core/router.js";
+import { readSubmission } from "../core/submission.js";
+import { data, isRouteErrorResponse, normalizeResult, redirect, resolveData } from "../core/responses.js";
+import { Await } from "./await.js";
+import { RouterProvider, useRouter } from "./context.js";
+import { Form } from "./form.js";
+import { useFetcher } from "./fetcher.js";
+import { useActionData, useLoaderData, useLocation, useParams, useRevalidator } from "./hooks.js";
+import { useMatches, useNavigate, useNavigation, useNavigationType, useOutletContext, useRootData, useRouteError, useRouteLoaderData, useSearchParams, useSubmit, useURLLocation } from "./route-hooks.js";
+import { Link, NavLink } from "./navigation.js";
+import { Routes } from "./routes.js";
+import { Outlet, RouterApplication } from "./router.js";
+export { Await, Form, Link, NavLink, Outlet, RouterApplication, RouterProvider, Routes, createDataRouter, createRouter, data, defineRoute, isRouteErrorResponse, normalizeResult, readSubmission, redirect, resolveData, useActionData, useFetcher, useLoaderData, useLocation, useMatches, useNavigate, useNavigation, useNavigationType, useOutletContext, useParams, useRevalidator, useRootData, useRouteError, useRouteLoaderData, useRouter, useSearchParams, useSubmit, useURLLocation };

package/dist/preact/lazy-route.d.ts

@@ -0,0 +1,19 @@
+import type { RouteModule } from "../core/index.ts";
+import { type ComponentType } from "preact";
+import type { AppRoute } from "./route-types.ts";
+export interface LazyRouteOptions {
+    path: string;
+    id?: string;
+    loader?: boolean;
+    action?: boolean;
+    clientAction?: boolean;
+    meta?: boolean;
+    shouldRevalidate?: boolean;
+    ErrorBoundary?: boolean;
+}
+type LoadedRoute = RouteModule & Pick<AppRoute, "meta">;
+interface LazyAppRoute extends AppRoute {
+    resolveComponent: () => ComponentType | undefined;
+}
+export declare function lazyRoute(options: LazyRouteOptions, importer: () => Promise<LoadedRoute>): LazyAppRoute;
+export {};

package/dist/preact/lazy-route.js

@@ -0,0 +1,51 @@
+import { useSyncExternalStore } from "./runtime.js";
+import { useRouter } from "./context.js";
+import { serverRoute } from "../client/index.js";
+import { createElement } from "preact";
+//#region .generated/preact/lazy-route.ts
+function LazyView() {
+	const router = useRouter();
+	const { path } = useSyncExternalStore(router.subscribe, router.getSnapshot);
+	const Component = router.routes.find((item) => item.path === path)?.resolveComponent();
+	return Component && createElement(Component, {});
+}
+function lazyRoute(options, importer) {
+	let module;
+	let pending;
+	function preload() {
+		pending ??= importer().then((loaded) => {
+			module = serverRoute(options.path, loaded, {
+				loader: options.loader,
+				action: options.action
+			});
+		}).catch((error) => {
+			pending = void 0;
+			throw error;
+		});
+		return pending;
+	}
+	async function run(args, action = false) {
+		await preload();
+		if (args.signal.aborted) return /* @__PURE__ */ new Error("Navigation cancelled");
+		return (action ? module.clientAction ?? module.action : module.clientLoader ?? module.loader)?.(args);
+	}
+	function ErrorBoundary(props) {
+		const Component = module?.ErrorBoundary;
+		if (!Component) return props.error.message;
+		return createElement(Component, props);
+	}
+	return {
+		path: options.path,
+		id: options.id,
+		preload,
+		default: LazyView,
+		resolveComponent: () => module?.default,
+		clientLoader: (args) => run(args),
+		...(options.action || options.clientAction) && { clientAction: (args) => run(args, true) },
+		...options.meta && { meta: (args) => module?.meta?.(args) ?? [] },
+		...options.shouldRevalidate && { shouldRevalidate: (args) => module?.shouldRevalidate?.(args) ?? true },
+		...options.ErrorBoundary && { ErrorBoundary }
+	};
+}
+//#endregion
+export { lazyRoute };

package/dist/preact/navigation-state.d.ts

@@ -0,0 +1,2 @@
+import type { Router } from "../core/index.ts";
+export declare function useNavigationSnapshot(router: Router): import("../core/navigation.ts").NavigationSnapshot;

package/dist/preact/navigation-state.js

@@ -0,0 +1,9 @@
+import { useSyncExternalStore } from "./runtime.js";
+import { navigationStore } from "../core/navigation.js";
+//#region .generated/preact/navigation-state.ts
+function useNavigationSnapshot(router) {
+	const store = navigationStore(router);
+	return useSyncExternalStore(store.subscribe, store.getSnapshot);
+}
+//#endregion
+export { useNavigationSnapshot };

package/dist/preact/navigation.d.ts

@@ -0,0 +1,28 @@
+import { type NavigateOptions } from "../core/index.ts";
+import type { ComponentProps, ReactNode } from "preact/compat";
+export type { NavigateOptions } from "../core/index.ts";
+export type { NavigationType } from "../core/navigation.ts";
+export type NavigateFunction = (to: string | number | Partial<Pick<URL, "pathname" | "search" | "hash">>, options?: NavigateOptions) => void;
+export interface LinkProps extends Omit<ComponentProps<"a">, "href" | "role"> {
+    to?: string;
+    href?: string;
+    replace?: boolean;
+    role?: "link" | "button" | "checkbox" | "menuitem" | "menuitemcheckbox" | "menuitemradio" | "option" | "radio" | "switch" | "tab" | "treeitem" | "doc-backlink" | "doc-biblioref" | "doc-glossref" | "doc-noteref";
+    prefetch?: string;
+    state?: unknown;
+    preventScrollReset?: boolean;
+    viewTransition?: boolean;
+    reloadDocument?: boolean;
+}
+export interface NavLinkRenderProps {
+    isActive: boolean;
+    isPending: boolean;
+}
+export interface NavLinkProps extends Omit<LinkProps, "className" | "children"> {
+    end?: boolean;
+    className?: string | ((state: NavLinkRenderProps) => string);
+    children?: ReactNode | ((state: NavLinkRenderProps) => ReactNode);
+}
+export declare function Link(options: LinkProps): ReactNode;
+export declare function NavLink({ href, to, end, className, children, ...props }: NavLinkProps): ReactNode;
+export { useNavigate, useNavigationType, useSearchParams, useURLLocation, } from "./route-hooks.tsx";

package/dist/preact/navigation.js

@@ -0,0 +1,60 @@
+import { matchRoutes } from "../core/match.js";
+import { navigationClick } from "../core/url.js";
+import { createElement } from "./runtime.js";
+import { useRouter, useSnapshot } from "./context.js";
+import { handoffDocument, resolveApplicationURL } from "../core/environment.js";
+import { useNavigate, useNavigationType, useSearchParams, useURLLocation } from "./route-hooks.js";
+//#region .generated/preact/navigation.tsx
+function Link(options) {
+	const { href: hrefProp, to = hrefProp ?? "/", replace, preventScrollReset, viewTransition, prefetch, state, reloadDocument, ...props } = options;
+	const router = useRouter();
+	const current = new URL(useSnapshot("url"));
+	const destination = resolveApplicationURL(new URL(to, current));
+	const internal = destination.origin === current.origin;
+	const preload = () => {
+		(matchRoutes(router.routes, destination.pathname)?.route)?.preload?.().catch(() => {});
+	};
+	if (!reloadDocument && prefetch !== "none" && internal) for (const name of [
+		"onPointerEnter",
+		"onFocus",
+		"onTouchStart"
+	]) {
+		const handler = props[name];
+		props[name] = (event) => {
+			handler?.(event);
+			preload();
+		};
+	}
+	return createElement("a", {
+		...props,
+		href: destination.href,
+		onClick(event) {
+			props.onClick?.(event);
+			if (reloadDocument || !navigationClick(event, event.currentTarget)) return;
+			if (!internal) {
+				handoffDocument(event, destination);
+				return;
+			}
+			event.preventDefault();
+			router.navigate(destination.href, options);
+		}
+	});
+}
+function NavLink({ href, to = href ?? "/", end, className, children, ...props }) {
+	const location = useURLLocation();
+	const target = new URL(to, location.href).pathname;
+	const isActive = location.pathname === target || !end && target !== "/" && location.pathname.startsWith(`${target}/`);
+	const state = {
+		isActive,
+		isPending: false
+	};
+	return createElement(Link, {
+		...props,
+		to,
+		className: typeof className === "function" ? className(state) : className,
+		...isActive && { "aria-current": "page" },
+		children: typeof children === "function" ? children(state) : children
+	});
+}
+//#endregion
+export { Link, NavLink, useNavigate, useNavigationType, useSearchParams, useURLLocation };

package/dist/preact/root-context.d.ts

@@ -0,0 +1,13 @@
+import type { Router } from "../core/index.ts";
+import type { AppRoute, Hydration, RootModule } from "./route-types.ts";
+export interface ApplicationContext {
+    router: Router;
+    routes: AppRoute[];
+    root: unknown;
+    rootModule?: RootModule;
+    hydration?: Hydration;
+    entry?: string;
+}
+export declare const Application: import("preact").Context<ApplicationContext | null>;
+export declare const OutletContext: import("preact").Context<unknown>;
+export declare function useApplication(): ApplicationContext;

package/dist/preact/root-context.js

@@ -0,0 +1,9 @@
+import { createContext, useContext } from "./runtime.js";
+//#region .generated/preact/root-context.ts
+var Application = createContext(null);
+var OutletContext = createContext(void 0);
+function useApplication() {
+	return useContext(Application);
+}
+//#endregion
+export { Application, OutletContext, useApplication };

package/dist/preact/root-data.d.ts

@@ -0,0 +1,8 @@
+import type { Router } from "../core/index.ts";
+import type { RootModule } from "./route-types.ts";
+export { createStore as createRootStore } from "../core/store.ts";
+export declare function attachRootData(router: Router, initial: unknown, rootModule?: RootModule): {
+    getSnapshot: () => unknown;
+    subscribe(listener: () => void): () => void;
+    update(next: unknown): void;
+};

package/dist/preact/root-data.js

@@ -0,0 +1,28 @@
+import { createStore } from "../core/store.js";
+//#region .generated/preact/root-data.ts
+function attachRootData(router, initial, rootModule) {
+	const store = createStore(initial);
+	const loaderPath = rootModule?.loaderPath;
+	if (!rootModule || !loaderPath) return store;
+	let pending;
+	const unregister = router.registerRevalidator(rootModule.id ?? "root", async (args) => {
+		if (rootModule.shouldRevalidate?.(args) === false) return;
+		pending?.dispose();
+		const fetcher = router.createFetcher();
+		pending = fetcher;
+		const result = await fetcher.load(loaderPath);
+		if (pending === fetcher && !result.error) store.update(result.data);
+		fetcher.dispose();
+		if (pending === fetcher) pending = void 0;
+	});
+	const dispose = router.dispose;
+	router.dispose = () => {
+		pending?.dispose();
+		pending = void 0;
+		unregister();
+		dispose();
+	};
+	return store;
+}
+//#endregion
+export { attachRootData, createStore as createRootStore };

package/dist/preact/route-hooks.d.ts

@@ -0,0 +1,32 @@
+import type { NavigateOptions } from "../core/index.ts";
+import type { NavigationType } from "../core/navigation.ts";
+import { type Submission, type SubmissionOptions } from "../core/submission.ts";
+import { useSnapshot } from "./context.ts";
+import type { NavigateFunction } from "./navigation.tsx";
+import type { RouteData } from "./route-types.ts";
+export declare function useRootData<T = unknown>(): RouteData<T>;
+/** Read root data or the active route's data by its manifest identifier. */
+export declare function useRouteLoaderData<T = unknown>(id: string): RouteData<T> | undefined;
+export { useSnapshot };
+export declare function useRouteError(): Error | undefined;
+export declare function useNavigation(): {
+    state: "idle" | "loading" | "submitting";
+    location: URL | undefined;
+};
+export declare function useMatches(): {
+    id: string;
+    data: unknown;
+    params: import("../core/index.ts").Params;
+}[];
+export declare function useOutletContext<T>(): T;
+export declare function useSubmit(): (value: Submission, options?: SubmissionOptions) => Promise<void> | Promise<import("../core/index.ts").Result<unknown>>;
+export declare function useURLLocation(): URL & {
+    state: unknown;
+    key: string;
+};
+export declare function useNavigate(): NavigateFunction;
+export declare function useSearchParams(): [
+    URLSearchParams,
+    (value: URLSearchParams | Record<string, string>, options?: NavigateOptions) => void
+];
+export declare function useNavigationType(): NavigationType;

package/dist/preact/route-hooks.js

@@ -0,0 +1,94 @@
+import { submissionBody, submissionSearch } from "../core/submission.js";
+import { useContext, useMemo } from "./runtime.js";
+import { useRouter, useSnapshot } from "./context.js";
+import { pendingLocation } from "../core/presentation.js";
+import { useNavigationSnapshot } from "./navigation-state.js";
+import { OutletContext, useApplication } from "./root-context.js";
+import { useCallback } from "preact/hooks";
+//#region .generated/preact/route-hooks.tsx
+function useRootData() {
+	return useApplication().root;
+}
+/** Read root data or the active route's data by its manifest identifier. */
+function useRouteLoaderData(id) {
+	const app = useApplication();
+	const snapshot = useSnapshot();
+	if (id === "root") return app.root;
+	const route = app.routes.find((item) => item.id === id);
+	if (!route || route.path !== snapshot.path) return void 0;
+	return snapshot.data;
+}
+function useRouteError() {
+	return useSnapshot("error");
+}
+function useNavigation() {
+	const router = useRouter();
+	const snapshot = useSnapshot();
+	const location = pendingLocation(router);
+	return useMemo(() => ({
+		state: snapshot.state,
+		location
+	}), [snapshot.state, location?.href]);
+}
+function useMatches() {
+	const { routes } = useApplication();
+	const snapshot = useSnapshot();
+	return [{
+		id: routes.find((item) => item.path === snapshot.path)?.id ?? "",
+		data: snapshot.data,
+		params: snapshot.params
+	}];
+}
+function useOutletContext() {
+	return useContext(OutletContext);
+}
+function useSubmit() {
+	const router = useRouter();
+	return useCallback((value, options = {}) => {
+		const body = submissionBody(value, options.encType);
+		const method = options.method?.toUpperCase();
+		const target = options.action ?? router.getSnapshot().url;
+		if (method === "GET") {
+			const url = new URL(target, router.getSnapshot().url);
+			url.search = submissionSearch(body);
+			return router.navigate(url.href, options);
+		}
+		return router.submit(target, body, { method });
+	}, [router]);
+}
+function useURLLocation() {
+	const href = useSnapshot("url");
+	const snapshot = useNavigationSnapshot(useRouter());
+	return useMemo(() => Object.assign(new URL(href), {
+		state: snapshot.state,
+		key: snapshot.key
+	}), [
+		href,
+		snapshot.state,
+		snapshot.key
+	]);
+}
+function useNavigate() {
+	const router = useRouter();
+	return useCallback((to, options) => {
+		if (typeof to === "number") {
+			window.history.go(to);
+			return;
+		}
+		const current = new URL(router.getSnapshot().url);
+		const target = typeof to === "string" ? to : `${to.pathname ?? current.pathname}${to.search ?? current.search}${to.hash ?? current.hash}`;
+		router.navigate(target, options);
+	}, [router]);
+}
+function useSearchParams() {
+	const location = useURLLocation();
+	const navigate = useNavigate();
+	return [useMemo(() => new URLSearchParams(location.search), [location.search]), useCallback((value, options) => {
+		navigate(`${location.pathname}?${new URLSearchParams(value)}`, options);
+	}, [location.pathname, navigate])];
+}
+function useNavigationType() {
+	return useNavigationSnapshot(useRouter()).type;
+}
+//#endregion
+export { useMatches, useNavigate, useNavigation, useNavigationType, useOutletContext, useRootData, useRouteError, useRouteLoaderData, useSearchParams, useSnapshot, useSubmit, useURLLocation };

package/dist/preact/route-types.d.ts

@@ -0,0 +1,54 @@
+import type { DataArgs, RevalidationArgs, Route, Snapshot } from "../core/index.ts";
+import type { DataResponse } from "../core/responses.ts";
+import type { ComponentType, ReactNode } from "preact/compat";
+export interface LoaderFunctionArgs extends DataArgs {
+    context?: unknown;
+}
+export type ActionFunctionArgs = LoaderFunctionArgs;
+export interface ClientLoaderFunctionArgs extends LoaderFunctionArgs {
+    serverLoader: <T = unknown>() => Promise<T>;
+}
+export interface ClientActionFunctionArgs extends LoaderFunctionArgs {
+    serverAction: <T = unknown>() => Promise<T>;
+}
+export type ShouldRevalidateFunctionArgs = RevalidationArgs;
+type UnwrapData<T> = T extends DataResponse<infer V> ? V : T;
+export type RouteData<T> = T extends (...args: never[]) => infer R ? UnwrapData<Exclude<Awaited<R>, Response | Error>> : T;
+export type MetaDescriptor = Record<string, unknown>;
+export interface MetaArgs<T> {
+    data: RouteData<T> | undefined;
+    loaderData: RouteData<T> | undefined;
+    error?: unknown;
+    params: Record<string, string>;
+    location: URL;
+}
+export type MetaFunction<T = unknown> = (args: MetaArgs<T>) => MetaDescriptor[];
+export type LinksFunction = () => Record<string, string>[];
+export interface AppRoute extends Route {
+    resolveComponent?: () => ComponentType | undefined;
+    preload?: () => Promise<void>;
+    id?: string;
+    routePath?: string;
+    meta?: MetaFunction;
+}
+export interface RootModule {
+    /** Route identity used by targeted revalidation. Defaults to root. */
+    id?: string;
+    /** Optional registered route URL used to revalidate root data after mutations. */
+    loaderPath?: string;
+    ErrorBoundary?: ComponentType;
+    default: ComponentType;
+    Layout: ComponentType<{
+        children: ReactNode;
+    }>;
+    loader?: (args: LoaderFunctionArgs) => unknown;
+    links?: LinksFunction;
+    meta?: MetaFunction;
+    shouldRevalidate?: (args: RevalidationArgs) => boolean;
+}
+export interface Hydration {
+    root: unknown;
+    snapshot: Snapshot;
+}
+export type HandleDataRequestFunction = (response: Response, args: LoaderFunctionArgs) => Response | Promise<Response>;
+export {};

package/dist/preact/router.d.ts

@@ -0,0 +1,16 @@
+/** @jsxImportSource preact */
+import type { ReactNode } from "preact/compat";
+import { type ApplicationContext } from "./root-context.ts";
+import { createRootStore } from "./root-data.ts";
+import type { AppRoute } from "./route-types.ts";
+export interface OutletProps {
+    context?: unknown;
+    children?: ReactNode;
+}
+export declare function Outlet({ context, children, }: OutletProps): import("preact").JSX.Element;
+export interface ApplicationProps extends ApplicationContext {
+    document?: boolean;
+    rootStore?: ReturnType<typeof createRootStore>;
+}
+export declare function RouterApplication(props: ApplicationProps): import("preact").JSX.Element;
+export declare function prepareRoutes(routes: AppRoute[]): AppRoute[];

package/dist/preact/router.js

@@ -0,0 +1,63 @@
+import { normalizeResult } from "../core/responses.js";
+import { useContext, useMemo, useSyncExternalStore } from "./runtime.js";
+import { RouterProvider } from "./context.js";
+import { createStore } from "../core/store.js";
+import { Application, OutletContext } from "./root-context.js";
+import { Routes } from "./routes.js";
+import { jsx } from "preact/jsx-runtime";
+//#region .generated/preact/router.tsx
+function Outlet({ context, children }) {
+	const current = useContext(OutletContext);
+	return /* @__PURE__ */ jsx(OutletContext, {
+		value: context ?? current,
+		children: children ?? /* @__PURE__ */ jsx(Routes, { fallback: /* @__PURE__ */ jsx("p", {
+			role: "status",
+			children: "Loading…"
+		}) })
+	});
+}
+function RouterApplication(props) {
+	const rootStore = useMemo(() => props.rootStore ?? createStore(props.root), [props.rootStore, props.root]);
+	const root = useSyncExternalStore(rootStore.subscribe, rootStore.getSnapshot);
+	const snapshot = useSyncExternalStore(props.router.subscribe, props.router.getSnapshot);
+	const route = props.routes.find((item) => item.path === snapshot.path);
+	const Root = snapshot.error && !route?.ErrorBoundary ? props.rootModule?.ErrorBoundary ?? Outlet : props.rootModule?.default ?? Outlet;
+	const Layout = props.rootModule?.Layout;
+	const children = /* @__PURE__ */ jsx(Root, {});
+	return /* @__PURE__ */ jsx(RouterProvider, {
+		router: props.router,
+		children: /* @__PURE__ */ jsx(Application, {
+			value: {
+				...props,
+				root
+			},
+			children: props.document ? Layout && /* @__PURE__ */ jsx(Layout, { children }) : children
+		})
+	});
+}
+function prepareRoutes(routes) {
+	return routes.map((route) => {
+		const wrapped = {
+			...route,
+			path: route.routePath ?? route.path,
+			shouldRevalidate: (args) => {
+				const { currentUrl, nextUrl } = args;
+				if (args.reason === "navigation" && currentUrl.pathname === nextUrl.pathname && currentUrl.search === nextUrl.search && currentUrl.hash !== nextUrl.hash) return false;
+				return route.shouldRevalidate?.(args) ?? args.defaultShouldRevalidate;
+			}
+		};
+		for (const key of [
+			"loader",
+			"action",
+			"clientLoader",
+			"clientAction"
+		]) {
+			const handler = route[key];
+			if (!handler) continue;
+			wrapped[key] = (args) => Promise.resolve().then(() => handler(args)).then(normalizeResult, normalizeResult);
+		}
+		return wrapped;
+	});
+}
+//#endregion
+export { Outlet, RouterApplication, prepareRoutes };

package/dist/{internal/preact → preact}/routes.d.ts

@@ -3,7 +3,7 @@
  * @module
  */
 import type { RouteModule } from "../core/index.ts";
-import type { ComponentType, ReactNode } from "./runtime.ts";
+import { type ComponentType, type ReactNode } from "./runtime.ts";
 /** Renderable route module with optional loading and error components. */
 export interface ViewModule extends RouteModule {
     default?: ComponentType;

package/dist/preact/routes.js

@@ -0,0 +1,12 @@
+import { createElement, useMemo } from "./runtime.js";
+import { useRouter, useSnapshot } from "./context.js";
+//#region .generated/preact/routes.ts
+/** Renders the first matching registered module. */
+function Routes({ fallback }) {
+	const router = useRouter();
+	const state = useSnapshot();
+	const component = router.routes.find((route) => route.path === state.path)?.[state.error ? "ErrorBoundary" : state.state === "loading" && !state.loaded ? "HydrateFallback" : "default"];
+	return useMemo(() => component && createElement(component, { error: state.error }), [component, state.error]) ?? state.error?.message ?? fallback;
+}
+//#endregion
+export { Routes };

package/dist/{internal/preact → preact}/runtime.js

@@ -1 +1 @@
-export { createContext, createElement, useContext, useEffect, useMemo, useSyncExternalStore, } from "preact/compat";
+export { createContext, createElement, useContext, useEffect, useMemo, useSyncExternalStore } from "preact/compat";