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

package/dist/src/svelte/router/lazyModule.d.ts

@@ -0,0 +1,29 @@
+import type { Component } from 'svelte';
+export type LazyComponent = Component<Record<string, unknown>>;
+/** `globalThis` record of `route pattern → module` that the hydration
+ *  entry fills before it hydrates a page whose server render included lazy
+ *  routes. Compiled client modules fill a sibling registry,
+ *  `Symbol.for('absolutejs.svelte.lazy-modules')`, of `source id →
+ *  () => import(chunk)` for every `.svelte` file they import dynamically
+ *  (see {@link lazyModuleRegistration}). */
+export declare const LAZY_RESOLVED_KEY: unique symbol;
+/** Export (and component property) the Svelte compiler adds to every
+ *  compiled component: the component's source path, relative to the
+ *  project root. The server records it for each lazy route it rendered so
+ *  the browser can load the same module before hydrating. */
+export declare const LAZY_SOURCE_EXPORT = "__ABSOLUTE_SVELTE_SOURCE__";
+/** The component a loader resolved to: a module namespace's `default`, or
+ *  the value itself when the loader already unwrapped it. */
+export declare const toLazyComponent: (value: unknown) => LazyComponent | undefined;
+/** The statement a compiled client module appends for each `.svelte` file
+ *  it imports dynamically, registering `source id → () => import(chunk)`,
+ *  so the hydration entry can load the module a lazy route rendered on the
+ *  server before it hydrates. Used by the build (compileSvelte) and the dev
+ *  module server. */
+export declare const lazyModuleRegistration: (sourceId: string, specifier: string) => string;
+/** The compiler-stamped source id of a loader result, from the module
+ *  namespace or from the component itself. */
+export declare const readLazySource: (value: unknown) => string | undefined;
+/** The module the hydration entry loaded for `pattern` before hydrating,
+ *  if any. */
+export declare const readSeededLazy: (pattern: string) => LazyComponent | undefined;

package/dist/src/svelte/router/navigation.d.ts

@@ -0,0 +1,55 @@
+import type { GotoOptions, NavigationOutcome, NavigationType, RouteGuard, RouterMode, ScrollPosition } from '../../../types/svelteRouter';
+import { type GuardEntry } from './guards';
+export type RouterNavigationHandle = {
+    /** Guards that apply when navigating to `url`, outermost first. */
+    guardsFor: (url: URL) => GuardEntry[];
+    /** Whether one of this router's routes matches `url`. */
+    matches: (url: URL) => boolean;
+    /** Start loading the lazy route `url` would render, if any. */
+    preload: (url: URL) => void;
+};
+/** @internal Router.svelte: make a router's guards and lazy routes
+ *  visible to navigation. Returns the deregistration. */
+export declare const registerRouter: (handle: RouterNavigationHandle) => () => void;
+/** @internal Router.svelte: which URL strategy goto() writes. */
+export declare const setRouterMode: (mode: RouterMode) => void;
+/**
+ * Run `guard` before every client-side navigation (`<Link>`, `goto()`,
+ * back/forward). Return `false` to cancel, a URL (or `redirect(...)`) to
+ * redirect, nothing to allow. Called during component initialisation it
+ * is removed when the component is destroyed; otherwise call the returned
+ * function to remove it.
+ *
+ * Browser-only: it doesn't run during the server render. Put checks the
+ * server must enforce (auth, a 302 on the first request) on
+ * `<Router guard>` or `<Route guard>` instead.
+ */
+export declare const beforeNavigate: (guard: RouteGuard) => () => void;
+/** Start loading the lazy route component `href` would render, through
+ *  every mounted router. Used by `<Link>` prefetching. */
+export declare const preloadRoute: (href: string) => void;
+/**
+ * @internal Link.svelte: whether a click on `href` belongs to cross-framework
+ * document navigation rather than this router. True only when
+ * `enableNavigation()` is active, the router uses history mode, and no
+ * mounted `<Router>` has a route for the URL: the link points at another
+ * page (possibly another framework's), so `<Link>` leaves the click to the
+ * browser and the navigation layer swaps that page in.
+ */
+export declare const belongsToDocumentNavigation: (href: string) => boolean;
+/** @internal `goto()` and `<Link>`: guarded client-side navigation. */
+export declare const navigate: (target: string, options: GotoOptions, type: NavigationType) => Promise<NavigationOutcome>;
+/** @internal Router.svelte (hash mode): guards for the first client
+ *  render, which the server could not run because it never sees the
+ *  hash. A redirect replaces the entry; a cancel is ignored (there is no
+ *  previous page to stay on). */
+export declare const enterInitialRoute: (url: URL) => Promise<void>;
+/**
+ * @internal Router.svelte: a `popstate` landed. `url` is the routable URL
+ * of the entry it landed on (hash mode already resolved). Runs the guards;
+ * a cancel puts the previous URL back, a redirect replaces the entry.
+ */
+export declare const handleTraversal: (state: unknown, url: URL) => Promise<void>;
+/** @internal Router.svelte: restore the position saved in the entry the
+ *  page loaded on (reload, or back/forward into this document). */
+export declare const restoreInitialScroll: (position: ScrollPosition) => Promise<void>;

