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

package/dist/types/svelteRouter.d.ts

@@ -46,11 +46,98 @@ export type GotoOptions = {
     replaceState?: boolean;
     /** Don't reset focus to body on navigation. */
     keepFocus?: boolean;
-    /** Don't scroll to top on navigation. */
+    /** Leave the scroll position alone: no scroll to the top, no scroll to
+     *  the `#hash` target. */
     noScroll?: boolean;
-    /** Value attached to `history.state`. */
+    /** Value attached to `history.state`, read back as `page.state`. */
     state?: unknown;
 };
+/** How a navigation started.
+ *
+ *  - `'link'` — a `<Link>` click.
+ *  - `'goto'` — a programmatic `goto()` call.
+ *  - `'popstate'` — the browser's back / forward buttons (or `history.go`).
+ *  - `'enter'` — the first render of the page: the server render, or the
+ *    first client render in hash mode (the server never sees the hash). */
+export type NavigationType = 'link' | 'goto' | 'popstate' | 'enter';
+/** What a guard sees about the navigation it is asked to allow. */
+export type NavigationContext = {
+    /** The URL being left. `null` on the first render (`type: 'enter'`). */
+    from: URL | null;
+    /** The URL being entered. In hash mode `to.pathname` is the routed path. */
+    to: URL;
+    /** Params of the route the guard belongs to, matched against `to`.
+     *  Empty for `beforeNavigate` guards and for a `<Router guard>` whose
+     *  routes don't match `to`. */
+    params: Record<string, string | undefined>;
+    type: NavigationType;
+    /** The incoming request during the server render, so a guard can read
+     *  cookies or headers. `undefined` in the browser. */
+    request: Request | undefined;
+};
+/** Redirect the navigation somewhere else. `replace: true` replaces the
+ *  current history entry instead of adding one (browser only; the server
+ *  always answers a redirect with a 302). */
+export type NavigationRedirectTarget = {
+    redirect: string;
+    replace?: boolean;
+};
+/** What a guard returns.
+ *
+ *  - nothing / `undefined` / `true` — allow.
+ *  - `false` — cancel: the URL and the rendered route stay as they were.
+ *  - a URL string or `{ redirect }` — navigate there instead. */
+export type RouteGuardResult = undefined | void | boolean | string | NavigationRedirectTarget;
+export type RouteGuard = (navigation: NavigationContext) => RouteGuardResult | Promise<RouteGuardResult>;
+/** What `goto()` resolves to once the navigation has settled. */
+export type NavigationOutcome = 'committed' | 'cancelled' | 'redirected' | 'superseded' | 'external';
+/** A lazily loaded route component: the module namespace returned by
+ *  `import('./Page.svelte')`, or the component itself. */
+export type LazyRouteModule<Props extends Record<string, unknown> = Record<string, unknown>> = {
+    default: import('svelte').Component<Props>;
+} | import('svelte').Component<Props>;
+export type LazyRouteLoader<Props extends Record<string, unknown> = Record<string, unknown>> = () => Promise<LazyRouteModule<Props>>;
+export type ScrollPosition = {
+    x: number;
+    y: number;
+};
+/** Router bookkeeping stored in `history.state`, next to the user's own
+ *  state (which `page.state` exposes unchanged). */
+export type RouterHistoryMeta = {
+    index: number;
+    key: string;
+    scroll?: ScrollPosition;
+};
+/** @internal What the server records for a lazy route it rendered. */
+export type SvelteRouterSsrResolved = {
+    component: import('svelte').Component<Record<string, unknown>>;
+    source: string | undefined;
+} | {
+    error: unknown;
+};
+/** @internal What a server-side guard decided for the whole request. */
+export type SvelteRouterSsrOutcome = {
+    kind: 'redirect';
+    location: string;
+} | {
+    kind: 'cancel';
+};
+/** @internal Per-request state the Svelte page handler passes the router
+ *  through Svelte context, so guards and lazy routes can be awaited
+ *  between render passes. */
+export type SvelteRouterSsrState = {
+    /** Queue work (a guard chain) to run once the current pass ends. */
+    afterRender: (task: () => Promise<void>) => void;
+    /** Start loading a lazy route's component; the page handler awaits it
+     *  and renders again with the component in `resolved`. */
+    load: (key: string, loader: () => Promise<unknown>) => void;
+    outcome: () => SvelteRouterSsrOutcome | undefined;
+    request: Request | undefined;
+    resolved: Map<string, SvelteRouterSsrResolved>;
+    /** Guard chains already run, so a later pass doesn't run them again. */
+    settledGuards: Set<string>;
+    setOutcome: (outcome: SvelteRouterSsrOutcome) => void;
+};
 export type LinkPrefetchMode = 'hover' | 'viewport' | 'none';
 export type PageState = {
     url: URL;

package/dist/types/svelteRouter.ts

@@ -69,12 +69,122 @@ export type GotoOptions = {
 	replaceState?: boolean;
 	/** Don't reset focus to body on navigation. */
 	keepFocus?: boolean;
-	/** Don't scroll to top on navigation. */
+	/** Leave the scroll position alone: no scroll to the top, no scroll to
+	 *  the `#hash` target. */
 	noScroll?: boolean;
-	/** Value attached to `history.state`. */
+	/** Value attached to `history.state`, read back as `page.state`. */
 	state?: unknown;
 };
 
+/** How a navigation started.
+ *
+ *  - `'link'` — a `<Link>` click.
+ *  - `'goto'` — a programmatic `goto()` call.
+ *  - `'popstate'` — the browser's back / forward buttons (or `history.go`).
+ *  - `'enter'` — the first render of the page: the server render, or the
+ *    first client render in hash mode (the server never sees the hash). */
+export type NavigationType = 'link' | 'goto' | 'popstate' | 'enter';
+
+/** What a guard sees about the navigation it is asked to allow. */
+export type NavigationContext = {
+	/** The URL being left. `null` on the first render (`type: 'enter'`). */
+	from: URL | null;
+	/** The URL being entered. In hash mode `to.pathname` is the routed path. */
+	to: URL;
+	/** Params of the route the guard belongs to, matched against `to`.
+	 *  Empty for `beforeNavigate` guards and for a `<Router guard>` whose
+	 *  routes don't match `to`. */
+	params: Record<string, string | undefined>;
+	type: NavigationType;
+	/** The incoming request during the server render, so a guard can read
+	 *  cookies or headers. `undefined` in the browser. */
+	request: Request | undefined;
+};
+
+/** Redirect the navigation somewhere else. `replace: true` replaces the
+ *  current history entry instead of adding one (browser only; the server
+ *  always answers a redirect with a 302). */
+export type NavigationRedirectTarget = {
+	redirect: string;
+	replace?: boolean;
+};
+
+/** What a guard returns.
+ *
+ *  - nothing / `undefined` / `true` — allow.
+ *  - `false` — cancel: the URL and the rendered route stay as they were.
+ *  - a URL string or `{ redirect }` — navigate there instead. */
+export type RouteGuardResult =
+	| undefined
+	| void
+	| boolean
+	| string
+	| NavigationRedirectTarget;
+
+export type RouteGuard = (
+	navigation: NavigationContext
+) => RouteGuardResult | Promise<RouteGuardResult>;
+
+/** What `goto()` resolves to once the navigation has settled. */
+export type NavigationOutcome =
+	| 'committed'
+	| 'cancelled'
+	| 'redirected'
+	| 'superseded'
+	| 'external';
+
+/** A lazily loaded route component: the module namespace returned by
+ *  `import('./Page.svelte')`, or the component itself. */
+export type LazyRouteModule<
+	Props extends Record<string, unknown> = Record<string, unknown>
+> =
+	| { default: import('svelte').Component<Props> }
+	| import('svelte').Component<Props>;
+
+export type LazyRouteLoader<
+	Props extends Record<string, unknown> = Record<string, unknown>
+> = () => Promise<LazyRouteModule<Props>>;
+
+export type ScrollPosition = { x: number; y: number };
+
+/** Router bookkeeping stored in `history.state`, next to the user's own
+ *  state (which `page.state` exposes unchanged). */
+export type RouterHistoryMeta = {
+	index: number;
+	key: string;
+	scroll?: ScrollPosition;
+};
+
+/** @internal What the server records for a lazy route it rendered. */
+export type SvelteRouterSsrResolved =
+	| {
+			component: import('svelte').Component<Record<string, unknown>>;
+			source: string | undefined;
+	  }
+	| { error: unknown };
+
+/** @internal What a server-side guard decided for the whole request. */
+export type SvelteRouterSsrOutcome =
+	| { kind: 'redirect'; location: string }
+	| { kind: 'cancel' };
+
+/** @internal Per-request state the Svelte page handler passes the router
+ *  through Svelte context, so guards and lazy routes can be awaited
+ *  between render passes. */
+export type SvelteRouterSsrState = {
+	/** Queue work (a guard chain) to run once the current pass ends. */
+	afterRender: (task: () => Promise<void>) => void;
+	/** Start loading a lazy route's component; the page handler awaits it
+	 *  and renders again with the component in `resolved`. */
+	load: (key: string, loader: () => Promise<unknown>) => void;
+	outcome: () => SvelteRouterSsrOutcome | undefined;
+	request: Request | undefined;
+	resolved: Map<string, SvelteRouterSsrResolved>;
+	/** Guard chains already run, so a later pass doesn't run them again. */
+	settledGuards: Set<string>;
+	setOutcome: (outcome: SvelteRouterSsrOutcome) => void;
+};
+
 export type LinkPrefetchMode = 'hover' | 'viewport' | 'none';
 
 export type PageState = {

package/dist/types/vue.d.ts

@@ -1,4 +1,4 @@
-import type { AllowedComponentProps, App, ComponentCustomProps, VNodeProps } from 'vue';
+import type { AllowedComponentProps, App, ComponentCustomProps, Ref, VNodeProps } from 'vue';
 import type { Router } from 'vue-router';
 /** The vue-router instance AbsoluteJS auto-creates from a page's `routes`
  *  export. Aliased to vue-router's own `Router` so consumers get the full,
@@ -51,4 +51,49 @@ export type VueComponentInstance = {
     setupState?: Record<string, unknown>;
     subTree?: VueVNode;
 };
+/** Loads the value `useServerData` stores under its key. Receives an
+ *  `AbortSignal` that aborts when the component unmounts or `refresh()` runs
+ *  again; pass it to `fetch` so stale requests are cancelled. */
+export type ServerDataFetcher<T> = (signal: AbortSignal) => Promise<T>;
+export type ServerDataOptions = {
+    /** Run the fetcher during server rendering and send the result to the
+     *  browser with the page. Default: `true`. Set `false` to always load on
+     *  the client (the server renders the pending state). */
+    server?: boolean;
+};
+export type ServerData<T> = {
+    /** The loaded value, or `null` before the first successful load. */
+    data: Ref<T | null>;
+    /** The last load failure, or `null`. A failure on the server reaches the
+     *  browser as an `Error` with the same `name`; its message is replaced
+     *  with a generic one in production. */
+    error: Ref<Error | null>;
+    /** True while a load is in flight. */
+    pending: Ref<boolean>;
+    /** Runs the fetcher again in the browser. An in-flight load is aborted
+     *  first. */
+    refresh: () => Promise<void>;
+};
+/** A serialized server failure, as written into the page. */
+export type ServerDataErrorEntry = {
+    error: {
+        message: string;
+        name: string;
+    };
+};
+/** One key's server result, as written into the page. */
+export type ServerDataEntry = {
+    data: unknown;
+} | ServerDataErrorEntry;
+/** Per-request store the Vue page handler puts on the SSR context. Keys are
+ *  claimed during `setup()`; `json` holds each result already serialized so
+ *  a value that cannot be serialized fails while the page renders, not
+ *  while the tail is written. */
+export type ServerDataCollector = {
+    claimed: Set<string>;
+    /** A render error recorded while setup() ran (a repeated key in
+     *  development), thrown by the page handler once rendering ends. */
+    failure: Error | null;
+    json: Map<string, string>;
+};
 export {};

package/dist/utils/iconVersion.ts

@@ -0,0 +1,34 @@
+// Browsers — Chrome especially — cache favicons in a store that is separate
+// from (and far stickier than) the HTTP cache. It ignores `must-revalidate`
+// and even survives a hard reload, and it caches *negative* results ("this
+// origin has no favicon") when an early request 404s. The only reliable way
+// to force a re-fetch is to change the icon's URL. Rather than make every app
+// hand-rename `favicon-v2.ico`, `favicon-v3.ico`, ... on each change, the
+// framework appends a content-hash query (`?v=<hash>`) to the favicon href so
+// the URL changes automatically whenever the icon bytes change.
+//
+// The hash is computed server-side (it needs filesystem access to the build
+// dir), so this module holds an optional resolver that `prepare` registers at
+// startup. `generateHeadElement` — which also runs in client bundles where no
+// resolver is set — calls `applyIconVersion`, which is a no-op until the
+// resolver is registered. That keeps the head builder isomorphic-safe.
+
+type IconVersionResolver = (href: string) => string;
+
+export const iconMimeType = (icon: string) => {
+	if (icon.endsWith('.svg')) return 'image/svg+xml';
+	if (icon.endsWith('.png')) return 'image/png';
+
+	return 'image/x-icon';
+};
+
+let resolver: IconVersionResolver | undefined;
+
+export const applyIconVersion = (href: string) =>
+	resolver ? resolver(href) : href;
+
+export const setIconVersionResolver = (
+	resolverFn: IconVersionResolver | undefined
+) => {
+	resolver = resolverFn;
+};

package/dist/vue/browser.js

@@ -440,6 +440,84 @@ var useIslandStore = (store, selector) => {
   });
   return state;
 };
