@absolutejs/absolute 0.19.0-beta.819 → 0.19.0-beta.820

package/dist/angular/components/core/streamingSlotRegistrar.js

@@ -1,7 +1,7 @@
 // @bun
 var __require = import.meta.require;
 
-// .angular-partial-tmp-ZCh5Bm/src/core/streamingSlotRegistrar.ts
+// .angular-partial-tmp-dDyepD/src/core/streamingSlotRegistrar.ts
 var STREAMING_SLOT_REGISTRAR_KEY = Symbol.for("absolutejs.streamingSlotRegistrar");
 var STREAMING_SLOT_WARNING_STORAGE_KEY = Symbol.for("absolutejs.streamingSlotWarningController");
 var STREAMING_SLOT_COLLECTION_STORAGE_KEY = Symbol.for("absolutejs.streamingSlotCollectionController");

package/dist/angular/components/core/streamingSlotRegistry.js

@@ -1,7 +1,7 @@
 // @bun
 var __require = import.meta.require;
 
-// .angular-partial-tmp-ZCh5Bm/src/core/streamingSlotRegistrar.ts
+// .angular-partial-tmp-dDyepD/src/core/streamingSlotRegistrar.ts
 var STREAMING_SLOT_REGISTRAR_KEY = Symbol.for("absolutejs.streamingSlotRegistrar");
 var STREAMING_SLOT_WARNING_STORAGE_KEY = Symbol.for("absolutejs.streamingSlotWarningController");
 var STREAMING_SLOT_COLLECTION_STORAGE_KEY = Symbol.for("absolutejs.streamingSlotCollectionController");
@@ -48,7 +48,7 @@ var warnMissingStreamingSlotCollector = (primitiveName) => {
   getWarningController()?.maybeWarn(primitiveName);
 };
 
-// .angular-partial-tmp-ZCh5Bm/src/core/streamingSlotRegistry.ts
+// .angular-partial-tmp-dDyepD/src/core/streamingSlotRegistry.ts
 var STREAMING_SLOT_STORAGE_KEY = Symbol.for("absolutejs.streamingSlotAsyncLocalStorage");
 var isObjectRecord2 = (value) => Boolean(value) && typeof value === "object";
 var isAsyncLocalStorage = (value) => isObjectRecord2(value) && ("getStore" in value) && typeof value.getStore === "function" && ("run" in value) && typeof value.run === "function";

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

@@ -0,0 +1,4 @@
+export { goto } from './goto';
+export { page } from './page.svelte';
+export { pushState, replaceState } from './pushState';
+export type { ExtractRouteParams, GotoOptions, LinkPrefetchMode, PageState, RouterMode } from '../../../types/svelteRouter';

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

@@ -0,0 +1,15 @@
+import type { GotoOptions, RouterMode } from '../../../types/svelteRouter';
+/**
+ * Internal — called by Router.svelte on mount so navigation primitives
+ * know which URL strategy to use. Hash mode rewrites the URL bar to
+ * `#/path` instead of `/path`.
+ */
+export declare const setRouterMode: (mode: RouterMode) => void;
+/**
+ * Programmatically navigate to a URL. Updates `page.url`, writes history,
+ * and (when supported) wraps the swap in `document.startViewTransition`.
+ *
+ * Mirrors SvelteKit's `goto` from `$app/navigation` — same name, same
+ * options shape, so a SvelteKit user finds the primitive familiar.
+ */
+export declare const goto: (target: string, options?: GotoOptions) => Promise<void>;

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

