@kasperrt/smolter 0.2.0 → 0.3.0

package/dist/core/router.js

@@ -0,0 +1,204 @@
+import { safeWrapAsync } from "./errors.js";
+import { matchRoutes } from "./match.js";
+import { internalURL } from "./url.js";
+//#region .generated/core/router.ts
+/** Create an isolated router. Use browser: true for browser history, or loadRouter for SSR. */
+function createDataRouter(routes, options = {}) {
+	const browser = options.browser && typeof window !== "undefined";
+	const hydrated = options.hydrationData?.state === "idle";
+	const initial = {
+		loaded: hydrated,
+		...options.hydrationData ?? {
+			url: new URL(options.url ?? (browser ? location.href : "/"), "http://localhost").href,
+			params: {},
+			state: "idle"
+		}
+	};
+	const revalidators = /* @__PURE__ */ new Set();
+	const channel = (initial, local) => {
+		let snapshot = initial;
+		let loadedURL;
+		let submission;
+		let controller;
+		const listeners = /* @__PURE__ */ new Set();
+		const emit = (state, next) => {
+			snapshot = {
+				...snapshot,
+				...next,
+				state
+			};
+			for (const listener of listeners) listener();
+		};
+		const run = async (href, body, operation = {}, navigation, redirects = 10) => {
+			controller?.abort();
+			controller = new AbortController();
+			const { signal } = controller;
+			const { method = "POST" } = operation;
+			revalidators.add(task);
+			submission = body;
+			const previous = snapshot;
+			const url = internalURL(main.getSnapshot().url, href);
+			const match = url && matchRoutes(routes, url.pathname);
+			const commit = () => {
+				if (local || !url) return;
+				const changed = snapshot.url !== url.href;
+				if (!changed && snapshot.path !== void 0) return;
+				if (browser && (navigation || body) && changed) history[operation.replace ? "replaceState" : "pushState"](null, "", url);
+				const sameRoute = snapshot.path === match?.route.path;
+				snapshot = {
+					...snapshot,
+					url: url.href,
+					path: match?.route.path,
+					params: match?.params ?? {},
+					actionData: void 0,
+					...!sameRoute && {
+						data: void 0,
+						loaded: false
+					}
+				};
+			};
+			if (!body) commit();
+			emit(body ? "submitting" : "loading", { error: void 0 });
+			const result = await safeWrapAsync(() => {
+				if (!match) return Error(url ? "No route" : "External URL");
+				if (navigation !== void 0 && previous.loaded && !previous.error && previous.path === match.route.path && match.route.shouldRevalidate?.({
+					url,
+					currentUrl: new URL(previous.url),
+					nextUrl: url,
+					defaultShouldRevalidate: true,
+					reason: "navigation"
+				}) === false) return previous.data;
+				const fn = match.route[body ? "clientAction" : "clientLoader"] || match.route[body ? "action" : "loader"];
+				if (!fn) return body && Error("No action");
+				return fn({
+					request: new Request(url, {
+						signal,
+						method: body && method,
+						body
+					}),
+					params: match.params,
+					signal
+				});
+			});
+			if (signal.aborted) return result;
+			const redirectTo = result.data instanceof Response && result.data.headers.get("Location");
+			if (redirectTo && redirects) {
+				await main.load(new URL(redirectTo, url).href, void 0, { replace: true }, true, redirects - 1);
+				if (!signal.aborted) {
+					submission = void 0;
+					emit("idle");
+				}
+				return result;
+			}
+			if (redirectTo) result.error = Error("Redirect loop");
+			if (!body && !result.error) loadedURL = url.href;
+			if (body && !result.error) commit();
+			emit(body && !result.error ? "loading" : "idle", {
+				[body && !local ? "actionData" : "data"]: result.data,
+				error: result.error,
+				loaded: body ? snapshot.loaded : !result.error
+			});
+			if (body && !result.error) {
+				await router.revalidate("action", {
+					formMethod: method,
+					formAction: url.href,
+					formData: body,
+					actionResult: result.data
+				}).finally(() => {
+					if (!signal.aborted) {
+						submission = void 0;
+						emit("idle");
+					}
+				});
+				return result;
+			}
+			if (!signal.aborted) submission = void 0;
+			return result;
+		};
+		const task = {
+			revalidate: async (args, targets) => {
+				if (local && (!loadedURL || submission)) return;
+				const url = new URL(local ? loadedURL : main.getSnapshot().url);
+				const route = matchRoutes(routes, url.pathname)?.route;
+				if (!route || targets && !targets.includes(route.id) && !targets.includes(route.path)) return;
+				if (route.shouldRevalidate?.({
+					...args,
+					url,
+					currentUrl: url,
+					nextUrl: url
+				}) === false) return;
+				return run(url.href);
+			},
+			getSnapshot: () => snapshot,
+			subscribe(listener) {
+				listeners.add(listener);
+				return () => {
+					listeners.delete(listener);
+				};
+			},
+			load: run,
+			submit: run,
+			dispose() {
+				controller?.abort();
+				listeners.clear();
+				revalidators.delete(task);
+			}
+		};
+		revalidators.add(task);
+		return task;
+	};
+	const main = channel(initial);
+	let started = 0;
+	const pop = () => main.load(location.href, void 0, void 0, false);
+	const router = {
+		...main,
+		routes,
+		start() {
+			if (!started++ && browser) addEventListener("popstate", pop);
+			if (!hydrated && main.getSnapshot() === initial) main.load(initial.url);
+			return () => {
+				if (!--started && browser) removeEventListener("popstate", pop);
+			};
+		},
+		async navigate(url, operation) {
+			await main.load(url, void 0, operation, true);
+		},
+		async revalidate(options = {}, context) {
+			const { route, reason = "manual", ...details } = typeof options === "string" ? {
+				reason: options,
+				...context
+			} : options;
+			const url = new URL(main.getSnapshot().url);
+			const args = {
+				...details,
+				url,
+				currentUrl: url,
+				nextUrl: url,
+				defaultShouldRevalidate: true,
+				reason
+			};
+			const targets = typeof route === "string" ? [route] : route;
+			await Promise.all([...revalidators].map((refresh) => refresh.revalidate(args, targets)));
+		},
+		registerRevalidator(id, refresh) {
+			const task = { revalidate: async (args, targets) => {
+				if (!targets || targets.includes(id)) return refresh(args);
+			} };
+			revalidators.add(task);
+			return () => {
+				revalidators.delete(task);
+			};
+		},
+		createFetcher() {
+			return channel({ state: "idle" }, true);
+		},
+		dispose() {
+			for (const refresh of revalidators) refresh.dispose?.();
+			revalidators.clear();
+			if (browser) removeEventListener("popstate", pop);
+		}
+	};
+	return router;
+}
+//#endregion
+export { createDataRouter };

