@askrjs/askr 0.0.33 → 0.0.35

package/dist/router/route.js

@@ -1,3 +1,5 @@
+import { defineContext, readContext } from "../runtime/context.js";
+import { markReactivePropsDirtySource, markReadableDerivedSubscribersDirty, notifyReadableReaders, recordReadableRead } from "../runtime/readable.js";
 import { getCurrentComponentInstance } from "../runtime/component.js";
 import { computeRank, matchSegments, parseSegments } from "./match.js";
 import { requireAuth, requireGuest, requirePermission, requireRole } from "./policy.js";
@@ -11,12 +13,14 @@ import { getRenderContext } from "../ssr/context.js";
 * Primary public authoring:
 *   - `registerRoutes(() => { ... }, options?)`
 *   - `group(options, () => { ... })`
+*   - `page(path, Component, () => { ... })`
+*   - `index(Component, options?)`
 *   - `route(path, Component, options?)`
 *   - `fallback(Component)`
+*   - `Outlet()` for page child rendering
 *   - `currentRoute()` for render-time access
 *
 */
-/** Legacy flat route array — kept for resolver and route() accessor backward compat. */
 const routes = [];
 /** Normalized route records built by the declarative registration API. */
 const records = [];
@@ -24,6 +28,7 @@ const records = [];
 const registrationScopeStack = [];
 const registrationSessionStack = [];
 const namespaces = /* @__PURE__ */ new Set();
+let registrationLocked = false;
 let defaultRouteAuthOptions;
 let activeClientRouteAuthOptions;
 const HAS_ROUTES_KEY = Symbol.for("__ASKR_HAS_ROUTES__");
@@ -72,6 +77,9 @@ function cachedSortedList(routeList) {
 	}
 	return sorted;
 }
