@loozo/angular-router 0.0.3 → 0.0.4

package/fesm2022/loozo-angular-router-_generated.mjs

@@ -1,7 +1,7 @@
-import { DestroyRef, Injector, PendingTasks, inject, resourceFromSnapshots, runInInjectionContext, signal } from "@angular/core";
-import { ActivatedRoute, NavigationCancel, NavigationCancellationCode, NavigationEnd, NavigationError, NavigationSkipped, NavigationStart, Router } from "@angular/router";
-import { Observable, from, isObservable } from "rxjs";
-import { codecPresence, createUrl, routeMetadata } from "@loozo/angular-router/_core";
+import { DestroyRef, computed, inject, signal } from "@angular/core";
+import { ActivatedRoute, RedirectCommand, Router, UrlTree } from "@angular/router";
+import { from, isObservable, map, merge } from "rxjs";
+import { codecFallback, createUrl, routeMetadata } from "@loozo/angular-router/_core";
 function hasIdentity(snapshot, id) {
 	const data = snapshot.routeConfig?.data;
 	return !!data && Object.hasOwn(data, "__loozoAngularRouterRouteId") && data.__loozoAngularRouterRouteId === id;
@@ -9,17 +9,33 @@ function hasIdentity(snapshot, id) {
 function assertIdentity(snapshot, id) {
 	if (!hasIdentity(snapshot, id)) throw new Error(`Generated route wiring identity mismatch: ${id}`);
 }
-function inputError(source, key, reason, cause) {
-	return Object.assign(new Error(`Invalid ${source} input ${key}: ${reason}`, { cause }), {
-		source,
-		key,
-		reason
-	});
+var InputError = class extends Error {
+	key;
+	reason;
+	source = "path";
+	constructor(key, reason, cause) {
+		super(`Invalid path input ${key}: ${reason}`, { cause });
+		this.key = key;
+		this.reason = reason;
+	}
+};
+function validateRaw(key, raws, array) {
+	if (!array && raws.length === 0) throw new InputError(key, "missing");
+	if (!array && raws.length > 1) throw new InputError(key, "repeated");
+	if (raws.some((raw) => typeof raw !== "string")) throw new InputError(key, "invalid", /* @__PURE__ */ new TypeError("Raw input must be a decoded string"));
 }
-function validateRaw(source, key, raws, array) {
-	if (!array && raws.length === 0) throw inputError(source, key, "missing");
-	if (!array && raws.length > 1) throw inputError(source, key, "repeated");
-	if (raws.some((raw) => typeof raw !== "string")) throw inputError(source, key, "invalid", /* @__PURE__ */ new TypeError("Raw input must be a decoded string"));
+function parse(codec, raw) {
+	let value;
+	try {
+		value = codec.parse(raw);
+	} catch (cause) {
+		return { cause };
+	}
+	if (value !== null && (typeof value === "object" || typeof value === "function") && typeof value.then === "function") {
+		Promise.resolve(value).catch(() => void 0);
+		throw new TypeError("ParamCodec.parse must return its value synchronously, not a Promise");
+	}
+	return { value };
 }
 function pathJobs(definition, url) {
 	const metadata = routeMetadata(definition);
@@ -31,9 +47,8 @@ function pathJobs(definition, url) {
 		const array = segment.kind === "catchall";
 		if (array) raws = url.slice(index).map((value) => value.path);
 		else if (index < url.length) raws = [url[index].path];
-		validateRaw("path", segment.name, raws, array);
+		validateRaw(segment.name, raws, array);
 		local.set(segment.name, {
-			source: "path",
 			key: segment.name,
 			raws,
 			array,
@@ -42,75 +57,63 @@ function pathJobs(definition, url) {
 	}
 	return [...local.values()];
 }
-function searchJobs(definition, snapshot) {
+function runPathJobs(jobs) {
+	const params = Object.create(null);
+	for (const job of jobs) {
+		const values = [];
+		for (const raw of job.raws) {
+			const result = parse(job.codec, raw);
+			if ("cause" in result) throw new InputError(job.key, "invalid", result.cause);
+			values.push(result.value);
+		}
+		if (job.array) params[job.key] = Object.freeze(values);
+		else params[job.key] = values[0];
+	}
+	return Object.freeze(params);
+}
+function parseSearch(definition, snapshot) {
 	const metadata = routeMetadata(definition);
-	const jobs = [];
+	const search = Object.create(null);
 	for (const key of Object.keys(metadata.search)) {
 		const codec = metadata.search[key];
 		const raws = snapshot.queryParamMap.getAll(key);
-		if (raws.length === 0 && codecPresence(codec) === "optional") continue;
-		validateRaw("search", key, raws, false);
-		jobs.push({
-			source: "search",
-			key,
-			raws,
-			array: false,
-			codec
-		});
-	}
-	return jobs;
-}
-async function runJobs(jobs) {
-	const params = Object.create(null);
-	const search = Object.create(null);
-	const pending = [];
-	for (const job of jobs) pending.push((async () => {
-		try {
-			const elements = [];
-			for (const raw of job.raws) elements.push((async () => job.codec.parse(raw))());
-			const values = await Promise.all(elements);
-			let value = values[0];
-			if (job.array) value = Object.freeze(values);
-			if (job.source === "path") params[job.key] = value;
-			else search[job.key] = value;
-		} catch (cause) {
-			throw inputError(job.source, job.key, "invalid", cause);
+		if (raws.length === 1 && typeof raws[0] === "string") {
+			const result = parse(codec, raws[0]);
+			if ("value" in result) {
+				search[key] = result.value;
+				continue;
+			}
 		}
-	})());
-	await Promise.all(pending);
-	return Object.freeze({
-		params: Object.freeze(params),
-		search: Object.freeze(search)
-	});
+		const fallback = codecFallback(codec);
+		if (fallback) search[key] = fallback.value;
+	}
+	return Object.freeze(search);
 }
 const full = /* @__PURE__ */ new WeakMap();
+const paths = /* @__PURE__ */ new WeakMap();
 const matching = /* @__PURE__ */ new WeakMap();
-function operation(cache, definition, snapshot, collect) {
+function memo(cache, definition, snapshot, run) {
 	let snapshots = cache.get(definition);
 	if (!snapshots) {
 		snapshots = /* @__PURE__ */ new WeakMap();
 		cache.set(definition, snapshots);
 	}
-	const existing = snapshots.get(snapshot);
-	if (existing) return existing;
-	const result = {
-		promise: Promise.resolve().then(() => runJobs(collect())),
-		outcome: void 0
-	};
-	snapshots.set(snapshot, result);
-	result.promise.then((value) => {
-		result.outcome = { value };
-	}, (cause) => {
-		let error = cause;
-		if (!(error instanceof Error)) error = new Error("Route input failure", { cause });
-		result.outcome = { error };
-	});
-	return result;
+	let outcome = snapshots.get(snapshot);
+	if (!outcome) {
+		try {
+			outcome = { value: run() };
+		} catch (error) {
+			outcome = { error };
+		}
+		snapshots.set(snapshot, outcome);
+	}
+	if ("error" in outcome) throw outcome.error;
+	return outcome.value;
 }
-function fullOperation(set, id, snapshot) {
+function parseInputs(set, id, snapshot) {
 	assertIdentity(snapshot, id);
 	const binding = set.records[id];
-	return operation(full, binding.definition(), snapshot, () => {
+	return memo(full, binding.definition(), snapshot, () => {
 		const jobs = [];
 		for (const ownerId of binding.owners) {
 			const definition = set.records[ownerId].definition();
@@ -120,50 +123,40 @@ function fullOperation(set, id, snapshot) {
 			assertIdentity(owner, ownerId);
 			jobs.push(...pathJobs(definition, owner.url));
 		}
-		jobs.push(...searchJobs(binding.definition(), snapshot));
-		return jobs;
+		const params = runPathJobs(jobs);
+		return Object.freeze({
+			params,
+			search: parseSearch(binding.definition(), snapshot)
+		});
 	});
 }
-function parseInputs(set, id, snapshot) {
-	return fullOperation(set, id, snapshot).promise;
-}
-function matchingInputs(set, id, snapshot) {
+function pathInputs(set, id, snapshot) {
 	assertIdentity(snapshot, id);
 	const definition = set.records[id].definition();
-	return operation(matching, definition, snapshot, () => [...pathJobs(definition, snapshot.url), ...searchJobs(definition, snapshot)]).promise;
-}
-function isPromiseResult(value) {
-	return !!value && typeof value.then === "function";
+	try {
+		return { params: memo(paths, definition, snapshot, () => runPathJobs(pathJobs(definition, snapshot.url))) };
+	} catch (error) {
+		if (error instanceof InputError) return { error };
+		throw error;
+	}
 }
-function bridge(inputs, callback) {
-	const injector = inject(Injector);
-	return new Observable((subscriber) => {
-		let subscription;
-		inputs().then((value) => {
-			if (subscriber.closed) return;
-			try {
-				const result = runInInjectionContext(injector, () => callback(value));
-				if (isObservable(result)) subscription = result.subscribe(subscriber);
-				else if (isPromiseResult(result)) subscription = from(Promise.resolve(result)).subscribe(subscriber);
-				else {
-					subscriber.next(result);
-					subscriber.complete();
-				}
-			} catch (error) {
-				subscriber.error(error);
-			}
-		}, (error) => subscriber.error(error));
-		return () => subscription?.unsubscribe();
+function matchingInputs(set, id, snapshot) {
+	const definition = set.records[id].definition();
+	return memo(matching, definition, snapshot, () => {
+		const path = pathInputs(set, id, snapshot);
+		if ("error" in path) return;
+		return Object.freeze({
+			params: path.params,
+			search: parseSearch(definition, snapshot)
+		});
 	});
 }
 function callbacks(set, id) {
-	const config = routeMetadata(set.records[id].definition()).config;
+	const metadata = routeMetadata(set.records[id].definition());
+	const config = metadata.config;
 	const result = {};
 	const activate = config.canActivate;
-	if (activate) result.canActivate = activate.map((callback) => (snapshot, state) => {
-		assertIdentity(snapshot, id);
-		return bridge(() => parseInputs(set, id, snapshot), (inputs) => callback(inputs, snapshot, state));
-	});
+	if (activate) result.canActivate = activate.map((callback) => (snapshot, state) => callback(parseInputs(set, id, snapshot), snapshot, state));
 	const children = config.canActivateChild;
 	if (children) result.canActivateChild = children.map((callback) => (child, state) => {
 		let parent;
@@ -175,27 +168,50 @@ function callbacks(set, id) {
 			}
 		}
 		if (!parent) throw new Error(`Generated guard ancestor missing: ${id}`);
-		assertIdentity(parent, id);
-		return bridge(() => parseInputs(set, id, parent), (inputs) => callback(inputs, child, state));
+		return callback(parseInputs(set, id, parent), child, state);
 	});
 	const matching = config.canMatch;
-	if (matching) result.canMatch = matching.map((callback) => (route, segments, snapshot) => {
-		assertIdentity(snapshot, id);
-		return bridge(() => matchingInputs(set, id, snapshot), (inputs) => callback(inputs, route, segments, snapshot));
+	const canMatch = [];
+	if (metadata.localSegments.some((segment) => segment.kind !== "static") || Object.keys(metadata.search).length > 0) {
+		const handler = config.onInvalidParams;
+		canMatch.push((route, segments, snapshot) => {
+			const path = pathInputs(set, id, snapshot);
+			if (!("error" in path)) {
+				matchingInputs(set, id, snapshot);
+				return true;
+			}
+			if (!handler) return false;
+			const decision = handler(path.error, route, segments, snapshot);
+			if (isObservable(decision) || isPromiseResult(decision)) return from(decision).pipe(map(invalidParamsResult));
+			return invalidParamsResult(decision);
+		});
+	}
+	if (matching) for (const callback of matching) canMatch.push((route, segments, snapshot) => {
+		const inputs = matchingInputs(set, id, snapshot);
+		if (inputs === void 0) return false;
+		return callback(inputs, route, segments, snapshot);
 	});
+	if (canMatch.length > 0) result.canMatch = canMatch;
 	const resolvers = config.resolve;
 	if (resolvers) {
 		const resolve = Object.create(null);
-		for (const key of Reflect.ownKeys(resolvers)) resolve[key] = (snapshot, state) => {
-			assertIdentity(snapshot, id);
-			return bridge(() => parseInputs(set, id, snapshot), (inputs) => resolvers[key](inputs, snapshot, state));
-		};
+		for (const key of Reflect.ownKeys(resolvers)) resolve[key] = (snapshot, state) => resolvers[key](parseInputs(set, id, snapshot), snapshot, state);
 		result.resolve = resolve;
 	}
+	const title = config.title;
+	if (typeof title === "function") result.title = (snapshot, state) => title(parseInputs(set, id, snapshot), snapshot, state);
+	else if (title !== void 0) result.title = title;
 	return result;
 }
+function isPromiseResult(value) {
+	return !!value && typeof value.then === "function";
+}
+function invalidParamsResult(decision) {
+	if (decision === false || decision instanceof UrlTree || decision instanceof RedirectCommand) return decision;
+	throw new TypeError("onInvalidParams must return false, a UrlTree or a RedirectCommand");
+}
 function redirect(definition) {
-	return async (snapshot) => {
+	return (snapshot) => {
 		const router = inject(Router);
 		const source = routeMetadata(definition());
 		const config = source.config.redirect;
@@ -217,39 +233,24 @@ function redirect(definition) {
 			const input = raw.get(key);
 			const raws = input?.values ?? [];
 			const array = input?.array ?? false;
-			validateRaw("path", key, raws, array);
+			validateRaw(key, raws, array);
 			jobs.push({
-				source: "path",
 				key,
 				raws,
 				array,
 				codec: source.params[key]
 			});
 		}
-		if (config.search.mode === "preserve") for (const key of Object.keys(target.search)) {
-			const codec = target.search[key];
-			const raws = snapshot.queryParamMap.getAll(key);
-			if (raws.length === 0 && codecPresence(codec) === "optional") continue;
-			validateRaw("search", key, raws, false);
-			jobs.push({
-				source: "search",
-				key,
-				raws,
-				array: false,
-				codec
-			});
-		}
-		const logical = await runJobs(jobs);
+		const logical = runPathJobs(jobs);
 		const params = Object.create(null);
-		for (const [key, sourceKey] of Object.entries(config.params)) params[key] = logical.params[sourceKey];
+		for (const [key, sourceKey] of Object.entries(config.params)) params[key] = logical[sourceKey];
 		const path = createUrlForPath(config.to, params);
 		const replacement = Object.create(null);
 		if (config.search.mode === "replace") {
 			const values = config.search.values;
 			for (const key of Object.keys(target.search).sort()) {
-				const codec = target.search[key];
-				if (codecPresence(codec) === "optional" && (!Object.hasOwn(values, key) || values[key] === void 0)) continue;
-				const raw = codec.stringify(values[key]);
+				if (!Object.hasOwn(values, key) || values[key] === void 0) continue;
+				const raw = target.search[key].stringify(values[key]);
 				if (typeof raw !== "string") throw new TypeError(`Redirect search codec must stringify to a string: ${key}`);
 				replacement[key] = raw;
 			}
@@ -288,190 +289,23 @@ function createUrlForPath(definition, params) {
 function observeRoute(set, id) {
 	const activated = inject(ActivatedRoute);
 	const router = inject(Router);
-	const destroy = inject(DestroyRef);
-	const tasks = inject(PendingTasks);
 	assertIdentity(activated.snapshot, id);
-	const paired = signal({
-		status: "loading",
-		value: void 0
-	}, ...ngDevMode ? [{ debugName: "paired" }] : /* istanbul ignore next */ []);
-	const data = signal({
-		status: "loading",
-		value: void 0
-	}, ...ngDevMode ? [{ debugName: "data" }] : /* istanbul ignore next */ []);
-	let survivor;
-	let work;
-	let commitment = -1;
-	let pending;
-	let visible = false;
-	let destroyed = false;
-	let release;
-	let acquiring = false;
-	function track() {
-		if (release || destroyed || acquiring) return;
-		acquiring = true;
-		const cleanup = tasks.add();
-		acquiring = false;
-		if (destroyed) {
-			cleanup();
-			return;
-		}
-		release = cleanup;
-	}
-	function untrack() {
-		const cleanup = release;
-		release = void 0;
-		cleanup?.();
-	}
-	function publish() {
-		if (!visible || destroyed || !work) return;
-		if (!work.outcome) {
-			paired.set({
-				status: "loading",
-				value: void 0
-			});
-			track();
-			return;
-		}
-		if ("value" in work.outcome) paired.set({
-			status: "resolved",
-			value: work.outcome.value
-		});
-		else paired.set({
-			status: "error",
-			error: work.outcome.error
-		});
-		untrack();
-	}
-	function adopt(snapshot) {
-		assertIdentity(snapshot, id);
-		if (snapshot === survivor) return;
-		survivor = snapshot;
-		const joined = fullOperation(set, id, snapshot);
-		work = joined;
-		if (!joined.outcome) track();
-		joined.promise.then(() => {
-			if (work === joined) publish();
-		}, () => {
-			if (work === joined) publish();
-		});
-	}
-	function reconcile() {
-		const successful = router.lastSuccessfulNavigation();
-		if (successful && successful.id > commitment) {
-			commitment = successful.id;
-			adopt(activated.snapshot);
-		}
-	}
-	function restore() {
-		if (destroyed) return;
-		reconcile();
-		if (!survivor) adopt(activated.snapshot);
-		const local = Object.create(null);
-		const resolvers = routeMetadata(set.records[id].definition()).config.resolve ?? {};
-		for (const key of Reflect.ownKeys(resolvers)) if (Object.hasOwn(survivor.data, key)) local[key] = survivor.data[key];
-		data.set({
-			status: "resolved",
-			value: Object.freeze(local)
-		});
-		visible = true;
-		publish();
-	}
-	function idleHandoff() {
-		queueMicrotask(() => {
-			if (destroyed || visible) return;
-			const current = router.currentNavigation();
-			const successful = router.lastSuccessfulNavigation();
-			if (!current || current.id === successful?.id) {
-				pending = void 0;
-				restore();
-			}
-		});
-	}
-	function eligible(id) {
-		const current = router.currentNavigation();
-		const successful = router.lastSuccessfulNavigation();
-		if (current && current.id > id && current.id !== successful?.id) return false;
-		return pending === void 0 || pending === id;
-	}
-	const subscription = router.events.subscribe((event) => {
-		if (destroyed) return;
-		if (event instanceof NavigationStart) {
-			pending = event.id;
-			visible = false;
-			reconcile();
-			paired.set({
-				status: "loading",
-				value: void 0
-			});
-			data.set({
-				status: "loading",
-				value: void 0
-			});
-		} else if (event instanceof NavigationEnd) {
-			reconcile();
-			if (eligible(event.id)) {
-				pending = void 0;
-				restore();
-			}
-		} else if (event instanceof NavigationCancel) {
-			reconcile();
-			if (event.code === NavigationCancellationCode.Redirect || event.code === NavigationCancellationCode.SupersededByNewNavigation) return;
-			if (eligible(event.id)) {
-				pending = void 0;
-				restore();
-			}
-		} else if (event instanceof NavigationSkipped) {
-			reconcile();
-			if (eligible(event.id)) {
-				pending = void 0;
-				restore();
-			}
-		} else if (event instanceof NavigationError && eligible(event.id)) {
-			reconcile();
-			pending = void 0;
-			visible = false;
-			let error = event.error;
-			if (!(error instanceof Error)) error = new Error("Navigation failure", { cause: event.error });
-			paired.set({
-				status: "error",
-				error
-			});
-			data.set({
-				status: "error",
-				error
-			});
-			untrack();
-		}
-	});
-	destroy.onDestroy(() => {
-		destroyed = true;
-		visible = false;
-		subscription.unsubscribe();
-		untrack();
+	const snapshot = signal(activated.snapshot, ...ngDevMode ? [{ debugName: "snapshot" }] : /* istanbul ignore next */ []);
+	const subscription = merge(activated.queryParams, activated.fragment, activated.params, activated.url, activated.data, router.events).subscribe(() => {
+		snapshot.set(activated.snapshot);
 	});
-	track();
-	if (!destroyed) {
-		const current = router.currentNavigation();
-		const successful = router.lastSuccessfulNavigation();
-		if (!current || current.id === successful?.id) restore();
-		else {
-			pending = current.id;
-			idleHandoff();
-		}
-	}
-	function project(key) {
-		const state = paired();
-		if (state.status === "error") return state;
-		return {
-			status: state.status,
-			value: state.value?.[key]
-		};
-	}
+	inject(DestroyRef).onDestroy(() => subscription.unsubscribe());
+	const inputs = computed(() => parseInputs(set, id, snapshot()), ...ngDevMode ? [{ debugName: "inputs" }] : /* istanbul ignore next */ []);
+	const resolvers = routeMetadata(set.records[id].definition()).config.resolve ?? {};
 	return {
-		params: resourceFromSnapshots(() => project("params")),
-		search: resourceFromSnapshots(() => project("search")),
-		data: resourceFromSnapshots(() => data())
+		params: computed(() => inputs().params),
+		search: computed(() => inputs().search),
+		data: computed(() => {
+			const data = snapshot().data;
+			const own = Object.create(null);
+			for (const key of Reflect.ownKeys(resolvers)) if (Object.hasOwn(data, key)) own[key] = data[key];
+			return Object.freeze(own);
+		})
 	};
 }
 const destinations = /* @__PURE__ */ new WeakMap();
@@ -488,7 +322,6 @@ function nativeOptions(definition) {
 	const options = {};
 	for (const key of [
 		"providers",
-		"title",
 		"data",
 		"canDeactivate",
 		"runGuardsAndResolvers"