nukejs 0.0.16 → 0.0.17

package/dist/ssr.js

@@ -1,262 +0,0 @@
-import path from "path";
-import fs from "fs";
-import { createElement } from "react";
-import { pathToFileURL } from "url";
-import { tsImport } from "tsx/esm/api";
-import { log, getDebugLevel } from "./logger.js";
-import { matchRoute, findLayoutsForRoute } from "./router.js";
-import { findClientComponentsInTree } from "./component-analyzer.js";
-import { renderElementToHtml } from "./renderer.js";
-import { runWithRequestStore, normaliseHeaders, sanitiseHeaders } from "./request-store.js";
-import {
-  runWithHtmlStore,
-  resolveTitle
-} from "./html-store.js";
-async function wrapWithLayouts(pageElement, layoutPaths) {
-  let element = pageElement;
-  for (let i = layoutPaths.length - 1; i >= 0; i--) {
-    const { default: LayoutComponent } = await tsImport(
-      pathToFileURL(layoutPaths[i]).href,
-      { parentURL: import.meta.url }
-    );
-    element = createElement(LayoutComponent, { children: element });
-  }
-  return element;
-}
-function toClientDebugLevel(level) {
-  if (level === true) return "verbose";
-  if (level === "info") return "info";
-  if (level === "error") return "error";
-  return "silent";
-}
-function escapeAttr(str) {
-  return str.replace(/&/g, "&").replace(/"/g, """);
-}
-function renderAttrs(attrs) {
-  return Object.entries(attrs).filter(([, v]) => v !== void 0 && v !== false).map(([k, v]) => v === true ? k : `${k}="${escapeAttr(String(v))}"`).join(" ");
-}
-function openTag(tag, attrs) {
-  const str = renderAttrs(attrs);
-  return str ? `<${tag} ${str}>` : `<${tag}>`;
-}
-function metaKey(k) {
-  return k === "httpEquiv" ? "http-equiv" : k;
-}
-function linkKey(k) {
-  if (k === "hrefLang") return "hreflang";
-  if (k === "crossOrigin") return "crossorigin";
-  return k;
-}
-function renderMetaTag(tag) {
-  const attrs = {};
-  for (const [k, v] of Object.entries(tag)) if (v !== void 0) attrs[metaKey(k)] = v;
-  return `  <meta ${renderAttrs(attrs)} />`;
-}
-function renderLinkTag(tag) {
-  const attrs = {};
-  for (const [k, v] of Object.entries(tag)) if (v !== void 0) attrs[linkKey(k)] = v;
-  return `  <link ${renderAttrs(attrs)} />`;
-}
-function renderScriptTag(tag) {
-  const attrs = {
-    src: tag.src,
-    type: tag.type,
-    crossorigin: tag.crossOrigin,
-    integrity: tag.integrity,
-    defer: tag.defer,
-    async: tag.async,
-    nomodule: tag.noModule
-  };
-  const attrStr = renderAttrs(attrs);
-  const open = attrStr ? `<script ${attrStr}>` : "<script>";
-  return `  ${open}${tag.src ? "" : tag.content ?? ""}</script>`;
-}
-function renderStyleTag(tag) {
-  const media = tag.media ? ` media="${escapeAttr(tag.media)}"` : "";
-  return `  <style${media}>${tag.content ?? ""}</style>`;
-}
-function renderManagedHeadTags(store) {
-  const headScripts = store.script.filter((s) => (s.position ?? "head") === "head");
-  const tags = [
-    ...store.meta.map(renderMetaTag),
-    ...store.link.map(renderLinkTag),
-    ...store.style.map(renderStyleTag),
-    ...headScripts.map(renderScriptTag)
-  ];
-  if (tags.length === 0) return [];
-  return ["  <!--n-head-->", ...tags, "  <!--/n-head-->"];
-}
-function renderManagedBodyScripts(store) {
-  const bodyScripts = store.script.filter((s) => s.position === "body");
-  if (bodyScripts.length === 0) return [];
-  return ["  <!--n-body-scripts-->", ...bodyScripts.map(renderScriptTag), "  <!--/n-body-scripts-->"];
-}
-async function renderFile(filePath, params, url, pagesDir, isDev, res, req, statusCode, skipClientSSR) {
-  const cleanUrl = url.split("?")[0];
-  const searchParams = new URL(url, "http://localhost").searchParams;
-  const queryParams = {};
-  searchParams.forEach((_, k) => {
-    if (!(k in params)) {
-      const all = searchParams.getAll(k);
-      queryParams[k] = all.length > 1 ? all : all[0];
-    }
-  });
-  const mergedParams = { ...queryParams, ...params };
-  const rawHeaders = req?.headers ?? {};
-  const normHeaders = normaliseHeaders(rawHeaders);
-  const safeHeaders = sanitiseHeaders(rawHeaders);
-  const layoutPaths = findLayoutsForRoute(filePath, pagesDir);
-  const { default: PageComponent } = await tsImport(
-    pathToFileURL(filePath).href,
-    { parentURL: import.meta.url }
-  );
-  const wrappedElement = await wrapWithLayouts(
-    createElement(PageComponent, mergedParams),
-    layoutPaths
-  );
-  const registry = /* @__PURE__ */ new Map();
-  for (const [id, p] of findClientComponentsInTree(filePath, pagesDir))
-    registry.set(id, p);
-  for (const layoutPath of layoutPaths)
-    for (const [id, p] of findClientComponentsInTree(layoutPath, pagesDir))
-      registry.set(id, p);
-  const ctx = { registry, hydrated: /* @__PURE__ */ new Set(), skipClientSSR };
-  let appHtml = "";
-  const store = await runWithRequestStore(
-    {
-      url,
-      pathname: cleanUrl,
-      params,
-      query: queryParams,
-      headers: normHeaders
-    },
-    () => runWithHtmlStore(async () => {
-      appHtml = await renderElementToHtml(wrappedElement, ctx);
-    })
-  );
-  const pageTitle = resolveTitle(store.titleOps, "NukeJS");
-  const headLines = [
-    '  <meta charset="utf-8" />',
-    '  <meta name="viewport" content="width=device-width, initial-scale=1" />',
-    `  <title>${escapeAttr(pageTitle)}</title>`,
-    ...renderManagedHeadTags(store)
-  ];
-  const runtimeData = JSON.stringify({
-    hydrateIds: [...ctx.hydrated],
-    allIds: [...registry.keys()],
-    url,
-    params,
-    query: queryParams,
-    headers: safeHeaders,
-    debug: toClientDebugLevel(getDebugLevel())
-  }).replace(/</g, "\\u003c").replace(/>/g, "\\u003e").replace(/&/g, "\\u0026");
-  const bodyScriptLines = renderManagedBodyScripts(store);
-  const bodyScriptsHtml = bodyScriptLines.length > 0 ? "\n" + bodyScriptLines.join("\n") + "\n" : "";
-  const html = `<!DOCTYPE html>
-${openTag("html", store.htmlAttrs)}
-<head>
-${headLines.join("\n")}
-</head>
-${openTag("body", store.bodyAttrs)}
-  <div id="app">${appHtml}</div>
-
-  <script id="__n_data" type="application/json">${runtimeData}</script>
-
-  <script type="importmap">
-{
-  "imports": {
-    "react":             "/__react.js",
-    "react-dom/client":  "/__react.js",
-    "react/jsx-runtime": "/__react.js",
-    "nukejs":            "/__n.js"
-  }
-}
-  </script>
-
-  <script type="module">
-    await import('react');
-    const { initRuntime } = await import('nukejs');
-    const data = JSON.parse(document.getElementById('__n_data').textContent);
-    initRuntime(data);
-  </script>
-
-  ${isDev ? '<script type="module" src="/__hmr.js"></script>' : ""}
-${bodyScriptsHtml}</body>
-</html>`;
-  res.statusCode = statusCode;
-  res.setHeader("Content-Type", "text/html");
-  res.end(html);
-}
-function serializeError(err) {
-  if (err instanceof Error) {
-    const props = {
-      errorMessage: err.message
-    };
-    if (process.env.NODE_ENV !== "production" && err.stack)
-      props.errorStack = err.stack;
-    const status = err.status ?? err.statusCode;
-    if (status != null)
-      props.errorStatus = String(status);
-    return props;
-  }
-  return { errorMessage: String(err) };
-}
-async function tryRenderErrorPage(statusCode, pagesDir, res, isDev, req, error) {
-  const errorFile = path.join(pagesDir, `_${statusCode}.tsx`);
-  if (!fs.existsSync(errorFile)) return false;
-  const errorProps = error != null ? serializeError(error) : {};
-  try {
-    await renderFile(errorFile, errorProps, "/", pagesDir, isDev, res, req, statusCode, false);
-    return true;
-  } catch (err) {
-    log.error(`Error rendering _${statusCode}.tsx:`, err);
-    return false;
-  }
-}
-async function serverSideRender(url, res, pagesDir, isDev = false, req) {
-  const skipClientSSR = url.includes("__hmr=1");
-  const cleanUrl = url.split("?")[0];
-  const searchParams = new URL(url, "http://localhost").searchParams;
-  if (searchParams.has("__clientError")) {
-    const errorProps = {
-      errorMessage: searchParams.get("__clientError") ?? "Client error"
-    };
-    const stack = searchParams.get("__clientStack");
-    if (stack) errorProps.errorStack = stack;
-    const errorFile = path.join(pagesDir, "_500.tsx");
-    if (fs.existsSync(errorFile)) {
-      try {
-        await renderFile(errorFile, errorProps, url, pagesDir, isDev, res, req, 500, false);
-      } catch (err) {
-        log.error("Error rendering _500.tsx for client error:", err);
-        res.statusCode = 500;
-        res.end("Internal Server Error");
-      }
-    } else {
-      res.statusCode = 500;
-      res.end("Internal Server Error");
-    }
-    return;
-  }
-  const routeMatch = matchRoute(cleanUrl, pagesDir);
-  if (!routeMatch) {
-    log.verbose(`No route found for: ${url}`);
-    if (await tryRenderErrorPage(404, pagesDir, res, isDev, req)) return;
-    res.statusCode = 404;
-    res.end("Page not found");
-    return;
-  }
-  const { filePath, params, routePattern } = routeMatch;
-  log.verbose(`SSR ${cleanUrl} -> ${path.relative(process.cwd(), filePath)}`);
-  try {
-    await renderFile(filePath, params, url, pagesDir, isDev, res, req, 200, skipClientSSR);
-  } catch (err) {
-    log.error("SSR render error:", err);
-    if (await tryRenderErrorPage(500, pagesDir, res, isDev, req, err)) return;
-    res.statusCode = 500;
-    res.end("Internal Server Error");
-  }
-}
-export {
-  serverSideRender
-};