package/dist/{internal/core → core}/serialize.d.ts

@@ -1,3 +1,5 @@
 import type { Snapshot } from "./types.ts";
 /** Safe inside a script element. Data must be JSON serializable; error stacks and causes are omitted. */
 export declare function serialize(snapshot: Snapshot): string;
+/** Encode JSON for embedding inside an HTML script element. */
+export declare function serializeData(value: unknown): string;

package/dist/core/serialize.js

@@ -0,0 +1,17 @@
+//#region .generated/core/serialize.ts
+/** Safe inside a script element. Data must be JSON serializable; error stacks and causes are omitted. */
+function serialize(snapshot) {
+	return serializeData({
+		...snapshot,
+		error: snapshot.error && {
+			name: snapshot.error.name,
+			message: snapshot.error.message
+		}
+	});
+}
+/** Encode JSON for embedding inside an HTML script element. */
+function serializeData(value) {
+	return JSON.stringify(value).replace(/</g, "\\u003c").replace(/\u2028/g, "\\u2028").replace(/\u2029/g, "\\u2029");
+}
+//#endregion
+export { serialize, serializeData };

package/dist/core/store.d.ts

@@ -0,0 +1,6 @@
+/** Small observable value shared by layout data and navigation state. */
+export declare function createStore<T>(initial: T): {
+    getSnapshot: () => T;
+    subscribe(listener: () => void): () => void;
+    update(next: T): void;
+};

