@absolutejs/absolute 0.20.0-beta.169 → 0.20.0-beta.170

package/dist/src/angular/zoneRuntime.d.ts

@@ -0,0 +1,5 @@
+import type { AngularChangeDetection } from '../../types/build';
+export declare const isAngularZoneMode: () => boolean;
+export declare const setAngularChangeDetection: (mode: AngularChangeDetection | undefined) => void;
+/** Load zone.js into the server process once, before the app listens. */
+export declare const installAngularZoneRuntime: () => Promise<void>;

package/dist/src/build/buildReactServerComponents.d.ts

@@ -0,0 +1,22 @@
+type BuildLog = BuildMessage | ResolveMessage;
+export type ReactServerBuildResult = {
+    logs: BuildLog[];
+    manifest: Record<string, string>;
+    outputPaths: string[];
+    success: boolean;
+};
+type ReactServerBuildOptions = {
+    buildPath: string;
+    directory: string;
+    isDev: boolean;
+    projectRoot: string;
+};
+export declare const clientModuleId: (projectRoot: string, path: string) => string;
+export declare const isClientModuleSource: (source: string) => boolean;
+export declare const buildReactServerComponents: ({ buildPath, directory, isDev, projectRoot }: ReactServerBuildOptions) => Promise<ReactServerBuildResult>;
+type ReactServerPassOptions = Omit<ReactServerBuildOptions, 'directory'> & {
+    directory: string | undefined;
+    incrementalFiles: string[] | undefined;
+};
+export declare const buildReactServerComponentsPass: ({ directory, incrementalFiles, ...options }: ReactServerPassOptions) => Promise<ReactServerBuildResult | undefined>;
+export {};

package/dist/src/build/downlevelAsyncForZone.d.ts

@@ -0,0 +1 @@
+export declare const downlevelAsyncForZone: (code: string, fileName: string) => string;

package/dist/src/build/fileRoutes.d.ts

@@ -0,0 +1,65 @@
+import type { BuildConfig } from '../../types/build';
+import type { FileRouteFramework } from '../../types/fileRoutes';
+export type FileRouteRoot = {
+    dir: string;
+    framework: FileRouteFramework;
+};
+export type ScannedFileRoute = {
+    framework: FileRouteFramework;
+    /** Flat page name: the manifest holds `<name>Index`, `<name>`, … */
+    name: string;
+    /** Elysia path, e.g. `/blog/:slug`. */
+    path: string;
+    /** Route file, absolute. */
+    source: string;
+    /** Co-located `<route>.server.ts`, absolute, when present. */
+    server?: string;
+};
+export type FileRouteScan = {
+    /** Unsupported or conflicting route files, one message each. */
+    problems: string[];
+    routes: ScannedFileRoute[];
+};
+type ResolvedFileRoutes = {
+    output: string;
+    roots: FileRouteRoot[];
+};
+/** The route folders and output module for `config`, or `undefined` when
+ *  file routing is off. */
+export declare const resolveFileRoutes: (config: BuildConfig, root?: string) => ResolvedFileRoutes | undefined;
+/** The Elysia path for a route file's path inside its route folder:
+ *  `index` → `/`, `blog/index` → `/blog`, `blog/[slug]` → `/blog/:slug`. */
+export declare const fileRoutePath: (framework: FileRouteFramework, relativePath: string) => {
+    path: string;
+    error?: undefined;
+} | {
+    error: string;
+    path?: undefined;
+};
+/** A route's page name: `Route` + its path in PascalCase + a short hash of
+ *  the framework and file path, so two routes never share a manifest key
+ *  (`blog/[slug]` and `blog-slug` both read `BlogSlug`). Letters and digits
+ *  only, so every manifest key derivation leaves it unchanged. */
+export declare const fileRoutePageName: (framework: FileRouteFramework, relativePath: string) => string;
+/** Scan every route folder. Records the result so the build and the dev
+ *  server can map a route file to its page name. */
+export declare const scanFileRoutes: (config: BuildConfig) => FileRouteScan;
+/** The route module's source. */
+export declare const renderFileRouteModule: (routes: ScannedFileRoute[], output: string) => string;
+/** Scan the route folders and (re)write the route module when its contents
+ *  change. `undefined` when file routing is off. */
+export declare const ensureFileRouteModule: (config: BuildConfig) => void;
+export declare const syncFileRoutes: (config: BuildConfig) => {
+    output: string;
+    written: boolean;
+    /** Unsupported or conflicting route files, one message each. */
+    problems: string[];
+    routes: ScannedFileRoute[];
+} | undefined;
+/** The route a source file is, when it is one: from the last scan, or from
+ *  its path when it was created since. */
+export declare const fileRouteFor: (source: string) => ScannedFileRoute | undefined;
+export declare const fileRouteNamed: (name: string) => ScannedFileRoute | undefined;
+export declare const fileRoutesOf: (framework: FileRouteFramework) => ScannedFileRoute[];
+export declare const isInFileRouteRoot: (path: string) => boolean;
+export {};