package/dist/src/svelte/router/pushState.d.ts

@@ -1,7 +1,9 @@
 /**
  * Shallow routing: update the URL bar and `page.state` without re-running
- * `<Route>` matching. Useful for modals / drawers / overlays that want a
- * shareable URL without swapping the active route's content.
+ * `<Route>` matching, guards or scrolling. Useful for modals / drawers /
+ * overlays that want a shareable URL without swapping the active route's
+ * content. The scroll position of the entry being left is saved, so
+ * going back restores it.
  *
  * Mirrors SvelteKit's `pushState` from `$app/navigation`.
  */

package/dist/src/svelte/router/scroll.d.ts

@@ -0,0 +1,34 @@
+import type { RouterHistoryMeta, ScrollPosition } from '../../../types/svelteRouter';
+export declare const readHistoryMeta: (state: unknown) => RouterHistoryMeta | undefined;
+/** The state the application stored (via `goto({ state })`, `pushState`,
+ *  …), without the router's bookkeeping. */
+export declare const readUserState: (state: unknown) => unknown;
+/** Adopt the entry a `popstate` landed on as the current one. Entries the
+ *  router didn't write (a plain `<a href="#x">` click, say) get stamped. */
+export declare const adoptHistoryEntry: (state: unknown) => RouterHistoryMeta;
+/** The full URL (hash included) of the entry the router currently shows. */
+export declare const currentCommittedHref: () => string | undefined;
+/** The entry the router currently shows. */
+export declare const currentHistoryEntry: () => RouterHistoryMeta | undefined;
+/** Record the live scroll position for the current entry, in memory and in
+ *  the entry's `history.state`, so it survives a reload. */
+export declare const persistScroll: () => void;
+/** Record the live scroll position for the current entry (in memory). */
+export declare const rememberScroll: () => void;
+/** Where the user was when they last left `meta`'s entry, if known. */
+export declare const savedScrollFor: (meta: RouterHistoryMeta) => ScrollPosition | undefined;
+/** Make sure the entry the page loaded on carries router bookkeeping, and
+ *  adopt it as the current one. Returns its meta. */
+export declare const stampInitialEntry: () => RouterHistoryMeta;
+/** Write a new entry (`push`) or replace the current one, saving the
+ *  scroll position of the entry being left first. */
+export declare const writeHistoryEntry: (href: string, user: unknown, mode: "push" | "replace") => RouterHistoryMeta;
+/** Take over scroll restoration from the browser while a router is
+ *  mounted: `history.scrollRestoration = 'manual'`, track the scroll
+ *  position of the current entry, and persist it on `pagehide`. Returns
+ *  the cleanup that hands control back. */
+export declare const activateScrollRestoration: () => () => void;
+/** Scroll the `#hash` target into view. Returns whether one was found —
+ *  `#` and `#top` scroll to the top, as browsers do. */
+export declare const scrollToHash: (hash: string) => boolean;
+export declare const scrollToPosition: (position: ScrollPosition) => void;

