@nifrajs/web 2.2.0 → 2.4.0

package/dist/fonts.d.ts

@@ -1,17 +1,17 @@
 /**
- * Font optimization primitives — generate a **CLS-safe `@font-face`** rule and the matching
+ * Font optimization primitives - generate a **CLS-safe `@font-face`** rule and the matching
  * **preload `<link>`** for a self-hosted font. The two fixes that matter most (the ones `next/font`
  * automates) are right here: `font-display: swap` (text paints immediately, no invisible-text FOIT)
  * plus a preload so the file downloads with the document, and optional metric overrides
  * (`size-adjust`/`ascent-override`/…) so swapping from the fallback to the web font doesn't shift layout.
  *
- * Self-host the file (drop a `.woff2` in your assets — never hotlink Google's CDN), then:
+ * Self-host the file (drop a `.woff2` in your assets - never hotlink Google's CDN), then:
  *
- *   // fonts.css (imported by your app — the CSS pipeline bundles + links it)
+ *   // fonts.css (imported by your app - the CSS pipeline bundles + links it)
  *   import { fontFace } from "@nifrajs/web"
  *   export default fontFace({ family: "Inter", src: [{ url: "/fonts/inter.woff2" }], weight: "100 900" })
  *
- *   // a root layout's meta — becomes a <link rel="preload" as="font"> in <head>
+ *   // a root layout's meta - becomes a <link rel="preload" as="font"> in <head>
  *   export const meta = { link: [fontPreload({ href: "/fonts/inter.woff2" })] }
  */
 import type { LinkDescriptor } from "./manifest.js";
@@ -32,7 +32,7 @@ export interface FontFace {
     readonly style?: "normal" | "italic" | "oblique";
     /** Defaults to `"swap"` (no flash of invisible text). */
     readonly display?: FontDisplay;
-    /** Restrict the glyphs this face covers, e.g. `"U+0000-00FF"` — lets the browser skip the download
+    /** Restrict the glyphs this face covers, e.g. `"U+0000-00FF"` - lets the browser skip the download
      * for pages without those characters. */
     readonly unicodeRange?: string;
     /** Metric overrides that eliminate layout shift when the fallback swaps to the web font (the
@@ -53,13 +53,13 @@ export interface FontPreloadInput {
     readonly href: string;
     /** MIME type (`font/woff2`, …). Inferred from the extension when omitted. */
     readonly type?: string;
-    /** `crossorigin` mode — defaults to `"anonymous"`. Fonts are always fetched in CORS mode, and a
+    /** `crossorigin` mode - defaults to `"anonymous"`. Fonts are always fetched in CORS mode, and a
      * preload whose `crossorigin` doesn't match the actual fetch is **wasted** (downloaded twice), so
      * this is on by default. */
     readonly crossOrigin?: "anonymous" | "use-credentials";
 }
 /**
- * Build a font preload as a `<link>` attribute set for a route/layout's `meta.link` — nifra injects it
+ * Build a font preload as a `<link>` attribute set for a route/layout's `meta.link` - nifra injects it
  * into `<head>` (`<link rel="preload" as="font" type="font/woff2" crossorigin="anonymous">`). Values are
  * escaped at injection by the head renderer. Preloading the font file removes a render-blocking round
  * trip (the browser would otherwise discover the font only after parsing the CSS).

package/dist/fonts.js

@@ -69,7 +69,7 @@ export function fontFace(face) {
     return `@font-face {\n  ${declarations.join(";\n  ")};\n}`;
 }
 /**
- * Build a font preload as a `<link>` attribute set for a route/layout's `meta.link` — nifra injects it
+ * Build a font preload as a `<link>` attribute set for a route/layout's `meta.link` - nifra injects it
  * into `<head>` (`<link rel="preload" as="font" type="font/woff2" crossorigin="anonymous">`). Values are
  * escaped at injection by the head renderer. Preloading the font file removes a render-blocking round
  * trip (the browser would otherwise discover the font only after parsing the CSS).

package/dist/forms.d.ts

@@ -1,6 +1,6 @@
 /**
- * `@nifrajs/web/forms` — a typed form ↔ backend-schema binding. The three artifacts that must agree —
- * a form's `<input name>`, the action's `formData.get`, and the typed-client payload — all key off the
+ * `@nifrajs/web/forms` - a typed form ↔ backend-schema binding. The three artifacts that must agree -
+ * a form's `<input name>`, the action's `formData.get`, and the typed-client payload - all key off the
  * ONE route body schema, derived purely from `typeof backend`. A typo'd field name, or a field the
  * schema doesn't have, becomes a COMPILE error instead of a silent runtime empty.
  *
@@ -8,14 +8,14 @@
  *   import { formFor } from "@nifrajs/web/forms"
  *
  *   const f = formFor<typeof backend, "/todos">()   // method defaults to "post"
- *   // In the component (any framework — spread the props onto an input):
+ *   // In the component (any framework - spread the props onto an input):
  *   <input {...f.field("text")} />                  // "text" ∈ the body's keys, else a compile error
  *   // In the action:
  *   const text = f.read(await request.formData(), "text")   // an orphan key won't compile
  *   await api.todos.post({ text })                  // payload already typed by nifra
  *
  * Framework-agnostic + dependency-free: no codegen, no schema is bundled into the client, and the
- * runtime is a trivial pass-through — all the work is in the types. It checks the field KEY, never the
+ * runtime is a trivial pass-through - all the work is in the types. It checks the field KEY, never the
  * MEANING (a `field("email")` collecting a phone is still valid here); that stays an app/AI concern.
  */
 import type { RouteInfo, Server } from "@nifrajs/core/server";
