@stone-js/use-react 0.1.0 → 0.2.0

package/dist/index.d.ts

@@ -1,40 +1,13 @@
-import { HTMLMetaDescriptor, HeadContext as HeadContext$1, FunctionalEventHandler, Route, Router, DecoratorPageRouteDefinition, NavigateOptions } from '@stone-js/router';
+import { FunctionalEventHandler, HeadContext as HeadContext$1, Route, Router, DecoratorPageRouteDefinition, HTMLMetaDescriptor, NavigateOptions } from '@stone-js/router';
 import * as react from 'react';
 import { ReactNode, ElementType, FunctionComponent } from 'react';
 import { Config } from '@stone-js/config';
 import { BrowserEvent, BrowserResponse, BrowserContext, BrowserAdapterResponseBuilder } from '@stone-js/browser-adapter';
-import { IncomingHttpEvent, OutgoingHttpResponse, RedirectResponse, IncomingHttpEventOptions, OutgoingHttpResponseOptions, RedirectResponseOptions } from '@stone-js/http-core';
-import { IncomingBrowserEvent, OutgoingBrowserResponse, RedirectBrowserResponse, IncomingBrowserEventOptions, OutgoingBrowserResponseOptions, RedirectBrowserResponseOptions } from '@stone-js/browser-core';
-import { IContainer, Promiseable, Laziable, FunctionalErrorHandler, IBlueprint, FunctionalAdapterErrorHandler, OutgoingResponseOptions, HookName as HookName$1, LifecycleHookType, ErrorHandlerOptions, AdapterErrorHandlerOptions, AdapterContext, IAdapterErrorHandler, AdapterErrorContext, AdapterEventBuilderType, IEventHandler, IErrorHandler, ILogger, IServiceProvider, StoneBlueprint, AppConfig, ClassType, InitializationError, ErrorOptions, BlueprintContext, NextMiddleware, MetaMiddleware } from '@stone-js/core';
+import { IncomingHttpEvent, OutgoingHttpResponse, RedirectResponse, IncomingHttpEventOptions, RedirectResponseOptions, OutgoingHttpResponseOptions } from '@stone-js/http-core';
+import { IncomingBrowserEvent, OutgoingBrowserResponse, RedirectBrowserResponse, IncomingBrowserEventOptions, RedirectBrowserResponseOptions, OutgoingBrowserResponseOptions } from '@stone-js/browser-core';
+import { IContainer, Promiseable, Laziable, FunctionalErrorHandler, IBlueprint, FunctionalAdapterErrorHandler, OutgoingResponseOptions, HookName as HookName$1, LifecycleHookType, ErrorHandlerOptions, AdapterErrorHandlerOptions, AdapterContext, IEventHandler, IErrorHandler, AdapterErrorContext, IServiceProvider, StoneBlueprint, AppConfig, IAdapterErrorHandler, AdapterEventBuilderType, ClassType, BlueprintContext, NextMiddleware, InitializationError, ErrorOptions, ILogger, MetaMiddleware } from '@stone-js/core';
 import { Root } from 'react-dom/client';
 
-/**
-  * Stone DOM Attribute.
-  */
-declare const STONE_DOM_ATTR = "data-stone-head";
-/**
- * Apply meta tags to the document document.head.
- *
- * @param document - The document object.
- * @param meta - The meta tag descriptor.
- */
-declare const applyMeta: (document: Document, meta: HTMLMetaDescriptor) => void;
-/**
- * Apply the head context to the document document.head.
- *
- * @param document - The document object.
- * @param context - The head context containing meta, link, script, and style descriptors.
- */
-declare const applyHeadContextToDom: (document: Document, context: HeadContext$1) => void;
-/**
- * Escape HTML special characters in a string.
- *
- * @param context - The head context containing meta, link, script, and style descriptors.
- * @param html - The HTML string to escape.
- * @returns The escaped string.
- */
-declare const applyHeadContextToHtmlString: (context: HeadContext$1, html: string) => string;
-
 /**
  * The type representing the Head Context for React.
  * It extends the BaseHeadContext to include additional properties specific to React.
@@ -66,6 +39,14 @@ type ReactIncomingEvent = IncomingHttpEvent | IncomingBrowserEvent;
  * Incoming event options for React.
 */
 type ReactIncomingEventOptions = IncomingBrowserEventOptions | IncomingHttpEventOptions;
+/**
+ * Redirect response options for React.
+*/
+type ReactRedirectResponseOptions = RedirectResponseOptions | RedirectBrowserResponseOptions;
+/**
+ * Outgoing response options for React.
+*/
+type ReactResponseOptions = OutgoingHttpResponseOptions | ReactOutgoingResponseOptions | ReactRedirectResponseOptions | OutgoingBrowserResponseOptions;
 /**
  * Outgoing response for React.
 */
@@ -467,47 +448,31 @@ declare const MetaReactRuntime: {
 };
 
 /**
- * UseReactBrowserErrorHandler options.
+  * Stone DOM Attribute.
+  */
+declare const STONE_DOM_ATTR = "data-stone-head";
+/**
+ * Apply meta tags to the document document.head.
+ *
+ * @param document - The document object.
+ * @param meta - The meta tag descriptor.
  */
-interface UseReactBrowserErrorHandlerOptions {
-    blueprint: IBlueprint;
-}
+declare const applyMeta: (document: Document, meta: HTMLMetaDescriptor) => void;
 /**
- * Class representing an UseReactBrowserErrorHandler.
+ * Apply the head context to the document document.head.
  *
- * Adapter level error handler for React applications.
+ * @param document - The document object.
+ * @param context - The head context containing meta, link, script, and style descriptors.
  */