package/dist/store.d.ts

@@ -1,104 +0,0 @@
-/**
- * store.ts — NukeJS Client State Management
- *
- * Provides a lightweight, cross-boundary state system for "use client"
- * components.  The core problem it solves: NukeJS hydrates every client
- * component into its own independent React root (via hydrateRoot / createRoot),
- * so React Context cannot carry state across component boundaries.  Each
- * component's esbuild bundle is also a separate module instance, so a plain
- * module-level variable would not be shared between bundles.
- *
- * Solution: all store state lives in `window.__nukeStores`, a Map that persists
- * for the lifetime of the page regardless of how many times the store module
- * is evaluated.  Every bundle that imports `createStore('counter', …)` gets
- * a thin proxy object that reads from and writes to the same backing entry —
- * state is automatically shared across roots and bundles.
- *
- * API:
- *
- *   const cartStore = createStore('cart', { items: [], total: 0 });
- *
- *   // Inside any "use client" component on the same page:
- *   const items = useStore(cartStore, s => s.items);
- *   cartStore.setState(s => ({ ...s, items: [...s.items, newItem] }));
- *
- * The store is safe to import in server components — it detects the absence of
- * `window` and returns a lightweight no-op stub so SSR never throws.
- */
-type Listener = () => void;
-type Unsubscribe = () => void;
-type Updater<T> = T | ((prev: T) => T);
-/**
- * A NukeJS store handle.  Create it once at module scope; pass it into
- * `useStore()` inside any client component to subscribe.
- */
-export interface Store<T extends object> {
-    /** Returns the current state snapshot. */
-    getState(): T;
-    /**
-     * Updates the state and notifies every subscriber.
-     *
-     * Accepts a full replacement value or an updater function:
-     *   store.setState({ count: 0 })
-     *   store.setState(s => ({ ...s, count: s.count + 1 }))
-     */
-    setState(updater: Updater<T>): void;
-    /**
-     * Registers a change listener.  Returns an unsubscribe function.
-     * Compatible with `useSyncExternalStore`.
-     */
-    subscribe(listener: Listener): Unsubscribe;
-    /** The name this store is registered under in the global registry. */
-    readonly name: string;
-    /**
-     * The value passed to `createStore` as its second argument.
-     * Used internally as the server snapshot so `useSyncExternalStore` always
-     * reconciles against a value that matches the server-rendered HTML —
-     * the server never has mutations, so initial state is always what it renders.
-     */
-    readonly initialState: T;
-}
-interface StoreEntry<T> {
-    state: T;
-    listeners: Set<Listener>;
-}
-declare global {
-    interface Window {
-        __nukeStores?: Map<string, StoreEntry<any>>;
-    }
-}
-/**
- * Creates (or retrieves) a named store backed by the page-global registry.
- *
- * If a store with the given `name` already exists in the registry (e.g.
- * because another bundle called `createStore` first), the existing entry is
- * reused and `initialState` is ignored.  This means the first bundle to run
- * wins the initial value — define your stores in a single shared file, or
- * treat `initialState` as a consistent default across all bundles.
- *
- * @param name          A unique string key for this store.
- * @param initialState  Default state used when the store is first created.
- */
-export declare function createStore<T extends object>(name: string, initialState: T): Store<T>;
-/**
- * React hook that subscribes a component to a store.
- *
- * An optional `selector` lets you derive a slice of state.  The component
- * only re-renders when the selected value changes (by reference equality),
- * not on every store mutation.
- *
- * Works across independent React roots — any component on the page that calls
- * `useStore` with the same store will re-render when that store changes,
- * regardless of which component boundary each lives in.
- *
- * @example
- * // Full state
- * const state = useStore(cartStore);
- *
- * @example
- * // Selected slice — re-renders only when `items` changes
- * const items = useStore(cartStore, s => s.items);
- */
-export declare function useStore<T extends object>(store: Store<T>): T;
-export declare function useStore<T extends object, U>(store: Store<T>, selector: (state: T) => U): U;
-export {};