@@ -23,23 +23,23 @@ type FormEntry = ReturnType<FormData["get"]>;
 type FormEntries = ReturnType<FormData["getAll"]>;
 /** The route registry baked into a server's type (`typeof app`). */
 type RegistryOf<App> = App extends Server<infer R, infer _Ctx> ? R : never;
-/** Every route path the app declares — constrains `Path`, so a wrong path is itself a type error. */
+/** Every route path the app declares - constrains `Path`, so a wrong path is itself a type error. */
 export type RoutePaths<App> = keyof RegistryOf<App> & string;
 /** The body object type of `App`'s `Method Path` route (`never` when the route declares no body). */
 export type RouteBody<App, Path extends string, Method extends string> = Path extends keyof RegistryOf<App> ? Uppercase<Method> extends keyof RegistryOf<App>[Path] ? (RegistryOf<App>[Path][Uppercase<Method>] & RouteInfo)["body"] : never : never;
-/** The valid field names for that route's body — the schema's keys as a string union. */
+/** The valid field names for that route's body - the schema's keys as a string union. */
 export type FieldKey<App, Path extends string, Method extends string> = [
     RouteBody<App, Path, Method>
 ] extends [never] ? never : keyof RouteBody<App, Path, Method> & string;
 /** Extra attributes merged into the returned input props (id, type, defaultValue, placeholder, …). */
 export type FieldProps = Record<string, unknown>;
 export interface FormHandle<App, Path extends string, Method extends string> {
-    /** Input props for a schema field. `name` is constrained to the body's keys — a typo, or a field the
+    /** Input props for a schema field. `name` is constrained to the body's keys - a typo, or a field the
      * schema doesn't have, is a COMPILE error. Spread onto an element: `<input {...f.field("text")} />`. */
     field<K extends FieldKey<App, Path, Method>>(name: K, props?: FieldProps): FieldProps & {
         name: K;
     };
-    /** `formData.get`, key-constrained to the body's fields — reading an orphan key won't compile. */
+    /** `formData.get`, key-constrained to the body's fields - reading an orphan key won't compile. */
     read<K extends FieldKey<App, Path, Method>>(form: FormData, name: K): FormEntry;
     /** `formData.getAll`, key-checked the same way. */
     readAll<K extends FieldKey<App, Path, Method>>(form: FormData, name: K): FormEntries;

package/dist/fs.d.ts

@@ -1,7 +1,7 @@
 import { type Manifest } from "./manifest.js";
 /** Options for {@link discoverRoutes}. */
 export interface DiscoverRoutesOptions {
-    /** Appended (as `?<importQuery>`) to each route's dynamic import — the dev server sets a
+    /** Appended (as `?<importQuery>`) to each route's dynamic import - the dev server sets a
      * changing value to bust Bun's module cache so SSR picks up edited route files. Ignored when
      * {@link load} is supplied, which does its own cache handling. */
     readonly importQuery?: string;

package/dist/fs.js

@@ -7,7 +7,7 @@ var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExte
     return path;
 };
 /**
- * @nifrajs/web/fs — filesystem route discovery. Separated from the main entry so `app.fetch`
+ * @nifrajs/web/fs - filesystem route discovery. Separated from the main entry so `app.fetch`
  * (and the rest of @nifrajs/web) stays fs-free + edge-portable: this runs at build/startup
  * only. It scans a routes dir and feeds the pure `buildManifest`.
  */