@pyreon/router 0.1.0

package/lib/index.js

@@ -0,0 +1,830 @@
+import { createContext, createRef, h, onUnmount, popContext, pushContext, useContext } from "@pyreon/core";
+import { computed, signal } from "@pyreon/reactivity";
+
+//#region src/loader.ts
+/**
+* Context frame that holds the loader data for the currently rendered route record.
+* Pushed by RouterView's withLoaderData wrapper before invoking the route component.
+*/
+const LoaderDataContext = createContext(void 0);
+/**
+* Returns the data resolved by the current route's `loader` function.
+* Must be called inside a route component rendered by <RouterView />.
+*
+* @example
+* const routes = [{ path: "/users", component: Users, loader: fetchUsers }]
+*
+* function Users() {
+*   const users = useLoaderData<User[]>()
+*   return h("ul", null, users.map(u => h("li", null, u.name)))
+* }
+*/
+function useLoaderData() {
+	return useContext(LoaderDataContext);
+}
+/**
+* SSR helper: pre-run all loaders for the given path before rendering.
+* Call this before `renderToString` so route components can read data via `useLoaderData()`.
+*
+* @example
+* const router = createRouter({ routes, url: req.url })
+* await prefetchLoaderData(router, req.url)
+* const html = await renderToString(h(App, { router }))
+*/
+async function prefetchLoaderData(router, path) {
+	const route = router._resolve(path);
+	const ac = new AbortController();
+	router._abortController = ac;
+	await Promise.all(route.matched.filter((r) => r.loader).map(async (r) => {
+		const data = await r.loader?.({
+			params: route.params,
+			query: route.query,
+			signal: ac.signal
+		});
+		router._loaderData.set(r, data);
+	}));
+}
+/**
+* Serialize loader data to a JSON-safe plain object for embedding in SSR HTML.
+* Keys are route path patterns (stable across server and client).
+*
+* @example — SSR handler:
+* await prefetchLoaderData(router, req.url)
+* const { html, head } = await renderWithHead(h(App, null))
+* const page = `...${head}
+*   <script>window.__PYREON_LOADER_DATA__=${JSON.stringify(serializeLoaderData(router))}<\/script>
+*   ...${html}...`
+*/
+function serializeLoaderData(router) {
+	const result = {};
+	for (const [record, data] of router._loaderData) result[record.path] = data;
+	return result;
+}
+/**
+* Hydrate loader data from a serialized object (e.g. `window.__PYREON_LOADER_DATA__`).
+* Populates the router's internal `_loaderData` map so the initial render uses
+* server-fetched data without re-running loaders on the client.
+*
+* Call this before `mount()`, after `createRouter()`.
+*
+* @example — client entry:
+* import { hydrateLoaderData } from "@pyreon/router"
+* const router = createRouter({ routes })
+* hydrateLoaderData(router, window.__PYREON_LOADER_DATA__ ?? {})
+* mount(h(App, null), document.getElementById("app")!)
+*/
+function hydrateLoaderData(router, serialized) {
+	if (!serialized || typeof serialized !== "object") return;
+	const route = router._resolve(router.currentRoute().path);
+	for (const record of route.matched) if (Object.hasOwn(serialized, record.path)) router._loaderData.set(record, serialized[record.path]);
+}
+
+//#endregion
+//#region src/match.ts
+/**
+* Parse a query string into key-value pairs. Duplicate keys are overwritten
+* (last value wins). Use `parseQueryMulti` to preserve duplicates as arrays.
+*/
+function parseQuery(qs) {
+	if (!qs) return {};
+	const result = {};
+	for (const part of qs.split("&")) {
+		const eqIdx = part.indexOf("=");
+		if (eqIdx < 0) {
+			const key = decodeURIComponent(part);
+			if (key) result[key] = "";
+		} else {
+			const key = decodeURIComponent(part.slice(0, eqIdx));
+			const val = decodeURIComponent(part.slice(eqIdx + 1));
+			if (key) result[key] = val;
+		}
+	}
+	return result;
+}
+/**
+* Parse a query string preserving duplicate keys as arrays.
+*
+* @example
+* parseQueryMulti("color=red&color=blue&size=lg")
+* // → { color: ["red", "blue"], size: "lg" }
+*/
+function parseQueryMulti(qs) {
+	if (!qs) return {};
+	const result = {};
+	for (const part of qs.split("&")) {
+		const eqIdx = part.indexOf("=");
+		let key;
+		let val;
+		if (eqIdx < 0) {
+			key = decodeURIComponent(part);
+			val = "";
+		} else {
+			key = decodeURIComponent(part.slice(0, eqIdx));
+			val = decodeURIComponent(part.slice(eqIdx + 1));
+		}
+		if (!key) continue;
+		const existing = result[key];
+		if (existing === void 0) result[key] = val;
+		else if (Array.isArray(existing)) existing.push(val);
+		else result[key] = [existing, val];
+	}
+	return result;
+}
+function stringifyQuery(query) {
+	const parts = [];
+	for (const [k, v] of Object.entries(query)) parts.push(v ? `${encodeURIComponent(k)}=${encodeURIComponent(v)}` : encodeURIComponent(k));
+	return parts.length ? `?${parts.join("&")}` : "";
+}
+/**
+* Match a single route pattern against a path segment.
+* Returns extracted params or null if no match.
+*
+* Supports:
+*   - Exact segments: "/about"
+*   - Param segments: "/user/:id"
+*   - Wildcard: "(.*)" matches everything
+*/
+function matchPath(pattern, path) {
+	if (pattern === "(.*)" || pattern === "*") return {};
+	const patternParts = pattern.split("/").filter(Boolean);
+	const pathParts = path.split("/").filter(Boolean);
+	const params = {};
+	for (let i = 0; i < patternParts.length; i++) {
+		const pp = patternParts[i];
+		const pt = pathParts[i];
+		if (pp.endsWith("*") && pp.startsWith(":")) {
+			const paramName = pp.slice(1, -1);
+			params[paramName] = pathParts.slice(i).map(decodeURIComponent).join("/");
+			return params;
+		}
+		if (pp.startsWith(":")) params[pp.slice(1)] = decodeURIComponent(pt);
+		else if (pp !== pt) return null;
+	}
+	if (patternParts.length !== pathParts.length) return null;
+	return params;
+}
+/**
+* Check if a path starts with a route's prefix (for nested route matching).
+* Returns the remaining path suffix, or null if no match.
+*/
+function matchPrefix(pattern, path) {
+	if (pattern === "(.*)" || pattern === "*") return {
+		params: {},
+		rest: path
+	};
+	const patternParts = pattern.split("/").filter(Boolean);
+	const pathParts = path.split("/").filter(Boolean);
+	if (pathParts.length < patternParts.length) return null;
+	const params = {};
+	for (let i = 0; i < patternParts.length; i++) {
+		const pp = patternParts[i];
+		const pt = pathParts[i];
+		if (pp.endsWith("*") && pp.startsWith(":")) {
+			const paramName = pp.slice(1, -1);
+			params[paramName] = pathParts.slice(i).map(decodeURIComponent).join("/");
+			return {
+				params,
+				rest: "/"
+			};
+		}
+		if (pp.startsWith(":")) params[pp.slice(1)] = decodeURIComponent(pt);
+		else if (pp !== pt) return null;
+	}
+	return {
+		params,
+		rest: `/${pathParts.slice(patternParts.length).join("/")}`
+	};
+}
+/**
+* Resolve a raw path (including query string and hash) against the route tree.
+* Handles nested routes recursively.
+*/
+function resolveRoute(rawPath, routes) {
+	const qIdx = rawPath.indexOf("?");
+	const pathAndHash = qIdx >= 0 ? rawPath.slice(0, qIdx) : rawPath;
+	const queryPart = qIdx >= 0 ? rawPath.slice(qIdx + 1) : "";
+	const hIdx = pathAndHash.indexOf("#");
+	const cleanPath = hIdx >= 0 ? pathAndHash.slice(0, hIdx) : pathAndHash;
+	const hash = hIdx >= 0 ? pathAndHash.slice(hIdx + 1) : "";
+	const query = parseQuery(queryPart);
+	const match = matchRoutes(cleanPath, routes, []);
+	if (match) return {
+		path: cleanPath,
+		params: match.params,
+		query,
+		hash,
+		matched: match.matched,
+		meta: mergeMeta(match.matched)
+	};
+	return {
+		path: cleanPath,
+		params: {},
+		query,
+		hash,
+		matched: [],
+		meta: {}
+	};
+}
+function matchRoutes(path, routes, parentMatched, parentParams = {}) {
+	for (const route of routes) {
+		const result = matchSingleRoute(path, route, parentMatched, parentParams);
+		if (result) return result;
+	}
+	return null;
+}
+function matchSingleRoute(path, route, parentMatched, parentParams) {
+	if (!route.children || route.children.length === 0) {
+		const params = matchPath(route.path, path);
+		if (params === null) return null;
+		return {
+			params: {
+				...parentParams,
+				...params
+			},
+			matched: [...parentMatched, route]
+		};
+	}
+	const prefix = matchPrefix(route.path, path);
+	if (prefix === null) return null;
+	const allParams = {
+		...parentParams,
+		...prefix.params
+	};
+	const matched = [...parentMatched, route];
+	const childMatch = matchRoutes(prefix.rest, route.children, matched, allParams);
+	if (childMatch) return childMatch;
+	const exactParams = matchPath(route.path, path);
+	if (exactParams === null) return null;
+	return {
+		params: {
+			...parentParams,
+			...exactParams
+		},
+		matched
+	};
+}
+/** Merge meta from matched routes (leaf takes precedence) */
+function mergeMeta(matched) {
+	const meta = {};
+	for (const record of matched) if (record.meta) Object.assign(meta, record.meta);
+	return meta;
+}
+/** Build a path string from a named route's pattern and params */
+function buildPath(pattern, params) {
+	return pattern.replace(/:([^/]+)\*?/g, (match, key) => {
+		const val = params[key] ?? "";
+		if (match.endsWith("*")) return val.split("/").map(encodeURIComponent).join("/");
+		return encodeURIComponent(val);
+	});
+}
+/** Find a route record by name (recursive, O(n)). Prefer buildNameIndex for repeated lookups. */
+function findRouteByName(name, routes) {
+	for (const route of routes) {
+		if (route.name === name) return route;
+		if (route.children) {
+			const found = findRouteByName(name, route.children);
+			if (found) return found;
+		}
+	}
+	return null;
+}
+/**
+* Pre-build a name → RouteRecord index from a route tree for O(1) named navigation.
+* Called once at router creation time; avoids O(n) depth-first search per push({ name }).
+*/
+function buildNameIndex(routes) {
+	const index = /* @__PURE__ */ new Map();
+	function walk(list) {
+		for (const route of list) {
+			if (route.name) index.set(route.name, route);
+			if (route.children) walk(route.children);
+		}
+	}
+	walk(routes);
+	return index;
+}
+
+//#endregion
+//#region src/scroll.ts
+/**
+* Scroll restoration manager.
+*
+* Saves scroll position before each navigation and restores it when
+* navigating back to a previously visited path.
+*/
+var ScrollManager = class {
+	_positions = /* @__PURE__ */ new Map();
+	_behavior;
+	constructor(behavior = "top") {
+		this._behavior = behavior;
+	}
+	/** Call before navigating away — saves current scroll position for `fromPath` */
+	save(fromPath) {
+		this._positions.set(fromPath, window.scrollY);
+	}
+	/** Call after navigation is committed — applies scroll behavior */
+	restore(to, from) {
+		const behavior = to.meta.scrollBehavior ?? this._behavior ?? "top";
+		if (typeof behavior === "function") {
+			const result = behavior(to, from, this._positions.get(to.path) ?? null);
+			this._applyResult(result, to.path);
+			return;
+		}
+		this._applyResult(behavior, to.path);
+	}
+	_applyResult(result, toPath) {
+		if (result === "none") return;
+		if (result === "top" || result === void 0) {
+			window.scrollTo({
+				top: 0,
+				behavior: "instant"
+			});
+			return;
+		}
+		if (result === "restore") {
+			const saved = this._positions.get(toPath) ?? 0;
+			window.scrollTo({
+				top: saved,
+				behavior: "instant"
+			});
+			return;
+		}
+		window.scrollTo({
+			top: result,
+			behavior: "instant"
+		});
+	}
+	getSavedPosition(path) {
+		return this._positions.get(path) ?? null;
+	}
+};
+
+//#endregion
+//#region src/types.ts
+const LAZY_SYMBOL = Symbol("pyreon.lazy");
+function lazy(loader, options) {
+	return {
+		[LAZY_SYMBOL]: true,
+		loader,
+		...options?.loading ? { loadingComponent: options.loading } : {},
+		...options?.error ? { errorComponent: options.error } : {}
+	};
+}
+function isLazy(c) {
+	return typeof c === "object" && c !== null && c[LAZY_SYMBOL] === true;
+}
+
+//#endregion
+//#region src/router.ts
+const _isBrowser = typeof window !== "undefined";
+const RouterContext = createContext(null);
+let _activeRouter = null;
+function setActiveRouter(router) {
+	if (router) router._viewDepth = 0;
+	_activeRouter = router;
+}
+function useRouter() {
+	const router = useContext(RouterContext) ?? _activeRouter;
+	if (!router) throw new Error("[pyreon-router] No router installed. Wrap your app in <RouterProvider router={router}>.");
+	return router;
+}
+function useRoute() {
+	const router = useContext(RouterContext) ?? _activeRouter;
+	if (!router) throw new Error("[pyreon-router] No router installed. Wrap your app in <RouterProvider router={router}>.");
+	return router.currentRoute;
+}
+function createRouter(options) {
+	const opts = Array.isArray(options) ? { routes: options } : options;
+	const { routes, mode = "hash", scrollBehavior, onError, maxCacheSize = 100 } = opts;
+	const nameIndex = buildNameIndex(routes);
+	const guards = [];
+	const afterHooks = [];
+	const scrollManager = new ScrollManager(scrollBehavior);
+	let _navGen = 0;
+	const getInitialLocation = () => {
+		if (opts.url) return opts.url;
+		if (!_isBrowser) return "/";
+		if (mode === "history") return window.location.pathname + window.location.search;
+		const hash = window.location.hash;
+		return hash.startsWith("#") ? hash.slice(1) || "/" : "/";
+	};
+	const getCurrentLocation = () => {
+		if (!_isBrowser) return currentPath();
+		if (mode === "history") return window.location.pathname + window.location.search;
+		const hash = window.location.hash;
+		return hash.startsWith("#") ? hash.slice(1) || "/" : "/";
+	};
+	const currentPath = signal(getInitialLocation());
+	const currentRoute = computed(() => resolveRoute(currentPath(), routes));
+	let _popstateHandler = null;
+	let _hashchangeHandler = null;
+	if (_isBrowser) if (mode === "history") {
+		_popstateHandler = () => currentPath.set(getCurrentLocation());
+		window.addEventListener("popstate", _popstateHandler);
+	} else {
+		_hashchangeHandler = () => currentPath.set(getCurrentLocation());
+		window.addEventListener("hashchange", _hashchangeHandler);
+	}
+	const componentCache = /* @__PURE__ */ new Map();
+	const loadingSignal = signal(0);
+	async function evaluateGuard(guard, to, from, gen) {
+		const result = await runGuard(guard, to, from);
+		if (gen !== _navGen) return { action: "cancel" };
+		if (result === false) return { action: "cancel" };
+		if (typeof result === "string") return {
+			action: "redirect",
+			target: result
+		};
+		return { action: "continue" };
+	}
+	async function runRouteGuards(records, guardKey, to, from, gen) {
+		for (const record of records) {
+			const raw = record[guardKey];
+			if (!raw) continue;
+			const routeGuards = Array.isArray(raw) ? raw : [raw];
+			for (const guard of routeGuards) {
+				const outcome = await evaluateGuard(guard, to, from, gen);
+				if (outcome.action !== "continue") return outcome;
+			}
+		}
+		return { action: "continue" };
+	}
+	async function runGlobalGuards(globalGuards, to, from, gen) {
+		for (const guard of globalGuards) {
+			const outcome = await evaluateGuard(guard, to, from, gen);
+			if (outcome.action !== "continue") return outcome;
+		}
+		return { action: "continue" };
+	}
+	function processLoaderResult(result, record, ac, to) {
+		if (result.status === "fulfilled") {
+			router._loaderData.set(record, result.value);
+			return true;
+		}
+		if (ac.signal.aborted) return true;
+		if (router._onError) {
+			if (router._onError(result.reason, to) === false) return false;
+		}
+		router._loaderData.set(record, void 0);
+		return true;
+	}
+	function syncBrowserUrl(path, replace) {
+		if (!_isBrowser) return;
+		const url = mode === "history" ? path : `#${path}`;
+		if (replace) window.history.replaceState(null, "", url);
+		else window.history.pushState(null, "", url);
+	}
+	function resolveRedirect(to) {
+		const leaf = to.matched[to.matched.length - 1];
+		if (!leaf?.redirect) return null;
+		return sanitizePath(typeof leaf.redirect === "function" ? leaf.redirect(to) : leaf.redirect);
+	}
+	async function runAllGuards(to, from, gen) {
+		const leaveOutcome = await runRouteGuards(from.matched, "beforeLeave", to, from, gen);
+		if (leaveOutcome.action !== "continue") return leaveOutcome;
+		const enterOutcome = await runRouteGuards(to.matched, "beforeEnter", to, from, gen);
+		if (enterOutcome.action !== "continue") return enterOutcome;
+		return runGlobalGuards(guards, to, from, gen);
+	}
+	async function runLoaders(to, gen, ac) {
+		const loadableRecords = to.matched.filter((r) => r.loader);
+		if (loadableRecords.length === 0) return true;
+		const loaderCtx = {
+			params: to.params,
+			query: to.query,
+			signal: ac.signal
+		};
+		const results = await Promise.allSettled(loadableRecords.map((r) => {
+			if (!r.loader) return Promise.resolve(void 0);
+			return r.loader(loaderCtx);
+		}));
+		if (gen !== _navGen) return false;
+		for (let i = 0; i < loadableRecords.length; i++) {
+			const result = results[i];
+			const record = loadableRecords[i];
+			if (!result || !record) continue;
+			if (!processLoaderResult(result, record, ac, to)) return false;
+		}
+		return true;
+	}
+	function commitNavigation(path, replace, to, from) {
+		scrollManager.save(from.path);
+		currentPath.set(path);
+		syncBrowserUrl(path, replace);
+		if (_isBrowser && to.meta.title) document.title = to.meta.title;
+		for (const record of router._loaderData.keys()) if (!to.matched.includes(record)) router._loaderData.delete(record);
+		for (const hook of afterHooks) try {
+			hook(to, from);
+		} catch (_err) {}
+		if (_isBrowser) queueMicrotask(() => scrollManager.restore(to, from));
+	}
+	async function navigate(path, replace, redirectDepth = 0) {
+		if (redirectDepth > 10) return;
+		const gen = ++_navGen;
+		loadingSignal.update((n) => n + 1);
+		const to = resolveRoute(path, routes);
+		const from = currentRoute();
+		const redirectTarget = resolveRedirect(to);
+		if (redirectTarget !== null) {
+			loadingSignal.update((n) => n - 1);
+			return navigate(redirectTarget, replace, redirectDepth + 1);
+		}
+		const guardOutcome = await runAllGuards(to, from, gen);
+		if (guardOutcome.action !== "continue") {
+			loadingSignal.update((n) => n - 1);
+			if (guardOutcome.action === "redirect") return navigate(sanitizePath(guardOutcome.target), replace, redirectDepth + 1);
+			return;
+		}
+		router._abortController?.abort();
+		const ac = new AbortController();
+		router._abortController = ac;
+		if (!await runLoaders(to, gen, ac)) {
+			loadingSignal.update((n) => n - 1);
+			return;
+		}
+		commitNavigation(path, replace, to, from);
+		loadingSignal.update((n) => n - 1);
+	}
+	const router = {
+		routes,
+		mode,
+		currentRoute,
+		_currentPath: currentPath,
+		_currentRoute: currentRoute,
+		_componentCache: componentCache,
+		_loadingSignal: loadingSignal,
+		_scrollPositions: /* @__PURE__ */ new Map(),
+		_scrollBehavior: scrollBehavior,
+		_viewDepth: 0,
+		_erroredChunks: /* @__PURE__ */ new Set(),
+		_loaderData: /* @__PURE__ */ new Map(),
+		_abortController: null,
+		_onError: onError,
+		_maxCacheSize: maxCacheSize,
+		async push(location) {
+			if (typeof location === "string") return navigate(sanitizePath(location), false);
+			return navigate(resolveNamedPath(location.name, location.params ?? {}, location.query ?? {}, nameIndex), false);
+		},
+		async replace(path) {
+			return navigate(sanitizePath(path), true);
+		},
+		back() {
+			if (_isBrowser) window.history.back();
+		},
+		beforeEach(guard) {
+			guards.push(guard);
+			return () => {
+				const idx = guards.indexOf(guard);
+				if (idx >= 0) guards.splice(idx, 1);
+			};
+		},
+		afterEach(hook) {
+			afterHooks.push(hook);
+			return () => {
+				const idx = afterHooks.indexOf(hook);
+				if (idx >= 0) afterHooks.splice(idx, 1);
+			};
+		},
+		loading: () => loadingSignal() > 0,
+		destroy() {
+			if (_popstateHandler) {
+				window.removeEventListener("popstate", _popstateHandler);
+				_popstateHandler = null;
+			}
+			if (_hashchangeHandler) {
+				window.removeEventListener("hashchange", _hashchangeHandler);
+				_hashchangeHandler = null;
+			}
+			guards.length = 0;
+			afterHooks.length = 0;
+			componentCache.clear();
+			router._loaderData.clear();
+			router._abortController?.abort();
+			router._abortController = null;
+		},
+		_resolve: (rawPath) => resolveRoute(rawPath, routes)
+	};
+	return router;
+}
+async function runGuard(guard, to, from) {
+	try {
+		return await guard(to, from);
+	} catch (_err) {
+		return false;
+	}
+}
+function resolveNamedPath(name, params, query, index) {
+	const record = index.get(name);
+	if (!record) return "/";
+	let path = buildPath(record.path, params);
+	const qs = Object.entries(query).map(([k, v]) => `${encodeURIComponent(k)}=${encodeURIComponent(v)}`).join("&");
+	if (qs) path += `?${qs}`;
+	return path;
+}
+/** Block unsafe navigation targets: javascript/data/vbscript URIs and absolute URLs. */
+function sanitizePath(path) {
+	const trimmed = path.trim();
+	if (/^(?:javascript|data|vbscript):/i.test(trimmed)) return "/";
+	if (/^\/\/|^https?:/i.test(trimmed)) return "/";
+	return path;
+}
+
+//#endregion
+//#region src/components.tsx
+const _prefetched = /* @__PURE__ */ new WeakMap();
+const RouterProvider = (props) => {
+	const router = props.router;
+	pushContext(new Map([[RouterContext.id, router]]));
+	onUnmount(() => {
+		popContext();
+		router.destroy();
+		setActiveRouter(null);
+	});
+	setActiveRouter(router);
+	return props.children ?? null;
+};
+/**
+* Renders the matched route component at this nesting level.
+*
+* Nested layouts work by placing a second `<RouterView />` inside the layout
+* component — it automatically renders the next level of the matched route.
+*
+* How depth tracking works:
+* Pyreon components run once in depth-first tree order. Each `RouterView`
+* captures `router._viewDepth` at setup time and immediately increments it,
+* so sibling and child views get the correct index. `onUnmount` decrements
+* the counter so dynamic route swaps work correctly.
+*
+* @example
+* // Route config:
+* { path: "/admin", component: AdminLayout, children: [
+*   { path: "users", component: AdminUsers },
+* ]}
+*
+* // AdminLayout renders a nested RouterView:
+* function AdminLayout() {
+*   return <div><Sidebar /><RouterView /></div>
+* }
+*/
+const RouterView = (props) => {
+	const router = props.router ?? useContext(RouterContext);
+	if (!router) return null;
+	const depth = router._viewDepth;
+	router._viewDepth++;
+	onUnmount(() => {
+		router._viewDepth--;
+	});
+	const child = () => {
+		router._loadingSignal();
+		const route = router.currentRoute();
+		if (route.matched.length === 0) return null;
+		const record = route.matched[depth];
+		if (!record) return null;
+		const cached = router._componentCache.get(record);
+		if (cached) return renderWithLoader(router, record, cached, route);
+		const raw = record.component;
+		if (!isLazy(raw)) {
+			cacheSet(router, record, raw);
+			return renderWithLoader(router, record, raw, route);
+		}
+		return renderLazyRoute(router, record, raw);
+	};
+	return h("div", { "data-pyreon-router-view": true }, child);
+};
+const RouterLink = (props) => {
+	const router = useContext(RouterContext);
+	const prefetchMode = props.prefetch ?? "hover";
+	const handleClick = (e) => {
+		e.preventDefault();
+		if (!router) return;
+		if (props.replace) router.replace(props.to);
+		else router.push(props.to);
+	};
+	const handleMouseEnter = () => {
+		if (prefetchMode !== "hover" || !router) return;
+		prefetchRoute(router, props.to);
+	};
+	const href = router?.mode === "history" ? props.to : `#${props.to}`;
+	const activeClass = () => {
+		if (!router) return "";
+		const current = router.currentRoute().path;
+		const target = props.to;
+		const isExact = current === target;
+		const isActive = isExact || !props.exact && isSegmentPrefix(current, target);
+		const classes = [];
+		if (isActive) classes.push(props.activeClass ?? "router-link-active");
+		if (isExact) classes.push(props.exactActiveClass ?? "router-link-exact-active");
+		return classes.join(" ").trim();
+	};
+	const ref = createRef();
+	if (prefetchMode === "viewport" && router && typeof IntersectionObserver !== "undefined") {
+		const observer = new IntersectionObserver((entries) => {
+			for (const entry of entries) if (entry.isIntersecting) {
+				prefetchRoute(router, props.to);
+				observer.disconnect();
+				break;
+			}
+		});
+		queueMicrotask(() => {
+			observer.observe(ref.current);
+		});
+		onUnmount(() => observer.disconnect());
+	}
+	return h("a", {
+		ref,
+		href,
+		class: activeClass,
+		onClick: handleClick,
+		onMouseEnter: handleMouseEnter
+	}, props.children ?? props.to);
+};
+/** Prefetch loader data for a route (only once per router + path). */
+function prefetchRoute(router, path) {
+	let set = _prefetched.get(router);
+	if (!set) {
+		set = /* @__PURE__ */ new Set();
+		_prefetched.set(router, set);
+	}
+	if (set.has(path)) return;
+	set.add(path);
+	prefetchLoaderData(router, path).catch(() => {
+		set?.delete(path);
+	});
+}
+function renderLazyRoute(router, record, raw) {
+	if (router._erroredChunks.has(record)) return raw.errorComponent ? h(raw.errorComponent, {}) : null;
+	const tryLoad = (attempt) => raw.loader().then((mod) => {
+		cacheSet(router, record, typeof mod === "function" ? mod : mod.default);
+		router._loadingSignal.update((n) => n + 1);
+	}).catch((err) => {
+		if (attempt < 3) return new Promise((res) => setTimeout(res, 500 * 2 ** attempt)).then(() => tryLoad(attempt + 1));
+		if (typeof window !== "undefined" && isStaleChunk(err)) {
+			window.location.reload();
+			return;
+		}
+		router._erroredChunks.add(record);
+		router._loadingSignal.update((n) => n + 1);
+	});
+	tryLoad(0);
+	return raw.loadingComponent ? h(raw.loadingComponent, {}) : null;
+}
+/**
+* Wraps the route component with a LoaderDataProvider so `useLoaderData()` works
+* inside the component. If the record has no loader, renders the component directly.
+*/
+function renderWithLoader(router, record, Comp, route) {
+	const routeProps = {
+		params: route.params,
+		query: route.query,
+		meta: route.meta
+	};
+	if (!record.loader) return h(Comp, routeProps);
+	const data = router._loaderData.get(record);
+	if (data === void 0 && record.errorComponent) return h(record.errorComponent, routeProps);
+	return h(LoaderDataProvider, {
+		data,
+		children: h(Comp, routeProps)
+	});
+}
+/**
+* Thin provider component that pushes LoaderDataContext before children mount.
+* Uses Pyreon's context stack so useLoaderData() reads it during child setup.
+*/
+function LoaderDataProvider(props) {
+	pushContext(new Map([[LoaderDataContext.id, props.data]]));
+	onUnmount(() => popContext());
+	return props.children;
+}
+/** Evict oldest cache entries when the component cache exceeds maxCacheSize. */
+function cacheSet(router, record, comp) {
+	router._componentCache.set(record, comp);
+	if (router._componentCache.size > router._maxCacheSize) {
+		const oldest = router._componentCache.keys().next().value;
+		router._componentCache.delete(oldest);
+	}
+}
+/**
+* Segment-aware prefix check for active link matching.
+* `/admin` is a prefix of `/admin/users` but NOT of `/admin-panel`.
+*/
+function isSegmentPrefix(current, target) {
+	if (target === "/") return false;
+	const cs = current.split("/").filter(Boolean);
+	const ts = target.split("/").filter(Boolean);
+	if (ts.length > cs.length) return false;
+	return ts.every((seg, i) => seg === cs[i]);
+}
+/**
+* Detect a stale chunk error — happens post-deploy when the browser requests
+* a hashed filename that no longer exists on the server. Trigger a full reload
+* so the user gets the new bundle instead of a broken loading state.
+*/
+function isStaleChunk(err) {
+	if (err instanceof TypeError && String(err.message).includes("Failed to fetch")) return true;
+	if (err instanceof SyntaxError) return true;
+	return false;
+}
+
+//#endregion
+export { RouterContext, RouterLink, RouterProvider, RouterView, buildPath, createRouter, findRouteByName, hydrateLoaderData, lazy, parseQuery, parseQueryMulti, prefetchLoaderData, resolveRoute, serializeLoaderData, stringifyQuery, useLoaderData, useRoute, useRouter };
+//# sourceMappingURL=index.js.map