package/dist/src/build/fonts/buildFonts.d.ts

@@ -0,0 +1,25 @@
+import type { FontFamilyConfig, FontFetch, FontsConfig } from '../../../types/fonts';
+export declare const FONTS_OUTPUT_DIRECTORY = "assets/fonts";
+export type BuildFontsInput = {
+    buildPath: string;
+    config: FontsConfig;
+    fetch?: FontFetch;
+    projectRoot: string;
+    warn?: (message: string) => void;
+};
+/** An 8-character content hash that always mixes letters and digits, the
+ *  shape the production server recognizes as fingerprinted (and caches
+ *  immutably) and stale-output cleanup recognizes as hashed. */
+export declare const fingerprint: (content: Uint8Array | string) => string;
+/** File name a download is cached under: a hash of its URL and the
+ *  User-Agent it was requested with. */
+export declare const fontCacheKey: (url: string) => string;
+export declare const familyClassName: (family: FontFamilyConfig) => string;
+export declare const familyVariable: (family: FontFamilyConfig) => string;
+/** Downloads/copies the configured fonts into the build and writes their
+ *  stylesheet. Returns the manifest keys to merge and every file written
+ *  (so stale-output cleanup keeps them). */
+export declare const buildFonts: ({ buildPath, config, fetch: fontFetch, projectRoot, warn }: BuildFontsInput) => Promise<{
+    manifest: Record<string, string>;
+    outputPaths: string[];
+}>;

package/dist/src/build/fonts/fallbackMetrics.d.ts

@@ -0,0 +1,13 @@
+import type { FontFallbackCategory, FontMetrics } from '../../../types/fonts';
+export declare const inferFallbackCategory: (family: string) => "sans-serif" | "serif" | "monospace";
+/** The overrides that make the system fallback occupy the same space as the
+ *  web font: `size-adjust` matches average character width, and the
+ *  ascent/descent/line-gap overrides (which apply after size-adjust) match
+ *  the web font's vertical metrics. */
+export declare const computeFallbackOverrides: (metrics: FontMetrics, category: FontFallbackCategory) => {
+    ascentOverride: string;
+    descentOverride: string;
+    lineGapOverride: string;
+    local: string[];
+    sizeAdjust: string;
+};

package/dist/src/build/fonts/googleFonts.d.ts

@@ -0,0 +1,18 @@
+import type { FontFamilyConfig, FontStyle } from '../../../types/fonts';
+export declare const GOOGLE_FONTS_CSS_ORIGIN = "https://fonts.googleapis.com";
+export declare const GOOGLE_FONTS_USER_AGENT = "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/130.0.0.0 Safari/537.36";
+export type GoogleFontFace = {
+    family: string;
+    style: FontStyle;
+    subset: string;
+    unicodeRange?: string;
+    url: string;
+    weight: string;
+};
+export declare const familyStyles: (family: FontFamilyConfig) => FontStyle[];
+export declare const familyWeights: (family: FontFamilyConfig) => string[];
+/** The css2 API URL for one family. Tuples must be sorted, italic last. */
+export declare const googleFontsCssUrl: (family: FontFamilyConfig, display: string) => string;
+/** Every `@font-face` in a css2 response, each tagged with the subset named
+ *  in the comment Google puts before it. */
+export declare const parseGoogleFontsCss: (css: string) => GoogleFontFace[];