-declare class UseReactBrowserErrorHandler implements IAdapterErrorHandler<unknown, unknown, unknown> {
-    private readonly logger;
-    private readonly blueprint;
-    /**
-     * Create an UseReactBrowserErrorHandler.
-     *
-     * @param options - UseReactBrowserErrorHandler options.
-     */
-    constructor({ blueprint }: UseReactBrowserErrorHandlerOptions);
-    /**
-     * Handle an error.
-     *
-     * @param error - The error to handle.
-     * @param context - The context of the adapter.
-     * @returns The raw response.
-     */
-    handle(error: any, context: AdapterErrorContext<unknown, unknown, unknown>): Promise<AdapterEventBuilderType<unknown>>;
-    /**
-     * Get the error body.
-     *
-     * @param error - The error to handle.
-     * @returns The error body.
-     */
-    private renderError;
-}
-
+declare const applyHeadContextToDom: (document: Document, context: HeadContext$1) => void;
 /**
- * Stone context.
- * Usefull to pass data to the components.
+ * Escape HTML special characters in a string.
+ *
+ * @param context - The head context containing meta, link, script, and style descriptors.
+ * @param html - The HTML string to escape.
+ * @returns The escaped string.
  */
-declare const StoneContext: react.Context<StoneContextType>;
+declare const applyHeadContextToHtmlString: (context: HeadContext$1, html: string) => string;
 
 /**
  * A useReact event handler for processing incoming events
@@ -543,6 +508,12 @@ declare class UseReactEventHandler<IncomingEventType extends ReactIncomingEvent
     private getComponentEventHandler;
 }
 
+/**
+ * Stone context.
+ * Usefull to pass data to the components.
+ */
+declare const StoneContext: react.Context<StoneContextType>;
+
 /**
  * UseReactError response type.
  */
