@nifrajs/web 0.1.0-alpha.1

package/dist/index.d.ts

@@ -0,0 +1,280 @@
+/**
+ * @nifrajs/web — the framework-agnostic SSR core. It owns the render *seam* and the HTML
+ * document orchestration, and knows nothing about any specific UI framework: a render
+ * adapter (@nifrajs/web-solid, @nifrajs/web-react, …) supplies the actual render + hydrate.
+ *
+ * The core treats a "component" and a hydration "container" as opaque `unknown` — only
+ * the adapter interprets them. That keeps this package both framework-agnostic and free
+ * of DOM types: it is pure server orchestration + string building.
+ */
+import { type Server } from "@nifrajs/core";
+import { type Deferred, defer } from "./deferred.js";
+import type { Manifest, Meta, MetaArgs, MetaInput } from "./manifest.js";
+import { type Submission } from "./router.js";
+export { DRAFT_COOKIE, type DraftCookieControls, disableDraft, type EnableDraftOptions, enableDraft, isDraftEnabled, } from "./draft.js";
+export { type FontDisplay, type FontFace, type FontPreloadInput, type FontSource, fontFace, fontPreload, } from "./fonts.js";
+export { type CachedResponse, type CacheStore, ISR_REVALIDATE_HEADER, ISR_STATUS_HEADER, type ISRApp, type ISROptions, type ISRPlatform, KVCacheStore, type KVCacheStoreOptions, type KVNamespaceLike, MemoryCacheStore, type MemoryCacheStoreOptions, type RevalidateEndpointOptions, revalidateEndpoint, withISR, } from "./isr.js";
+export { type Action, buildManifest, enumeratePrerenderedPaths, enumerateStaticRoutes, filePathToPattern, filePathToPatterns, type GetStaticPaths, type LayoutEntry, type Loader, type LoaderContext, type Manifest, type Meta, type MetaArgs, type MetaInput, type RouteEntry, type RouteModule, type StaticPath, type StaticPaths, type StaticRoutes, } from "./manifest.js";
+export { createQueryClient, hashQueryKey, type QueryClient, type QueryClientOptions, type QueryHandle, type QueryState, type QueryStatus, } from "./query.js";
+export { type ClientRouter, type ClientRouterOptions, createClientRouter, createMatcher, DATA_HEADER, type Fetcher, type FetcherState, type FetchRouteData, type MountRouterOptions, REDIRECT_HEADER, REVALIDATE_HEADER, type RouteMatch, type RoutePattern, type RouterState, type Submission, type SubmitOptions, } from "./router.js";
+export { type Deferred, defer };
+/** The data handed to a route component. Opaque to the core. `actionData` is the return of a
+ * route `action` after a POST (absent on plain GETs). `pending` + `submission` are client-only
+ * (absent on SSR): they drive **optimistic UI** — render from `submission.formData` while `pending`. */
+export interface RenderProps {
+    readonly data: unknown;
+    readonly actionData?: unknown;
+    /** True while a client navigation or submit is in flight (client-only; absent/false on SSR). */
+    readonly pending?: boolean;
+    /** The in-flight client submit, for optimistic UI (client-only; absent on SSR + when idle). */
+    readonly submission?: Submission;
+}
+/** The seam every render adapter implements. */
+export interface RenderAdapter {
+    /**
+     * Server: render a route's layout `chain` (outermost layout → page) to a **stream** of HTML
+     * bytes, including the framework's hydration markers. The page (innermost) receives `props`
+     * (the loader data); each layout wraps the child via its `children`. Returns (or resolves to)
+     * a Web `ReadableStream<Uint8Array>`: a streaming renderer flushes the shell first and streams
+     * Suspense boundaries as they resolve; a non-streaming renderer may return a one-chunk stream.
+     * May be async — e.g. React resolves once the shell is renderable, so a shell-render throw can
+     * still map to an error status before any byte is sent.
+     */
+    renderToStream(chain: readonly unknown[], props: RenderProps): ReadableStream<Uint8Array> | Promise<ReadableStream<Uint8Array>>;
+    /**
+     * Server (optional): render the chain to a complete HTML **string** in one pass, with the same
+     * hydration markers `renderToStream` produces. When provided, `renderPage` uses it for any page
+     * that does **not** `defer()` — buffering the document is faster than the streaming pipeline there,
+     * because the framework's synchronous renderer (React `renderToString`, Solid `renderToString`,
+     * Preact `render`, Vue `renderToString`, Svelte `render`) is markedly cheaper than its streaming
+     * renderer — most visibly on Bun, where React Fizz / Solid `renderToStream` are the heaviest. Pages
+     * that `defer()` keep the streaming path (progressive `<Await>` needs it). Markup MUST be
+     * hydration-equivalent to `renderToStream`; a throw surfaces like the streaming shell-readiness
+     * await (the `_error` boundary maps it to a status). Omit it to always stream.
+     */
+    renderToString?(chain: readonly unknown[], props: RenderProps): string | Promise<string>;
+    /**
+     * Server: per-document bootstrap markup injected into `<head>` that the client
+     * `hydrate` requires (Solid: `generateHydrationScript()`). Empty string if none.
+     */
+    hydrationHead(): string;
+}
+/** Global the server serializes loader data into; the client reads it to hydrate. */
+export declare const DATA_GLOBAL = "__NIFRA_DATA__";
+/** Global the server writes the matched route id into; the client uses it to pick the chain. */
+export declare const ROUTE_GLOBAL = "__NIFRA_ROUTE__";
+/** Global the server serializes an action's data return into (absent on GETs); the client
+ * reads it so hydration after a native form POST matches the server-rendered markup. */
+export declare const ACTION_GLOBAL = "__NIFRA_ACTION__";
+type MaybePromise<T> = T | Promise<T>;
+declare const RESPONSE_RESULT: unique symbol;
+export interface RenderedPage {
+    readonly [RESPONSE_RESULT]: true;
+    toResponse(): Response;
+    toNodeBody?(): {
+        readonly status: number;
+        readonly headers: Readonly<Record<string, string | readonly string[]>> | undefined;
+        readonly body: string | Uint8Array;
+    };
+}
+export interface RenderPageOptions {
+    readonly adapter: RenderAdapter;
+    /** The layout chain to render — outermost layout → page (opaque; the adapter renders it). */
+    readonly chain: readonly unknown[];
+    /** The loader output for this request. */
+    readonly data: unknown;
+    /** An action's data return (POST only) — surfaced to the page as `actionData` + serialized
+     * for the client so post-POST hydration matches. Omit on GETs. */
+    readonly actionData?: unknown;
+    /** URL of the built client entry (loaded as a module script). */
+    readonly clientEntry: string;
+    /** Chunk URLs for the **matched** route (its layout chain + own chunk) to `modulepreload` in the
+     * shell — so the route code downloads in parallel with the entry instead of after it
+     * (`buildClient`'s per-route map). Empty/omitted ⇒ only the entry is preloaded (unchanged). */
+    readonly preload?: readonly string[];
+    /** Stylesheet URLs for the **matched** route (its layout chain + own CSS, from `buildClient`'s
+     * `BuildManifest.css`) — injected as `<link rel="stylesheet">` in `<head>` so styles arrive with the
+     * first paint (no FOUC). Rendered even on non-hydrated pages. Empty/omitted ⇒ none (unchanged). */
+    readonly styles?: readonly string[];
+    /** SSG: the prerendered-path set, serialized to `window.__NIFRA_PRERENDERED__` so the client fetches
+     * a static `_data.json` on soft-nav into a prerendered route. Empty/omitted ⇒ not injected. */
+    readonly prerenderedPaths?: readonly string[];
+    /** ISR: route freshness in seconds, emitted as the `x-nifra-isr-revalidate` header for a `withISR`
+     * wrapper to read. Omit ⇒ no header (the wrapper's default TTL applies). */
+    readonly revalidate?: number;
+    /** Matched route id; written to `window.__NIFRA_ROUTE__` so the client hydrates this chain. */
+    readonly routeId?: string;
+    /** HTTP status for the response (default 200; e.g. 404 for a not-found page). */
+    readonly status?: number;
+    /** Document title (fallback when `head.title` is unset). */
+    readonly title?: string;
+    /** Resolved route head — `title` overrides `title` above; `meta`/`link` render as managed
+     * (`data-nifra`) tags the client updates on navigation. */
+    readonly head?: Meta;
+    /** Id of the container wrapping the app markup (default `"root"`). */
+    readonly rootId?: string;
+    /** When `false`, emit a complete but **non-hydrated** document — no client entry script, data
+     * globals, or modulepreloads. Used for server-rendered `_error` pages: a terminal state that needs no
+     * client takeover, and it sidesteps an SSR/hydrate mismatch (the server rendered the boundary, not
+     * the page the client manifest maps this route id to). Default `true`. */
+    readonly hydrate?: boolean;
+    /** Island client bundles (`@nifrajs/web/islands`) to load as `<script type="module">` in the document
+     * tail — emitted **regardless of `hydrate`**, so a static (`hydrate: false`) page can still mount
+     * no-framework islands. URLs are attribute-escaped. Empty/omitted ⇒ none (unchanged output). */
+    readonly islandScripts?: readonly string[];
+}
+/**
+ * Server: render a full HTML document for a page — the adapter's hydration head + the SSR
+ * markup (**streamed**) + the serialized loader data + the client module — as a `Response`.
+ * The shell (`<head>` + the open container) flushes first, the adapter's app stream follows,
+ * then the tail (data globals + client entry). Pure Web Standards, so it returns straight from
+ * a nifra route handler and streams on any fetch runtime (Bun/Node/Deno/Workers).
+ */
+export declare function renderPage(options: RenderPageOptions): MaybePromise<Response>;
+export declare function renderPageResult(options: RenderPageOptions): MaybePromise<RenderedPage>;
+/** Options for {@link redirect}. */
+export interface RedirectOptions {
+    /** HTTP status (default 303 See Other; pass 307/308 to preserve the method). */
+    readonly status?: number;
+    /** Allow an off-origin / absolute destination. Off by default: only a same-origin path (a single
+     * leading `/`) is permitted, so an action can't be turned into an open redirect by passing
+     * attacker-controlled input straight through. Set `true` for a deliberate external redirect. */
+    readonly external?: boolean;
+}
+/**
+ * Build a redirect `Response` — return it from a route `action` for the Post/Redirect/Get
+ * pattern (POST mutates, 303 sends the browser to a fresh GET, so a reload doesn't re-submit).
+ * Defaults to 303 (See Other); pass `307`/`308` (or `{ status }`) to preserve the method.
+ *
+ * **Secure by default:** `location` must be a same-origin path (begins with `/`, not `//`). An
+ * off-origin/absolute destination throws unless you pass `{ external: true }` — this closes the
+ * open-redirect footgun of `return redirect(formData.get("next"))` on the no-JS (native-form) path,
+ * which returns the action's `Response` verbatim.
+ *
+ * @param statusOrOptions a status number (back-compat) or `{ status?, external? }`.
+ */
+export declare function redirect(location: string, statusOrOptions?: number | RedirectOptions): Response;
+/** The wrapper `revalidate()` returns: the action's `data` plus the paths it changed. A plain tagged
+ * shape (not a class) so `@nifrajs/client`'s `ActionData` can unwrap it structurally without importing
+ * from `@nifrajs/web`. `createWebApp` strips the wrapper — the client receives `data` as the body and
+ * the paths via the `X-Nifra-Revalidate` header. */
+export interface RevalidateResult<T> {
+    readonly __nifraRevalidate: readonly string[];
+    readonly data: T;
+}
+/**
+ * Return this from an action to declare which routes the mutation changed (alongside the action's
+ * `data`). `createWebApp` sets the `X-Nifra-Revalidate` response header; after the submit the client
+ * marks those cached routes stale — refetching the active one and any mounted fetcher showing them —
+ * so a mutation can refresh views beyond the one that was submitted. `data` is still surfaced to the
+ * component as `actionData` (the wrapper is transparent to `ActionData<typeof action>`).
+ */
+export declare function revalidate<T>(paths: readonly string[], data: T): RevalidateResult<T>;
+/**
+ * Serialize loader data for embedding inside an inline `<script>`. `JSON.stringify` alone
+ * is NOT safe there: a string containing `</script>` or `<!--` would break out of the
+ * script element (an XSS vector). Escape `<`/`>` to `\uXXXX`, plus the U+2028/U+2029
+ * separators.
+ */
+export declare function serializeData(data: unknown): string;
+/** Resolve a route's `meta` (static or a function of the loader data + params) to a {@link Meta}. */
+export declare function resolveMeta(meta: MetaInput | undefined, args: MetaArgs): Meta;
+export interface CreateWebAppOptions {
+    readonly adapter: RenderAdapter;
+    readonly manifest: Manifest;
+    /** URL of the built client entry (module script) injected into every page. */
+    readonly clientEntry: string;
+    /** Default document title for all pages. */
+    readonly title?: string;
+    /** Injected into each loader's `ctx.api` — typically an `inProcessClient(app)` (typed
+     * per-route via `@nifrajs/client`'s `createRoutes`). Opaque to the core. */
+    readonly api?: unknown;
+    /** Secret for **draft / preview mode** (see `enableDraft`). When set, a request carrying a valid
+     * signed `__nifra_draft` cookie gets `ctx.draft === true` in loaders/actions (else always `false`).
+     * Pair with `withISR({ draftSecret })` so editors bypass the cache. Omit to disable draft mode. */
+    readonly draftSecret?: string;
+    /** Per-route chunk URLs (`buildClient`'s `BuildManifest.routes`) — `routeId → [layout chunks…, own
+     * chunk]`. When present, each page `modulepreload`s its matched route's chunks alongside the entry,
+     * so the route code downloads in parallel (no entry→route-chunk waterfall). Omit ⇒ entry-only. */
+    readonly routePreload?: Readonly<Record<string, readonly string[]>>;
+    /** The app's bundled stylesheet URLs (`buildClient`'s `BuildManifest.css`) — the aggregate, injected
+     * as `<link rel="stylesheet">` in a page's `<head>`. Used as the fallback for any route absent from
+     * {@link routeStyles}. Omit ⇒ no links (dev, where Vite injects CSS, or a CSS-free app). */
+    readonly styles?: readonly string[];
+    /** Per-route stylesheet URLs (`buildClient`'s `BuildManifest.routeStyles`) — `routeId → [chain CSS]`.
+     * When a matched route has an entry here, only those (its layout chain + own CSS) are linked instead
+     * of the aggregate `styles`, so a page ships only the CSS it uses. An empty array ⇒ no `<link>` (the
+     * page imports no CSS). Routes absent here fall back to `styles`. Omit ⇒ always use `styles`. */
+    readonly routeStyles?: Readonly<Record<string, readonly string[]>>;
+    /** SSG: the prerendered-path set (e.g. from `enumeratePrerenderedPaths` or the build's
+     * `prerendered.json`). Injected as `window.__NIFRA_PRERENDERED__` on every page so a client soft-nav
+     * into a prerendered route fetches its static `_data.json` instead of hitting the worker. */
+    readonly prerenderedPaths?: readonly string[];
+    /** SSG: per dynamic route pattern, its `getStaticPaths` `fallback` (from `enumerateStaticRoutes` or
+     * the build's `prerendered.json`). A route mapped to `"404"` rejects any path NOT in
+     * `prerenderedPaths` with the 404 page — the unlisted path simply doesn't exist. `"ssr"` (the
+     * default for unmapped routes) renders unlisted paths on-demand. */
+    readonly staticFallbacks?: Readonly<Record<string, "ssr" | "404">>;
+    /** Observe every loader/action failure — for error-reporting plugins (Sentry-style). Called for
+     * real throws (not control-flow `Response`s like `redirect`), **before** the nearest `_error`
+     * boundary renders / a soft-nav 500 / a rethrow — so it sees errors that the boundary would
+     * otherwise hide. Observation only; its own throws are swallowed so a faulty reporter can't break
+     * rendering. (`beforeLoader` is intentionally omitted — the core HTTP hooks already cover
+     * pre-request work.) */
+    readonly onLoaderError?: (error: unknown, ctx: {
+        readonly request: Request;
+        readonly params: Readonly<Record<string, string>>;
+        readonly route: string;
+    }) => void;
+}
+/**
+ * Build a nifra app from a route manifest: every route SSRs its layout chain via `renderPage`,
+ * and a wildcard catch-all renders `_404` (or a plain 404). Reuses @nifrajs/core's router +
+ * lifecycle, so matching, params, and precedence are battle-tested. fs-free — feed it a
+ * manifest from `discoverRoutes` (`@nifrajs/web/fs`) at startup, so the served app stays portable.
+ */
+export declare function createWebApp(options: CreateWebAppOptions): Server;
+export interface GenerateClientEntryOptions {
+    /** Module specifier for the adapter's client runtime (exports `mountRouter`), e.g.
+     * `"@nifrajs/web-solid/client"`. */
+    readonly clientModule: string;
+    /** Turn a route/layout source file (relative to the routes dir) into an import specifier. */
+    readonly resolve: (file: string) => string;
+}
+/**
+ * Codegen: emit a client-entry module (as source) that lazily imports each route's layout chain
+ * (so `Bun.build` with `splitting` code-splits one chunk per route), builds a `patterns` list,
+ * then creates the agnostic router store (with a `loadModule` hook), installs history + form
+ * interception, loads the initial route's chunk, and hydrates the adapter's stateful Router. The
+ * initial route is derived from the URL (falling back to the server-injected route id, e.g.
+ * `_404`), so after hydration the Router owns navigation and swaps routes without full reloads.
+ * Bun has no `import.meta.glob`, so file-based routing needs this. Write the result to a file and
+ * bundle it with `buildClient` / `Bun.build` (+ the adapter's transform).
+ */
+export declare function generateClientEntry(manifest: Manifest, options: GenerateClientEntryOptions): string;
+export interface GenerateServerManifestOptions {
+    /** Turn a route/layout source file (relative to the routes dir) into an import specifier —
+     * same contract as `generateClientEntry`'s `resolve`. */
+    readonly resolve: (file: string) => string;
+    /** The content-hashed client entry URL (from `buildClient`'s manifest), **baked** into the emitted
+     * module — a disk-less worker can't read `manifest.json` at runtime. */
+    readonly clientEntry: string;
+    /** Emit **lazy** per-route loaders (`() => import("./routes/x")`, a static specifier) instead of
+     * eager `import * as`, so a bundler with code-splitting emits one chunk per route — loaded on the
+     * first request to it, not all at boot (smaller cold-start parse). Default `false` (eager). Both
+     * modes are fs-free with statically-analyzable specifiers; only the *when* differs. */
+    readonly lazy?: boolean;
+}
+/**
+ * Codegen: emit a **server manifest** module (as source) for disk-less edge runtimes (Cloudflare
+ * Workers, …) — and, with a `target`, any portable server bundle. `discoverRoutes` scans `node:fs`
+ * and dynamic-imports each route by a *runtime* path — neither exists on workerd. This instead emits
+ * **statically-analyzable** imports of every route/layout/`_error`/`_404` (so the bundler includes them) and
+ * rebuilds the manifest with `buildManifest` — the SAME pure logic `discoverRoutes` feeds, so patterns
+ * + layout chains are identical. Eager (`import * as`) by default; `lazy` emits `() => import(...)` so
+ * a code-splitting bundler chunks per route. The emitted module exports `manifest` (consumed by
+ * `createWebApp`, unchanged) + `clientEntry` (baked). Write it to a file and bundle it into the worker
+ * entry (see `buildServer` in `@nifrajs/web/build`).
+ */
+export declare function generateServerManifest(manifest: Manifest, options: GenerateServerManifestOptions): string;
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"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"}