@pracht/core 0.8.0 → 0.9.0

package/dist/{runtime-middleware-aeBdgjYr.d.mts → runtime-middleware-pYubngnL.d.mts}

@@ -1,26 +1,79 @@
-import { A as HrefRouteDefinition, F as LoaderLike, N as LoaderData, O as HrefFn, dt as RouteTarget, nt as RouteId, st as RouteParams } from "./app-BWriseLj.mjs";
-import { c as SerializedRouteError } from "./runtime-context-ytVd7GmZ.mjs";
+import { E as LoaderLike, J as RouteId, K as RouteDataFor, S as LinkPrefetchStrategy, at as RouteTarget, b as HrefRouteDefinition, et as RouteParams, v as HrefFn, w as LoaderData } from "./types-B-sfVjaH.mjs";
+import { c as SerializedRouteError } from "./runtime-context-BYBwVA0M.mjs";
 import * as _$preact from "preact";
 import { JSX, h } from "preact";
 
 //#region src/href.d.ts
 declare function createHref(routes: readonly HrefRouteDefinition[]): HrefFn;
 //#endregion
+//#region src/navigation-state.d.ts
+/**
+ * Shared reactive store for the current client navigation / form submission.
+ *
+ * The client router (`router.ts`) and `<Form>` (`runtime-hooks.ts`) write to
+ * this store; `useNavigation()` subscribes to it. The store lives in its own
+ * module so both writers can import it without creating a cycle, and so it
+ * stays safe to import during SSR (no `window` access at module scope).
+ */
+interface NavigationLocation {
+  pathname: string;
+  search: string;
+  hash: string;
+  href: string;
+}
+type Navigation = {
+  state: "idle";
+  location?: undefined;
+  formData?: undefined;
+} | {
+  state: "loading";
+  location: NavigationLocation;
+  formData?: undefined;
+} | {
+  state: "submitting";
+  location: NavigationLocation;
+  formData: FormData;
+};
+//#endregion
 //#region src/runtime-hooks.d.ts
 interface FormProps extends Omit<JSX.HTMLAttributes<HTMLFormElement>, "action" | "method"> {
   action?: string;
   method?: string;
 }
-type LinkProps<TRoute extends RouteId = RouteId> = Omit<JSX.HTMLAttributes<HTMLAnchorElement>, "href"> & RouteTarget<TRoute>;
+type LinkProps<TRoute extends RouteId = RouteId> = Omit<JSX.HTMLAttributes<HTMLAnchorElement>, "href"> & RouteTarget<TRoute> & {
+  /**
+   * Prefetch strategy for this link, overriding the route-level strategy:
+   * `"intent"` (hover/focus), `"viewport"` (IntersectionObserver),
+   * `"render"` (as soon as the link mounts), or `"none"`. When omitted the
+   * route's `prefetch` meta applies (default: `"intent"`).
+   */
+  prefetch?: LinkPrefetchStrategy; /** Keep the current scroll position when this link navigates. */
+  preserveScroll?: boolean;
+  /**
+   * Wrap the navigation triggered by this link in
+   * `document.startViewTransition()` when supported.
+   */
+  viewTransition?: boolean;
+};
 interface Location {
   pathname: string;
   search: string;
 }
+declare function useRouteData<TRoute extends RouteId>(routeId: TRoute): RouteDataFor<TRoute>;
 declare function useRouteData<TLoader extends LoaderLike>(): LoaderData<TLoader>;
 declare function useRouteData<TData = unknown>(): TData;
 declare function useLocation(): Location;
 declare function useParams(): RouteParams;
 declare function useRevalidate(): () => Promise<unknown>;
+/**
+ * Reactive pending state for the current client navigation or `<Form>`
+ * submission. Returns `{ state: "idle" }` when nothing is in flight,
+ * `{ state: "loading", location }` while the router fetches and commits a
+ * navigation, and `{ state: "submitting", location, formData }` while a
+ * `<Form>` submission is awaiting its response. During SSR it always
+ * returns the idle state.
+ */
+declare function useNavigation(): Navigation;
 declare function Link<TRoute extends RouteId>(props: LinkProps<TRoute>): _$preact.VNode<_$preact.ClassAttributes<HTMLAnchorElement> & h.JSX.HTMLAttributes<HTMLAnchorElement>>;
 declare function Form(props: FormProps): _$preact.VNode<_$preact.ClassAttributes<HTMLFormElement> & h.JSX.HTMLAttributes<HTMLFormElement>>;
 //#endregion