+let currentRouteSnapshot = buildRouteSnapshot("/", "", "");
+const currentRouteSource = (() => currentRouteSnapshot);
+currentRouteSource._readers = /* @__PURE__ */ new Map();
 let serverLocation = null;
 function setServerLocation(url) {
 	serverLocation = url;
@@ -79,27 +87,87 @@ function setServerLocation(url) {
 function isPromise(value) {
 	return value instanceof Promise;
 }
+function buildRouteSnapshot(pathname, search, hash) {
+	const query = makeQuery(search);
+	const matches = computeMatchesFromRoutes(pathname, getActiveRoutes());
+	return Object.freeze({
+		path: pathname,
+		params: deepFreeze({ ...matches[0]?.params }),
+		query,
+		hash: hash || null,
+		matches: Object.freeze(matches)
+	});
+}
+function setCurrentRouteSnapshot(pathname, search, hash) {
+	currentRouteSnapshot = buildRouteSnapshot(pathname, search, hash);
+	const instance = getCurrentComponentInstance();
+	markReadableDerivedSubscribersDirty(currentRouteSource);
+	markReactivePropsDirtySource(currentRouteSource);
+	notifyReadableReaders(currentRouteSource, instance);
+}
+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 = normalizedPath === "/" ? [] : normalizedPath.split("/").filter(Boolean);
+		return { "*": urlParts.length === 0 ? "/" : urlParts.length === 1 ? urlParts[0] : "/" + urlParts.join("/") };
+	}
+	if (normalizedPath !== normalizedPrefix && !normalizedPath.startsWith(`${normalizedPrefix}/`)) return null;
+	const remainder = normalizedPath === normalizedPrefix ? "/" : normalizedPath.slice(normalizedPrefix.length + 1);
+	const remainderParts = remainder === "/" ? [] : remainder.split("/").filter(Boolean);
+	return { "*": remainderParts.length === 0 ? "/" : remainderParts.length === 1 ? remainderParts[0] : "/" + remainderParts.join("/") };
+}
 function computeMatchesFromRoutes(pathname, routesList) {
-	const matches = [];
+	const bestMatch = routesList === routes ? getMatchingRecord(pathname, records) : 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 findBestResolvedRouteFromRoutes(pathname, routeList) {
 	const normalized = pathname.endsWith("/") && pathname !== "/" ? pathname.slice(0, -1) : pathname;
 	const urlParts = normalized === "/" ? [] : normalized.split("/").filter(Boolean);
-	for (const r of routesList) {
-		const params = matchSegments(urlParts, cachedSegs(r));
-		if (params !== null) matches.push({
-			pattern: r.path,
-			params,
-			name: r.name,
-			namespace: r.namespace,
-			rank: cachedRank(r)
-		});
+	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;
+		}
 	}
-	matches.sort((a, b) => b.rank - a.rank);
-	return matches.map((m) => ({
-		path: m.pattern,
-		params: deepFreeze({ ...m.params }),
-		name: m.name,
-		namespace: m.namespace
-	}));
+	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 getActiveRoutes() {
 	return getRenderContext()?.routes ?? routes;
@@ -125,6 +193,20 @@ function getCurrentLayoutChain() {
 	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 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);
@@ -134,7 +216,6 @@ function getCurrentInheritedPolicies() {
 * Prevent route registrations after the app has started.
 * Enforced in production; tests may unlock explicitly.
 */
-let registrationLocked = false;
 function lockRouteRegistration() {
 	registrationLocked = true;
 }
@@ -145,6 +226,37 @@ function validateRoutePath(path) {
 		throw new Error(`Route parameter syntax uses {name} interpolation, not :name. Use "${suggested}" instead of "${path}".`);
 	}
 }
+function normalizeAbsoluteRoutePath(path) {
+	if (!path || path === "/") return "/";
+	return (path.endsWith("/") ? path.slice(0, -1) : path) || "/";
+}
+function joinRoutePaths(prefix, path) {
+	const normalizedPrefix = normalizeAbsoluteRoutePath(prefix || "/");
+	const normalizedPath = path.replace(/^\/+|\/+$/g, "");
+	if (!normalizedPath) return normalizedPrefix;
+	return normalizedPrefix === "/" ? `/${normalizedPath}` : `${normalizedPrefix}/${normalizedPath}`;
+}
+function resolvePageScopePath(path) {
+	if (!path) throw new Error("page(path, Component, fn) requires a non-empty path.");
+	if (path.startsWith("/")) {
+		validateRoutePath(path);
+		return normalizeAbsoluteRoutePath(path);
+	}
+	return joinRoutePaths(getCurrentPathPrefix(), path);
+}
+function resolveIndexPath() {
+	return normalizeAbsoluteRoutePath(getCurrentPathPrefix() || "/");
+}
+function resolveRouteRegistrationPath(path) {
+	if (path.startsWith("/")) {
+		if (hasActivePageScope()) throw new Error(`Child route paths inside page() must be relative. Use "${path.slice(1)}" instead of "${path}".`);
+		validateRoutePath(path);
+		return normalizeAbsoluteRoutePath(path);
+	}
+	const prefix = getCurrentPathPrefix();
+	if (!prefix) throw new Error(`Route path must begin with "/". Got: "${path}"`);
+	return joinRoutePaths(prefix, path);
+}
 function insertRecordSorted(record) {
 	let lo = 0;
 	let hi = records.length;
@@ -169,6 +281,10 @@ function addRouteToStores(routeObj) {
 }
 /** Promises from in-flight lazy() imports, drained by createSPA / hydrateSPA. */
 const pendingLazy = /* @__PURE__ */ new Set();
+const outletContext = defineContext(null);
+function Outlet() {
+	return readContext(outletContext);
+}
 /**
 * Snapshot the current in-flight lazy() imports.
 * Boot uses this before clearing route state so manifest-based startup can
@@ -227,9 +343,30 @@ function _drainLazy(additionalPending = []) {
 function group(options, fn) {
 	pushGroupScope(options, fn);
 }
+function page(path, Component, optionsOrFn, maybeFn) {
+	const options = typeof optionsOrFn === "function" ? {} : optionsOrFn;
+	const fn = typeof optionsOrFn === "function" ? optionsOrFn : maybeFn;
+	if (typeof Component !== "function") throw new Error("page(path, Component, fn) requires a component function as the second argument.");
+	if (typeof fn !== "function") throw new Error("page(path, Component, fn) requires a route definition callback as the final argument.");
+	pushPageScope(path, Component, options, fn);
+}
+function index(Component, options) {
+	registerRouteAtResolvedPath(resolveIndexPath(), Component, options);
+}
 function fallback(Component) {
+	if (hasActivePageScope()) {
+		if (getCurrentScopeKind() !== "page") throw new Error("fallback() inside page() must be declared directly in the page scope, not inside nested group().");
+		registerRouteAtResolvedPath(`${getCurrentPathPrefix()}/*`, Component, void 0, {
+			isFallback: true,
+			fallbackPrefix: getCurrentPathPrefix()
+		});
+		return;
+	}
 	if (!registrationScopeStack.every((scope) => scope.policies.length === 0 && !scope.state.guestOnly && !scope.state.authenticated)) throw new Error("fallback() can only be registered at the root scope. Use route(\"/*\", Component) if you need compatibility behavior.");
-	route("/*", Component);
+	registerRouteAtResolvedPath("/*", Component, void 0, {
+		isFallback: true,
+		fallbackPrefix: "/"
+	});
 }
 function pushRegistrationScope(scope, fn) {
 	registrationScopeStack.push(scope);
@@ -246,11 +383,28 @@ function pushGroupScope(options, fn) {
 	});
 	const policies = compileNodePolicies(options);
 	pushRegistrationScope({
+		kind: "group",
+		pathPrefix: getCurrentPathPrefix(),
 		layout: options.layout,
 		policies,
 		state: nextAccessScopeState(options, getCurrentAccessScopeState())
 	}, fn);
 }
+function pushPageScope(path, Component, options, fn) {
+	if (hasActivePageScope()) throw new Error("page() cannot be nested inside another page(). Use route() for child leaves or group() for inherited behavior inside the existing page scope.");
+	validateAccessMetadata(options, {
+		authConfigured: getCurrentRegistrationSession().authConfigured,
+		state: getCurrentAccessScopeState()
+	});
+	const policies = compileNodePolicies(options);
+	pushRegistrationScope({
+		kind: "page",
+		pathPrefix: resolvePageScopePath(path),
+		page: Component,
+		policies,
+		state: nextAccessScopeState(options, getCurrentAccessScopeState())
+	}, fn);
+}
 function hasBuiltInAuthMetadata(node) {
 	return node.auth !== void 0 || !!node.role || !!node.permission;
 }
@@ -297,6 +451,55 @@ function normalizeRouteOptions(options) {
 		...options.namespace ? { namespace: options.namespace } : {}
 	};
 }
+function applyPageChain(pageChain, params, content) {
+	let nextContent = content;
+	for (let i = pageChain.length - 1; i >= 0; i--) nextContent = outletContext.Scope({
+		value: nextContent,
+		children: pageChain[i].component(params)
+	});
+	return nextContent;
+}
+function registerRouteAtResolvedPath(path, Component, options, metadata) {
+	validateAccessMetadata(options ?? {}, {
+		authConfigured: getCurrentRegistrationSession().authConfigured,
+		state: getCurrentAccessScopeState()
+	});
+	const chain = getCurrentLayoutChain();
+	const pageChain = getCurrentPageChain();
+	const segments = parseSegments(path);
+	const rank = computeRank(segments);
+	const isFallback = metadata?.isFallback ?? path === "/*";
+	const comp = Component;
+	const normalizedOptions = normalizeRouteOptions(options);
+	const policies = [...getCurrentInheritedPolicies(), ...normalizedOptions?.policies ?? []];
+	const handler = (params) => {
+		let content = comp(params);
+		content = applyPageChain(pageChain, params, content);
+		for (let i = chain.length - 1; i >= 0; i--) content = chain[i].component({ children: content });
+		return content;
+	};
+	insertRecordSorted({
+		path,
+		component: comp,
+		segments,
+		rank,
+		layoutChain: chain,
+		pageChain,
+		options: normalizedOptions ? {
+			...normalizedOptions,
+			...policies.length > 0 ? { policies } : {}
+		} : policies.length > 0 ? { policies } : {},
+		isFallback,
+		handler,
+		...metadata?.fallbackPrefix ? { fallbackPrefix: metadata.fallbackPrefix } : {}
+	});
+	addRouteToStores({
+		path,
+		handler,
+		namespace: normalizedOptions?.namespace ?? options?.namespace,
+		...metadata?.fallbackPrefix ? { fallbackPrefix: metadata.fallbackPrefix } : {}
+	});
+}
 function registerRoutes(definition, options = {}) {
 	defaultRouteAuthOptions = options.auth;
 	registrationSessionStack.push({ authConfigured: !!options.auth?.resolve });
@@ -341,8 +544,19 @@ function readCurrentRouteSnapshot() {
 	});
 }
 function currentRoute() {
+	const instance = getCurrentComponentInstance();
+	if (!instance) throw new Error("currentRoute() can only be called during component render execution. Call currentRoute() from inside your component function.");
+	if (typeof window === "undefined" || instance.ssr) return readCurrentRouteSnapshot();
+	if (currentRouteSnapshot.path !== (window.location.pathname || "/")) {
+		recordReadableRead(currentRouteSource);
+		return readCurrentRouteSnapshot();
+	}
+	recordReadableRead(currentRouteSource);
 	return readCurrentRouteSnapshot();
 }
+function syncCurrentRouteSnapshot(pathname, search, hash) {
+	setCurrentRouteSnapshot(pathname, search, hash);
+}
 function route(path, Component, options) {
 	if (getExecutionModel() === "islands") throw new Error("Routes are not supported with islands. Use createSPA (client) or createSSR (server) instead.");
 	if (typeof path === "undefined") throw new Error("route() is only for route registration. Use currentRoute() inside components.");
@@ -350,41 +564,7 @@ function route(path, Component, options) {
 	if (currentInst && currentInst.ssr) throw new Error("route() cannot be called during SSR rendering. Register routes at module load time instead.");
 	if (registrationLocked) throw new Error("Route registration is locked after app startup. Register routes at module load time before calling createSPA or createSSR.");
 	if (typeof Component !== "function") throw new Error("route(path, Component) requires a component function as the second argument. Passing JSX elements or VNodes directly is not supported.");
-	validateRoutePath(path);
-	validateAccessMetadata(options ?? {}, {
-		authConfigured: getCurrentRegistrationSession().authConfigured,
-		state: getCurrentAccessScopeState()
-	});
-	const chain = getCurrentLayoutChain();
-	const segments = parseSegments(path);
-	const rank = computeRank(segments);
-	const isFallback = path === "/*";
-	const comp = Component;
-	const normalizedOptions = normalizeRouteOptions(options);
-	const policies = [...getCurrentInheritedPolicies(), ...normalizedOptions?.policies ?? []];
-	const handler = (params) => {
-		let content = comp(params);
-		for (let i = chain.length - 1; i >= 0; i--) content = chain[i].component({ children: content });
-		return content;
-	};
-	insertRecordSorted({
-		path,
-		component: comp,
-		segments,
-		rank,
-		layoutChain: chain,
-		options: normalizedOptions ? {
-			...normalizedOptions,
-			...policies.length > 0 ? { policies } : {}
-		} : policies.length > 0 ? { policies } : {},
-		isFallback,
-		handler
-	});
-	addRouteToStores({
-		path,
-		handler,
-		namespace: normalizedOptions?.namespace ?? options?.namespace
-	});
+	registerRouteAtResolvedPath(resolveRouteRegistrationPath(path), Component, options);
 }
 /**
 * Return the normalized route manifest built from registered route definitions.
@@ -410,14 +590,14 @@ function getManifest() {
 function _applyManifest(manifest) {
 	defaultRouteAuthOptions = manifest.auth;
 	for (const record of manifest.records) {
-		records.push(record);
+		insertRecordSorted(record);
 		addRouteToStores({
 			path: record.path,
 			handler: record.handler,
-			namespace: record.options.namespace
+			namespace: record.options.namespace,
+			..."fallbackPrefix" in record && typeof record.fallbackPrefix === "string" ? { fallbackPrefix: record.fallbackPrefix } : {}
 		});
 	}
-	records.sort((a, b) => b.rank - a.rank);
 }
 /**
 * Get all registered routes (flat list, insertion order).
@@ -467,6 +647,26 @@ function clearRoutes() {
 function getLoadedNamespaces() {
 	return Array.from(namespaces);
 }
+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;
+}
 /**
 * Resolve a path to a route handler.
 *
@@ -479,26 +679,32 @@ function resolveRoute(pathname) {
 	const normalized = pathname.endsWith("/") && pathname !== "/" ? pathname.slice(0, -1) : pathname;
 	const urlParts = normalized === "/" ? [] : normalized.split("/").filter(Boolean);
 	for (const record of records) {
+		if (record.fallbackPrefix) continue;
 		const params = matchSegments(urlParts, record.segments);
 		if (params !== null) return {
 			handler: record.handler,
 			params
 		};
 	}
-	return null;
+	const fallbackMatch = findBestScopedFallbackRecord(normalized, records);
+	return fallbackMatch ? {
+		handler: fallbackMatch.record.handler,
+		params: fallbackMatch.params
+	} : null;
 }
 function getMatchingRecord(target, routeRecords) {
 	const location = parseLocation(target);
 	const normalized = location.pathname.endsWith("/") && location.pathname !== "/" ? location.pathname.slice(0, -1) : location.pathname;
 	const urlParts = normalized === "/" ? [] : normalized.split("/").filter(Boolean);
 	for (const record of routeRecords) {
+		if (record.fallbackPrefix) continue;
 		const params = matchSegments(urlParts, record.segments);
 		if (params !== null) return {
 			record,
 			params
 		};
 	}
-	return null;
+	return findBestScopedFallbackRecord(normalized, routeRecords);
 }
 function getRoutePolicies(options) {
 	if (!options) return [];
@@ -571,29 +777,13 @@ function resolveRouteRequest(target, options = {}) {
 */
 function resolveRouteFromRoutes(pathname, routeList) {
 	if (routeList === routes) return resolveRoute(pathname);
-	const normalized = pathname.endsWith("/") && pathname !== "/" ? pathname.slice(0, -1) : pathname;
-	const urlParts = normalized === "/" ? [] : normalized.split("/").filter(Boolean);
-	const sorted = cachedSortedList(routeList);
-	let bestHandler = null;
-	let bestParams = {};
-	let bestRank = -Infinity;
-	for (const r of sorted) {
-		const rank = cachedRank(r);
-		if (rank < bestRank) break;
-		if (bestHandler !== null && rank === bestRank) continue;
-		const params = matchSegments(urlParts, cachedSegs(r));
-		if (params !== null) {
-			bestHandler = r.handler;
-			bestParams = params;
-			bestRank = rank;
-		}
-	}
-	return bestHandler !== null ? {
-		handler: bestHandler,
-		params: bestParams
+	const match = findBestResolvedRouteFromRoutes(pathname, routeList);
+	return match ? {
+		handler: match.route.handler,
+		params: match.params
 	} : null;
 }
 //#endregion
-export { _applyManifest, _drainLazy, _setActiveRouteAuthOptions, _snapshotLazy, clearRoutes, currentRoute, fallback, getLoadedNamespaces, getManifest, getNamespaceRoutes, getRoutes, group, lazy, lockRouteRegistration, registerRoutes, resolveRoute, resolveRouteFromRoutes, resolveRouteRequest, route, setServerLocation, unloadNamespace };
+export { Outlet, _applyManifest, _drainLazy, _setActiveRouteAuthOptions, _snapshotLazy, clearRoutes, currentRoute, fallback, getLoadedNamespaces, getManifest, getNamespaceRoutes, getRoutes, group, index, lazy, lockRouteRegistration, page, registerRoutes, resolveRoute, resolveRouteFromRoutes, resolveRouteRequest, route, setServerLocation, syncCurrentRouteSnapshot, unloadNamespace };
 
 //# sourceMappingURL=route.js.map