@absolutejs/absolute 0.19.0-beta.1043 → 0.19.0-beta.1044

package/dist/svelte/router/matchPath.ts

@@ -0,0 +1,136 @@
+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;
+};
+
+const STATIC_SEGMENT_WEIGHT = 100;
+const PARAM_SEGMENT_WEIGHT = 10;
+const WILDCARD_SEGMENT_WEIGHT = 1;
+const OPTIONAL_PENALTY = 1;
+
+const splitPath = (path: string) => {
+	const trimmed = path.replace(/^\/+/, '').replace(/\/+$/, '');
+	if (trimmed === '') return [];
+
+	return trimmed.split('/');
+};
+
+const compileSegment = (raw: string): CompiledSegment => {
+	if (raw === '*' || raw.startsWith('*')) {
+		return { kind: 'wildcard' };
+	}
+
+	if (raw.startsWith(':')) {
+		const body = raw.slice(1);
+		const optional = body.endsWith('?');
+		const name = optional ? body.slice(0, -1) : body;
+
+		return { kind: 'param', name, optional };
+	}
+
+	return { kind: 'static', value: raw };
+};
+
+/**
+ * Compile a `<Route path>` pattern into segments + a specificity score.
+ * Higher score = more specific (longer static prefix beats parameterised).
+ */
+export const comparePatterns = (
+	a: { score: number; index: number },
+	b: { score: number; index: number }
+) => {
+	if (a.score !== b.score) return b.score - a.score;
+
+	return a.index - b.index;
+};
+export const compilePattern = (pattern: string): CompiledPattern => {
+	const segments = splitPath(pattern).map(compileSegment);
+
+	let score = 0;
+	for (const segment of segments) {
+		if (segment.kind === 'static') score += STATIC_SEGMENT_WEIGHT;
+		else if (segment.kind === 'param') {
+			score += PARAM_SEGMENT_WEIGHT;
+			if (segment.optional) score -= OPTIONAL_PENALTY;
+		} else if (segment.kind === 'wildcard')
+			score += WILDCARD_SEGMENT_WEIGHT;
+	}
+
+	return { score, segments };
+};
+export const joinBasepath = (basepath: string, pattern: string) => {
+	const trimmedBase = basepath.replace(/\/+$/, '');
+	const trimmedPattern = pattern.replace(/^\/+/, '');
+
+	if (trimmedPattern === '') {
+		return trimmedBase === '' ? '/' : trimmedBase;
+	}
+
+	if (trimmedBase === '') {
+		return `/${trimmedPattern}`;
+	}
+
+	return `${trimmedBase}/${trimmedPattern}`;
+};
+export const matchPattern = <Path extends string>(
+	pattern: CompiledPattern,
+	pathname: string
+): RouteMatchResult<ExtractRouteParams<Path>> => {
+	const pathSegments = splitPath(pathname);
+	const params: Record<string, string | undefined> = {};
+
+	let pi = 0;
+	for (let si = 0; si < pattern.segments.length; si++) {
+		const segment = pattern.segments[si];
+		if (!segment) continue;
+
+		if (segment.kind === 'wildcard') {
+			params['wildcard'] = pathSegments.slice(pi).join('/');
+
+			return {
+				matched: true,
+				params: params as ExtractRouteParams<Path>
+			};
+		}
+
+		const candidate = pathSegments[pi];
+
+		if (candidate === undefined) {
+			if (segment.kind === 'param' && segment.optional) {
+				params[segment.name] = undefined;
+				continue;
+			}
+
+			return { matched: false };
+		}
+
+		if (segment.kind === 'static') {
+			if (segment.value !== candidate) return { matched: false };
+			pi++;
+			continue;
+		}
+
+		// param
+		params[segment.name] = candidate;
+		pi++;
+	}
+
+	if (pi !== pathSegments.length) {
+		return { matched: false };
+	}
+
+	return {
+		matched: true,
+		params: params as ExtractRouteParams<Path>
+	};
+};

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

@@ -0,0 +1,15 @@
+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;
+export declare const seedPage: (url: URL, params?: Record<string, string | undefined>) => void;
+export declare const setPage: (next: Partial<PageState>) => void;

package/dist/svelte/router/page.js

