@askrjs/askr 0.0.52 → 0.0.53

package/dist/router/navigation-targets.js

@@ -1,634 +0,0 @@
-import { isDevelopmentEnvironment } from "../common/env.js";
-import { logger } from "../common/logger.js";
-import { flushRuntimeScheduler } from "../runtime/access.js";
-import { ELEMENT_TYPE, Fragment } from "../common/jsx.js";
-import { cleanupComponent } from "../runtime/component-cleanup.js";
-import { isPromiseLike } from "../common/promise.js";
-import { beginLifecycleCommitBatch, discardLifecycleCommitBatch, drainLifecycleCommitErrors, flushLifecycleCommitBatch } from "../runtime/lifecycle-batch.js";
-import { mountComponent } from "../runtime/component-internal.js";
-import { DefaultPortal, clearDefaultPortalForInstance } from "../runtime/portal.js";
-import "../runtime/index.js";
-import { teardownNodeSubtree } from "../renderer/cleanup.js";
-import "../jsx/index.js";
-import { resolveRouteFromRoutes } from "./route-matching.js";
-import { resolveRouteRequest } from "./resolution.js";
-import "./route.js";
-import { getCurrentHref, getCurrentPathname, getRegisteredAppsSnapshot, parseTargetUrl, setCurrentRouteLocation, syncAppRegistrationLocation, syncRegisteredRouteSnapshot } from "./navigation-registry.js";
-import { applyHistoryScroll, applyNavigationScroll, saveScrollPosition } from "./navigation-scroll.js";
-//#region src/router/navigation-targets.ts
-const MAX_NAVIGATION_REDIRECTS = 20;
-let activeRouteRequestId = 0;
-let activeRouteRequestController = null;
-function beginRouteRequest() {
-	activeRouteRequestId += 1;
-	activeRouteRequestController?.abort();
-	activeRouteRequestController = new AbortController();
-	return {
-		id: activeRouteRequestId,
-		signal: activeRouteRequestController.signal
-	};
-}
-function isStaleRouteRequest(requestId) {
-	return requestId !== activeRouteRequestId;
-}
-function cancelRouteRequests() {
-	activeRouteRequestId += 1;
-	activeRouteRequestController?.abort();
-	activeRouteRequestController = null;
-}
-function isRenderResult(result) {
-	return result !== null && result.kind === "render";
-}
-function getRedirectHistoryMode(replace) {
-	return replace === false ? "push" : "replace";
-}
-function getNavigationHistoryMode(options) {
-	if (options.history) return options.history;
-	return options.replace ? "replace" : "push";
-}
-function createDeniedResolvedRoute(status) {
-	return {
-		handler: () => ({
-			type: "div",
-			props: { "data-route-denied": String(status) },
-			children: [String(status)]
-		}),
-		params: {}
-	};
-}
-function bindResolvedRouteHandler(resolved) {
-	return () => resolved.handler(resolved.params);
-}
-function wrapRootRouteHandler(componentFn) {
-	const wrappedFn = (props, ctx) => {
-		const out = componentFn(props, ctx);
-		if (isPromiseLike(out)) throw new Error("Async components are not supported. Components must return synchronously.");
-		const portalVNode = {
-			$$typeof: ELEMENT_TYPE,
-			type: DefaultPortal,
-			props: { __askrAutoDefaultPortal: true },
-			key: "__default_portal"
-		};
-		return {
-			$$typeof: ELEMENT_TYPE,
-			type: Fragment,
-			props: { children: out === void 0 || out === null ? [portalVNode] : [out, portalVNode] }
-		};
-	};
-	Object.defineProperty(wrappedFn, "name", { value: componentFn.name || "Component" });
-	return wrappedFn;
-}
-function flattenLifecycleErrors(error, result) {
-	if (error instanceof AggregateError) {
-		for (const nested of error.errors) flattenLifecycleErrors(nested, result);
-		return;
-	}
-	result.push(error);
-}
-function reportRouteCleanupErrors(errors) {
-	for (const error of errors) {
-		const flattened = [];
-		flattenLifecycleErrors(error, flattened);
-		for (const cleanupError of flattened.length > 0 ? flattened : [error]) logger.error("[Askr] route cleanup failed:", cleanupError);
-	}
-}
-function captureRouteDom(root) {
-	if (!root) return null;
-	const nodes = [];
-	const visit = (node) => {
-		nodes.push({
-			node,
-			children: Array.from(node.childNodes),
-			attributes: node instanceof Element ? Array.from(node.attributes).map((attribute) => [attribute.name, attribute.value]) : null,
-			nodeValue: node.nodeValue
-		});
-		for (const child of Array.from(node.childNodes)) visit(child);
-	};
-	visit(root);
-	return {
-		root,
-		nodes
-	};
-}
-function collectProvisionalRouteNodes(snapshot) {
-	const originalNodes = new Set(snapshot.nodes.map((entry) => entry.node));
-	const provisional = [];
-	const visit = (node) => {
-		if (!originalNodes.has(node)) {
-			provisional.push(node);
-			return;
-		}
-		for (const child of Array.from(node.childNodes)) visit(child);
-	};
-	for (const child of Array.from(snapshot.root.childNodes)) visit(child);
-	return provisional;
-}
-function restoreRouteDom(snapshot) {
-	if (!snapshot) return [];
-	const errors = [];
-	for (const node of collectProvisionalRouteNodes(snapshot)) try {
-		teardownNodeSubtree(node, { strict: true });
-	} catch (error) {
-		errors.push(error);
-	}
-	for (const entry of snapshot.nodes) {
-		const { node, attributes } = entry;
-		try {
-			if (attributes && node instanceof Element) {
-				const expected = new Map(attributes);
-				for (const attribute of Array.from(node.attributes)) if (!expected.has(attribute.name)) node.removeAttribute(attribute.name);
-				for (const [name, value] of attributes) if (node.getAttribute(name) !== value) node.setAttribute(name, value);
-			} else if (!(node instanceof Element)) node.nodeValue = entry.nodeValue;
-			if (node instanceof Element || node instanceof DocumentFragment) node.replaceChildren(...entry.children);
-		} catch (error) {
-			errors.push(error);
-		}
-	}
-	return errors;
-}
-function collectHostInstances(root) {
-	const instances = [];
-	const seen = /* @__PURE__ */ new Set();
-	const pending = [root];
-	while (pending.length > 0) {
-		const node = pending.pop();
-		if (node instanceof Element) {
-			const host = node;
-			for (const instance of host.__ASKR_INSTANCES ?? []) if (!seen.has(instance)) {
-				seen.add(instance);
-				instances.push(instance);
-			}
-			if (host.__ASKR_INSTANCE && !seen.has(host.__ASKR_INSTANCE)) {
-				seen.add(host.__ASKR_INSTANCE);
-				instances.push(host.__ASKR_INSTANCE);
-			}
-		} else {
-			const instance = node.__ASKR_INSTANCE;
-			if (instance && !seen.has(instance)) {
-				seen.add(instance);
-				instances.push(instance);
-			}
-		}
-		for (let child = node.lastChild; child; child = child.previousSibling) pending.push(child);
-	}
-	return instances;
-}
-function captureDeferredRouteCleanup(instance) {
-	return {
-		instance,
-		previousFn: instance.fn,
-		previousProps: instance.props,
-		previousExpectedStateIndices: instance.expectedStateIndices,
-		previousFirstRenderComplete: instance.firstRenderComplete,
-		previousStateIndexCheck: instance.stateIndexCheck,
-		previousErrorBoundaryState: instance.errorBoundaryState,
-		previousTarget: instance.target,
-		previousDom: captureRouteDom(instance.target),
-		previousStateValues: instance.stateValues,
-		previousCleanupFns: instance.cleanupFns,
-		previousOwnedChildScopes: instance._ownedChildScopes,
-		previousAbortController: instance.abortController,
-		previousMountOperations: instance.mountOperations,
-		previousCommitOperations: instance.commitOperations,
-		previousLifecycleSlots: instance.lifecycleSlots,
-		previousLifecycleGeneration: instance.lifecycleGeneration,
-		previousEvaluationGeneration: instance.evaluationGeneration,
-		previousHasPendingUpdate: instance.hasPendingUpdate,
-		previousNotifyUpdate: instance.notifyUpdate,
-		previousPlaceholder: instance._placeholder,
-		previousMounted: instance.mounted,
-		previousCurrentRenderToken: instance._currentRenderToken,
-		previousLastRenderToken: instance.lastRenderToken,
-		previousPendingReadSources: instance._pendingReadSources,
-		previousPendingReadSourceVersions: instance._pendingReadSourceVersions,
-		previousLastReadSources: instance._lastReadSources,
-		previousInstances: instance.target ? collectHostInstances(instance.target) : []
-	};
-}
-function restoreDeferredRouteInstance(deferred) {
-	const instance = deferred.instance;
-	const errors = restoreRouteDom(deferred.previousDom);
-	instance.fn = deferred.previousFn;
-	instance.props = deferred.previousProps;
-	instance.expectedStateIndices = deferred.previousExpectedStateIndices;
-	instance.firstRenderComplete = deferred.previousFirstRenderComplete;
-	instance.stateIndexCheck = deferred.previousStateIndexCheck;
-	instance.errorBoundaryState = deferred.previousErrorBoundaryState;
-	instance.target = deferred.previousTarget;
-	instance.stateValues = deferred.previousStateValues;
-	instance.cleanupFns = deferred.previousCleanupFns;
-	instance._ownedChildScopes = deferred.previousOwnedChildScopes;
-	instance.abortController = deferred.previousAbortController;
-	instance.mountOperations = deferred.previousMountOperations;
-	instance.commitOperations = deferred.previousCommitOperations;
-	instance.lifecycleSlots = deferred.previousLifecycleSlots;
-	instance.lifecycleGeneration = deferred.previousLifecycleGeneration;
-	instance.evaluationGeneration = deferred.previousEvaluationGeneration;
-	instance.hasPendingUpdate = deferred.previousHasPendingUpdate;
-	instance.notifyUpdate = deferred.previousNotifyUpdate;
-	instance._placeholder = deferred.previousPlaceholder;
-	instance.mounted = deferred.previousMounted;
-	instance._currentRenderToken = deferred.previousCurrentRenderToken;
-	instance.lastRenderToken = deferred.previousLastRenderToken;
-	instance._pendingReadSources = deferred.previousPendingReadSources;
-	instance._pendingReadSourceVersions = deferred.previousPendingReadSourceVersions;
-	instance._lastReadSources = deferred.previousLastReadSources;
-	return errors;
-}
-function restoreDeferredRouteInstances(deferredCleanups) {
-	const errors = [];
-	for (let index = deferredCleanups.length - 1; index >= 0; index -= 1) errors.push(...restoreDeferredRouteInstance(deferredCleanups[index]));
-	if (errors.length > 0) reportRouteCleanupErrors(errors);
-}
-function cleanupDeferredRouteInstance(deferred) {
-	const errors = [];
-	const instance = deferred.instance;
-	const current = {
-		stateValues: instance.stateValues,
-		cleanupFns: instance.cleanupFns,
-		ownedChildScopes: instance._ownedChildScopes,
-		abortController: instance.abortController,
-		mountOperations: instance.mountOperations,
-		commitOperations: instance.commitOperations,
-		lifecycleSlots: instance.lifecycleSlots,
-		lifecycleGeneration: instance.lifecycleGeneration,
-		evaluationGeneration: instance.evaluationGeneration,
-		hasPendingUpdate: instance.hasPendingUpdate,
-		notifyUpdate: instance.notifyUpdate,
-		placeholder: instance._placeholder,
-		mounted: instance.mounted,
-		currentRenderToken: instance._currentRenderToken,
-		lastRenderToken: instance.lastRenderToken,
-		pendingReadSources: instance._pendingReadSources,
-		pendingReadSourceVersions: instance._pendingReadSourceVersions,
-		lastReadSources: instance._lastReadSources
-	};
-	instance.stateValues = deferred.previousStateValues;
-	instance.cleanupFns = deferred.previousCleanupFns;
-	instance._ownedChildScopes = deferred.previousOwnedChildScopes;
-	instance.abortController = deferred.previousAbortController;
-	instance.mountOperations = deferred.previousMountOperations;
-	instance.commitOperations = deferred.previousCommitOperations;
-	instance.lifecycleSlots = deferred.previousLifecycleSlots;
-	instance.lifecycleGeneration = deferred.previousLifecycleGeneration;
-	instance.evaluationGeneration = deferred.previousEvaluationGeneration;
-	instance.hasPendingUpdate = deferred.previousHasPendingUpdate;
-	instance.notifyUpdate = deferred.previousNotifyUpdate;
-	instance._placeholder = deferred.previousPlaceholder;
-	instance.mounted = deferred.previousMounted;
-	instance._currentRenderToken = deferred.previousCurrentRenderToken;
-	instance.lastRenderToken = deferred.previousLastRenderToken;
-	instance._pendingReadSources = deferred.previousPendingReadSources;
-	instance._pendingReadSourceVersions = deferred.previousPendingReadSourceVersions;
-	instance._lastReadSources = deferred.previousLastReadSources;
-	try {
-		cleanupComponent(instance);
-	} catch (error) {
-		errors.push(error);
-	} finally {
-		instance.stateValues = current.stateValues;
-		instance.cleanupFns = current.cleanupFns;
-		instance._ownedChildScopes = current.ownedChildScopes;
-		instance.abortController = current.abortController;
-		instance.mountOperations = current.mountOperations;
-		instance.commitOperations = current.commitOperations;
-		instance.lifecycleSlots = current.lifecycleSlots;
-		instance.lifecycleGeneration = current.lifecycleGeneration;
-		instance.evaluationGeneration = current.evaluationGeneration;
-		instance.hasPendingUpdate = current.hasPendingUpdate;
-		instance.notifyUpdate = current.notifyUpdate;
-		instance._placeholder = current.placeholder;
-		instance.mounted = current.mounted;
-		instance._currentRenderToken = current.currentRenderToken;
-		instance.lastRenderToken = current.lastRenderToken;
-		instance._pendingReadSources = current.pendingReadSources;
-		instance._pendingReadSourceVersions = current.pendingReadSourceVersions;
-		instance._lastReadSources = current.lastReadSources;
-	}
-	const root = instance.target;
-	const liveInstances = root ? new Set(collectHostInstances(root)) : /* @__PURE__ */ new Set();
-	for (let index = deferred.previousInstances.length - 1; index >= 0; index--) {
-		const previous = deferred.previousInstances[index];
-		if (previous === instance || liveInstances.has(previous)) continue;
-		try {
-			cleanupComponent(previous);
-		} catch (error) {
-			errors.push(error);
-		}
-	}
-	return errors;
-}
-function remountResolvedRoute(instance, resolved, pathname, href, existingSnapshot) {
-	const deferredCleanup = existingSnapshot ?? captureDeferredRouteCleanup(instance);
-	clearDefaultPortalForInstance(instance);
-	instance.fn = wrapRootRouteHandler(bindResolvedRouteHandler(resolved));
-	instance.props = {};
-	instance.stateValues = [];
-	instance.expectedStateIndices = [];
-	instance.firstRenderComplete = false;
-	instance.stateIndexCheck = -1;
-	instance.evaluationGeneration++;
-	instance.notifyUpdate = null;
-	instance.mountOperations = [];
-	instance.commitOperations = [];
-	instance.lifecycleSlots = [];
-	instance.cleanupFns = [];
-	instance._ownedChildScopes = /* @__PURE__ */ new Set();
-	instance._placeholder = void 0;
-	instance.hasPendingUpdate = false;
-	instance._currentRenderToken = void 0;
-	instance.lastRenderToken = 0;
-	instance._pendingReadSources = void 0;
-	instance._lastReadSources = void 0;
-	instance.abortController = null;
-	mountComponent(instance);
-	setCurrentRouteLocation(pathname, href);
-	return deferredCleanup;
-}
-function rerenderResolvedRoute(instance, pathname, href) {
-	setCurrentRouteLocation(pathname, href);
-	instance._enqueueRun?.();
-	return true;
-}
-function resolveAppRouteRequest(app, pathname, href, signal) {
-	if (app.manifest) return resolveRouteRequest(href, {
-		manifest: app.manifest,
-		auth: app.auth,
-		signal
-	});
-	if (app.routes) {
-		const resolved = resolveRouteFromRoutes(pathname, app.routes);
-		if (!resolved) return null;
-		return {
-			kind: "render",
-			handler: resolved.handler,
-			params: resolved.params
-		};
-	}
-	return resolveRouteRequest(href, {
-		auth: app.auth,
-		signal
-	});
-}
-function getResolvedRouteHandler(resolved) {
-	if (!resolved) throw new Error("[Askr] cannot prepare an unmatched navigation target");
-	if (resolved.kind === "deny") return createDeniedResolvedRoute(resolved.status);
-	if (!isRenderResult(resolved)) throw new Error("[Askr] cannot prepare a redirect as a destination root");
-	return {
-		handler: resolved.handler,
-		params: resolved.params
-	};
-}
-function resolveNavigationTargetsForApps(pathname, href, signal) {
-	const apps = getRegisteredAppsSnapshot();
-	if (apps.length === 1) {
-		const app = apps[0];
-		const resolved = resolveAppRouteRequest(app, pathname, href, signal);
-		if (isPromiseLike(resolved)) return Promise.resolve(resolved).then((next) => [{
-			app,
-			resolved: next
-		}]);
-		return [{
-			app,
-			resolved
-		}];
-	}
-	const syncTargets = [];
-	const pendingTargets = [];
-	for (const app of apps) {
-		const resolved = resolveAppRouteRequest(app, pathname, href, signal);
-		if (isPromiseLike(resolved)) {
-			pendingTargets.push(Promise.resolve(resolved).then((next) => ({
-				app,
-				resolved: next
-			})));
-			continue;
-		}
-		syncTargets.push({
-			app,
-			resolved
-		});
-	}
-	if (pendingTargets.length === 0) return syncTargets;
-	return Promise.all([...syncTargets.map((target) => Promise.resolve(target)), ...pendingTargets]);
-}
-function applyNavigationTargets(requestId, path, options, redirectState, pathname, href, targets, navigateWithRedirectState) {
-	if (isStaleRouteRequest(requestId)) return;
-	const previousPathname = getCurrentPathname();
-	const previousHref = getCurrentHref();
-	for (const target of targets) {
-		const resolved = target.resolved;
-		if (!resolved || resolved.kind !== "redirect") continue;
-		const redirectTarget = parseTargetUrl(resolved.to);
-		const redirectHref = `${redirectTarget.pathname}${redirectTarget.search}${redirectTarget.hash}`;
-		if (redirectHref === href) {
-			if (isDevelopmentEnvironment()) logger.warn(`Navigation guard redirected to the same path: ${redirectHref}`);
-			return;
-		}
-		if (redirectState.visited.has(redirectHref)) throw new Error(`[Askr] Navigation redirect cycle detected at ${redirectHref}.`);
-		if (redirectState.redirects >= MAX_NAVIGATION_REDIRECTS) throw new Error(`[Askr] Navigation redirect limit exceeded (${MAX_NAVIGATION_REDIRECTS}).`);
-		redirectState.visited.add(redirectHref);
-		redirectState.redirects++;
-		navigateWithRedirectState(redirectHref, { history: getRedirectHistoryMode(resolved.replace) }, redirectState);
-		return;
-	}
-	const matchedTargets = targets.filter((target) => target.resolved !== null);
-	if (matchedTargets.length === 0) {
-		if (isDevelopmentEnvironment()) logger.warn(`No route found for path: ${path}`);
-		return;
-	}
-	if (isStaleRouteRequest(requestId)) return;
-	const samePathTargets = [];
-	const rootsToPrepare = [];
-	for (const target of matchedTargets) {
-		const resolved = target.resolved;
-		if (resolved.kind === "redirect") continue;
-		if (pathname === target.app.pathname && isRenderResult(resolved)) {
-			samePathTargets.push(target);
-			continue;
-		}
-		rootsToPrepare.push(target);
-	}
-	const rollbackSnapshots = matchedTargets.map((target) => captureDeferredRouteCleanup(target.app.instance));
-	const rollbackSnapshotByInstance = new Map(rollbackSnapshots.map((snapshot) => [snapshot.instance, snapshot]));
-	const deferredCleanups = [];
-	const cleanupErrors = [];
-	const previousAppLocations = matchedTargets.map((target) => ({
-		app: target.app,
-		pathname: target.app.pathname,
-		href: target.app.href
-	}));
-	const restoreOnExit = () => {
-		if (!navigationBatchClosed) {
-			discardLifecycleCommitBatch(navigationBatch);
-			navigationBatchClosed = true;
-		}
-		restoreDeferredRouteInstances(rollbackSnapshots);
-		for (const previous of previousAppLocations) {
-			previous.app.pathname = previous.pathname;
-			previous.app.href = previous.href;
-		}
-		setCurrentRouteLocation(previousPathname, previousHref);
-	};
-	const navigationBatch = beginLifecycleCommitBatch();
-	let navigationBatchClosed = false;
-	try {
-		for (const target of rootsToPrepare) {
-			if (isStaleRouteRequest(requestId)) {
-				restoreOnExit();
-				return;
-			}
-			const deferredCleanup = remountResolvedRoute(target.app.instance, getResolvedRouteHandler(target.resolved), pathname, href, rollbackSnapshotByInstance.get(target.app.instance));
-			deferredCleanups.push(deferredCleanup);
-		}
-		if (isStaleRouteRequest(requestId)) {
-			restoreOnExit();
-			return;
-		}
-		flushRuntimeScheduler();
-		cleanupErrors.push(...drainLifecycleCommitErrors());
-		if (isStaleRouteRequest(requestId)) {
-			restoreOnExit();
-			return;
-		}
-		for (const target of samePathTargets) {
-			if (isStaleRouteRequest(requestId)) {
-				restoreOnExit();
-				return;
-			}
-			rerenderResolvedRoute(target.app.instance, pathname, href);
-		}
-		flushRuntimeScheduler();
-		cleanupErrors.push(...drainLifecycleCommitErrors());
-		if (isStaleRouteRequest(requestId)) {
-			restoreOnExit();
-			return;
-		}
-		flushLifecycleCommitBatch(navigationBatch);
-		navigationBatchClosed = true;
-		cleanupErrors.push(...drainLifecycleCommitErrors());
-		for (const target of matchedTargets) if (target.resolved && target.resolved.kind !== "redirect") syncAppRegistrationLocation(target.app, pathname, href);
-		if (isStaleRouteRequest(requestId)) {
-			restoreOnExit();
-			return;
-		}
-		saveScrollPosition(previousHref);
-		const historyMethod = getNavigationHistoryMode(options) === "replace" ? "replaceState" : "pushState";
-		window.history[historyMethod]({ path: href }, "", href);
-		setCurrentRouteLocation(pathname, href);
-		syncRegisteredRouteSnapshot();
-		if (pathname !== previousPathname) applyNavigationScroll(options.scroll);
-		for (const deferredCleanup of deferredCleanups) cleanupErrors.push(...cleanupDeferredRouteInstance(deferredCleanup));
-		for (const error of cleanupErrors) reportRouteCleanupErrors([error]);
-	} catch (error) {
-		restoreOnExit();
-		logger.error("[Askr] navigation failed:", error);
-		throw error;
-	}
-}
-function applyPopStateNavigationTargets(requestId, previousHref, previousState, pathname, href, state, targets, navigate) {
-	if (isStaleRouteRequest(requestId)) return;
-	const matchedTargets = targets.filter((target) => target.resolved !== null);
-	if (matchedTargets.length === 0) {
-		if (isDevelopmentEnvironment()) logger.warn(`No route found for path: ${pathname}`);
-		return;
-	}
-	for (const target of matchedTargets) {
-		const resolved = target.resolved;
-		if (resolved.kind !== "redirect") continue;
-		navigate(resolved.to, { history: getRedirectHistoryMode(resolved.replace) });
-		return;
-	}
-	const samePathTargets = [];
-	const rootsToPrepare = [];
-	for (const target of matchedTargets) {
-		const resolved = target.resolved;
-		if (pathname === target.app.pathname && isRenderResult(resolved)) {
-			samePathTargets.push(target);
-			continue;
-		}
-		if (resolved.kind === "redirect") continue;
-		rootsToPrepare.push(target);
-	}
-	const previousPathname = getCurrentPathname();
-	const rollbackSnapshots = matchedTargets.map((target) => captureDeferredRouteCleanup(target.app.instance));
-	const rollbackSnapshotByInstance = new Map(rollbackSnapshots.map((snapshot) => [snapshot.instance, snapshot]));
-	const deferredCleanups = [];
-	const cleanupErrors = [];
-	const previousAppLocations = matchedTargets.map((target) => ({
-		app: target.app,
-		pathname: target.app.pathname,
-		href: target.app.href
-	}));
-	const restoreOnExit = () => {
-		if (!navigationBatchClosed) {
-			discardLifecycleCommitBatch(navigationBatch);
-			navigationBatchClosed = true;
-		}
-		restoreDeferredRouteInstances(rollbackSnapshots);
-		for (const previous of previousAppLocations) {
-			previous.app.pathname = previous.pathname;
-			previous.app.href = previous.href;
-		}
-		setCurrentRouteLocation(previousPathname, previousHref);
-	};
-	const navigationBatch = beginLifecycleCommitBatch();
-	let navigationBatchClosed = false;
-	try {
-		for (const target of rootsToPrepare) {
-			if (isStaleRouteRequest(requestId)) {
-				restoreOnExit();
-				return;
-			}
-			const deferredCleanup = remountResolvedRoute(target.app.instance, getResolvedRouteHandler(target.resolved), pathname, href, rollbackSnapshotByInstance.get(target.app.instance));
-			deferredCleanups.push(deferredCleanup);
-		}
-		if (isStaleRouteRequest(requestId)) {
-			restoreOnExit();
-			return;
-		}
-		flushRuntimeScheduler();
-		cleanupErrors.push(...drainLifecycleCommitErrors());
-		if (isStaleRouteRequest(requestId)) {
-			restoreOnExit();
-			return;
-		}
-		for (const target of samePathTargets) {
-			if (isStaleRouteRequest(requestId)) {
-				restoreOnExit();
-				return;
-			}
-			rerenderResolvedRoute(target.app.instance, pathname, href);
-		}
-		flushRuntimeScheduler();
-		cleanupErrors.push(...drainLifecycleCommitErrors());
-		if (isStaleRouteRequest(requestId)) {
-			restoreOnExit();
-			return;
-		}
-		flushLifecycleCommitBatch(navigationBatch);
-		navigationBatchClosed = true;
-		cleanupErrors.push(...drainLifecycleCommitErrors());
-		for (const target of matchedTargets) if (target.resolved && target.resolved.kind !== "redirect") syncAppRegistrationLocation(target.app, pathname, href);
-		if (isStaleRouteRequest(requestId)) {
-			restoreOnExit();
-			return;
-		}
-		setCurrentRouteLocation(pathname, href);
-		syncRegisteredRouteSnapshot();
-		applyHistoryScroll(href, state);
-		for (const deferredCleanup of deferredCleanups) cleanupErrors.push(...cleanupDeferredRouteInstance(deferredCleanup));
-		for (const error of cleanupErrors) reportRouteCleanupErrors([error]);
-	} catch (error) {
-		restoreOnExit();
-		try {
-			window.history.replaceState(previousState, "", previousHref);
-			syncRegisteredRouteSnapshot();
-		} catch (rollbackError) {
-			logger.error("[Askr] failed to restore URL after popstate failure:", rollbackError);
-		}
-		throw error;
-	}
-}
-//#endregion
-export { applyNavigationTargets, applyPopStateNavigationTargets, beginRouteRequest, cancelRouteRequests, getRedirectHistoryMode, isStaleRouteRequest, resolveNavigationTargetsForApps };