@@ -0,0 +1,21 @@
+/**
+ * Hash mode: routing happens against `window.location.hash` with the
+ * leading `#/` stripped. Useful for static deploys (GitHub Pages, S3)
+ * where the host can't be configured to wildcard-route to one HTML file.
+ *
+ * URLs look like `https://example.com/#/dashboard/settings`. The
+ * `pathname` part stays at `/` so the server always serves the same
+ * page; `<Route>` matching looks at the hash instead.
+ */
+/**
+ * Extract the routable pathname from a full URL when hash mode is on.
+ * Returns the part after `#/`, prefixed with `/` so it parses as a
+ * normal pathname.
+ */
+export declare const hashPathnameOf: (url: URL) => string;
+/**
+ * Build a hash URL from a routable pathname. Used by goto() / pushState()
+ * when in hash mode — converts `/dashboard/settings` to `#/dashboard/settings`
+ * and writes the result back to the URL.
+ */
+export declare const buildHashHref: (pathname: string) => string;

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

@@ -0,0 +1,4 @@
+export { goto } from './goto';
+export { page } from './page.svelte';
+export { pushState, replaceState } from './pushState';
+export type { ExtractRouteParams, GotoOptions, LinkPrefetchMode, PageState, RouterMode } from '../../../types/svelteRouter';

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

@@ -0,0 +1,50 @@
+import type { ExtractRouteParams, RouteMatchResult } from '../../../types/svelteRouter';
+type CompiledSegment = {
+    kind: 'static';
+    value: string;
+} | {
+    kind: 'param';
+    name: string;
+    optional: boolean;
+} | {
+    kind: 'wildcard';
+};
+type CompiledPattern = {
+    segments: CompiledSegment[];
+    score: number;
+};
+/**
+ * Compile a `<Route path>` pattern into segments + a specificity score.
+ * Higher score = more specific (longer static prefix beats parameterised).
+ */
+export declare const compilePattern: (pattern: string) => CompiledPattern;
+/**
+ * Match a URL pathname against a compiled pattern. Returns the extracted
+ * params on a successful match, or a miss otherwise.
+ */
+export declare const matchPattern: <Path extends string>(pattern: CompiledPattern, pathname: string) => RouteMatchResult<ExtractRouteParams<Path>>;
+/**
+ * Stable comparator for compiled patterns. Higher specificity sorts first.
+ * When two patterns have equal score, declaration order (the original index)
+ * decides — passed in via the `index` field on each entry.
+ */
+export declare const comparePatterns: (a: {
+    score: number;
+    index: number;
+}, b: {
+    score: number;
+    index: number;
+}) => number;
+/**
+ * Join a basepath stack with a child pattern, producing an absolute pattern
+ * that the route matcher can compile against an incoming pathname.
+ *
+ * Handles slash edge cases:
+ *   joinBasepath('', '/users')           → '/users'
+ *   joinBasepath('/portal', '/users')    → '/portal/users'
+ *   joinBasepath('/portal/', '/users')   → '/portal/users'
+ *   joinBasepath('/portal', 'users')     → '/portal/users'
+ *   joinBasepath('/portal', '/')         → '/portal'
+ */
+export declare const joinBasepath: (basepath: string, pattern: string) => string;
+export {};

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

@@ -0,0 +1,24 @@
+import type { PageState } from '../../../types/svelteRouter';
+/**
+ * Reactive route state. Mirrors SvelteKit's `page` from `$app/state`:
+ *
+ *   import { page } from '@absolutejs/absolute/svelte/router';
+ *   page.url.pathname        // current path (reactive)
+ *   page.url.searchParams    // parsed URLSearchParams (reactive)
+ *   page.params.id           // active route params (reactive)
+ *   page.state               // history.state for the current entry
+ *
+ * Backed by `$state`. Direct property access in templates re-renders.
+ */
+export declare const page: PageState;
+/**
+ * Internal — only Router.svelte and the navigation primitives call this.
+ * Replaces the entire page state in one assignment so subscribers fire
+ * once per navigation rather than once per mutated field.
+ */
+export declare const setPage: (next: Partial<PageState>) => void;
+/**
+ * Internal — used during SSR to seed the page state before render so
+ * `<Route>` blocks see the correct `page.url`.
+ */
+export declare const seedPage: (url: URL, params?: Record<string, string | undefined>) => void;

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

