@funstack/router 0.0.3-alpha.1 → 0.0.4

package/dist/index.d.mts

@@ -1,4 +1,4 @@
-import { a as RouteDefinition, i as RouteComponentPropsWithData, n as PathParams, o as route, r as RouteComponentProps, s as routeState, t as LoaderArgs } from "./route-BXVQqSlR.mjs";
+import { a as LoaderArgs, c as RouteComponentProps, d as RouteDefinition, f as TypefulOpaqueRouteDefinition, i as ExtractRouteState, l as RouteComponentPropsOf, m as routeState, n as ExtractRouteId, o as OpaqueRouteDefinition, p as route, r as ExtractRouteParams, s as PathParams, t as ExtractRouteData, u as RouteComponentPropsWithData } from "./route-gXPaU-cv.mjs";
 import { ComponentType, ReactNode } from "react";
 
 //#region src/types.d.ts
@@ -7,20 +7,28 @@ declare const InternalRouteDefinitionSymbol: unique symbol;
  * Internal structure for storing per-route state in NavigationHistoryEntry.
  * Each route in the matched stack gets its own state slot indexed by match position.
  */
-
 /**
  * Route definition for the router.
  * When a loader is defined, the component receives the loader result as a `data` prop.
  */
 type InternalRouteDefinition = {
-  [InternalRouteDefinitionSymbol]: never;
-  /** Path pattern to match (e.g., "users/:id") */
-  path: string;
-  /** Child routes for nested routing */
+  [InternalRouteDefinitionSymbol]: never; /** Path pattern to match (e.g., "users/:id"). If omitted, the route is pathless (always matches, consumes nothing). */
+  path?: string; /** Child routes for nested routing */
   children?: InternalRouteDefinition[];
-  /** Data loader function for this route */
-  loader?: (args: LoaderArgs) => unknown;
-  /** Component to render when this route matches */
+  /**
+   * Whether this route requires an exact match.
+   * - true: Only matches exact pathname
+   * - false: Matches as prefix
+   * - undefined: Default (exact for leaf, prefix for parent)
+   */
+  exact?: boolean;
+  /**
+   * Whether this route requires a child to match when it has children.
+   * - true (default): Parent does not match if no child matches
+   * - false: Parent can match alone if it has a component, outlet will be null
+   */
+  requireChildren?: boolean; /** Data loader function for this route */
+  loader?: (args: LoaderArgs<Record<string, string>>) => unknown; /** Component to render when this route matches */
   component?: ComponentType<{
     data?: unknown;
     params?: Record<string, string>;
@@ -35,29 +43,29 @@ type InternalRouteDefinition = {
  * A matched route with its parameters.
  */
 type MatchedRoute = {
-  /** The original route definition */
-  route: InternalRouteDefinition;
-  /** Extracted path parameters */
-  params: Record<string, string>;
-  /** The matched pathname segment */
+  /** The original route definition */route: InternalRouteDefinition; /** Extracted path parameters */
+  params: Record<string, string>; /** The matched pathname segment */
   pathname: string;
 };
 /**
  * A matched route with loader data.
  */
 type MatchedRouteWithData = MatchedRoute & {
-  /** Data returned from the loader (undefined if no loader) */
-  data: unknown | undefined;
+  /** Data returned from the loader (undefined if no loader) */data: unknown | undefined;
+};
+/**
+ * Information passed to onNavigate callback.
+ */
+type OnNavigateInfo = {
+  /** Array of matched routes, or null if no routes matched */matches: readonly MatchedRoute[] | null; /** Whether the router will intercept this navigation (before user's preventDefault() call) */
+  intercepting: boolean;
 };
 /**
  * Options for navigation.
  */
 type NavigateOptions = {
-  /** Replace current history entry instead of pushing */
-  replace?: boolean;
-  /** State to associate with the navigation */
-  state?: unknown;
-  /** Ephemeral info for this navigation only (not persisted in history) */
+  /** Replace current history entry instead of pushing */replace?: boolean; /** State to associate with the navigation */
+  state?: unknown; /** Ephemeral info for this navigation only (not persisted in history) */
   info?: unknown;
 };
 /**
@@ -73,9 +81,9 @@ type Location = {
  * Call `event.preventDefault()` to prevent the router from handling this navigation.
  *
  * @param event - The NavigateEvent from the Navigation API
- * @param matched - Array of matched routes, or null if no routes matched
+ * @param info - Information about the navigation including matched routes and whether it will be intercepted
  */
-type OnNavigateCallback = (event: NavigateEvent, matched: readonly MatchedRoute[] | null) => void;
+type OnNavigateCallback = (event: NavigateEvent, info: OnNavigateInfo) => void;
 /**
  * Fallback mode when Navigation API is unavailable.
  *
@@ -92,7 +100,7 @@ type RouterProps = {
    * Call `event.preventDefault()` to prevent the router from handling this navigation.
    *
    * @param event - The NavigateEvent from the Navigation API
-   * @param matched - Array of matched routes, or null if no routes matched
+   * @param info - Information about the navigation including matched routes and whether it will be intercepted
    */
   onNavigate?: OnNavigateCallback;
   /**
@@ -172,21 +180,91 @@ type UseBlockerOptions = {
  */
 declare function useBlocker(options: UseBlockerOptions): void;
 //#endregion
+//#region src/hooks/useRouteParams.d.ts
+/**
+ * Returns typed route parameters for the given route definition.
+ * Throws an error if called outside a matching route or if the route ID is not found
+ * in the current route hierarchy.
+ *
+ * @example
+ * ```typescript
+ * const userRoute = route({
+ *   id: "user",
+ *   path: "/users/:userId",
+ *   component: UserPage,
+ * });
+ *
+ * function UserPage() {
+ *   const params = useRouteParams(userRoute);
+ *   // params is typed as { userId: string }
+ *   return <div>User ID: {params.userId}</div>;
+ * }
+ * ```
+ */
+declare function useRouteParams<T extends TypefulOpaqueRouteDefinition<string, Record<string, string>, unknown, unknown>>(route: T): ExtractRouteParams<T>;
+//#endregion
+//#region src/hooks/useRouteState.d.ts
+/**
+ * Returns typed navigation state for the given route definition.
+ * Throws an error if called outside a matching route or if the route ID is not found
+ * in the current route hierarchy.
+ *
+ * @example
+ * ```typescript
+ * type ScrollState = { scrollPos: number };
+ * const scrollRoute = routeState<ScrollState>()({
+ *   id: "scroll",
+ *   path: "/scroll",
+ *   component: ScrollPage,
+ * });
+ *
+ * function ScrollPage() {
+ *   const state = useRouteState(scrollRoute);
+ *   // state is typed as ScrollState | undefined
+ *   return <div>Scroll position: {state?.scrollPos ?? 0}</div>;
+ * }
+ * ```
+ */
+declare function useRouteState<T extends TypefulOpaqueRouteDefinition<string, Record<string, string>, unknown, unknown>>(route: T): ExtractRouteState<T> | undefined;
+//#endregion
+//#region src/hooks/useRouteData.d.ts
+/**
+ * Returns typed loader data for the given route definition.
+ * Throws an error if called outside a matching route or if the route ID is not found
+ * in the current route hierarchy.
+ *
+ * @example
+ * ```typescript
+ * const userRoute = route({
+ *   id: "user",
+ *   path: "/users/:userId",
+ *   loader: async ({ params }) => {
+ *     const res = await fetch(`/api/users/${params.userId}`);
+ *     return res.json() as Promise<{ name: string; age: number }>;
+ *   },
+ *   component: UserPage,
+ * });
+ *
+ * function UserPage() {
+ *   const data = useRouteData(userRoute);
+ *   // data is typed as Promise<{ name: string; age: number }>
+ *   return <div>User: {data.name}</div>;
+ * }
+ * ```
+ */
+declare function useRouteData<T extends TypefulOpaqueRouteDefinition<string, Record<string, string>, unknown, unknown>>(route: T): ExtractRouteData<T>;
+//#endregion
 //#region src/core/RouterAdapter.d.ts
 /**
  * Represents the current location state.
  * Abstracts NavigationHistoryEntry for static mode compatibility.
  */
 type LocationEntry = {
-  /** The current URL */
-  url: URL;
-  /** Unique key for this entry (used for loader caching) */
-  key: string;
-  /** State associated with this entry */
-  state: unknown;
-  /** Ephemeral info from current navigation (undefined if not from navigation event) */
+  /** The current URL */url: URL; /** Unique key for this entry (used for loader caching) */
+  key: string; /** State associated with this entry */
+  state: unknown; /** Ephemeral info from current navigation (undefined if not from navigation event) */
   info: unknown;
 };
 //#endregion
-export { type FallbackMode, type LoaderArgs, type Location, type LocationEntry, type MatchedRoute, type MatchedRouteWithData, type NavigateOptions, type OnNavigateCallback, Outlet, type PathParams, type RouteComponentProps, type RouteComponentPropsWithData, type RouteDefinition, Router, type RouterProps, type UseBlockerOptions, route, routeState, useBlocker, useLocation, useNavigate, useSearchParams };
+export { type ExtractRouteData, type ExtractRouteId, type ExtractRouteParams, type ExtractRouteState, type FallbackMode, type LoaderArgs, type Location, type LocationEntry, type MatchedRoute, type MatchedRouteWithData, type NavigateOptions, type OnNavigateCallback, type OnNavigateInfo, type OpaqueRouteDefinition, Outlet, type PathParams, type RouteComponentProps, type RouteComponentPropsOf, type RouteComponentPropsWithData, type RouteDefinition, Router, type RouterProps, type TypefulOpaqueRouteDefinition, type UseBlockerOptions, route, routeState, useBlocker, useLocation, useNavigate, useRouteData, useRouteParams, useRouteState, useSearchParams };
 //# sourceMappingURL=index.d.mts.map

package/dist/index.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.mts","names":[],"sources":["../src/types.ts","../src/Router.tsx","../src/Outlet.tsx","../src/hooks/useNavigate.ts","../src/hooks/useLocation.ts","../src/hooks/useSearchParams.ts","../src/hooks/useBlocker.ts","../src/core/RouterAdapter.ts"],"sourcesContent":[],"mappings":";;;;cAGM;;AAFwD;AAgB9D;;;;;;;AA4CY,KA5CA,uBAAA,GA8CH;EAUG,CAvDT,6BAAA,CAuD6B,EAAA,KAAG;EAQvB;EAYA,IAAA,EAAA,MAAQ;EAaR;EAWA,QAAA,CAAA,EA/FC,uBA+FW,EAAA;;kBAzFN;;ECAN,SAAA,CAAA,EDGN,aCHiB,CAAA;IACb,IAAA,CAAA,EAAA,OAAA;IAQK,MAAA,CAAA,EDJE,MCIF,CAAA,MAAA,EAAA,MAAA,CAAA;IAOF,KAAA,CAAA,EAAA,OAAA;IAAY,QAAA,CAAA,EAAA,CAAA,KAAA,EAAA,OAAA,GAAA,CAAA,CAAA,IAAA,EAAA,OAAA,EAAA,GAAA,OAAA,CAAA,EAAA,GDPZ,OCOY,CAAA,IAAA,CAAA;IAGT,YAAM,CAAA,EAAA,CAAA,KAAA,EAAA,OAAA,GAAA,CAAA,CAAA,IAAA,EAAA,OAAA,EAAA,GAAA,OAAA,CAAA,EAAA,GAAA,IAAA;IACZ,UAAA,CAAA,EAAA,GAAA,GAAA,IAAA;IACR,IAAA,CAAA,EAAA,OAAA;EACA,CAAA,CAAA,GDRI,SCQJ;CACC;;AE5CH;;KHsDY,YAAA;;EItDI,KAAA,EJwDP,uBIxDsB;;UJ0DrB;;EK9DL,QAAA,EAAA,MAAA;CAEC;;;;AAE8C,KLkExC,oBAAA,GAAuB,YKlEiB,GAAA;EAAM;EAM1C,IAAA,EAAA,OAAA,GAAA,SAAe;;;;ACV/B;AAmCgB,KN2CJ,eAAA,GM3CwB;;;;EC5BxB,KAAA,CAAA,EAAA,OAAA;;;;;;;KPmFA,QAAA;;;;;;;;;;;;KAaA,kBAAA,WACH,iCACW;;;;;;;KASR,YAAA;;;KCzFA,WAAA;EDzBN,MAAA,EC0BI,eD1BJ,EAAA;EAcM;;;;;;;EAyBN,UAAA,CAAA,ECLS,kBDKT;EAAS;AAmBf;AAYA;AAQA;AAYA;AAaA;EAWY,QAAA,CAAA,ECzEC,YDyEW;;iBCtER,MAAA;UACN;;;GAGP,cAAc;;;;;;ADlD6C;AAgBlD,iBEVI,MAAA,CAAA,CFUmB,EEVT,SFUS;;;;;;AAd7B,iBGIU,WAAA,CAAA,CHJ8B,EAAA,CAAA,EAAA,EAAA,MAAA,EAAA,OAAA,CAAA,EGIQ,eHJR,EAAA,GAAA,IAAA;;;;;;AAAxC,iBIIU,WAAA,CAAA,CJJ8B,EIIf,QJJe;;;KKAzC,eAAA,YAEC,kBACA,iCACQ,oBAAoB,kBAAkB;;;;ALJ9C,iBKUU,eAAA,CAAA,CLV8B,EAAA,CKUV,eLVU,EKUO,eLVP,CAAA;;;KMAlC,iBAAA;;;;ANFkD;EAgBlD,WAAA,EAAA,GAAA,GAAA,OAAuB;CAChC;;;;;;;;AA2CH;AAYA;AAQA;AAYA;AAaA;AAWA;;;;ACzFA;;;;;AAmBA;;;;;;AAI0B,iBKbV,UAAA,CLaU,OAAA,EKbU,iBLaV,CAAA,EAAA,IAAA;;;;;;ADlDoC;AAgBlD,KOPA,aAAA,GPOA;EACT;EAIU,GAAA,EOVN,GPUM;EAMK;EAKD,GAAA,EAAA,MAAA;EAIJ;EANP,KAAA,EAAA,OAAA;EAWA;EAAS,IAAA,EAAA,OAAA;AAmBf,CAAA"}
+{"version":3,"file":"index.d.mts","names":[],"sources":["../src/types.ts","../src/Router.tsx","../src/Outlet.tsx","../src/hooks/useNavigate.ts","../src/hooks/useLocation.ts","../src/hooks/useSearchParams.ts","../src/hooks/useBlocker.ts","../src/hooks/useRouteParams.ts","../src/hooks/useRouteState.ts","../src/hooks/useRouteData.ts","../src/core/RouterAdapter.ts"],"mappings":";;;;cAGM,6BAAA;;AAFwD;;;;;;;KAgBlD,uBAAA;EAAA,CACT,6BAAA,UA4Bc;EA1Bf,IAAA,WAwBI;EAtBJ,QAAA,GAAW,uBAAA;EAiCE;;;;;;EA1Bb,KAAA;EAMA;;;;;EAAA,eAAA,YASI;EAHJ,MAAA,IAAU,IAAA,EAAM,UAAA,CAAW,MAAA,+BAKrB;EAHN,SAAA,GACI,aAAA;IACE,IAAA;IACA,MAAA,GAAS,MAAA;IACT,KAAA;IACA,QAAA,IACE,KAAA,cAAmB,IAAA,2BAChB,OAAA;IACL,YAAA,IAAgB,KAAA,cAAmB,IAAA;IACnC,UAAA;IACA,IAAA;EAAA,KAEF,SAAA;AAAA;;;;KAmBM,YAAA;EAMV,oCAJA,KAAA,EAAO,uBAAA,EAIC;EAFR,MAAA,EAAQ,MAAA,kBAQsB;EAN9B,QAAA;AAAA;;AAcF;;KARY,oBAAA,GAAuB,YAAA;EAUH,6DAR9B,IAAA;AAAA;;;;KAMU,cAAA;EAUe,4DARzB,OAAA,WAAkB,YAAA,WAQO;EANzB,YAAA;AAAA;;;;KAMU,eAAA;EAYQ,uDAVlB,OAAA,YAUkB;EARlB,KAAA,YAUA;EARA,IAAA;AAAA;;AAmBF;;KAbY,QAAA;EACV,QAAA;EACA,MAAA;EACA,IAAA;AAAA;;;;AAqBF;;;;KAXY,kBAAA,IACV,KAAA,EAAO,aAAA,EACP,IAAA,EAAM,cAAA;;;;ACvGR;;;KDgHY,YAAA;;;KChHA,WAAA;EACV,MAAA,EAAQ,eAAA;ED1BoC;;;;AAc9C;;;ECoBE,UAAA,GAAa,kBAAA;EDfF;;;;;;ECsBX,QAAA,GAAW,YAAA;AAAA;AAAA,iBAGG,MAAA,CAAA;EACd,MAAA,EAAQ,WAAA;EACR,UAAA;EACA;AAAA,GACC,WAAA,GAAc,SAAA;;;;;;ADlD6C;iBEM9C,MAAA,CAAA,GAAU,SAAA;;;;;;iBCAV,WAAA,CAAA,IAAgB,EAAA,UAAY,OAAA,GAAU,eAAA;;;;;;iBCAtC,WAAA,CAAA,GAAe,QAAA;;;KCJ1B,eAAA,IACH,MAAA,EACI,eAAA,GACA,MAAA,qBACE,IAAA,EAAM,eAAA,KAAoB,eAAA,GAAkB,MAAA;;;;iBAMpC,eAAA,CAAA,IAAoB,eAAA,EAAiB,eAAA;;;KCVzC,iBAAA;;;;ANFkD;EMO5D,WAAA;AAAA;;;ANSF;;;;;;;;;;;;;;;;;;;;;;;;;iBMqBgB,UAAA,CAAW,OAAA,EAAS,iBAAA;;;;;;ANrC0B;;;;;AAgB9D;;;;;;;;;;;;iBOSgB,cAAA,WACJ,4BAAA,SAER,MAAA,oCAAA,CAIF,KAAA,EAAO,CAAA,GAAI,kBAAA,CAAmB,CAAA;;;;;;APhC8B;;;;;AAgB9D;;;;;;;;;;;;;iBQUgB,aAAA,WACJ,4BAAA,SAER,MAAA,oCAAA,CAIF,KAAA,EAAO,CAAA,GAAI,iBAAA,CAAkB,CAAA;;;;;;ARjC+B;;;;;AAgB9D;;;;;;;;;;;;;;;;iBSagB,YAAA,WACJ,4BAAA,SAER,MAAA,oCAAA,CAIF,KAAA,EAAO,CAAA,GAAI,gBAAA,CAAiB,CAAA;;;;;;ATpCgC;KUSlD,aAAA;wBAEV,GAAA,EAAK,GAAA,EVTuC;EUW5C,GAAA,UVGiC;EUDjC,KAAA,WVEC;EUAD,IAAA;AAAA"}

package/dist/index.mjs

@@ -1,6 +1,6 @@
 "use client";
 
-import { n as routeState, t as route } from "./route-DiO6FM2A.mjs";
+import { n as routeState, t as route } from "./route-p_gr5yPI.mjs";
 import { createContext, useCallback, useContext, useEffect, useId, useMemo, useState, useSyncExternalStore } from "react";
 import { jsx } from "react/jsx-runtime";
 
@@ -10,6 +10,18 @@ const RouterContext = createContext(null);
 //#endregion
 //#region src/context/RouteContext.ts
 const RouteContext = createContext(null);
+/**
+* Find a route context by ID in the ancestor chain.
+* Returns the matching context or null if not found.
+*/
+function findRouteContextById(context, id) {
+	let current = context;
+	while (current !== null) {
+		if (current.id === id) return current;
+		current = current.parent;
+	}
+	return null;
+}
 
 //#endregion
 //#region src/context/BlockerContext.ts
@@ -54,8 +66,8 @@ function internalRoutes(routes) {
 * Returns null if no match is found.
 */
 function matchRoutes(routes, pathname) {
-	for (const route$1 of routes) {
-		const matched = matchRoute(route$1, pathname);
+	for (const route of routes) {
+		const matched = matchRoute(route, pathname);
 		if (matched) return matched;
 	}
 	return null;
@@ -63,12 +75,29 @@ function matchRoutes(routes, pathname) {
 /**
 * Match a single route and its children recursively.
 */
-function matchRoute(route$1, pathname) {
-	const hasChildren = Boolean(route$1.children?.length);
-	const { matched, params, consumedPathname } = matchPath(route$1.path, pathname, !hasChildren);
+function matchRoute(route, pathname) {
+	const hasChildren = Boolean(route.children?.length);
+	if (route.path === void 0) {
+		const result = {
+			route,
+			params: {},
+			pathname: ""
+		};
+		if (hasChildren) {
+			for (const child of route.children) {
+				const childMatch = matchRoute(child, pathname);
+				if (childMatch) return [result, ...childMatch];
+			}
+			if (route.component && route.requireChildren === false) return [result];
+			return null;
+		}
+		return [result];
+	}
+	const isExact = route.exact ?? !hasChildren;
+	const { matched, params, consumedPathname } = matchPath(route.path, pathname, isExact);
 	if (!matched) return null;
 	const result = {
-		route: route$1,
+		route,
 		params,
 		pathname: consumedPathname
 	};
@@ -76,7 +105,7 @@ function matchRoute(route$1, pathname) {
 		let remainingPathname = pathname.slice(consumedPathname.length);
 		if (!remainingPathname.startsWith("/")) remainingPathname = "/" + remainingPathname;
 		if (remainingPathname === "") remainingPathname = "/";
-		for (const child of route$1.children) {
+		for (const child of route.children) {
 			const childMatch = matchRoute(child, remainingPathname);
 			if (childMatch) return [result, ...childMatch.map((m) => ({
 				...m,
@@ -86,7 +115,7 @@ function matchRoute(route$1, pathname) {
 				}
 			}))];
 		}
-		if (route$1.component) return [result];
+		if (route.component && route.requireChildren === false) return [result];
 		return null;
 	}
 	return [result];
@@ -133,10 +162,10 @@ const loaderCache = /* @__PURE__ */ new Map();
 * Get or create a loader result from cache.
 * If the result is not cached, executes the loader and caches the result.
 */
-function getOrCreateLoaderResult(entryId, matchIndex, route$1, args) {
-	if (!route$1.loader) return;
+function getOrCreateLoaderResult(entryId, matchIndex, route, args) {
+	if (!route.loader) return;
 	const cacheKey = `${entryId}:${matchIndex}`;
-	if (!loaderCache.has(cacheKey)) loaderCache.set(cacheKey, route$1.loader(args));
+	if (!loaderCache.has(cacheKey)) loaderCache.set(cacheKey, route.loader(args));
 	return loaderCache.get(cacheKey);
 }
 /**
@@ -151,8 +180,8 @@ function createLoaderRequest(url) {
 */
 function executeLoaders(matchedRoutes, entryId, request, signal) {
 	return matchedRoutes.map((match, index) => {
-		const { route: route$1, params } = match;
-		const data = getOrCreateLoaderResult(entryId, index, route$1, {
+		const { route, params } = match;
+		const data = getOrCreateLoaderResult(entryId, index, route, {
 			params,
 			request,
 			signal
@@ -255,17 +284,23 @@ var NavigationAPIAdapter = class {
 				return;
 			}
 			if (!event.canIntercept) {
-				onNavigate?.(event, []);
+				onNavigate?.(event, {
+					matches: [],
+					intercepting: false
+				});
 				return;
 			}
 			const url = new URL(event.destination.url);
 			const matched = matchRoutes(routes, url.pathname);
+			const willIntercept = matched !== null && !event.hashChange && event.downloadRequest === null;
 			if (onNavigate) {
-				onNavigate(event, matched);
+				onNavigate(event, {
+					matches: matched,
+					intercepting: willIntercept
+				});
 				if (event.defaultPrevented) return;
 			}
-			if (event.hashChange || event.downloadRequest !== null) return;
-			if (!matched) return;
+			if (!willIntercept) return;
 			if (idleController) {
 				idleController.abort();
 				idleController = null;
@@ -450,13 +485,14 @@ function Router({ routes: inputRoutes, onNavigate, fallback = "none" }) {
 * Recursively render matched routes with proper context.
 */
 function RouteRenderer({ matchedRoutes, index }) {
+	const parentRouteContext = useContext(RouteContext);
 	const match = matchedRoutes[index];
 	if (!match) return null;
-	const { route: route$1, params, pathname, data } = match;
+	const { route, params, pathname, data } = match;
 	const routerContext = useContext(RouterContext);
 	if (!routerContext) throw new Error("RouteRenderer must be used within RouterContext");
 	const { locationEntry, url, navigateAsync, updateCurrentEntryState } = routerContext;
-	const routeState$1 = locationEntry.state?.__routeStates?.[index];
+	const routeState = locationEntry.state?.__routeStates?.[index];
 	const setStateSync = useCallback((stateOrUpdater) => {
 		const currentStates = locationEntry.state?.__routeStates ?? [];
 		const currentRouteState = currentStates[index];
@@ -498,28 +534,37 @@ function RouteRenderer({ matchedRoutes, index }) {
 		matchedRoutes,
 		index: index + 1
 	}) : null;
+	const routeId = route.id;
 	const routeContextValue = useMemo(() => ({
+		id: routeId,
 		params,
 		matchedPath: pathname,
-		outlet
+		state: routeState,
+		data,
+		outlet,
+		parent: parentRouteContext
 	}), [
+		routeId,
 		params,
 		pathname,
-		outlet
+		routeState,
+		data,
+		outlet,
+		parentRouteContext
 	]);
 	const renderComponent = () => {
-		const componentOrElement = route$1.component;
+		const componentOrElement = route.component;
 		if (componentOrElement == null) return outlet;
 		if (typeof componentOrElement !== "function") return componentOrElement;
 		const Component = componentOrElement;
 		const stateProps = {
-			state: routeState$1,
+			state: routeState,
 			setState,
 			setStateSync,
 			resetState
 		};
 		const { info } = locationEntry;
-		if (route$1.loader) return /* @__PURE__ */ jsx(Component, {
+		if (route.loader) return /* @__PURE__ */ jsx(Component, {
 			data,
 			params,
 			...stateProps,
@@ -644,5 +689,113 @@ function useBlocker(options) {
 }
 
 //#endregion
-export { Outlet, Router, route, routeState, useBlocker, useLocation, useNavigate, useSearchParams };
+//#region src/hooks/useRouteContext.ts
+/**
+* Internal hook that returns the RouteContextValue for the given route.
+* If the route has an ID, it searches the ancestor chain for a matching route.
+* If no ID is provided, it returns the current (nearest) route context.
+*
+* @param hookName - Name of the calling hook (for error messages)
+* @param routeId - Optional route ID to search for in the ancestor chain
+* @returns The matching RouteContextValue
+* @throws If called outside a route component or if the route ID is not found
+* @internal
+*/
+function useRouteContext(hookName, routeId) {
+	const context = useContext(RouteContext);
+	if (!context) throw new Error(`${hookName} must be used within a route component`);
+	if (routeId === void 0) return context;
+	const matchedContext = findRouteContextById(context, routeId);
+	if (!matchedContext) throw new Error(`${hookName}: Route ID "${routeId}" not found in current route hierarchy. Current route is "${context.id ?? "(no id)"}"`);
+	return matchedContext;
+}
+
+//#endregion
+//#region src/hooks/useRouteParams.ts
+/**
+* Returns typed route parameters for the given route definition.
+* Throws an error if called outside a matching route or if the route ID is not found
+* in the current route hierarchy.
+*
+* @example
+* ```typescript
+* const userRoute = route({
+*   id: "user",
+*   path: "/users/:userId",
+*   component: UserPage,
+* });
+*
+* function UserPage() {
+*   const params = useRouteParams(userRoute);
+*   // params is typed as { userId: string }
+*   return <div>User ID: {params.userId}</div>;
+* }
+* ```
+*/
+function useRouteParams(route) {
+	const routeId = route.id;
+	return useRouteContext("useRouteParams", routeId).params;
+}
+
+//#endregion
+//#region src/hooks/useRouteState.ts
+/**
+* Returns typed navigation state for the given route definition.
+* Throws an error if called outside a matching route or if the route ID is not found
+* in the current route hierarchy.
+*
+* @example
+* ```typescript
+* type ScrollState = { scrollPos: number };
+* const scrollRoute = routeState<ScrollState>()({
+*   id: "scroll",
+*   path: "/scroll",
+*   component: ScrollPage,
+* });
+*
+* function ScrollPage() {
+*   const state = useRouteState(scrollRoute);
+*   // state is typed as ScrollState | undefined
+*   return <div>Scroll position: {state?.scrollPos ?? 0}</div>;
+* }
+* ```
+*/
+function useRouteState(route) {
+	const routeId = route.id;
+	return useRouteContext("useRouteState", routeId).state;
+}
+
+//#endregion
+//#region src/hooks/useRouteData.ts
+/**
+* Returns typed loader data for the given route definition.
+* Throws an error if called outside a matching route or if the route ID is not found
+* in the current route hierarchy.
+*
+* @example
+* ```typescript
+* const userRoute = route({
+*   id: "user",
+*   path: "/users/:userId",
+*   loader: async ({ params }) => {
+*     const res = await fetch(`/api/users/${params.userId}`);
+*     return res.json() as Promise<{ name: string; age: number }>;
+*   },
+*   component: UserPage,
+* });
+*
+* function UserPage() {
+*   const data = useRouteData(userRoute);
+*   // data is typed as Promise<{ name: string; age: number }>
+*   return <div>User: {data.name}</div>;
+* }
+* ```
+*/
+function useRouteData(route) {
+	const routeId = route.id;
+	return useRouteContext("useRouteData", routeId).data;
+}
+
+//#endregion
+export { Outlet, Router, route, routeState, useBlocker, useLocation, useNavigate, useRouteData, useRouteParams, useRouteState, useSearchParams };
 //# sourceMappingURL=index.mjs.map