@nestjs-ssr/react 0.1.12 → 0.2.1

package/dist/index.js

@@ -4,7 +4,7 @@ var common = require('@nestjs/common');
 var core = require('@nestjs/core');
 var fs = require('fs');
 var path = require('path');
-var serialize = require('serialize-javascript');
+var devalue = require('devalue');
 var escapeHtml = require('escape-html');
 var server = require('react-dom/server');
 var react = require('react');
@@ -12,7 +12,6 @@ var operators = require('rxjs/operators');
 
 function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
 
-var serialize__default = /*#__PURE__*/_interopDefault(serialize);
 var escapeHtml__default = /*#__PURE__*/_interopDefault(escapeHtml);
 
 var __defProp = Object.defineProperty;
@@ -105,21 +104,20 @@ exports.TemplateParserService = class TemplateParserService {
   /**
   * Build inline script that provides initial state to the client
   *
-  * Safely serializes data using serialize-javascript to avoid XSS vulnerabilities.
-  * This library handles all edge cases including escaping dangerous characters,
-  * functions, dates, regexes, and prevents prototype pollution.
+  * Safely serializes data using devalue to avoid XSS vulnerabilities.
+  * Devalue is designed specifically for SSR, handling complex types safely
+  * while being faster and more secure than alternatives.
   */
-  buildInlineScripts(data, context, componentName) {
+  buildInlineScripts(data, context, componentName, layouts) {
+    const layoutMetadata = layouts ? layouts.map((l) => ({
+      name: l.layout.displayName || l.layout.name || "default",
+      props: l.props
+    })) : [];
     return `<script>
-window.__INITIAL_STATE__ = ${serialize__default.default(data, {
-      isJSON: true
-    })};
-window.__CONTEXT__ = ${serialize__default.default(context, {
-      isJSON: true
-    })};
-window.__COMPONENT_NAME__ = ${serialize__default.default(componentName, {
-      isJSON: true
-    })};
+window.__INITIAL_STATE__ = ${devalue.uneval(data)};
+window.__CONTEXT__ = ${devalue.uneval(context)};
+window.__COMPONENT_NAME__ = ${devalue.uneval(componentName)};
+window.__LAYOUTS__ = ${devalue.uneval(layoutMetadata)};
 </script>`;
   }
   /**
@@ -428,12 +426,14 @@ exports.RenderService = class _RenderService {
   isDevelopment;
   ssrMode;
   entryServerPath;
-  constructor(templateParser, streamingErrorHandler, ssrMode, defaultHead) {
+  rootLayout = void 0;
+  rootLayoutChecked = false;
+  constructor(templateParser, streamingErrorHandler, ssrMode, defaultHead, customTemplate) {
     this.templateParser = templateParser;
     this.streamingErrorHandler = streamingErrorHandler;
     this.defaultHead = defaultHead;
     this.isDevelopment = process.env.NODE_ENV !== "production";
-    this.ssrMode = ssrMode || process.env.SSR_MODE || "string";
+    this.ssrMode = ssrMode || process.env.SSR_MODE || "stream";
     const absoluteServerPath = path.join(__dirname, "/templates/entry-server.tsx");
     const relativeServerPath = path.relative(process.cwd(), absoluteServerPath);
     if (relativeServerPath.startsWith("..")) {
@@ -441,36 +441,54 @@ exports.RenderService = class _RenderService {
     } else {
       this.entryServerPath = "/" + relativeServerPath.replace(/\\/g, "/");
     }
-    let templatePath;
-    if (this.isDevelopment) {
-      const packageTemplatePaths = [
-        path.join(__dirname, "../templates/index.html"),
-        path.join(__dirname, "../src/templates/index.html"),
-        path.join(__dirname, "../../src/templates/index.html")
-      ];
-      const localTemplatePath = path.join(process.cwd(), "src/views/index.html");
-      const foundPackageTemplate = packageTemplatePaths.find((p) => fs.existsSync(p));
-      if (foundPackageTemplate) {
-        templatePath = foundPackageTemplate;
-      } else if (fs.existsSync(localTemplatePath)) {
-        templatePath = localTemplatePath;
+    if (customTemplate) {
+      if (customTemplate.includes("<!DOCTYPE") || customTemplate.includes("<html")) {
+        this.template = customTemplate;
+        this.logger.log(`\u2713 Loaded custom template (inline)`);
       } else {
-        throw new Error(`Template file not found. Tried:
+        const customTemplatePath = customTemplate.startsWith("/") ? customTemplate : path.join(process.cwd(), customTemplate);
+        if (!fs.existsSync(customTemplatePath)) {
+          throw new Error(`Custom template file not found at ${customTemplatePath}`);
+        }
+        try {
+          this.template = fs.readFileSync(customTemplatePath, "utf-8");
+          this.logger.log(`\u2713 Loaded custom template from ${customTemplatePath}`);
+        } catch (error) {
+          throw new Error(`Failed to read custom template file at ${customTemplatePath}: ${error.message}`);
+        }
+      }
+    } else {
+      let templatePath;
+      if (this.isDevelopment) {
+        const packageTemplatePaths = [
+          path.join(__dirname, "../templates/index.html"),
+          path.join(__dirname, "../src/templates/index.html"),
+          path.join(__dirname, "../../src/templates/index.html")
+        ];
+        const localTemplatePath = path.join(process.cwd(), "src/views/index.html");
+        const foundPackageTemplate = packageTemplatePaths.find((p) => fs.existsSync(p));
+        if (foundPackageTemplate) {
+          templatePath = foundPackageTemplate;
+        } else if (fs.existsSync(localTemplatePath)) {
+          templatePath = localTemplatePath;
+        } else {
+          throw new Error(`Template file not found. Tried:
 ` + packageTemplatePaths.map((p) => `  - ${p} (package template)`).join("\n") + `
   - ${localTemplatePath} (local template)`);
+        }
+      } else {
+        templatePath = path.join(process.cwd(), "dist/client/index.html");
+        if (!fs.existsSync(templatePath)) {
+          throw new Error(`Template file not found at ${templatePath}. Make sure to run the build process first.`);
+        }
       }
-    } else {
-      templatePath = path.join(process.cwd(), "dist/client/index.html");
-      if (!fs.existsSync(templatePath)) {
-        throw new Error(`Template file not found at ${templatePath}. Make sure to run the build process first.`);
+      try {
+        this.template = fs.readFileSync(templatePath, "utf-8");
+        this.logger.log(`\u2713 Loaded template from ${templatePath}`);
+      } catch (error) {
+        throw new Error(`Failed to read template file at ${templatePath}: ${error.message}`);
       }
     }
-    try {
-      this.template = fs.readFileSync(templatePath, "utf-8");
-      this.logger.log(`\u2713 Loaded template from ${templatePath}`);
-    } catch (error) {
-      throw new Error(`Failed to read template file at ${templatePath}: ${error.message}`);
-    }
     if (!this.isDevelopment) {
       const manifestPath = path.join(process.cwd(), "dist/client/.vite/manifest.json");
       if (fs.existsSync(manifestPath)) {
@@ -490,6 +508,52 @@ exports.RenderService = class _RenderService {
     this.vite = vite;
   }
   /**
+  * Get the root layout component if it exists
+  * Auto-discovers layout files at conventional paths:
+  * - src/views/layout.tsx
+  * - src/views/layout/index.tsx
+  * - src/views/_layout.tsx
+  */
+  async getRootLayout() {
+    if (this.rootLayoutChecked) {
+      return this.rootLayout;
+    }
+    this.rootLayoutChecked = true;
+    const conventionalPaths = [
+      "src/views/layout.tsx",
+      "src/views/layout/index.tsx",
+      "src/views/_layout.tsx"
+    ];
+    try {
+      for (const path$1 of conventionalPaths) {
+        const absolutePath = path.join(process.cwd(), path$1);
+        if (!fs.existsSync(absolutePath)) {
+          continue;
+        }
+        this.logger.log(`\u2713 Found root layout at ${path$1}`);
+        if (this.vite) {
+          const layoutModule = await this.vite.ssrLoadModule("/" + path$1);
+          this.rootLayout = layoutModule.default;
+          return this.rootLayout;
+        } else {
+          const prodPath = path$1.replace("src/views", "dist/server/views").replace(".tsx", ".js");
+          const absoluteProdPath = path.join(process.cwd(), prodPath);
+          if (fs.existsSync(absoluteProdPath)) {
+            const layoutModule = await import(absoluteProdPath);
+            this.rootLayout = layoutModule.default;
+            return this.rootLayout;
+          }
+        }
+      }
+      this.rootLayout = null;
+      return null;
+    } catch (error) {
+      this.logger.warn(`\u26A0\uFE0F  Error loading root layout: ${error.message}`);
+      this.rootLayout = null;
+      return null;
+    }
+  }
+  /**
   * Main render method that routes to string or stream mode
   */
   async render(viewComponent, data = {}, res, head) {
@@ -551,20 +615,19 @@ exports.RenderService = class _RenderService {
           throw new Error("Server bundle not found in manifest. Run `pnpm build:server` to generate the server bundle.");
         }
       }
-      const { data: pageData, __context: context } = data;
+      const { data: pageData, __context: context, __layouts: layouts } = data;
       const appHtml = await renderModule.renderComponent(viewComponent, data);
       const componentName = viewComponent.displayName || viewComponent.name || "Component";
+      const layoutMetadata = layouts ? layouts.map((l) => ({
+        name: l.layout.displayName || l.layout.name || "default",
+        props: l.props
+      })) : [];
       const initialStateScript = `
         <script>
-          window.__INITIAL_STATE__ = ${serialize__default.default(pageData, {
-        isJSON: true
-      })};
-          window.__CONTEXT__ = ${serialize__default.default(context, {
-        isJSON: true
-      })};
-          window.__COMPONENT_NAME__ = ${serialize__default.default(componentName, {
-        isJSON: true
-      })};
+          window.__INITIAL_STATE__ = ${devalue.uneval(pageData)};
+          window.__CONTEXT__ = ${devalue.uneval(context)};
+          window.__COMPONENT_NAME__ = ${devalue.uneval(componentName)};
+          window.__LAYOUTS__ = ${devalue.uneval(layoutMetadata)};
         </script>
       `;
       let clientScript = "";
@@ -637,9 +700,9 @@ exports.RenderService = class _RenderService {
           throw new Error("Server bundle not found in manifest. Run `pnpm build:server` to generate the server bundle.");
         }
       }
-      const { data: pageData, __context: context } = data;
+      const { data: pageData, __context: context, __layouts: layouts } = data;
       const componentName = viewComponent.displayName || viewComponent.name || "Component";
-      const inlineScripts = this.templateParser.buildInlineScripts(pageData, context, componentName);
+      const inlineScripts = this.templateParser.buildInlineScripts(pageData, context, componentName, layouts);
       const clientScript = this.templateParser.getClientScriptTag(this.isDevelopment, this.manifest);
       const stylesheetTags = this.templateParser.getStylesheetTags(this.isDevelopment, this.manifest);
       const headTags = this.templateParser.buildHeadTags(head);
@@ -695,22 +758,38 @@ exports.RenderService = _ts_decorate3([
   _ts_param2(2, common.Inject("SSR_MODE")),
   _ts_param2(3, common.Optional()),
   _ts_param2(3, common.Inject("DEFAULT_HEAD")),
+  _ts_param2(4, common.Optional()),
+  _ts_param2(4, common.Inject("CUSTOM_TEMPLATE")),
   _ts_metadata2("design:type", Function),
   _ts_metadata2("design:paramtypes", [
     typeof exports.TemplateParserService === "undefined" ? Object : exports.TemplateParserService,
     typeof exports.StreamingErrorHandler === "undefined" ? Object : exports.StreamingErrorHandler,
     typeof SSRMode === "undefined" ? Object : SSRMode,
-    typeof HeadData === "undefined" ? Object : HeadData
+    typeof HeadData === "undefined" ? Object : HeadData,
+    String
   ])
 ], exports.RenderService);
 var RENDER_KEY = "render";
-function Render(component) {
+var RENDER_OPTIONS_KEY = "render_options";
+function Render(component, options) {
   return (target, propertyKey, descriptor) => {
     common.SetMetadata(RENDER_KEY, component)(target, propertyKey, descriptor);
+    if (options) {
+      common.SetMetadata(RENDER_OPTIONS_KEY, options)(target, propertyKey, descriptor);
+    }
   };
 }
 __name(Render, "Render");
-var ReactRender = Render;
+var LAYOUT_KEY = "layout";
+function Layout(layout, options) {
+  return (target) => {
+    common.SetMetadata(LAYOUT_KEY, {
+      layout,
+      options
+    })(target);
+  };
+}
+__name(Layout, "Layout");
 
 // src/render/render.interceptor.ts
 function _ts_decorate4(decorators, target, key, desc) {
@@ -724,6 +803,12 @@ function _ts_metadata3(k, v) {
   if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 }
 __name(_ts_metadata3, "_ts_metadata");
+function _ts_param3(paramIndex, decorator) {
+  return function(target, key) {
+    decorator(target, key, paramIndex);
+  };
+}
+__name(_ts_param3, "_ts_param");
 function isRenderResponse(data) {
   return data && typeof data === "object" && "props" in data;
 }
@@ -734,9 +819,60 @@ exports.RenderInterceptor = class RenderInterceptor {
   }
   reflector;
   renderService;
-  constructor(reflector, renderService) {
+  allowedHeaders;
+  allowedCookies;
+  constructor(reflector, renderService, allowedHeaders, allowedCookies) {
     this.reflector = reflector;
     this.renderService = renderService;
+    this.allowedHeaders = allowedHeaders;
+    this.allowedCookies = allowedCookies;
+  }
+  /**
+  * Resolve the layout hierarchy for a given route
+  * Hierarchy: Root Layout → Controller Layout → Method Layout → Page
+  *
+  * Props are merged in priority order:
+  * 1. Static props from @Layout decorator (base)
+  * 2. Static props from @Render decorator (override)
+  * 3. Dynamic props from controller return (final override)
+  */
+  async resolveLayoutChain(context, dynamicLayoutProps) {
+    const layouts = [];
+    const rootLayout = await this.renderService.getRootLayout();
+    if (rootLayout) {
+      layouts.push({
+        layout: rootLayout,
+        props: dynamicLayoutProps || {}
+      });
+    }
+    const controllerLayoutMeta = this.reflector.get(LAYOUT_KEY, context.getClass());
+    const renderOptions = this.reflector.get(RENDER_OPTIONS_KEY, context.getHandler());
+    if (renderOptions?.layout === null) {
+      return [];
+    } else if (renderOptions?.layout === false) {
+      return layouts;
+    }
+    if (controllerLayoutMeta) {
+      const mergedProps = {
+        ...controllerLayoutMeta.options?.props || {},
+        ...dynamicLayoutProps || {}
+      };
+      layouts.push({
+        layout: controllerLayoutMeta.layout,
+        props: mergedProps
+      });
+    }
+    if (renderOptions?.layout) {
+      const mergedProps = {
+        ...renderOptions.layoutProps || {},
+        ...dynamicLayoutProps || {}
+      };
+      layouts.push({
+        layout: renderOptions.layout,
+        props: mergedProps
+      });
+    }
+    return layouts;
   }
   intercept(context, next) {
     const viewPathOrComponent = this.reflector.get(RENDER_KEY, context.getHandler());
@@ -752,16 +888,36 @@ exports.RenderInterceptor = class RenderInterceptor {
         path: request.path,
         query: request.query,
         params: request.params,
-        userAgent: request.headers["user-agent"],
-        acceptLanguage: request.headers["accept-language"],
-        referer: request.headers.referer
+        method: request.method
       };
+      if (this.allowedHeaders?.length) {
+        for (const headerName of this.allowedHeaders) {
+          const value = request.headers[headerName.toLowerCase()];
+          if (value) {
+            renderContext[headerName] = Array.isArray(value) ? value.join(", ") : value;
+          }
+        }
+      }
+      if (this.allowedCookies?.length && request.cookies) {
+        const cookies = {};
+        for (const cookieName of this.allowedCookies) {
+          const value = request.cookies[cookieName];
+          if (value !== void 0) {
+            cookies[cookieName] = value;
+          }
+        }
+        if (Object.keys(cookies).length > 0) {
+          renderContext.cookies = cookies;
+        }
+      }
       const renderResponse = isRenderResponse(data) ? data : {
         props: data
       };
+      const layoutChain = await this.resolveLayoutChain(context, renderResponse.layoutProps);
       const fullData = {
         data: renderResponse.props,
-        __context: renderContext
+        __context: renderContext,
+        __layouts: layoutChain
       };
       try {
         const html = await this.renderService.render(viewPathOrComponent, fullData, response, renderResponse.head);
@@ -778,10 +934,16 @@ exports.RenderInterceptor = class RenderInterceptor {
 };
 exports.RenderInterceptor = _ts_decorate4([
   common.Injectable(),
+  _ts_param3(2, common.Optional()),
+  _ts_param3(2, common.Inject("ALLOWED_HEADERS")),
+  _ts_param3(3, common.Optional()),
+  _ts_param3(3, common.Inject("ALLOWED_COOKIES")),
   _ts_metadata3("design:type", Function),
   _ts_metadata3("design:paramtypes", [
     typeof core.Reflector === "undefined" ? Object : core.Reflector,
-    typeof exports.RenderService === "undefined" ? Object : exports.RenderService
+    typeof exports.RenderService === "undefined" ? Object : exports.RenderService,
+    Array,
+    Array
   ])
 ], exports.RenderInterceptor);
 function _ts_decorate5(decorators, target, key, desc) {
@@ -795,12 +957,12 @@ function _ts_metadata4(k, v) {
   if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 }
 __name(_ts_metadata4, "_ts_metadata");
-function _ts_param3(paramIndex, decorator) {
+function _ts_param4(paramIndex, decorator) {
   return function(target, key) {
     decorator(target, key, paramIndex);
   };
 }
-__name(_ts_param3, "_ts_param");
+__name(_ts_param4, "_ts_param");
 var ViteInitializerService = class _ViteInitializerService {
   static {
     __name(this, "ViteInitializerService");
@@ -916,8 +1078,8 @@ var ViteInitializerService = class _ViteInitializerService {
 };
 ViteInitializerService = _ts_decorate5([
   common.Injectable(),
-  _ts_param3(2, common.Optional()),
-  _ts_param3(2, common.Inject("VITE_CONFIG")),
+  _ts_param4(2, common.Optional()),
+  _ts_param4(2, common.Inject("VITE_CONFIG")),
   _ts_metadata4("design:type", Function),
   _ts_metadata4("design:paramtypes", [
     typeof exports.RenderService === "undefined" ? Object : exports.RenderService,
@@ -1010,6 +1172,20 @@ exports.RenderModule = class _RenderModule {
         useValue: config.defaultHead
       });
     }
+    if (config?.template) {
+      providers.push({
+        provide: "CUSTOM_TEMPLATE",
+        useValue: config.template
+      });
+    }
+    providers.push({
+      provide: "ALLOWED_HEADERS",
+      useValue: config?.allowedHeaders || []
+    });
+    providers.push({
+      provide: "ALLOWED_COOKIES",
+      useValue: config?.allowedCookies || []
+    });
     return {
       global: true,
       module: _RenderModule,
@@ -1102,6 +1278,30 @@ exports.RenderModule = class _RenderModule {
         inject: [
           "RENDER_CONFIG"
         ]
+      },
+      // Custom template provider - reads from config
+      {
+        provide: "CUSTOM_TEMPLATE",
+        useFactory: /* @__PURE__ */ __name((config) => config?.template, "useFactory"),
+        inject: [
+          "RENDER_CONFIG"
+        ]
+      },
+      // Allowed headers provider - reads from config
+      {
+        provide: "ALLOWED_HEADERS",
+        useFactory: /* @__PURE__ */ __name((config) => config?.allowedHeaders || [], "useFactory"),
+        inject: [
+          "RENDER_CONFIG"
+        ]
+      },
+      // Allowed cookies provider - reads from config
+      {
+        provide: "ALLOWED_COOKIES",
+        useFactory: /* @__PURE__ */ __name((config) => config?.allowedCookies || [], "useFactory"),
+        inject: [
+          "RENDER_CONFIG"
+        ]
       }
     ];
     return {
@@ -1138,32 +1338,203 @@ exports.RenderModule = _ts_decorate6([
   })
 ], exports.RenderModule);
 var PageContext = /* @__PURE__ */ react.createContext(null);
-function usePageContext() {
-  const context = react.useContext(PageContext);
-  if (!context) {
-    throw new Error("usePageContext must be used within PageContextProvider");
-  }
-  return context;
+function PageContextProvider({ context, children }) {
+  return /* @__PURE__ */ React.createElement(PageContext.Provider, {
+    value: context
+  }, children);
 }
-__name(usePageContext, "usePageContext");
-function useParams() {
-  return usePageContext().params;
-}
-__name(useParams, "useParams");
-function useQuery() {
-  return usePageContext().query;
-}
-__name(useQuery, "useQuery");
-function useUserAgent() {
-  return usePageContext().userAgent;
+__name(PageContextProvider, "PageContextProvider");
+function createSSRHooks() {
+  return {
+    /**
+    * Hook to access the full page context with your app's type.
+    * Contains URL metadata, headers, and any custom properties you've added.
+    */
+    usePageContext: /* @__PURE__ */ __name(() => {
+      const context = react.useContext(PageContext);
+      if (!context) {
+        throw new Error("usePageContext must be used within PageContextProvider");
+      }
+      return context;
+    }, "usePageContext"),
+    /**
+    * Hook to access route parameters.
+    *
+    * @example
+    * ```tsx
+    * // Route: /users/:id
+    * const params = useParams();
+    * console.log(params.id); // '123'
+    * ```
+    */
+    useParams: /* @__PURE__ */ __name(() => {
+      const context = react.useContext(PageContext);
+      if (!context) {
+        throw new Error("useParams must be used within PageContextProvider");
+      }
+      return context.params;
+    }, "useParams"),
+    /**
+    * Hook to access query string parameters.
+    *
+    * @example
+    * ```tsx
+    * // URL: /search?q=react&sort=date
+    * const query = useQuery();
+    * console.log(query.q);    // 'react'
+    * console.log(query.sort); // 'date'
+    * ```
+    */
+    useQuery: /* @__PURE__ */ __name(() => {
+      const context = react.useContext(PageContext);
+      if (!context) {
+        throw new Error("useQuery must be used within PageContextProvider");
+      }
+      return context.query;
+    }, "useQuery"),
+    /**
+    * Alias for usePageContext() with a more intuitive name.
+    * Returns the full request context with your app's type.
+    *
+    * @example
+    * ```tsx
+    * const request = useRequest();
+    * console.log(request.path);   // '/users/123'
+    * console.log(request.method); // 'GET'
+    * console.log(request.params); // { id: '123' }
+    * console.log(request.query);  // { search: 'foo' }
+    * ```
+    */
+    useRequest: /* @__PURE__ */ __name(() => {
+      const context = react.useContext(PageContext);
+      if (!context) {
+        throw new Error("useRequest must be used within PageContextProvider");
+      }
+      return context;
+    }, "useRequest"),
+    /**
+    * Hook to access headers configured via allowedHeaders.
+    * Returns all headers as a Record.
+    *
+    * Configure in module registration:
+    * ```typescript
+    * RenderModule.register({
+    *   allowedHeaders: ['user-agent', 'x-tenant-id', 'x-api-version']
+    * })
+    * ```
+    *
+    * @example
+    * ```tsx
+    * const headers = useHeaders();
+    * console.log(headers['user-agent']); // 'Mozilla/5.0...'
+    * console.log(headers['x-tenant-id']); // 'tenant-123'
+    * console.log(headers['x-api-version']); // 'v2'
+    * ```
+    */
+    useHeaders: /* @__PURE__ */ __name(() => {
+      const context = react.useContext(PageContext);
+      if (!context) {
+        throw new Error("useHeaders must be used within PageContextProvider");
+      }
+      const baseKeys = /* @__PURE__ */ new Set([
+        "url",
+        "path",
+        "query",
+        "params",
+        "method",
+        "cookies"
+      ]);
+      const headers = {};
+      for (const [key, value] of Object.entries(context)) {
+        if (!baseKeys.has(key) && typeof value === "string") {
+          headers[key] = value;
+        }
+      }
+      return headers;
+    }, "useHeaders"),
+    /**
+    * Hook to access a specific custom header by name.
+    * Returns undefined if the header is not configured or not present.
+    *
+    * @param name - The header name (as configured in allowedHeaders)
+    *
+    * @example
+    * ```tsx
+    * const tenantId = useHeader('x-tenant-id');
+    * if (tenantId) {
+    *   console.log(`Tenant: ${tenantId}`);
+    * }
+    * ```
+    */
+    useHeader: /* @__PURE__ */ __name((name) => {
+      const context = react.useContext(PageContext);
+      if (!context) {
+        throw new Error("useHeader must be used within PageContextProvider");
+      }
+      const value = context[name];
+      return typeof value === "string" ? value : void 0;
+    }, "useHeader"),
+    /**
+    * Hook to access cookies configured via allowedCookies.
+    * Returns all allowed cookies as a Record.
+    *
+    * Configure in module registration:
+    * ```typescript
+    * RenderModule.register({
+    *   allowedCookies: ['theme', 'locale', 'consent']
+    * })
+    * ```
+    *
+    * @example
+    * ```tsx
+    * const cookies = useCookies();
+    * console.log(cookies.theme);  // 'dark'
+    * console.log(cookies.locale); // 'en-US'
+    * ```
+    */
+    useCookies: /* @__PURE__ */ __name(() => {
+      const context = react.useContext(PageContext);
+      if (!context) {
+        throw new Error("useCookies must be used within PageContextProvider");
+      }
+      const cookies = context.cookies;
+      return typeof cookies === "object" && cookies !== null ? cookies : {};
+    }, "useCookies"),
+    /**
+    * Hook to access a specific cookie by name.
+    * Returns undefined if the cookie is not configured or not present.
+    *
+    * @param name - The cookie name (as configured in allowedCookies)
+    *
+    * @example
+    * ```tsx
+    * const theme = useCookie('theme');
+    * if (theme === 'dark') {
+    *   console.log('Dark mode enabled');
+    * }
+    * ```
+    */
+    useCookie: /* @__PURE__ */ __name((name) => {
+      const context = react.useContext(PageContext);
+      if (!context) {
+        throw new Error("useCookie must be used within PageContextProvider");
+      }
+      const contextObj = context;
+      const cookies = contextObj.cookies;
+      if (typeof cookies === "object" && cookies !== null && !Array.isArray(cookies)) {
+        const cookiesRecord = cookies;
+        const value = cookiesRecord[name];
+        return typeof value === "string" ? value : void 0;
+      }
+      return void 0;
+    }, "useCookie")
+  };
 }
-__name(useUserAgent, "useUserAgent");
+__name(createSSRHooks, "createSSRHooks");
 
 exports.ErrorPageDevelopment = ErrorPageDevelopment;
 exports.ErrorPageProduction = ErrorPageProduction;
-exports.ReactRender = ReactRender;
+exports.Layout = Layout;
+exports.PageContextProvider = PageContextProvider;
 exports.Render = Render;
-exports.usePageContext = usePageContext;
-exports.useParams = useParams;
-exports.useQuery = useQuery;
-exports.useUserAgent = useUserAgent;
+exports.createSSRHooks = createSSRHooks;