@@ -0,0 +1,21 @@
+/**
+ * Prefetch a URL into the in-memory cache. No-op if the user has signalled
+ * data-saver / reduced-data, or if the URL is already cached.
+ */
+export declare const prefetch: (url: string) => void;
+/**
+ * Consume a cached prefetch entry on actual navigation, removing it from
+ * the cache. Returns the cached Promise<Response> or undefined.
+ */
+export declare const consumePrefetch: (url: string) => Promise<Response> | undefined;
+export declare const clearPrefetchCache: () => void;
+type HoverHandle = {
+    cancel: () => void;
+};
+/**
+ * Wrap a prefetch trigger in a hover-debounce so glancing across many links
+ * doesn't fire a fetch storm. The returned handle's `cancel()` aborts the
+ * pending hover prefetch (e.g. on `pointerleave`).
+ */
+export declare const scheduleHoverPrefetch: (url: string) => HoverHandle;
+export {};

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

@@ -0,0 +1,13 @@
+/**
+ * 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.
+ *
+ * Mirrors SvelteKit's `pushState` from `$app/navigation`.
+ */
+export declare const pushState: (target: string, state: unknown) => void;
+/**
+ * Same as `pushState` but uses `history.replaceState`. Mirrors SvelteKit's
+ * `replaceState` from `$app/navigation`.
+ */
+export declare const replaceState: (target: string, state: unknown) => void;

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

@@ -0,0 +1,6 @@
+/**
+ * Wrap a state mutation in `document.startViewTransition` when supported.
+ * Falls through to a synchronous call otherwise. Reduced-motion users get
+ * instant swaps via the browser's own handling of `prefers-reduced-motion`.
+ */
+export declare const withViewTransition: (mutate: () => void | Promise<void>) => Promise<void>;

package/dist/svelte/router/Link.svelte

@@ -0,0 +1,124 @@
+<script lang="ts">
+	import { onDestroy, onMount, type Snippet } from 'svelte';
+	import type { LinkPrefetchMode } from '../../../types/svelteRouter';
+	import { goto } from './goto';
+	import { prefetch, scheduleHoverPrefetch } from './prefetchCache';
+
+	type LinkProps = {
+		/** Destination URL — relative or absolute. */
+		to: string;
+		/** `true` → use `history.replaceState` instead of `pushState`.
+		 *  Same name as SvelteKit's `goto` option. */
+		replaceState?: boolean;
+		/** `'hover'` (default) — prefetch on `pointerenter`.
+		 *  `'viewport'` — prefetch when the link enters the viewport.
+		 *  `'none'` — disable prefetch for this link. */
+		prefetch?: LinkPrefetchMode;
+		/** Don't reset focus to body on navigate. */
+		keepFocus?: boolean;
+		/** Don't scroll to top on navigate. */
+		noScroll?: boolean;
+		/** Forwarded to the underlying `<a>` element. */
+		class?: string;
+		/** Forwarded to the underlying `<a>` element. */
+		target?: string;
+		children?: Snippet;
+		/** Allow arbitrary HTML attributes through. */
+		[key: string]: unknown;
+	};
+
+	let {
+		to,
+		replaceState = false,
+		prefetch: prefetchMode = 'hover',
+		keepFocus = false,
+		noScroll = false,
+		class: classProp,
+		target,
+		children,
+		...rest
+	}: LinkProps = $props();
+
+	let anchor: HTMLAnchorElement | null = null;
+	let hoverHandle: { cancel: () => void } | null = null;
+	let viewportObserver: IntersectionObserver | null = null;
+
+	const isModifierClick = (event: MouseEvent) =>
+		event.metaKey || event.ctrlKey || event.shiftKey || event.altKey;
+
+	const isExternal = (href: string) => {
+		if (typeof window === 'undefined') return false;
+
+		try {
+			const url = new URL(href, window.location.href);
+
+			return url.origin !== window.location.origin;
+		} catch {
+			return false;
+		}
+	};
+
+	const handleClick = (event: MouseEvent) => {
+		if (isModifierClick(event)) return;
+		if (event.button !== 0) return;
+		if (target && target !== '_self') return;
+		if (rest['download'] !== undefined) return;
+		if (isExternal(to)) return;
+
+		event.preventDefault();
+		void goto(to, {
+			keepFocus,
+			noScroll,
+			replaceState
+		});
+	};
+
+	const handlePointerEnter = () => {
+		if (prefetchMode !== 'hover' || isExternal(to)) return;
+		hoverHandle?.cancel();
+		hoverHandle = scheduleHoverPrefetch(to);
+	};
+
+	const handlePointerLeave = () => {
+		hoverHandle?.cancel();
+		hoverHandle = null;
+	};
+
+	onMount(() => {
+		if (prefetchMode !== 'viewport' || !anchor) return;
+		if (typeof IntersectionObserver === 'undefined') return;
+		if (isExternal(to)) return;
+
+		viewportObserver = new IntersectionObserver(
+			(entries) => {
+				for (const entry of entries) {
+					if (entry.isIntersecting) {
+						prefetch(to);
+						viewportObserver?.disconnect();
+						return;
+					}
+				}
+			},
+			{ rootMargin: '128px' }
+		);
+		viewportObserver.observe(anchor);
+	});
+
+	onDestroy(() => {
+		hoverHandle?.cancel();
+		viewportObserver?.disconnect();
+	});
+</script>
+
+<a
+	bind:this={anchor}
+	href={to}
+	class={classProp}
+	{target}
+	onclick={handleClick}
+	onpointerenter={handlePointerEnter}
+	onpointerleave={handlePointerLeave}
+	{...rest}
+>
+	{@render children?.()}
+</a>

