@pracht/core 0.8.0 → 0.9.0

package/dist/prefetch-api-Bf-P7XFo.d.mts

@@ -0,0 +1,39 @@
+import { J as RouteId, at as RouteTarget } from "./types-B-sfVjaH.mjs";
+import { FunctionComponent } from "preact";
+
+//#region src/forwardRef.d.ts
+/**
+ * Pass ref down to a child. This is mainly used in libraries with HOCs that
+ * wrap components. Using `forwardRef` there is an easy way to get a reference
+ * of the wrapped component instead of one of the wrapper itself.
+ */
+declare function forwardRef<P = {}>(fn: ((props: P, ref: any) => any) & {
+  displayName?: string;
+}): FunctionComponent<P & {
+  ref?: any;
+}>;
+//#endregion
+//#region src/hydration.d.ts
+/**
+ * Returns `true` once the initial hydration (including all Suspense
+ * boundaries) has fully resolved. During SSR and hydration this returns
+ * `false`.
+ */
+declare function useIsHydrated(): boolean;
+//#endregion
+//#region src/prefetch-api.d.ts
+interface PrefetchFn {
+  (to: string): Promise<void>;
+  <TRoute extends RouteId>(to: RouteTarget<TRoute>): Promise<void>;
+}
+/**
+ * Imperatively prefetch a route: warms the route/shell module chunks and
+ * caches the route-state JSON in the shared prefetch cache. Accepts an href
+ * string or a typed route target (`{ route, params, search }`).
+ *
+ * Available once the client router has initialized; a no-op during SSR,
+ * before hydration, and for URLs that do not match a client route.
+ */
+declare const prefetch: PrefetchFn;
+//#endregion
+export { forwardRef as i, prefetch as n, useIsHydrated as r, PrefetchFn as t };

package/dist/prefetch-api-ChSCTbEB.mjs

@@ -0,0 +1,69 @@
+import { o as matchAppRoute, t as buildHref } from "./app-CGRKjZ6Z.mjs";
+import { a as removeCachedRouteState, c as fetchPrachtRouteState, d as routeNeedsServerFetch, i as getCachedRouteState, n as cacheRouteState, t as EMPTY_ROUTE_STATE_PROMISE } from "./prefetch-cache-BNLEp9H5.mjs";
+//#region src/prefetch-api.ts
+/**
+* Imperative prefetch surface shared by the lazy prefetch listeners
+* (`prefetch.ts`), the client router, and userland code via the public
+* `prefetch()` export. Kept separate from `prefetch.ts` so importing the
+* public API does not pull the document-level listener setup into the
+* critical hydration path — every module imported here is already part of
+* the core client bundle.
+*/
+let activePrefetchTarget = null;
+/**
+* Called by the client router during initialization so prefetching can match
+* URLs against the resolved app and warm route/shell module chunks.
+*/
+function registerPrefetchTarget(app, warmModules) {
+	activePrefetchTarget = {
+		app,
+		warmModules
+	};
+}
+/**
+* Fetch (or reuse) the route-state JSON for `url` and store it in the shared
+* bounded prefetch cache so a subsequent client navigation can consume it
+* without a second network request. Rejected fetches are evicted from the
+* cache so a transient network error does not poison later navigations.
+*/
+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);
+	promise.catch(() => removeCachedRouteState(url, promise));
+	return promise;
+}
+/**
+* Imperatively prefetch a route: warms the route/shell module chunks and
+* caches the route-state JSON in the shared prefetch cache. Accepts an href
+* string or a typed route target (`{ route, params, search }`).
+*
+* Available once the client router has initialized; a no-op during SSR,
+* before hydration, and for URLs that do not match a client route.
+*/
+const prefetch = async (to) => {
+	if (typeof window === "undefined") return;
+	const target = activePrefetchTarget;
+	if (!target) return;
+	let href;
+	try {
+		href = typeof to === "string" ? to : buildHref(target.app.routes, to.route, to);
+	} catch {
+		return;
+	}
+	let url;
+	try {
+		url = new URL(href, window.location.href);
+	} catch {
+		return;
+	}
+	if (url.origin !== window.location.origin) return;
+	const match = matchAppRoute(target.app, url.pathname);
+	if (!match) return;
+	target.warmModules?.(match);
+	await prefetchRouteState(url.pathname + url.search, match.route).catch(() => {});
+};
+//#endregion
+export { prefetchRouteState as n, registerPrefetchTarget as r, prefetch as t };

package/dist/{prefetch-cache-DzP2Bj9H.mjs → prefetch-cache-BNLEp9H5.mjs}