package/dist/router/policy.d.ts

@@ -1,27 +0,0 @@
-import { AccessAllowDecision, AccessDecision, AccessDenyDecision, AccessDenyStatus, AccessRedirectDecision, AccessRedirectStatus, RouteAuthOptions, RouteContext, RoutePolicy } from "../common/router.js";
-
-//#region src/router/policy.d.ts
-type BuiltInRoutePolicyKind = 'auth' | 'guest' | 'role' | 'permission';
-interface BuiltInRoutePolicyMetadata {
-  kind: BuiltInRoutePolicyKind;
-  value?: string;
-}
-declare function allow(): AccessAllowDecision;
-declare function redirect(to: string, init?: {
-  status?: AccessRedirectStatus;
-  replace?: boolean;
-}): AccessRedirectDecision;
-declare function deny(status: AccessDenyStatus): AccessDenyDecision;
-declare function unauthorized(): AccessDenyDecision;
-declare function forbidden(): AccessDenyDecision;
-declare function notFound(): AccessDenyDecision;
-declare function normalizeAccessDecision(result: AccessDecision): AccessDecision;
-declare function withRouteAuthOptions(context: RouteContext, auth: RouteAuthOptions | undefined): RouteContext;
-declare function _getBuiltInRoutePolicy(policy: RoutePolicy): BuiltInRoutePolicyMetadata | null;
-declare function requireAuth(): RoutePolicy;
-declare function requireGuest(): RoutePolicy;
-declare function requireRole(role: string): RoutePolicy;
-declare function requirePermission(permission: string): RoutePolicy;
-declare function evaluateRoutePolicy(policy: RoutePolicy, context: RouteContext): Promise<AccessDecision>;
-//#endregion
-export { BuiltInRoutePolicyKind, BuiltInRoutePolicyMetadata, allow, deny, forbidden, notFound, redirect, requireAuth, requirePermission, requireRole, unauthorized };