package/dist/store.js

@@ -1,45 +0,0 @@
-import { useSyncExternalStore } from "react";
-function getRegistry() {
-  if (typeof window === "undefined") {
-    return /* @__PURE__ */ new Map();
-  }
-  if (!window.__nukeStores) {
-    window.__nukeStores = /* @__PURE__ */ new Map();
-  }
-  return window.__nukeStores;
-}
-function createStore(name, initialState) {
-  const registry = getRegistry();
-  if (!registry.has(name)) {
-    registry.set(name, {
-      state: initialState,
-      listeners: /* @__PURE__ */ new Set()
-    });
-  }
-  const entry = registry.get(name);
-  const subscribe = (listener) => {
-    entry.listeners.add(listener);
-    return () => {
-      entry.listeners.delete(listener);
-    };
-  };
-  const getState = () => entry.state;
-  const setState = (updater) => {
-    entry.state = typeof updater === "function" ? updater(entry.state) : updater;
-    for (const l of Array.from(entry.listeners)) l();
-  };
-  return { name, initialState, getState, setState, subscribe };
-}
-function useStore(store, selector) {
-  const getSnapshot = selector ? () => selector(store.getState()) : () => store.getState();
-  const getServerSnapshot = selector ? () => selector(store.initialState) : () => store.initialState;
-  return useSyncExternalStore(
-    store.subscribe,
-    getSnapshot,
-    getServerSnapshot
-  );
-}
-export {
-  createStore,
-  useStore
-};