package/dist/src/build/fonts/injectFontTags.d.ts

@@ -0,0 +1,7 @@
+import type { FontAssets } from '../../../types/fonts';
+/** Adds the font preloads and stylesheet to a static page's `<head>`,
+ *  ahead of the page's own stylesheets so they can use the font
+ *  variables. Pages that already link the stylesheet, or have no head,
+ *  are left alone. */
+export declare const injectFontHead: (html: string, fonts: FontAssets) => string;
+export declare const injectFontTags: (directory: string, fonts: FontAssets) => Promise<void>;

package/dist/src/build/fonts/parseFontMetrics.d.ts

@@ -0,0 +1,4 @@
+import type { FontMetrics } from '../../../types/fonts';
+/** Reads ascent, descent, line gap, units per em and the frequency-weighted
+ *  average character width from a TTF/OTF/WOFF/WOFF2 file. */
+export declare const parseFontMetrics: (bytes: Uint8Array) => FontMetrics;

package/dist/src/build/generateReactIndexes.d.ts

@@ -1,2 +1,8 @@
 export declare const reactRefreshRuntimePath: string;
-export declare const generateReactIndexFiles: (reactPagesDirectory: string, reactIndexesDirectory: string, isDev?: boolean) => Promise<void>;
+/** A page that lives outside `pages/` under a name of its own: a file
+ *  route (src/build/fileRoutes.ts). */
+export type ExtraReactPage = {
+    name: string;
+    source: string;
+};
+export declare const generateReactIndexFiles: (reactPagesDirectory: string, reactIndexesDirectory: string, isDev?: boolean, extraPages?: readonly ExtraReactPage[]) => Promise<void>;

package/dist/src/build/htmlIncludes.d.ts

@@ -0,0 +1,16 @@
+export type HtmlIncludeResult = {
+    /** Every file pulled in, directly or through another include. */
+    dependencies: string[];
+    html: string;
+};
+type ReadFile = (path: string) => string;
+/** The files `filePath` includes, directly or through other includes.
+ *  Empty when it includes nothing or can't be read/expanded. */
+export declare const collectHtmlIncludeDependencies: (filePath: string) => string[];
+/** Expands every <abs-include> in `html`, which was read from `filePath`.
+ *  Throws on a missing file or an include cycle, naming the chain. */
+export declare const expandHtmlIncludes: (html: string, filePath: string, options?: {
+    readFile?: ReadFile;
+    root?: string;
+}) => HtmlIncludeResult;
+export {};

package/dist/src/build/inlineSourceMapComment.d.ts

@@ -0,0 +1 @@
+export declare const inlineSourceMapComment: (map: unknown) => string;

package/dist/src/build/scanConventions.d.ts

@@ -1,4 +1,7 @@
 import type { FrameworkConventionEntry } from '../../types/conventions';
