@alepha/react 0.6.10 → 0.7.1

package/dist/index.d.ts

@@ -1,9 +1,8 @@
 import * as _alepha_core from '@alepha/core';
-import { Alepha, Static as Static$1, TSchema as TSchema$1, KIND, OPTIONS, Async, Class, TObject as TObject$1 } from '@alepha/core';
-import * as _alepha_server from '@alepha/server';
-import { HttpClientLink, HttpClient, ServerRouterProvider, ServerHandler, ServerRequest } from '@alepha/server';
-import * as react from 'react';
-import react__default, { ReactNode, FC, AnchorHTMLAttributes } from 'react';
+import { TSchema as TSchema$1, KIND, OPTIONS, Static as Static$1, Async, Alepha, Service, TObject as TObject$1 } from '@alepha/core';
+import { ServerRoute, ApiLinksResponse, HttpClient, ClientScope, HttpVirtualClient, ServerRouterProvider, ServerTimingProvider, ServerHandler, ServerRequest } from '@alepha/server';
+import * as React from 'react';
+import React__default, { PropsWithChildren, ReactNode, FC, ErrorInfo, AnchorHTMLAttributes } from 'react';
 import { Root } from 'react-dom/client';
 import { RouterProvider, Route } from '@alepha/router';
 import * as react_jsx_runtime from 'react/jsx-runtime';
@@ -126,7 +125,294 @@ interface TSchema extends TKind, SchemaOptions {
     static: unknown;
 }
 
