@askrjs/askr 0.0.52 → 0.0.53

package/dist/route-matching-vJpvLVbX.js

@@ -0,0 +1,515 @@
+import { n as getActiveRenderContext } from "./render-context-Clw3rFiO.js";
+//#region src/router/match.ts
+function splitPathSegments(path) {
+	const normalized = path.endsWith("/") && path !== "/" ? path.slice(0, -1) : path;
+	if (!normalized || normalized === "/") return [];
+	const withoutLeadingSlash = normalized.startsWith("/") ? normalized.slice(1) : normalized;
+	return withoutLeadingSlash.length === 0 ? [] : withoutLeadingSlash.split("/");
+}
+function normalizeRouteSegmentName(value) {
+	return value.trim();
+}
+/**
+* Parse a route template path into typed segments.
+*
+* @example
+* parseSegments('/users/{id}')  // [{kind:'static',value:'users'},{kind:'param',value:'id'}]
+* parseSegments('/*')           // [{kind:'catchall',value:'*'}]
+* parseSegments('/posts/*')     // [{kind:'static',value:'posts'},{kind:'wildcard',value:'*'}]
+* parseSegments('/files/{*path}') // [{kind:'static',value:'files'},{kind:'splat',value:'path'}]
+*/
+function parseSegments(path) {
+	const parts = (path.endsWith("/") && path !== "/" ? path.slice(0, -1) : path).split("/").filter(Boolean);
+	if (parts.length === 1 && parts[0] === "*") return [{
+		kind: "catchall",
+		value: "*"
+	}];
+	return parts.map((segment) => {
+		if (segment.startsWith("{") && segment.endsWith("}")) {
+			const value = normalizeRouteSegmentName(segment.slice(1, -1));
+			if (value.startsWith("*")) return {
+				kind: "splat",
+				value: normalizeRouteSegmentName(value.slice(1))
+			};
+			return {
+				kind: "param",
+				value
+			};
+		}
+		if (segment === "*") return {
+			kind: "wildcard",
+			value: "*"
+		};
+		return {
+			kind: "static",
+			value: segment
+		};
+	});
+}
+/**
+* Compute a numeric specificity rank from a parsed segment list.
+*
+* Scoring: static = 3, param = 2, wildcard = 1, catchall = 0.
+* Higher rank wins when multiple routes match the same path.
+*/
+function computeRank(segments) {
+	if (segments.length === 1 && segments[0].kind === "catchall") return -1;
+	let score = 0;
+	for (const seg of segments) if (seg.kind === "static") score += 3;
+	else if (seg.kind === "param") score += 2;
+	else if (seg.kind === "wildcard") score += 1;
+	else if (seg.kind === "splat") score -= .5;
+	return score;
+}
+/** Reused frozen empty params object — returned for purely-static (no-capture) routes. */
+const emptyParams = Object.freeze(Object.create(null));
+Object.freeze({
+	matched: false,
+	params: emptyParams
+});
+function decodeRouteParam(part) {
+	if (!part.includes("%")) return part;
+	try {
+		return decodeURIComponent(part);
+	} catch {
+		return part;
+	}
+}
+/**
+* Match pre-split URL parts against pre-parsed route segments.
+*
+* This is the hot-path matcher used by `resolveRoute` and
+* `resolveRouteFromRoutes`. Callers split the URL path **once** and reuse
+* `urlParts` across all route comparisons in a single resolution call.
+*
+* - Returns a params object (possibly the shared `{}`) on match.
+* - Returns `null` on no match.
+* - Params are allocated lazily — purely-static routes return the frozen
+*   empty sentinel without any heap allocation.
+*/
+function matchSegments(urlParts, segments) {
+	if (segments.length === 1 && segments[0].kind === "catchall") return { "*": urlParts.length === 0 ? "/" : urlParts.length === 1 ? urlParts[0] : "/" + urlParts.join("/") };
+	const splatIndex = segments.findIndex((segment) => segment.kind === "splat");
+	if (splatIndex !== -1) {
+		if (splatIndex !== segments.length - 1) return null;
+		if (urlParts.length < splatIndex) return null;
+	} else if (urlParts.length !== segments.length) return null;
+	let params = null;
+	const normalizeCapturedSplatParts = (parts) => {
+		let start = 0;
+		while (start < parts.length && parts[start] === "") start += 1;
+		return start === 0 ? parts : parts.slice(start);
+	};
+	for (let i = 0; i < segments.length; i++) {
+		const seg = segments[i];
+		const part = urlParts[i];
+		if (seg.kind === "static") {
+			if (seg.value !== part) return null;
+		} else if (seg.kind === "splat") {
+			if (params === null) params = {};
+			params[seg.value] = normalizeCapturedSplatParts(urlParts.slice(i).map(decodeRouteParam)).join("/");
+			return params;
+		} else {
+			if (params === null) params = {};
+			if (seg.kind === "param") params[seg.value] = decodeRouteParam(part);
+			else params["*"] = part;
+		}
+	}
+	return params ?? emptyParams;
+}
+//#endregion
+//#region src/router/store.ts
+const routes = [];
+const records = [];
+const namespaces = /* @__PURE__ */ new Set();
+const routesByDepth = /* @__PURE__ */ new Map();
+const registrationScopeStack = [];
+let registrationLocked = false;
+let defaultRouteAuthOptions;
+let activeClientRouteAuthOptions;
+function getDepth(path) {
+	const normalized = path.endsWith("/") && path !== "/" ? path.slice(0, -1) : path;
+	return normalized === "/" ? 0 : normalized.split("/").filter(Boolean).length;
+}
+function getRouteRecords() {
+	return records;
+}
+function isRouteStoreRoutes(routeList) {
+	return routeList === routes;
+}
+function insertRecordSorted(record) {
+	let lo = 0;
+	let hi = records.length;
+	while (lo < hi) {
+		const mid = lo + hi >>> 1;
+		if (records[mid].rank >= record.rank) lo = mid + 1;
+		else hi = mid;
+	}
+	records.splice(lo, 0, record);
+}
+function addRouteToStores(routeObj) {
+	routes.push(routeObj);
+	const depth = getDepth(routeObj.path);
+	let depthRoutes = routesByDepth.get(depth);
+	if (!depthRoutes) {
+		depthRoutes = [];
+		routesByDepth.set(depth, depthRoutes);
+	}
+	depthRoutes.push(routeObj);
+	if (routeObj.namespace) namespaces.add(routeObj.namespace);
+}
+function getActiveRoutes() {
+	return getActiveRenderContext()?.routes ?? routes;
+}
+function getActiveRouteAuthOptions(override) {
+	if (override) return override;
+	return getActiveRenderContext()?.routeAuth ?? activeClientRouteAuthOptions ?? defaultRouteAuthOptions;
+}
+function _setActiveRouteAuthOptions(auth) {
+	activeClientRouteAuthOptions = auth;
+}
+function getDefaultRouteAuthOptions() {
+	return defaultRouteAuthOptions;
+}
+function setDefaultRouteAuthOptions(auth) {
+	defaultRouteAuthOptions = auth;
+}
+function getCurrentLayoutChain() {
+	const layoutChain = [];
+	for (const scope of registrationScopeStack) if (scope.layout) layoutChain.push({ component: scope.layout });
+	return layoutChain;
+}
+function getCurrentPageChain() {
+	const pageChain = [];
+	for (const scope of registrationScopeStack) if (scope.page) pageChain.push({ component: scope.page });
+	return pageChain;
+}
+function hasActivePageScope() {
+	return registrationScopeStack.some((scope) => !!scope.page);
+}
+function getCurrentPageScope() {
+	for (let index = registrationScopeStack.length - 1; index >= 0; index -= 1) {
+		const scope = registrationScopeStack[index];
+		if (scope.kind === "page") return scope;
+	}
+	return null;
+}
+function getCurrentScopeKind() {
+	return registrationScopeStack[registrationScopeStack.length - 1]?.kind ?? null;
+}
+function getCurrentPathPrefix() {
+	return registrationScopeStack[registrationScopeStack.length - 1]?.pathPrefix ?? "";
+}
+function getCurrentInheritedPolicies() {
+	const policies = [];
+	for (const scope of registrationScopeStack) if (scope.policies.length > 0) policies.push(...scope.policies);
+	return policies;
+}
+function getCurrentInheritedAuthRequirements() {
+	return registrationScopeStack.flatMap((scope) => scope.auth ? [scope.auth] : []);
+}
+function getCurrentInheritedMeta() {
+	return registrationScopeStack.flatMap((scope) => scope.meta ? [scope.meta] : []);
+}
+function pushRegistrationScope(scope, fn) {
+	registrationScopeStack.push(scope);
+	try {
+		fn();
+	} finally {
+		registrationScopeStack.pop();
+	}
+}
+function lockRouteRegistration() {
+	registrationLocked = true;
+}
+function assertRouteRegistrationUnlocked() {
+	if (registrationLocked) throw new Error("Route registration is locked after app startup. Register routes at module load time before calling createSPA or createSSR.");
+}
+function getRoutes() {
+	return [...routes];
+}
+function hasRegisteredRoutes() {
+	return routes.length > 0 || records.length > 0;
+}
+function clearRouteState() {
+	routes.length = 0;
+	records.length = 0;
+	namespaces.clear();
+	routesByDepth.clear();
+	registrationScopeStack.length = 0;
+	registrationLocked = false;
+	defaultRouteAuthOptions = void 0;
+	activeClientRouteAuthOptions = void 0;
+}
+function snapshotRouteState() {
+	return {
+		routes: [...routes],
+		records: [...records],
+		namespaces: [...namespaces],
+		registrationLocked,
+		defaultRouteAuthOptions,
+		activeClientRouteAuthOptions,
+		routesByDepth: [...routesByDepth.entries()].map(([depth, depthRoutes]) => [depth, [...depthRoutes]]),
+		registrationScopeStack: [...registrationScopeStack]
+	};
+}
+function restoreRouteState(snapshot) {
+	routes.length = 0;
+	routes.push(...snapshot.routes);
+	records.length = 0;
+	records.push(...snapshot.records);
+	namespaces.clear();
+	for (const namespace of snapshot.namespaces) namespaces.add(namespace);
+	routesByDepth.clear();
+	for (const [depth, depthRoutes] of snapshot.routesByDepth) routesByDepth.set(depth, [...depthRoutes]);
+	registrationScopeStack.length = 0;
+	registrationScopeStack.push(...snapshot.registrationScopeStack);
+	registrationLocked = snapshot.registrationLocked;
+	defaultRouteAuthOptions = snapshot.defaultRouteAuthOptions;
+	activeClientRouteAuthOptions = snapshot.activeClientRouteAuthOptions;
+}
+//#endregion
+//#region src/router/route-context.ts
+function parseLocation(url) {
+	try {
+		const parsedUrl = new URL(url, "http://localhost");
+		return {
+			pathname: parsedUrl.pathname,
+			search: parsedUrl.search,
+			hash: parsedUrl.hash
+		};
+	} catch {
+		return {
+			pathname: "/",
+			search: "",
+			hash: ""
+		};
+	}
+}
+function deepFreeze(obj) {
+	if (obj && typeof obj === "object" && !Object.isFrozen(obj)) {
+		Object.freeze(obj);
+		for (const key of Object.keys(obj)) {
+			const value = obj[key];
+			if (value && typeof value === "object") deepFreeze(value);
+		}
+	}
+	return obj;
+}
+function makeQuery(search) {
+	const searchParams = new URLSearchParams(search || "");
+	const mapping = /* @__PURE__ */ new Map();
+	for (const [key, value] of searchParams.entries()) {
+		const existing = mapping.get(key);
+		if (existing) existing.push(value);
+		else mapping.set(key, [value]);
+	}
+	return deepFreeze({
+		get(key) {
+			const values = mapping.get(key);
+			return values ? values[0] : null;
+		},
+		getAll(key) {
+			const values = mapping.get(key);
+			return values ? [...values] : [];
+		},
+		has(key) {
+			return mapping.has(key);
+		},
+		toJSON() {
+			const output = {};
+			for (const [key, values] of mapping.entries()) output[key] = values.length > 1 ? [...values] : values[0];
+			return output;
+		}
+	});
+}
+function buildRouteContextBase(target, params, options) {
+	const parsed = parseLocation(target);
+	const href = `${parsed.pathname}${parsed.search}${parsed.hash}`;
+	return {
+		mode: options.mode,
+		params,
+		pathname: parsed.pathname,
+		search: parsed.search,
+		hash: parsed.hash,
+		href,
+		signal: options.signal
+	};
+}
+function buildRouteContext(target, params, options) {
+	return {
+		...buildRouteContextBase(target, params, options),
+		auth: options.authContext
+	};
+}
+//#endregion
+//#region src/router/route-matching.ts
+const routeSegsCache = /* @__PURE__ */ new WeakMap();
+const routeRankCache = /* @__PURE__ */ new WeakMap();
+const sortedListCache = /* @__PURE__ */ new WeakMap();
+function cachedSegs(route) {
+	let segments = routeSegsCache.get(route);
+	if (!segments) {
+		segments = parseSegments(route.path);
+		routeSegsCache.set(route, segments);
+	}
+	return segments;
+}
+function cachedRank(route) {
+	let rank = routeRankCache.get(route);
+	if (rank === void 0) {
+		rank = computeRank(cachedSegs(route));
+		routeRankCache.set(route, rank);
+	}
+	return rank;
+}
+function cachedSortedList(routeList) {
+	let sorted = sortedListCache.get(routeList);
+	if (!sorted) {
+		sorted = [...routeList].sort((a, b) => cachedRank(b) - cachedRank(a));
+		sortedListCache.set(routeList, sorted);
+	}
+	return sorted;
+}
+function matchFallbackPrefix(pathname, fallbackPrefix) {
+	const normalizedPath = pathname.endsWith("/") && pathname !== "/" ? pathname.slice(0, -1) : pathname;
+	const normalizedPrefix = fallbackPrefix.endsWith("/") && fallbackPrefix !== "/" ? fallbackPrefix.slice(0, -1) : fallbackPrefix;
+	if (normalizedPrefix === "/") {
+		const urlParts = splitPathSegments(normalizedPath);
+		return { "*": urlParts.length === 0 ? "/" : urlParts.length === 1 ? urlParts[0] : "/" + urlParts.join("/") };
+	}
+	if (normalizedPath !== normalizedPrefix && !normalizedPath.startsWith(`${normalizedPrefix}/`)) return null;
+	const remainderParts = splitPathSegments(normalizedPath === normalizedPrefix ? "/" : normalizedPath.slice(normalizedPrefix.length));
+	return { "*": remainderParts.length === 0 ? "/" : remainderParts.length === 1 ? remainderParts[0] : "/" + remainderParts.join("/") };
+}
+function findBestResolvedRouteFromRoutes(pathname, routeList) {
+	const normalized = pathname.endsWith("/") && pathname !== "/" ? pathname.slice(0, -1) : pathname;
+	const urlParts = splitPathSegments(normalized);
+	const sorted = cachedSortedList(routeList);
+	let bestRoute = null;
+	let bestParams = {};
+	let bestRank = -Infinity;
+	for (const route of sorted) {
+		if (route.fallbackPrefix) continue;
+		const rank = cachedRank(route);
+		if (rank < bestRank) break;
+		if (bestRoute !== null && rank === bestRank) continue;
+		const params = matchSegments(urlParts, cachedSegs(route));
+		if (params !== null) {
+			bestRoute = route;
+			bestParams = params;
+			bestRank = rank;
+		}
+	}
+	if (bestRoute !== null) return {
+		route: bestRoute,
+		params: bestParams
+	};
+	let bestFallback = null;
+	let bestFallbackParams = null;
+	let bestPrefixLength = -1;
+	for (const route of routeList) {
+		const internalRoute = route;
+		if (!internalRoute.fallbackPrefix) continue;
+		const params = matchFallbackPrefix(normalized, internalRoute.fallbackPrefix);
+		if (params === null) continue;
+		if (internalRoute.fallbackPrefix.length > bestPrefixLength) {
+			bestFallback = internalRoute;
+			bestFallbackParams = params;
+			bestPrefixLength = internalRoute.fallbackPrefix.length;
+		}
+	}
+	return bestFallback && bestFallbackParams ? {
+		route: bestFallback,
+		params: bestFallbackParams
+	} : null;
+}
+function findBestScopedFallbackRecord(pathname, routeRecords) {
+	let bestRecord = null;
+	let bestParams = null;
+	let bestPrefixLength = -1;
+	for (const routeRecord of routeRecords) {
+		const record = routeRecord;
+		if (!record.fallbackPrefix) continue;
+		const params = matchFallbackPrefix(pathname, record.fallbackPrefix);
+		if (params === null) continue;
+		if (record.fallbackPrefix.length > bestPrefixLength) {
+			bestRecord = record;
+			bestParams = params;
+			bestPrefixLength = record.fallbackPrefix.length;
+		}
+	}
+	return bestRecord && bestParams ? {
+		record: bestRecord,
+		params: bestParams
+	} : null;
+}
+function getMatchingRouteRecord(target, routeRecords) {
+	const location = parseLocation(target);
+	const normalized = location.pathname.endsWith("/") && location.pathname !== "/" ? location.pathname.slice(0, -1) : location.pathname;
+	const urlParts = splitPathSegments(normalized);
+	for (const record of routeRecords) {
+		if (record.fallbackPrefix) continue;
+		const params = matchSegments(urlParts, record.segments);
+		if (params !== null) return {
+			record,
+			params
+		};
+	}
+	return findBestScopedFallbackRecord(normalized, routeRecords);
+}
+function computeMatchesFromRoutes(pathname, routesList) {
+	const bestMatch = isRouteStoreRoutes(routesList) ? getMatchingRouteRecord(pathname, getRouteRecords()) : findBestResolvedRouteFromRoutes(pathname, routesList);
+	if (!bestMatch) return [];
+	return [{
+		path: "route" in bestMatch ? bestMatch.route.path : bestMatch.record.path,
+		params: deepFreeze({ ...bestMatch.params }),
+		name: "route" in bestMatch ? bestMatch.route.name : void 0,
+		namespace: "route" in bestMatch ? bestMatch.route.namespace : bestMatch.record.options.namespace
+	}];
+}
+function computeMatchesFromRouteRecords(pathname, routeRecords) {
+	const bestMatch = getMatchingRouteRecord(pathname, routeRecords);
+	if (!bestMatch) return [];
+	return [{
+		path: bestMatch.record.path,
+		params: deepFreeze({ ...bestMatch.params }),
+		namespace: bestMatch.record.options.namespace
+	}];
+}
+function computeRouteActivityMatches(pathname, options = {}) {
+	if (options.manifest) return computeMatchesFromRouteRecords(pathname, options.manifest.records);
+	if (options.routes) return computeMatchesFromRoutes(pathname, options.routes);
+	return computeMatchesFromRoutes(pathname, getActiveRoutes());
+}
+function resolveRoute(pathname) {
+	const normalized = pathname.endsWith("/") && pathname !== "/" ? pathname.slice(0, -1) : pathname;
+	const urlParts = splitPathSegments(normalized);
+	const records = getRouteRecords();
+	for (const record of records) {
+		if (record.fallbackPrefix) continue;
+		const params = matchSegments(urlParts, record.segments);
+		if (params !== null) return {
+			handler: record.handler,
+			params
+		};
+	}
+	const fallbackMatch = findBestScopedFallbackRecord(normalized, records);
+	return fallbackMatch ? {
+		handler: fallbackMatch.record.handler,
+		params: fallbackMatch.params
+	} : null;
+}
+function resolveRouteFromRoutes(pathname, routeList) {
+	if (isRouteStoreRoutes(routeList)) return resolveRoute(pathname);
+	const match = findBestResolvedRouteFromRoutes(pathname, routeList);
+	return match ? {
+		handler: match.route.handler,
+		params: match.params
+	} : null;
+}
+function _resolveRouteMatchFromRoutes(pathname, routeList) {
+	return findBestResolvedRouteFromRoutes(pathname, routeList);
+}
+//#endregion
+export { insertRecordSorted as A, getCurrentPathPrefix as C, getRoutes as D, getRouteRecords as E, snapshotRouteState as F, computeRank as I, normalizeRouteSegmentName as L, pushRegistrationScope as M, restoreRouteState as N, hasActivePageScope as O, setDefaultRouteAuthOptions as P, parseSegments as R, getCurrentPageScope as S, getDefaultRouteAuthOptions as T, getCurrentInheritedAuthRequirements as _, resolveRouteFromRoutes as a, getCurrentLayoutChain as b, deepFreeze as c, _setActiveRouteAuthOptions as d, addRouteToStores as f, getActiveRoutes as g, getActiveRouteAuthOptions as h, getMatchingRouteRecord as i, lockRouteRegistration as j, hasRegisteredRoutes as k, makeQuery as l, clearRouteState as m, computeMatchesFromRoutes as n, buildRouteContext as o, assertRouteRegistrationUnlocked as p, computeRouteActivityMatches as r, buildRouteContextBase as s, _resolveRouteMatchFromRoutes as t, parseLocation as u, getCurrentInheritedMeta as v, getCurrentScopeKind as w, getCurrentPageChain as x, getCurrentInheritedPolicies as y };