+// src/vue/serverDataState.ts
+import { getCurrentScope, onScopeDispose, ref, shallowRef } from "vue";
+var toError = (cause) => cause instanceof Error ? cause : new Error(String(cause));
+var createServerDataState = (fetcher, initiallyPending) => {
+  const data = shallowRef(null);
+  const error = shallowRef(null);
+  const pending = ref(initiallyPending);
+  let controller = null;
+  let disposed = false;
+  const cancel = () => {
+    controller?.abort();
+    controller = null;
+  };
+  const finish = (current) => {
+    if (controller === current)
+      controller = null;
+    if (!current.signal.aborted)
+      pending.value = false;
+  };
+  const refresh = async () => {
+    if (disposed)
+      return;
+    cancel();
+    const current = new AbortController;
+    controller = current;
+    pending.value = true;
+    error.value = null;
+    try {
+      const result = await fetcher(current.signal);
+      if (!current.signal.aborted)
+        data.value = result;
+    } catch (cause) {
+      if (!current.signal.aborted)
+        error.value = toError(cause);
+    } finally {
+      finish(current);
+    }
+  };
+  if (getCurrentScope()) {
+    onScopeDispose(() => {
+      disposed = true;
+      cancel();
+    });
+  }
+  const result = { data, error, pending, refresh };
+  return result;
+};
+var errorFromEntry = ({ error }) => {
+  const restored = new Error(error.message);
+  restored.name = error.name;
+  return restored;
+};
+var isFetcherResult = (_fetcher, _value) => true;
+
+// src/vue/useServerData.browser.ts
+var takeServerDataEntry = (key) => {
+  const payload = typeof window === "undefined" ? undefined : window.__ABSOLUTE_SERVER_DATA__;
+  if (!payload || !Object.hasOwn(payload, key))
+    return null;
+  const entry = payload[key];
+  Reflect.deleteProperty(payload, key);
+  return entry ?? null;
+};
+var useServerData = (key, fetcher, _options = {}) => {
+  const entry = takeServerDataEntry(key);
+  const state = createServerDataState(fetcher, entry === null);
+  if (entry === null) {
+    state.refresh();
+    return state;
+  }
+  if ("error" in entry) {
+    state.error.value = errorFromEntry(entry);
+    return state;
+  }
+  if (isFetcherResult(fetcher, entry.data))
+    state.data.value = entry.data;
+  return state;
+};
 // src/client/browserTranslation.ts
 init_browserTranslationAttributes();
 var translatedFontText = (node, baselines) => {
@@ -618,6 +696,20 @@ var applyVueRouterRedirect = (router, requestedUrl, setRedirect, status = DEFAUL
 // src/vue/router/Link.ts
 import { defineComponent as defineComponent3, getCurrentInstance, h as h3 } from "vue";
 
+// src/dev/client/cspNonce.ts
+var applyPageNonce = (element) => {
+  const nonce = readPageNonce();
+  if (nonce)
+    element.nonce = nonce;
+  return element;
+};
+var readPageNonce = () => {
+  if (typeof document === "undefined")
+    return;
+  const carrier = document.querySelector("script[nonce], style[nonce]");
+  return carrier?.nonce || undefined;
+};
+
 // src/client/prefetch.ts
 var PREFETCH_CACHE_LIMIT = 16;
 var HOVER_DEBOUNCE_MS = 250;
@@ -892,7 +984,7 @@ var speculate = (url) => {
     liveSpeculationRules.get(oldest.value)?.remove();
     liveSpeculationRules.delete(oldest.value);
   }
-  const script = document.createElement("script");
+  const script = applyPageNonce(document.createElement("script"));
   script.type = "speculationrules";
   script.textContent = JSON.stringify({
     prerender: [{ eagerness: "immediate", urls: [url] }]
@@ -911,6 +1003,7 @@ var scheduleHoverPrefetch = (url, options = {}) => {
     prefetch(url, { kind: options.kind ?? "route" });
     if (options.prerender)
       speculate(url);
+    options.onPrefetch?.();
   }, HOVER_DEBOUNCE_MS);
   return {
     cancel: () => window.clearTimeout(timer)
@@ -925,8 +1018,10 @@ var handleIntersections = (entries) => {
     const target = viewportTargets.get(entry.target);
     viewportObserver?.unobserve(entry.target);
     viewportTargets.delete(entry.target);
-    if (target)
-      prefetch(target.url, target.options);
+    if (!target)
+      continue;
+    prefetch(target.url, { kind: target.options.kind });
+    target.options.onVisible?.();
   }
 };
 var getViewportObserver = () => {
@@ -955,16 +1050,16 @@ var observeViewport = (element, url, options = {}) => {
 
 // src/vue/usePrefetch.ts
 import {
-  getCurrentScope,
-  onScopeDispose,
-  ref,
+  getCurrentScope as getCurrentScope2,
+  onScopeDispose as onScopeDispose2,
+  ref as ref2,
   toValue,
   watchEffect
 } from "vue";
 var usePrefetch = (href, options = {}) => {
   const viewportKind = options.kind ?? "document";
   const triggerKind = options.kind ?? "route";
-  const element = ref(null);
+  const element = ref2(null);
   let hoverHandle = null;
   const currentHref = () => toValue(href);
   const currentMode = () => toValue(options.mode) ?? resolveDefaultPrefetchMode();
@@ -1009,8 +1104,8 @@ var usePrefetch = (href, options = {}) => {
       onCleanup(observeViewport(node, target, { kind: viewportKind }));
     }, { flush: "post" });
   }
-  if (getCurrentScope())
-    onScopeDispose(cancelHover);
+  if (getCurrentScope2())
+    onScopeDispose2(cancelHover);
   return {
     element,
     onBlur: cancelHover,
@@ -1106,8 +1201,9 @@ export {
   prepareBrowserTranslationHydration,
   preserveBrowserTranslation,
   useIslandStore,
-  usePrefetch
+  usePrefetch,
+  useServerData
 };
 
-//# debugId=A73C3B0A98113D7964756E2164756E21
+//# debugId=14B61170EEA73C5764756E2164756E21
 //# sourceMappingURL=browser.js.map