@pracht/core 0.7.0 → 0.8.1

package/dist/manifest.d.mts

@@ -0,0 +1,2 @@
+import { G as PrachtAppConfig, V as ModuleRef, W as PrachtApp, Y as RenderMode, b as GroupDefinition, et as RouteConfig, ft as RouteTreeNode, i as group, it as RouteMeta, l as route, lt as RouteRevalidate, r as defineApp, tt as RouteDefinition, u as timeRevalidate, vt as TimeRevalidatePolicy, x as GroupMeta } from "./app-BWriseLj.mjs";
+export { type GroupDefinition, type GroupMeta, type ModuleRef, type PrachtApp, type PrachtAppConfig, type RenderMode, type RouteConfig, type RouteDefinition, type RouteMeta, type RouteRevalidate, type RouteTreeNode, type TimeRevalidatePolicy, defineApp, group, route, timeRevalidate };

package/dist/manifest.mjs

@@ -0,0 +1,2 @@
+import { i as group, l as route, r as defineApp, u as timeRevalidate } from "./app-w-P1wf5T.mjs";
+export { defineApp, group, route, timeRevalidate };

package/dist/prefetch-D9amIQtw.mjs

@@ -0,0 +1,118 @@
+import { o as matchAppRoute } from "./app-w-P1wf5T.mjs";
+import { a as trimMapToSize, i as getCachedRouteState, n as cacheRouteState, s as fetchPrachtRouteState, t as EMPTY_ROUTE_STATE_PROMISE, u as routeNeedsServerFetch } from "./prefetch-cache-DzP2Bj9H.mjs";
+//#region src/prefetch.ts
+const MAX_MATCH_CACHE_ENTRIES = 250;
+function prefetchRouteState(url, route) {
+	if (route && !routeNeedsServerFetch(route)) return EMPTY_ROUTE_STATE_PROMISE;
+	const cached = getCachedRouteState(url);
+	if (cached) return cached;
+	const promise = fetchPrachtRouteState(url);
+	cacheRouteState(url, promise);
+	return promise;
+}
+function setupPrefetching(app, warmModules) {
+	let hoverTimer = null;
+	const observedViewportAnchors = /* @__PURE__ */ new WeakSet();
+	const matchCache = /* @__PURE__ */ new Map();
+	function getRoutePathname(url) {
+		try {
+			return new URL(url, window.location.origin).pathname;
+		} catch {
+			return null;
+		}
+	}
+	function getInternalHref(anchor) {
+		const href = anchor.getAttribute("href");
+		if (!href || href.startsWith("#")) return null;
+		let url;
+		try {
+			url = new URL(href, window.location.origin);
+		} catch {
+			return null;
+		}
+		if (url.origin !== window.location.origin) return null;
+		return url.pathname + url.search;
+	}
+	function getMatchEntry(href) {
+		const cached = matchCache.get(href);
+		if (cached) {
+			matchCache.delete(href);
+			matchCache.set(href, cached);
+			return cached;
+		}
+		const routePathname = getRoutePathname(href);
+		const match = routePathname ? matchAppRoute(app, routePathname) ?? null : null;
+		const entry = {
+			match,
+			strategy: match ? match.route.prefetch ?? "intent" : "none"
+		};
+		matchCache.set(href, entry);
+		trimMapToSize(matchCache, MAX_MATCH_CACHE_ENTRIES);
+		return entry;
+	}
+	function prefetchHref(href) {
+		const match = getMatchEntry(href).match;
+		prefetchRouteState(href, match?.route);
+		if (warmModules && match) warmModules(match);
+	}
+	document.addEventListener("mouseenter", (e) => {
+		const anchor = e.target.closest?.("a");
+		if (!anchor) return;
+		const href = getInternalHref(anchor);
+		if (!href) return;
+		const strategy = getMatchEntry(href).strategy;
+		if (strategy !== "hover" && strategy !== "intent") return;
+		if (hoverTimer) clearTimeout(hoverTimer);
+		hoverTimer = setTimeout(() => {
+			prefetchHref(href);
+		}, 50);
+	}, true);
+	document.addEventListener("mouseleave", (e) => {
+		if (!e.target.closest?.("a")) return;
+		if (hoverTimer) {
+			clearTimeout(hoverTimer);
+			hoverTimer = null;
+		}
+	}, true);
+	document.addEventListener("focusin", (e) => {
+		const anchor = e.target.closest?.("a");
+		if (!anchor) return;
+		const href = getInternalHref(anchor);
+		if (!href) return;
+		const strategy = getMatchEntry(href).strategy;
+		if (strategy !== "hover" && strategy !== "intent") return;
+		prefetchHref(href);
+	}, true);
+	if (typeof IntersectionObserver === "undefined") return;
+	const observer = new IntersectionObserver((entries) => {
+		for (const entry of entries) {
+			if (!entry.isIntersecting) continue;
+			const anchor = entry.target;
+			const href = getInternalHref(anchor);
+			if (!href) continue;
+			prefetchHref(href);
+			observer.unobserve(anchor);
+		}
+	}, { rootMargin: "200px" });
+	function observeAnchor(anchor) {
+		if (observedViewportAnchors.has(anchor)) return;
+		const href = getInternalHref(anchor);
+		if (!href) return;
+		if (getMatchEntry(href).strategy !== "viewport") return;
+		observedViewportAnchors.add(anchor);
+		observer.observe(anchor);
+	}
+	function observeViewportLinks(root) {
+		if (root instanceof HTMLAnchorElement) observeAnchor(root);
+		for (const anchor of root.querySelectorAll("a[href]")) observeAnchor(anchor);
+	}
+	observeViewportLinks(document.body);
+	new MutationObserver((records) => {
+		for (const record of records) for (const node of record.addedNodes) if (node instanceof HTMLElement || node instanceof DocumentFragment) observeViewportLinks(node);
+	}).observe(document.body, {
+		childList: true,
+		subtree: true
+	});
+}
+//#endregion
+export { setupPrefetching };

