@stone-js/use-react 0.3.0 → 0.3.1

package/dist/index.js

@@ -1,4 +1,4 @@
-import { InitializationError, isEmpty, isNotEmpty, isMetaClassModule, isMetaFactoryModule, isObjectLikeModule, isFunction, isFunctionModule, mergeBlueprints, stoneBlueprint, classDecoratorLegacyWrapper, setMetadata, methodDecoratorLegacyWrapper, addMetadata, LIFECYCLE_HOOK_KEY, hasMetadata, getMetadata, isMatchedAdapter, Logger, addBlueprint } from '@stone-js/core';
+import { isNotEmpty, isEmpty, InitializationError, isMetaClassModule, isMetaFactoryModule, isObjectLikeModule, isFunction, isFunctionModule, classDecoratorLegacyWrapper, setMetadata, methodDecoratorLegacyWrapper, addMetadata, LIFECYCLE_HOOK_KEY, hasMetadata, getMetadata, isMatchedAdapter, mergeBlueprints, stoneBlueprint, Logger, addBlueprint } from '@stone-js/core';
 import { jsx, jsxs, Fragment } from 'react/jsx-runtime';
 import { renderToString } from 'react-dom/server';
 import { createContext, StrictMode, useContext, useMemo, useState, useEffect } from 'react';
@@ -7,58 +7,6 @@ import { Config } from '@stone-js/config';
 import { GET, NODE_CONSOLE_PLATFORM, Router, RouteEvent } from '@stone-js/router';
 import { RedirectResponse, OutgoingHttpResponse, MetaCompressionMiddleware, MetaStaticFileMiddleware } from '@stone-js/http-core';
 
-/**
- * Custom error for react operations.
- */
-class UseReactError extends InitializationError {
-    constructor(message, options) {
-        super(message, options);
-        this.name = 'UseReactError';
-    }
-}
-
-/**
- * A useReact event handler for processing incoming events
- * For single event handler.
- *
- * Multiple event handlers will be processed by the router.
- *
- * @template IncomingEventType - The type representing the incoming event.
- * @template OutgoingResponseType - The type representing the outgoing response.
- */
-class UseReactEventHandler {
-    blueprint;
-    /**
-     * Constructs a `UseReactEventHandler` instance.
-     *
-     * @param options - The UseReactEventHandler options including blueprint.
-     */
-    constructor({ blueprint }) {
-        this.blueprint = blueprint;
-    }
-    /**
-     * Handle an incoming event.
-     *
-     * @returns The outgoing response.
-     */
-    handle() {
-        return this.getComponentEventHandler();
-    }
-    /**
-     * Get the component event handler.
-     *
-     * @returns The component event handler.
-     * @throws {UseReactError} If the component event handler is missing.
-     */
-    getComponentEventHandler() {
-        const handler = this.blueprint.get('stone.useReact.componentEventHandler');
-        if (isEmpty(handler)) {
-            throw new UseReactError('The component event handler is missing.');
-        }
-        return handler;
-    }
-}
-
 /**
   * Stone DOM Attribute.
   */
@@ -321,6 +269,16 @@ const StoneError = () => {
     return (jsxs(Fragment, { children: [jsx("h1", { children: "An error occured" }), jsx("p", { children: "Sorry, something went wrong." })] }));
 };
 
+/**
+ * Custom error for react operations.
+ */
+class UseReactError extends InitializationError {
+    constructor(message, options) {
+        super(message, options);
+        this.name = 'UseReactError';
+    }
+}
+
 /**
  * Build the React application for the current route.
  * Or for the main handler if the route is not defined.
@@ -752,6 +710,48 @@ class ReactRuntime {
 */
 const MetaReactRuntime = { module: ReactRuntime, isClass: true, alias: 'reactRuntime', singleton: true };
 