package/dist/core/store.js

@@ -0,0 +1,21 @@
+//#region .generated/core/store.ts
+/** Small observable value shared by layout data and navigation state. */
+function createStore(initial) {
+	let value = initial;
+	const listeners = /* @__PURE__ */ new Set();
+	return {
+		getSnapshot: () => value,
+		subscribe(listener) {
+			listeners.add(listener);
+			return () => {
+				listeners.delete(listener);
+			};
+		},
+		update(next) {
+			value = next;
+			for (const listener of listeners) listener();
+		}
+	};
+}
+//#endregion
+export { createStore };

package/dist/core/submission.d.ts

@@ -0,0 +1,30 @@
+import type { Fetcher, NavigateOptions, Router } from "./types.ts";
+/** Values accepted by programmatic route submissions. */
+export type Submission = FormData | HTMLFormElement | Record<string, unknown>;
+/** Destination and encoding for a programmatic route submission. */
+export interface SubmissionOptions {
+    action?: string;
+    encType?: string;
+    method?: string;
+    replace?: boolean;
+    preventScrollReset?: boolean;
+}
+export declare function formData(value: Submission): FormData;
+export declare function submissionBody(value: Submission, encoding?: string): FormData;
+/** Encode successful form controls for a GET route request. */
+export declare function submissionSearch(body: FormData): string;
+/** Read the JSON payload of a programmatic submission. */
+export declare function readSubmission(request: Request): Promise<unknown>;
+/** Browser form behavior shared by the React and Preact adapters. */
+export interface RouteFormOptions extends NavigateOptions {
+    action?: string;
+    method?: "get" | "post" | "put" | "patch" | "delete";
+    reloadDocument?: boolean;
+}
+export interface FormSubmissionEvent {
+    currentTarget: HTMLFormElement;
+    defaultPrevented: boolean;
+    preventDefault: () => void;
+}
+/** Submit an internal form while leaving external actions to the browser. */
+export declare function submitForm(router: Router, event: FormSubmissionEvent, submitter: HTMLElement | null, options: RouteFormOptions, fetcher?: Fetcher): void;

package/dist/core/submission.js

@@ -0,0 +1,41 @@
+import { internalURL } from "./url.js";
+//#region .generated/core/submission.ts
+function formData(value) {
+	if (value instanceof FormData) return value;
+	if (typeof HTMLFormElement !== "undefined" && value instanceof HTMLFormElement) return new FormData(value);
+	const body = new FormData();
+	for (const [key, field] of Object.entries(value)) body.append(key, String(field));
+	return body;
+}
+function submissionBody(value, encoding) {
+	return formData(encoding === "application/json" ? { _payload: JSON.stringify(value) } : value);
+}
+/** Encode successful form controls for a GET route request. */
+function submissionSearch(body) {
+	const search = new URLSearchParams();
+	for (const [key, value] of body) search.append(key, typeof value === "string" ? value : value.name);
+	return String(search);
+}
+/** Read the JSON payload of a programmatic submission. */
+async function readSubmission(request) {
+	if (request.headers.get("Content-Type")?.includes("application/json")) return request.json();
+	const body = await request.formData();
+	return JSON.parse(String(body.get("_payload") ?? "{}"));
+}
+/** Submit an internal form while leaving external actions to the browser. */
+function submitForm(router, event, submitter, options, fetcher) {
+	if (event.defaultPrevented || options.reloadDocument) return;
+	const target = internalURL(router.getSnapshot().url, submitter?.getAttribute("formaction") ?? options.action);
+	if (!target) return;
+	const data = new FormData(event.currentTarget, submitter);
+	const method = (submitter?.getAttribute("formmethod") ?? options.method)?.toUpperCase();
+	event.preventDefault();
+	if (method === "GET") {
+		target.search = submissionSearch(data);
+		fetcher ? fetcher.load(target.href) : router.navigate(target.href, options);
+		return;
+	}
+	(fetcher ?? router).submit(target.href, data, { method });
+}
+//#endregion
+export { formData, readSubmission, submissionBody, submissionSearch, submitForm };