package/dist/prefetch-cache-DzP2Bj9H.mjs

@@ -0,0 +1,129 @@
+//#region src/runtime-constants.ts
+const SAFE_METHODS = new Set(["GET", "HEAD"]);
+const HYDRATION_STATE_ELEMENT_ID = "pracht-state";
+const ROUTE_STATE_REQUEST_HEADER = "x-pracht-route-state-request";
+const ROUTE_STATE_CACHE_CONTROL = "no-store";
+const EMPTY_ROUTE_PARAMS = {};
+//#endregion
+//#region src/runtime-client-fetch.ts
+const SAFE_NAVIGATION_PROTOCOLS = new Set(["http:", "https:"]);
+/**
+* Parse a possibly-server-supplied redirect target against a base URL and
+* return it only if it uses a safe navigation scheme (`http:` or `https:`).
+*
+* `javascript:`, `data:`, `vbscript:`, `blob:`, `file:` and similar schemes
+* can execute script or bypass same-origin assumptions when assigned to
+* `window.location.href` — a server-controlled redirect (from a loader,
+* middleware, form action response, or API route) must never be able to
+* trigger them. Returns `null` for unsafe or unparseable inputs.
+*/
+function parseSafeNavigationUrl(location, base) {
+	let targetUrl;
+	try {
+		targetUrl = new URL(location, base);
+	} catch {
+		return null;
+	}
+	if (!SAFE_NAVIGATION_PROTOCOLS.has(targetUrl.protocol)) return null;
+	return targetUrl;
+}
+function routeNeedsServerFetch(route) {
+	if (route.hasLoader === false && route.middlewareFiles.length === 0) return false;
+	return true;
+}
+function buildRouteStateUrl(url) {
+	return `${url}${url.includes("?") ? "&" : "?"}_data=1`;
+}
+async function fetchPrachtRouteState(url, options) {
+	const fetchUrl = options?.useDataParam ? buildRouteStateUrl(url) : url;
+	const response = await fetch(fetchUrl, {
+		headers: options?.useDataParam ? {} : {
+			[ROUTE_STATE_REQUEST_HEADER]: "1",
+			"Cache-Control": "no-cache"
+		},
+		redirect: "manual",
+		signal: options?.signal
+	});
+	if (response.type === "opaqueredirect" || response.status >= 300 && response.status < 400) return {
+		location: response.headers.get("location") ?? url,
+		type: "redirect"
+	};
+	const json = await response.json();
+	if (json.redirect) return {
+		location: json.redirect,
+		type: "redirect"
+	};
+	if (!response.ok) {
+		if (json.error) return {
+			error: json.error,
+			type: "error"
+		};
+		throw new Error(`Failed to fetch route state (${response.status})`);
+	}
+	return {
+		data: json.data,
+		type: "data"
+	};
+}
+async function navigateToClientLocation(location, options) {
+	if (typeof window === "undefined") return;
+	const targetUrl = parseSafeNavigationUrl(location, window.location.href);
+	if (!targetUrl) {
+		console.error(`[pracht] refused to navigate to unsafe URL: ${location}`);
+		return;
+	}
+	const target = targetUrl.pathname + targetUrl.search + targetUrl.hash;
+	if (targetUrl.origin === window.location.origin && window.__PRACHT_NAVIGATE__) {
+		await window.__PRACHT_NAVIGATE__(target, options);
+		return;
+	}
+	if (options?.replace) {
+		window.location.replace(targetUrl.toString());
+		return;
+	}
+	window.location.href = targetUrl.toString();
+}
+//#endregion
+//#region src/prefetch-cache.ts
+const CACHE_TTL_MS = 3e4;
+const MAX_PREFETCH_CACHE_ENTRIES = 100;
+const EMPTY_ROUTE_STATE = {
+	type: "data",
+	data: void 0
+};
+const prefetchCache = /* @__PURE__ */ new Map();
+const EMPTY_ROUTE_STATE_PROMISE = Promise.resolve(EMPTY_ROUTE_STATE);
+function clearPrefetchCache() {
+	prefetchCache.clear();
+}
+function getCachedRouteState(url) {
+	const entry = prefetchCache.get(url);
+	if (!entry) return null;
+	if (Date.now() - entry.timestamp > CACHE_TTL_MS) {
+		prefetchCache.delete(url);
+		return null;
+	}
+	prefetchCache.delete(url);
+	prefetchCache.set(url, entry);
+	return entry.promise;
+}
+function cacheRouteState(url, promise) {
+	sweepPrefetchCache();
+	prefetchCache.set(url, {
+		promise,
+		timestamp: Date.now()
+	});
+	trimMapToSize(prefetchCache, MAX_PREFETCH_CACHE_ENTRIES);
+}
+function sweepPrefetchCache(now = Date.now()) {
+	for (const [url, entry] of prefetchCache) if (now - entry.timestamp > CACHE_TTL_MS) prefetchCache.delete(url);
+}
+function trimMapToSize(map, maxEntries) {
+	while (map.size > maxEntries) {
+		const first = map.keys().next();
+		if (first.done) return;
+		map.delete(first.value);
+	}
+}
+//#endregion
+export { trimMapToSize as a, navigateToClientLocation as c, EMPTY_ROUTE_PARAMS as d, HYDRATION_STATE_ELEMENT_ID as f, SAFE_METHODS as h, getCachedRouteState as i, parseSafeNavigationUrl as l, ROUTE_STATE_REQUEST_HEADER as m, cacheRouteState as n, buildRouteStateUrl as o, ROUTE_STATE_CACHE_CONTROL as p, clearPrefetchCache as r, fetchPrachtRouteState as s, EMPTY_ROUTE_STATE_PROMISE as t, routeNeedsServerFetch as u };