@@ -4,6 +4,9 @@ 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 = {};
+const PREFETCH_ATTRIBUTE = "data-pracht-prefetch";
+const PRESERVE_SCROLL_ATTRIBUTE = "data-pracht-preserve-scroll";
+const VIEW_TRANSITION_ATTRIBUTE = "data-pracht-view-transition";
 //#endregion
 //#region src/runtime-client-fetch.ts
 const SAFE_NAVIGATION_PROTOCOLS = new Set(["http:", "https:"]);
@@ -115,6 +118,14 @@ function cacheRouteState(url, promise) {
 	});
 	trimMapToSize(prefetchCache, MAX_PREFETCH_CACHE_ENTRIES);
 }
+/**
+* Remove a cached entry, but only when it still holds `promise` — a newer
+* entry cached under the same URL must not be evicted by an older rejection.
+*/
+function removeCachedRouteState(url, promise) {
+	const entry = prefetchCache.get(url);
+	if (entry && entry.promise === promise) prefetchCache.delete(url);
+}
 function sweepPrefetchCache(now = Date.now()) {
 	for (const [url, entry] of prefetchCache) if (now - entry.timestamp > CACHE_TTL_MS) prefetchCache.delete(url);
 }
@@ -126,4 +137,4 @@ function trimMapToSize(map, maxEntries) {
 	}
 }
 //#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 };
+export { ROUTE_STATE_REQUEST_HEADER as _, removeCachedRouteState as a, fetchPrachtRouteState as c, routeNeedsServerFetch as d, EMPTY_ROUTE_PARAMS as f, ROUTE_STATE_CACHE_CONTROL as g, PRESERVE_SCROLL_ATTRIBUTE as h, getCachedRouteState as i, navigateToClientLocation as l, PREFETCH_ATTRIBUTE as m, cacheRouteState as n, trimMapToSize as o, HYDRATION_STATE_ELEMENT_ID as p, clearPrefetchCache as r, buildRouteStateUrl as s, EMPTY_ROUTE_STATE_PROMISE as t, parseSafeNavigationUrl as u, SAFE_METHODS as v, VIEW_TRANSITION_ATTRIBUTE as y };

package/dist/{prerender-B8_CqYwd.d.mts → prerender-BV42B9jK.d.mts}

@@ -1,4 +1,27 @@
-import { H as ModuleRegistry, W as PrachtApp, X as ResolvedApiRoute, lt as RouteRevalidate } from "./app-BWriseLj.mjs";
+import { F as PrachtApp, N as ModuleRegistry, V as ResolvedApiRoute, nt as RouteRevalidate } from "./types-B-sfVjaH.mjs";
+//#region src/runtime-timing.d.ts
+/**
+ * Per-request phase timing for dev tooling.
+ *
+ * The runtime only records durations when a collector object is passed via
+ * `HandlePrachtRequestOptions.timings` — the dev server passes one, production
+ * adapters never do, so production requests skip all timing work.
+ */
+interface PrachtPhaseTimings {
+  /** Milliseconds spent in the middleware chain, excluding loader and render. */
+  mw?: number;
+  /** Milliseconds spent awaiting the route loader. */
+  loader?: number;
+  /** Milliseconds spent resolving modules and rendering the response, excluding the loader. */
+  render?: number;
+}
+/**
+ * Format collected phase timings as a standards-compliant `Server-Timing`
+ * header value, e.g. `mw;dur=1.2, loader;dur=14.8, render;dur=3.1`.
+ * Returns an empty string when nothing was recorded.
+ */
+declare function formatServerTimingHeader(timings: PrachtPhaseTimings): string;
+//#endregion
 //#region src/runtime-headers.d.ts
 declare function applyDefaultSecurityHeaders(headers: Headers): Headers;
 //#endregion
@@ -16,6 +39,12 @@ interface HandlePrachtRequestOptions<TContext = unknown> {
   /** Per-source-file JS chunk map produced by the vite plugin for modulepreload hints. */
   jsManifest?: Record<string, string[]>;
   apiRoutes?: ResolvedApiRoute[];
+  /**
+   * Dev-only phase-timing collector. When provided, the runtime records
+   * middleware/loader/render durations (ms) onto it so callers can emit a
+   * `Server-Timing` header. Leave unset in production — no timing work runs.
+   */
+  timings?: PrachtPhaseTimings;
 }
 declare function handlePrachtRequest<TContext>(options: HandlePrachtRequestOptions<TContext>): Promise<Response>;
 //#endregion
