@alepha/react 0.7.5 → 0.7.7

package/dist/index.d.ts

@@ -1,87 +1,26 @@
-import * as _alepha_core from '@alepha/core';
-import { TSchema as TSchema$1, KIND, OPTIONS, Static, Async, Alepha, Service, TObject, Module } from '@alepha/core';
-import { ServerRequest, ApiLinksResponse, HttpClient, ClientScope, HttpVirtualClient, ServerRouterProvider, ServerTimingProvider, ServerHandler } from '@alepha/server';
-import * as React from 'react';
-import React__default, { PropsWithChildren, ReactNode, FC, ErrorInfo, AnchorHTMLAttributes } from 'react';
-import { ServerRouteCache } from '@alepha/server-cache';
-import { Root } from 'react-dom/client';
-import { RouterProvider, Route } from '@alepha/router';
-import * as react_jsx_runtime from 'react/jsx-runtime';
-import { ServerStaticProvider } from '@alepha/server-static';
-
-/** Symbol key applied to readonly types */
-declare const ReadonlyKind: unique symbol;
-/** Symbol key applied to optional types */
-declare const OptionalKind: unique symbol;
-/** Symbol key applied to types */
-declare const Hint: unique symbol;
-/** Symbol key applied to types */
-declare const Kind: unique symbol;
-
-type StringFormatOption = 'date-time' | 'time' | 'date' | 'email' | 'idn-email' | 'hostname' | 'idn-hostname' | 'ipv4' | 'ipv6' | 'uri' | 'uri-reference' | 'iri' | 'uuid' | 'iri-reference' | 'uri-template' | 'json-pointer' | 'relative-json-pointer' | 'regex' | ({} & string);
-type StringContentEncodingOption = '7bit' | '8bit' | 'binary' | 'quoted-printable' | 'base64' | ({} & string);
-interface StringOptions extends SchemaOptions {
-    /** The maximum string length */
-    maxLength?: number;
-    /** The minimum string length */
-    minLength?: number;
-    /** A regular expression pattern this string should match */
-    pattern?: string;
-    /** A format this string should match */
-    format?: StringFormatOption;
-    /** The content encoding for this string */
-    contentEncoding?: StringContentEncodingOption;
-    /** The content media type for this string */
-    contentMediaType?: string;
-}
-interface TString extends TSchema, StringOptions {
-    [Kind]: 'String';
-    static: string;
-    type: 'string';
-}
-
-interface TBoolean extends TSchema {
-    [Kind]: 'Boolean';
-    static: boolean;
-    type: 'boolean';
-}
-
-type TOptional<T extends TSchema> = T & {
-    [OptionalKind]: 'Optional';
-};
-
-interface SchemaOptions {
-    $schema?: string;
-    /** Id for this schema */
-    $id?: string;
-    /** Title of this schema */
-    title?: string;
-    /** Description of this schema */
-    description?: string;
-    /** Default value for this schema */
-    default?: any;
-    /** Example values matching this schema */
-    examples?: any;
-    /** Optional annotation for readOnly */
-    readOnly?: boolean;
-    /** Optional annotation for writeOnly */
-    writeOnly?: boolean;
-    [prop: string]: any;
-}
-interface TKind {
-    [Kind]: string;
-}
-interface TSchema extends TKind, SchemaOptions {
-    [ReadonlyKind]?: string;
-    [OptionalKind]?: string;
-    [Hint]?: string;
-    params: unknown[];
-    static: unknown;
-}
+import * as _alepha_core12 from "@alepha/core";
+import * as _alepha_core23 from "@alepha/core";
+import * as _alepha_core16 from "@alepha/core";
+import * as _alepha_core6 from "@alepha/core";
+import { Alepha, Async, KIND, Module, OPTIONS, Service, Static, TObject, TSchema } from "@alepha/core";
+import { ApiLinksResponse, ServerHandler, ServerRequest, ServerRouterProvider, ServerTimingProvider } from "@alepha/server";
+import { ServerRouteCache } from "@alepha/server-cache";
+import * as react19 from "react";
+import * as react20 from "react";
+import React, { AnchorHTMLAttributes, ErrorInfo, FC, PropsWithChildren, ReactNode } from "react";
+import * as react_jsx_runtime22 from "react/jsx-runtime";
+import * as react_jsx_runtime21 from "react/jsx-runtime";
+import { ClientScope, HttpVirtualClient, LinkProvider } from "@alepha/server-links";
+import { ServerStaticProvider } from "@alepha/server-static";
+import { Route, RouterProvider } from "@alepha/router";
+import * as _sinclair_typebox11 from "@sinclair/typebox";
+import * as _sinclair_typebox1 from "@sinclair/typebox";
+import { Root } from "react-dom/client";
 
+//#region src/components/ClientOnly.d.ts
 interface ClientOnlyProps {
-    fallback?: ReactNode;
-    disabled?: boolean;
+  fallback?: ReactNode;
+  disabled?: boolean;
 }
 /**
  * A small utility component that renders its children only on the client side.
@@ -94,397 +33,343 @@ interface ClientOnlyProps {
  * - you want to prevent pre-rendering of a component
  */
 declare const ClientOnly: (props: PropsWithChildren<ClientOnlyProps>) => ReactNode;
