@alepha/react 0.9.3 → 0.9.5

package/dist/index.d.ts

@@ -1,22 +1,15 @@
-import * as _alepha_core17 from "@alepha/core";
-import * as _alepha_core11 from "@alepha/core";
-import * as _alepha_core13 from "@alepha/core";
-import * as _alepha_core1 from "@alepha/core";
-import * as _alepha_core0 from "@alepha/core";
-import { Alepha, Async, Descriptor, KIND, Service, State, Static, TObject, TSchema } from "@alepha/core";
-import { ApiLinksResponse, RequestConfigSchema, ServerHandler, ServerRequest, ServerRouterProvider, ServerTimingProvider } from "@alepha/server";
+import * as _alepha_core14 from "@alepha/core";
+import { Alepha, Async, Descriptor, Hooks, KIND, Service, State, Static, TObject, TSchema } from "@alepha/core";
+import { RequestConfigSchema, ServerHandler, ServerProvider, ServerRequest, ServerRouterProvider, ServerTimingProvider } from "@alepha/server";
 import { ServerRouteCache } from "@alepha/server-cache";
 import { ClientScope, HttpVirtualClient, LinkProvider, VirtualAction } from "@alepha/server-links";
-import * as react0$1 from "react";
+import * as _alepha_logger1 from "@alepha/logger";
 import * as react0 from "react";
-import * as react1 from "react";
 import React, { AnchorHTMLAttributes, CSSProperties, ErrorInfo, FC, PropsWithChildren, ReactNode } from "react";
-import * as react_jsx_runtime0$1 from "react/jsx-runtime";
 import * as react_jsx_runtime0 from "react/jsx-runtime";
-import * as react_jsx_runtime2 from "react/jsx-runtime";
-import { Route, RouterProvider } from "@alepha/router";
 import { ServerStaticProvider } from "@alepha/server-static";