package/dist/use-html.d.ts

@@ -1,64 +0,0 @@
-/**
- * use-html.ts — useHtml() Hook
- *
- * A universal hook that lets React components control the HTML document's
- * <head>, <html> attributes, and <body> attributes from within JSX — on both
- * the server (SSR) and the client (hydration / SPA navigation).
- *
- * Server behaviour:
- *   Writes directly into the per-request html-store.  The store is flushed
- *   into the HTML document after the component tree is fully rendered.
- *   useHtml() is called synchronously during rendering so no actual React
- *   hook is used — it's just a function that pokes the globalThis store.
- *
- * Client behaviour:
- *   Uses useEffect() to apply changes to the live document and clean them up
- *   when the component unmounts (navigation, unmount).  Each effect is keyed
- *   to its options object via JSON.stringify so React re-runs it when the
- *   options change.
- *
- * Layout title templates:
- *   Layouts typically set title as a function so they can append a site suffix:
- *
- *   ```tsx
- *   // Root layout
- *   useHtml({ title: (prev) => `${prev} | Acme` });
- *
- *   // A page
- *   useHtml({ title: 'About' });
- *   // → 'About | Acme'
- *   ```
- *
- * Example usage:
- *   ```tsx
- *   useHtml({
- *     title: 'Blog Post',
- *     meta:  [{ name: 'description', content: 'A great post' }],
- *     link:  [{ rel: 'canonical', href: 'https://example.com/post' }],
- *   });
- *   ```
- */
-import type { TitleValue, HtmlAttrs, BodyAttrs, MetaTag, LinkTag, ScriptTag, StyleTag } from './html-store';
-export type { TitleValue, HtmlAttrs, BodyAttrs, MetaTag, LinkTag, ScriptTag, StyleTag };
-export interface HtmlOptions {
-    /**
-     * Page title.
-     *   string   → sets the title directly (page wins over layout).
-     *   function → receives the inner title; use in layouts to append a suffix:
-     *              `(prev) => \`${prev} | MySite\``
-     */
-    title?: TitleValue;
-    /** Attributes merged onto <html>. Per-attribute last-write-wins. */
-    htmlAttrs?: HtmlAttrs;
-    /** Attributes merged onto <body>. Per-attribute last-write-wins. */
-    bodyAttrs?: BodyAttrs;
-    meta?: MetaTag[];
-    link?: LinkTag[];
-    script?: ScriptTag[];
-    style?: StyleTag[];
-}
-/**
- * Applies HTML document customisations from a React component.
- * Automatically detects whether it is running on the server or the client.
- */
-export declare function useHtml(options: HtmlOptions): void;

