@alepha/react 0.6.1 → 0.6.3

package/dist/index.d.ts

@@ -1,14 +1,12 @@
 import * as _alepha_core from '@alepha/core';
-import { EventEmitter, Alepha, TSchema as TSchema$1, Static as Static$1, Async, KIND, Class, TObject as TObject$1 } from '@alepha/core';
+import { Alepha, EventEmitter, Static as Static$1, TSchema as TSchema$1, KIND, Async, Class, TObject as TObject$1 } from '@alepha/core';
+import { HttpClientLink, HttpClient, ServerRouterProvider, ServerHandler, ServerRequest } from '@alepha/server';
 import * as react from 'react';
-import react__default, { ReactNode, AnchorHTMLAttributes, FC } from 'react';
-import * as react_jsx_runtime from 'react/jsx-runtime';
-import { UserAccountToken } from '@alepha/security';
-import * as _alepha_server from '@alepha/server';
-import { FastifyCookieProvider, CookieManager, HttpClient, ServerProvider, ServeDescriptorOptions, CreateRoute } from '@alepha/server';
+import react__default, { ReactNode, FC, AnchorHTMLAttributes } from 'react';
 import { Root } from 'react-dom/client';
-import { MatchFunction, ParamData } from 'path-to-regexp';
-import { Configuration } from 'openid-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;
@@ -51,19 +49,6 @@ interface TBoolean extends TSchema {
     type: 'boolean';
 }
 
-interface NumberOptions extends SchemaOptions {
-    exclusiveMaximum?: number;
-    exclusiveMinimum?: number;
-    maximum?: number;
-    minimum?: number;
-    multipleOf?: number;
-}
-interface TNumber extends TSchema, NumberOptions {
-    [Kind]: 'Number';
-    static: number;
-    type: 'number';
-}
-
 type TOptional<T extends TSchema> = T & {
     [OptionalKind]: 'Optional';
 };
@@ -140,504 +125,64 @@ interface TSchema extends TKind, SchemaOptions {
     static: unknown;
 }
 