-import { Root } from "react-dom/client";
+import { DateTimeProvider } from "@alepha/datetime";
+import { Route, RouterProvider } from "@alepha/router";
 
 //#region src/components/ClientOnly.d.ts
 interface ClientOnlyProps {
@@ -35,132 +28,139 @@ interface ClientOnlyProps {
  */
 declare const ClientOnly: (props: PropsWithChildren<ClientOnlyProps>) => ReactNode;
 //#endregion
-//#region src/providers/BrowserRouterProvider.d.ts
-interface BrowserRoute extends Route {
-  page: PageRoute;
-}
-declare class BrowserRouterProvider extends RouterProvider<BrowserRoute> {
-  protected readonly log: _alepha_core17.Logger;
-  protected readonly alepha: Alepha;
-  protected readonly pageDescriptorProvider: PageDescriptorProvider;
-  add(entry: PageRouteEntry): void;
-  protected readonly configure: _alepha_core17.HookDescriptor<"configure">;
-  transition(url: URL, options?: TransitionOptions): Promise<RouterRenderResult>;
-  root(state: RouterState, context: PageReactContext): ReactNode;
+//#region src/errors/Redirection.d.ts
+/**
+ * Used for Redirection during the page loading.
+ *
+ * Depends on the context, it can be thrown or just returned.
+ */
+declare class Redirection extends Error {
+  readonly redirect: string;
+  constructor(redirect: string);
 }
-//# sourceMappingURL=BrowserRouterProvider.d.ts.map
 //#endregion
-//#region src/providers/ReactBrowserProvider.d.ts
-declare class ReactBrowserProvider {
-  protected readonly log: _alepha_core11.Logger;
-  protected readonly client: LinkProvider;
-  protected readonly alepha: Alepha;
-  protected readonly router: BrowserRouterProvider;
-  protected root: Root;
-  transitioning?: {
-    to: string;
+//#region src/providers/ReactPageProvider.d.ts
+declare const envSchema$2: _alepha_core14.TObject<{
+  REACT_STRICT_MODE: _alepha_core14.TBoolean;
+}>;
+declare module "@alepha/core" {
+  interface Env extends Partial<Static<typeof envSchema$2>> {}
+}
+declare class ReactPageProvider {
+  protected readonly log: _alepha_logger1.Logger;
+  protected readonly env: {
+    REACT_STRICT_MODE: boolean;
   };
-  state: RouterState;
-  get document(): Document;
-  get history(): History;
-  get location(): Location;
-  get url(): string;
-  pushState(url: string, replace?: boolean): void;
-  invalidate(props?: Record<string, any>): Promise<void>;
-  go(url: string, options?: RouterGoOptions): Promise<void>;
-  protected render(options?: {
-    url?: string;
-    previous?: PreviousLayerData[];
-  }): Promise<RouterRenderResult>;
+  protected readonly alepha: Alepha;
+  protected readonly pages: PageRoute[];
+  getPages(): PageRoute[];
+  page(name: string): PageRoute;
+  pathname(name: string, options?: {
+    params?: Record<string, string>;
+    query?: Record<string, string>;
+  }): string;
+  url(name: string, options?: {
+    params?: Record<string, string>;
+    host?: string;
+  }): URL;
+  root(state: ReactRouterState): ReactNode;
+  protected convertStringObjectToObject: (schema?: TSchema, value?: any) => any;
   /**
-   * Get embedded layers from the server.
+   * Create a new RouterState based on a given route and request.
+   * This method resolves the layers for the route, applying any query and params schemas defined in the route.
+   * It also handles errors and redirects.
    */
-  protected getHydrationState(): ReactHydrationState | undefined;
-  readonly ready: _alepha_core11.HookDescriptor<"ready">;
+  createLayers(route: PageRoute, state: ReactRouterState, previous?: PreviousLayerData[]): Promise<CreateLayersResult>;
+  protected createRedirectionLayer(redirect: string): CreateLayersResult;
+  protected getErrorHandler(route: PageRoute): ErrorHandler | undefined;
+  protected createElement(page: PageRoute, props: Record<string, any>): Promise<ReactNode>;
+  renderError(error: Error): ReactNode;
+  renderEmptyView(): ReactNode;
+  href(page: {
+    options: {
+      name?: string;
+    };
+  }, params?: Record<string, any>): string;
+  compile(path: string, params?: Record<string, string>): string;
+  protected renderView(index: number, path: string, view: ReactNode | undefined, page: PageRoute): ReactNode;
+  protected readonly configure: _alepha_core14.HookDescriptor<"configure">;
+  protected map(pages: Array<PageDescriptor>, target: PageDescriptor): PageRouteEntry;
+  add(entry: PageRouteEntry): void;
+  protected createMatch(page: PageRoute): string;
+  protected _next: number;
+  protected nextId(): string;
 }
-interface RouterGoOptions {
-  replace?: boolean;
-  match?: TransitionOptions;
-  params?: Record<string, string>;
-  query?: Record<string, string>;
+declare const isPageRoute: (it: any) => it is PageRoute;
+interface PageRouteEntry extends Omit<PageDescriptorOptions, "children" | "parent"> {
+  children?: PageRouteEntry[];
 }
-interface ReactHydrationState {
-  layers?: Array<PreviousLayerData>;
-  links?: ApiLinksResponse;
+interface PageRoute extends PageRouteEntry {
+  type: "page";
+  name: string;
+  parent?: PageRoute;
+  match: string;
 }
-//# sourceMappingURL=ReactBrowserProvider.d.ts.map
-//#endregion
-//#region src/hooks/RouterHookApi.d.ts
-declare class RouterHookApi<T extends object> {
-  private readonly pages;
-  private readonly context;
-  private readonly state;
-  private readonly layer;
-  private readonly pageApi;
-  private readonly browser?;
-  constructor(pages: PageRoute[], context: PageReactContext, state: RouterState, layer: {
-    path: string;
-  }, pageApi: PageDescriptorProvider, browser?: ReactBrowserProvider | undefined);
-  path(name: keyof VirtualRouter<T>, config?: {
-    params?: Record<string, string>;
-    query?: Record<string, string>;
-  }): string;
-  getURL(): URL;
-  get location(): Location;
-  get current(): RouterState;
-  get pathname(): string;
-  get query(): Record<string, string>;
-  back(): Promise<void>;
-  forward(): Promise<void>;
-  invalidate(props?: Record<string, any>): Promise<void>;
+interface Layer {
+  config?: {
+    query?: Record<string, any>;
+    params?: Record<string, any>;
+    context?: Record<string, any>;
+  };
+  name: string;
+  props?: Record<string, any>;
+  error?: Error;
+  part?: string;
+  element: ReactNode;
+  index: number;
+  path: string;
+  route?: PageRoute;
+  cache?: boolean;
+}
+type PreviousLayerData = Omit<Layer, "element" | "index" | "path">;
+interface AnchorProps {
+  href: string;
+  onClick: (ev?: any) => any;
+}
+interface ReactRouterState {
   /**
-   * Create a valid href for the given pathname.
-   *
-   * @param pathname
-   * @param layer
+   * Stack of layers for the current page.
    */
-  createHref(pathname: HrefLike, layer?: {
-    path: string;
-  }, options?: {
-    params?: Record<string, any>;
-  }): string;
-  go(path: string, options?: RouterGoOptions): Promise<void>;
-  go(path: keyof VirtualRouter<T>, options?: RouterGoOptions): Promise<void>;
-  anchor(path: string, options?: {
-    params?: Record<string, any>;
-  }): AnchorProps;
-  anchor(path: keyof VirtualRouter<T>, options?: {
-    params?: Record<string, any>;
-  }): AnchorProps;
+  layers: Array<Layer>;
   /**
-   * Set query params.
-   *
-   * @param record
-   * @param options
+   * URL of the current page.
    */
-  setQueryParams(record: Record<string, any> | ((queryParams: Record<string, any>) => Record<string, any>), options?: {
-    /**
-     * If true, this will add a new entry to the history stack.
-     */
-    push?: boolean;
-  }): void;
+  url: URL;
+  /**
+   * Error handler for the current page.
+   */
+  onError: ErrorHandler;
+  /**
+   * Params extracted from the URL for the current page.
+   */
+  params: Record<string, any>;
+  /**
+   * Query parameters extracted from the URL for the current page.
+   */
+  query: Record<string, string>;
+  /**
+   * Optional meta information associated with the current page.
+   */
+  meta: Record<string, any>;
 }
-type HrefLike = string | {
-  options: {
-    path?: string;
-    name?: string;
-  };
-};
-type VirtualRouter<T> = { [K in keyof T as T[K] extends PageDescriptor ? K : never]: T[K] };
-//# sourceMappingURL=RouterHookApi.d.ts.map
-//#endregion
-//#region src/errors/Redirection.d.ts
-declare class Redirection extends Error {
-  readonly page: HrefLike;
-  constructor(page: HrefLike);
+interface RouterStackItem {
+  route: PageRoute;
+  config?: Record<string, any>;
+  props?: Record<string, any>;
+  error?: Error;
+  cache?: boolean;
+}
+interface TransitionOptions {
+  previous?: PreviousLayerData[];
+}
+interface CreateLayersResult {
+  redirect?: string;
+  state?: ReactRouterState;
 }
-//# sourceMappingURL=Redirection.d.ts.map
-
 //#endregion
 //#region src/descriptors/$page.d.ts
 /**
@@ -299,8 +299,51 @@ interface PageDescriptorOptions<TConfig extends PageConfigSchema = PageConfigSch
    * Called when user leaves the page. (browser only)
    */
   onLeave?: () => void;
+  /**
+   * @experimental
+   *
+   * Add a css animation when the page is loaded or unloaded.
+   * It uses CSS animations, so you need to define the keyframes in your CSS.
+   *
+   * @example Simple animation name
+   * ```ts
+   * animation: "fadeIn"
+   * ```
+   *
+   * CSS example:
+   * ```css
+   * @keyframes fadeIn {
+   *  from { opacity: 0; }
+   *  to { opacity: 1; }
+   * }
+   * ```
+   *
+   * @example Detailed animation
+   * ```ts
+   * animation: {
+   *   enter: { name: "fadeIn", duration: 300 },
+   *   exit: { name: "fadeOut", duration: 200, timing: "ease-in-out" },
+   * }
+   * ```
+   *
+   * @example Only exit animation
+   * ```ts
+   * animation: {
+   *   exit: "fadeOut"
+   * }
+   * ```
+   *
+   * @example With custom timing function
+   * ```ts
+   * animation: {
+   *   enter: { name: "fadeIn", duration: 300, timing: "cubic-bezier(0.4, 0, 0.2, 1)" },
+   *   exit: { name: "fadeOut", duration: 200, timing: "ease-in-out" },
+   * }
+   * ```
+   */
+  animation?: PageAnimation;
 }
-type ErrorHandler = (error: Error, context: PageReactContext) => ReactNode | Redirection | undefined;
+type ErrorHandler = (error: Error, state: ReactRouterState) => ReactNode | Redirection | undefined;
 declare class PageDescriptor<TConfig extends PageConfigSchema = PageConfigSchema, TProps extends object = TPropsDefault, TPropsParent extends object = TPropsParentDefault> extends Descriptor<PageDescriptorOptions<TConfig, TProps, TPropsParent>> {
   protected onInit(): void;
   get name(): string;
@@ -309,6 +352,12 @@ declare class PageDescriptor<TConfig extends PageConfigSchema = PageConfigSchema
    * Only valid for server-side rendering, it will throw an error if called on the client-side.
    */
   render(options?: PageDescriptorRenderOptions): Promise<PageDescriptorRenderResult>;
+  fetch(options?: PageDescriptorRenderOptions): Promise<{
+    html: string;
+    response: Response;
+  }>;
+  match(url: string): boolean;
+  pathname(config: any): string;
 }
 interface PageConfigSchema {
   query?: TSchema;
@@ -319,144 +368,122 @@ type TPropsParentDefault = {};
 interface PageDescriptorRenderOptions {
   params?: Record<string, string>;
   query?: Record<string, string>;
+  /**
+   * If true, the HTML layout will be included in the response.
+   * If false, only the page content will be returned.
+   *
+   * @default true
+   */
   html?: boolean;
   hydration?: boolean;
 }
 interface PageDescriptorRenderResult {
   html: string;
-  context: PageReactContext;
+  state: ReactRouterState;
+  redirect?: string;
 }
 interface PageRequestConfig<TConfig extends PageConfigSchema = PageConfigSchema> {
   params: TConfig["params"] extends TSchema ? Static<TConfig["params"]> : Record<string, string>;
   query: TConfig["query"] extends TSchema ? Static<TConfig["query"]> : Record<string, string>;
 }
-type PageResolve<TConfig extends PageConfigSchema = PageConfigSchema, TPropsParent extends object = TPropsParentDefault> = PageRequestConfig<TConfig> & TPropsParent & PageReactContext;
-//# sourceMappingURL=$page.d.ts.map
+type PageResolve<TConfig extends PageConfigSchema = PageConfigSchema, TPropsParent extends object = TPropsParentDefault> = PageRequestConfig<TConfig> & TPropsParent & Omit<ReactRouterState, "layers" | "onError">;
+type PageAnimation = PageAnimationObject | ((state: ReactRouterState) => PageAnimationObject | undefined);
+type PageAnimationObject = CssAnimationName | {
+  enter?: CssAnimation | CssAnimationName;
+  exit?: CssAnimation | CssAnimationName;
+};
+type CssAnimationName = string;
+type CssAnimation = {
+  name: string;
+  duration?: number;
+  timing?: string;
+};
 //#endregion
-//#region src/providers/PageDescriptorProvider.d.ts
-declare const envSchema$1: _alepha_core13.TObject<{
-  REACT_STRICT_MODE: _alepha_core13.TBoolean;
+//#region src/providers/ReactBrowserRouterProvider.d.ts
+interface BrowserRoute extends Route {
+  page: PageRoute;
+}
+declare class ReactBrowserRouterProvider extends RouterProvider<BrowserRoute> {
+  protected readonly log: _alepha_logger1.Logger;
+  protected readonly alepha: Alepha;
+  protected readonly pageApi: ReactPageProvider;
+  add(entry: PageRouteEntry): void;
+  protected readonly configure: _alepha_core14.HookDescriptor<"configure">;
+  transition(url: URL, previous?: PreviousLayerData[], meta?: {}): Promise<string | void>;
+  root(state: ReactRouterState): ReactNode;
+}
+//#endregion
+//#region src/providers/ReactBrowserProvider.d.ts
+declare const envSchema$1: _alepha_core14.TObject<{
+  REACT_ROOT_ID: _alepha_core14.TString;
 }>;
 declare module "@alepha/core" {
   interface Env extends Partial<Static<typeof envSchema$1>> {}
 }
-declare class PageDescriptorProvider {
-  protected readonly log: _alepha_core13.Logger;
+interface ReactBrowserRendererOptions {
+  scrollRestoration?: "top" | "manual";
+}
+declare class ReactBrowserProvider {
   protected readonly env: {
-    REACT_STRICT_MODE: boolean;
+    REACT_ROOT_ID: string;
   };
+  protected readonly log: _alepha_logger1.Logger;
+  protected readonly client: LinkProvider;
   protected readonly alepha: Alepha;
-  protected readonly pages: PageRoute[];
-  getPages(): PageRoute[];
-  page(name: string): PageRoute;
-  pathname(name: string, options?: {
-    params?: Record<string, string>;
-    query?: Record<string, string>;
-  }): string;
-  url(name: string, options?: {
-    params?: Record<string, string>;
-    base?: string;
-  }): URL;
-  root(state: RouterState, context: PageReactContext): ReactNode;
-  createLayers(route: PageRoute, request: PageRequest): Promise<CreateLayersResult>;
-  protected createRedirectionLayer(href: HrefLike, context: {
-    pathname: string;
-    search: string;
-  }): {
-    layers: never[];
-    redirect: string;
-    pathname: string;
-    search: string;
-  };
-  protected getErrorHandler(route: PageRoute): ErrorHandler | undefined;
-  protected createElement(page: PageRoute, props: Record<string, any>): Promise<ReactNode>;
-  renderError(error: Error): ReactNode;
-  renderEmptyView(): ReactNode;
-  href(page: {
-    options: {
-      name?: string;
-    };
-  }, params?: Record<string, any>): string;
-  compile(path: string, params?: Record<string, string>): string;
-  protected renderView(index: number, path: string, view: ReactNode | undefined, page: PageRoute): ReactNode;
-  protected readonly configure: _alepha_core13.HookDescriptor<"configure">;
-  protected map(pages: Array<PageDescriptor>, target: PageDescriptor): PageRouteEntry;
-  add(entry: PageRouteEntry): void;
-  protected createMatch(page: PageRoute): string;
-  protected _next: number;
-  protected nextId(): string;
-}
-declare const isPageRoute: (it: any) => it is PageRoute;
-interface PageRouteEntry extends Omit<PageDescriptorOptions, "children" | "parent"> {
-  children?: PageRouteEntry[];
-}
-interface PageRoute extends PageRouteEntry {
-  type: "page";
-  name: string;
-  parent?: PageRoute;
-  match: string;
-}
-interface Layer {
-  config?: {
-    query?: Record<string, any>;
-    params?: Record<string, any>;
-    context?: Record<string, any>;
+  protected readonly router: ReactBrowserRouterProvider;
+  protected readonly dateTimeProvider: DateTimeProvider;
+  options: ReactBrowserRendererOptions;
+  protected getRootElement(): HTMLElement;
+  transitioning?: {
+    to: string;
+    from?: string;
   };
-  name: string;
-  props?: Record<string, any>;
-  error?: Error;
-  part?: string;
-  element: ReactNode;
-  index: number;
-  path: string;
-  route?: PageRoute;
-  cache?: boolean;
-}
-type PreviousLayerData = Omit<Layer, "element" | "index" | "path">;
-interface AnchorProps {
-  href: string;
-  onClick: (ev?: any) => any;
-}
-interface RouterState {
-  pathname: string;
-  search: string;
-  layers: Array<Layer>;
-}
-interface TransitionOptions {
-  state?: RouterState;
-  previous?: PreviousLayerData[];
-  context?: PageReactContext;
-}
-interface RouterStackItem {
-  route: PageRoute;
-  config?: Record<string, any>;
-  props?: Record<string, any>;
-  error?: Error;
-  cache?: boolean;
+  get state(): ReactRouterState;
+  /**
+   * Accessor for Document DOM API.
+   */
+  get document(): Document;
+  /**
+   * Accessor for History DOM API.
+   */
+  get history(): History;
+  /**
+   * Accessor for Location DOM API.
+   */
+  get location(): Location;
+  get base(): string;
+  get url(): string;
+  pushState(path: string, replace?: boolean): void;
+  invalidate(props?: Record<string, any>): Promise<void>;
+  go(url: string, options?: RouterGoOptions): Promise<void>;
+  protected render(options?: RouterRenderOptions): Promise<void>;
+  /**
+   * Get embedded layers from the server.
+   */
+  protected getHydrationState(): ReactHydrationState | undefined;
+  protected readonly onTransitionEnd: _alepha_core14.HookDescriptor<"react:transition:end">;
+  readonly ready: _alepha_core14.HookDescriptor<"ready">;
 }
-interface RouterRenderResult {
-  state: RouterState;
-  context: PageReactContext;
-  redirect?: string;
+interface RouterGoOptions {
+  replace?: boolean;
+  match?: TransitionOptions;
+  params?: Record<string, string>;
+  query?: Record<string, string>;
+  meta?: Record<string, any>;
+  /**
+   * Recreate the whole page, ignoring the current state.
+   */
+  force?: boolean;
 }
-interface PageRequest extends PageReactContext {
-  params: Record<string, any>;
-  query: Record<string, string>;
+type ReactHydrationState = {
+  layers?: Array<PreviousLayerData>;
+} & {
+  [key: string]: any;
+};
+interface RouterRenderOptions {
+  url?: string;
   previous?: PreviousLayerData[];
-}
-interface CreateLayersResult extends RouterState {
-  redirect?: string;
-}
-/**
- * It's like RouterState, but publicly available in React context.
- * This is where we store all plugin data!
- */
-interface PageReactContext {
-  url: URL;
-  onError: ErrorHandler;
-  links?: ApiLinksResponse;
-  params: Record<string, any>;
-  query: Record<string, string>;
+  meta?: Record<string, any>;
 }
 //#endregion
 //#region src/components/ErrorBoundary.d.ts
@@ -499,120 +526,170 @@ declare class ErrorBoundary extends React.Component<PropsWithChildren<ErrorBound
   render(): ReactNode;
 }
 //#endregion
+//#region src/components/ErrorViewer.d.ts
+interface ErrorViewerProps {
+  error: Error;
+  alepha: Alepha;
+}
+declare const ErrorViewer: ({
+  error,
+  alepha
+}: ErrorViewerProps) => react_jsx_runtime0.JSX.Element;
+//#endregion
 //#region src/components/Link.d.ts
 interface LinkProps extends AnchorHTMLAttributes<HTMLAnchorElement> {
-  to: string;
-  children?: React.ReactNode;
+  href: string;
 }
-declare const Link: (props: LinkProps) => react_jsx_runtime0$1.JSX.Element;
+declare const Link: (props: LinkProps) => react_jsx_runtime0.JSX.Element;
 //#endregion
 //#region src/components/NestedView.d.ts
 interface NestedViewProps {
   children?: ReactNode;
+  errorBoundary?: false | ((error: Error) => ReactNode);
 }
-/**
- * A component that renders the current view of the nested router layer.
- *
- * To be simple, it renders the `element` of the current child page of a parent page.
- *
- * @example
- * ```tsx
- * import { NestedView } from "@alepha/react";
- *
- * class App {
- *   parent = $page({
- *     component: () => <NestedView />,
- *   });
- *
- *   child = $page({
- *     parent: this.root,
- *     component: () => <div>Child Page</div>,
- *   });
- * }
- * ```
- */
-declare const NestedView: (props: NestedViewProps) => react_jsx_runtime0.JSX.Element;
+declare const _default: react0.MemoExoticComponent<(props: NestedViewProps) => react_jsx_runtime0.JSX.Element>;
 //#endregion
 //#region src/components/NotFound.d.ts
 declare function NotFoundPage(props: {
   style?: CSSProperties;
-}): react_jsx_runtime2.JSX.Element;
-//# sourceMappingURL=NotFound.d.ts.map
+}): react_jsx_runtime0.JSX.Element;
 //#endregion
 //#region src/contexts/AlephaContext.d.ts
-declare const AlephaContext: react0$1.Context<Alepha | undefined>;
-//# sourceMappingURL=AlephaContext.d.ts.map
-//#endregion
-//#region src/contexts/RouterContext.d.ts
-interface RouterContextValue {
-  state: RouterState;
-  context: PageReactContext;
-}
-declare const RouterContext: react0.Context<RouterContextValue | undefined>;
-//# sourceMappingURL=RouterContext.d.ts.map
+declare const AlephaContext: react0.Context<Alepha | undefined>;
 //#endregion
 //#region src/contexts/RouterLayerContext.d.ts
 interface RouterLayerContextValue {
   index: number;
   path: string;
 }
-declare const RouterLayerContext: react1.Context<RouterLayerContextValue | undefined>;
-//# sourceMappingURL=RouterLayerContext.d.ts.map
+declare const RouterLayerContext: react0.Context<RouterLayerContextValue | undefined>;
 //#endregion
 //#region src/hooks/useActive.d.ts
-declare const useActive: (path?: HrefLike) => UseActiveHook;
+interface UseActiveOptions {
+  href: string;
+  startWith?: boolean;
+}
+declare const useActive: (args: string | UseActiveOptions) => UseActiveHook;
 interface UseActiveHook {
   isActive: boolean;
   anchorProps: AnchorProps;
   isPending: boolean;
-  name?: string;
 }
-//# sourceMappingURL=useActive.d.ts.map
 //#endregion
 //#region src/hooks/useAlepha.d.ts
+/**
+ * Main Alepha hook.
+ *
+ * It provides access to the Alepha instance within a React component.
+ *
+ * With Alepha, you can access the core functionalities of the framework:
+ *
+ * - alepha.state() for state management
+ * - alepha.inject() for dependency injection
+ * - alepha.emit() for event handling
+ * etc...
+ */
 declare const useAlepha: () => Alepha;
-//# sourceMappingURL=useAlepha.d.ts.map
 //#endregion
 //#region src/hooks/useClient.d.ts
-declare const useClient: <T extends object>(_scope?: ClientScope) => HttpVirtualClient<T>;
-//# sourceMappingURL=useClient.d.ts.map
+/**
+ * Hook to get a virtual client for the specified scope.
+ *
+ * It's the React-hook version of `$client()`, from `AlephaServerLinks` module.
+ */
+declare const useClient: <T extends object>(scope?: ClientScope) => HttpVirtualClient<T>;
 //#endregion
 //#region src/hooks/useInject.d.ts
+/**
+ * Hook to inject a service instance.
+ * It's a wrapper of `useAlepha().inject(service)` with a memoization.
+ */
 declare const useInject: <T extends object>(service: Service<T>) => T;
-//# sourceMappingURL=useInject.d.ts.map
 //#endregion
 //#region src/hooks/useQueryParams.d.ts
+/**
+ * Not well tested. Use with caution.
+ */
+declare const useQueryParams: <T extends TObject>(schema: T, options?: UseQueryParamsHookOptions) => [Static<T>, (data: Static<T>) => void];
 interface UseQueryParamsHookOptions {
   format?: "base64" | "querystring";
   key?: string;
   push?: boolean;
 }
-declare const useQueryParams: <T extends TObject>(schema: T, options?: UseQueryParamsHookOptions) => [Static<T>, (data: Static<T>) => void];
-//# sourceMappingURL=useQueryParams.d.ts.map
+//#endregion
+//#region src/services/ReactRouter.d.ts
+declare class ReactRouter<T extends object> {
+  protected readonly alepha: Alepha;
+  protected readonly pageApi: ReactPageProvider;
+  get state(): ReactRouterState;
+  get pages(): PageRoute[];
+  get browser(): ReactBrowserProvider | undefined;
+  path(name: keyof VirtualRouter<T>, config?: {
+    params?: Record<string, any>;
+    query?: Record<string, any>;
+  }): string;
+  getURL(): URL;
+  get location(): Location;
+  get current(): ReactRouterState;
+  get pathname(): string;
+  get query(): Record<string, string>;
+  back(): Promise<void>;
+  forward(): Promise<void>;
+  invalidate(props?: Record<string, any>): Promise<void>;
+  go(path: string, options?: RouterGoOptions): Promise<void>;
+  go(path: keyof VirtualRouter<T>, options?: RouterGoOptions): Promise<void>;
+  anchor(path: string, options?: RouterGoOptions): AnchorProps;
+  anchor(path: keyof VirtualRouter<T>, options?: RouterGoOptions): AnchorProps;
+  base(path: string): string;
+  /**
+   * Set query params.
+   *
+   * @param record
+   * @param options
+   */
+  setQueryParams(record: Record<string, any> | ((queryParams: Record<string, any>) => Record<string, any>), options?: {
+    /**
+     * If true, this will add a new entry to the history stack.
+     */
+    push?: boolean;
+  }): void;
+}
+type VirtualRouter<T> = { [K in keyof T as T[K] extends PageDescriptor ? K : never]: T[K] };
 //#endregion
 //#region src/hooks/useRouter.d.ts
-declare const useRouter: <T extends object>() => RouterHookApi<T>;
-//# sourceMappingURL=useRouter.d.ts.map
+/**
+ * Use this hook to access the React Router instance.
+ *
+ * You can add a type parameter to specify the type of your application.
+ * This will allow you to use the router in a typesafe way.
+ *
+ * @example
+ * class App {
+ *   home = $page();
+ * }
+ *
+ * const router = useRouter<App>();
+ * router.go("home"); // typesafe
+ */
+declare const useRouter: <T extends object = any>() => ReactRouter<T>;
 //#endregion
 //#region src/hooks/useRouterEvents.d.ts
+type Hook<T extends keyof Hooks> = ((ev: Hooks[T]) => void) | {
+  priority?: "first" | "last";
+  callback: (ev: Hooks[T]) => void;
+};
+/**
+ * Subscribe to various router events.
+ */
 declare const useRouterEvents: (opts?: {
-  onBegin?: (ev: {
-    state: RouterState;
-  }) => void;
-  onEnd?: (ev: {
-    state: RouterState;
-    context: PageReactContext;
-  }) => void;
-  onError?: (ev: {
-    state: RouterState;
-    error: Error;
-  }) => void;
+  onBegin?: Hook<"react:transition:begin">;
+  onError?: Hook<"react:transition:error">;
+  onEnd?: Hook<"react:transition:end">;
+  onSuccess?: Hook<"react:transition:success">;
 }, deps?: any[]) => void;
-//# sourceMappingURL=useRouterEvents.d.ts.map
 //#endregion
 //#region src/hooks/useRouterState.d.ts
-declare const useRouterState: () => RouterState;
-//# sourceMappingURL=useRouterState.d.ts.map
+declare const useRouterState: () => ReactRouterState;
 //#endregion
 //#region src/hooks/useSchema.d.ts
 declare const useSchema: <TConfig extends RequestConfigSchema>(action: VirtualAction<TConfig>) => UseSchemaReturn<TConfig>;
@@ -625,22 +702,20 @@ type UseSchemaReturn<TConfig extends RequestConfigSchema> = TConfig & {
 declare const ssrSchemaLoading: (alepha: Alepha, name: string) => RequestConfigSchema | {
   loading: boolean;
 };
-//# sourceMappingURL=useSchema.d.ts.map
 //#endregion
 //#region src/hooks/useStore.d.ts
 /**
  * Hook to access and mutate the Alepha state.
  */
 declare const useStore: <Key extends keyof State>(key: Key, defaultValue?: State[Key]) => [State[Key], (value: State[Key]) => void];
-//# sourceMappingURL=useStore.d.ts.map
 //#endregion
 //#region src/providers/ReactServerProvider.d.ts
-declare const envSchema: _alepha_core1.TObject<{
-  REACT_SERVER_DIST: _alepha_core1.TString;
-  REACT_SERVER_PREFIX: _alepha_core1.TString;
-  REACT_SSR_ENABLED: _alepha_core1.TOptional<_alepha_core1.TBoolean>;
-  REACT_ROOT_ID: _alepha_core1.TString;
-  REACT_SERVER_TEMPLATE: _alepha_core1.TOptional<_alepha_core1.TString>;
+declare const envSchema: _alepha_core14.TObject<{
+  REACT_SERVER_DIST: _alepha_core14.TString;
+  REACT_SERVER_PREFIX: _alepha_core14.TString;
+  REACT_SSR_ENABLED: _alepha_core14.TOptional<_alepha_core14.TBoolean>;
+  REACT_ROOT_ID: _alepha_core14.TString;
+  REACT_SERVER_TEMPLATE: _alepha_core14.TOptional<_alepha_core14.TString>;
 }>;
 declare module "@alepha/core" {
   interface Env extends Partial<Static<typeof envSchema>> {}
@@ -649,9 +724,10 @@ declare module "@alepha/core" {
   }
 }
 declare class ReactServerProvider {
-  protected readonly log: _alepha_core1.Logger;
+  protected readonly log: _alepha_logger1.Logger;
   protected readonly alepha: Alepha;
-  protected readonly pageDescriptorProvider: PageDescriptorProvider;
+  protected readonly pageApi: ReactPageProvider;
+  protected readonly serverProvider: ServerProvider;
   protected readonly serverStaticProvider: ServerStaticProvider;
   protected readonly serverRouterProvider: ServerRouterProvider;
   protected readonly serverTimingProvider: ServerTimingProvider;
@@ -663,7 +739,7 @@ declare class ReactServerProvider {
     REACT_ROOT_ID: string;
   };
   protected readonly ROOT_DIV_REGEX: RegExp;
-  readonly onConfigure: _alepha_core1.HookDescriptor<"configure">;
+  readonly onConfigure: _alepha_core14.HookDescriptor<"configure">;
   get template(): string;
   protected registerPages(templateLoader: TemplateLoader): Promise<void>;
   protected getPublicDirectory(): string;
@@ -672,16 +748,9 @@ declare class ReactServerProvider {
   /**
    * For testing purposes, creates a render function that can be used.
    */
-  protected createRenderFunction(name: string, withIndex?: boolean): (options?: PageDescriptorRenderOptions) => Promise<{
-    context: PageRequest;
-    state: CreateLayersResult;
-    html: string;
-  } | {
-    context: PageRequest;
-    html: string;
-  }>;
-  protected createHandler(page: PageRoute, templateLoader: TemplateLoader): ServerHandler;
-  renderToHtml(template: string, state: RouterState, context: PageReactContext, hydration?: boolean): string | Redirection;
+  protected createRenderFunction(name: string, withIndex?: boolean): (options?: PageDescriptorRenderOptions) => Promise<PageDescriptorRenderResult>;
+  protected createHandler(route: PageRoute, templateLoader: TemplateLoader): ServerHandler;
+  renderToHtml(template: string, state: ReactRouterState, hydration?: boolean): string | Redirection;
   protected fillTemplate(response: {
     html: string;
   }, app: string, script: string): void;
@@ -690,43 +759,39 @@ type TemplateLoader = () => Promise<string | undefined>;
 //#endregion
 //#region src/index.d.ts
 declare module "@alepha/core" {
+  interface State {
+    "react.router.state"?: ReactRouterState;
+  }
   interface Hooks {
-    "react:router:createLayers": {
-      request: ServerRequest;
-      context: PageRequest;
-      layers: PageRequest[];
-    };
     "react:server:render:begin": {
       request?: ServerRequest;
-      context: PageRequest;
+      state: ReactRouterState;
     };
     "react:server:render:end": {
       request?: ServerRequest;
-      context: PageRequest;
-      state: RouterState;
+      state: ReactRouterState;
       html: string;
     };
     "react:browser:render": {
-      state: RouterState;
-      context: PageReactContext;
+      root: HTMLDivElement;
+      element: ReactNode;
+      state: ReactRouterState;
       hydration?: ReactHydrationState;
     };
     "react:transition:begin": {
-      state: RouterState;
-      context: PageReactContext;
+      previous: ReactRouterState;
+      state: ReactRouterState;
+      animation?: PageAnimation;
     };
     "react:transition:success": {
-      state: RouterState;
-      context: PageReactContext;
+      state: ReactRouterState;
     };
     "react:transition:error": {
+      state: ReactRouterState;
       error: Error;
-      state: RouterState;
-      context: PageReactContext;
     };
     "react:transition:end": {
-      state: RouterState;
-      context: PageReactContext;
+      state: ReactRouterState;
     };
   }
 }
@@ -740,9 +805,7 @@ declare module "@alepha/core" {
  * @see {@link $page}
  * @module alepha.react
  */
-declare const AlephaReact: _alepha_core0.Service<_alepha_core0.Module>;
-//# sourceMappingURL=index.d.ts.map
-
+declare const AlephaReact: _alepha_core14.Service<_alepha_core14.Module>;
 //#endregion
-export { $page, AlephaContext, AlephaReact, AnchorProps, ClientOnly, CreateLayersResult, ErrorBoundary, ErrorHandler, HrefLike, Layer, Link, LinkProps, NestedView, NotFoundPage as NotFound, PageConfigSchema, PageDescriptor, PageDescriptorOptions, PageDescriptorProvider, PageDescriptorRenderOptions, PageDescriptorRenderResult, PageReactContext, PageRequest, PageRequestConfig, PageResolve, PageRoute, PageRouteEntry, PreviousLayerData, ReactBrowserProvider, ReactHydrationState, ReactServerProvider, Redirection, RouterContext, RouterContextValue, RouterGoOptions, RouterHookApi, RouterLayerContext, RouterLayerContextValue, RouterRenderResult, RouterStackItem, RouterState, TPropsDefault, TPropsParentDefault, TransitionOptions, UseActiveHook, UseQueryParamsHookOptions, UseSchemaReturn, VirtualRouter, isPageRoute, ssrSchemaLoading, useActive, useAlepha, useClient, useInject, useQueryParams, useRouter, useRouterEvents, useRouterState, useSchema, useStore };
+export { $page, AlephaContext, AlephaReact, AnchorProps, ClientOnly, CreateLayersResult, ErrorBoundary, ErrorHandler, ErrorViewer, Layer, Link, LinkProps, _default as NestedView, NotFoundPage as NotFound, PageAnimation, PageConfigSchema, PageDescriptor, PageDescriptorOptions, PageDescriptorRenderOptions, PageDescriptorRenderResult, PageRequestConfig, PageResolve, PageRoute, PageRouteEntry, PreviousLayerData, ReactBrowserProvider, ReactBrowserRendererOptions, ReactHydrationState, ReactPageProvider, ReactRouter, ReactRouterState, ReactServerProvider, Redirection, RouterGoOptions, RouterLayerContext, RouterLayerContextValue, RouterRenderOptions, RouterStackItem, TPropsDefault, TPropsParentDefault, TransitionOptions, UseActiveHook, UseActiveOptions, UseQueryParamsHookOptions, UseSchemaReturn, VirtualRouter, isPageRoute, ssrSchemaLoading, useActive, useAlepha, useClient, useInject, useQueryParams, useRouter, useRouterEvents, useRouterState, useSchema, useStore };
 //# sourceMappingURL=index.d.ts.map