@absolutejs/absolute 0.19.0-beta.999 → 0.20.0-beta.1

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

@@ -1,4 +1,4 @@
-import type { Snippet } from 'svelte';
+import { SvelteComponent, type Snippet } from 'svelte';
 import type { LinkPrefetchMode } from '../../types/svelteRouter';
 
 type LinkProps = {
@@ -16,6 +16,6 @@ type LinkProps = {
 declare const __propDef: { props: LinkProps };
 type Props = typeof __propDef.props;
 
-import { SvelteComponent } from 'svelte';
+class Link extends SvelteComponent<Props> {}
 
-export default class Link extends SvelteComponent<Props> {}
+export { Link as default };

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

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

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

@@ -1,4 +1,4 @@
-import type { Snippet } from 'svelte';
+import { SvelteComponent, type Snippet } from 'svelte';
 import type { RouterMode } from '../../types/svelteRouter';
 
 type RouterProps = {
@@ -11,6 +11,6 @@ type RouterProps = {
 declare const __propDef: { props: RouterProps };
 type Props = typeof __propDef.props;
 
-import { SvelteComponent } from 'svelte';
+class Router extends SvelteComponent<Props> {}
 
-export default class Router extends SvelteComponent<Props> {}
+export { Router as default };

package/dist/svelte/router/hashMode.ts

@@ -13,8 +13,13 @@
  * Returns the part after `#/`, prefixed with `/` so it parses as a
  * normal pathname.
  */
+export const buildHashHref = (pathname: string) => {
+	const trimmed = pathname.replace(/^\/+/, '');
+
+	return trimmed === '' ? '#/' : `#/${trimmed}`;
+};
 export const hashPathnameOf = (url: URL) => {
-	const hash = url.hash;
+	const { hash } = url;
 	if (!hash || hash === '#') return '/';
 
 	// Tolerate both `#/foo` and `#foo`.
@@ -24,14 +29,3 @@ export const hashPathnameOf = (url: URL) => {
 
 	return `/${trimmed.replace(/^\/+/, '')}`;
 };
-
-/**
- * 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 const buildHashHref = (pathname: string) => {
-	const trimmed = pathname.replace(/^\/+/, '');
-
-	return trimmed === '' ? '#/' : `#/${trimmed}`;
-};

package/dist/svelte/router/matchPath.ts

@@ -12,11 +12,18 @@ type CompiledPattern = {
 	segments: CompiledSegment[];
 	score: number;
 };
+type RouteMatchBuilder = <Path extends string>(
+	params: Record<string, string | undefined>
+) => RouteMatchResult<ExtractRouteParams<Path>>;
 
 const STATIC_SEGMENT_WEIGHT = 100;
 const PARAM_SEGMENT_WEIGHT = 10;
 const WILDCARD_SEGMENT_WEIGHT = 1;
 const OPTIONAL_PENALTY = 1;
+const buildRouteMatch: RouteMatchBuilder = (params) => ({
+	matched: true,
+	params: Object.assign(Object.create(null), params)
+});
 
 const splitPath = (path: string) => {
 	const trimmed = path.replace(/^\/+/, '').replace(/\/+$/, '');
@@ -45,6 +52,14 @@ const compileSegment = (raw: string): CompiledSegment => {
  * Compile a `<Route path>` pattern into segments + a specificity score.
  * Higher score = more specific (longer static prefix beats parameterised).
  */
+export const comparePatterns = (
+	left: { score: number; index: number },
+	right: { score: number; index: number }
+) => {
+	if (left.score !== right.score) return right.score - left.score;
+
+	return left.index - right.index;
+};
 export const compilePattern = (pattern: string): CompiledPattern => {
 	const segments = splitPath(pattern).map(compileSegment);
 
@@ -58,13 +73,22 @@ export const compilePattern = (pattern: string): CompiledPattern => {
 			score += WILDCARD_SEGMENT_WEIGHT;
 	}
 
-	return { segments, score };
+	return { score, segments };
 };
+export const joinBasepath = (basepath: string, pattern: string) => {
+	const trimmedBase = basepath.replace(/\/+$/, '');
+	const trimmedPattern = pattern.replace(/^\/+/, '');
 
-/**
- * Match a URL pathname against a compiled pattern. Returns the extracted
- * params on a successful match, or a miss otherwise.
- */
+	if (trimmedPattern === '') {
+		return trimmedBase === '' ? '/' : trimmedBase;
+	}
+
+	if (trimmedBase === '') {
+		return `/${trimmedPattern}`;
+	}
+
+	return `${trimmedBase}/${trimmedPattern}`;
+};
 export const matchPattern = <Path extends string>(
 	pattern: CompiledPattern,
 	pathname: string
@@ -72,20 +96,22 @@ export const matchPattern = <Path extends string>(
 	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];
+	let pathIndex = 0;
+	for (
+		let segmentIndex = 0;
+		segmentIndex < pattern.segments.length;
+		segmentIndex++
+	) {
+		const segment = pattern.segments[segmentIndex];
 		if (!segment) continue;
 
 		if (segment.kind === 'wildcard') {
-			params['wildcard'] = pathSegments.slice(pi).join('/');
-			return {
-				matched: true,
-				params: params as ExtractRouteParams<Path>
-			};
+			params['wildcard'] = pathSegments.slice(pathIndex).join('/');
+
+			return buildRouteMatch<Path>(params);
 		}
 
-		const candidate = pathSegments[pi];
+		const candidate = pathSegments[pathIndex];
 
 		if (candidate === undefined) {
 			if (segment.kind === 'param' && segment.optional) {
@@ -98,61 +124,18 @@ export const matchPattern = <Path extends string>(
 
 		if (segment.kind === 'static') {
 			if (segment.value !== candidate) return { matched: false };
-			pi++;
+			pathIndex++;
 			continue;
 		}
 
 		// param
 		params[segment.name] = candidate;
-		pi++;
+		pathIndex++;
 	}
 
-	if (pi !== pathSegments.length) {
+	if (pathIndex !== pathSegments.length) {
 		return { matched: false };
 	}
 
-	return {
-		matched: true,
-		params: params as 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 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;
-};
-
-/**
- * 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 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}`;
+	return buildRouteMatch<Path>(params);
 };

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

@@ -11,14 +11,5 @@ import type { PageState } from '../../types/svelteRouter';
  * 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;
+export declare const setPage: (next: Partial<PageState>) => void;

package/dist/svelte/router/page.js

@@ -14,14 +14,14 @@ const inner = $.proxy(initialState());
 
 export const page = inner;
 
-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;
-};
-
 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

@@ -11,13 +11,13 @@ const cache = new Map<string, CacheEntry>();
 const isSlowConnection = () => {
 	if (typeof navigator === 'undefined') return false;
 
-	const connection = (
-		navigator as Navigator & {
-			connection?: { saveData?: boolean };
-		}
-	).connection;
+	const connection = Reflect.get(navigator, 'connection');
 
-	return connection?.saveData === true;
+	return (
+		typeof connection === 'object' &&
+		connection !== null &&
+		Reflect.get(connection, 'saveData') === true
+	);
 };
 
 const prefersReducedData = () => {
@@ -36,6 +36,16 @@ const evictOldest = () => {
  * 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;
@@ -49,22 +59,6 @@ export const prefetch = (url: string) => {
 	cache.set(url, { promise, url });
 };
 
-/**
- * Consume a cached prefetch entry on actual navigation, removing it from
- * the cache. Returns the cached Promise<Response> or undefined.
- */
-export const consumePrefetch = (url: string) => {
-	const entry = cache.get(url);
-	if (!entry) return undefined;
-	cache.delete(url);
-
-	return entry.promise;
-};
-
-export const clearPrefetchCache = () => {
-	cache.clear();
-};
-
 type HoverHandle = {
 	cancel: () => void;
 };
@@ -76,7 +70,11 @@ type HoverHandle = {
  */
 export const scheduleHoverPrefetch = (url: string): HoverHandle => {
 	if (typeof window === 'undefined') {
-		return { cancel: () => {} };
+		return {
+			cancel: () => {
+				/* nothing scheduled server-side */
+			}
+		};
 	}
 
 	const timer = window.setTimeout(() => {

package/dist/svelte/router/viewTransitions.ts

@@ -1,14 +1,7 @@
-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'
-	);
+	return typeof Reflect.get(document, 'startViewTransition') === 'function';
 };
 
 /**
@@ -28,8 +21,25 @@ export const withViewTransition = async (
 	// 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;
+	const startViewTransition: unknown = Reflect.get(
+		document,
+		'startViewTransition'
+	);
+	if (typeof startViewTransition !== 'function') {
+		await mutate();
+
+		return;
+	}
+	const transitionResult: unknown = Reflect.apply(
+		startViewTransition,
+		document,
+		[() => mutate()]
+	);
+	if (
+		typeof transitionResult === 'object' &&
+		transitionResult !== null &&
+		'finished' in transitionResult
+	) {
+		await transitionResult.finished;
+	}
 };