package/dist/{internal/core → core}/types.d.ts

@@ -41,6 +41,8 @@ export interface RevalidationArgs extends RevalidationContext {
 }
 /** A route component and its optional server and client data handlers. */
 export interface RouteModule {
+    /** Stable identifier for targeted revalidation; defaults to the path. */
+    id?: string;
     default?: unknown;
     HydrateFallback?: unknown;
     ErrorBoundary?: unknown;
@@ -80,7 +82,11 @@ export interface RouterOptions {
 }
 /** Options for replacing rather than appending a browser history entry. */
 export interface NavigateOptions {
+    state?: unknown;
+    viewTransition?: boolean;
     replace?: boolean;
+    /** Preserve scroll in integrations that manage scroll restoration. */
+    preventScrollReset?: boolean;
 }
 /** HTTP method for a route action submission; defaults to POST. */
 export interface SubmitOptions {
@@ -104,6 +110,13 @@ export interface Fetcher {
     /** Abort work and release subscriptions when this imperative fetcher is no longer used. */
     dispose: () => void;
 }
+/** Refresh active route data without navigation, optionally selecting route IDs or paths. */
+export interface RevalidateOptions extends RevalidationContext {
+    route?: string | readonly string[];
+    reason?: RevalidationArgs["reason"];
+}
+/** A registered layout loader's revalidation callback. */
+export type Revalidator = (args: RevalidationArgs) => void | Promise<void>;
 /** Route navigation, subscriptions, fetchers, and loader revalidation. */
 export interface Router {
     routes: readonly Route[];
@@ -111,7 +124,9 @@ export interface Router {
     subscribe: (listener: () => void) => () => void;
     start: () => () => void;
     navigate: (url: string, options?: NavigateOptions) => Promise<void>;
-    revalidate: (reason?: RevalidationArgs["reason"], context?: RevalidationContext) => Promise<void>;
+    revalidate: (options?: RevalidateOptions | RevalidationArgs["reason"], context?: RevalidationContext) => Promise<void>;
+    /** Register layout data under a route ID. The returned function unregisters it. */
+    registerRevalidator: (id: string, revalidate: Revalidator) => () => void;
     submit: (url: string, body: FormData, options?: SubmitOptions) => Promise<Result>;
     /** Create an independent fetcher. Framework useFetcher hooks manage disposal automatically. */
     createFetcher: () => Fetcher;

package/dist/core/url.d.ts

@@ -0,0 +1,7 @@
+/** Resolve an internal URL; external links remain the browser's responsibility. */
+export declare function internalURL(base: string, href?: string): URL | undefined;
+/** Browser and framework event fields used by navigation interception. */
+type NavigationClickEvent = Pick<MouseEvent, "defaultPrevented" | "button" | "metaKey" | "ctrlKey" | "altKey" | "shiftKey">;
+/** Whether an anchor click should use router navigation. */
+export declare function navigationClick(event: NavigationClickEvent, anchor: HTMLAnchorElement): boolean;
+export {};

package/dist/core/url.js

@@ -0,0 +1,12 @@
+//#region .generated/core/url.ts
+/** Resolve an internal URL; external links remain the browser's responsibility. */
+function internalURL(base, href = base) {
+	const url = new URL(href, base);
+	if (url.origin === new URL(base).origin) return url;
+}
+/** Whether an anchor click should use router navigation. */
+function navigationClick(event, anchor) {
+	return !(event.defaultPrevented || event.button || event.metaKey || event.ctrlKey || event.altKey || event.shiftKey || anchor.hasAttribute("download") || anchor.target && anchor.target !== "_self");
+}
+//#endregion
+export { internalURL, navigationClick };

package/dist/core/utils.d.ts

@@ -0,0 +1,5 @@
+/** Framework-independent, browser-safe utilities. @module */
+export * from "./errors.ts";
+export * from "./match.ts";
+export * from "./serialize.ts";
+export * from "./url.ts";

package/dist/core/utils.js

@@ -0,0 +1,5 @@
+import { safeWrapAsync } from "./errors.js";
+import { defineRoute, matchRoutes } from "./match.js";
+import { internalURL, navigationClick } from "./url.js";
+import { serialize, serializeData } from "./serialize.js";
+export { defineRoute, internalURL, matchRoutes, navigationClick, safeWrapAsync, serialize, serializeData };

package/dist/files/index.js

@@ -0,0 +1,64 @@
+import { safeWrapAsync } from "../core/errors.js";
+import { readdir } from "node:fs/promises";
+import { resolve } from "node:path";
+//#region .generated/files/index.ts
+/**
+* Build-time discovery of flat file routes.
+* @module
+*/
+var routeFile = /^route\.[jt]sx?$/;
+var flatFile = /\.[jt]sx?$/;
+/** Read only flat files and immediate route folders. Colocated helpers are ignored. */
+async function flatRoutes(directory) {
+	const result = await safeWrapAsync(async () => {
+		const entries = await readdir(directory, { withFileTypes: true });
+		const routes = [];
+		const patterns = /* @__PURE__ */ new Set();
+		for (const entry of entries) {
+			let name = entry.name;
+			let file = resolve(directory, name);
+			if (entry.isDirectory()) {
+				const candidates = (await readdir(file)).filter((name) => routeFile.test(name));
+				if (candidates.length > 1) return /* @__PURE__ */ new Error(`Multiple route files in ${file}`);
+				if (!candidates.length) continue;
+				file = resolve(file, candidates[0]);
+			} else {
+				if (!entry.isFile() || !flatFile.test(name) || name.endsWith(".d.ts")) continue;
+				name = name.replace(flatFile, "");
+			}
+			if (/[()[\]:*?]/.test(name)) return /* @__PURE__ */ new Error(`Unsupported flat route name: ${name}`);
+			const segments = name.split(".");
+			const parts = [];
+			for (const [index, segment] of segments.entries()) {
+				if (!segment) return /* @__PURE__ */ new Error(`Empty route segment: ${name}`);
+				if (segment === "_index" && index !== segments.length - 1) return /* @__PURE__ */ new Error(`_index must be last: ${name}`);
+				if (segment === "$" && index !== segments.length - 1) return /* @__PURE__ */ new Error(`Splat must be last: ${name}`);
+				if (segment.startsWith("_")) continue;
+				const part = segment.replace(/_$/, "");
+				parts.push(part === "$" ? "*" : part.replace(/^\$/, ":"));
+			}
+			if (segments.at(-1)?.startsWith("_") && segments.at(-1) !== "_index") continue;
+			const path = `/${parts.join("/")}`;
+			const pattern = path.replace(/:[^/]+/g, ":");
+			if (patterns.has(pattern)) return /* @__PURE__ */ new Error(`Conflicting flat route: ${path}`);
+			patterns.add(pattern);
+			routes.push({
+				path,
+				file
+			});
+		}
+		return routes.sort((a, b) => {
+			const left = a.path.split("/");
+			const right = b.path.split("/");
+			const rank = (part) => part === "*" ? 0 : part?.startsWith(":") ? 1 : part === void 0 ? 2 : 3;
+			for (let index = 0; index < Math.max(left.length, right.length); index++) {
+				const difference = rank(right[index]) - rank(left[index]);
+				if (difference) return difference;
+			}
+			return a.path.localeCompare(b.path);
+		});
+	});
+	return result.error ?? result.data;
+}
+//#endregion
+export { flatRoutes };

package/dist/preact/await.d.ts

@@ -0,0 +1,7 @@
+import type { ComponentChildren } from "preact";
+export interface AwaitProps<T> {
+    resolve: T | Promise<T>;
+    children: (value: Awaited<T>) => ComponentChildren;
+    errorElement?: ComponentChildren;
+}
+export declare function Await<T>({ resolve, children, errorElement, }: AwaitProps<T>): ComponentChildren;

package/dist/preact/await.js

@@ -0,0 +1,19 @@
+import { use } from "preact/compat";
+//#region .generated/preact/await.tsx
+var resolutions = /* @__PURE__ */ new WeakMap();
+function Await({ resolve, children, errorElement }) {
+	if (!(resolve instanceof Promise)) return children(resolve);
+	let pending = resolutions.get(resolve);
+	if (!pending) {
+		pending = resolve.then((value) => ({ value }), (error) => ({ error }));
+		resolutions.set(resolve, pending);
+	}
+	const result = use(pending);
+	if ("error" in result) {
+		if (errorElement !== void 0) return errorElement;
+		throw result.error;
+	}
+	return children(result.value);
+}
+//#endregion
+export { Await };

package/dist/preact/client.d.ts

@@ -0,0 +1,7 @@
+/** Browser mounting and hydration for Preact applications. @module */
+/** @jsxImportSource preact */
+import { type Router } from "../core/index.ts";
+import type { AppRoute, RootModule } from "./route-types.ts";
+export * from "../client/index.ts";
+export { configureApplication } from "../core/environment.ts";
+export declare function mountApplication(routes: AppRoute[], rootModule?: RootModule, hash?: boolean): Promise<Router>;

package/dist/preact/client.js

@@ -0,0 +1,67 @@
+import { matchRoutes } from "../core/match.js";
+import { createDataRouter } from "../core/router.js";
+import { configureApplication } from "../core/environment.js";
+import { retainRoute } from "../core/presentation.js";
+import { connectNavigation } from "../core/navigation.js";
+import { attachRootData } from "./root-data.js";
+import { RouterApplication, prepareRoutes } from "./router.js";
+import { deserialize } from "../client/deserialize.js";
+import { serverRoute } from "../client/index.js";
+import { flushSync } from "preact/compat";
+import { jsx } from "preact/jsx-runtime";
+import { hydrate, render } from "preact";
+//#region .generated/preact/client.tsx
+/** Browser mounting and hydration for Preact applications. @module */
+/** @jsxImportSource preact */
+async function mountApplication(routes, rootModule, hash = false) {
+	const initialURL = new URL(hash ? location.hash.slice(1) || "/" : location.href, location.origin);
+	await (matchRoutes(routes, initialURL.pathname)?.route)?.preload?.();
+	routes = prepareRoutes(routes);
+	const element = document.getElementById("smolter-data");
+	const hydration = element?.textContent ? JSON.parse(element.textContent) : void 0;
+	if (hydration?.snapshot.error) hydration.snapshot.error = Object.assign(new Error(hydration.snapshot.error.message), hydration.snapshot.error);
+	const router = createDataRouter(routes, {
+		browser: !hash,
+		url: hash ? new URL(location.hash.slice(1) || "/", location.origin).href : location.href,
+		...hydration && { hydrationData: hydration.snapshot }
+	});
+	retainRoute(router, flushSync);
+	if (hash) connectHashHistory(router);
+	connectNavigation(router);
+	const rootStore = attachRootData(router, hydration?.root, rootModule);
+	const props = {
+		routes,
+		router,
+		root: hydration?.root,
+		rootModule,
+		rootStore
+	};
+	if (hydration) {
+		hydrate(/* @__PURE__ */ jsx(RouterApplication, {
+			...props,
+			document: true
+		}), document);
+		return router;
+	}
+	const target = document.getElementById("root");
+	if (target) render(/* @__PURE__ */ jsx(RouterApplication, { ...props }), target);
+	return router;
+}
+function connectHashHistory(router) {
+	const navigate = router.navigate;
+	router.navigate = async (url, options) => {
+		const target = new URL(url, router.getSnapshot().url);
+		const hash = `#${target.pathname}${target.search}`;
+		history[options?.replace ? "replaceState" : "pushState"](null, "", hash);
+		await navigate(url, options);
+	};
+	const onHashChange = () => void navigate(location.hash.slice(1) || "/");
+	window.addEventListener("hashchange", onHashChange);
+	const dispose = router.dispose;
+	router.dispose = () => {
+		window.removeEventListener("hashchange", onHashChange);
+		dispose();
+	};
+}
+//#endregion
+export { configureApplication, deserialize, mountApplication, serverRoute };

package/dist/preact/context.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Preact components and typed data hooks. Import from @kasperrt/smolter/preact.
+ * @module
+ */
+import type { NavigationRouter, Snapshot } from "../core/index.ts";
+import { type ReactNode } from "./runtime.ts";
+/** Router instance and children rendered within its context. */
+export interface RouterProviderProps {
+    router: NavigationRouter;
+    children?: ReactNode;
+}
+/** Provide a router to descendant hooks and connect its browser lifecycle. */
+export declare function RouterProvider({ router, children, }: RouterProviderProps): ReactNode;
+/** Hooks require a RouterProvider. */
+export declare function useRouter<T extends NavigationRouter = NavigationRouter>(): T;
+export declare function useSnapshot(): Snapshot;
+export declare function useSnapshot<K extends keyof Snapshot>(key: K): Snapshot[K];
+export declare function useSnapshot<K extends keyof Snapshot>(key: K, path: string | undefined): Snapshot[K] | undefined;

package/dist/preact/context.js

@@ -0,0 +1,23 @@
+import { createContext, createElement, useContext, useEffect, useSyncExternalStore } from "./runtime.js";
+//#region .generated/preact/context.ts
+var RouterContext = createContext(void 0);
+/** Provide a router to descendant hooks and connect its browser lifecycle. */
+function RouterProvider({ router, children }) {
+	useEffect(router.start, [router]);
+	return createElement(RouterContext, { value: router }, children);
+}
+/** Hooks require a RouterProvider. */
+function useRouter() {
+	return useContext(RouterContext);
+}
+function useSnapshot(key, path) {
+	const router = useRouter();
+	const getSnapshot = () => {
+		const snapshot = router.getSnapshot();
+		if (path !== void 0 && path !== snapshot.path) return void 0;
+		return key ? snapshot[key] : snapshot;
+	};
+	return useSyncExternalStore(router.subscribe, getSnapshot);
+}
+//#endregion
+export { RouterProvider, useRouter, useSnapshot };

package/dist/preact/document.d.ts

@@ -0,0 +1,15 @@
+/** @jsxImportSource preact */
+import type { ComponentProps } from "preact/compat";
+export declare function Meta(): import("preact").JSX.Element;
+export declare function Links(): import("preact").JSX.Element;
+export interface ScriptProps {
+    nonce?: string;
+}
+export declare function Scripts({ nonce }: ScriptProps): import("preact").JSX.Element;
+export declare function ScrollRestoration(_props: ScriptProps): null;
+/** HTML attributes for server markup and client document reconciliation. */
+export interface DocumentProps extends ComponentProps<"html"> {
+    "data-debug"?: boolean;
+}
+/** Render the server document and preserve client-managed theme classes on hydration. */
+export declare function Document(props: DocumentProps): import("preact").JSX.Element;