package/dist/use-html.js

@@ -1,128 +0,0 @@
-import { useEffect } from "react";
-import { getHtmlStore } from "./html-store.js";
-function useHtml(options) {
-  if (typeof document === "undefined") {
-    serverUseHtml(options);
-  } else {
-    clientUseHtml(options);
-  }
-}
-function serverUseHtml(options) {
-  const store = getHtmlStore();
-  if (!store) return;
-  if (options.title !== void 0) store.titleOps.push(options.title);
-  if (options.htmlAttrs) Object.assign(store.htmlAttrs, options.htmlAttrs);
-  if (options.bodyAttrs) Object.assign(store.bodyAttrs, options.bodyAttrs);
-  if (options.meta?.length) store.meta.push(...options.meta);
-  if (options.link?.length) store.link.push(...options.link);
-  if (options.script?.length) store.script.push(...options.script);
-  if (options.style?.length) store.style.push(...options.style);
-}
-let _uid = 0;
-const uid = () => `uh${++_uid}`;
-function clientUseHtml(options) {
-  useEffect(() => {
-    if (options.title === void 0) return;
-    const prev = document.title;
-    document.title = typeof options.title === "function" ? options.title(prev) : options.title;
-    return () => {
-      document.title = prev;
-    };
-  }, [typeof options.title === "function" ? options.title.toString() : options.title]);
-  useEffect(() => {
-    if (!options.htmlAttrs) return;
-    return applyAttrs(document.documentElement, options.htmlAttrs);
-  }, [JSON.stringify(options.htmlAttrs)]);
-  useEffect(() => {
-    if (!options.bodyAttrs) return;
-    return applyAttrs(document.body, options.bodyAttrs);
-  }, [JSON.stringify(options.bodyAttrs)]);
-  useEffect(() => {
-    if (!options.meta?.length) return;
-    const id = uid();
-    const nodes = options.meta.map((tag) => {
-      const el = document.createElement("meta");
-      for (const [k, v] of Object.entries(tag)) {
-        if (v !== void 0) el.setAttribute(domAttr(k), v);
-      }
-      el.dataset.usehtml = id;
-      document.head.appendChild(el);
-      return el;
-    });
-    return () => nodes.forEach((n) => n.remove());
-  }, [JSON.stringify(options.meta)]);
-  useEffect(() => {
-    if (!options.link?.length) return;
-    const id = uid();
-    const nodes = options.link.map((tag) => {
-      const el = document.createElement("link");
-      for (const [k, v] of Object.entries(tag)) {
-        if (v !== void 0) el.setAttribute(domAttr(k), v);
-      }
-      el.dataset.usehtml = id;
-      document.head.appendChild(el);
-      return el;
-    });
-    return () => nodes.forEach((n) => n.remove());
-  }, [JSON.stringify(options.link)]);
-  useEffect(() => {
-    if (!options.script?.length) return;
-    const id = uid();
-    const nodes = options.script.map((tag) => {
-      const el = document.createElement("script");
-      if (tag.src) el.src = tag.src;
-      if (tag.type) el.type = tag.type;
-      if (tag.defer) el.defer = true;
-      if (tag.async) el.async = true;
-      if (tag.noModule) el.setAttribute("nomodule", "");
-      if (tag.crossOrigin) el.crossOrigin = tag.crossOrigin;
-      if (tag.integrity) el.integrity = tag.integrity;
-      if (tag.content) el.textContent = tag.content;
-      el.dataset.usehtml = id;
-      if (tag.position === "body") {
-        document.body.appendChild(el);
-      } else {
-        document.head.appendChild(el);
-      }
-      return el;
-    });
-    return () => nodes.forEach((n) => n.remove());
-  }, [JSON.stringify(options.script)]);
-  useEffect(() => {
-    if (!options.style?.length) return;
-    const id = uid();
-    const nodes = options.style.map((tag) => {
-      const el = document.createElement("style");
-      if (tag.media) el.media = tag.media;
-      if (tag.content) el.textContent = tag.content;
-      el.dataset.usehtml = id;
-      document.head.appendChild(el);
-      return el;
-    });
-    return () => nodes.forEach((n) => n.remove());
-  }, [JSON.stringify(options.style)]);
-}
-function applyAttrs(el, attrs) {
-  const prev = {};
-  for (const [k, v] of Object.entries(attrs)) {
-    if (v === void 0) continue;
-    const attr = domAttr(k);
-    prev[attr] = el.getAttribute(attr);
-    el.setAttribute(attr, v);
-  }
-  return () => {
-    for (const [attr, was] of Object.entries(prev)) {
-      if (was === null) el.removeAttribute(attr);
-      else el.setAttribute(attr, was);
-    }
-  };
-}
-function domAttr(key) {
-  if (key === "httpEquiv") return "http-equiv";
-  if (key === "hrefLang") return "hreflang";
-  if (key === "crossOrigin") return "crossorigin";
-  return key;
-}
-export {
-  useHtml
-};