-
+//#endregion
+//#region src/descriptors/$page.d.ts
 declare const KEY = "PAGE";
 interface PageConfigSchema {
-    query?: TSchema$1;
-    params?: TSchema$1;
+  query?: TSchema;
+  params?: TSchema;
 }
 type TPropsDefault = any;
 type TPropsParentDefault = {};
 interface PageDescriptorOptions<TConfig extends PageConfigSchema = PageConfigSchema, TProps extends object = TPropsDefault, TPropsParent extends object = TPropsParentDefault> {
-    /**
-     * Name your page.
-     *
-     * @default Descriptor key
-     */
-    name?: string;
-    /**
-     * Optional description of the page.
-     */
-    description?: string;
-    /**
-     * Add a pathname to the page.
-     *
-     * Pathname can contain parameters, like `/post/:slug`.
-     *
-     * @default ""
-     */
-    path?: string;
-    /**
-     * Add an input schema to define:
-     * - `params`: parameters from the pathname.
-     * - `query`: query parameters from the URL.
-     */
-    schema?: TConfig;
-    /**
-     * Load data before rendering the page.
-     *
-     * This function receives
-     * - the request context and
-     * - the parent props (if page has a parent)
-     *
-     * In SSR, the returned data will be serialized and sent to the client, then reused during the client-side hydration.
-     *
-     * Resolve can be stopped by throwing an error, which will be handled by the `errorHandler` function.
-     * It's common to throw a `NotFoundError` to display a 404 page.
-     *
-     * RedirectError can be thrown to redirect the user to another page.
-     */
-    resolve?: (context: PageResolve<TConfig, TPropsParent>) => Async<TProps>;
-    /**
-     * The component to render when the page is loaded.
-     *
-     * If `lazy` is defined, this will be ignored.
-     * Prefer using `lazy` to improve the initial loading time.
-     */
-    component?: FC<TProps & TPropsParent>;
-    /**
-     * Lazy load the component when the page is loaded.
-     *
-     * It's recommended to use this for components to improve the initial loading time
-     * and enable code-splitting.
-     */
-    lazy?: () => Promise<{
-        default: FC<TProps & TPropsParent>;
-    }>;
-    /**
-     * Set some children pages and make the page a parent page.
-     *
-     * /!\ Parent page can't be rendered directly. /!\
-     *
-     * If you still want to render at this pathname, add a child page with an empty path.
-     */
-    children?: Array<{
-        [OPTIONS]: PageDescriptorOptions;
-    }>;
-    parent?: {
-        [OPTIONS]: PageDescriptorOptions<PageConfigSchema, TPropsParent>;
-    };
-    can?: () => boolean;
-    head?: Head$1 | ((props: TProps, previous?: Head$1) => Head$1);
-    errorHandler?: (error: Error) => ReactNode;
-    prerender?: boolean | {
-        entries?: Array<Partial<PageRequestConfig<TConfig>>>;
-    };
-    /**
-     * If true, the page will be rendered on the client-side.
-     */
-    client?: boolean | ClientOnlyProps;
-    afterHandler?: (request: ServerRequest) => any;
-    cache?: ServerRouteCache;
+  /**
+   * Name your page.
+   *
+   * @default Descriptor key
+   */
+  name?: string;
+  /**
+   * Optional description of the page.
+   */
+  description?: string;
+  /**
+   * Add a pathname to the page.
+   *
+   * Pathname can contain parameters, like `/post/:slug`.
+   *
+   * @default ""
+   */
+  path?: string;
+  /**
+   * Add an input schema to define:
+   * - `params`: parameters from the pathname.
+   * - `query`: query parameters from the URL.
+   */
+  schema?: TConfig;
+  /**
+   * Load data before rendering the page.
+   *
+   * This function receives
+   * - the request context and
+   * - the parent props (if page has a parent)
+   *
+   * In SSR, the returned data will be serialized and sent to the client, then reused during the client-side hydration.
+   *
+   * Resolve can be stopped by throwing an error, which will be handled by the `errorHandler` function.
+   * It's common to throw a `NotFoundError` to display a 404 page.
+   *
+   * RedirectError can be thrown to redirect the user to another page.
+   */
+  resolve?: (context: PageResolve<TConfig, TPropsParent>) => Async<TProps>;
+  /**
+   * The component to render when the page is loaded.
+   *
+   * If `lazy` is defined, this will be ignored.
+   * Prefer using `lazy` to improve the initial loading time.
+   */
+  component?: FC<TProps & TPropsParent>;
+  /**
+   * Lazy load the component when the page is loaded.
+   *
+   * It's recommended to use this for components to improve the initial loading time
+   * and enable code-splitting.
+   */
+  lazy?: () => Promise<{
+    default: FC<TProps & TPropsParent>;
+  }>;
+  /**
+   * Set some children pages and make the page a parent page.
+   *
+   * /!\ Parent page can't be rendered directly. /!\
+   *
+   * If you still want to render at this pathname, add a child page with an empty path.
+   */
+  children?: Array<{
+    [OPTIONS]: PageDescriptorOptions;
+  }>;
+  parent?: {
+    [OPTIONS]: PageDescriptorOptions<PageConfigSchema, TPropsParent>;
+  };
+  can?: () => boolean;
+  errorHandler?: (error: Error) => ReactNode;
+  prerender?: boolean | {
+    entries?: Array<Partial<PageRequestConfig<TConfig>>>;
+  };
+  /**
+   * If true, the page will be rendered on the client-side.
+   */
+  client?: boolean | ClientOnlyProps;
+  afterHandler?: (request: ServerRequest) => any;
+  cache?: ServerRouteCache;
 }
 interface PageDescriptor<TConfig extends PageConfigSchema = PageConfigSchema, TProps extends object = TPropsDefault, TPropsParent extends object = TPropsParentDefault> {
-    [KIND]: typeof KEY;
-    [OPTIONS]: PageDescriptorOptions<TConfig, TProps, TPropsParent>;
-    /**
-     * For testing or build purposes, this will render the page (with or without the HTML layout) and return the HTML and context.
-     * Only valid for server-side rendering, it will throw an error if called on the client-side.
-     */
-    render: (options?: PageDescriptorRenderOptions) => Promise<PageDescriptorRenderResult>;
+  [KIND]: typeof KEY;
+  [OPTIONS]: PageDescriptorOptions<TConfig, TProps, TPropsParent>;
+  /**
+   * For testing or build purposes, this will render the page (with or without the HTML layout) and return the HTML and context.
+   * Only valid for server-side rendering, it will throw an error if called on the client-side.
+   */
+  render: (options?: PageDescriptorRenderOptions) => Promise<PageDescriptorRenderResult>;
 }
 /**
  * Main descriptor for defining a React route in the application.
  */
 declare const $page: {
-    <TConfig extends PageConfigSchema = PageConfigSchema, TProps extends object = any, TPropsParent extends object = TPropsParentDefault>(options: PageDescriptorOptions<TConfig, TProps, TPropsParent>): PageDescriptor<TConfig, TProps, TPropsParent>;
-    [KIND]: string;
+  <TConfig extends PageConfigSchema = PageConfigSchema, TProps extends object = any, TPropsParent extends object = TPropsParentDefault>(options: PageDescriptorOptions<TConfig, TProps, TPropsParent>): PageDescriptor<TConfig, TProps, TPropsParent>;
+  [KIND]: string;
 };
 interface PageDescriptorRenderOptions {
-    params?: Record<string, string>;
-    query?: Record<string, string>;
-    withLayout?: boolean;
+  params?: Record<string, string>;
+  query?: Record<string, string>;
+  html?: boolean;
+  hydration?: boolean;
 }
 interface PageDescriptorRenderResult {
-    html: string;
-    context: PageReactContext;
-}
-interface Head$1 {
-    title?: string;
-    description?: string;
-    titleSeparator?: string;
-    htmlAttributes?: Record<string, string>;
-    bodyAttributes?: Record<string, string>;
-    meta?: Array<{
-        name: string;
-        content: string;
-    }>;
-    keywords?: string[];
-    author?: string;
-    robots?: string;
-    themeColor?: string;
-    viewport?: string | {
-        width?: string;
-        height?: string;
-        initialScale?: string;
-        maximumScale?: string;
-        userScalable?: "no" | "yes" | "0" | "1";
-        interactiveWidget?: "resizes-visual" | "resizes-content" | "overlays-content";
-    };
-    og?: {
-        title?: string;
-        description?: string;
-        image?: string;
-        url?: string;
-        type?: string;
-    };
-    twitter?: {
-        card?: string;
-        title?: string;
-        description?: string;
-        image?: string;
-        site?: string;
-    };
+  html: string;
+  context: PageReactContext;
 }
 interface PageRequestConfig<TConfig extends PageConfigSchema = PageConfigSchema> {
-    params: TConfig["params"] extends TSchema$1 ? Static<TConfig["params"]> : Record<string, string>;
-    query: TConfig["query"] extends TSchema$1 ? Static<TConfig["query"]> : Record<string, string>;
+  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;
-
-declare const envSchema$1: _alepha_core.TObject<{
-    REACT_STRICT_MODE: TBoolean;
+//#endregion
+//#region src/providers/PageDescriptorProvider.d.ts
+declare const envSchema$1: _alepha_core12.TObject<{
+  REACT_STRICT_MODE: _sinclair_typebox11.TBoolean;
 }>;
 declare module "@alepha/core" {
-    interface Env extends Partial<Static<typeof envSchema$1>> {
-    }
+  interface Env extends Partial<Static<typeof envSchema$1>> {}
 }
 declare class PageDescriptorProvider {
-    protected readonly log: _alepha_core.Logger;
-    protected readonly env: {
-        REACT_STRICT_MODE: boolean;
+  protected readonly log: _alepha_core12.Logger;
+  protected readonly env: {
+    REACT_STRICT_MODE: boolean;
+  };
+  protected readonly alepha: Alepha;
+  protected readonly pages: PageRoute[];
+  getPages(): PageRoute[];
+  page(name: string): PageRoute;
+  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 getErrorHandler(route: PageRoute): ((error: Error) => ReactNode) | undefined;
+  protected createElement(page: PageRoute, props: Record<string, any>): Promise<ReactNode>;
+  renderError(error: Error): ReactNode;
+  renderEmptyView(): ReactNode;
+  href(page: {
+    options: {
+      name?: string;
     };
-    protected readonly alepha: Alepha;
-    protected readonly pages: PageRoute[];
-    getPages(): PageRoute[];
-    page(name: string): PageRoute;
-    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 getErrorHandler(route: PageRoute): ((error: Error) => ReactNode) | undefined;
-    protected createElement(page: PageRoute, props: Record<string, any>): Promise<ReactNode>;
-    protected fillHead(page: PageRoute, ctx: PageRequest, props: Record<string, any>): void;
-    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_core.HookDescriptor<"configure">;
-    protected map(pages: Array<{
-        value: {
-            [OPTIONS]: PageDescriptorOptions;
-        };
-    }>, target: {
-        [OPTIONS]: PageDescriptorOptions;
-    }): PageRouteEntry;
-    add(entry: PageRouteEntry): void;
-    protected createMatch(page: PageRoute): string;
-    protected _next: number;
-    protected nextId(): 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_core12.HookDescriptor<"configure">;
+  protected map(pages: Array<{
+    value: {
+      [OPTIONS]: PageDescriptorOptions;
+    };
+  }>, target: {
+    [OPTIONS]: PageDescriptorOptions;
+  }): 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[];
+  children?: PageRouteEntry[];
 }
 interface PageRoute extends PageRouteEntry {
-    type: "page";
-    name: string;
-    parent?: PageRoute;
-    match: string;
+  type: "page";
+  name: string;
+  parent?: PageRoute;
+  match: string;
 }
 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;
+  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;
 }
 type PreviousLayerData = Omit<Layer, "element" | "index" | "path">;
 interface AnchorProps {
-    href: string;
-    onClick: (ev: any) => any;
+  href: string;
+  onClick: (ev: any) => any;
 }
 interface RouterState {
-    pathname: string;
-    search: string;
-    layers: Array<Layer>;
+  pathname: string;
+  search: string;
+  layers: Array<Layer>;
 }
 interface TransitionOptions {
-    state?: RouterState;
-    previous?: PreviousLayerData[];
-    context?: PageReactContext;
+  state?: RouterState;
+  previous?: PreviousLayerData[];
+  context?: PageReactContext;
 }
 interface RouterStackItem {
-    route: PageRoute;
-    config?: Record<string, any>;
-    props?: Record<string, any>;
-    error?: Error;
+  route: PageRoute;
+  config?: Record<string, any>;
+  props?: Record<string, any>;
+  error?: Error;
 }
 interface RouterRenderResult {
-    state: RouterState;
-    context: PageReactContext;
-    redirect?: string;
+  state: RouterState;
+  context: PageReactContext;
+  redirect?: string;
 }
 interface PageRequest extends PageReactContext {
-    params: Record<string, any>;
-    query: Record<string, string>;
-    previous?: PreviousLayerData[];
+  params: Record<string, any>;
+  query: Record<string, string>;
+  previous?: PreviousLayerData[];
 }
 interface CreateLayersResult extends RouterState {
-    redirect?: string;
+  redirect?: string;
 }
 /**
  * It's like RouterState, but publicly available in React context.
  * This is where we store all plugin data!
  */
 interface PageReactContext {
-    url: URL;
-    head: Head$1;
-    onError: (error: Error) => ReactNode;
-    links?: ApiLinksResponse;
-}
-
-interface Head {
-    title?: string;
-    htmlAttributes?: Record<string, string>;
-    bodyAttributes?: Record<string, string>;
-    meta?: Array<{
-        name: string;
-        content: string;
-    }>;
-}
-declare class ServerHeadProvider {
-    renderHead(template: string, head: Head): string;
-    mergeAttributes(existing: string, attrs: Record<string, string>): string;
-    parseAttributes(attrStr: string): Record<string, string>;
-    escapeHtml(str: string): string;
-}
-
-declare class BrowserHeadProvider {
-    renderHead(document: Document, head: Head): void;
+  url: URL;
+  onError: (error: Error) => ReactNode;
+  links?: ApiLinksResponse;
 }
-
+//#endregion
+//#region src/providers/BrowserRouterProvider.d.ts
 interface BrowserRoute extends Route {
-    page: PageRoute;
+  page: PageRoute;
 }
 declare class BrowserRouterProvider extends RouterProvider<BrowserRoute> {
-    protected readonly log: _alepha_core.Logger;
-    protected readonly alepha: Alepha;
-    protected readonly pageDescriptorProvider: PageDescriptorProvider;
-    add(entry: PageRouteEntry): void;
-    protected readonly configure: _alepha_core.HookDescriptor<"configure">;
-    transition(url: URL, options?: TransitionOptions): Promise<RouterRenderResult>;
-    root(state: RouterState, context: PageReactContext): ReactNode;
-}
-
+  protected readonly log: _alepha_core23.Logger;
+  protected readonly alepha: Alepha;
+  protected readonly pageDescriptorProvider: PageDescriptorProvider;
+  add(entry: PageRouteEntry): void;
+  protected readonly configure: _alepha_core23.HookDescriptor<"configure">;
+  transition(url: URL, options?: TransitionOptions): Promise<RouterRenderResult>;
+  root(state: RouterState, context: PageReactContext): ReactNode;
+}
+//#endregion
+//#region src/providers/ReactBrowserProvider.d.ts
 declare class ReactBrowserProvider {
-    protected readonly log: _alepha_core.Logger;
-    protected readonly client: HttpClient;
-    protected readonly alepha: Alepha;
-    protected readonly router: BrowserRouterProvider;
-    protected readonly headProvider: BrowserHeadProvider;
-    protected root: Root;
-    transitioning?: {
-        to: string;
-    };
-    state: RouterState;
-    get document(): Document;
-    get history(): History;
-    get url(): string;
-    invalidate(props?: Record<string, any>): Promise<void>;
-    go(url: string, options?: RouterGoOptions): Promise<void>;
-    protected render(options?: {
-        url?: string;
-        previous?: PreviousLayerData[];
-    }): Promise<RouterRenderResult>;
-    /**
-     * Get embedded layers from the server.
-     */
-    protected getHydrationState(): ReactHydrationState | undefined;
-    readonly ready: _alepha_core.HookDescriptor<"ready">;
-    readonly onTransitionEnd: _alepha_core.HookDescriptor<"react:transition:end">;
+  protected readonly log: _alepha_core16.Logger;
+  protected readonly client: LinkProvider;
+  protected readonly alepha: Alepha;
+  protected readonly router: BrowserRouterProvider;
+  protected root: Root;
+  transitioning?: {
+    to: string;
+  };
+  state: RouterState;
+  get document(): Document;
+  get history(): History;
+  get url(): string;
+  invalidate(props?: Record<string, any>): Promise<void>;
+  go(url: string, options?: RouterGoOptions): Promise<void>;
+  protected render(options?: {
+    url?: string;
+    previous?: PreviousLayerData[];
+  }): Promise<RouterRenderResult>;
+  /**
+   * Get embedded layers from the server.
+   */
+  protected getHydrationState(): ReactHydrationState | undefined;
+  readonly ready: _alepha_core16.HookDescriptor<"ready">;
 }
 interface RouterGoOptions {
-    replace?: boolean;
-    match?: TransitionOptions;
-    params?: Record<string, string>;
+  replace?: boolean;
+  match?: TransitionOptions;
+  params?: Record<string, string>;
 }
 interface ReactHydrationState {
-    layers?: Array<PreviousLayerData>;
-    links?: ApiLinksResponse;
+  layers?: Array<PreviousLayerData>;
+  links?: ApiLinksResponse;
 }
-
+//#endregion
+//#region src/components/ErrorBoundary.d.ts
 /**
  * Props for the ErrorBoundary component.
  */
 interface ErrorBoundaryProps {
-    /**
-     * Fallback React node to render when an error is caught.
-     * If not provided, a default error message will be shown.
-     */
-    fallback: (error: Error) => ReactNode;
-    /**
-     * Optional callback that receives the error and error info.
-     * Use this to log errors to a monitoring service.
-     */
-    onError?: (error: Error, info: ErrorInfo) => void;
+  /**
+   * Fallback React node to render when an error is caught.
+   * If not provided, a default error message will be shown.
+   */
+  fallback: (error: Error) => ReactNode;
+  /**
+   * Optional callback that receives the error and error info.
+   * Use this to log errors to a monitoring service.
+   */
+  onError?: (error: Error, info: ErrorInfo) => void;
 }
 /**
  * State of the ErrorBoundary component.
  */
 interface ErrorBoundaryState {
-    error?: Error;
+  error?: Error;
 }
 /**
  * A reusable error boundary for catching rendering errors
  * in any part of the React component tree.
  */
-declare class ErrorBoundary extends React__default.Component<PropsWithChildren<ErrorBoundaryProps>, ErrorBoundaryState> {
-    constructor(props: ErrorBoundaryProps);
-    /**
-     * Update state so the next render shows the fallback UI.
-     */
-    static getDerivedStateFromError(error: Error): ErrorBoundaryState;
-    /**
-     * Lifecycle method called when an error is caught.
-     * You can log the error or perform side effects here.
-     */
-    componentDidCatch(error: Error, info: ErrorInfo): void;
-    render(): ReactNode;
-}
-
+declare class ErrorBoundary extends React.Component<PropsWithChildren<ErrorBoundaryProps>, ErrorBoundaryState> {
+  constructor(props: ErrorBoundaryProps);
+  /**
+   * Update state so the next render shows the fallback UI.
+   */
+  static getDerivedStateFromError(error: Error): ErrorBoundaryState;
+  /**
+   * Lifecycle method called when an error is caught.
+   * You can log the error or perform side effects here.
+   */
+  componentDidCatch(error: Error, info: ErrorInfo): void;
+  render(): ReactNode;
+}
+//#endregion
+//#region src/components/Link.d.ts
 interface LinkProps extends AnchorHTMLAttributes<HTMLAnchorElement> {
-    to: string | PageDescriptor;
-    children?: React__default.ReactNode;
+  to: string | PageDescriptor;
+  children?: React.ReactNode;
 }
-declare const Link: (props: LinkProps) => react_jsx_runtime.JSX.Element | null;
-
+declare const Link: (props: LinkProps) => react_jsx_runtime22.JSX.Element | null;
+//#endregion
+//#region src/components/NestedView.d.ts
 interface NestedViewProps {
-    children?: ReactNode;
+  children?: ReactNode;
 }
 /**
  * A component that renders the current view of the nested router layer.
@@ -507,201 +392,224 @@ interface NestedViewProps {
  * }
  * ```
  */
-declare const NestedView: (props: NestedViewProps) => react_jsx_runtime.JSX.Element;
-
+declare const NestedView: (props: NestedViewProps) => react_jsx_runtime21.JSX.Element;
+//#endregion
+//#region src/contexts/RouterContext.d.ts
 interface RouterContextValue {
-    alepha: Alepha;
-    state: RouterState;
-    context: PageReactContext;
+  alepha: Alepha;
+  state: RouterState;
+  context: PageReactContext;
 }
-declare const RouterContext: React.Context<RouterContextValue | undefined>;
-
+declare const RouterContext: react19.Context<RouterContextValue | undefined>;
+//#endregion
+//#region src/contexts/RouterLayerContext.d.ts
 interface RouterLayerContextValue {
-    index: number;
-    path: string;
+  index: number;
+  path: string;
 }
-declare const RouterLayerContext: React.Context<RouterLayerContextValue | undefined>;
-
+declare const RouterLayerContext: react20.Context<RouterLayerContextValue | undefined>;
+//#endregion
+//#region src/hooks/RouterHookApi.d.ts
 declare class RouterHookApi {
-    private readonly pages;
-    private readonly state;
-    private readonly layer;
-    private readonly browser?;
-    constructor(pages: PageRoute[], state: RouterState, layer: {
-        path: string;
-    }, browser?: ReactBrowserProvider | undefined);
-    get current(): RouterState;
-    get pathname(): string;
-    get query(): Record<string, string>;
-    back(): Promise<void>;
-    forward(): Promise<void>;
-    invalidate(props?: Record<string, any>): Promise<void>;
-    /**
-     * Create a valid href for the given pathname.
-     *
-     * @param pathname
-     * @param layer
-     */
-    createHref(pathname: HrefLike, layer?: {
-        path: string;
-    }, options?: {
-        params?: Record<string, any>;
-    }): string;
-    go(path: string, options?: RouterGoOptions): Promise<void>;
-    go<T extends object>(path: keyof VirtualRouter<T>, options?: RouterGoOptions): Promise<void>;
-    anchor(path: string, options?: {
-        params?: Record<string, any>;
-    }): AnchorProps;
-    anchor<T extends object>(path: keyof VirtualRouter<T>, options?: {
-        params?: Record<string, any>;
-    }): AnchorProps;
+  private readonly pages;
+  private readonly state;
+  private readonly layer;
+  private readonly browser?;
+  constructor(pages: PageRoute[], state: RouterState, layer: {
+    path: string;
+  }, browser?: ReactBrowserProvider | undefined);
+  get current(): RouterState;
+  get pathname(): string;
+  get query(): Record<string, string>;
+  back(): Promise<void>;
+  forward(): Promise<void>;
+  invalidate(props?: Record<string, any>): Promise<void>;
+  /**
+   * Create a valid href for the given pathname.
+   *
+   * @param pathname
+   * @param layer
+   */
+  createHref(pathname: HrefLike, layer?: {
+    path: string;
+  }, options?: {
+    params?: Record<string, any>;
+  }): string;
+  go(path: string, options?: RouterGoOptions): Promise<void>;
+  go<T extends object>(path: keyof VirtualRouter<T>, options?: RouterGoOptions): Promise<void>;
+  anchor(path: string, options?: {
+    params?: Record<string, any>;
+  }): AnchorProps;
+  anchor<T extends object>(path: keyof VirtualRouter<T>, options?: {
+    params?: Record<string, any>;
+  }): AnchorProps;
+  /**
+   * Set query params.
+   *
+   * @param record
+   * @param options
+   */
+  setQueryParams(record: Record<string, any> | ((queryParams: Record<string, any>) => Record<string, any>), options?: {
     /**
-     * Set query params.
-     *
-     * @param record
-     * @param options
+     * If true, this will add a new entry to the history stack.
      */
-    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;
+    push?: boolean;
+  }): void;
 }
 type HrefLike = string | {
-    options: {
-        path?: string;
-        name?: string;
-    };
-};
-type VirtualRouter<T> = {
-    [K in keyof T as T[K] extends PageDescriptor ? K : never]: T[K];
+  options: {
+    path?: string;
+    name?: string;
+  };
 };
-
+type VirtualRouter<T> = { [K in keyof T as T[K] extends PageDescriptor ? K : never]: T[K] };
+//#endregion
+//#region src/errors/RedirectionError.d.ts
 declare class RedirectionError extends Error {
-    readonly page: HrefLike;
-    constructor(page: HrefLike);
+  readonly page: HrefLike;
+  constructor(page: HrefLike);
 }
-
+//#endregion
+//#region src/hooks/useActive.d.ts
 declare const useActive: (path: HrefLike) => UseActiveHook;
 interface UseActiveHook {
-    isActive: boolean;
-    anchorProps: AnchorProps;
-    isPending: boolean;
-    name?: string;
+  isActive: boolean;
+  anchorProps: AnchorProps;
+  isPending: boolean;
+  name?: string;
 }
-
+//#endregion
+//#region src/hooks/useAlepha.d.ts
 declare const useAlepha: () => Alepha;
-
+//#endregion
+//#region src/hooks/useClient.d.ts
 declare const useClient: <T extends object>(_scope?: ClientScope) => HttpVirtualClient<T>;
-
+//#endregion
+//#region src/hooks/useInject.d.ts
 declare const useInject: <T extends object>(clazz: Service<T>) => T;
-
+//#endregion
+//#region src/hooks/useQueryParams.d.ts
 interface UseQueryParamsHookOptions {
-    format?: "base64" | "querystring";
-    key?: string;
-    push?: boolean;
+  format?: "base64" | "querystring";
+  key?: string;
+  push?: boolean;
 }
 declare const useQueryParams: <T extends TObject>(schema: T, options?: UseQueryParamsHookOptions) => [Static<T>, (data: Static<T>) => void];
-
+//#endregion
+//#region src/hooks/useRouter.d.ts
 declare const useRouter: () => RouterHookApi;
-
+//#endregion
+//#region src/hooks/useRouterEvents.d.ts
 declare const useRouterEvents: (opts?: {
-    onBegin?: (ev: {
-        state: RouterState;
-    }) => void;
-    onEnd?: (ev: {
-        state: RouterState;
-    }) => void;
-    onError?: (ev: {
-        state: RouterState;
-        error: Error;
-    }) => void;
+  onBegin?: (ev: {
+    state: RouterState;
+  }) => void;
+  onEnd?: (ev: {
+    state: RouterState;
+  }) => void;
+  onError?: (ev: {
+    state: RouterState;
+    error: Error;
+  }) => void;
 }, deps?: any[]) => void;
-
+//#endregion
+//#region src/hooks/useRouterState.d.ts
 declare const useRouterState: () => RouterState;
-
-declare const envSchema: _alepha_core.TObject<{
-    REACT_SERVER_DIST: TString;
-    REACT_SERVER_PREFIX: TString;
-    REACT_SSR_ENABLED: TOptional<TBoolean>;
-    REACT_ROOT_ID: TString;
+//#endregion
+//#region src/providers/ReactServerProvider.d.ts
+declare const envSchema: _alepha_core6.TObject<{
+  REACT_SERVER_DIST: _sinclair_typebox1.TString;
+  REACT_SERVER_PREFIX: _sinclair_typebox1.TString;
+  REACT_SSR_ENABLED: _sinclair_typebox1.TOptional<_sinclair_typebox1.TBoolean>;
+  REACT_ROOT_ID: _sinclair_typebox1.TString;
 }>;
 declare module "@alepha/core" {
-    interface Env extends Partial<Static<typeof envSchema>> {
-    }
-    interface State {
-        "ReactServerProvider.template"?: string;
-        "ReactServerProvider.ssr"?: boolean;
-    }
+  interface Env extends Partial<Static<typeof envSchema>> {}
+  interface State {
+    "ReactServerProvider.template"?: string;
+    "ReactServerProvider.ssr"?: boolean;
+  }
 }
 declare class ReactServerProvider {
-    protected readonly log: _alepha_core.Logger;
-    protected readonly alepha: Alepha;
-    protected readonly pageDescriptorProvider: PageDescriptorProvider;
-    protected readonly serverStaticProvider: ServerStaticProvider;
-    protected readonly serverRouterProvider: ServerRouterProvider;
-    protected readonly headProvider: ServerHeadProvider;
-    protected readonly serverTimingProvider: ServerTimingProvider;
-    protected readonly env: {
-        REACT_SSR_ENABLED?: boolean | undefined;
-        REACT_SERVER_DIST: string;
-        REACT_SERVER_PREFIX: string;
-        REACT_ROOT_ID: string;
-    };
-    protected readonly ROOT_DIV_REGEX: RegExp;
-    readonly onConfigure: _alepha_core.HookDescriptor<"configure">;
-    get template(): string | undefined;
-    protected registerPages(templateLoader: TemplateLoader): Promise<void>;
-    protected getPublicDirectory(): string;
-    protected configureStaticServer(root: string): Promise<void>;
-    protected configureVite(ssrEnabled: boolean): Promise<void>;
-    /**
-     * For testing purposes, creates a render function that can be used.
-     */
-    protected createRenderFunction(name: string, withIndex?: boolean): (options?: {
-        params?: Record<string, string>;
-        query?: Record<string, string>;
-    }) => Promise<{
-        context: PageRequest;
-        html: string;
-    }>;
-    protected createHandler(page: PageRoute, templateLoader: TemplateLoader): ServerHandler;
-    renderToHtml(template: string, state: RouterState, context: PageReactContext): string;
-    protected fillTemplate(response: {
-        html: string;
-    }, app: string, script: string): void;
+  protected readonly log: _alepha_core6.Logger;
+  protected readonly alepha: Alepha;
+  protected readonly pageDescriptorProvider: PageDescriptorProvider;
+  protected readonly serverStaticProvider: ServerStaticProvider;
+  protected readonly serverRouterProvider: ServerRouterProvider;
+  protected readonly serverTimingProvider: ServerTimingProvider;
+  protected readonly env: {
+    REACT_SSR_ENABLED?: boolean | undefined;
+    REACT_SERVER_DIST: string;
+    REACT_SERVER_PREFIX: string;
+    REACT_ROOT_ID: string;
+  };
+  protected readonly ROOT_DIV_REGEX: RegExp;
+  readonly onConfigure: _alepha_core6.HookDescriptor<"configure">;
+  get template(): string;
+  protected registerPages(templateLoader: TemplateLoader): Promise<void>;
+  protected getPublicDirectory(): string;
+  protected configureStaticServer(root: string): Promise<void>;
+  protected configureVite(ssrEnabled: boolean): Promise<void>;
+  /**
+   * 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;
+  protected fillTemplate(response: {
+    html: string;
+  }, app: string, script: string): void;
 }
 type TemplateLoader = () => Promise<string | undefined>;
-
+//#endregion
+//#region src/index.d.ts
 declare module "@alepha/core" {
-    interface Hooks {
-        "react:browser:render": {
-            state: RouterState;
-            context: PageReactContext;
-            hydration?: ReactHydrationState;
-        };
-        "react:server:render": {
-            request: ServerRequest;
-            pageRequest: PageRequest;
-        };
-        "react:transition:begin": {
-            state: RouterState;
-            context: PageReactContext;
-        };
-        "react:transition:success": {
-            state: RouterState;
-        };
-        "react:transition:error": {
-            error: Error;
-            state: RouterState;
-            context: PageReactContext;
-        };
-        "react:transition:end": {
-            state: RouterState;
-            context: PageReactContext;
-        };
-    }
+  interface Hooks {
+    "react:router:createLayers": {
+      request: ServerRequest;
+      context: PageRequest;
+      layers: PageRequest[];
+    };
+    "react:server:render:begin": {
+      request?: ServerRequest;
+      context: PageRequest;
+    };
+    "react:server:render:end": {
+      request?: ServerRequest;
+      context: PageRequest;
+      state: RouterState;
+      html: string;
+    };
+    "react:browser:render": {
+      state: RouterState;
+      context: PageReactContext;
+      hydration?: ReactHydrationState;
+    };
+    "react:transition:begin": {
+      state: RouterState;
+      context: PageReactContext;
+    };
+    "react:transition:success": {
+      state: RouterState;
+      context: PageReactContext;
+    };
+    "react:transition:error": {
+      error: Error;
+      state: RouterState;
+      context: PageReactContext;
+    };
+    "react:transition:end": {
+      state: RouterState;
+      context: PageReactContext;
+    };
+  }
 }
 /**
  * Alepha React Module
@@ -713,8 +621,9 @@ declare module "@alepha/core" {
  * @module alepha.react
  */
 declare class AlephaReact implements Module {
-    readonly name = "alepha.react";
-    readonly $services: (alepha: Alepha) => Alepha;
+  readonly name = "alepha.react";
+  readonly $services: (alepha: Alepha) => Alepha;
 }
-
-export { $page, AlephaReact, type AnchorProps, ClientOnly, type CreateLayersResult, ErrorBoundary, type Head$1 as Head, type HrefLike, type Layer, Link, NestedView, type PageConfigSchema, type PageDescriptor, type PageDescriptorOptions, PageDescriptorProvider, type PageDescriptorRenderOptions, type PageDescriptorRenderResult, type PageReactContext, type PageRequest, type PageRequestConfig, type PageResolve, type PageRoute, type PageRouteEntry, type PreviousLayerData, ReactBrowserProvider, type ReactHydrationState, ReactServerProvider, RedirectionError, RouterContext, type RouterContextValue, type RouterGoOptions, RouterHookApi, RouterLayerContext, type RouterLayerContextValue, type RouterRenderResult, type RouterStackItem, type RouterState, type TPropsDefault, type TPropsParentDefault, type TransitionOptions, type UseActiveHook, type UseQueryParamsHookOptions, type VirtualRouter, isPageRoute, useActive, useAlepha, useClient, useInject, useQueryParams, useRouter, useRouterEvents, useRouterState };
+//#endregion
+export { $page, AlephaReact, AnchorProps, ClientOnly, CreateLayersResult, ErrorBoundary, HrefLike, Layer, Link, NestedView, PageConfigSchema, PageDescriptor, PageDescriptorOptions, PageDescriptorProvider, PageDescriptorRenderOptions, PageDescriptorRenderResult, PageReactContext, PageRequest, PageRequestConfig, PageResolve, PageRoute, PageRouteEntry, PreviousLayerData, ReactBrowserProvider, ReactHydrationState, ReactServerProvider, RedirectionError, RouterContext, RouterContextValue, RouterGoOptions, RouterHookApi, RouterLayerContext, RouterLayerContextValue, RouterRenderResult, RouterStackItem, RouterState, TPropsDefault, TPropsParentDefault, TransitionOptions, UseActiveHook, UseQueryParamsHookOptions, VirtualRouter, isPageRoute, useActive, useAlepha, useClient, useInject, useQueryParams, useRouter, useRouterEvents, useRouterState };
+//# sourceMappingURL=index.d.ts.map