@@ -732,9 +703,9 @@ declare function getBrowserContent(app: ReactNode, component: ReactNode, layout:
  * @param container - The service container.
  * @param event - The incoming browser event.
  * @param head - The head context.
- * @returns A promise that resolves when the content is hydrated.
+ * @returns The server response content as a string.
  */
-declare function getServerContent(component: ReactNode, data: Partial<ResponseSnapshotType>, container: IContainer, event: IncomingBrowserEvent, head?: HeadContext): Promise<string>;
+declare function getServerContent(component: ReactNode, data: Partial<ResponseSnapshotType>, container: IContainer, event: IncomingBrowserEvent, head?: HeadContext): string;
 /**
  * Get the response snapshot.
  *
@@ -764,6 +735,47 @@ declare function renderStoneSnapshot(snapshot: string): string;
  */
 declare function executeHooks(name: UseReactHookName, context: UseReactHookListenerContext): Promise<void>;
 
+/**
+ * Options for configuring the use-react service provider.
+ */
+interface UseReactServiceProviderOptions {
+    container: IContainer;
+}
+/**
+ * Use React Service Provider.
+ */
+declare class UseReactServiceProvider implements IServiceProvider {
+    private readonly container;
+    /**
+     * Constructs a new `UseReactServiceProvider` instance.
+     *
+     * @param container - The container to register services in.
+     */
+    constructor(container: IContainer);
+    /**
+     * Register method for the service provider.
+     */
+    register(): Promiseable<void>;
+    /**
+     * Boot method for the service provider.
+     */
+    boot(): Promiseable<void>;
+    /**
+     * Register the snapshot.
+     *
+     * We save the snapshot on server side rendering and
+     * we use it to hydrate the application on the client side.
+    */
+    private registerSnapshot;
+}
+/**
+ * MetaUseReactServiceProvider
+ */
+declare const MetaUseReactServiceProvider: {
+    module: typeof UseReactServiceProvider;
+    isClass: boolean;
+};
+
 /**
  * Prepare the page to render.
  *
@@ -801,59 +813,6 @@ declare function prepareErrorPage(event: IncomingBrowserEvent, response: ReactOu
  */
 declare function prepareFallbackErrorPage(event: IncomingBrowserEvent, response: ReactOutgoingResponse, container: IContainer, snapshot: ResponseSnapshotType): Promise<void>;
 
-/**
- * Create an UseReact response.
- *
- * @param options - The options for creating the response.
- * @returns The React response.
- */
-declare const reactResponse: (options: OutgoingHttpResponseOptions | OutgoingBrowserResponseOptions | RedirectResponseOptions | RedirectBrowserResponseOptions) => Promise<ReactOutgoingResponse>;
-/**
- * Create an UseReact redirect response.
- *
- * @param options - The options for creating the response.
- * @returns The React redirect response.
- */
-declare const reactRedirectResponse: (options: RedirectResponseOptions | RedirectBrowserResponseOptions) => Promise<ReactOutgoingResponse>;
-
-/**
- * UseReactServerErrorHandler options.
- */
-interface UseReactServerErrorHandlerOptions {
-    logger: ILogger;
-    blueprint: IBlueprint;
-}
-/**
- * Class representing an UseReactServerErrorHandler.
- *
- * Adapter level error handler for React applications.
- */
-declare class UseReactServerErrorHandler implements IAdapterErrorHandler<unknown, unknown, unknown> {
-    private readonly logger;
-    private readonly blueprint;
-    /**
-     * Create an UseReactServerErrorHandler.
-     *
-     * @param options - UseReactServerErrorHandler options.
-     */
-    constructor({ blueprint }: UseReactServerErrorHandlerOptions);
-    /**
-     * Handle an error.
-     *
-     * @param error - The error to handle.
-     * @param context - The context of the adapter.
-     * @returns The raw response.
-     */
-    handle(error: any, context: AdapterErrorContext<unknown, unknown, unknown>): Promise<AdapterEventBuilderType<unknown>>;
-    /**
-     * Get the error body.
-     *
-     * @param error - The error to handle.
-     * @returns The error body.
-    */
-    private getErrorBody;
-}
-
 /**
  * Constants for the Stone SNAPSHOT
  */
@@ -863,47 +822,6 @@ declare const STONE_SNAPSHOT = "__STONE_SNAPSHOT__";
  */
 declare const STONE_PAGE_EVENT_OUTLET = "stone:inject:react-page:outlet";
 
-/**
- * Options for configuring the use-react service provider.
- */
-interface UseReactServiceProviderOptions {
-    container: IContainer;
-}
-/**
- * Use React Service Provider.
- */
-declare class UseReactServiceProvider implements IServiceProvider {
-    private readonly container;
-    /**
-     * Constructs a new `UseReactServiceProvider` instance.
-     *
-     * @param container - The container to register services in.
-     */
-    constructor(container: IContainer);
-    /**
-     * Register method for the service provider.
-     */
-    register(): Promiseable<void>;
-    /**
-     * Boot method for the service provider.
-     */
-    boot(): Promiseable<void>;
-    /**
-     * Register the snapshot.
-     *
-     * We save the snapshot on server side rendering and
-     * we use it to hydrate the application on the client side.
-    */
-    private registerSnapshot;
-}
-/**
- * MetaUseReactServiceProvider
- */
-declare const MetaUseReactServiceProvider: {
-    module: typeof UseReactServiceProvider;
-    isClass: boolean;
-};
-
 /**
  * Configuration options for integrating React with Stone.js.
  */
@@ -923,6 +841,12 @@ interface UseReactConfig {
      * A map of layout components with their respective event handlers.
      */
     layout?: Record<string, MetaPageLayout>;
+    /**
+     * A list of platforms to ignore for React rendering.
+     * This can be used to disable React rendering on specific platforms.
+     * For example, you might want to ignore rendering on CLI platforms.
+     */
+    ignorePlatforms?: string[];
     /**
      * Handles incoming events for the root React component.
      */
@@ -960,7 +884,7 @@ interface UseReactBlueprint extends StoneBlueprint<ReactIncomingEvent, ReactOutg
  *
  * - Defines middleware, lifecycle hooks, and the default HTML template path.
  */
-declare const useReactBlueprint: UseReactBlueprint;
+declare const internalUseReactBlueprint: UseReactBlueprint;
 
 /**
  * Utility function to define a factory-based adapter error page.
@@ -982,69 +906,25 @@ declare function defineAdapterErrorPage(module: AdapterErrorPageClass<unknown, u
 }): UseReactBlueprint;
 
 /**
- * Defines a Stone React app using a factory-based main handler.
+ * Utility function to define a factory-based page.
  *
- * @param module - A factory function for the main page.
- * @param options - Optional application-level configuration.
- * @param blueprints - Additional blueprints to merge.
- * @returns A fully merged Stone blueprint.
+ * @param module - The EventHandler module.
+ * @param options - Page definition options.
+ * @returns The UseReactBlueprint.
  */
-declare function defineStoneReactApp<U extends ReactIncomingEvent = ReactIncomingEvent>(module: FactoryPage<U>, options?: Partial<UseReactAppConfig>, blueprints?: Array<StoneBlueprint<any, any> & Record<string, any>>): StoneBlueprint<U>;
+declare function definePage<U extends ReactIncomingEvent = ReactIncomingEvent>(module: FactoryPage<U>, options: PageOptions & {
+    isClass?: undefined;
+}): Partial<StoneBlueprint<U>>;
 /**
- * Defines a Stone React app using a class-based main handler.
+ * Utility function to define a class-based page.
  *
- * @param module - A class constructor for the main page.
- * @param options - Optional application-level configuration.
- * @param blueprints - Additional blueprints to merge.
- * @returns A fully merged Stone blueprint.
+ * @param module - The EventHandler module.
+ * @param options - Page definition options.
+ * @returns The UseReactBlueprint.
  */
-declare function defineStoneReactApp<U extends ReactIncomingEvent = ReactIncomingEvent>(module: PageClass<U>, options: Partial<UseReactAppConfig> & {
-    isClass: boolean;
-}, blueprints?: Array<StoneBlueprint<any, any> & Record<string, any>>): StoneBlueprint<U>;
-/**
- * Defines a Stone React app without a main handler (router-only).
- *
- * @param options - Application-level configuration.
- * @param blueprints - Additional blueprints to merge.
- * @returns A fully merged Stone blueprint.
- */
-declare function defineStoneReactApp<U extends ReactIncomingEvent = ReactIncomingEvent>(options?: Partial<UseReactAppConfig>, blueprints?: Array<StoneBlueprint<any, any> & Record<string, any>>): StoneBlueprint<U>;
-
-/**
- * Stone Client options.
- */
-interface StoneClientOptions {
-    children: ReactNode;
-}
-/**
- * Stone Client.
- * This component is used to wrap content
- * that should only be rendered on the client.
- *
- * @param options - The options to create the Stone Client.
- */
-declare const StoneClient: FunctionComponent<StoneClientOptions>;
-
-/**
- * Utility function to define a factory-based page.
- *
- * @param module - The EventHandler module.
- * @param options - Page definition options.
- * @returns The UseReactBlueprint.
- */
-declare function definePage<U extends ReactIncomingEvent = ReactIncomingEvent>(module: FactoryPage<U>, options: PageOptions & {
-    isClass?: undefined;
-}): Partial<StoneBlueprint<U>>;
-/**
- * Utility function to define a class-based page.
- *
- * @param module - The EventHandler module.
- * @param options - Page definition options.
- * @returns The UseReactBlueprint.
- */
-declare function definePage<U extends ReactIncomingEvent = ReactIncomingEvent>(module: PageClass<U>, options: PageOptions & {
-    isClass: true;
-}): Partial<StoneBlueprint<U>>;
+declare function definePage<U extends ReactIncomingEvent = ReactIncomingEvent>(module: PageClass<U>, options: PageOptions & {
+    isClass: true;
+}): Partial<StoneBlueprint<U>>;
 /**
  * Utility function to define a factory-based page layout.
  *
@@ -1086,11 +966,107 @@ declare function defineErrorPage(module: ErrorPageClass<ReactIncomingEvent>, opt
     isClass: true;
 }): UseReactBlueprint;
 
+/**
+ * Defines a Stone React app using a factory-based main handler.
+ *
+ * @param module - A factory function for the main page.
+ * @param options - Optional application-level configuration.
+ * @param blueprints - Additional blueprints to merge.
+ * @returns A fully merged Stone blueprint.
+ */
+declare function defineStoneReactApp<U extends ReactIncomingEvent = ReactIncomingEvent>(module: FactoryPage<U>, options?: Partial<UseReactAppConfig>, blueprints?: Array<StoneBlueprint<any, any> & Record<string, any>>): StoneBlueprint<U>;
+/**
+ * Defines a Stone React app using a class-based main handler.
+ *
+ * @param module - A class constructor for the main page.
+ * @param options - Optional application-level configuration.
+ * @param blueprints - Additional blueprints to merge.
+ * @returns A fully merged Stone blueprint.
+ */
+declare function defineStoneReactApp<U extends ReactIncomingEvent = ReactIncomingEvent>(module: PageClass<U>, options: Partial<UseReactAppConfig> & {
+    isClass: boolean;
+}, blueprints?: Array<StoneBlueprint<any, any> & Record<string, any>>): StoneBlueprint<U>;
+/**
+ * Defines a Stone React app without a main handler (router-only).
+ *
+ * @param options - Application-level configuration.
+ * @param blueprints - Additional blueprints to merge.
+ * @returns A fully merged Stone blueprint.
+ */
+declare function defineStoneReactApp<U extends ReactIncomingEvent = ReactIncomingEvent>(options?: Partial<UseReactAppConfig>, blueprints?: Array<StoneBlueprint<any, any> & Record<string, any>>): StoneBlueprint<U>;
+
+/**
+ * UseReactBrowserErrorHandler options.
+ */
+interface UseReactBrowserErrorHandlerOptions {
+    blueprint: IBlueprint;
+}
+/**
+ * Class representing an UseReactBrowserErrorHandler.
+ *
+ * Adapter level error handler for React applications.
+ */
+declare class UseReactBrowserErrorHandler implements IAdapterErrorHandler<unknown, unknown, unknown> {
+    private readonly logger;
+    private readonly blueprint;
+    /**
+     * Create an UseReactBrowserErrorHandler.
+     *
+     * @param options - UseReactBrowserErrorHandler options.
+     */
+    constructor({ blueprint }: UseReactBrowserErrorHandlerOptions);
+    /**
+     * Handle an error.
+     *
+     * @param error - The error to handle.
+     * @param context - The context of the adapter.
+     * @returns The raw response.
+     */
+    handle(error: any, context: AdapterErrorContext<unknown, unknown, unknown>): Promise<AdapterEventBuilderType<unknown>>;
+    /**
+     * Get the error body.
+     *
+     * @param error - The error to handle.
+     * @returns The error body.
+     */
+    private renderError;
+}
+
+/**
+ * Create an UseReact response.
+ *
+ * @param options - The options for creating the response.
+ * @returns The React response.
+ */
+declare const reactResponse: (options: ReactResponseOptions) => ReactOutgoingResponse;
+/**
+ * Create an UseReact redirect response.
+ *
+ * @param options - The options for creating the response.
+ * @returns The React redirect response.
+ */
+declare const reactRedirectResponse: (options: ReactRedirectResponseOptions) => ReactOutgoingResponse;
+
 /**
  * Stone Error.
  */
 declare const StoneError: FunctionComponent;
 
+/**
+ * Stone Client options.
+ */
+interface StoneClientOptions {
+    children: ReactNode;
+}
+/**
+ * Stone Client.
+ * This component is used to wrap content
+ * that should only be rendered on the client.
+ *
+ * @param options - The options to create the Stone Client.
+ */
+declare const StoneClient: FunctionComponent<StoneClientOptions>;
+
 interface BaseProps {
     rel?: string;
     href?: string;
@@ -1115,26 +1091,6 @@ type StoneLinkOptions = (BaseProps & {
  */
 declare const StoneLink: FunctionComponent<StoneLinkOptions>;
 
-/**
- * Stone Outlet options.
- */
-interface StoneOutletOptions {
-    children: ReactNode;
-}
-/**
- * A dynamic rendering component that updates its content based on a global event.
- *
- * - Listens for `stone:inject:react-page:outlet` and updates its view when triggered.
- * - Uses `useState` to manage the currently displayed content.
- * - Automatically cleans up event listeners on unmount.
- *
- * This component enables dynamic content updates within a Stone.js application.
- *
- * @param options - The options to create the Stone Outlet.
- * @returns The Stone Outlet component.
- */
-declare const StoneOutlet: FunctionComponent<StoneOutletOptions>;
-
 /**
  * Stone Page options.
  */
@@ -1156,6 +1112,26 @@ interface StonePageOptions {
  */
 declare const StonePage: FunctionComponent<StonePageOptions>;
 
+/**
+ * Stone Outlet options.
+ */
+interface StoneOutletOptions {
+    children: ReactNode;
+}
+/**
+ * A dynamic rendering component that updates its content based on a global event.
+ *
+ * - Listens for `stone:inject:react-page:outlet` and updates its view when triggered.
+ * - Uses `useState` to manage the currently displayed content.
+ * - Automatically cleans up event listeners on unmount.
+ *
+ * This component enables dynamic content updates within a Stone.js application.
+ *
+ * @param options - The options to create the Stone Outlet.
+ * @returns The Stone Outlet component.
+ */
+declare const StoneOutlet: FunctionComponent<StoneOutletOptions>;
+
 /**
  * Stone Server options.
  */
@@ -1191,6 +1167,26 @@ declare const StoneServer: FunctionComponent<StoneServerOptions>;
  */
 declare const AdapterErrorPage: <T extends ClassType = ClassType>(options: AdapterErrorPageOptions) => ClassDecorator;
 
+/**
+ * A class decorator for defining a class as a React Handler layout.
+ *
+ * @param options - Configuration options for the layout definition.
+ * @returns A method decorator to be applied to a class method.
+ *
+ * @example
+ * ```typescript
+ * import { ErrorPage } from '@stone-js/use-react';
+ *
+ * @ErrorPage({ error: 'UserNotFoundError' })
+ * class UserErrorPage {
+ *   render({ error }) {
+ *     return <h1>User name: {error.message}</h1>;
+ *   }
+ * }
+ * ```
+ */
+declare const ErrorPage: <T extends ClassType = ClassType>(options: ErrorPageOptions) => ClassDecorator;
+
 /**
  * Hook decorator to mark a method as a lifecycle hook
  * And automatically add it to the global lifecycle hook registry.
@@ -1234,26 +1230,6 @@ declare const Hook: <T extends Function = Function>(name: HookName) => MethodDec
  */
 declare const Page: <T extends ClassType = ClassType>(path: string, options?: PageOptions) => ClassDecorator;
 
-/**
- * A class decorator for defining a class as a React Handler layout.
- *
- * @param options - Configuration options for the layout definition.
- * @returns A method decorator to be applied to a class method.
- *
- * @example
- * ```typescript
- * import { ErrorPage } from '@stone-js/use-react';
- *
- * @ErrorPage({ error: 'UserNotFoundError' })
- * class UserErrorPage {
- *   render({ error }) {
- *     return <h1>User name: {error.message}</h1>;
- *   }
- * }
- * ```
- */
-declare const ErrorPage: <T extends ClassType = ClassType>(options: ErrorPageOptions) => ClassDecorator;
-
 /**
  * A class decorator for defining a class as a React Page layout.
  *
@@ -1318,29 +1294,6 @@ declare const PageStatus: <T extends Function = Function>(statusCode?: number, h
  */
 declare const Snapshot: <T extends Function = Function>(name?: string) => MethodDecorator;
 
-/**
- * UseReact decorator options.
- */
-interface UseReactOptions extends Partial<UseReactConfig> {
-}
-/**
- * UseReact decorator.
- *
- * UseReact is a class decorator that allows you to use React components in your Stone application.
- * The decorator is used to define the React configuration for the class.
- *
- * @param options - UseReactOptions
- * @returns ClassDecorator
- */
-declare const UseReact: <T extends ClassType = ClassType>(options?: UseReactOptions) => ClassDecorator;
-
-/**
- * Custom error for react operations.
- */
-declare class UseReactError extends InitializationError {
-    constructor(message: string, options?: ErrorOptions);
-}
-
 /**
  * Blueprint middleware to dynamically set lifecycle hooks for react.
  *
@@ -1354,22 +1307,6 @@ declare class UseReactError extends InitializationError {
  * ```
  */
 declare const SetUseReactHooksMiddleware: (context: BlueprintContext<IBlueprint, ClassType>, next: NextMiddleware<BlueprintContext<IBlueprint, ClassType>, IBlueprint>) => Promiseable<IBlueprint>;
-/**
- * Blueprint middleware to set BrowserResponseMiddleware for the Browser adapter.
- *
- * The MetaBrowserResponseMiddleware is an adapter middleware and is useful
- * for handling outgoing responses and rendering them in the browser.
- *
- * @param context - The configuration context containing modules and blueprint.
- * @param next - The next pipeline function to continue processing.
- * @returns The updated blueprint or a promise resolving to it.
- *
- * @example
- * ```typescript
- * SetBrowserResponseMiddlewareMiddleware(context, next)
- * ```
- */
-declare const SetBrowserResponseMiddlewareMiddleware: (context: BlueprintContext<IBlueprint, ClassType>, next: NextMiddleware<BlueprintContext<IBlueprint, ClassType>, IBlueprint>) => Promise<IBlueprint>;
 /**
  * Blueprint middleware to process and register kernel error page definitions from modules.
  *
@@ -1384,7 +1321,7 @@ declare const SetBrowserResponseMiddlewareMiddleware: (context: BlueprintContext
  */
 declare const SetReactKernelErrorPageMiddleware: (context: BlueprintContext<IBlueprint, ClassType>, next: NextMiddleware<BlueprintContext<IBlueprint, ClassType>, IBlueprint>) => Promiseable<IBlueprint>;
 /**
- * Blueprint middleware to process and register adapter error page definitions from modules.
+ * Blueprint middleware to process and register route definitions from modules.
  *
  * @param context - The configuration context containing modules and blueprint.
  * @param next - The next pipeline function to continue processing.
@@ -1392,12 +1329,12 @@ declare const SetReactKernelErrorPageMiddleware: (context: BlueprintContext<IBlu
  *
  * @example
  * ```typescript
- * SetReactAdapterErrorPageMiddleware(context, next)
+ * SetReactRouteDefinitionsMiddleware(context, next)
  * ```
  */
-declare const SetReactAdapterErrorPageMiddleware: (context: BlueprintContext<IBlueprint, ClassType>, next: NextMiddleware<BlueprintContext<IBlueprint, ClassType>, IBlueprint>) => Promiseable<IBlueprint>;
+declare const SetReactRouteDefinitionsMiddleware: (context: BlueprintContext<IBlueprint, ClassType>, next: NextMiddleware<BlueprintContext<IBlueprint, ClassType>, IBlueprint>) => Promiseable<IBlueprint>;
 /**
- * Blueprint middleware to set StaticFileMiddleware for SSR adapter.
+ * Blueprint middleware to process and register layout definitions from modules.
  *
  * @param context - The configuration context containing modules and blueprint.
  * @param next - The next pipeline function to continue processing.
@@ -1405,38 +1342,110 @@ declare const SetReactAdapterErrorPageMiddleware: (context: BlueprintContext<IBl
  *
  * @example
  * ```typescript
- * SetSSRStaticFileMiddleware(context, next)
+ * SetReactPageLayoutMiddleware(context, next)
  * ```
  */
-declare const SetSSRStaticFileMiddleware: (context: BlueprintContext<IBlueprint, ClassType>, next: NextMiddleware<BlueprintContext<IBlueprint, ClassType>, IBlueprint>) => Promise<IBlueprint>;
+declare const SetReactPageLayoutMiddleware: (context: BlueprintContext<IBlueprint, ClassType>, next: NextMiddleware<BlueprintContext<IBlueprint, ClassType>, IBlueprint>) => Promiseable<IBlueprint>;
 /**
- * Blueprint middleware to set CompressionMiddleware for SSR adapter.
+ * Blueprint middleware to set the UseReact as the main event handler for the application.
+ *
+ * Set as fallback event handler if none of the other event handlers are registered.
  *
  * @param context - The configuration context containing modules and blueprint.
- * @param next - The next pipeline function to continue processing.
- * @returns The updated blueprint or a promise resolving to it.
+ * @param next - The next function in the pipeline.
+ * @returns The updated blueprint.
  *
  * @example
  * ```typescript
- * SetSSRCompressionMiddleware(context, next)
+ * SetUseReactEventHandlerMiddleware({ modules, blueprint }, next);
  * ```
  */
-declare const SetSSRCompressionMiddleware: (context: BlueprintContext<IBlueprint, ClassType>, next: NextMiddleware<BlueprintContext<IBlueprint, ClassType>, IBlueprint>) => Promise<IBlueprint>;
+declare function SetUseReactEventHandlerMiddleware(context: BlueprintContext<IBlueprint, ClassType>, next: NextMiddleware<BlueprintContext<IBlueprint, ClassType>, IBlueprint>): Promise<IBlueprint>;
+
 /**
- * Blueprint middleware to process and register route definitions from modules.
+ * Constants are defined here to prevent Circular dependency between modules
+ * This pattern must be applied to all Stone libraries or third party libraries.
+ */
+/**
+ * A unique symbol key to mark classes as React Page component.
+ */
+declare const REACT_PAGE_KEY: unique symbol;
+/**
+ * A unique symbol key to mark classes as React Page layout component.
+ */
+declare const REACT_PAGE_LAYOUT_KEY: unique symbol;
+/**
+ * A unique symbol key to mark classes as React Error handler component.
+ */
+declare const REACT_ERROR_PAGE_KEY: unique symbol;
+/**
+ * A unique symbol key to mark classes as React Adapter Error handler component.
+ */
+declare const REACT_ADAPTER_ERROR_PAGE_KEY: unique symbol;
+/**
+ * A unique symbol key to mark classes as React Stone application entry point.
+ */
+declare const STONE_REACT_APP_KEY: unique symbol;
+
+/**
+ * Custom error for react operations.
+ */
+declare class UseReactError extends InitializationError {
+    constructor(message: string, options?: ErrorOptions);
+}
+
+/**
+ * UseReactServerErrorHandler options.
+ */
+interface UseReactServerErrorHandlerOptions {
+    logger: ILogger;
+    blueprint: IBlueprint;
+}
+/**
+ * Class representing an UseReactServerErrorHandler.
  *
- * @param context - The configuration context containing modules and blueprint.
- * @param next - The next pipeline function to continue processing.
- * @returns The updated blueprint or a promise resolving to it.
+ * Adapter level error handler for React applications.
+ */
+declare class UseReactServerErrorHandler implements IAdapterErrorHandler<unknown, unknown, unknown> {
+    private readonly logger;
+    private readonly blueprint;
+    /**
+     * Create an UseReactServerErrorHandler.
+     *
+     * @param options - UseReactServerErrorHandler options.
+     */
+    constructor({ blueprint }: UseReactServerErrorHandlerOptions);
+    /**
+     * Handle an error.
+     *
+     * @param error - The error to handle.
+     * @param context - The context of the adapter.
+     * @returns The raw response.
+     */
+    handle(error: any, context: AdapterErrorContext<unknown, unknown, unknown>): Promise<AdapterEventBuilderType<unknown>>;
+    /**
+     * Get the error body.
+     *
+     * @param error - The error to handle.
+     * @returns The error body.
+    */
+    private getErrorBody;
+}
+
+/**
+ * Sets the error handler for the React adapter and registers error pages.
  *
- * @example
- * ```typescript
- * SetReactRouteDefinitionsMiddleware(context, next)
- * ```
+ * @param errorHandler - The error handler to set for the React adapter.
+ * @param context - The blueprint context containing modules and blueprint.
+ * @returns The updated blueprint context with the error handler and error pages set.
  */
-declare const SetReactRouteDefinitionsMiddleware: (context: BlueprintContext<IBlueprint, ClassType>, next: NextMiddleware<BlueprintContext<IBlueprint, ClassType>, IBlueprint>) => Promiseable<IBlueprint>;
+declare function setUseReactAdapterErrorHandler(errorHandler: typeof UseReactServerErrorHandler | typeof UseReactBrowserErrorHandler, context: BlueprintContext<IBlueprint, ClassType>): BlueprintContext<IBlueprint, ClassType>;
+
 /**
- * Blueprint middleware to process and register layout definitions from modules.
+ * Blueprint middleware to set BrowserResponseMiddleware for the Browser adapter.
+ *
+ * The MetaBrowserResponseMiddleware is an adapter middleware and is useful
+ * for handling outgoing responses and rendering them in the browser.
  *
  * @param context - The configuration context containing modules and blueprint.
  * @param next - The next pipeline function to continue processing.
@@ -1444,32 +1453,30 @@ declare const SetReactRouteDefinitionsMiddleware: (context: BlueprintContext<IBl
  *
  * @example
  * ```typescript
- * SetReactPageLayoutMiddleware(context, next)
+ * SetBrowserResponseMiddlewareMiddleware(context, next)
  * ```
  */
-declare const SetReactPageLayoutMiddleware: (context: BlueprintContext<IBlueprint, ClassType>, next: NextMiddleware<BlueprintContext<IBlueprint, ClassType>, IBlueprint>) => Promiseable<IBlueprint>;
+declare const SetBrowserResponseMiddlewareMiddleware: (context: BlueprintContext<IBlueprint, ClassType>, next: NextMiddleware<BlueprintContext<IBlueprint, ClassType>, IBlueprint>) => Promise<IBlueprint>;
 /**
- * Blueprint middleware to set the UseReact as the main event handler for the application.
- *
- * Set as fallback event handler if none of the other event handlers are registered.
+ * Blueprint middleware to process and register adapter error page definitions from modules.
  *
  * @param context - The configuration context containing modules and blueprint.
- * @param next - The next function in the pipeline.
- * @returns The updated blueprint.
+ * @param next - The next pipeline function to continue processing.
+ * @returns The updated blueprint or a promise resolving to it.
  *
  * @example
  * ```typescript
- * SetUseReactEventHandlerMiddleware({ modules, blueprint }, next);
+ * SetReactAdapterErrorPageMiddleware(context, next)
  * ```
  */
-declare function SetUseReactEventHandlerMiddleware(context: BlueprintContext<IBlueprint, ClassType>, next: NextMiddleware<BlueprintContext<IBlueprint, ClassType>, IBlueprint>): Promise<IBlueprint>;
+declare const SetReactAdapterErrorPageMiddleware: (context: BlueprintContext<IBlueprint, ClassType>, next: NextMiddleware<BlueprintContext<IBlueprint, ClassType>, IBlueprint>) => Promiseable<IBlueprint>;
 /**
  * Configuration for react processing middleware.
  *
  * This array defines a list of middleware pipes, each with a `pipe` function and a `priority`.
  * These pipes are executed in the order of their priority values, with lower values running first.
  */
-declare const metaUseReactBlueprintMiddleware: Array<MetaMiddleware<BlueprintContext<IBlueprint, ClassType>, IBlueprint>>;
+declare const metaBrowserUseReactBlueprintMiddleware: Array<MetaMiddleware<BlueprintContext<IBlueprint, ClassType>, IBlueprint>>;
 
 /**
  * Adapter Middleware for handling outgoing responses and rendering them in the browser.
@@ -1538,29 +1545,27 @@ declare const MetaBrowserResponseMiddleware: {
 };
 
 /**
- * Constants are defined here to prevent Circular dependency between modules
- * This pattern must be applied to all Stone libraries or third party libraries.
- */
-/**
- * A unique symbol key to mark classes as React Page component.
- */
-declare const REACT_PAGE_KEY: unique symbol;
-/**
- * A unique symbol key to mark classes as React Page layout component.
- */
-declare const REACT_PAGE_LAYOUT_KEY: unique symbol;
-/**
- * A unique symbol key to mark classes as React Error handler component.
+ * UseReact decorator options.
  */
-declare const REACT_ERROR_PAGE_KEY: unique symbol;
+interface UseReactOptions extends Partial<UseReactConfig> {
+}
 /**
- * A unique symbol key to mark classes as React Adapter Error handler component.
+ * UseReact decorator.
+ *
+ * UseReact is a class decorator that allows you to use React components in your Stone application.
+ * The decorator is used to define the React configuration for the class.
+ *
+ * @param options - UseReactOptions
+ * @returns ClassDecorator
  */
-declare const REACT_ADAPTER_ERROR_PAGE_KEY: unique symbol;
+declare const UseReact: <T extends ClassType = ClassType>(options?: UseReactOptions) => ClassDecorator;
+
 /**
- * A unique symbol key to mark classes as React Stone application entry point.
+ * Default blueprint for a React-based Stone.js application.
+ *
+ * - Defines middleware, lifecycle hooks, and the default HTML template path.
  */
-declare const STONE_REACT_APP_KEY: unique symbol;
+declare const useReactBlueprint: UseReactBlueprint;
 
-export { AdapterErrorPage, BrowserResponseMiddleware, ErrorPage, Hook, MetaBrowserResponseMiddleware, MetaReactRuntime, MetaUseReactServiceProvider, Page, PageLayout, PageStatus, REACT_ADAPTER_ERROR_PAGE_KEY, REACT_ERROR_PAGE_KEY, REACT_PAGE_KEY, REACT_PAGE_LAYOUT_KEY, ReactRuntime, STONE_DOM_ATTR, STONE_PAGE_EVENT_OUTLET, STONE_REACT_APP_KEY, STONE_SNAPSHOT, SetBrowserResponseMiddlewareMiddleware, SetReactAdapterErrorPageMiddleware, SetReactKernelErrorPageMiddleware, SetReactPageLayoutMiddleware, SetReactRouteDefinitionsMiddleware, SetSSRCompressionMiddleware, SetSSRStaticFileMiddleware, SetUseReactEventHandlerMiddleware, SetUseReactHooksMiddleware, Snapshot, StoneClient, StoneContext, StoneError, StoneLink, StoneOutlet, StonePage, StoneServer, UseReact, UseReactBrowserErrorHandler, UseReactError, UseReactEventHandler, UseReactKernelErrorHandler, UseReactServerErrorHandler, UseReactServiceProvider, applyHeadContextToDom, applyHeadContextToHtmlString, applyMeta, buildAdapterErrorComponent, buildAppComponent, buildLayoutComponent, buildPageComponent, defineAdapterErrorPage, defineErrorPage, definePage, definePageLayout, defineStoneReactApp, executeHandler, executeHooks, getAppRootElement, getBrowserContent, getResponseSnapshot, getServerContent, htmlTemplate, hydrateReactApp, isClient, isSSR, isServer, metaUseReactBlueprintMiddleware, onPreparingResponse, prepareErrorPage, prepareFallbackErrorPage, preparePage, reactRedirectResponse, reactResponse, renderReactApp, renderStoneSnapshot, resolveComponent, resolveLazyComponent, snapshotResponse, useReactBlueprint };
-export type { AdapterErrorPageClass, AdapterErrorPageOptions, AdapterErrorPageRenderContext, AdapterErrorPageType, AdapterPageLayoutRenderContext, BrowserResponseContent, ErrorPageClass, ErrorPageHeadContext, ErrorPageOptions, ErrorPageRenderContext, ErrorPageType, FactoryAdapterErrorPage, FactoryErrorPage, FactoryPage, FactoryPageLayout, HeadContext, HeadersType, HookName, IAdapterErrorPage, IErrorPage, IPage, IPageLayout, IRoute, IRouter, ISnapshot, MetaAdapterErrorPage, MetaErrorPage, MetaPage, MetaPageLayout, OnPreparingResponseOptions, PageClass, PageHeadContext, PageLayoutClass, PageLayoutOptions, PageLayoutRenderContext, PageLayoutType, PageOptions, PageRenderContext, PageType, ReactBrowserAdapterContext, ReactIncomingEvent, ReactIncomingEventOptions, ReactLifecycleHookType, ReactOutgoingResponse, ReactOutgoingResponseOptions, ReactRuntimeOptions, ResponseSnapshotType, StoneContextType, StoneLinkOptions, StoneOutletOptions, UseReactAppConfig, UseReactBlueprint, UseReactBrowserErrorHandlerOptions, UseReactConfig, UseReactErrorResponseType, UseReactHookListener, UseReactHookListenerContext, UseReactHookName, UseReactHookType, UseReactOptions, UseReactServerErrorHandlerOptions, UseReactServiceProviderOptions };
+export { AdapterErrorPage, BrowserResponseMiddleware, ErrorPage, Hook, MetaBrowserResponseMiddleware, MetaReactRuntime, MetaUseReactServiceProvider, Page, PageLayout, PageStatus, REACT_ADAPTER_ERROR_PAGE_KEY, REACT_ERROR_PAGE_KEY, REACT_PAGE_KEY, REACT_PAGE_LAYOUT_KEY, ReactRuntime, STONE_DOM_ATTR, STONE_PAGE_EVENT_OUTLET, STONE_REACT_APP_KEY, STONE_SNAPSHOT, SetBrowserResponseMiddlewareMiddleware, SetReactAdapterErrorPageMiddleware, SetReactKernelErrorPageMiddleware, SetReactPageLayoutMiddleware, SetReactRouteDefinitionsMiddleware, SetUseReactEventHandlerMiddleware, SetUseReactHooksMiddleware, Snapshot, StoneClient, StoneContext, StoneError, StoneLink, StoneOutlet, StonePage, StoneServer, UseReact, UseReactBrowserErrorHandler, UseReactError, UseReactEventHandler, UseReactKernelErrorHandler, UseReactServiceProvider, applyHeadContextToDom, applyHeadContextToHtmlString, applyMeta, buildAdapterErrorComponent, buildAppComponent, buildLayoutComponent, buildPageComponent, defineAdapterErrorPage, defineErrorPage, definePage, definePageLayout, defineStoneReactApp, executeHandler, executeHooks, getAppRootElement, getBrowserContent, getResponseSnapshot, getServerContent, htmlTemplate, hydrateReactApp, internalUseReactBlueprint, isClient, isSSR, isServer, metaBrowserUseReactBlueprintMiddleware, onPreparingResponse, prepareErrorPage, prepareFallbackErrorPage, preparePage, reactRedirectResponse, reactResponse, renderReactApp, renderStoneSnapshot, resolveComponent, resolveLazyComponent, setUseReactAdapterErrorHandler, snapshotResponse, useReactBlueprint };
+export type { AdapterErrorPageClass, AdapterErrorPageOptions, AdapterErrorPageRenderContext, AdapterErrorPageType, AdapterPageLayoutRenderContext, BrowserResponseContent, ErrorPageClass, ErrorPageHeadContext, ErrorPageOptions, ErrorPageRenderContext, ErrorPageType, FactoryAdapterErrorPage, FactoryErrorPage, FactoryPage, FactoryPageLayout, HeadContext, HeadersType, HookName, IAdapterErrorPage, IErrorPage, IPage, IPageLayout, IRoute, IRouter, ISnapshot, MetaAdapterErrorPage, MetaErrorPage, MetaPage, MetaPageLayout, OnPreparingResponseOptions, PageClass, PageHeadContext, PageLayoutClass, PageLayoutOptions, PageLayoutRenderContext, PageLayoutType, PageOptions, PageRenderContext, PageType, ReactBrowserAdapterContext, ReactIncomingEvent, ReactIncomingEventOptions, ReactLifecycleHookType, ReactOutgoingResponse, ReactOutgoingResponseOptions, ReactRedirectResponseOptions, ReactResponseOptions, ReactRuntimeOptions, ResponseSnapshotType, StoneContextType, StoneLinkOptions, StoneOutletOptions, UseReactAppConfig, UseReactBlueprint, UseReactBrowserErrorHandlerOptions, UseReactConfig, UseReactErrorResponseType, UseReactHookListener, UseReactHookListenerContext, UseReactHookName, UseReactHookType, UseReactOptions, UseReactServiceProviderOptions };