@ereo/client 0.1.22 → 0.1.24

package/dist/index.js

@@ -248,14 +248,111 @@ function cleanupIslands() {
   islandRegistry.cleanupAll();
 }
 
+// src/view-transition.ts
+import { createContext, useContext } from "react";
+function isViewTransitionSupported() {
+  return typeof document !== "undefined" && "startViewTransition" in document;
+}
+function startViewTransition(callback, options) {
+  if (!isViewTransitionSupported()) {
+    const result = callback();
+    if (result && typeof result.then === "function") {
+      result.catch(() => {});
+    }
+    return null;
+  }
+  if (options?.className) {
+    document.documentElement.classList.add(options.className);
+  }
+  const transition = document.startViewTransition(callback);
+  if (options?.className) {
+    const className = options.className;
+    transition.finished.then(() => {
+      document.documentElement.classList.remove(className);
+    }).catch(() => {
+      document.documentElement.classList.remove(className);
+    });
+  }
+  return transition;
+}
+var ViewTransitionContext = createContext({
+  isTransitioning: false,
+  currentTransition: null
+});
+function useViewTransitionState() {
+  const context = useContext(ViewTransitionContext);
+  return {
+    isTransitioning: context.isTransitioning,
+    currentTransition: context.currentTransition
+  };
+}
+var viewTransitionsEnabled = false;
+var globalTransitionOptions;
+function enableViewTransitions(options) {
+  viewTransitionsEnabled = true;
+  globalTransitionOptions = options;
+}
+function disableViewTransitions() {
+  viewTransitionsEnabled = false;
+  globalTransitionOptions = undefined;
+}
+function areViewTransitionsEnabled() {
+  return viewTransitionsEnabled;
+}
+function resetViewTransitions() {
+  viewTransitionsEnabled = false;
+  globalTransitionOptions = undefined;
+}
+
 // src/navigation.ts
 class ClientRouter {
   listeners = new Set;
   currentState;
+  blockers = new Set;
+  blockerListeners = new Set;
+  pendingNavigation = null;
   constructor() {
     this.currentState = this.getStateFromLocation();
     this.setupPopState();
   }
+  addBlocker(fn) {
+    this.blockers.add(fn);
+    return () => this.blockers.delete(fn);
+  }
+  isBlocked() {
+    for (const fn of this.blockers) {
+      if (fn())
+        return true;
+    }
+    return false;
+  }
+  subscribeBlocker(listener) {
+    this.blockerListeners.add(listener);
+    return () => this.blockerListeners.delete(listener);
+  }
+  notifyBlockers() {
+    for (const listener of this.blockerListeners) {
+      listener();
+    }
+  }
+  proceedNavigation() {
+    const pending = this.pendingNavigation;
+    this.pendingNavigation = null;
+    const savedBlockers = new Set(this.blockers);
+    this.blockers.clear();
+    this.notifyBlockers();
+    if (pending) {
+      this.navigate(pending.to, pending.options).then(() => {
+        for (const fn of savedBlockers) {
+          this.blockers.add(fn);
+        }
+      });
+    }
+  }
+  resetNavigation() {
+    this.pendingNavigation = null;
+    this.notifyBlockers();
+  }
   getStateFromLocation() {
     if (typeof window === "undefined") {
       return { pathname: "/", search: "", hash: "" };
@@ -271,6 +368,16 @@ class ClientRouter {
     if (typeof window === "undefined")
       return;
     window.addEventListener("popstate", (event) => {
+      if (this.isBlocked()) {
+        const current = this.currentState;
+        window.history.pushState(current.state, "", current.pathname + current.search + current.hash);
+        this.pendingNavigation = {
+          to: window.location.pathname + window.location.search + window.location.hash,
+          options: {}
+        };
+        this.notifyBlockers();
+        return;
+      }
       const from = this.currentState;
       this.currentState = this.getStateFromLocation();
       this.notify({
@@ -283,25 +390,39 @@ class ClientRouter {
   async navigate(to, options = {}) {
     if (typeof window === "undefined")
       return;
-    const url = new URL(to, window.location.origin);
-    const from = this.currentState;
-    const newState = {
-      pathname: url.pathname,
-      search: url.search,
-      hash: url.hash,
-      state: options.state
+    if (this.isBlocked()) {
+      this.pendingNavigation = { to, options };
+      this.notifyBlockers();
+      return;
+    }
+    const useTransition = options.viewTransition === true ? areViewTransitionsEnabled() || options.viewTransition : options.viewTransition ? true : areViewTransitionsEnabled();
+    const transitionOptions = typeof options.viewTransition === "object" ? options.viewTransition : undefined;
+    const doNavigate = () => {
+      const url = new URL(to, window.location.origin);
+      const from = this.currentState;
+      const newState = {
+        pathname: url.pathname,
+        search: url.search,
+        hash: url.hash,
+        state: options.state
+      };
+      if (options.replace) {
+        window.history.replaceState(options.state, "", to);
+      } else {
+        window.history.pushState(options.state, "", to);
+      }
+      this.currentState = newState;
+      this.notify({
+        type: options.replace ? "replace" : "push",
+        from,
+        to: newState
+      });
     };
-    if (options.replace) {
-      window.history.replaceState(options.state, "", to);
+    if (useTransition) {
+      startViewTransition(doNavigate, transitionOptions);
     } else {
-      window.history.pushState(options.state, "", to);
+      doNavigate();
     }
-    this.currentState = newState;
-    this.notify({
-      type: options.replace ? "replace" : "push",
-      from,
-      to: newState
-    });
   }
   back() {
     if (typeof window !== "undefined") {
@@ -543,63 +664,149 @@ function isPrefetched(url) {
 }
 // src/hooks.ts
 import {
-  createContext,
-  useContext,
-  useState,
-  useCallback,
+  createContext as createContext3,
+  useContext as useContext3,
+  useState as useState3,
+  useCallback as useCallback2,
+  useMemo as useMemo2,
+  createElement as createElement2
+} from "react";
+
+// src/matches.ts
+import {
+  createContext as createContext2,
+  useContext as useContext2,
+  useState as useState2,
   useMemo,
   createElement
 } from "react";
-var LoaderDataContext = createContext(null);
-var ActionDataContext = createContext(null);
-var NavigationContext = createContext(null);
-var ErrorContext = createContext(null);
+var MatchesContext = createContext2(null);
+function useMatches() {
+  const context = useContext2(MatchesContext);
+  if (context === null) {
+    throw new Error("useMatches must be used within an EreoProvider. " + "Make sure your component is wrapped with <EreoProvider>.");
+  }
+  return context.matches;
+}
+function MatchesProvider({
+  children,
+  initialMatches = []
+}) {
+  const [matches, setMatches] = useState2(initialMatches);
+  const value = useMemo(() => ({ matches, setMatches }), [matches]);
+  return createElement(MatchesContext.Provider, { value }, children);
+}
+
+// src/hooks.ts
+var LoaderDataContext = createContext3(null);
+var ActionDataContext = createContext3(null);
+var NavigationContext = createContext3(null);
+var ErrorContext = createContext3(null);
+var ParamsContext = createContext3(null);
+var LocationContext = createContext3(null);
 function useLoaderData() {
-  const context = useContext(LoaderDataContext);
+  const context = useContext3(LoaderDataContext);
   if (context === null) {
     throw new Error("useLoaderData must be used within an EreoProvider. " + "Make sure your component is wrapped with <EreoProvider>.");
   }
   return context.data;
 }
+function useRouteLoaderData(routeId) {
+  const context = useContext3(MatchesContext);
+  if (context === null) {
+    return;
+  }
+  const match = context.matches.find((m) => m.id === routeId);
+  return match?.data;
+}
 function useActionData() {
-  const context = useContext(ActionDataContext);
+  const context = useContext3(ActionDataContext);
   if (context === null) {
     return;
   }
   return context.data;
 }
 function useNavigation() {
-  const context = useContext(NavigationContext);
+  const context = useContext3(NavigationContext);
   if (context === null) {
     throw new Error("useNavigation must be used within an EreoProvider. " + "Make sure your component is wrapped with <EreoProvider>.");
   }
   return context.state;
 }
 function useError() {
-  const context = useContext(ErrorContext);
+  const context = useContext3(ErrorContext);
   if (context === null) {
     throw new Error("useError must be used within an EreoProvider. " + "Make sure your component is wrapped with <EreoProvider>.");
   }
   return context.error;
 }
+function useParams() {
+  const context = useContext3(ParamsContext);
+  if (context === null) {
+    throw new Error("useParams must be used within an EreoProvider. " + "Make sure your component is wrapped with <EreoProvider>.");
+  }
+  return context.params;
+}
+function useSearchParams() {
+  const locationCtx = useContext3(LocationContext);
+  if (locationCtx === null) {
+    throw new Error("useSearchParams must be used within an EreoProvider. " + "Make sure your component is wrapped with <EreoProvider>.");
+  }
+  const searchParams = useMemo2(() => new URLSearchParams(locationCtx.location.search), [locationCtx.location.search]);
+  const setSearchParams = useCallback2((nextParams, options) => {
+    let resolved;
+    if (typeof nextParams === "function") {
+      const result = nextParams(searchParams);
+      resolved = result instanceof URLSearchParams ? result : new URLSearchParams(result);
+    } else if (nextParams instanceof URLSearchParams) {
+      resolved = nextParams;
+    } else {
+      resolved = new URLSearchParams(nextParams);
+    }
+    const newSearch = resolved.toString();
+    const newLocation = {
+      ...locationCtx.location,
+      search: newSearch ? `?${newSearch}` : "",
+      key: Math.random().toString(36).slice(2, 10)
+    };
+    locationCtx.setLocation(newLocation);
+    if (typeof window !== "undefined") {
+      const url = new URL(window.location.href);
+      url.search = newLocation.search;
+      if (options?.replace) {
+        window.history.replaceState(locationCtx.location.state, "", url.toString());
+      } else {
+        window.history.pushState(locationCtx.location.state, "", url.toString());
+      }
+    }
+  }, [searchParams, locationCtx]);
+  return [searchParams, setSearchParams];
+}
+function useLocation() {
+  const context = useContext3(LocationContext);
+  if (context === null) {
+    throw new Error("useLocation must be used within an EreoProvider. " + "Make sure your component is wrapped with <EreoProvider>.");
+  }
+  return context.location;
+}
 function LoaderDataProvider({
   children,
   initialData
 }) {
-  const [data, setData] = useState(initialData);
-  const value = useMemo(() => ({ data, setData }), [data]);
-  return createElement(LoaderDataContext.Provider, { value }, children);
+  const [data, setData] = useState3(initialData);
+  const value = useMemo2(() => ({ data, setData }), [data]);
+  return createElement2(LoaderDataContext.Provider, { value }, children);
 }
 function ActionDataProvider({
   children,
   initialData
 }) {
-  const [data, setData] = useState(initialData);
-  const clearData = useCallback(() => {
+  const [data, setData] = useState3(initialData);
+  const clearData = useCallback2(() => {
     setData(undefined);
   }, []);
-  const value = useMemo(() => ({ data, setData, clearData }), [data, clearData]);
-  return createElement(ActionDataContext.Provider, { value }, children);
+  const value = useMemo2(() => ({ data, setData, clearData }), [data, clearData]);
+  return createElement2(ActionDataContext.Provider, { value }, children);
 }
 var defaultNavigationState = {
   status: "idle"
@@ -608,14 +815,14 @@ function NavigationProvider({
   children,
   initialState = defaultNavigationState
 }) {
-  const [state, setState] = useState(initialState);
-  const startLoading = useCallback((location) => {
+  const [state, setState] = useState3(initialState);
+  const startLoading = useCallback2((location) => {
     setState({
       status: "loading",
       location
     });
   }, []);
-  const startSubmitting = useCallback((options) => {
+  const startSubmitting = useCallback2((options) => {
     setState({
       status: "submitting",
       location: options.location,
@@ -624,61 +831,87 @@ function NavigationProvider({
       formAction: options.formAction
     });
   }, []);
-  const complete = useCallback(() => {
+  const complete = useCallback2(() => {
     setState({ status: "idle" });
   }, []);
-  const value = useMemo(() => ({
+  const value = useMemo2(() => ({
     state,
     setState,
     startLoading,
     startSubmitting,
     complete
   }), [state, startLoading, startSubmitting, complete]);
-  return createElement(NavigationContext.Provider, { value }, children);
+  return createElement2(NavigationContext.Provider, { value }, children);
 }
 function ErrorProvider({
   children,
   initialError
 }) {
-  const [error, setError] = useState(initialError);
-  const clearError = useCallback(() => {
+  const [error, setError] = useState3(initialError);
+  const clearError = useCallback2(() => {
     setError(undefined);
   }, []);
-  const value = useMemo(() => ({ error, setError, clearError }), [error, clearError]);
-  return createElement(ErrorContext.Provider, { value }, children);
+  const value = useMemo2(() => ({ error, setError, clearError }), [error, clearError]);
+  return createElement2(ErrorContext.Provider, { value }, children);
+}
+function ParamsProvider({
+  children,
+  initialParams = {}
+}) {
+  const [params, setParams] = useState3(initialParams);
+  const value = useMemo2(() => ({ params, setParams }), [params]);
+  return createElement2(ParamsContext.Provider, { value }, children);
+}
+var defaultLocation = {
+  pathname: "/",
+  search: "",
+  hash: "",
+  state: null,
+  key: "default"
+};
+function LocationProvider({
+  children,
+  initialLocation = defaultLocation
+}) {
+  const [location, setLocation] = useState3(initialLocation);
+  const value = useMemo2(() => ({ location, setLocation }), [location]);
+  return createElement2(LocationContext.Provider, { value }, children);
 }
 function EreoProvider({
   children,
   loaderData,
   actionData,
   navigationState,
-  error
+  error,
+  params,
+  location,
+  matches
 }) {
-  return createElement(ErrorProvider, { initialError: error, children: createElement(NavigationProvider, { initialState: navigationState, children: createElement(ActionDataProvider, { initialData: actionData, children: createElement(LoaderDataProvider, { initialData: loaderData, children }) }) }) });
+  return createElement2(MatchesProvider, { initialMatches: matches, children: createElement2(LocationProvider, { initialLocation: location, children: createElement2(ParamsProvider, { initialParams: params, children: createElement2(ErrorProvider, { initialError: error, children: createElement2(NavigationProvider, { initialState: navigationState, children: createElement2(ActionDataProvider, { initialData: actionData, children: createElement2(LoaderDataProvider, { initialData: loaderData, children }) }) }) }) }) }) });
 }
 function useLoaderDataContext() {
-  const context = useContext(LoaderDataContext);
+  const context = useContext3(LoaderDataContext);
   if (context === null) {
     throw new Error("useLoaderDataContext must be used within an EreoProvider");
   }
   return context;
 }
 function useActionDataContext() {
-  const context = useContext(ActionDataContext);
+  const context = useContext3(ActionDataContext);
   if (context === null) {
     throw new Error("useActionDataContext must be used within an EreoProvider");
   }
   return context;
 }
 function useNavigationContext() {
-  const context = useContext(NavigationContext);
+  const context = useContext3(NavigationContext);
   if (context === null) {
     throw new Error("useNavigationContext must be used within an EreoProvider");
   }
   return context;
 }
 function useErrorContext() {
-  const context = useContext(ErrorContext);
+  const context = useContext3(ErrorContext);
   if (context === null) {
     throw new Error("useErrorContext must be used within an EreoProvider");
   }
@@ -720,6 +953,7 @@ var Link = React.forwardRef(function Link2({
   preventScrollReset = false,
   state,
   reloadDocument = false,
+  viewTransition,
   onClick,
   onMouseEnter,
   onFocus,
@@ -751,11 +985,11 @@ var Link = React.forwardRef(function Link2({
       return;
     }
     event.preventDefault();
-    navigate(destination, { replace, state });
+    navigate(destination, { replace, state, viewTransition });
     if (!preventScrollReset && typeof window !== "undefined") {
       window.scrollTo(0, 0);
     }
-  }, [onClick, destination, replace, state, isExternal, reloadDocument, preventScrollReset]);
+  }, [onClick, destination, replace, state, isExternal, reloadDocument, preventScrollReset, viewTransition]);
   const handleMouseEnter = React.useCallback((event) => {
     onMouseEnter?.(event);
     if (prefetchStrategy === "intent") {
@@ -1278,18 +1512,52 @@ async function preloadRoute(path, options) {
   } catch {}
 }
 // src/form.ts
-import { createElement as createElement2, useCallback as useCallback4, useRef as useRef3, useState as useState4, useEffect as useEffect3, useContext as useContext2, createContext as createContext2 } from "react";
-var FormContext = createContext2(null);
+import { createElement as createElement3, useCallback as useCallback5, useRef as useRef3, useState as useState6, useEffect as useEffect4, useContext as useContext4, createContext as createContext4 } from "react";
+var FormContext = createContext4(null);
 function FormProvider({
   children,
   initialActionData
 }) {
-  const [actionData, setActionData] = useState4(initialActionData);
-  const [state, setState] = useState4("idle");
-  return createElement2(FormContext.Provider, { value: { actionData, state, setActionData, setState } }, children);
+  const [actionData, setActionData] = useState6(initialActionData);
+  const [state, setState] = useState6("idle");
+  return createElement3(FormContext.Provider, { value: { actionData, state, setActionData, setState } }, children);
 }
 function useFormContext() {
-  return useContext2(FormContext);
+  return useContext4(FormContext);
+}
+var fetcherRegistry = new Map;
+var fetcherListeners = new Set;
+var fetcherIdCounter = 0;
+function generateFetcherId() {
+  return `__fetcher_${++fetcherIdCounter}`;
+}
+function registerFetcher(id, state) {
+  fetcherRegistry.set(id, state);
+  notifyFetcherListeners();
+}
+function updateFetcherInRegistry(id, state) {
+  if (fetcherRegistry.has(id)) {
+    fetcherRegistry.set(id, state);
+    notifyFetcherListeners();
+  }
+}
+function unregisterFetcher(id) {
+  fetcherRegistry.delete(id);
+  notifyFetcherListeners();
+}
+function notifyFetcherListeners() {
+  for (const listener of fetcherListeners) {
+    listener();
+  }
+}
+function subscribeFetcherRegistry(listener) {
+  fetcherListeners.add(listener);
+  return () => {
+    fetcherListeners.delete(listener);
+  };
+}
+function getFetcherRegistrySnapshot() {
+  return Array.from(fetcherRegistry.values());
 }
 function Form({
   method = "post",
@@ -1307,7 +1575,7 @@ function Form({
   const formRef = useRef3(null);
   const formContext = useFormContext();
   const resolvedAction = action ?? (typeof window !== "undefined" ? window.location.pathname : "");
-  const handleSubmit = useCallback4(async (event) => {
+  const handleSubmit = useCallback5(async (event) => {
     if (onSubmit) {
       onSubmit(event);
       if (event.defaultPrevented) {
@@ -1410,14 +1678,14 @@ function Form({
     }
   }, [method, resolvedAction, onSubmitStart, onSubmitEnd, replace, preventScrollReset, encType, fetcherKey, formContext, onSubmit]);
   const formMethod = method.toLowerCase() === "get" ? "get" : "post";
-  return createElement2("form", {
+  return createElement3("form", {
     ref: formRef,
     method: formMethod,
     action: resolvedAction,
     encType,
     onSubmit: handleSubmit,
     ...props
-  }, method !== "get" && method !== "post" ? createElement2("input", {
+  }, method !== "get" && method !== "post" ? createElement3("input", {
     type: "hidden",
     name: "_method",
     value: method.toUpperCase()
@@ -1425,7 +1693,7 @@ function Form({
 }
 function useSubmit() {
   const formContext = useFormContext();
-  const submit = useCallback4(async (target, options = {}) => {
+  const submit = useCallback5(async (target, options = {}) => {
     const {
       method = "post",
       action,
@@ -1532,25 +1800,39 @@ function useSubmit() {
   return submit;
 }
 function useFetcher(key) {
-  const [state, setStateInternal] = useState4("idle");
-  const [data, setData] = useState4(undefined);
-  const [error, setError] = useState4(undefined);
-  const [formData, setFormData] = useState4(undefined);
-  const [formMethod, setFormMethod] = useState4(undefined);
-  const [formAction, setFormAction] = useState4(undefined);
+  const [state, setStateInternal] = useState6("idle");
+  const [data, setData] = useState6(undefined);
+  const [error, setError] = useState6(undefined);
+  const [formData, setFormData] = useState6(undefined);
+  const [formMethod, setFormMethod] = useState6(undefined);
+  const [formAction, setFormAction] = useState6(undefined);
+  const fetcherIdRef = useRef3(key || generateFetcherId());
   const mountedRef = useRef3(true);
-  useEffect3(() => {
+  useEffect4(() => {
     mountedRef.current = true;
+    const id = fetcherIdRef.current;
+    registerFetcher(id, { state: "idle" });
     return () => {
       mountedRef.current = false;
+      unregisterFetcher(id);
     };
   }, []);
-  const safeSetState = useCallback4((newState) => {
+  useEffect4(() => {
+    updateFetcherInRegistry(fetcherIdRef.current, {
+      state,
+      data,
+      error,
+      formData,
+      formMethod,
+      formAction
+    });
+  }, [state, data, error, formData, formMethod, formAction]);
+  const safeSetState = useCallback5((newState) => {
     if (mountedRef.current) {
       setStateInternal(newState);
     }
   }, []);
-  const reset = useCallback4(() => {
+  const reset = useCallback5(() => {
     if (mountedRef.current) {
       setStateInternal("idle");
       setData(undefined);
@@ -1560,7 +1842,7 @@ function useFetcher(key) {
       setFormAction(undefined);
     }
   }, []);
-  const submit = useCallback4(async (target, options = {}) => {
+  const submit = useCallback5(async (target, options = {}) => {
     const {
       method = "post",
       action,
@@ -1648,7 +1930,7 @@ function useFetcher(key) {
       }
     }
   }, [safeSetState]);
-  const load = useCallback4(async (href) => {
+  const load = useCallback5(async (href) => {
     if (typeof window === "undefined") {
       return;
     }
@@ -1674,7 +1956,7 @@ function useFetcher(key) {
       }
     }
   }, [safeSetState]);
-  const FetcherForm = useCallback4((formProps) => {
+  const FetcherForm = useCallback5((formProps) => {
     return Form({
       ...formProps,
       fetcherKey: key || "fetcher",
@@ -1718,14 +2000,14 @@ function useActionData2() {
   return context?.actionData;
 }
 function useNavigation2() {
-  const [navigationState, setNavigationState] = useState4(() => {
+  const [navigationState, setNavigationState] = useState6(() => {
     if (typeof window === "undefined") {
       return { pathname: "/", search: "", hash: "" };
     }
     return router.getState();
   });
   const formContext = useFormContext();
-  useEffect3(() => {
+  useEffect4(() => {
     return router.subscribe((event) => {
       setNavigationState(event.to);
     });
@@ -1735,6 +2017,15 @@ function useNavigation2() {
     state: formContext?.state || "idle"
   };
 }
+function useFetchers() {
+  const [fetchers, setFetchers] = useState6(() => getFetcherRegistrySnapshot());
+  useEffect4(() => {
+    return subscribeFetcherRegistry(() => {
+      setFetchers(getFetcherRegistrySnapshot());
+    });
+  }, []);
+  return fetchers;
+}
 function serializeFormData(formData) {
   const params = new URLSearchParams;
   formData.forEach((value, key) => {
@@ -1781,10 +2072,168 @@ function objectToFormData(obj) {
   }
   return formData;
 }
+// src/revalidation.ts
+import {
+  useState as useState7,
+  useCallback as useCallback6,
+  useContext as useContext5
+} from "react";
+function getRoutesToRevalidate(routes, nextParams, context) {
+  const routeIds = [];
+  for (const route of routes) {
+    const shouldRevalidateFn = route.module?.shouldRevalidate;
+    if (!shouldRevalidateFn) {
+      if (route.module?.loader) {
+        routeIds.push(route.id);
+      }
+      continue;
+    }
+    if (!route.module?.loader) {
+      continue;
+    }
+    const args = {
+      currentUrl: context.currentUrl,
+      nextUrl: context.nextUrl,
+      currentParams: route.params,
+      nextParams,
+      formMethod: context.formMethod,
+      formAction: context.formAction,
+      formData: context.formData,
+      actionResult: context.actionResult,
+      defaultShouldRevalidate: true
+    };
+    try {
+      if (shouldRevalidateFn(args)) {
+        routeIds.push(route.id);
+      }
+    } catch (error) {
+      console.error(`shouldRevalidate threw for route "${route.id}", defaulting to revalidate:`, error);
+      routeIds.push(route.id);
+    }
+  }
+  return routeIds;
+}
+function checkShouldRevalidate(shouldRevalidateFn, args) {
+  if (!shouldRevalidateFn) {
+    return args.defaultShouldRevalidate;
+  }
+  try {
+    return shouldRevalidateFn(args);
+  } catch {
+    return args.defaultShouldRevalidate;
+  }
+}
+function useRevalidator() {
+  const [state, setState] = useState7("idle");
+  const loaderCtx = useContext5(LoaderDataContext);
+  const matchesCtx = useContext5(MatchesContext);
+  const revalidate = useCallback6(async () => {
+    if (typeof window === "undefined")
+      return;
+    setState("loading");
+    try {
+      const response = await fetch(window.location.href, {
+        headers: { Accept: "application/json" }
+      });
+      if (!response.ok) {
+        throw new Error(`Revalidation failed: ${response.status}`);
+      }
+      const result = await response.json();
+      if (loaderCtx) {
+        loaderCtx.setData(result.data);
+      }
+      if (matchesCtx && result.matches) {
+        matchesCtx.setMatches(result.matches);
+      }
+    } catch (error) {
+      console.error("Revalidation error:", error);
+    } finally {
+      setState("idle");
+    }
+  }, [loaderCtx, matchesCtx]);
+  return { state, revalidate };
+}
+// src/use-navigation-type.ts
+import { useState as useState8, useEffect as useEffect5 } from "react";
+function useNavigationType() {
+  const [type, setType] = useState8("push");
+  useEffect5(() => {
+    return router.subscribe((event) => {
+      setType(event.type);
+    });
+  }, []);
+  return type;
+}
+// src/use-before-unload.ts
+import { useRef as useRef4, useEffect as useEffect6 } from "react";
+function useBeforeUnload(callback, options) {
+  const callbackRef = useRef4(callback);
+  callbackRef.current = callback;
+  useEffect6(() => {
+    if (typeof window === "undefined")
+      return;
+    const handler = (event) => {
+      callbackRef.current(event);
+    };
+    const capture = options?.capture ?? false;
+    window.addEventListener("beforeunload", handler, { capture });
+    return () => {
+      window.removeEventListener("beforeunload", handler, { capture });
+    };
+  }, [options?.capture]);
+}
+// src/blocker.ts
+import { useState as useState9, useEffect as useEffect7, useCallback as useCallback8, useRef as useRef5 } from "react";
+function useBlocker(shouldBlock) {
+  const [state, setState] = useState9("unblocked");
+  const shouldBlockRef = useRef5(shouldBlock);
+  shouldBlockRef.current = shouldBlock;
+  useEffect7(() => {
+    if (typeof window === "undefined")
+      return;
+    const blockerFn = () => {
+      const block = typeof shouldBlockRef.current === "function" ? shouldBlockRef.current() : shouldBlockRef.current;
+      return block;
+    };
+    const removeBlocker = router.addBlocker(blockerFn);
+    const removeListener = router.subscribeBlocker(() => {
+      if (router.pendingNavigation) {
+        setState("blocked");
+      } else {
+        setState("unblocked");
+      }
+    });
+    return () => {
+      removeBlocker();
+      removeListener();
+    };
+  }, []);
+  useEffect7(() => {
+    if (typeof window === "undefined")
+      return;
+    const handleBeforeUnload = (e) => {
+      const block = typeof shouldBlockRef.current === "function" ? shouldBlockRef.current() : shouldBlockRef.current;
+      if (block) {
+        e.preventDefault();
+      }
+    };
+    window.addEventListener("beforeunload", handleBeforeUnload);
+    return () => window.removeEventListener("beforeunload", handleBeforeUnload);
+  }, []);
+  const proceed = useCallback8(() => {
+    setState("proceeding");
+    router.proceedNavigation();
+  }, []);
+  const reset = useCallback8(() => {
+    setState("unblocked");
+    router.resetNavigation();
+  }, []);
+  return { state, proceed, reset };
+}
 // src/error-boundary.tsx
 import React3, {
   Component,
-  useContext as useContext3
+  useContext as useContext6
 } from "react";
 class ErrorBoundary extends Component {
   constructor(props) {
@@ -1843,7 +2292,7 @@ class ErrorBoundary extends Component {
   }
 }
 function useErrorBoundary() {
-  const context = useContext3(ErrorContext);
+  const context = useContext6(ErrorContext);
   if (!context) {
     throw new Error("useErrorBoundary must be used within an EreoProvider or ErrorProvider. " + "Make sure your component is wrapped with the appropriate provider.");
   }
@@ -1854,7 +2303,7 @@ function useErrorBoundary() {
   };
 }
 function useRouteError() {
-  const context = useContext3(ErrorContext);
+  const context = useContext6(ErrorContext);
   return context?.error;
 }
 
@@ -1985,6 +2434,235 @@ class RouteError extends Error {
     };
   }
 }
+// src/outlet.ts
+import {
+  createContext as createContext5,
+  useContext as useContext7,
+  createElement as createElement4
+} from "react";
+var OutletElementContext = createContext5(null);
+var OutletDataContext = createContext5(null);
+function Outlet({ context } = {}) {
+  const elementCtx = useContext7(OutletElementContext);
+  if (elementCtx === null) {
+    return null;
+  }
+  const child = elementCtx.element;
+  if (context !== undefined) {
+    return createElement4(OutletDataContext.Provider, { value: { data: context } }, child);
+  }
+  return child;
+}
+function useOutletContext() {
+  const context = useContext7(OutletDataContext);
+  if (context === null) {
+    throw new Error("useOutletContext must be used within a route rendered by an <Outlet> " + "that has a context prop. Make sure the parent layout passes context " + "via <Outlet context={...} />.");
+  }
+  return context.data;
+}
+function OutletProvider({
+  children,
+  element,
+  context
+}) {
+  const elementValue = { element };
+  let tree = createElement4(OutletElementContext.Provider, { value: elementValue }, children);
+  if (context !== undefined) {
+    tree = createElement4(OutletDataContext.Provider, { value: { data: context } }, tree);
+  }
+  return tree;
+}
+// src/route-links.ts
+var EREO_LINK_ATTR = "data-ereo-link";
+var activeLinks = [];
+function renderLinkTags(links) {
+  return links.map((link) => {
+    const attrs = Object.entries(link).filter(([, v]) => v !== undefined).map(([k, v]) => `${k}="${escapeAttr(String(v))}"`).join(" ");
+    return `<link ${attrs} ${EREO_LINK_ATTR}>`;
+  }).join(`
+`);
+}
+function updateRouteLinks(links) {
+  if (typeof document === "undefined")
+    return;
+  removeRouteLinks();
+  const head = document.head;
+  const newLinks = [];
+  for (const descriptor of links) {
+    const link = document.createElement("link");
+    for (const [key, value] of Object.entries(descriptor)) {
+      if (value !== undefined) {
+        link.setAttribute(key, String(value));
+      }
+    }
+    link.setAttribute(EREO_LINK_ATTR, "");
+    head.appendChild(link);
+    newLinks.push(link);
+  }
+  activeLinks = newLinks;
+}
+function removeRouteLinks() {
+  if (typeof document === "undefined")
+    return;
+  for (const link of activeLinks) {
+    link.parentNode?.removeChild(link);
+  }
+  activeLinks = [];
+}
+function getActiveLinksCount() {
+  return activeLinks.length;
+}
+function escapeAttr(s) {
+  return s.replace(/&/g, "&amp;").replace(/"/g, "&quot;").replace(/</g, "&lt;");
+}
+// src/client-data.ts
+async function executeClientLoader(clientLoader, pathname, params, request) {
+  const req = request ?? new Request(typeof window !== "undefined" ? window.location.href : `http://localhost${pathname}`);
+  const serverLoader = async () => {
+    return fetchLoaderData(pathname, params);
+  };
+  const args = {
+    params,
+    request: req,
+    serverLoader
+  };
+  return clientLoader(args);
+}
+async function executeClientAction(clientAction, pathname, params, request) {
+  const serverAction = async () => {
+    const formData = await request.clone().formData().catch(() => {
+      return;
+    });
+    return submitAction(pathname, formData ?? new FormData);
+  };
+  const args = {
+    params,
+    request,
+    serverAction
+  };
+  return clientAction(args);
+}
+function shouldHydrateClientLoader(clientLoader) {
+  if (!clientLoader)
+    return false;
+  return clientLoader.hydrate === true;
+}
+function getHydrateFallback(module) {
+  if (!module)
+    return;
+  if (!shouldHydrateClientLoader(module.clientLoader))
+    return;
+  return module.HydrateFallback;
+}
+// src/lazy-route.ts
+var lazyRoutes = new Map;
+var moduleCache = new Map;
+var loadingPromises = new Map;
+function registerLazyRoute(id, path, loader) {
+  lazyRoutes.set(id, {
+    id,
+    path,
+    loader,
+    loaded: false
+  });
+}
+function registerLazyRoutes(routes) {
+  for (const [id, { path, loader }] of Object.entries(routes)) {
+    registerLazyRoute(id, path, loader);
+  }
+}
+async function loadLazyRoute(id) {
+  const cached = moduleCache.get(id);
+  if (cached)
+    return cached;
+  const inflight = loadingPromises.get(id);
+  if (inflight)
+    return inflight;
+  const route = lazyRoutes.get(id);
+  if (!route) {
+    throw new Error(`Lazy route "${id}" is not registered. ` + "Make sure to call registerLazyRoute() before loading.");
+  }
+  const promise = route.loader().then((module) => {
+    moduleCache.set(id, module);
+    route.loaded = true;
+    route.module = module;
+    loadingPromises.delete(id);
+    return module;
+  }).catch((error) => {
+    loadingPromises.delete(id);
+    throw error;
+  });
+  loadingPromises.set(id, promise);
+  return promise;
+}
+async function preloadLazyRoute(id) {
+  if (moduleCache.has(id))
+    return;
+  await loadLazyRoute(id);
+}
+function isRouteLoaded(id) {
+  return moduleCache.has(id);
+}
+function getLoadedModule(id) {
+  return moduleCache.get(id);
+}
+function getLazyRouteIds() {
+  return Array.from(lazyRoutes.keys());
+}
+function clearLazyRouteCache() {
+  moduleCache.clear();
+  loadingPromises.clear();
+  for (const route of lazyRoutes.values()) {
+    route.loaded = false;
+    route.module = undefined;
+  }
+}
+function resetLazyRoutes() {
+  lazyRoutes.clear();
+  moduleCache.clear();
+  loadingPromises.clear();
+}
+var manifest = null;
+function setRouteManifest(m) {
+  manifest = m;
+}
+function getRouteManifestEntry(id) {
+  return manifest?.[id];
+}
+function preloadRouteAssets(id) {
+  if (typeof document === "undefined")
+    return;
+  if (!manifest)
+    return;
+  const entry = manifest[id];
+  if (!entry)
+    return;
+  const head = document.head;
+  const existing = new Set(Array.from(head.querySelectorAll('link[rel="modulepreload"], link[rel="preload"]')).map((el) => el.getAttribute("href")));
+  if (!existing.has(entry.js)) {
+    const link = document.createElement("link");
+    link.rel = "modulepreload";
+    link.href = entry.js;
+    head.appendChild(link);
+  }
+  for (const css of entry.css || []) {
+    if (!existing.has(css)) {
+      const link = document.createElement("link");
+      link.rel = "preload";
+      link.href = css;
+      link.as = "style";
+      head.appendChild(link);
+    }
+  }
+  for (const imp of entry.imports || []) {
+    if (!existing.has(imp)) {
+      const link = document.createElement("link");
+      link.rel = "modulepreload";
+      link.href = imp;
+      head.appendChild(link);
+    }
+  }
+}
 // src/await.tsx
 import { jsxDEV as jsxDEV3, Fragment } from "react/jsx-dev-runtime";
 var promiseCache = new WeakMap;
@@ -2054,6 +2732,98 @@ function isDeferredData(value) {
 async function resolveAwait(deferred) {
   return deferred.promise;
 }
+// src/scroll-restoration.ts
+import { useEffect as useEffect8, useRef as useRef6, createElement as createElement5 } from "react";
+var memoryStore = new Map;
+function getScrollPosition(key, storageKey) {
+  if (typeof sessionStorage !== "undefined") {
+    try {
+      const stored = sessionStorage.getItem(`${storageKey}:${key}`);
+      if (stored)
+        return JSON.parse(stored);
+    } catch {}
+  }
+  return memoryStore.get(key);
+}
+function saveScrollPosition(key, position, storageKey) {
+  if (typeof sessionStorage !== "undefined") {
+    try {
+      sessionStorage.setItem(`${storageKey}:${key}`, JSON.stringify(position));
+      return;
+    } catch {}
+  }
+  memoryStore.set(key, position);
+}
+function clearScrollPositions() {
+  memoryStore.clear();
+}
+function ScrollRestoration({
+  getKey,
+  nonce,
+  storageKey = "ereo-scroll"
+} = {}) {
+  const isSetup = useRef6(false);
+  useEffect8(() => {
+    if (typeof window === "undefined")
+      return;
+    if (isSetup.current)
+      return;
+    isSetup.current = true;
+    if ("scrollRestoration" in history) {
+      history.scrollRestoration = "manual";
+    }
+    const keyFn = getKey ?? ((pathname) => pathname);
+    const unsubscribe = router.subscribe((event) => {
+      const fromKey = keyFn(event.from.pathname);
+      saveScrollPosition(fromKey, { x: window.scrollX, y: window.scrollY }, storageKey);
+      if (event.type === "pop") {
+        const toKey = keyFn(event.to.pathname);
+        const saved = getScrollPosition(toKey, storageKey);
+        if (saved) {
+          requestAnimationFrame(() => {
+            window.scrollTo(saved.x, saved.y);
+          });
+        }
+      } else {
+        if (event.to.hash) {
+          requestAnimationFrame(() => {
+            const target = document.getElementById(event.to.hash.slice(1));
+            if (target) {
+              target.scrollIntoView();
+            } else {
+              window.scrollTo(0, 0);
+            }
+          });
+        } else {
+          window.scrollTo(0, 0);
+        }
+      }
+    });
+    const handleBeforeUnload = () => {
+      const currentKey = keyFn(window.location.pathname);
+      saveScrollPosition(currentKey, { x: window.scrollX, y: window.scrollY }, storageKey);
+    };
+    window.addEventListener("beforeunload", handleBeforeUnload);
+    return () => {
+      unsubscribe();
+      window.removeEventListener("beforeunload", handleBeforeUnload);
+      if ("scrollRestoration" in history) {
+        history.scrollRestoration = "auto";
+      }
+      isSetup.current = false;
+    };
+  }, [getKey, storageKey]);
+  if (nonce !== undefined) {
+    return createElement5("script", {
+      nonce,
+      suppressHydrationWarning: true,
+      dangerouslySetInnerHTML: {
+        __html: `if("scrollRestoration" in history)history.scrollRestoration="manual";`
+      }
+    });
+  }
+  return null;
+}
 
 // src/index.ts
 function initClient() {
@@ -2063,11 +2833,20 @@ function initClient() {
 }
 export {
   withErrorBoundary,
+  useViewTransitionState,
   useTypedNavigate,
   useSubmit,
+  useSearchParams,
+  useRouteLoaderData,
   useRouteError,
+  useRevalidator,
+  useParams,
+  useOutletContext,
+  useNavigationType,
   useNavigationContext,
   useNavigation,
+  useMatches,
+  useLocation,
   useLoaderDataContext,
   useLoaderData,
   useIsRouteActive,
@@ -2075,30 +2854,45 @@ export {
   useNavigation2 as useFormNavigation,
   useFormContext,
   useActionData2 as useFormActionData,
+  useFetchers,
   useFetcher,
   useErrorContext,
   useErrorBoundary,
   useError,
+  useBlocker,
+  useBeforeUnload,
   useActionDataContext,
   useActionData,
+  updateRouteLinks,
   typedRedirect,
   typedNavigate,
   goForward2 as typedGoForward,
   goBack2 as typedGoBack,
   submitAction,
   stripHydrationProps,
+  startViewTransition,
+  shouldHydrateClientLoader,
   shouldHydrate,
   setupScrollRestoration,
   setupLinkPrefetch,
   setupAutoPrefetch,
+  setRouteManifest,
   serializeFormData,
   router,
   resolveAwait,
+  resetViewTransitions,
+  resetLazyRoutes,
   resetIslandCounter,
+  renderLinkTags,
+  removeRouteLinks,
+  registerLazyRoutes,
+  registerLazyRoute,
   registerIslandComponents,
   registerIslandComponent,
   redirect,
+  preloadRouteAssets,
   preloadRoute,
+  preloadLazyRoute,
   prefetchAll,
   prefetch,
   parseTypedSearchParams,
@@ -2108,7 +2902,10 @@ export {
   onNavigate,
   objectToFormData,
   navigate,
+  loadLazyRoute,
   islandRegistry,
+  isViewTransitionSupported,
+  isRouteLoaded,
   isRouteErrorResponse,
   isPrefetching,
   isPrefetched,
@@ -2119,27 +2916,53 @@ export {
   goForward,
   goBack,
   go,
+  getRoutesToRevalidate,
+  getRouteManifestEntry,
   getPrefetchedData,
   getNavigationState,
+  getLoadedModule,
+  getLazyRouteIds,
   getIslandCount,
   getIslandComponent,
+  getHydrateFallback,
+  getActiveLinksCount,
   generateIslandId,
   formDataToObject,
   fetchLoaderData,
+  executeClientLoader,
+  executeClientAction,
+  enableViewTransitions,
+  disableViewTransitions,
   createRouteErrorResponse,
   createIsland,
   createHydrationTrigger,
+  clearScrollPositions,
   clearPrefetchCache,
+  clearLazyRouteCache,
   cleanupIslands,
+  checkShouldRevalidate,
   buildUrl,
   buildTypedUrl,
+  areViewTransitionsEnabled,
+  ViewTransitionContext,
   TypedNavLink,
   TypedLink,
+  ScrollRestoration,
   RouteErrorBoundary,
   RouteError,
+  ParamsProvider,
+  ParamsContext,
+  OutletProvider,
+  OutletElementContext,
+  OutletDataContext,
+  Outlet,
   NavigationProvider,
   NavigationContext,
   NavLink,
+  MatchesProvider,
+  MatchesContext,
+  LocationProvider,
+  LocationContext,
   LoaderDataProvider,
   LoaderDataContext,
   Link,