package/dist/src/svelte/routerSsr.d.ts

@@ -0,0 +1,9 @@
+/** Context key the router reads (Router.svelte / Route.svelte use the
+ *  same `Symbol.for` name). */
+export declare const SVELTE_ROUTER_SSR_CONTEXT_KEY: unique symbol;
+export declare const createSvelteRouterSsr: (request: Request | undefined) => {
+    bootstrapScript: () => string;
+    context: Map<unknown, unknown>;
+    response: () => Response | undefined;
+    settle: () => Promise<boolean>;
+};

package/dist/src/svelte/server.d.ts

@@ -1 +1,2 @@
+export { svelteFileRoute } from './fileRoute';
 export { handleSveltePageRequest } from './pageHandler';

package/dist/src/utils/cspNonceRef.d.ts

@@ -0,0 +1,8 @@
+/** ` nonce="…"` for an inline <script>/<style> tag, or '' without one. */
+export declare const nonceAttr: (nonce?: string | undefined) => string;
+/** Adds the nonce to the <style id="svelte-…"> tags Svelte renders into the
+ *  head for components compiled with injected CSS. Only those: a <style>
+ *  that arrived through {@html} stays without one. */
+export declare const nonceSvelteHeadStyles: (head: string, nonce?: string | undefined) => string;
+export declare const readCspNonce: () => string | undefined;
+export declare const registerCspNonceGetter: (getter: () => string | undefined) => void;

package/dist/src/utils/fontAssets.d.ts

@@ -0,0 +1,17 @@
+import type { FontAssets } from '../../types/fonts';
+export declare const FONT_PRELOAD_MANIFEST_PREFIX = "AbsoluteFontPreload";
+export declare const FONTS_CSS_MANIFEST_KEY = "AbsoluteFontsCSS";
+export declare const FONTS_REMOTE_CSS_MANIFEST_PREFIX = "AbsoluteFontsRemoteCSS";
+/** The font stylesheet(s) and preloads the build produced from the `fonts`
+ *  config, read from the manifest. Pass the result to `Head`'s or
+ *  `generateHeadElement`'s `fonts` option. Empty when no fonts are
+ *  configured. Plain data, safe to pass as a page prop. */
+export declare const fontAssets: (manifest: Record<string, string>) => FontAssets;
+export declare const fontMimeType: (href: string) => string;
+/** Origins a font stylesheet loads from, for `preconnect` hints. Only
+ *  remote (fallback) stylesheets need them. */
+export declare const fontPreconnectOrigins: (fonts: FontAssets) => string[];
+/** `<link>` tags for a page's `<head>`: preconnects (remote fallback only),
+ *  font preloads, then the stylesheets. All linked, never inline, so they
+ *  work under a strict Content-Security-Policy. */
+export declare const renderFontTags: (fonts: FontAssets) => string[];

package/dist/src/utils/formActionProtocol.d.ts

@@ -0,0 +1,10 @@
+import type { ActionResult } from '../../types/formAction';
+export declare const ACTION_ERROR_ATTRIBUTE = "data-action-error";
+export declare const ACTION_FORM_ATTRIBUTE = "data-absolute-action";
+export declare const ACTION_MESSAGE_ATTRIBUTE = "data-action-message";
+export declare const ACTION_REQUEST_HEADER = "x-absolute-action";
+export declare const ACTION_STATUS_ATTRIBUTE = "data-action-status";
+export declare const ACTION_SUCCESS_ATTRIBUTE = "data-action-success";
+/** True for a well-formed action result. The type parameters let callers
+ *  name the action's data and fields; only the shape is checked. */
+export declare const isActionResult: <Data = unknown, Fields extends string = string>(value: unknown) => value is ActionResult<Data, Fields>;

package/dist/src/utils/generateHeadElement.d.ts

@@ -1,5 +1,5 @@
 import type { Metadata, SpeculationRules } from '../../types/metadata';