package/dist/use-request.d.ts

@@ -1,74 +0,0 @@
-/**
- * use-request.ts — useRequest() Hook
- *
- * Universal hook that exposes the current request's URL parameters, query
- * string, and headers to any React component — server or client, dev or prod.
- *
- * ┌───────────────────────────────────────────────────────────────────────────┐
- * │  Environment    │  Data source                                            │
- * ├─────────────────┼─────────────────────────────────────────────────────────┤
- * │  SSR (server)   │  request-store, populated by ssr.ts before rendering   │
- * │  Client         │  __n_data JSON blob + window.location (reactive)        │
- * └───────────────────────────────────────────────────────────────────────────┘
- *
- * The hook stays reactive on the client: it listens to 'locationchange' events
- * fired by NukeJS's SPA router so values update on soft navigation without a
- * full page reload.
- *
- * --- Usage ---
- *
- * Basic:
- * ```tsx
- * // Works in server components (SSR) and client components ("use client")
- * const { params, query, headers, pathname } = useRequest();
- * const slug    = params.slug as string;
- * const lang    = query.lang as string;
- * const locale  = headers['accept-language'];
- * ```
- *
- * Building useI18n on top:
- * ```tsx
- * // hooks/useI18n.ts
- * import { useRequest } from 'nukejs';
- *
- * const translations = {
- *   en: { welcome: 'Welcome' },
- *   fr: { welcome: 'Bienvenue' },
- * } as const;
- * type Locale = keyof typeof translations;
- *
- * function parseLocale(header = ''): Locale {
- *   const tag = header.split(',')[0]?.split('-')[0]?.trim().toLowerCase();
- *   return (tag in translations ? tag : 'en') as Locale;
- * }
- *
- * export function useI18n() {
- *   const { query, headers } = useRequest();
- *   // ?lang=fr wins over Accept-Language header
- *   const locale = ((query.lang as string) ?? parseLocale(headers['accept-language'])) as Locale;
- *   return { t: translations[locale] ?? translations.en, locale };
- * }
- *
- * // Page.tsx
- * const { t } = useI18n();
- * return <h1>{t.welcome}</h1>;
- * ```
- *
- * --- Notes ---
- * - `headers` on the client never contains `cookie`, `authorization`, or
- *   `proxy-authorization` — these are stripped by the SSR pipeline before
- *   embedding in __n_data. See request-store.ts for the full exclusion list.
- * - In a "use client" component, `params` always reflects the __n_data blob
- *   written at the time of the most recent SSR/navigation.  For the freshest
- *   pathname use `useRouter().path` instead.
- */
-import type { RequestContext } from './request-store';
-export type { RequestContext };
-/**
- * Returns the current request context: URL params, query string, and headers.
- *
- * Automatically detects SSR vs browser and returns the correct data for
- * each environment.  On the client it is reactive — values update on SPA
- * navigation without a page reload.
- */
-export declare function useRequest(): RequestContext;