@@ -74,4 +127,4 @@ type RedirectOptions = number | {
  */
 declare function redirect(target: string, options?: RedirectOptions): Response;
 //#endregion
-export { parseSafeNavigationUrl as a, Link as c, useLocation as d, useParams as f, createHref as h, fetchPrachtRouteState as i, LinkProps as l, useRouteData as m, redirect as n, Form as o, useRevalidate as p, RouteStateResult as r, FormProps as s, RedirectOptions as t, Location as u };
+export { NavigationLocation as _, parseSafeNavigationUrl as a, Link as c, useLocation as d, useNavigation as f, Navigation as g, useRouteData as h, fetchPrachtRouteState as i, LinkProps as l, useRevalidate as m, redirect as n, Form as o, useParams as p, RouteStateResult as r, FormProps as s, RedirectOptions as t, Location as u, createHref as v };

package/dist/server.d.mts

@@ -1,5 +1,7 @@
-import { $ as RouteComponentProps, A as HrefRouteDefinition, B as ModuleImporter, C as HeadAttributes, D as HrefArgs, E as HeadersArgs, G as PrachtAppConfig, H as ModuleRegistry, I as MiddlewareArgs, J as Register, K as PrachtHttpError, L as MiddlewareFn, M as LoaderArgs, N as LoaderData, O as HrefFn, P as LoaderFn, Q as ResolvedRoute, R as MiddlewareModule, S as HeadArgs, T as HeadScriptDescriptor, U as NavigateOptions, V as ModuleRef, W as PrachtApp, X as ResolvedApiRoute, Y as RenderMode, Z as ResolvedPrachtApp, _ as BuildHrefOptions, _t as ShellProps, a as matchApiRoute, at as RouteModule, b as GroupDefinition, c as resolveApp, ct as RouteParamsFor, d as ApiConfig, dt as RouteTarget, et as RouteConfig, f as ApiRouteArgs, ft as RouteTreeNode, g as BaseRouteArgs, gt as ShellModule, h as ApiRouteModule, ht as SearchParamsInput, i as group, it as RouteMeta, j as HttpMethod, k as HrefOptions, l as route, lt as RouteRevalidate, m as ApiRouteMatch, mt as SearchParamValue, n as buildPathFromSegments, nt as RouteId, o as matchAppRoute, ot as RouteParamInput, p as ApiRouteHandler, pt as SearchParamPrimitive, q as PrefetchStrategy, r as defineApp, rt as RouteMatch, s as resolveApiRoutes, st as RouteParams, t as buildHref, tt as RouteDefinition, u as timeRevalidate, ut as RouteSearchFor, v as DataModule, vt as TimeRevalidatePolicy, w as HeadMetadata, x as GroupMeta, y as ErrorBoundaryProps, z as MiddlewareNext } from "./app-BWriseLj.mjs";
-import { h as createHref, n as redirect, t as RedirectOptions } from "./runtime-middleware-aeBdgjYr.mjs";
-import { c as SerializedRouteError, n as PrachtRuntimeProvider, o as PrachtRuntimeDiagnosticPhase, s as PrachtRuntimeDiagnostics } from "./runtime-context-ytVd7GmZ.mjs";
-import { a as prerenderApp, c as applyDefaultSecurityHeaders, i as PrerenderResult, n as PrerenderAppOptions, o as HandlePrachtRequestOptions, r as PrerenderAppResult, s as handlePrachtRequest, t as ISGManifestEntry } from "./prerender-B8_CqYwd.mjs";
-export { type ApiConfig, type ApiRouteArgs, type ApiRouteHandler, type ApiRouteMatch, type ApiRouteModule, type BaseRouteArgs, type BuildHrefOptions, type DataModule, type ErrorBoundaryProps, type GroupDefinition, type GroupMeta, type HandlePrachtRequestOptions, type HeadArgs, type HeadAttributes, type HeadMetadata, type HeadScriptDescriptor, type HeadersArgs, type HrefArgs, type HrefFn, type HrefOptions, type HrefRouteDefinition, type HttpMethod, type ISGManifestEntry, type LoaderArgs, type LoaderData, type LoaderFn, type MiddlewareArgs, type MiddlewareFn, type MiddlewareModule, type MiddlewareNext, type ModuleImporter, type ModuleRef, type ModuleRegistry, type NavigateOptions, type PrachtApp, type PrachtAppConfig, PrachtHttpError, type PrachtRuntimeDiagnosticPhase, type PrachtRuntimeDiagnostics, PrachtRuntimeProvider, type PrefetchStrategy, type PrerenderAppOptions, type PrerenderAppResult, type PrerenderResult, type RedirectOptions, type Register, type RenderMode, type ResolvedApiRoute, type ResolvedPrachtApp, type ResolvedRoute, type RouteComponentProps, type RouteConfig, type RouteDefinition, type RouteId, type RouteMatch, type RouteMeta, type RouteModule, type RouteParamInput, type RouteParams, type RouteParamsFor, type RouteRevalidate, type RouteSearchFor, type RouteTarget, type RouteTreeNode, type SearchParamPrimitive, type SearchParamValue, type SearchParamsInput, type SerializedRouteError, type ShellModule, type ShellProps, type TimeRevalidatePolicy, applyDefaultSecurityHeaders, buildHref, buildPathFromSegments, createHref, defineApp, group, handlePrachtRequest, matchApiRoute, matchAppRoute, prerenderApp, redirect, resolveApiRoutes, resolveApp, route, timeRevalidate };
+import { $ as RouteParamInput, A as MiddlewareNext, B as RenderMode, C as LoaderArgs, D as MiddlewareArgs, F as PrachtApp, G as RouteConfig, H as ResolvedPrachtApp, I as PrachtAppConfig, J as RouteId, K as RouteDataFor, L as PrachtHttpError, M as ModuleRef, N as ModuleRegistry, O as MiddlewareFn, P as NavigateOptions, Q as RouteModule, R as PrefetchStrategy, T as LoaderFn, U as ResolvedRoute, V as ResolvedApiRoute, W as RouteComponentProps, X as RouteMatch, Y as RouteLoaderData, Z as RouteMeta, _ as HrefArgs, a as ApiRouteModule, at as RouteTarget, b as HrefRouteDefinition, c as DataModule, ct as SearchParamValue, d as GroupMeta, dt as ShellProps, et as RouteParams, f as HeadArgs, ft as TimeRevalidatePolicy, g as HeadersArgs, h as HeadScriptDescriptor, i as ApiRouteMatch, j as ModuleImporter, k as MiddlewareModule, l as ErrorBoundaryProps, lt as SearchParamsInput, m as HeadMetadata, n as ApiRouteArgs, nt as RouteRevalidate, o as BaseRouteArgs, ot as RouteTreeNode, p as HeadAttributes, q as RouteDefinition, r as ApiRouteHandler, rt as RouteSearchFor, s as BuildHrefOptions, st as SearchParamPrimitive, t as ApiConfig, tt as RouteParamsFor, u as GroupDefinition, ut as ShellModule, v as HrefFn, w as LoaderData, x as HttpMethod, y as HrefOptions, z as Register } from "./types-B-sfVjaH.mjs";
+import { a as matchApiRoute, c as resolveApp, i as group, l as route, n as buildPathFromSegments, o as matchAppRoute, r as defineApp, s as resolveApiRoutes, t as buildHref, u as timeRevalidate } from "./app-BN3pjxtw.mjs";
+import { n as redirect, t as RedirectOptions, v as createHref } from "./runtime-middleware-pYubngnL.mjs";
+import { c as SerializedRouteError, n as PrachtRuntimeProvider, o as PrachtRuntimeDiagnosticPhase, s as PrachtRuntimeDiagnostics } from "./runtime-context-BYBwVA0M.mjs";
+import { a as buildAppGraph, c as serializeAppRoutes, i as AppGraphRoute, n as AppGraphApiRoute, o as detectApiMethods, r as AppGraphModuleAccess, s as serializeApiRoutes, t as AppGraph } from "./app-graph-DBoDsHJ5.mjs";
+import { a as prerenderApp, c as applyDefaultSecurityHeaders, i as PrerenderResult, l as PrachtPhaseTimings, n as PrerenderAppOptions, o as HandlePrachtRequestOptions, r as PrerenderAppResult, s as handlePrachtRequest, t as ISGManifestEntry, u as formatServerTimingHeader } from "./prerender-BV42B9jK.mjs";
+export { type ApiConfig, type ApiRouteArgs, type ApiRouteHandler, type ApiRouteMatch, type ApiRouteModule, type AppGraph, type AppGraphApiRoute, type AppGraphModuleAccess, type AppGraphRoute, type BaseRouteArgs, type BuildHrefOptions, type DataModule, type ErrorBoundaryProps, type GroupDefinition, type GroupMeta, type HandlePrachtRequestOptions, type HeadArgs, type HeadAttributes, type HeadMetadata, type HeadScriptDescriptor, type HeadersArgs, type HrefArgs, type HrefFn, type HrefOptions, type HrefRouteDefinition, type HttpMethod, type ISGManifestEntry, type LoaderArgs, type LoaderData, type LoaderFn, type MiddlewareArgs, type MiddlewareFn, type MiddlewareModule, type MiddlewareNext, type ModuleImporter, type ModuleRef, type ModuleRegistry, type NavigateOptions, type PrachtApp, type PrachtAppConfig, PrachtHttpError, type PrachtPhaseTimings, type PrachtRuntimeDiagnosticPhase, type PrachtRuntimeDiagnostics, PrachtRuntimeProvider, type PrefetchStrategy, type PrerenderAppOptions, type PrerenderAppResult, type PrerenderResult, type RedirectOptions, type Register, type RenderMode, type ResolvedApiRoute, type ResolvedPrachtApp, type ResolvedRoute, type RouteComponentProps, type RouteConfig, type RouteDataFor, type RouteDefinition, type RouteId, type RouteLoaderData, type RouteMatch, type RouteMeta, type RouteModule, type RouteParamInput, type RouteParams, type RouteParamsFor, type RouteRevalidate, type RouteSearchFor, type RouteTarget, type RouteTreeNode, type SearchParamPrimitive, type SearchParamValue, type SearchParamsInput, type SerializedRouteError, type ShellModule, type ShellProps, type TimeRevalidatePolicy, applyDefaultSecurityHeaders, buildAppGraph, buildHref, buildPathFromSegments, createHref, defineApp, detectApiMethods, formatServerTimingHeader, group, handlePrachtRequest, matchApiRoute, matchAppRoute, prerenderApp, redirect, resolveApiRoutes, resolveApp, route, serializeApiRoutes, serializeAppRoutes, timeRevalidate };

package/dist/server.mjs

@@ -1,5 +1,6 @@
-import { a as matchApiRoute, c as resolveApp, i as group, l as route, n as buildPathFromSegments, o as matchAppRoute, r as defineApp, s as resolveApiRoutes, t as buildHref, u as timeRevalidate } from "./app-BvC1uQG5.mjs";
-import { S as createHref, _ as applyDefaultSecurityHeaders, t as PrachtHttpError, u as redirect } from "./types-idmK5omD.mjs";
-import { t as PrachtRuntimeProvider } from "./runtime-context-B5pREhcM.mjs";
-import { n as handlePrachtRequest, t as prerenderApp } from "./prerender-D3E2H96p.mjs";
-export { PrachtHttpError, PrachtRuntimeProvider, applyDefaultSecurityHeaders, buildHref, buildPathFromSegments, createHref, defineApp, group, handlePrachtRequest, matchApiRoute, matchAppRoute, prerenderApp, redirect, resolveApiRoutes, resolveApp, route, timeRevalidate };
+import { a as matchApiRoute, c as resolveApp, i as group, l as route, n as buildPathFromSegments, o as matchAppRoute, r as defineApp, s as resolveApiRoutes, t as buildHref, u as timeRevalidate } from "./app-CGRKjZ6Z.mjs";
+import { C as createHref, d as redirect, t as PrachtHttpError, v as applyDefaultSecurityHeaders } from "./types-DEPXdbyp.mjs";
+import { i as serializeAppRoutes, n as detectApiMethods, r as serializeApiRoutes, t as buildAppGraph } from "./app-graph-BlaCcGUZ.mjs";
+import { s as PrachtRuntimeProvider } from "./navigation-state-BjwXTeVz.mjs";
+import { n as handlePrachtRequest, r as formatServerTimingHeader, t as prerenderApp } from "./prerender-C8BpANz3.mjs";
+export { PrachtHttpError, PrachtRuntimeProvider, applyDefaultSecurityHeaders, buildAppGraph, buildHref, buildPathFromSegments, createHref, defineApp, detectApiMethods, formatServerTimingHeader, group, handlePrachtRequest, matchApiRoute, matchAppRoute, prerenderApp, redirect, resolveApiRoutes, resolveApp, route, serializeApiRoutes, serializeAppRoutes, timeRevalidate };

package/dist/{app-BWriseLj.d.mts → types-B-sfVjaH.d.mts}

@@ -32,6 +32,17 @@ interface BuildHrefOptions {
 }
 interface NavigateOptions {
   replace?: boolean;
+  /**
+   * Keep the current scroll position after the navigation commits instead of
+   * scrolling to the top (or to the target `#hash` element).
+   */
+  preserveScroll?: boolean;
+  /**
+   * Wrap this navigation's DOM commit in `document.startViewTransition()`
+   * when the browser supports it. Overrides the app-level
+   * `viewTransitions` default for this navigation.
+   */
+  viewTransition?: boolean;
 }
 interface HrefRouteDefinition {
   id?: string;
@@ -51,6 +62,9 @@ type RouteParamsFor<TRoute extends RouteId> = HasRegisteredRoutes extends true ?
 type RouteSearchFor<TRoute extends RouteId> = HasRegisteredRoutes extends true ? TRoute extends keyof RegisteredRouteMap ? RegisteredRouteMap[TRoute] extends {
   search: infer TSearch;
 } ? TSearch : SearchParamsInput : never : SearchParamsInput;
+type RouteDataFor<TRoute extends RouteId> = HasRegisteredRoutes extends true ? TRoute extends keyof RegisteredRouteMap ? RegisteredRouteMap[TRoute] extends {
+  data: infer TData;
+} ? TData : unknown : never : unknown;
 type TypedHrefOptions<TRoute extends RouteId> = IsEmptyRouteParams<RouteParamsFor<TRoute>> extends true ? {
   params?: never;
   search?: RouteSearchFor<TRoute>;
@@ -105,6 +119,12 @@ interface ApiRouteMatch {
   pathname: string;
 }
 type PrefetchStrategy = "none" | "hover" | "viewport" | "intent";
+/**
+ * Per-link prefetch strategy accepted by `<Link prefetch>`. Extends the
+ * route-level strategies with `"render"`, which prefetches as soon as the
+ * link is rendered.
+ */
+type LinkPrefetchStrategy = PrefetchStrategy | "render";
 interface RouteMeta {
   id?: string;
   shell?: string;
@@ -153,12 +173,20 @@ interface PrachtAppConfig {
   middleware?: Record<string, ModuleRef>;
   api?: ApiConfig;
   routes: RouteTreeNode[];
+  /**
+   * Enable the View Transitions API for every client navigation by default.
+   * Individual navigations can still opt out via
+   * `navigate(to, { viewTransition: false })`. Ignored in browsers without
+   * `document.startViewTransition` support.
+   */
+  viewTransitions?: boolean;
 }
 interface PrachtApp {
   shells: Record<string, string>;
   middleware: Record<string, string>;
   api: ApiConfig;
   routes: RouteTreeNode[];
+  viewTransitions?: boolean;
 }
 interface StaticRouteSegment {
   type: "static";
@@ -216,6 +244,19 @@ interface HeadMetadata {
 type MaybePromise<T> = T | Promise<T>;
 type LoaderLike = ((args: LoaderArgs<any>) => unknown) | undefined;
 type LoaderData<TLoader extends LoaderLike> = TLoader extends ((...args: any[]) => infer TResult) ? Awaited<TResult> : never;
+/**
+ * Extract loader data from a route module type. `pracht typegen` uses this to
+ * register per-route loader data on `Register["routes"]`. When a separate
+ * loader module is wired via the manifest (`loader: () => import(...)`), pass
+ * it first and the route module second — the loader module wins, matching the
+ * runtime's resolution order. Modules without a `loader` export resolve to
+ * `undefined`, mirroring the data a loaderless route receives.
+ */
+type RouteLoaderData<TModule, TFallbackModule = TModule> = TModule extends {
+  loader: (...args: any[]) => infer TResult;
+} ? Awaited<TResult> : TFallbackModule extends {
+  loader: (...args: any[]) => infer TFallbackResult;
+} ? Awaited<TFallbackResult> : undefined;
 interface HeadArgs<TLoader extends LoaderLike = undefined, TContext = any> extends BaseRouteArgs<TContext> {
   data: LoaderData<TLoader>;
 }
@@ -274,25 +315,4 @@ declare class PrachtHttpError extends Error {
   constructor(status: number, message: string);
 }
 //#endregion
-//#region src/app.d.ts
-declare function timeRevalidate(seconds: number): TimeRevalidatePolicy;
-declare function route(path: string, file: ModuleRef, meta?: RouteMeta): RouteDefinition;
-declare function route(path: string, config: RouteConfig): RouteDefinition;
-declare function group(meta: GroupMeta, routes: RouteTreeNode[]): GroupDefinition;
-declare function defineApp(config: PrachtAppConfig): PrachtApp;
-declare function resolveApp(app: PrachtApp): ResolvedPrachtApp;
-declare function matchAppRoute(app: PrachtApp | ResolvedPrachtApp, pathname: string): RouteMatch | undefined;
-declare function buildPathFromSegments(segments: readonly RouteSegment[], params: RouteParams): string;
-declare function buildHref<TRoute extends RouteId>(routes: readonly HrefRouteDefinition[], routeId: TRoute, ...args: HrefArgs<TRoute>): string;
-/**
- * Convert a list of file paths from `import.meta.glob` into resolved API routes.
- *
- * Example: `"/src/api/health.ts"` → path `/api/health`
- *          `"/src/api/users/[id].ts"` → path `/api/users/:id`
- *          `"/src/api/files/[...path].ts"` → path `/api/files/*`
- *          `"/src/api/index.ts"` → path `/api`
- */
-declare function resolveApiRoutes(files: string[], apiDir?: string): ResolvedApiRoute[];
-declare function matchApiRoute(apiRoutes: ResolvedApiRoute[], pathname: string): ApiRouteMatch | undefined;
-//#endregion
-export { RouteComponentProps as $, HrefRouteDefinition as A, ModuleImporter as B, HeadAttributes as C, HrefArgs as D, HeadersArgs as E, LoaderLike as F, PrachtAppConfig as G, ModuleRegistry as H, MiddlewareArgs as I, Register as J, PrachtHttpError as K, MiddlewareFn as L, LoaderArgs as M, LoaderData as N, HrefFn as O, LoaderFn as P, ResolvedRoute as Q, MiddlewareModule as R, HeadArgs as S, HeadScriptDescriptor as T, NavigateOptions as U, ModuleRef as V, PrachtApp as W, ResolvedApiRoute as X, RenderMode as Y, ResolvedPrachtApp as Z, BuildHrefOptions as _, ShellProps as _t, matchApiRoute as a, RouteModule as at, GroupDefinition as b, resolveApp as c, RouteParamsFor as ct, ApiConfig as d, RouteTarget as dt, RouteConfig as et, ApiRouteArgs as f, RouteTreeNode as ft, BaseRouteArgs as g, ShellModule as gt, ApiRouteModule as h, SearchParamsInput as ht, group as i, RouteMeta as it, HttpMethod as j, HrefOptions as k, route as l, RouteRevalidate as lt, ApiRouteMatch as m, SearchParamValue as mt, buildPathFromSegments as n, RouteId as nt, matchAppRoute as o, RouteParamInput as ot, ApiRouteHandler as p, SearchParamPrimitive as pt, PrefetchStrategy as q, defineApp as r, RouteMatch as rt, resolveApiRoutes as s, RouteParams as st, buildHref as t, RouteDefinition as tt, timeRevalidate as u, RouteSearchFor as ut, DataModule as v, TimeRevalidatePolicy as vt, HeadMetadata as w, GroupMeta as x, ErrorBoundaryProps as y, MiddlewareNext as z };
+export { RouteParamInput as $, MiddlewareNext as A, RenderMode as B, LoaderArgs as C, MiddlewareArgs as D, LoaderLike as E, PrachtApp as F, RouteConfig as G, ResolvedPrachtApp as H, PrachtAppConfig as I, RouteId as J, RouteDataFor as K, PrachtHttpError as L, ModuleRef as M, ModuleRegistry as N, MiddlewareFn as O, NavigateOptions as P, RouteModule as Q, PrefetchStrategy as R, LinkPrefetchStrategy as S, LoaderFn as T, ResolvedRoute as U, ResolvedApiRoute as V, RouteComponentProps as W, RouteMatch as X, RouteLoaderData as Y, RouteMeta as Z, HrefArgs as _, ApiRouteModule as a, RouteTarget as at, HrefRouteDefinition as b, DataModule as c, SearchParamValue as ct, GroupMeta as d, ShellProps as dt, RouteParams as et, HeadArgs as f, TimeRevalidatePolicy as ft, HeadersArgs as g, HeadScriptDescriptor as h, ApiRouteMatch as i, RouteSegment as it, ModuleImporter as j, MiddlewareModule as k, ErrorBoundaryProps as l, SearchParamsInput as lt, HeadMetadata as m, ApiRouteArgs as n, RouteRevalidate as nt, BaseRouteArgs as o, RouteTreeNode as ot, HeadAttributes as p, RouteDefinition as q, ApiRouteHandler as r, RouteSearchFor as rt, BuildHrefOptions as s, SearchParamPrimitive as st, ApiConfig as t, RouteParamsFor as tt, GroupDefinition as u, ShellModule as ut, HrefFn as v, LoaderData as w, HttpMethod as x, HrefOptions as y, Register as z };

package/dist/{types-idmK5omD.mjs → types-DEPXdbyp.mjs}

@@ -1,8 +1,8 @@
-import { t as buildHref } from "./app-BvC1uQG5.mjs";
-import { c as navigateToClientLocation, h as SAFE_METHODS, l as parseSafeNavigationUrl, m as ROUTE_STATE_REQUEST_HEADER, p as ROUTE_STATE_CACHE_CONTROL, r as clearPrefetchCache, s as fetchPrachtRouteState } from "./prefetch-cache-DzP2Bj9H.mjs";
-import { n as RouteDataContext, s as deserializeRouteError } from "./runtime-context-B5pREhcM.mjs";
+import { t as buildHref } from "./app-CGRKjZ6Z.mjs";
+import { _ as ROUTE_STATE_REQUEST_HEADER, c as fetchPrachtRouteState, g as ROUTE_STATE_CACHE_CONTROL, h as PRESERVE_SCROLL_ATTRIBUTE, l as navigateToClientLocation, m as PREFETCH_ATTRIBUTE, r as clearPrefetchCache, u as parseSafeNavigationUrl, v as SAFE_METHODS, y as VIEW_TRANSITION_ATTRIBUTE } from "./prefetch-cache-BNLEp9H5.mjs";
+import { a as settleNavigation, c as RouteDataContext, i as getNavigation, n as beginSubmittingNavigation, o as subscribeToNavigation, p as deserializeRouteError, r as createNavigationLocation } from "./navigation-state-BjwXTeVz.mjs";
 import { h } from "preact";
-import { useContext } from "preact/hooks";
+import { useContext, useEffect, useState } from "preact/hooks";
 //#region src/href.ts
 function createHref(routes) {
 	return ((routeId, options) => buildHref(routes, routeId, options));
@@ -268,8 +268,10 @@ async function mergeDocumentHeaders(shellModule, routeModule, routeArgs, data) {
 }
 //#endregion
 //#region src/runtime-hooks.ts
-function useRouteData() {
-	return useContext(RouteDataContext)?.data;
+function useRouteData(routeId) {
+	const runtime = useContext(RouteDataContext);
+	if (import.meta.env?.DEV && routeId !== void 0 && runtime && runtime.routeId !== routeId) console.warn(`useRouteData("${routeId}") rendered inside route "${runtime.routeId}"; returning the active route's data.`);
+	return runtime?.data;
 }
 function useLocation() {
 	return parseLocation(useContext(RouteDataContext)?.url ?? (typeof window !== "undefined" ? window.location.pathname + window.location.search : "/"));
@@ -291,17 +293,36 @@ function useRevalidate() {
 		return result.data;
 	};
 }
+/**
+* Reactive pending state for the current client navigation or `<Form>`
+* submission. Returns `{ state: "idle" }` when nothing is in flight,
+* `{ state: "loading", location }` while the router fetches and commits a
+* navigation, and `{ state: "submitting", location, formData }` while a
+* `<Form>` submission is awaiting its response. During SSR it always
+* returns the idle state.
+*/
+function useNavigation() {
+	const [navigation, setNavigation] = useState(getNavigation);
+	useEffect(() => {
+		setNavigation(getNavigation());
+		return subscribeToNavigation(setNavigation);
+	}, []);
+	return navigation;
+}
 function Link(props) {
 	const routes = useContext(RouteDataContext)?.routes ?? globalThis.__PRACHT_ROUTE_DEFINITIONS__;
 	if (!routes) throw new Error("<Link route=...> must render inside a pracht route tree.");
-	const { route, params, search, hash, ...anchorProps } = props;
+	const { route, params, search, hash, prefetch, preserveScroll, viewTransition, ...anchorProps } = props;
 	return h("a", {
 		...anchorProps,
 		href: buildHref(routes, route, {
 			params,
 			search,
 			hash
-		})
+		}),
+		[PREFETCH_ATTRIBUTE]: prefetch,
+		[PRESERVE_SCROLL_ATTRIBUTE]: preserveScroll ? "" : void 0,
+		[VIEW_TRANSITION_ATTRIBUTE]: viewTransition ? "" : void 0
 	});
 }
 function Form(props) {
@@ -318,18 +339,18 @@ function Form(props) {
 			if (SAFE_METHODS.has(formMethod)) return;
 			event.preventDefault();
 			clearPrefetchCache();
-			const response = await fetch(props.action ?? form.action, {
-				method: formMethod,
-				body: new FormData(form),
-				redirect: "manual"
-			});
-			if (response.type === "opaqueredirect" || response.status >= 300 && response.status < 400) {
-				const location = response.headers.get("location");
-				if (location) {
-					await navigateToClientLocation(location);
-					return;
-				}
-				window.location.href = props.action ?? form.action;
+			const actionUrl = props.action ?? form.action;
+			const formData = new FormData(form);
+			const navigationToken = beginSubmittingNavigation(createNavigationLocation(actionUrl), formData);
+			try {
+				const response = await fetch(actionUrl, {
+					method: formMethod,
+					body: formData,
+					redirect: "manual"
+				});
+				if (response.type === "opaqueredirect" || response.status >= 300 && response.status < 400) await navigateToClientLocation(response.headers.get("location") ?? actionUrl);
+			} finally {
+				settleNavigation(navigationToken);
 			}
 		}
 	});
@@ -352,4 +373,4 @@ var PrachtHttpError = class extends Error {
 	}
 };
 //#endregion
-export { createHref as S, applyDefaultSecurityHeaders as _, useParams as a, withDefaultSecurityHeaders as b, mergeDocumentHeaders as c, runMiddlewareChain as d, resolveDataFunctions as f, appendVaryHeader as g, resolveRegistryModule as h, useLocation as i, mergeHeadMetadata as l, resolvePageJsUrls as m, Form as n, useRevalidate as o, resolvePageCssUrls as p, Link as r, useRouteData as s, PrachtHttpError as t, redirect as u, applyHeaders as v, withRouteResponseHeaders as x, applySecurityAndRouteHeaders as y };
+export { createHref as C, withRouteResponseHeaders as S, appendVaryHeader as _, useNavigation as a, applySecurityAndRouteHeaders as b, useRouteData as c, redirect as d, runMiddlewareChain as f, resolveRegistryModule as g, resolvePageJsUrls as h, useLocation as i, mergeDocumentHeaders as l, resolvePageCssUrls as m, Form as n, useParams as o, resolveDataFunctions as p, Link as r, useRevalidate as s, PrachtHttpError as t, mergeHeadMetadata as u, applyDefaultSecurityHeaders as v, withDefaultSecurityHeaders as x, applyHeaders as y };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pracht/core",
-  "version": "0.8.0",
+  "version": "0.9.0",
   "description": "Core runtime for Pracht, a full-stack Preact framework with per-route SSR, SSG, ISG, SPA, loaders, and API routes.",
   "keywords": [
     "pracht",
@@ -53,6 +53,14 @@
     "./error-overlay": {
       "types": "./dist/error-overlay.d.mts",
       "default": "./dist/error-overlay.mjs"
+    },
+    "./dev-404": {
+      "types": "./dist/dev-404.d.mts",
+      "default": "./dist/dev-404.mjs"
+    },
+    "./devtools": {
+      "types": "./dist/devtools.d.mts",
+      "default": "./dist/devtools.mjs"
     }
   },
   "publishConfig": {

package/dist/hydration-M1QzbQ1O.d.mts

@@ -1,23 +0,0 @@
-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
-export { forwardRef as n, useIsHydrated as t };