+interface ClientOnlyProps {
+    fallback?: ReactNode;
+    disabled?: boolean;
+}
+/**
+ * A small utility component that renders its children only on the client side.
+ *
+ * Optionally, you can provide a fallback React node that will be rendered.
+ *
+ * You should use this component when
+ * - you have code that relies on browser-specific APIs
+ * - you want to avoid server-side rendering for a specific part of your application
+ * - you want to prevent pre-rendering of a component
+ */
+declare const ClientOnly: (props: PropsWithChildren<ClientOnlyProps>) => ReactNode;
+
+declare const KEY = "PAGE";
+interface PageConfigSchema {
+    query?: TSchema$1;
+    params?: TSchema$1;
+}
+type TPropsDefault = any;
+type TPropsParentDefault = {};
+interface PageDescriptorOptions<TConfig extends PageConfigSchema = PageConfigSchema, TProps extends object = TPropsDefault, TPropsParent extends object = TPropsParentDefault> extends Pick<ServerRoute, "cache"> {
+    /**
+     * 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;
+}
+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>;
+}
+/**
+ * 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;
+};
+interface PageDescriptorRenderOptions {
+    params?: Record<string, string>;
+    query?: Record<string, string>;
+    withLayout?: 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;
+    };
+}
+interface PageRequestConfig<TConfig extends PageConfigSchema = PageConfigSchema> {
+    params: TConfig["params"] extends TSchema$1 ? Static$1<TConfig["params"]> : Record<string, string>;
+    query: TConfig["query"] extends TSchema$1 ? Static$1<TConfig["query"]> : Record<string, string>;
+}
+type PageResolve<TConfig extends PageConfigSchema = PageConfigSchema, TPropsParent extends object = TPropsParentDefault> = PageRequestConfig<TConfig> & TPropsParent & PageReactContext;
+
+declare const envSchema$2: _alepha_core.TObject<{
+    REACT_STRICT_MODE: TBoolean;
+}>;
+declare module "@alepha/core" {
+    interface Env extends Partial<Static$1<typeof envSchema$2>> {
+    }
+}
+declare class PageDescriptorProvider {
+    protected readonly log: _alepha_core.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>;
+    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;
+}
+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>;
+    };
+    name: string;
+    props?: Record<string, any>;
+    error?: Error;
+    part?: string;
+    element: ReactNode;
+    index: number;
+    path: string;
+}
+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;
+}
+interface RouterRenderResult {
+    state: RouterState;
+    context: PageReactContext;
+    redirect?: string;
+}
+interface PageRequest extends PageReactContext {
+    params: Record<string, any>;
+    query: Record<string, 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;
+    head: Head$1;
+    onError: (error: Error) => ReactNode;
+    links?: ApiLinksResponse;
+}
+
+interface Head {
     title?: string;
     htmlAttributes?: Record<string, string>;
     bodyAttributes?: Record<string, string>;
@@ -136,14 +422,14 @@ interface Head$1 {
     }>;
 }
 declare class ServerHeadProvider {
-    renderHead(template: string, head: Head$1): string;
+    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$1): void;
+    renderHead(document: Document, head: Head): void;
 }
 
 interface BrowserRoute extends Route {
@@ -156,7 +442,7 @@ declare class BrowserRouterProvider extends RouterProvider<BrowserRoute> {
     add(entry: PageRouteEntry): void;
     protected readonly configure: _alepha_core.HookDescriptor<"configure">;
     transition(url: URL, options?: TransitionOptions): Promise<RouterRenderResult>;
-    root(state: RouterState, context?: PageReactContext): ReactNode;
+    root(state: RouterState, context: PageReactContext): ReactNode;
 }
 
 declare const envSchema$1: _alepha_core.TObject<{
@@ -193,10 +479,7 @@ declare class ReactBrowserProvider {
     protected render(options?: {
         url?: string;
         previous?: PreviousLayerData[];
-    }): Promise<{
-        url: string;
-        head: Head;
-    }>;
+    }): Promise<RouterRenderResult>;
     /**
      * Get embedded layers from the server.
      *
@@ -218,17 +501,45 @@ declare class ReactBrowserProvider {
 interface RouterGoOptions {
     replace?: boolean;
     match?: TransitionOptions;
+    params?: Record<string, string>;
 }
 interface ReactHydrationState {
-    layers?: PreviousLayerData[];
-    links?: HttpClientLink[];
+    layers?: Array<PreviousLayerData>;
+    links?: ApiLinksResponse;
 }
 
+interface NestedViewProps {
+    children?: 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_runtime.JSX.Element;
+
 declare class RouterHookApi {
+    private readonly pages;
     private readonly state;
     private readonly layer;
     private readonly browser?;
-    constructor(state: RouterState, layer: {
+    constructor(pages: PageRoute[], state: RouterState, layer: {
         path: string;
     }, browser?: ReactBrowserProvider | undefined);
     /**
@@ -264,29 +575,24 @@ declare class RouterHookApi {
      */
     createHref(pathname: HrefLike, layer?: {
         path: string;
+    }, options?: {
+        params?: Record<string, any>;
     }): string;
-    /**
-     *
-     * @param path
-     * @param options
-     */
-    go(path: HrefLike, options?: RouterGoOptions): Promise<void>;
-    /**
-     *
-     * @param path
-     */
-    createAnchorProps(path: string): AnchorProps;
+    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>, options?: {
-        /**
-         * If true, this will merge current query params with the new ones.
-         */
-        merge?: boolean;
+    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.
          */
@@ -299,190 +605,57 @@ type HrefLike = string | {
         name?: string;
     };
 };
-
-declare const KEY = "PAGE";
-interface PageConfigSchema {
-    query?: TSchema$1;
-    params?: TSchema$1;
-}
-type TPropsDefault = any;
-type TPropsParentDefault = object;
-interface PageDescriptorOptions<TConfig extends PageConfigSchema = PageConfigSchema, TProps extends object = TPropsDefault, TPropsParent extends object = TPropsParentDefault> {
-    name?: string;
-    path?: string;
-    schema?: TConfig;
-    resolve?: (config: PageResolve<TConfig, TPropsParent>) => Async<TProps>;
-    component?: FC<TProps & TPropsParent>;
-    lazy?: () => Promise<{
-        default: FC<TProps & TPropsParent>;
-    }>;
-    children?: Array<{
-        [OPTIONS]: PageDescriptorOptions;
-    }>;
-    parent?: {
-        [OPTIONS]: PageDescriptorOptions<any, TPropsParent>;
-    };
-    can?: () => boolean;
-    head?: Head | ((props: TProps, previous?: Head) => Head);
-    errorHandler?: FC<{
-        error: Error;
-        url: string;
-    }>;
-}
-interface PageDescriptor<TConfig extends PageConfigSchema = PageConfigSchema, TProps extends object = TPropsDefault, TPropsParent extends object = TPropsParentDefault> {
-    [KIND]: typeof KEY;
-    [OPTIONS]: PageDescriptorOptions<TConfig, TProps, TPropsParent>;
-    render: (options?: {
-        params?: Record<string, string>;
-        query?: Record<string, string>;
-    }) => Promise<string>;
-    go: () => void;
-    createAnchorProps: (routerHook: RouterHookApi) => {
-        href: string;
-        onClick: () => void;
-    };
-    can: () => boolean;
-}
-declare const $page: {
-    <TConfig extends PageConfigSchema = PageConfigSchema, TProps extends object = any, TPropsParent extends object = object>(options: PageDescriptorOptions<TConfig, TProps, TPropsParent>): PageDescriptor<TConfig, TProps, TPropsParent>;
-    [KIND]: string;
+type VirtualRouter<T> = {
+    [K in keyof T as T[K] extends PageDescriptor ? K : never]: T[K];
 };
-interface Head {
-    title?: string;
-    titleSeparator?: string;
-    htmlAttributes?: Record<string, string>;
-    bodyAttributes?: Record<string, string>;
-    meta?: Array<{
-        name: string;
-        content: string;
-    }>;
-}
-interface PageRequestConfig<TConfig extends PageConfigSchema = PageConfigSchema> {
-    params: TConfig["params"] extends TSchema$1 ? Static$1<TConfig["params"]> : Record<string, string>;
-    query: TConfig["query"] extends TSchema$1 ? Static$1<TConfig["query"]> : Record<string, string>;
-}
-type PageResolve<TConfig extends PageConfigSchema = PageConfigSchema, TPropsParent extends object = TPropsParentDefault> = PageRequestConfig<TConfig> & TPropsParent & PageResolveContext;
-interface PageResolveContext {
-    url: URL;
-    head: Head;
-}
 
-declare class PageDescriptorProvider {
-    protected readonly log: _alepha_core.Logger;
-    protected readonly alepha: Alepha;
-    protected readonly pages: PageRoute[];
-    getPages(): PageRoute[];
-    page(name: string): PageRoute;
-    root(state: RouterState, context?: PageReactContext): ReactNode;
-    createLayers(route: PageRoute, request: PageRequest): Promise<CreateLayersResult>;
-    protected getErrorHandler(route: PageRoute): react.FC<{
-        error: Error;
-        url: string;
-    }> | undefined;
-    protected createElement(page: PageRoute, props: Record<string, any>): Promise<ReactNode>;
-    protected fillHead(page: PageRoute, ctx: PageRequest, props: Record<string, any>): void;
-    renderError(e: 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): 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;
-}
-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>;
-    };
-    name: string;
-    props?: Record<string, any>;
-    error?: Error;
-    part?: string;
-    element: ReactNode;
-    index: number;
-    path: string;
-}
-type PreviousLayerData = Omit<Layer, "element">;
-interface AnchorProps {
-    href?: string;
-    onClick?: (ev: any) => any;
-}
-interface RouterState {
-    pathname: string;
-    search: string;
-    layers: Array<Layer>;
-    head: Head;
+declare class RedirectionError extends Error {
+    readonly page: HrefLike;
+    constructor(page: HrefLike);
 }
-interface TransitionOptions {
-    state?: RouterState;
-    previous?: PreviousLayerData[];
-    context?: PageReactContext;
+
+/**
+ * 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;
 }
-interface RouterStackItem {
-    route: PageRoute;
-    config?: Record<string, any>;
-    props?: Record<string, any>;
+/**
+ * State of the ErrorBoundary component.
+ */
+interface ErrorBoundaryState {
     error?: Error;
 }
-interface RouterRenderResult {
-    redirect?: string;
-    layers: Layer[];
-    head: Head;
-    element: ReactNode;
-}
-interface PageRequest extends PageReactContext {
-    url: URL;
-    params: Record<string, any>;
-    query: Record<string, string>;
-    head: Head;
-    previous?: PreviousLayerData[];
-}
-interface CreateLayersResult extends RouterState {
-    redirect?: string;
-}
-interface PageReactContext {
-    links?: HttpClientLink[];
-}
-
-interface NestedViewProps {
-    children?: ReactNode;
-}
 /**
- * Nested view component
- *
- * @param props
- * @constructor
+ * A reusable error boundary for catching rendering errors
+ * in any part of the React component tree.
  */
-declare const NestedView: (props: NestedViewProps) => string | number | bigint | boolean | react.ReactElement<unknown, string | react.JSXElementConstructor<any>> | Iterable<ReactNode> | Promise<string | number | bigint | boolean | react.ReactPortal | react.ReactElement<unknown, string | react.JSXElementConstructor<any>> | Iterable<ReactNode> | null | undefined> | null;
+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;
+}
 
 interface LinkProps extends AnchorHTMLAttributes<HTMLAnchorElement> {
     to: string | PageDescriptor;
-    children?: react__default.ReactNode;
+    children?: React__default.ReactNode;
 }
 declare const Link: (props: LinkProps) => react_jsx_runtime.JSX.Element | null;
 
@@ -491,18 +664,27 @@ interface RouterContextValue {
     state: RouterState;
     context: PageReactContext;
 }
-declare const RouterContext: react.Context<RouterContextValue | undefined>;
+declare const RouterContext: React.Context<RouterContextValue | undefined>;
 
 interface RouterLayerContextValue {
     index: number;
     path: string;
 }
-declare const RouterLayerContext: react.Context<RouterLayerContextValue | undefined>;
+declare const RouterLayerContext: React.Context<RouterLayerContextValue | undefined>;
 
-declare const useInject: <T extends object>(clazz: Class<T>) => T;
+declare const useActive: (path: HrefLike) => UseActiveHook;
+interface UseActiveHook {
+    isActive: boolean;
+    anchorProps: AnchorProps;
+    isPending: boolean;
+    name?: string;
+}
 
-declare const useClient: () => HttpClient;
-declare const useApi: <T extends object>() => _alepha_server.HttpVirtualClient<T>;
+declare const useAlepha: () => Alepha;
+
+declare const useClient: <T extends object>(_scope?: ClientScope) => HttpVirtualClient<T>;
+
+declare const useInject: <T extends object>(clazz: Service<T>) => T;
 
 interface UseQueryParamsHookOptions {
     format?: "base64" | "querystring";
@@ -528,23 +710,10 @@ declare const useRouterEvents: (opts?: {
 
 declare const useRouterState: () => RouterState;
 
-declare const useActive: (path: HrefLike) => UseActiveHook;
-interface UseActiveHook {
-    isActive: boolean;
-    anchorProps: AnchorProps;
-    isPending: boolean;
-    name?: string;
-}
-
-declare class RedirectionError extends Error {
-    readonly page: HrefLike;
-    constructor(page: HrefLike);
-}
-
 declare const envSchema: TObject<{
     REACT_SERVER_DIST: TString;
     REACT_SERVER_PREFIX: TString;
-    REACT_SSR_ENABLED: TBoolean;
+    REACT_SSR_ENABLED: TOptional<TBoolean>;
     REACT_ROOT_ID: TString;
 }>;
 declare module "@alepha/core" {
@@ -562,31 +731,42 @@ declare class ReactServerProvider {
     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_ROOT_ID: string;
         REACT_SERVER_DIST: string;
         REACT_SERVER_PREFIX: string;
-        REACT_SSR_ENABLED: boolean;
     };
     protected readonly ROOT_DIV_REGEX: RegExp;
-    protected readonly configure: _alepha_core.HookDescriptor<"configure">;
-    protected registerPages(templateLoader: () => Promise<string | undefined>): Promise<void>;
+    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(): Promise<void>;
-    protected createRenderFunction(name: string): (options?: {
+    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<string>;
-    protected createHandler(page: PageRoute, templateLoader: () => Promise<string | undefined>): ServerHandler;
-    fillTemplate(response: {
+    }) => 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;
 }
+type TemplateLoader = () => Promise<string | undefined>;
 
 declare module "@alepha/core" {
     interface Hooks {
         "react:browser:render": {
+            state: RouterState;
             context: PageReactContext;
             hydration?: ReactHydrationState;
         };
@@ -596,6 +776,7 @@ declare module "@alepha/core" {
         };
         "react:transition:begin": {
             state: RouterState;
+            context: PageReactContext;
         };
         "react:transition:success": {
             state: RouterState;
@@ -603,9 +784,11 @@ declare module "@alepha/core" {
         "react:transition:error": {
             error: Error;
             state: RouterState;
+            context: PageReactContext;
         };
         "react:transition:end": {
             state: RouterState;
+            context: PageReactContext;
         };
     }
 }
@@ -614,4 +797,4 @@ declare class ReactModule {
     constructor();
 }
 
-export { $page, type AnchorProps, type CreateLayersResult, type Head, type HrefLike, type Layer, Link, NestedView, type PageConfigSchema, type PageDescriptor, type PageDescriptorOptions, PageDescriptorProvider, type PageReactContext, type PageRequest, type PageRequestConfig, type PageResolve, type PageResolveContext, type PageRoute, type PageRouteEntry, type PreviousLayerData, ReactBrowserProvider, type ReactHydrationState, ReactModule, 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, envSchema, isPageRoute, useActive, useApi, useClient, useInject, useQueryParams, useRouter, useRouterEvents, useRouterState };
+export { $page, 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, ReactModule, 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, envSchema, isPageRoute, useActive, useAlepha, useClient, useInject, useQueryParams, useRouter, useRouterEvents, useRouterState };