package/dist/svelte/router/Link.svelte.d.ts

@@ -0,0 +1,21 @@
+import type { Snippet } from 'svelte';
+import type { LinkPrefetchMode } from '../../types/svelteRouter';
+
+type LinkProps = {
+	to: string;
+	replaceState?: boolean;
+	prefetch?: LinkPrefetchMode;
+	keepFocus?: boolean;
+	noScroll?: boolean;
+	class?: string;
+	target?: string;
+	children?: Snippet;
+	[key: string]: unknown;
+};
+
+declare const __propDef: { props: LinkProps };
+type Props = typeof __propDef.props;
+
+import { SvelteComponent } from 'svelte';
+
+export default class Link extends SvelteComponent<Props> {}

package/dist/svelte/router/Route.svelte

@@ -0,0 +1,51 @@
+<script lang="ts" generics="Path extends string">
+	import { getContext, onDestroy, type Snippet } from 'svelte';
+	import type { ExtractRouteParams } from '../../../types/svelteRouter';
+	import type { RouterRegistry } from './Router.svelte';
+	import { compilePattern, joinBasepath, matchPattern } from './matchPath';
+	import { page } from './page.svelte';
+
+	const ROUTER_CONTEXT_KEY = Symbol.for('absolutejs.svelte-router');
+
+	type RouteProps = {
+		path: Path;
+		content: Snippet<[ExtractRouteParams<Path>]>;
+	};
+
+	let { path, content }: RouteProps = $props();
+
+	const registry = getContext<RouterRegistry | undefined>(ROUTER_CONTEXT_KEY);
+	if (!registry) {
+		throw new Error(
+			'<Route> must be a descendant of <Router>. ' +
+				'Wrap your routes in `<Router url={...}>` (server) or `<Router>` (client).'
+		);
+	}
+
+	const id = registry.nextRouteId();
+	let registrationOrder = 0;
+
+	const fullPattern = $derived(joinBasepath(registry.basepath, path));
+	const compiled = $derived(compilePattern(fullPattern));
+
+	$effect(() => {
+		registrationOrder = Number(id.slice(1));
+		registry.register(id, {
+			pattern: compiled,
+			registrationOrder
+		});
+	});
+
+	onDestroy(() => registry.deregister(id));
+
+	const isWinner = $derived(registry.isWinner(id));
+	const match = $derived(
+		isWinner
+			? matchPattern<Path>(compiled, page.url.pathname)
+			: { matched: false as const }
+	);
+</script>
+
+{#if match.matched}
+	{@render content(match.params)}
+{/if}

package/dist/svelte/router/Route.svelte.d.ts

@@ -0,0 +1,13 @@
+import type { Snippet } from 'svelte';
+import type { ExtractRouteParams } from '../../types/svelteRouter';
+
+type RouteProps<Path extends string> = {
+	path: Path;
+	content: Snippet<[ExtractRouteParams<Path>]>;
+};
+
+import { SvelteComponent } from 'svelte';
+
+export default class Route<
+	Path extends string = string
+> extends SvelteComponent<RouteProps<Path>> {}

package/dist/svelte/router/Router.svelte

@@ -0,0 +1,164 @@
+<script lang="ts" module>
+	type CompiledPatternBox = {
+		// reactive — read by the winner-resolver
+		pattern: ReturnType<typeof import('./matchPath').compilePattern>;
+		// stable — assigned at registration time, used as tiebreaker
+		registrationOrder: number;
+	};
+
+	export type RouterRegistry = {
+		basepath: string;
+		mode: import('../../../types/svelteRouter').RouterMode;
+		register: (id: string, entry: CompiledPatternBox) => void;
+		deregister: (id: string) => void;
+		isWinner: (id: string) => boolean;
+		nextRouteId: () => string;
+	};
+</script>
+
+<script lang="ts">
+	import { getContext, onMount, setContext, type Snippet } from 'svelte';
+	import type { RouterMode } from '../../../types/svelteRouter';
+	import { setRouterMode } from './goto';
+	import { hashPathnameOf } from './hashMode';
+	import { joinBasepath, matchPattern } from './matchPath';
+	import { page, seedPage, setPage } from './page.svelte';
+
+	const ROUTER_CONTEXT_KEY = Symbol.for('absolutejs.svelte-router');
+
+	type RouterProps = {
+		/** SSR URL passthrough. On the server, the page handler forwards
+		 *  `request.url` here. On the client, this prop is omitted and the
+		 *  router reads `window.location` instead. */
+		url?: string;
+		/** Optional URL prefix the router operates under. Stacks with
+		 *  parent `<Router basepath>` blocks for nested routers. */
+		basepath?: string;
+		/** `'history'` (default, clean URLs) or `'hash'` (`/#/path`,
+		 *  for static deploys). */
+		mode?: RouterMode;
+		children?: Snippet;
+	};
+
+	let {
+		url,
+		basepath = '',
+		mode = 'history',
+		children
+	}: RouterProps = $props();
+
+	const parent = getContext<RouterRegistry | undefined>(ROUTER_CONTEXT_KEY);
+	const stackedBasepath = parent
+		? joinBasepath(parent.basepath, basepath)
+		: basepath === ''
+			? ''
+			: basepath.startsWith('/')
+				? basepath
+				: `/${basepath}`;
+	const stackedMode: RouterMode = parent?.mode ?? mode;
+	const isOutermost = parent === undefined;
+
+	// Specificity ranking across siblings: each <Route> registers with
+	// its compiled pattern + a stable mount-order index. The winner is
+	// $derived from the current URL — highest score wins; ties break by
+	// earlier registration order.
+	const routes = $state(new Map<string, CompiledPatternBox>());
+	let routeCounter = 0;
+
+	const registry: RouterRegistry = {
+		basepath: stackedBasepath,
+		deregister: (id) => {
+			routes.delete(id);
+		},
+		isWinner: (id) => winnerId === id,
+		mode: stackedMode,
+		nextRouteId: () => `r${routeCounter++}`,
+		register: (id, entry) => {
+			routes.set(id, entry);
+		}
+	};
+
+	const winnerId = $derived.by(() => {
+		let bestId: string | null = null;
+		let bestScore = -Infinity;
+		let bestOrder = Infinity;
+
+		for (const [id, entry] of routes) {
+			const match = matchPattern(entry.pattern, page.url.pathname);
+			if (!match.matched) continue;
+
+			if (
+				entry.pattern.score > bestScore ||
+				(entry.pattern.score === bestScore &&
+					entry.registrationOrder < bestOrder)
+			) {
+				bestScore = entry.pattern.score;
+				bestOrder = entry.registrationOrder;
+				bestId = id;
+			}
+		}
+
+		return bestId;
+	});
+
+	setContext<RouterRegistry>(ROUTER_CONTEXT_KEY, registry);
+
+	if (isOutermost) {
+		setRouterMode(stackedMode);
+
+		const baseUrl =
+			typeof window !== 'undefined' ? window.location.href : (url ?? '/');
+		const fullUrl =
+			typeof window !== 'undefined'
+				? new URL(baseUrl)
+				: new URL(baseUrl, 'http://localhost/');
+
+		const routablePathname =
+			stackedMode === 'hash' ? hashPathnameOf(fullUrl) : fullUrl.pathname;
+		const initial = new URL(fullUrl.href);
+		initial.pathname = routablePathname;
+		seedPage(initial);
+	}
+
+	onMount(() => {
+		if (!isOutermost) return;
+
+		const onPopState = (event: PopStateEvent) => {
+			const next = new URL(window.location.href);
+			const routable =
+				stackedMode === 'hash' ? hashPathnameOf(next) : next.pathname;
+			const synthetic = new URL(next.href);
+			synthetic.pathname = routable;
+			setPage({
+				params: {},
+				state: event.state ?? null,
+				url: synthetic
+			});
+		};
+
+		const onHashChange = () => {
+			const next = new URL(window.location.href);
+			const synthetic = new URL(next.href);
+			synthetic.pathname = hashPathnameOf(next);
+			setPage({
+				params: {},
+				state: window.history.state ?? null,
+				url: synthetic
+			});
+		};
+
+		window.addEventListener('popstate', onPopState);
+		if (stackedMode === 'hash') {
+			window.addEventListener('hashchange', onHashChange);
+		}
+
+		return () => {
+			window.removeEventListener('popstate', onPopState);
+			if (stackedMode === 'hash') {
+				window.removeEventListener('hashchange', onHashChange);
+			}
+		};
+	});
+</script>
+
+{@render children?.()}

package/dist/svelte/router/Router.svelte.d.ts

@@ -0,0 +1,16 @@
+import type { Snippet } from 'svelte';
+import type { RouterMode } from '../../types/svelteRouter';
+
+type RouterProps = {
+	url?: string;
+	basepath?: string;
+	mode?: RouterMode;
+	children?: Snippet;
+};
+
+declare const __propDef: { props: RouterProps };
+type Props = typeof __propDef.props;
+
+import { SvelteComponent } from 'svelte';
+
+export default class Router extends SvelteComponent<Props> {}

package/dist/svelte/router/browser.ts

@@ -0,0 +1,14 @@
+// Browser entry — same shape as ./index.ts. Components are imported by
+// their .svelte path; this entry exposes only the runtime API.
+
+export { goto } from './goto';
+export { page } from './page.svelte';
+export { pushState, replaceState } from './pushState';
+
+export type {
+	ExtractRouteParams,
+	GotoOptions,
+	LinkPrefetchMode,
+	PageState,
+	RouterMode
+} from '../../types/svelteRouter';