-export declare const generateHeadElement: ({ cssPath, title, description, font, icon, canonical, openGraph, twitter, robots, meta, jsonLd, preload, speculationRules }?: Metadata) => `<head>
+export declare const generateHeadElement: ({ cssPath, title, description, font, fonts, icon, canonical, alternates, openGraph, twitter, robots, meta, jsonLd, preload, speculationRules }?: Metadata) => `<head>
   ${string}
 </head>`;
 /** Serialize declarative speculation rules to the JSON body of a

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

@@ -1,6 +1,7 @@
 export * from './defineConfig';
 export * from './defineConvention';
 export * from './generateHeadElement';
+export { fontAssets } from './fontAssets';
 export * from './iconVersion';
 export * from './jsonLd';
 export * from './defineEnv';

package/dist/src/utils/inlinePageCss.d.ts

@@ -1,3 +1,21 @@
+/** Read the per-page compiled CSS sidecar that the build emitted next to
+ *  the SSR JS, and splice it into the SSR head as an inline <style>
+ *  block. Used by each framework's page handler so scoped/per-page
+ *  styles are present on first paint instead of loading client-side
+ *  after hydration (which produces a one-frame flash of unstyled
+ *  chrome — sidebar/logo/cards).
+ *
+ *  The CSS sidecar is written by `core/build.ts` after the server and
+ *  CSS Bun.build passes finish: for each SSR JS output, a `.css` file
+ *  with the same basename + hash is placed beside it. The handler
+ *  derives the sidecar path from the SSR JS path it already has
+ *  (`pagePath` / `index`) so there's no manifest lookup, no extra
+ *  argument the user must thread through, and no chance of getting
+ *  the URL hash wrong.
+ *
+ *  Content-hashed filenames mean the sidecar is immutable for the
+ *  lifetime of a build, so the read is memoised by absolute path and
+ *  the handler hits `readFile` at most once per page per process. */
 /** Drop every memoised sibling-CSS read (including cached misses). The dev
  *  server calls this after rebuilding page bundles: a request landing
  *  mid-rebuild can otherwise cache '' for a freshly hashed path whose

package/dist/src/utils/loadConfig.d.ts

@@ -10,9 +10,11 @@ export declare const loadConfig: (configPath?: string) => Promise<{
         bootstrap?: string;
     };
     reactDirectory?: string;
+    reactServerComponentsDirectory?: string;
     vueDirectory?: string;
     angularDirectory?: string;
     angular?: {
+        changeDetection?: import("..").AngularChangeDetection;
         providers?: ReadonlyArray<import("@angular/core").Provider | import("@angular/core").EnvironmentProviders>;
     };
     astroDirectory?: string;
@@ -53,7 +55,10 @@ export declare const loadConfig: (configPath?: string) => Promise<{
     static?: import("..").StaticConfig;
     compile?: import("..").CompileConfig;
     images?: import("..").ImageConfig;
+    fonts?: import("..").FontsConfig;
+    vitals?: import("..").VitalsConfig;
     sitemap?: import("..").SitemapConfig;
+    fileRoutes?: boolean | import("..").FileRoutesConfig;
     openapi?: boolean | import("..").OpenApiConfig;
     telemetry?: boolean | import("..").OtelConfig;
     sourcemaps?: "external" | "inline" | boolean;

package/dist/src/utils/localeRef.d.ts

@@ -0,0 +1,10 @@
+import type { TextDirection } from '../../types/i18n';
+export type RequestLocale = {
+    locale: string;
+    dir: TextDirection;
+};
+/** ` lang="…" dir="…"` for the request's locale, or ` lang="<fallback>"`
+ *  when no i18n plugin resolved one. */
+export declare const htmlLangAttributes: (fallback?: string) => string;
+export declare const readRequestLocale: () => RequestLocale | undefined;
+export declare const registerRequestLocaleGetter: (getter: () => RequestLocale | undefined) => void;

package/dist/src/utils/resolveConvention.d.ts

@@ -7,4 +7,9 @@ export declare const resolveNotFoundConventionPath: (framework: keyof Convention
 export declare const setConventions: (map: ConventionsMap) => void;
 export declare const renderConventionError: (framework: keyof ConventionsMap, pageName: string, error: unknown) => Promise<Response | null>;
 export declare const renderConventionNotFound: (framework: keyof ConventionsMap) => Promise<Response | null>;
-export declare const renderFirstNotFound: () => Promise<Response | null>;
+/** Renders the first available not-found convention. An HTMX request
+ *  (`HX-Request` header) tries the HTMX pages directory's not-found.html
+ *  first, so an HTMX swap gets HTMX markup. */
+export declare const renderFirstNotFound: (options?: {
+    preferHtmx?: boolean;
+}) => Promise<Response | null>;

package/dist/src/utils/streamingSlots.d.ts

@@ -29,6 +29,11 @@ type StreamingSlotPolicyValue = {
     onSlotMetric?: StreamingSlotMetricHandler;
 };
 export type StreamingSlot = {
+    /** Resolve this slot on every request, even when the page is
+     *  pre-rendered: the cached shell keeps the fallback and the content
+     *  streams in per request (partial prerendering). Off by default, so a
+     *  pre-rendered page bakes the slot's content into its HTML. */
+    dynamic?: boolean;
     errorHtml?: unknown;
     fallbackHtml?: unknown;
     id: string;

package/dist/src/vue/browser.d.ts

@@ -1,6 +1,8 @@
 export { Island } from './Island.browser';
 export { createTypedIsland } from './createIsland.browser';
 export { useIslandStore } from './useIslandStore';
+export { useServerData } from './useServerData.browser';
+export type { ServerData, ServerDataFetcher, ServerDataOptions } from '../../types/vue';
 export { captureSsrTextBaselines, prepareBrowserTranslationHydration, preserveBrowserTranslation } from './browserTranslation';
 export { defineRoutes, defineVueSetupApp } from './defineVuePage';
 export { applyVueRouterRedirect } from './routerRedirectProviders';

package/dist/src/vue/components/Image.d.ts

@@ -51,16 +51,16 @@ export declare const Image: import("vue").DefineComponent<{
     fetchPriority?: "high" | "low" | "auto" | undefined;
     overrideSrc?: string | undefined;
 }> & Readonly<{}>, {
-    style: Record<string, any>;
     fill: boolean;
+    style: Record<string, any>;
     loader: Function;
     loading: string;
     onError: Function;
     height: number;
     width: number;
     placeholder: string;
-    onLoad: Function;
     className: string;
+    onLoad: Function;
     quality: number;
     unoptimized: boolean;
     sizes: string;

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

@@ -9,6 +9,8 @@ export { captureSsrTextBaselines, prepareBrowserTranslationHydration, preserveBr
 export { Image } from './components/Image';
 export { StreamSlot, SuspenseSlot } from './components';
 export { useResource } from './useResource';
+export { useServerData } from './useServerData';
+export type { ServerData, ServerDataFetcher, ServerDataOptions } from '../../types/vue';
 export { Link } from './router/Link';
 export { usePrefetch } from './usePrefetch';
 export type { UsePrefetchOptions } from './usePrefetch';

package/dist/src/vue/serverDataPayload.d.ts

@@ -0,0 +1,32 @@
+import type { ServerDataCollector } from '../../types/vue';
+/** Property on the Vue `SSRContext` that carries the request's collector.
+ *  A plain string (not a symbol) so it survives a page bundle that ends up
+ *  with its own copy of this module. */
+export declare const SERVER_DATA_CONTEXT_KEY = "__absoluteServerData";
+/** Reserves `key` for this request and returns whether the caller owns it.
+ *  Two components using one key would overwrite each other's payload and
+ *  hydrate from the wrong value, so a repeated key is refused. Outside
+ *  production the collector records an error that fails the page once
+ *  rendering ends (throwing from `setup()` would leave Vue's SSR state
+ *  half-reset); in production a warning is logged and the repeated call
+ *  loads in the browser. */
+export declare const claimServerDataKey: (collector: ServerDataCollector, key: string) => boolean;
+export declare const createServerDataCollector: () => ServerDataCollector;
+export declare const isServerDataCollector: (value: unknown) => value is ServerDataCollector;
+/** The inline script that hands `useServerData` results to the browser, or
+ *  an empty string when the page loaded none. Every inline script for this
+ *  payload is written here, so attributes such as a CSP nonce belong in
+ *  this one place. The JSON is escaped so no value can close the script
+ *  element or break the JavaScript around it. */
+export declare const serializeServerDataScript: (collector: ServerDataCollector | null) => string;
+/** Records a failed load and returns the error to render with: the one the
+ *  browser receives, with its message replaced in production. */
+export declare const storeServerDataError: (collector: ServerDataCollector, key: string, cause: unknown) => Error;
+/** Serializes the value now so an unserializable result (a cycle, a
+ *  BigInt) becomes this key's error state instead of breaking the page.
+ *  Returns the error when serialization failed. */
+export declare const storeServerDataValue: (collector: ServerDataCollector, key: string, value: unknown) => Error | null;
+/** Throws the error a render recorded (a repeated key in development), so
+ *  the page handler fails the response instead of serving a page whose
+ *  payload is ambiguous. */
+export declare const throwServerDataFailure: (collector: ServerDataCollector) => void;

package/dist/src/vue/serverDataState.d.ts

@@ -0,0 +1,9 @@
+import type { ServerData, ServerDataErrorEntry, ServerDataFetcher } from '../../types/vue';
+/** Refs plus an abortable `refresh`, shared by the server and browser
+ *  builds of `useServerData`. */
+export declare const createServerDataState: <T>(fetcher: ServerDataFetcher<T>, initiallyPending: boolean) => ServerData<T>;
+export declare const errorFromEntry: ({ error }: ServerDataErrorEntry) => Error;
+/** The page payload for a key was produced by this same fetcher on the
+ *  server, so its value has the fetcher's result type. This predicate
+ *  records that contract for the compiler; JSON cannot carry the type. */
+export declare const isFetcherResult: <T>(_fetcher: ServerDataFetcher<T>, _value: unknown) => _value is T;

package/dist/src/vue/useServerData.browser.d.ts

@@ -0,0 +1,6 @@
+import type { ServerDataFetcher, ServerDataOptions } from '../../types/vue';
+/** Browser build of `useServerData`: hydrates from the value the server
+ *  wrote into the page without calling the fetcher, and calls the fetcher
+ *  when the page carries no value for `key`. See the server build for the
+ *  full contract. */
+export declare const useServerData: <T>(key: string, fetcher: ServerDataFetcher<T>, _options?: ServerDataOptions) => import("./browser").ServerData<T>;

package/dist/src/vue/useServerData.d.ts

@@ -0,0 +1,24 @@
+import type { ServerData, ServerDataFetcher, ServerDataOptions } from '../../types/vue';
+/** Loads data while the page renders on the server and hands it to the
+ *  browser with the page, so hydration reuses it instead of fetching again.
+ *  When no server value exists (a client-side route change, `server: false`,
+ *  or a page whose shell is not server-rendered) it loads in the browser.
+ *
+ *  Call it in a component's `setup()`. `key` must be unique among the
+ *  `useServerData` calls of one request; the result must be JSON
+ *  serializable.
+ *
+ *  ```ts
+ *  const loadProfile = async (signal: AbortSignal): Promise<Profile> => {
+ *  	const response = await fetch('https://api.example.com/me', { signal });
+ *
+ *  	return response.json();
+ *  };
+ *  const { data, error, pending, refresh } = useServerData(
+ *  	'profile',
+ *  	loadProfile
+ *  );
+ *  ```
+ *
+ *  This is the server build; the browser build reads the page payload. */
+export declare const useServerData: <T>(key: string, fetcher: ServerDataFetcher<T>, options?: ServerDataOptions) => ServerData<T>;