-interface NestedViewProps {
-    children?: ReactNode;
-}
-/**
- * Nested view component
- *
- * @param props
- * @constructor
- */
-declare const NestedView: (props: NestedViewProps) => string | number | boolean | react.ReactElement<any, string | react.JSXElementConstructor<any>> | Iterable<ReactNode> | null;
-
-interface LinkProps extends AnchorHTMLAttributes<HTMLAnchorElement> {
-    to: string;
-    children?: react__default.ReactNode;
-}
-declare const Link: (props: LinkProps) => react_jsx_runtime.JSX.Element;
-
-declare class Router extends EventEmitter<RouterEvents> {
-    protected readonly log: _alepha_core.Logger;
-    protected readonly alepha: Alepha;
-    protected readonly pages: PageRoute[];
-    protected notFoundPageRoute?: PageRoute;
-    /**
-     * Get the page by name.
-     *
-     * @param name - Page name
-     * @return PageRoute
-     */
-    page(name: string): PageRoute;
-    /**
-     *
-     */
-    root(state: RouterState, context?: PageContext): ReactNode;
-    /**
-     *
-     * @param url
-     * @param options
-     */
-    render(url: string, options?: RouterRenderOptions): Promise<RouterRenderResult>;
-    /**
-     *
-     * @param url
-     * @param options
-     * @param context
-     * @protected
-     */
-    match(url: string, options?: RouterMatchOptions, context?: RouterRenderContext): Promise<Layer[]>;
-    /**
-     * Create layers for the given route.
-     *
-     * @param url
-     * @param route
-     * @param params
-     * @param query
-     * @param previous
-     * @param args
-     * @param renderContext
-     * @protected
-     */
-    createLayers(url: string, route: PageRoute, params?: Record<string, any>, query?: Record<string, string>, previous?: PreviousLayerData[], args?: PageContext, renderContext?: RouterRenderContext): Promise<Layer[]>;
-    /**
-     *
-     * @param route
-     * @protected
-     */
-    protected getErrorHandler(route: PageRoute): react.FC<{
-        error: Error;
-        url: string;
-    }> | undefined;
-    /**
-     *
-     * @param page
-     * @param props
-     * @protected
-     */
-    protected createElement(page: PageRoute, props: Record<string, any>): Promise<ReactNode>;
-    /**
-     * Merge the render context with the page context.
-     *
-     * @param page
-     * @param ctx
-     * @param props
-     * @protected
-     */
-    protected mergeRenderContext(page: PageRoute, ctx: RouterRenderContext, props: Record<string, any>): void;
-    /**
-     *
-     * @param e
-     * @protected
-     */
-    protected renderError(e: Error): ReactNode;
-    /**
-     * Render an empty view.
-     *
-     * @protected
-     */
-    protected renderEmptyView(): ReactNode;
-    /**
-     * Create a valid href for the given page.
-     * @param page
-     * @param params
-     */
-    href(page: {
-        options: {
-            name?: string;
-        };
-    }, params?: Record<string, any>): string;
-    /**
-     *
-     * @param index
-     * @param path
-     * @param view
-     * @protected
-     */
-    protected renderView(index: number, path: string, view?: ReactNode): ReactNode;
-    /**
-     *
-     * @param entry
-     */
-    add(entry: PageRouteEntry): void;
-    /**
-     * Create a match function for the given page.
-     *
-     * @param page
-     * @protected
-     */
-    protected createMatchFunction(page: PageRoute): {
-        exec: MatchFunction<ParamData>;
-        path: string;
-    } | undefined;
-    /**
-     *
-     */
-    empty(): boolean;
-    /**
-     *
-     * @protected
-     */
-    protected _next: number;
-    /**
-     *
-     * @protected
-     */
-    protected nextId(): string;
-}
-interface PageRouteEntry extends Omit<PageDescriptorOptions, "children" | "parent"> {
-    /**
-     *
-     */
-    name?: string;
-    /**
-     *
-     */
-    match?: {
-        /**
-         *
-         */
-        exec: MatchFunction<ParamData>;
-        /**
-         *
-         */
-        path: string;
-    };
-    /**
-     *
-     */
-    children?: PageRouteEntry[];
-    /**
-     *
-     */
-    parent?: PageRoute;
-}
-interface PageRoute extends PageRouteEntry {
-    /**
-     *
-     */
-    name: string;
-    /**
-     *
-     */
-    parent?: PageRoute;
-}
-interface Layer {
-    /**
-     *
-     */
-    config?: {
-        /**
-         *
-         */
-        query?: Record<string, any>;
-        /**
-         *
-         */
-        params?: Record<string, any>;
-        /**
-         *
-         */
-        context?: Record<string, any>;
-    };
-    /**
-     *
-     */
-    name: string;
-    /**
-     *
-     */
-    props?: Record<string, any>;
-    /**
-     *
-     */
-    part?: string;
-    /**
-     *
-     */
-    element: ReactNode;
-    /**
-     *
-     */
-    index: number;
-    /**
-     *
-     */
-    path: string;
-}
-/**
- *
- */
-type PreviousLayerData = Omit<Layer, "element">;
-interface AnchorProps {
-    /**
-     *
-     */
-    href?: string;
-    /**
-     *
-     * @param ev
-     */
-    onClick?: (ev: any) => any;
-}
-interface RouterMatchOptions {
-    /**
-     *
-     */
-    previous?: PreviousLayerData[];
-    /**
-     *
-     */
-    args?: PageContext;
-}
-interface RouterEvents {
-    /**
-     *
-     */
-    begin: undefined;
-    /**
-     *
-     */
-    success: undefined;
-    /**
-     *
-     */
-    error: Error;
-    /**
-     *
-     */
-    end: RouterState;
-}
-interface RouterState {
-    /**
-     *
-     */
-    pathname: string;
-    /**
-     *
-     */
-    search: string;
-    /**
-     *
-     */
-    layers: Array<Layer>;
-    /**
-     *
-     */
-    context: RouterRenderContext;
-}
-interface RouterRenderContext {
-    /**
-     *
-     */
-    helmet?: RouterRenderHelmetContext;
-}
-interface RouterRenderOptions extends RouterMatchOptions {
-    /**
-     * State to update.
-     */
-    state?: RouterState;
-}
-interface RouterStackItem {
-    /**
-     *
-     */
-    route: PageRoute;
-    /**
-     *
-     */
-    config?: Record<string, any>;
-    /**
-     *
-     */
-    props?: Record<string, any>;
-    /**
-     *
-     */
-    error?: Error;
-}
-interface RouterRenderHelmetContext {
-    /**
-     *
-     */
+interface Head$1 {
     title?: string;
-    /**
-     *
-     */
-    html?: {
-        attributes?: Record<string, string>;
-    };
-    /**
-     *
-     */
-    body?: {
-        attributes?: Record<string, string>;
-    };
-    /**
-     *
-     */
+    htmlAttributes?: Record<string, string>;
+    bodyAttributes?: Record<string, string>;
     meta?: Array<{
         name: string;
         content: string;
     }>;
 }
-interface RouterRenderResult {
-    /**
-     *
-     */
-    element: ReactNode;
-    /**
-     *
-     */
-    layers: Layer[];
-    /**
-     *
-     */
-    redirect?: string;
-    /**
-     *
-     */
-    context: RouterRenderContext;
+declare class ServerHeadProvider {
+    renderHead(template: string, head: Head$1): string;
+    mergeAttributes(existing: string, attrs: Record<string, string>): string;
+    parseAttributes(attrStr: string): Record<string, string>;
+    escapeHtml(str: string): string;
 }
 
-declare class ReactAuthProvider {
-    protected readonly log: _alepha_core.Logger;
-    protected readonly alepha: Alepha;
-    protected readonly fastifyCookieProvider: FastifyCookieProvider;
-    protected authProviders: AuthProvider[];
-    protected readonly authorizationCode: _alepha_server.CookieDescriptor<TObject<{
-        codeVerifier: TOptional<TString>;
-        redirectUri: TOptional<TString>;
-    }>>;
-    protected readonly tokens: _alepha_server.CookieDescriptor<TObject<{
-        access_token: TOptional<TString>;
-        expires_in: TOptional<TNumber>;
-        refresh_token: TOptional<TString>;
-        id_token: TOptional<TString>;
-        scope: TOptional<TString>;
-        issued_at: TOptional<TNumber>;
-    }>>;
-    protected readonly user: _alepha_server.CookieDescriptor<TObject<{
-        id: TString;
-        name: TOptional<TString>;
-        email: TOptional<TString>;
-    }>>;
-    protected readonly configure: _alepha_core.HookDescriptor<"configure">;
-    /**
-     * Configure Fastify to forward Session Access Token to Header Authorization.
-     */
-    protected readonly configureFastify: _alepha_core.HookDescriptor<"configure:fastify">;
-    /**
-     *
-     * @param cookies
-     * @protected
-     */
-    protected refresh(cookies: CookieManager): Promise<SessionTokens | undefined>;
-    /**
-     *
-     */
-    readonly login: _alepha_server.RouteDescriptor<{
-        query: TObject<{
-            redirect: TOptional<TString>;
-            provider: TOptional<TString>;
-        }>;
-    }, false>;
-    /**
-     *
-     */
-    readonly callback: _alepha_server.RouteDescriptor<{
-        query: TObject<{
-            provider: TOptional<TString>;
-        }>;
-    }, false>;
-    /**
-     *
-     * @param accessToken
-     * @protected
-     */
-    protected userFromAccessToken(accessToken: string): {
-        id: any;
-        name: any;
-        email: any;
-    } | undefined;
-    /**
-     *
-     */
-    readonly logout: _alepha_server.RouteDescriptor<{
-        query: TObject<{
-            redirect: TOptional<TString>;
-            provider: TOptional<TString>;
-        }>;
-    }, false>;
-    /**
-     *
-     * @param name
-     * @protected
-     */
-    protected provider(name?: string): AuthProvider;
-    /**
-     *
-     * @param file
-     * @protected
-     */
-    protected isViteFile(file: string): boolean;
-}
-interface SessionTokens {
-    access_token?: string;
-    expires_in?: number;
-    refresh_token?: string;
-    id_token?: string;
-    scope?: string;
-    issued_at?: number;
-}
-interface SessionAuthorizationCode {
-    codeVerifier?: string;
-    redirectUri?: string;
-    nonce?: string;
-    max_age?: number;
-    state?: string;
-}
-interface AuthProvider {
-    name: string;
-    redirectUri: string;
-    client: Configuration;
+declare class BrowserHeadProvider {
+    renderHead(document: Document, head: Head$1): void;
 }
-interface ReactUser {
-    id: string;
-    name?: string;
-    email?: string;
+
+interface BrowserRoute extends Route {
+    page: PageRoute;
 }
-interface ReactHydrationState {
-    user?: ReactUser;
-    auth?: "server" | "client";
-    layers?: PreviousLayerData[];
+declare class BrowserRouterProvider extends RouterProvider<BrowserRoute> {
+    protected readonly log: _alepha_core.Logger;
+    protected readonly alepha: Alepha;
+    protected readonly pageDescriptorProvider: PageDescriptorProvider;
+    readonly events: EventEmitter<RouterEvents>;
+    add(entry: PageRouteEntry): void;
+    protected readonly configure: _alepha_core.HookDescriptor<"configure">;
+    transition(url: URL, options?: TransitionOptions): Promise<RouterRenderResult>;
+    root(state: RouterState, context?: PageReactContext): ReactNode;
 }
 
+declare const envSchema$1: _alepha_core.TObject<{
+    REACT_ROOT_ID: TString;
+}>;
+declare module "@alepha/core" {
+    interface Env extends Partial<Static$1<typeof envSchema$1>> {
+    }
+}
 declare class ReactBrowserProvider {
     protected readonly log: _alepha_core.Logger;
     protected readonly client: HttpClient;
-    protected readonly router: Router;
+    protected readonly alepha: Alepha;
+    protected readonly router: BrowserRouterProvider;
+    protected readonly headProvider: BrowserHeadProvider;
+    protected readonly env: {
+        REACT_ROOT_ID: string;
+    };
     protected root: Root;
     transitioning?: {
         to: string;
     };
     state: RouterState;
-    /**
-     *
-     */
     get document(): Document;
-    /**
-     *
-     */
     get history(): History;
-    /**
-     *
-     */
     get url(): string;
-    /**
-     *
-     * @param props
-     */
     invalidate(props?: Record<string, any>): Promise<void>;
     /**
      *
@@ -645,18 +190,13 @@ declare class ReactBrowserProvider {
      * @param options
      */
     go(url: string, options?: RouterGoOptions): Promise<void>;
-    /**
-     *
-     * @param options
-     * @protected
-     */
     protected render(options?: {
         url?: string;
         previous?: PreviousLayerData[];
     }): Promise<{
         url: string;
+        head: Head;
     }>;
-    protected renderHelmetContext(ctx: RouterRenderHelmetContext): void;
     /**
      * Get embedded layers from the server.
      *
@@ -668,24 +208,19 @@ declare class ReactBrowserProvider {
      * @protected
      */
     protected getRootElement(): HTMLElement;
-    protected getUserFromCookies(): UserAccountToken | undefined;
     /**
      *
      * @protected
      */
     protected ready: _alepha_core.HookDescriptor<"ready">;
-    /**
-     *
-     * @protected
-     */
-    protected stop: _alepha_core.HookDescriptor<"stop">;
 }
-/**
- *
- */
 interface RouterGoOptions {
     replace?: boolean;
-    match?: RouterMatchOptions;
+    match?: TransitionOptions;
+}
+interface ReactHydrationState {
+    layers?: PreviousLayerData[];
+    links?: HttpClientLink[];
 }
 
 declare class RouterHookApi {
@@ -764,83 +299,40 @@ type HrefLike = string | {
     };
 };
 
-declare const pageDescriptorKey = "PAGE";
-interface PageDescriptorConfigSchema {
+declare const KEY = "PAGE";
+interface PageConfigSchema {
     query?: TSchema$1;
     params?: TSchema$1;
 }
 type TPropsDefault = any;
 type TPropsParentDefault = object;
-interface PageDescriptorOptions<TConfig extends PageDescriptorConfigSchema = PageDescriptorConfigSchema, TProps extends object = TPropsDefault, TPropsParent extends object = TPropsParentDefault> {
-    /**
-     *
-     */
+interface PageDescriptorOptions<TConfig extends PageConfigSchema = PageConfigSchema, TProps extends object = TPropsDefault, TPropsParent extends object = TPropsParentDefault> {
     name?: string;
-    /**
-     *
-     */
     path?: string;
-    /**
-     *
-     */
     schema?: TConfig;
-    /**
-     * Function to call when the page is loaded.
-     */
-    resolve?: (config: PageDescriptorConfigValue<TConfig> & TPropsParent & {
-        context: PageContext;
-    }, context: PageContext) => Async<TProps>;
-    /**
-     * Component to render when the page is loaded.
-     */
+    resolve?: (config: PageResolve<TConfig, TPropsParent>) => Async<TProps>;
     component?: FC<TProps & TPropsParent>;
-    /**
-     * Component to render when the page is loaded. (like .component)
-     */
     lazy?: () => Promise<{
         default: FC<TProps & TPropsParent>;
     }>;
-    /**
-     *
-     */
-    children?: () => Array<{
+    children?: Array<{
         options: PageDescriptorOptions;
     }>;
-    /**
-     *
-     */
     parent?: {
         options: PageDescriptorOptions<any, TPropsParent>;
     };
-    /**
-     *
-     */
-    helmet?: RouterRenderHelmetContext | ((props: TProps) => RouterRenderHelmetContext);
-    /**
-     *
-     */
+    can?: () => boolean;
+    head?: Head | ((props: TProps, previous?: Head) => Head);
     notFoundHandler?: FC<{
-        error: Error;
+        url: string;
     }>;
-    /**
-     *
-     */
     errorHandler?: FC<{
         error: Error;
         url: string;
     }>;
 }
-interface PageContext {
-    user?: UserAccountToken;
-    cookies?: CookieManager;
-}
-interface PageDescriptorConfigValue<TConfig extends PageDescriptorConfigSchema = PageDescriptorConfigSchema> {
-    query: TConfig["query"] extends TSchema$1 ? Static$1<TConfig["query"]> : Record<string, string>;
-    params: TConfig["params"] extends TSchema$1 ? Static$1<TConfig["params"]> : Record<string, string>;
-    pathname: string;
-}
-interface PageDescriptor<TConfig extends PageDescriptorConfigSchema = PageDescriptorConfigSchema, TProps extends object = TPropsDefault, TPropsParent extends object = TPropsParentDefault> {
-    [KIND]: typeof pageDescriptorKey;
+interface PageDescriptor<TConfig extends PageConfigSchema = PageConfigSchema, TProps extends object = TPropsDefault, TPropsParent extends object = TPropsParentDefault> {
+    [KIND]: typeof KEY;
     render: (options?: {
         params?: Record<string, string>;
         query?: Record<string, string>;
@@ -851,17 +343,162 @@ interface PageDescriptor<TConfig extends PageDescriptorConfigSchema = PageDescri
         onClick: () => void;
     };
     options: PageDescriptorOptions<TConfig, TProps, TPropsParent>;
+    can: () => boolean;
 }
 declare const $page: {
-    <TConfig extends PageDescriptorConfigSchema = PageDescriptorConfigSchema, TProps extends object = any, TPropsParent extends object = object>(options: PageDescriptorOptions<TConfig, TProps, TPropsParent>): PageDescriptor<TConfig, TProps, TPropsParent>;
+    <TConfig extends PageConfigSchema = PageConfigSchema, TProps extends object = any, TPropsParent extends object = object>(options: PageDescriptorOptions<TConfig, TProps, TPropsParent>): PageDescriptor<TConfig, TProps, TPropsParent>;
     [KIND]: string;
 };
+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, events?: EventEmitter<RouterEvents>): 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 RouterEvents {
+    begin: undefined;
+    success: undefined;
+    error: Error;
+    end: RouterState;
+}
+interface RouterState {
+    pathname: string;
+    search: string;
+    layers: Array<Layer>;
+    head: Head;
+}
+interface TransitionOptions {
+    state?: RouterState;
+    previous?: PreviousLayerData[];
+    context?: PageReactContext;
+}
+interface RouterStackItem {
+    route: PageRoute;
+    config?: Record<string, any>;
+    props?: Record<string, any>;
+    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
+ */
+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;
+
+interface LinkProps extends AnchorHTMLAttributes<HTMLAnchorElement> {
+    to: string | PageDescriptor;
+    children?: react__default.ReactNode;
+}
+declare const Link: (props: LinkProps) => react_jsx_runtime.JSX.Element | null;
 
 interface RouterContextValue {
-    router: Router;
     alepha: Alepha;
     state: RouterState;
-    args: PageContext;
+    context: PageReactContext;
+    events: EventEmitter<RouterEvents>;
 }
 declare const RouterContext: react.Context<RouterContextValue | undefined>;
 
@@ -871,35 +508,6 @@ interface RouterLayerContextValue {
 }
 declare const RouterLayerContext: react.Context<RouterLayerContextValue | undefined>;
 
-declare class Auth {
-    alepha: Alepha;
-    log: _alepha_core.Logger;
-    client: HttpClient;
-    api: string;
-    start: _alepha_core.HookDescriptor<"start">;
-    login: (provider?: string) => void;
-    logout: () => void;
-}
-
-declare const KEY = "AUTH";
-interface AuthDescriptorOptions {
-    name?: string;
-    oidc?: {
-        issuer: string;
-        clientId: string;
-        clientSecret?: string;
-        redirectUri?: string;
-    };
-}
-interface AuthDescriptor {
-    [KIND]: typeof KEY;
-    options: AuthDescriptorOptions;
-}
-declare const $auth: {
-    (options: AuthDescriptorOptions): AuthDescriptor;
-    [KIND]: string;
-};
-
 declare const useInject: <T extends object>(clazz: Class<T>) => T;
 
 declare const useClient: () => HttpClient;
@@ -911,9 +519,6 @@ interface UseQueryParamsHookOptions {
 }
 declare const useQueryParams: <T extends TObject$1>(schema: T, options?: UseQueryParamsHookOptions) => [Static$1<T>, (data: Static$1<T>) => void];
 
-/**
- *
- */
 declare const useRouter: () => RouterHookApi;
 
 declare const useRouterEvents: (opts?: {
@@ -932,112 +537,69 @@ interface UseActiveHook {
     name?: string;
 }
 
-declare const useAuth: () => AuthHook;
-interface AuthHook {
-    user?: UserAccountToken;
-    logout: () => void;
-    login: (provider?: string) => void;
-}
-
-declare class PageDescriptorProvider {
-    protected readonly alepha: Alepha;
-    protected readonly router: Router;
-    protected readonly configure: _alepha_core.HookDescriptor<"configure">;
-    /**
-     * Transform
-     * @param pages
-     * @param target
-     * @protected
-     */
-    protected map(pages: Array<{
-        value: {
-            options: PageDescriptorOptions;
-        };
-    }>, target: {
-        options: PageDescriptorOptions;
-    }): PageRouteEntry;
+declare class RedirectionError extends Error {
+    readonly page: HrefLike;
+    constructor(page: HrefLike);
 }
 
-declare const envSchema$1: TObject<{
+declare const envSchema: TObject<{
     REACT_SERVER_DIST: TString;
     REACT_SERVER_PREFIX: TString;
     REACT_SSR_ENABLED: TBoolean;
-    REACT_SSR_OUTLET: TString;
+    REACT_ROOT_ID: TString;
 }>;
 declare module "@alepha/core" {
-    interface Env extends Partial<Static$1<typeof envSchema$1>> {
+    interface Env extends Partial<Static$1<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 router: Router;
-    protected readonly server: ServerProvider;
+    protected readonly pageDescriptorProvider: PageDescriptorProvider;
+    protected readonly serverStaticProvider: ServerStaticProvider;
+    protected readonly serverRouterProvider: ServerRouterProvider;
+    protected readonly headProvider: ServerHeadProvider;
     protected readonly env: {
+        REACT_ROOT_ID: string;
         REACT_SERVER_DIST: string;
         REACT_SERVER_PREFIX: string;
         REACT_SSR_ENABLED: boolean;
-        REACT_SSR_OUTLET: string;
     };
+    protected readonly ROOT_DIV_REGEX: RegExp;
     protected readonly configure: _alepha_core.HookDescriptor<"configure">;
-    protected configureRoutes(): Promise<void>;
-    /**
-     * Check if the template contains the outlet.
-     *
-     * @param template
-     * @protected
-     */
-    protected checkTemplate(template: string): string;
-    /**
-     *
-     * @param root
-     * @protected
-     */
-    protected createStaticHandler(root: string): ServeDescriptorOptions;
-    /**
-     *
-     * @param templateLoader
-     * @protected
-     */
-    protected createHandler(templateLoader: () => Promise<string | undefined>): CreateRoute;
-    protected processDescriptors(): void;
-    /**
-     *
-     * @param url
-     * @protected
-     */
-    protected notFoundHandler(url: URL): Response | undefined;
-    /**
-     *
-     * @param url
-     * @param template
-     * @param args
-     */
-    ssr(url: URL, template?: string, args?: PageContext): Promise<Response>;
-    protected renderHelmetContext(template: string, helmetContext: RouterRenderHelmetContext): string;
-}
-
-declare class RedirectionError extends Error {
-    readonly page: HrefLike;
-    constructor(page: HrefLike);
+    protected registerPages(templateLoader: () => Promise<string | undefined>): Promise<void>;
+    protected getPublicDirectory(): string;
+    protected configureStaticServer(root: string): Promise<void>;
+    protected configureVite(): Promise<void>;
+    protected createRenderFunction(name: string): (options?: {
+        params?: Record<string, string>;
+        query?: Record<string, string>;
+    }) => Promise<string>;
+    protected createHandler(page: PageRoute, templateLoader: () => Promise<string | undefined>): ServerHandler;
+    fillTemplate(response: {
+        html: string;
+    }, app: string, script: string): void;
 }
 
-declare const envSchema: _alepha_core.TObject<{
-    REACT_AUTH_ENABLED: TBoolean;
-}>;
 declare module "@alepha/core" {
-    interface Env extends Partial<Static$1<typeof envSchema>> {
+    interface Hooks {
+        "react:browser:render": {
+            context: PageReactContext;
+            hydration?: ReactHydrationState;
+        };
+        "react:server:render": {
+            request: ServerRequest;
+            pageRequest: PageRequest;
+        };
     }
 }
 declare class ReactModule {
-    protected readonly env: {
-        REACT_AUTH_ENABLED: boolean;
-    };
     protected readonly alepha: Alepha;
     constructor();
 }
 
-export { $auth, $page, type AnchorProps, Auth, type AuthDescriptor, type AuthDescriptorOptions, type AuthHook, type AuthProvider, type HrefLike, type Layer, Link, NestedView, type PageContext, type PageDescriptor, type PageDescriptorConfigSchema, type PageDescriptorConfigValue, type PageDescriptorOptions, PageDescriptorProvider, type PageRoute, type PageRouteEntry, type PreviousLayerData, ReactAuthProvider, ReactBrowserProvider, type ReactHydrationState, ReactModule, ReactServerProvider, type ReactUser, RedirectionError, Router, RouterContext, type RouterContextValue, type RouterEvents, type RouterGoOptions, RouterHookApi, RouterLayerContext, type RouterLayerContextValue, type RouterMatchOptions, type RouterRenderContext, type RouterRenderHelmetContext, type RouterRenderOptions, type RouterRenderResult, type RouterStackItem, type RouterState, type SessionAuthorizationCode, type SessionTokens, type TPropsDefault, type TPropsParentDefault, type UseActiveHook, type UseQueryParamsHookOptions, envSchema$1 as envSchema, pageDescriptorKey, useActive, useAuth, useClient, useInject, useQueryParams, useRouter, useRouterEvents, useRouterState };
+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 RouterEvents, 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, useClient, useInject, useQueryParams, useRouter, useRouterEvents, useRouterState };