+/**
+ * A useReact event handler for processing incoming events
+ * For single event handler.
+ *
+ * Multiple event handlers will be processed by the router.
+ *
+ * @template IncomingEventType - The type representing the incoming event.
+ * @template OutgoingResponseType - The type representing the outgoing response.
+ */
+class UseReactEventHandler {
+    blueprint;
+    /**
+     * Constructs a `UseReactEventHandler` instance.
+     *
+     * @param options - The UseReactEventHandler options including blueprint.
+     */
+    constructor({ blueprint }) {
+        this.blueprint = blueprint;
+    }
+    /**
+     * Handle an incoming event.
+     *
+     * @returns The outgoing response.
+     */
+    handle() {
+        return this.getComponentEventHandler();
+    }
+    /**
+     * Get the component event handler.
+     *
+     * @returns The component event handler.
+     * @throws {UseReactError} If the component event handler is missing.
+     */
+    getComponentEventHandler() {
+        const handler = this.blueprint.get('stone.useReact.componentEventHandler');
+        if (isEmpty(handler)) {
+            throw new UseReactError('The component event handler is missing.');
+        }
+        return handler;
+    }
+}
+
 /**
  * Class representing an UseReactUseReactKernelErrorHandler.
  *
@@ -913,230 +913,93 @@ class UseReactServiceProvider {
 const MetaUseReactServiceProvider = { module: UseReactServiceProvider, isClass: true };
 
 /**
- * Utility function to define an adapter error page.
- *
- * @param module - The adapter error page module.
- * @param options - Optional adapter error page options.
- * @returns The UseReactBlueprint.
+ * Constants are defined here to prevent Circular dependency between modules
+ * This pattern must be applied to all Stone libraries or third party libraries.
  */
-function defineAdapterErrorPage(module, options) {
-    const error = options?.error ?? 'default';
-    const adapterErrorPages = Object.fromEntries([error].flat().map((err) => [
-        err,
-        {
-            ...options,
-            module,
-            error: err,
-            isFactory: options?.isClass !== true
-        }
-    ]));
-    return {
-        stone: {
-            useReact: {
-                adapterErrorPages
-            }
-        }
-    };
-}
+/**
+ * A unique symbol key to mark classes as React Page component.
+ */
+const REACT_PAGE_KEY = Symbol.for('ReactPage');
+/**
+ * A unique symbol key to mark classes as React Page layout component.
+ */
+const REACT_PAGE_LAYOUT_KEY = Symbol.for('ReactPageLayout');
+/**
+ * A unique symbol key to mark classes as React Error handler component.
+ */
+const REACT_ERROR_PAGE_KEY = Symbol.for('ReactErrorPage');
+/**
+ * A unique symbol key to mark classes as React Adapter Error handler component.
+ */
+const REACT_ADAPTER_ERROR_PAGE_KEY = Symbol.for('ReactAdapterErrorPage');
+/**
+ * A unique symbol key to mark classes as React Stone application entry point.
+ */
+const STONE_REACT_APP_KEY = Symbol.for('StoneReactApp');
 
 /**
- * Default blueprint for a React-based Stone.js application.
+ * A class decorator for defining a class as a React Handler layout.
  *
- * - Defines middleware, lifecycle hooks, and the default HTML template path.
+ * @param options - Configuration options for the layout definition.
+ * @returns A method decorator to be applied to a class method.
+ *
+ * @example
+ * ```typescript
+ * import { AdapterErrorPage } from '@stone-js/use-react';
+ *
+ * @AdapterErrorPage({ error: 'UserNotFoundError' })
+ * class UserAdapterErrorPage {
+ *   render({ error }) {
+ *     return <h1>User name: {error.message}</h1>;
+ *   }
+ * }
+ * ```
  */