package/dist/prerender-B8_CqYwd.d.mts

@@ -0,0 +1,51 @@
+import { H as ModuleRegistry, W as PrachtApp, X as ResolvedApiRoute, lt as RouteRevalidate } from "./app-BWriseLj.mjs";
+//#region src/runtime-headers.d.ts
+declare function applyDefaultSecurityHeaders(headers: Headers): Headers;
+//#endregion
+//#region src/runtime.d.ts
+interface HandlePrachtRequestOptions<TContext = unknown> {
+  app: PrachtApp;
+  request: Request;
+  context?: TContext;
+  registry?: ModuleRegistry;
+  /** Expose raw server error details in rendered HTML and route-state JSON. */
+  debugErrors?: boolean;
+  clientEntryUrl?: string;
+  /** Per-source-file CSS map produced by the vite plugin. */
+  cssManifest?: Record<string, string[]>;
+  /** Per-source-file JS chunk map produced by the vite plugin for modulepreload hints. */
+  jsManifest?: Record<string, string[]>;
+  apiRoutes?: ResolvedApiRoute[];
+}
+declare function handlePrachtRequest<TContext>(options: HandlePrachtRequestOptions<TContext>): Promise<Response>;
+//#endregion
+//#region src/prerender.d.ts
+interface PrerenderResult {
+  path: string;
+  html: string;
+  headers?: Record<string, string>;
+}
+interface ISGManifestEntry {
+  revalidate: RouteRevalidate;
+}
+interface PrerenderAppResult {
+  pages: PrerenderResult[];
+  isgManifest: Record<string, ISGManifestEntry>;
+}
+interface PrerenderAppOptions {
+  app: PrachtApp;
+  registry?: ModuleRegistry;
+  clientEntryUrl?: string;
+  /** Per-source-file CSS map produced by the vite plugin. */
+  cssManifest?: Record<string, string[]>;
+  /** Per-source-file JS map produced by the vite plugin for modulepreload hints. */
+  jsManifest?: Record<string, string[]>;
+  /** Maximum number of pages rendered concurrently. Defaults to 10. */
+  concurrency?: number;
+}
+declare function prerenderApp(options: PrerenderAppOptions): Promise<PrerenderResult[]>;
+declare function prerenderApp(options: PrerenderAppOptions & {
+  withISGManifest: true;
+}): Promise<PrerenderAppResult>;
+//#endregion
+export { prerenderApp as a, applyDefaultSecurityHeaders as c, PrerenderResult as i, PrerenderAppOptions as n, HandlePrachtRequestOptions as o, PrerenderAppResult as r, handlePrachtRequest as s, ISGManifestEntry as t };