+/** Whether `fileName` is an error/loading/not-found convention file
+ *  (`error.html`, `Home.error.html`, `not-found.svelte`, …). */
+export declare const isConventionFile: (fileName: string) => boolean;
 export declare const scanConventions: (pagesDir: string, pattern: string) => Promise<{
     conventions: FrameworkConventionEntry | undefined;
     pageFiles: string[];

package/dist/src/build/vitals.d.ts

@@ -0,0 +1,21 @@
+import type { VitalsConfig } from '../../types/build';
+export declare const DEFAULT_VITALS_ENDPOINT = "/__absolute/vitals";
+/** Whether vitals are on for this build: production builds with `vitals`
+ *  set, and dev builds only with `vitals.dev`. */
+export declare const isVitalsEnabled: (config: VitalsConfig | undefined, isDev: boolean) => boolean;
+export declare const resolveVitalsConfig: (config: VitalsConfig) => {
+    endpoint: string;
+    sampleRate: number;
+};
+/** Adds the reporter to a static HTML/HTMX page. */
+export declare const injectVitalsReporterHtml: (html: string) => string;
+export type VitalsBuildArtifacts = {
+    banner: string;
+};
+export declare const materializeVitalsReporter: ({ buildPath, config, generatedRoot, write }: {
+    buildPath: string;
+    config: VitalsConfig;
+    generatedRoot: string;
+    /** Incremental builds reuse the reporter from the full build. */
+    write?: boolean;
+}) => Promise<VitalsBuildArtifacts>;

package/dist/src/client/formActions.d.ts

@@ -0,0 +1,29 @@
+import type { ActionData, ActionFields, ActionPath, ActionResult, AnyFormAction } from '../../types/formAction';
+export type SubmitFormActionOptions = {
+    signal?: AbortSignal;
+};
+/** A reducer for React 19's `useActionState` (JavaScript-only: React
+ *  renders function form actions as `javascript:` URLs on the server; use
+ *  `useFormAction` for forms that also work without JavaScript). */
+export declare const formActionReducer: <Action extends AnyFormAction = AnyFormAction>(path: ActionPath<Action>) => (_previous: unknown, body: FormData) => Promise<ActionResult<ActionData<Action>, ActionFields<Action>>>;
+/** Posts `body` to the action at `path` and returns its result. Network
+ *  and unexpected server failures come back as an error state with a
+ *  `message`; an aborted request rejects with the abort error. */
+export declare const submitFormAction: <Action extends AnyFormAction = AnyFormAction>(path: ActionPath<Action>, body: FormData, options?: SubmitFormActionOptions) => Promise<ActionResult<ActionData<Action>, ActionFields<Action>>>;
+export type FormActionEventDetail = {
+    result: ActionResult;
+};
+/** Fired on the form after every enhanced submission. */
+export declare const FORM_ACTION_EVENT = "absolute:form-action";
+/** Writes `result` into a plain form: field errors into
+ *  `[data-action-error="field"]`, the message into `[data-action-message]`,
+ *  `[data-action-success]` shown on success, `aria-invalid` on the fields
+ *  and `data-action-status` on the form. Focuses the first invalid field. */
+export declare const applyActionResult: (form: HTMLFormElement, result: ActionResult) => void;
+/** Submits `form` with fetch instead of a page load. Returns a function
+ *  that removes the enhancement. */
+export declare const enhanceForm: (form: HTMLFormElement) => () => void;
+/** Enhances every `<form data-absolute-action>` under `root` (except
+ *  `hx-post` forms, which HTMX submits). Returns a function that removes
+ *  the enhancements. */
+export declare const enhanceForms: (root?: ParentNode) => () => void;

package/dist/src/client/index.d.ts

@@ -3,3 +3,5 @@ export { getStreamSwapRuntimeScript } from './streamSwap';
 export { createIslandStore, getIslandStoreServerSnapshot, initializeIslandStores, readIslandStore, subscribeIslandStore } from './islandStore';
 export { startIslands } from './islandRuntime';
 export { captureSsrTextBaselines, prepareBrowserTranslationHydration } from './browserTranslation';
+export { applyActionResult, enhanceForm, enhanceForms, FORM_ACTION_EVENT, formActionReducer, submitFormAction } from './formActions';
+export type { FormActionEventDetail, SubmitFormActionOptions } from './formActions';

package/dist/src/client/navigation.d.ts

@@ -0,0 +1,16 @@
+import type { DocumentNavigationOutcome, EnableNavigationOptions, NavigateDocumentOptions } from '../../types/navigation';
+/** Turn the layer off: listeners removed, history methods restored. */
+export declare const disableNavigation: () => void;
+/**
+ * Install cross-framework document navigation for this tab. Idempotent:
+ * every page can call it (each framework bundle carries its own copy of
+ * this module; the first call wins and its options apply).
+ */
+export declare const enableNavigation: (options?: EnableNavigationOptions) => void;
+/** Whether `enableNavigation()` is active in this tab. */
+export declare const isNavigationEnabled: () => boolean;
+/**
+ * Navigate to `href` through the layer: a soft swap when it is enabled
+ * and the page can be torn down, a normal page load otherwise.
+ */
+export declare const navigateDocument: (href: string, options?: NavigateDocumentOptions) => Promise<DocumentNavigationOutcome>;

package/dist/src/client/prefetch.d.ts

@@ -1,32 +1,4 @@
-/**
- * Framework-neutral navigation prefetch primitive.
- *
- * Pure DOM + `fetch` — no framework imports — so the React, Vue and Svelte
- * `<Link>` components (and user code) share one cache, one in-flight
- * budget, one IntersectionObserver and one set of data-saver guards.
- *
- *   import { prefetch, speculate } from '@absolutejs/absolute/client/prefetch';
- *
- * What a prefetch buys the click that follows:
- *  - `'document'` — the HTML lands in the browser's HTTP cache (pages
- *    carry a content-hash `ETag`), so the real navigation revalidates
- *    with a 304 instead of re-rendering.
- *  - `'module'`   — `<link rel="modulepreload">` parses + compiles the
- *    client module graph ahead of time.
- *  - `'data'`     — the route-data payload
- *    (`application/vnd.absolute.route+json`): the page's props plus the
- *    client entry and stylesheets it needs, which are `modulepreload`ed
- *    / prefetched as the payload lands. A 404 / 406 from a server that
- *    doesn't speak route data is remembered as "no data".
- *  - `'route'`    — `'document'` + `'data'`, i.e. everything a click
- *    needs. What a `<Link>` warms on hover / pointerdown.
- *  - `speculate()` — a prerender speculation rule; the browser renders
- *    the whole target page in a hidden tab so the click is instant.
- *
- * Global opt-out: `window.__ABSOLUTE_PREFETCH__ = false` disables every
- * entry point in this module (useful for analytics-sensitive pages).
- */
-import type { HoverPrefetchHandle, HoverPrefetchOptions, PrefetchKind, PrefetchOptions } from '../../types/prefetch';
+import type { HoverPrefetchHandle, HoverPrefetchOptions, PrefetchKind, PrefetchOptions, ViewportPrefetchOptions } from '../../types/prefetch';
 export declare const ROUTE_DATA_MEDIA_TYPE = "application/vnd.absolute.route+json";
 /** `true` when prefetching is allowed right now: we're in a browser, the
  *  page hasn't opted out via `window.__ABSOLUTE_PREFETCH__ = false`, and
@@ -85,7 +57,7 @@ export declare const scheduleHoverPrefetch: (url: string, options?: HoverPrefetc
  * IntersectionObserver is shared by every link on the page. Returns an
  * unobserve function for the caller's unmount hook.
  */
-export declare const observeViewport: (element: Element, url: string, options?: PrefetchOptions) => () => void;
+export declare const observeViewport: (element: Element, url: string, options?: ViewportPrefetchOptions) => () => void;
 /** Test / teardown helper — forgets injected modulepreload + speculation
  *  rule bookkeeping and cancels any queued fetches. */
 export declare const resetPrefetchState: () => void;

package/dist/src/core/build.d.ts

@@ -9,12 +9,12 @@ import type { BuildConfig, BuildPassError, BunBuildConfigOverride, BunBuildPassK
  *  production build scans once, so it opts out and pays no stat pass. */
 export declare const scanWorkerReferences: (dirs: string[], memoise?: boolean) => Promise<string[]>;
 type BunBuildOptions = Parameters<typeof bunBuild>[0];
-export declare const resolveBunBuildOverride: (config: BuildConfig["bunBuild"], pass: BunBuildPassKey) => Partial<Omit<Bun.BuildConfig, "compile" | "target" | "entrypoints" | "outdir" | "root" | "format" | "throw">>;
+export declare const resolveBunBuildOverride: (config: BuildConfig["bunBuild"], pass: BunBuildPassKey) => Partial<Omit<Bun.BuildConfig, "format" | "compile" | "target" | "entrypoints" | "outdir" | "root" | "throw">>;
 /** Resolve the Bun `sourcemap` mode for CLIENT bundles from the `sourcemaps`
  *  config. Dev always uses inline maps (HMR / devtools); production emits
  *  external maps only when explicitly enabled — they're then chained back to
  *  source + moved to a private dir by `privatizeClientSourcemaps`. */
-export declare const resolveClientSourcemap: (sourcemaps: BuildConfig["sourcemaps"], devMode: boolean) => "none" | "external" | "inline";
+export declare const resolveClientSourcemap: (sourcemaps: BuildConfig["sourcemaps"], devMode: boolean) => "none" | "inline" | "external";
 export declare const mergeBunBuildConfig: (base: BunBuildOptions, override: BunBuildConfigOverride) => Bun.BuildConfig;
 export declare const build: (config: BuildConfig) => Promise<{
     conventions?: undefined;

package/dist/src/core/cspNonce.d.ts

@@ -0,0 +1,12 @@
+export declare const createCspNonce: () => string;
+/** @internal Test hook: turns nonces off again. */
+export declare const disableCspNonces: () => void;
+/** Turns nonces on for this process. Called by `secureHeaders()`; the flag
+ *  lives on globalThis so every bundle (dist/index.js, the framework
+ *  entries) sees the same state. */
+export declare const enableCspNonces: () => void;
+/** The nonce for `request` (default: the request being handled), or
+ *  undefined when `secureHeaders()` isn't in use or there's no request
+ *  (build-time rendering). */
+export declare const getCspNonce: (request?: Request | undefined) => string | undefined;
+export declare const isCspNonceEnabled: () => boolean;

package/dist/src/core/fileRouteAdapter.d.ts

@@ -0,0 +1,15 @@
+import type { FileRouteDefinition, FileRouteFramework, FileRouteRenderInput, FileRouteServerModule } from '../../types/fileRoutes';
+type ServerHooks<Path extends string> = {
+    path: Path;
+    server?: () => Promise<FileRouteServerModule<Path, unknown> | undefined>;
+};
+export declare const serverHooksOf: <Path extends string>({ path, server }: ServerHooks<Path>) => Pick<FileRouteDefinition, "load" | "beforeHandle">;
+export type FileRouteAdapterInput<Path extends string> = {
+    name: string;
+    path: Path;
+    source: string;
+};
+export declare const defineFileRouteWith: <Path extends string>(framework: FileRouteFramework, route: FileRouteAdapterInput<Path> & {
+    server?: () => Promise<FileRouteServerModule<Path, unknown> | undefined>;
+}, render: (input: FileRouteRenderInput) => Promise<Response>) => FileRouteDefinition;
+export {};

package/dist/src/core/fileRoutes.d.ts

@@ -0,0 +1,5 @@
+import { type AnyElysia } from 'elysia';
+import type { FileRouteDefinition } from '../../types/fileRoutes';
+/** Register every file route on the app. Pass the `routeTree` the build
+ *  generates and the manifest from `prepare()`. */
+export declare const fileRoutes: (routes: readonly FileRouteDefinition[], manifest: Record<string, string>) => <App extends AnyElysia>(app: App) => App;

package/dist/src/core/formActionFlash.d.ts

@@ -0,0 +1,25 @@
+import { Elysia } from 'elysia';
+import type { ActionResult } from '../../types/formAction';
+export declare const ACTION_FLASH_COOKIE = "absolute_action";
+export type ActionFlash = {
+    action: string;
+    result: ActionResult;
+};
+export declare const clearActionFlashCookie: (secure: boolean) => string;
+/** `Set-Cookie` value carrying `flash`, shrunk (values or data first, then
+ *  details) until it fits a cookie. */
+export declare const encodeActionFlash: (flash: ActionFlash, secure: boolean) => string;
+/** The flash the request carries, when it is well-formed. */
+export declare const readActionFlash: (request: Request) => ActionFlash | undefined;
+/** Writes `flash` into the page's matching `<form data-absolute-action>`:
+ *  field errors, the form message, the success element, `aria-invalid`
+ *  and (after an error) the values the user typed. */
+export declare const rewriteActionForms: (response: Response, flash: ActionFlash, pageUrl: string) => Response;
+/** Consumes the flash on the first HTML page served while it is set. */
+export declare const consumeActionFlash: (request: Request, response: unknown) => Response | undefined;
+/** Part of the `absolutejs` plugin from `prepare()`: renders and clears
+ *  form-action results on HTML pages. */
+export declare const formActionRuntime: () => Elysia<"", "local", import("elysia").DefaultSingleton, {
+    typebox: {};
+    error: [];
+}, import("elysia").DefaultMetadata, {}, import("elysia").DefaultEphemeral, import("elysia").DefaultEphemeral>;