@@ -0,0 +1,27 @@
+/* page.svelte.ts generated by Svelte v5.55.0 */
+import * as $ from 'svelte/internal/client';
+
+const initialUrl = () => {
+	if (typeof window !== "undefined") {
+		return new URL(window.location.href);
+	}
+
+	return new URL("http://localhost/");
+};
+
+const initialState = () => ({ params: {}, state: undefined, url: initialUrl() });
+const inner = $.proxy(initialState());
+
+export const page = inner;
+
+export const seedPage = (url, params = {}) => {
+	inner.url = url;
+	inner.params = params;
+	inner.state = undefined;
+};
+
+export const setPage = (next) => {
+	if (next.url !== undefined) inner.url = next.url;
+	if (next.params !== undefined) inner.params = next.params;
+	if (next.state !== undefined) inner.state = next.state;
+};

package/dist/svelte/router/prefetchCache.ts

@@ -0,0 +1,85 @@
+const PREFETCH_CACHE_LIMIT = 16;
+const HOVER_DEBOUNCE_MS = 250;
+
+type CacheEntry = {
+	url: string;
+	promise: Promise<Response>;
+};
+
+const cache = new Map<string, CacheEntry>();
+
+const isSlowConnection = () => {
+	if (typeof navigator === 'undefined') return false;
+
+	const {connection} = (navigator as Navigator & {
+			connection?: { saveData?: boolean };
+		});
+
+	return connection?.saveData === true;
+};
+
+const prefersReducedData = () => {
+	if (typeof window === 'undefined' || !window.matchMedia) return false;
+
+	return window.matchMedia('(prefers-reduced-data: reduce)').matches;
+};
+
+const evictOldest = () => {
+	const oldest = cache.keys().next();
+	if (oldest.done) return;
+	cache.delete(oldest.value);
+};
+
+/**
+ * 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 const clearPrefetchCache = () => {
+	cache.clear();
+};
+export const consumePrefetch = (url: string) => {
+	const entry = cache.get(url);
+	if (!entry) return undefined;
+	cache.delete(url);
+
+	return entry.promise;
+};
+export const prefetch = (url: string) => {
+	if (typeof fetch === 'undefined') return;
+	if (isSlowConnection() || prefersReducedData()) return;
+	if (cache.has(url)) return;
+
+	while (cache.size >= PREFETCH_CACHE_LIMIT) evictOldest();
+
+	const promise = fetch(url, { credentials: 'same-origin' }).catch(
+		() => new Response(null, { status: 0 })
+	);
+	cache.set(url, { promise, url });
+};
+
+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 const scheduleHoverPrefetch = (url: string): HoverHandle => {
+	if (typeof window === 'undefined') {
+		return {
+			cancel: () => {
+				/* nothing scheduled server-side */
+			}
+		};
+	}
+
+	const timer = window.setTimeout(() => {
+		prefetch(url);
+	}, HOVER_DEBOUNCE_MS);
+
+	return {
+		cancel: () => window.clearTimeout(timer)
+	};
+};

package/dist/svelte/router/pushState.ts

@@ -0,0 +1,35 @@
+import { setPage } from './page.js';
+
+const resolveTarget = (target: string) => {
+	if (typeof window === 'undefined')
+		return new URL(target, 'http://localhost/');
+
+	return new URL(target, window.location.href);
+};
+
+/**
+ * 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 const pushState = (target: string, state: unknown) => {
+	if (typeof window === 'undefined') return;
+
+	const url = resolveTarget(target);
+	window.history.pushState(state, '', url.href);
+	setPage({ state, url });
+};
+
+/**
+ * Same as `pushState` but uses `history.replaceState`. Mirrors SvelteKit's
+ * `replaceState` from `$app/navigation`.
+ */
+export const replaceState = (target: string, state: unknown) => {
+	if (typeof window === 'undefined') return;
+
+	const url = resolveTarget(target);
+	window.history.replaceState(state, '', url.href);
+	setPage({ state, url });
+};

package/dist/svelte/router/viewTransitions.ts

@@ -0,0 +1,35 @@
+type StartViewTransition = (callback: () => void | Promise<void>) => {
+	finished: Promise<void>;
+};
+
+const supportsViewTransitions = () => {
+	if (typeof document === 'undefined') return false;
+
+	return (
+		typeof (document as { startViewTransition?: StartViewTransition })
+			.startViewTransition === 'function'
+	);
+};
+
+/**
+ * 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 const withViewTransition = async (
+	mutate: () => void | Promise<void>
+) => {
+	if (!supportsViewTransitions()) {
+		await mutate();
+
+		return;
+	}
+
+	// Call as a method on `document` (NOT as an extracted bare function) —
+	// `document.startViewTransition` requires `this === document` or it
+	// throws "Illegal invocation".
+	const doc = document as Document & {
+		startViewTransition: StartViewTransition;
+	};
+	await doc.startViewTransition(() => mutate()).finished;
+};