-const internalUseReactBlueprint = {
-    stone: {
-        useReact: {},
-        services: [MetaReactRuntime],
-        providers: [MetaUseReactServiceProvider]
-    }
+const AdapterErrorPage = (options) => {
+    return classDecoratorLegacyWrapper((_target, context) => {
+        setMetadata(context, REACT_ADAPTER_ERROR_PAGE_KEY, { ...options, isClass: true });
+    });
 };
 
 /**
- * Defines a Stone React app using a factory-based or class-based main handler.
+ * A class decorator for defining a class as a React Handler layout.
  *
- * @param moduleOrOptions - A factory function or class constructor for the main page.
- * @param optionsOrBlueprints - Optional application-level configuration.
- * @param maybeBlueprints - Additional blueprints to merge.
- * @returns A fully merged Stone blueprint.
+ * @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>;
+ *   }
+ * }
+ * ```
  */
-function defineStoneReactApp(moduleOrOptions = {}, optionsOrBlueprints, maybeBlueprints) {
-    let module;
-    let options = {};
-    let blueprints = [];
-    // Pattern: defineStoneReactApp(handler, options?, blueprints?)
-    if (isFunctionModule(moduleOrOptions)) {
-        module = moduleOrOptions;
-        if (isObjectLikeModule(optionsOrBlueprints)) {
-            options = optionsOrBlueprints;
-            blueprints = Array.isArray(maybeBlueprints) ? maybeBlueprints : [];
-        }
-    }
-    else if (isObjectLikeModule(moduleOrOptions)) { // Pattern: defineStoneReactApp(options, blueprints?)
-        options = moduleOrOptions;
-        blueprints = Array.isArray(optionsOrBlueprints) ? optionsOrBlueprints : [];
-    }
-    const stonePart = {
-        ...options,
-        useReact: {
-            ...options.useReact
-        }
-    };
-    if (isNotEmpty(module)) {
-        stonePart.useReact.componentEventHandler = {
-            module,
-            isComponent: true,
-            isClass: options.isClass,
-            isFactory: options.isClass !== true
-        };
-    }
-    return mergeBlueprints(stoneBlueprint, internalUseReactBlueprint, ...blueprints, { stone: stonePart });
-}
+const ErrorPage = (options) => {
+    return classDecoratorLegacyWrapper((_target, context) => {
+        setMetadata(context, REACT_ERROR_PAGE_KEY, { ...options, isClass: true });
+    });
+};
 
 /**
- * Utility function to define a page.
+ * Hook decorator to mark a method as a lifecycle hook
+ * And automatically add it to the global lifecycle hook registry.
  *
- * @param module - The EventHandler module.
- * @param options - Page definition options.
- * @returns The UseReactBlueprint.
- */
-function definePage(module, options) {
-    return {
-        stone: {
-            router: {
-                definitions: [
-                    {
-                        ...options,
-                        method: GET,
-                        methods: [],
-                        children: undefined,
-                        handler: {
-                            module,
-                            isComponent: true,
-                            layout: options?.layout,
-                            isClass: options?.isClass,
-                            isFactory: options?.isClass !== true
-                        }
-                    }
-                ]
-            }
-        }
-    };
-}
-/**
- * Utility function to define a page layout.
- *
- * @param module - The layout module.
- * @param options - Optional page layout definition options.
- * @returns The UseReactBlueprint.
- */
-function definePageLayout(module, options) {
-    const name = options?.name ?? 'default';
-    return {
-        stone: {
-            useReact: {
-                layout: {
-                    [name]: {
-                        module,
-                        isClass: options?.isClass,
-                        isFactory: options?.isClass !== true
-                    }
-                }
-            }
-        }
-    };
-}
-/**
- * Utility function to define an error page.
- *
- * @param module - The layout module.
- * @param options - Optional page layout definition options.
- * @returns The UseReactBlueprint.
- */
-function defineErrorPage(module, options) {
-    const error = options?.error ?? 'default';
-    const errorPages = Object.fromEntries([error].flat().map((err) => [
-        err,
-        {
-            ...options,
-            module,
-            error: err,
-            isFactory: options?.isClass !== true
-        }
-    ]));
-    return {
-        stone: {
-            useReact: {
-                errorPages
-            }
-        }
-    };
-}
-
-/**
- * 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.
- */
-const REACT_PAGE_KEY = Symbol.for('ReactPage');
-/**
- * A unique symbol key to mark classes as React Page layout component.
- */
-const REACT_PAGE_LAYOUT_KEY = Symbol.for('ReactPageLayout');
-/**
- * A unique symbol key to mark classes as React Error handler component.
- */
-const REACT_ERROR_PAGE_KEY = Symbol.for('ReactErrorPage');
-/**
- * A unique symbol key to mark classes as React Adapter Error handler component.
- */
-const REACT_ADAPTER_ERROR_PAGE_KEY = Symbol.for('ReactAdapterErrorPage');
-/**
- * A unique symbol key to mark classes as React Stone application entry point.
- */
-const STONE_REACT_APP_KEY = Symbol.for('StoneReactApp');
-
-/**
- * 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>;
- *   }
- * }
- * ```
- */
-const ErrorPage = (options) => {
-    return classDecoratorLegacyWrapper((_target, context) => {
-        setMetadata(context, REACT_ERROR_PAGE_KEY, { ...options, isClass: true });
-    });
-};
-
-/**
- * Hook decorator to mark a method as a lifecycle hook
- * And automatically add it to the global lifecycle hook registry.
- *
- * @example
- * ```typescript
- * class MyClass {
- *    // ...
- *    @Hook('onPreparingPage')
- *    onPreparingPage () {}
- * }
- * ```
- *
- * @param name - The name of the lifecycle hook.
- * @returns A class decorator function that sets the metadata using the provided options.
+ * @example
+ * ```typescript
+ * class MyClass {
+ *    // ...
+ *    @Hook('onPreparingPage')
+ *    onPreparingPage () {}
+ * }
+ * ```
+ *
+ * @param name - The name of the lifecycle hook.
+ * @returns A class decorator function that sets the metadata using the provided options.
  */
 const Hook = (name) => {
     return methodDecoratorLegacyWrapper((_target, context) => {
@@ -1169,26 +1032,31 @@ const PageLayout = (options) => {
 };
 
 /**
- * A class decorator for defining a class as a React Handler layout.
+ * Decorator to create a snapshot of the current data.
  *
- * @param options - Configuration options for the layout definition.
- * @returns A method decorator to be applied to a class method.
+ * @param name - The name of the snapshot.
+ * @returns A method decorator.
  *
  * @example
  * ```typescript
- * import { AdapterErrorPage } from '@stone-js/use-react';
+ * import { Service } from '@stone-js/core';
+ * import { Snapshot } from '@stone-js/use-react';
  *
- * @AdapterErrorPage({ error: 'UserNotFoundError' })
- * class UserAdapterErrorPage {
- *   render({ error }) {
- *     return <h1>User name: {error.message}</h1>;
+ * @Service({ alias: 'userService' })
+ * class UserService {
+ *   @Snapshot()
+ *   showProfile() {
+ *     return { name: 'John Doe' };
  *   }
  * }
  * ```
  */
-const AdapterErrorPage = (options) => {
-    return classDecoratorLegacyWrapper((_target, context) => {
-        setMetadata(context, REACT_ADAPTER_ERROR_PAGE_KEY, { ...options, isClass: true });
+const Snapshot = (name) => {
+    return methodDecoratorLegacyWrapper((target, context) => {
+        return async function (...args) {
+            name = name ?? `${String(Object.getPrototypeOf(this).constructor.name)}.${String(context.name)}`;
+            return await ReactRuntime.instance?.snapshot(name, () => target.apply(this, args));
+        };
     });
 };
 
@@ -1256,35 +1124,6 @@ const Page = (path, options = {}) => {
     });
 };
 
-/**
- * Decorator to create a snapshot of the current data.
- *
- * @param name - The name of the snapshot.
- * @returns A method decorator.
- *
- * @example
- * ```typescript
- * import { Service } from '@stone-js/core';
- * import { Snapshot } from '@stone-js/use-react';
- *
- * @Service({ alias: 'userService' })
- * class UserService {
- *   @Snapshot()
- *   showProfile() {
- *     return { name: 'John Doe' };
- *   }
- * }
- * ```
- */
-const Snapshot = (name) => {
-    return methodDecoratorLegacyWrapper((target, context) => {
-        return async function (...args) {
-            name = name ?? `${String(Object.getPrototypeOf(this).constructor.name)}.${String(context.name)}`;
-            return await ReactRuntime.instance?.snapshot(name, () => target.apply(this, args));
-        };
-    });
-};
-
 /**
  * Sets the error handler for the React adapter and registers error pages.
  *
@@ -1320,76 +1159,6 @@ function setUseReactAdapterErrorHandler(errorHandler, context) {
     return context;
 }
 
-/**
- * Create an UseReact response.
- *
- * @param options - The options for creating the response.
- * @returns The React response.
- */
-const reactResponse = (options) => {
-    if (isNotEmpty(options) &&
-        (isNotEmpty(options.url) ||
-            (isNotEmpty(options.content) && isNotEmpty(options.content.redirect)))) {
-        return reactRedirectResponse(options);
-    }
-    return OutgoingHttpResponse.create(options);
-};
-/**
- * Create an UseReact redirect response.
- *
- * @param options - The options for creating the response.
- * @returns The React redirect response.
- */
-const reactRedirectResponse = (options) => {
-    return RedirectResponse.create({ statusCode: 302, ...options });
-};
-
-/**
- * Class representing an UseReactServerErrorHandler.
- *
- * Adapter level error handler for React applications.
- */
-class UseReactServerErrorHandler {
-    logger;
-    blueprint;
-    /**
-     * Create an UseReactServerErrorHandler.
-     *
-     * @param options - UseReactServerErrorHandler options.
-     */
-    constructor({ blueprint }) {
-        this.blueprint = blueprint;
-        this.logger = Logger.getInstance();
-    }
-    /**
-     * Handle an error.
-     *
-     * @param error - The error to handle.
-     * @param context - The context of the adapter.
-     * @returns The raw response.
-     */
-    async handle(error, context) {
-        this.logger.error(error.message, { error });
-        return context
-            .rawResponseBuilder
-            .add('statusCode', error.statusCode ?? 500)
-            .add('headers', new Headers({ 'Content-Type': 'text/html' }))
-            .add('body', await this.getErrorBody(error, context));
-    }
-    /**
-     * Get the error body.
-     *
-     * @param error - The error to handle.
-     * @returns The error body.
-    */
-    async getErrorBody(error, context) {
-        const statusCode = error.statusCode ?? 500;
-        const template = htmlTemplate(this.blueprint);
-        const ClientApp = await buildAdapterErrorComponent(this.blueprint, context, statusCode, error);
-        return template.replace('<!--app-html-->', renderToString(ClientApp));
-    }
-}
-
 /**
  * Blueprint middleware to dynamically set lifecycle hooks for react.
  *
@@ -1521,6 +1290,237 @@ async function SetUseReactEventHandlerMiddleware(context, next) {
     return blueprint;
 }
 
+/**
+ * Default blueprint for a React-based Stone.js application.
+ *
+ * - Defines middleware, lifecycle hooks, and the default HTML template path.
+ */
+const internalUseReactBlueprint = {
+    stone: {
+        useReact: {},
+        services: [MetaReactRuntime],
+        providers: [MetaUseReactServiceProvider]
+    }
+};
+
+/**
+ * Utility function to define an adapter error page.
+ *
+ * @param module - The adapter error page module.
+ * @param options - Optional adapter error page options.
+ * @returns The UseReactBlueprint.
+ */
+function defineAdapterErrorPage(module, options) {
+    const error = options?.error ?? 'default';
+    const adapterErrorPages = Object.fromEntries([error].flat().map((err) => [
+        err,
+        {
+            ...options,
+            module,
+            error: err,
+            isFactory: options?.isClass !== true
+        }
+    ]));
+    return {
+        stone: {
+            useReact: {
+                adapterErrorPages
+            }
+        }
+    };
+}
+
+/**
+ * Defines a Stone React app using a factory-based or class-based main handler.
+ *
+ * @param moduleOrOptions - A factory function or class constructor for the main page.
+ * @param optionsOrBlueprints - Optional application-level configuration.
+ * @param maybeBlueprints - Additional blueprints to merge.
+ * @returns A fully merged Stone blueprint.
+ */
+function defineStoneReactApp(moduleOrOptions = {}, optionsOrBlueprints, maybeBlueprints) {
+    let module;
+    let options = {};
+    let blueprints = [];
+    // Pattern: defineStoneReactApp(handler, options?, blueprints?)
+    if (isFunctionModule(moduleOrOptions)) {
+        module = moduleOrOptions;
+        if (isObjectLikeModule(optionsOrBlueprints)) {
+            options = optionsOrBlueprints;
+            blueprints = Array.isArray(maybeBlueprints) ? maybeBlueprints : [];
+        }
+    }
+    else if (isObjectLikeModule(moduleOrOptions)) { // Pattern: defineStoneReactApp(options, blueprints?)
+        options = moduleOrOptions;
+        blueprints = Array.isArray(optionsOrBlueprints) ? optionsOrBlueprints : [];
+    }
+    const stonePart = {
+        ...options,
+        useReact: {
+            ...options.useReact
+        }
+    };
+    if (isNotEmpty(module)) {
+        stonePart.useReact.componentEventHandler = {
+            module,
+            isComponent: true,
+            isClass: options.isClass,
+            isFactory: options.isClass !== true
+        };
+    }
+    return mergeBlueprints(stoneBlueprint, internalUseReactBlueprint, ...blueprints, { stone: stonePart });
+}
+
+/**
+ * Utility function to define a page.
+ *
+ * @param module - The EventHandler module.
+ * @param options - Page definition options.
+ * @returns The UseReactBlueprint.
+ */
+function definePage(module, options) {
+    return {
+        stone: {
+            router: {
+                definitions: [
+                    {
+                        ...options,
+                        method: GET,
+                        methods: [],
+                        children: undefined,
+                        handler: {
+                            module,
+                            isComponent: true,
+                            layout: options?.layout,
+                            isClass: options?.isClass,
+                            isFactory: options?.isClass !== true
+                        }
+                    }
+                ]
+            }
+        }
+    };
+}
+/**
+ * Utility function to define a page layout.
+ *
+ * @param module - The layout module.
+ * @param options - Optional page layout definition options.
+ * @returns The UseReactBlueprint.
+ */
+function definePageLayout(module, options) {
+    const name = options?.name ?? 'default';
+    return {
+        stone: {
+            useReact: {
+                layout: {
+                    [name]: {
+                        module,
+                        isClass: options?.isClass,
+                        isFactory: options?.isClass !== true
+                    }
+                }
+            }
+        }
+    };
+}
+/**
+ * Utility function to define an error page.
+ *
+ * @param module - The layout module.
+ * @param options - Optional page layout definition options.
+ * @returns The UseReactBlueprint.
+ */
+function defineErrorPage(module, options) {
+    const error = options?.error ?? 'default';
+    const errorPages = Object.fromEntries([error].flat().map((err) => [
+        err,
+        {
+            ...options,
+            module,
+            error: err,
+            isFactory: options?.isClass !== true
+        }
+    ]));
+    return {
+        stone: {
+            useReact: {
+                errorPages
+            }
+        }
+    };
+}
+
+/**
+ * Create an UseReact response.
+ *
+ * @param options - The options for creating the response.
+ * @returns The React response.
+ */
+const reactResponse = (options) => {
+    if (isNotEmpty(options) &&
+        (isNotEmpty(options.url) ||
+            (isNotEmpty(options.content) && isNotEmpty(options.content.redirect)))) {
+        return reactRedirectResponse(options);
+    }
+    return OutgoingHttpResponse.create(options);
+};
+/**
+ * Create an UseReact redirect response.
+ *
+ * @param options - The options for creating the response.
+ * @returns The React redirect response.
+ */
+const reactRedirectResponse = (options) => {
+    return RedirectResponse.create({ statusCode: 302, ...options });
+};
+
+/**
+ * Class representing an UseReactServerErrorHandler.
+ *
+ * Adapter level error handler for React applications.
+ */
+class UseReactServerErrorHandler {
+    logger;
+    blueprint;
+    /**
+     * Create an UseReactServerErrorHandler.
+     *
+     * @param options - UseReactServerErrorHandler options.
+     */
+    constructor({ blueprint }) {
+        this.blueprint = blueprint;
+        this.logger = Logger.getInstance();
+    }
+    /**
+     * Handle an error.
+     *
+     * @param error - The error to handle.
+     * @param context - The context of the adapter.
+     * @returns The raw response.
+     */
+    async handle(error, context) {
+        this.logger.error(error.message, { error });
+        return context
+            .rawResponseBuilder
+            .add('statusCode', error.statusCode ?? 500)
+            .add('headers', new Headers({ 'Content-Type': 'text/html' }))
+            .add('body', await this.getErrorBody(error, context));
+    }
+    /**
+     * Get the error body.
+     *
+     * @param error - The error to handle.
+     * @returns The error body.
+    */
+    async getErrorBody(error, context) {
+        const statusCode = error.statusCode ?? 500;
+        const template = htmlTemplate(this.blueprint);
+        const ClientApp = await buildAdapterErrorComponent(this.blueprint, context, statusCode, error);
+        return template.replace('<!--app-html-->', renderToString(ClientApp));
+    }
+}
+
 /**
  * Blueprint middleware to process and register adapter error page definitions from modules.
  *