@@ -48,4 +77,4 @@ 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 };
+export { prerenderApp as a, applyDefaultSecurityHeaders as c, PrerenderResult as i, PrachtPhaseTimings as l, PrerenderAppOptions as n, HandlePrachtRequestOptions as o, PrerenderAppResult as r, handlePrachtRequest as s, ISGManifestEntry as t, formatServerTimingHeader as u };

package/dist/{prerender-D3E2H96p.mjs → prerender-C8BpANz3.mjs}

@@ -1,7 +1,7 @@
-import { a as matchApiRoute, c as resolveApp, n as buildPathFromSegments, o as matchAppRoute } from "./app-BvC1uQG5.mjs";
-import { _ as applyDefaultSecurityHeaders, b as withDefaultSecurityHeaders, c as mergeDocumentHeaders, d as runMiddlewareChain, f as resolveDataFunctions, g as appendVaryHeader, h as resolveRegistryModule, l as mergeHeadMetadata, m as resolvePageJsUrls, p as resolvePageCssUrls, v as applyHeaders, x as withRouteResponseHeaders, y as applySecurityAndRouteHeaders } from "./types-idmK5omD.mjs";
-import { f as HYDRATION_STATE_ELEMENT_ID, h as SAFE_METHODS, m as ROUTE_STATE_REQUEST_HEADER, o as buildRouteStateUrl } from "./prefetch-cache-DzP2Bj9H.mjs";
-import { a as buildRuntimeDiagnostics, c as normalizeRouteError, l as shouldExposeServerErrors, o as createSerializedRouteError, s as deserializeRouteError, t as PrachtRuntimeProvider } from "./runtime-context-B5pREhcM.mjs";
+import { a as matchApiRoute, c as resolveApp, n as buildPathFromSegments, o as matchAppRoute } from "./app-CGRKjZ6Z.mjs";
+import { S as withRouteResponseHeaders, _ as appendVaryHeader, b as applySecurityAndRouteHeaders, f as runMiddlewareChain, g as resolveRegistryModule, h as resolvePageJsUrls, l as mergeDocumentHeaders, m as resolvePageCssUrls, p as resolveDataFunctions, u as mergeHeadMetadata, v as applyDefaultSecurityHeaders, x as withDefaultSecurityHeaders, y as applyHeaders } from "./types-DEPXdbyp.mjs";
+import { _ as ROUTE_STATE_REQUEST_HEADER, p as HYDRATION_STATE_ELEMENT_ID, s as buildRouteStateUrl, v as SAFE_METHODS } from "./prefetch-cache-BNLEp9H5.mjs";
+import { d as buildRuntimeDiagnostics, f as createSerializedRouteError, h as shouldExposeServerErrors, m as normalizeRouteError, p as deserializeRouteError, s as PrachtRuntimeProvider } from "./navigation-state-BjwXTeVz.mjs";
 import { h } from "preact";
 //#region src/runtime-html.ts
 function escapeHtml(str) {
@@ -249,11 +249,9 @@ function prefersMarkdown(accept) {
 	if (!html) return true;
 	return md.quality >= html.quality;
 }
-function markdownResponse(source) {
-	const headers = new Headers({
-		"content-type": "text/markdown; charset=utf-8",
-		"cache-control": "public, max-age=0, must-revalidate"
-	});
+function markdownResponse(source, initHeaders) {
+	const headers = new Headers(initHeaders);
+	headers.set("content-type", "text/markdown; charset=utf-8");
 	appendVaryHeader(headers, "Accept");
 	applyDefaultSecurityHeaders(headers);
 	return new Response(source, {
@@ -262,6 +260,29 @@ function markdownResponse(source) {
 	});
 }
 //#endregion
+//#region src/runtime-timing.ts
+const PHASE_ORDER = [
+	"mw",
+	"loader",
+	"render"
+];
+/**
+* Format collected phase timings as a standards-compliant `Server-Timing`
+* header value, e.g. `mw;dur=1.2, loader;dur=14.8, render;dur=3.1`.
+* Returns an empty string when nothing was recorded.
+*/
+function formatServerTimingHeader(timings) {
+	const entries = [];
+	for (const phase of PHASE_ORDER) {
+		const duration = timings[phase];
+		if (typeof duration === "number" && Number.isFinite(duration)) entries.push(`${phase};dur=${formatDuration(duration)}`);
+	}
+	return entries.join(", ");
+}
+function formatDuration(duration) {
+	return String(Math.max(0, Math.round(duration * 10) / 10));
+}
+//#endregion
 //#region src/runtime.ts
 const SAME_ORIGIN_FETCH_SITE = "same-origin";
 /**
@@ -433,6 +454,7 @@ async function handlePrachtRequest(options) {
 	let shellModule;
 	let loaderFile;
 	let currentPhase = "middleware";
+	const timings = options.timings;
 	try {
 		const routeModulePromise = resolveRegistryModule(registry.routeModules, match.route.file);
 		const shellModulePromise = match.route.shellFile ? resolveRegistryModule(registry.shellModules, match.route.shellFile) : Promise.resolve(void 0);
@@ -444,17 +466,22 @@ async function handlePrachtRequest(options) {
 			currentPhase = "render";
 			routeModule = await routeModulePromise;
 			if (!routeModule) throw new Error("Route module not found");
-			if (!isRouteStateRequest && typeof routeModule.markdown === "string" && prefersMarkdown(options.request.headers.get("accept"))) return markdownResponse(routeModule.markdown);
 			currentPhase = "loader";
 			const { loader, loaderFile: resolvedLoaderFile } = await dataFunctionsPromise;
 			loaderFile = resolvedLoaderFile;
-			const loaderResult = loader ? await loader(routeArgs) : void 0;
+			let loaderResult;
+			if (loader) {
+				const loaderStart = timings ? performance.now() : 0;
+				loaderResult = await loader(routeArgs);
+				if (timings) timings.loader = performance.now() - loaderStart;
+			}
 			if (loaderResult instanceof Response) return loaderResult;
 			const data = loaderResult;
 			if (isRouteStateRequest) return Response.json({ data });
 			currentPhase = "render";
 			shellModule = await shellModulePromise;
 			const [head, documentHeaders] = await Promise.all([mergeHeadMetadata(shellModule, routeModule, routeArgs, data), mergeDocumentHeaders(shellModule, routeModule, routeArgs, data)]);
+			if (!isRouteStateRequest && typeof routeModule.markdown === "string" && prefersMarkdown(options.request.headers.get("accept"))) return markdownResponse(routeModule.markdown, documentHeaders);
 			const cssUrls = resolvePageCssUrls(options.cssManifest, match.route.shellFile, match.route.file);
 			const modulePreloadUrls = resolvePageJsUrls(options.jsManifest, match.route.shellFile, match.route.file);
 			if (match.route.render === "spa") {
@@ -519,7 +546,20 @@ async function handlePrachtRequest(options) {
 				modulePreloadUrls
 			}), 200, documentHeaders);
 		};
-		return normalizePageResponse(await runMiddlewareChain({
+		let terminal = pageTerminal;
+		let chainStart = 0;
+		if (timings) {
+			terminal = async () => {
+				const terminalStart = performance.now();
+				try {
+					return await pageTerminal();
+				} finally {
+					timings.render = performance.now() - terminalStart - (timings.loader ?? 0);
+				}
+			};
+			chainStart = performance.now();
+		}
+		const response = await runMiddlewareChain({
 			context: pageContext,
 			middlewareFiles: match.route.middlewareFiles,
 			params: match.params,
@@ -528,8 +568,10 @@ async function handlePrachtRequest(options) {
 			route: match.route,
 			signal: requestSignal,
 			url,
-			terminal: pageTerminal
-		}), { isRouteStateRequest });
+			terminal
+		});
+		if (timings) timings.mw = performance.now() - chainStart - (timings.render ?? 0) - (timings.loader ?? 0);
+		return normalizePageResponse(response, { isRouteStateRequest });
 	} catch (error) {
 		return renderRouteErrorResponse({
 			error,
@@ -645,4 +687,4 @@ async function collectSSGPaths(route, registry) {
 	return (await routeModule.getStaticPaths()).map((params) => buildPathFromSegments(route.segments, params));
 }
 //#endregion
-export { handlePrachtRequest as n, prerenderApp as t };
+export { handlePrachtRequest as n, formatServerTimingHeader as r, prerenderApp as t };

package/dist/{router-BcUmg1kB.d.mts → router-B_Aj5TtY.d.mts}

@@ -1,5 +1,5 @@
-import { U as NavigateOptions, Z as ResolvedPrachtApp, dt as RouteTarget, nt as RouteId } from "./app-BWriseLj.mjs";
-import { t as PrachtHydrationState } from "./runtime-context-ytVd7GmZ.mjs";
+import { H as ResolvedPrachtApp, J as RouteId, P as NavigateOptions, at as RouteTarget } from "./types-B-sfVjaH.mjs";
+import { t as PrachtHydrationState } from "./runtime-context-BYBwVA0M.mjs";
 
 //#region src/router.d.ts
 declare global {