@loozo/angular-router 0.0.2 → 0.0.4

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

@@ -1,658 +1,366 @@
-import { inject, Injector, runInInjectionContext, DestroyRef, PendingTasks, signal, resourceFromSnapshots } from '@angular/core';
-import { Router, ActivatedRoute, NavigationStart, NavigationEnd, NavigationCancel, NavigationCancellationCode, NavigationSkipped, NavigationError } from '@angular/router';
-import { Observable, isObservable, from } from 'rxjs';
-import { routeMetadata, codecPresence, createUrl } 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);
+	const data = snapshot.routeConfig?.data;
+	return !!data && Object.hasOwn(data, "__loozoAngularRouterRouteId") && data.__loozoAngularRouterRouteId === id;
 }
 function assertIdentity(snapshot, id) {
-    if (!hasIdentity(snapshot, id)) {
-        throw new Error(`Generated route wiring identity mismatch: ${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", 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);
-    const local = new Map();
-    for (let index = 0; index < metadata.localSegments.length; index += 1) {
-        const segment = metadata.localSegments[index];
-        if (segment.kind === "static") {
-            continue;
-        }
-        let raws = [];
-        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);
-        // Repeated local scalars intentionally use Angular's last positional occurrence.
-        local.set(segment.name, {
-            source: "path",
-            key: segment.name,
-            raws,
-            array,
-            codec: metadata.localParams[segment.name],
-        });
-    }
-    return [...local.values()];
-}
-function searchJobs(definition, snapshot) {
-    const metadata = routeMetadata(definition);
-    const jobs = [];
-    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;
+	const metadata = routeMetadata(definition);
+	const local = /* @__PURE__ */ new Map();
+	for (let index = 0; index < metadata.localSegments.length; index += 1) {
+		const segment = metadata.localSegments[index];
+		if (segment.kind === "static") continue;
+		let raws = [];
+		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(segment.name, raws, array);
+		local.set(segment.name, {
+			key: segment.name,
+			raws,
+			array,
+			codec: metadata.localParams[segment.name]
+		});
+	}
+	return [...local.values()];
 }
-async function runJobs(jobs) {
-    const params = Object.create(null);
-    const search = Object.create(null);
-    const pending = [];
-    for (const job of jobs) {
-        // Async boundaries convert every synchronous throw into an observed rejection.
-        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);
-            }
-        })());
-    }
-    await Promise.all(pending);
-    return Object.freeze({ params: Object.freeze(params), search: Object.freeze(search) });
+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);
 }
-const full = new WeakMap();
-const matching = new WeakMap();
-function operation(cache, definition, snapshot, collect) {
-    let snapshots = cache.get(definition);
-    if (!snapshots) {
-        snapshots = new WeakMap();
-        cache.set(definition, snapshots);
-    }
-    const existing = snapshots.get(snapshot);
-    if (existing) {
-        return existing;
-    }
-    // Insert before application code can run; even synchronous reentry joins the same operation.
-    const result = {
-        promise: Promise.resolve().then(() => runJobs(collect())),
-        outcome: undefined,
-    };
-    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;
+function parseSearch(definition, snapshot) {
+	const metadata = routeMetadata(definition);
+	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 === 1 && typeof raws[0] === "string") {
+			const result = parse(codec, raws[0]);
+			if ("value" in result) {
+				search[key] = result.value;
+				continue;
+			}
+		}
+		const fallback = codecFallback(codec);
+		if (fallback) search[key] = fallback.value;
+	}
+	return Object.freeze(search);
 }
-function fullOperation(set, id, snapshot) {
-    assertIdentity(snapshot, id);
-    const binding = set.records[id];
-    return operation(full, binding.definition(), snapshot, () => {
-        const jobs = [];
-        for (const ownerId of binding.owners) {
-            const definition = set.records[ownerId].definition();
-            // Pathless/static owners contribute no positional input. Effective search belongs
-            // to this complete future record; inherited data is never positional authority.
-            if (!routeMetadata(definition).localSegments.some((segment) => segment.kind !== "static")) {
-                continue;
-            }
-            const owner = [...snapshot.pathFromRoot]
-                .reverse()
-                .find((record) => hasIdentity(record, ownerId));
-            if (!owner) {
-                throw new Error(`Generated route ancestor missing: ${ownerId}`);
-            }
-            assertIdentity(owner, ownerId);
-            jobs.push(...pathJobs(definition, owner.url));
-        }
-        jobs.push(...searchJobs(binding.definition(), snapshot));
-        return jobs;
-    });
+const full = /* @__PURE__ */ new WeakMap();
+const paths = /* @__PURE__ */ new WeakMap();
+const matching = /* @__PURE__ */ new WeakMap();
+function memo(cache, definition, snapshot, run) {
+	let snapshots = cache.get(definition);
+	if (!snapshots) {
+		snapshots = /* @__PURE__ */ new WeakMap();
+		cache.set(definition, snapshots);
+	}
+	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 parseInputs(set, id, snapshot) {
-    return fullOperation(set, id, snapshot).promise;
+	assertIdentity(snapshot, id);
+	const binding = set.records[id];
+	return memo(full, binding.definition(), snapshot, () => {
+		const jobs = [];
+		for (const ownerId of binding.owners) {
+			const definition = set.records[ownerId].definition();
+			if (!routeMetadata(definition).localSegments.some((segment) => segment.kind !== "static")) continue;
+			const owner = [...snapshot.pathFromRoot].reverse().find((record) => hasIdentity(record, ownerId));
+			if (!owner) throw new Error(`Generated route ancestor missing: ${ownerId}`);
+			assertIdentity(owner, ownerId);
+			jobs.push(...pathJobs(definition, owner.url));
+		}
+		const params = runPathJobs(jobs);
+		return Object.freeze({
+			params,
+			search: parseSearch(binding.definition(), snapshot)
+		});
+	});
+}
+function pathInputs(set, id, snapshot) {
+	assertIdentity(snapshot, id);
+	const definition = set.records[id].definition();
+	try {
+		return { params: memo(paths, definition, snapshot, () => runPathJobs(pathJobs(definition, snapshot.url))) };
+	} catch (error) {
+		if (error instanceof InputError) return { error };
+		throw error;
+	}
 }
 function matchingInputs(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;
+	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 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) => callback(parseInputs(set, id, snapshot), snapshot, state));
+	const children = config.canActivateChild;
+	if (children) result.canActivateChild = children.map((callback) => (child, state) => {
+		let parent;
+		for (let index = child.pathFromRoot.length - 2; index >= 0; index -= 1) {
+			const ancestor = child.pathFromRoot[index];
+			if (hasIdentity(ancestor, id)) {
+				parent = ancestor;
+				break;
+			}
+		}
+		if (!parent) throw new Error(`Generated guard ancestor missing: ${id}`);
+		return callback(parseInputs(set, id, parent), child, state);
+	});
+	const matching = config.canMatch;
+	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) => 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";
+	return !!value && typeof value.then === "function";
 }
-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 callbacks(set, id) {
-    const config = routeMetadata(set.records[id].definition()).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));
-        });
-    }
-    const children = config.canActivateChild;
-    if (children) {
-        result.canActivateChild = children.map((callback) => (child, state) => {
-            let parent;
-            // The native ancestry includes child itself; only proper ancestors can declare this guard.
-            for (let index = child.pathFromRoot.length - 2; index >= 0; index -= 1) {
-                const ancestor = child.pathFromRoot[index];
-                if (hasIdentity(ancestor, id)) {
-                    parent = ancestor;
-                    break;
-                }
-            }
-            if (!parent) {
-                throw new Error(`Generated guard ancestor missing: ${id}`);
-            }
-            assertIdentity(parent, id);
-            return bridge(() => parseInputs(set, id, parent), (inputs) => callback(inputs, 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 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));
-            };
-        }
-        result.resolve = resolve;
-    }
-    return result;
+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) => {
-        const router = inject(Router);
-        const source = routeMetadata(definition());
-        const config = source.config.redirect;
-        const target = routeMetadata(config.to);
-        const raw = new Map();
-        for (let index = 0; index < source.segments.length; index += 1) {
-            const segment = source.segments[index];
-            if (segment.kind === "scalar") {
-                raw.set(segment.name, {
-                    values: snapshot.url.slice(index, index + 1).map((value) => value.path),
-                    array: false,
-                });
-            }
-            else if (segment.kind === "catchall") {
-                raw.set(segment.name, {
-                    values: snapshot.url.slice(index).map((value) => value.path),
-                    array: true,
-                });
-            }
-        }
-        const jobs = [];
-        for (const key of new Set(Object.values(config.params))) {
-            const input = raw.get(key);
-            const raws = input?.values ?? [];
-            const array = input?.array ?? false;
-            validateRaw("path", 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 });
-            }
-        }
-        // Every demand is prechecked. Async wrappers observe even synchronous preserved-search
-        // throws after earlier source jobs launch, without detaching those later rejections.
-        const logical = await runJobs(jobs);
-        const params = Object.create(null);
-        for (const [key, sourceKey] of Object.entries(config.params)) {
-            params[key] = logical.params[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] === undefined)) {
-                    continue;
-                }
-                const raw = codec.stringify(values[key]);
-                if (typeof raw !== "string") {
-                    throw new TypeError(`Redirect search codec must stringify to a string: ${key}`);
-                }
-                replacement[key] = raw;
-            }
-        }
-        // No native conversion before demanded codecs and destination stringification succeed.
-        const tree = router.parseUrl(path);
-        if (config.search.mode === "preserve") {
-            tree.queryParams = { ...snapshot.queryParams };
-        }
-        else if (config.search.mode === "replace") {
-            tree.queryParams = replacement;
-        }
-        if (config.fragment.mode === "preserve") {
-            tree.fragment = snapshot.fragment;
-        }
-        else if (config.fragment.mode === "replace") {
-            tree.fragment = config.fragment.value;
-        }
-        return tree;
-    };
+	return (snapshot) => {
+		const router = inject(Router);
+		const source = routeMetadata(definition());
+		const config = source.config.redirect;
+		const target = routeMetadata(config.to);
+		const raw = /* @__PURE__ */ new Map();
+		for (let index = 0; index < source.segments.length; index += 1) {
+			const segment = source.segments[index];
+			if (segment.kind === "scalar") raw.set(segment.name, {
+				values: snapshot.url.slice(index, index + 1).map((value) => value.path),
+				array: false
+			});
+			else if (segment.kind === "catchall") raw.set(segment.name, {
+				values: snapshot.url.slice(index).map((value) => value.path),
+				array: true
+			});
+		}
+		const jobs = [];
+		for (const key of new Set(Object.values(config.params))) {
+			const input = raw.get(key);
+			const raws = input?.values ?? [];
+			const array = input?.array ?? false;
+			validateRaw(key, raws, array);
+			jobs.push({
+				key,
+				raws,
+				array,
+				codec: source.params[key]
+			});
+		}
+		const logical = runPathJobs(jobs);
+		const params = Object.create(null);
+		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()) {
+				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;
+			}
+		}
+		const tree = router.parseUrl(path);
+		if (config.search.mode === "preserve") tree.queryParams = { ...snapshot.queryParams };
+		else if (config.search.mode === "replace") tree.queryParams = replacement;
+		if (config.fragment.mode === "preserve") tree.fragment = snapshot.fragment;
+		else if (config.fragment.mode === "replace") tree.fragment = config.fragment.value;
+		return tree;
+	};
 }
 function createUrlForPath(definition, params) {
-    const metadata = routeMetadata(definition);
-    const parts = [];
-    function encode(raw) {
-        if (raw === "" || raw === "." || raw === "..") {
-            throw new TypeError("Invalid redirect path value");
-        }
-        return encodeURIComponent(raw).replace(/\(/g, "%28").replace(/\)/g, "%29");
-    }
-    for (const segment of metadata.segments) {
-        if (segment.kind === "static") {
-            parts.push(encode(segment.text));
-        }
-        else if (segment.kind === "scalar") {
-            const raw = metadata.params[segment.name].stringify(params[segment.name]);
-            if (typeof raw !== "string") {
-                throw new TypeError("Redirect codec must stringify to a string");
-            }
-            parts.push(encode(raw));
-        }
-        else {
-            const values = params[segment.name];
-            if (!Array.isArray(values)) {
-                throw new TypeError("Redirect catchall requires an array");
-            }
-            for (const value of values) {
-                const raw = metadata.params[segment.name].stringify(value);
-                if (typeof raw !== "string") {
-                    throw new TypeError("Redirect codec must stringify to a string");
-                }
-                parts.push(encode(raw));
-            }
-        }
-    }
-    return `/${parts.join("/")}`;
+	const metadata = routeMetadata(definition);
+	const parts = [];
+	function encode(raw) {
+		if (raw === "" || raw === "." || raw === "..") throw new TypeError("Invalid redirect path value");
+		return encodeURIComponent(raw).replace(/\(/g, "%28").replace(/\)/g, "%29");
+	}
+	for (const segment of metadata.segments) if (segment.kind === "static") parts.push(encode(segment.text));
+	else if (segment.kind === "scalar") {
+		const raw = metadata.params[segment.name].stringify(params[segment.name]);
+		if (typeof raw !== "string") throw new TypeError("Redirect codec must stringify to a string");
+		parts.push(encode(raw));
+	} else {
+		const values = params[segment.name];
+		if (!Array.isArray(values)) throw new TypeError("Redirect catchall requires an array");
+		for (const value of values) {
+			const raw = metadata.params[segment.name].stringify(value);
+			if (typeof raw !== "string") throw new TypeError("Redirect codec must stringify to a string");
+			parts.push(encode(raw));
+		}
+	}
+	return `/${parts.join("/")}`;
 }
-
-// Shared parsing has no view/task lifetime. Each handle owns its visibility and relevance.
 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: undefined,
-    }, /* @ts-ignore */
-    ...(ngDevMode ? [{ debugName: "paired" }] : /* istanbul ignore next */ []));
-    const data = signal({
-        status: "loading",
-        value: undefined,
-    }, /* @ts-ignore */
-    ...(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;
-        }
-        // Native add synchronously notifies stability observers before returning ownership.
-        acquiring = true;
-        const cleanup = tasks.add();
-        acquiring = false;
-        if (destroyed) {
-            cleanup();
-            return;
-        }
-        release = cleanup;
-    }
-    function untrack() {
-        const cleanup = release;
-        release = undefined;
-        cleanup?.();
-    }
-    function publish() {
-        if (!visible || destroyed || !work) {
-            return;
-        }
-        if (!work.outcome) {
-            paired.set({ status: "loading", value: undefined });
-            track();
-            return;
-        }
-        if ("value" in work.outcome) {
-            paired.set({ status: "resolved", value: work.outcome.value });
-        }
-        else {
-            paired.set({ status: "error", error: work.outcome.error });
-        }
-        // A synchronous paired write always precedes package task removal.
-        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 = undefined;
-                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 === undefined || pending === id;
-    }
-    // Subscribe before reading native phase: constructors can run inside event delivery.
-    const subscription = router.events.subscribe((event) => {
-        if (destroyed) {
-            return;
-        }
-        if (event instanceof NavigationStart) {
-            pending = event.id;
-            visible = false;
-            reconcile();
-            paired.set({ status: "loading", value: undefined });
-            data.set({ status: "loading", value: undefined });
-        }
-        else if (event instanceof NavigationEnd) {
-            // Even an old End may expose a newer true survivor; it cannot settle a newer Start.
-            reconcile();
-            if (eligible(event.id)) {
-                pending = undefined;
-                restore();
-            }
-        }
-        else if (event instanceof NavigationCancel) {
-            reconcile();
-            if (event.code === NavigationCancellationCode.Redirect ||
-                event.code === NavigationCancellationCode.SupersededByNewNavigation) {
-                return;
-            }
-            if (eligible(event.id)) {
-                pending = undefined;
-                restore();
-            }
-        }
-        else if (event instanceof NavigationSkipped) {
-            reconcile();
-            if (eligible(event.id)) {
-                pending = undefined;
-                restore();
-            }
-        }
-        else if (event instanceof NavigationError && eligible(event.id)) {
-            reconcile();
-            pending = undefined;
-            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();
-    });
-    // Synchronous task handoff prevents whenStable resolving before a missed-terminal microtask.
-    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] };
-    }
-    return {
-        params: resourceFromSnapshots(() => project("params")),
-        search: resourceFromSnapshots(() => project("search")),
-        data: resourceFromSnapshots(() => data()),
-    };
+	const activated = inject(ActivatedRoute);
+	const router = inject(Router);
+	assertIdentity(activated.snapshot, id);
+	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);
+	});
+	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: 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 = new WeakMap();
+const destinations = /* @__PURE__ */ new WeakMap();
 function createDestination(getSet, id) {
-    const destination = Object.freeze({});
-    destinations.set(destination, { getSet, id });
-    return destination;
+	const destination = Object.freeze({});
+	destinations.set(destination, {
+		getSet,
+		id
+	});
+	return destination;
 }
 function nativeOptions(definition) {
-    const config = routeMetadata(definition).config;
-    const options = {};
-    for (const key of ["providers", "title", "data", "canDeactivate", "runGuardsAndResolvers"]) {
-        if (Object.hasOwn(config, key)) {
-            options[key] = config[key];
-        }
-    }
-    return options;
+	const config = routeMetadata(definition).config;
+	const options = {};
+	for (const key of [
+		"providers",
+		"data",
+		"canDeactivate",
+		"runGuardsAndResolvers"
+	]) if (Object.hasOwn(config, key)) options[key] = config[key];
+	return options;
 }
 function injectGeneratedRoute(set, id) {
-    const router = inject(Router);
-    const view = observeRoute(set, id);
-    function url(args) {
-        if (args.length !== 1 && args.length !== 2) {
-            throw new TypeError("Expected values or a selected destination and values");
-        }
-        let target = id;
-        let values = args[0];
-        if (args.length === 2) {
-            const selector = args[0];
-            values = args[1];
-            if (typeof selector === "string") {
-                if (selector !== ".") {
-                    if (Object.hasOwn(set.absolute, selector)) {
-                        target = set.absolute[selector];
-                    }
-                    else if (Object.hasOwn(set.relative[id], selector)) {
-                        target = set.relative[id][selector];
-                    }
-                    else {
-                        throw new TypeError(`Unknown generated selector: ${selector}`);
-                    }
-                }
-            }
-            else {
-                if (typeof selector !== "object" || selector === null) {
-                    throw new TypeError("Expected a literal selector or genuine generated destination");
-                }
-                const destination = destinations.get(selector);
-                if (!destination ||
-                    destination.getSet() !== set ||
-                    !Object.hasOwn(set.records, destination.id)) {
-                    throw new TypeError("Expected a destination from the same generated set");
-                }
-                target = destination.id;
-            }
-        }
-        return createUrl(set.destinations[target](), values);
-    }
-    return {
-        params: view.params,
-        search: view.search,
-        data: view.data,
-        link: ((...args) => router.parseUrl(url(args))),
-        navigate: ((...args) => router.navigateByUrl(url(args))),
-    };
+	const router = inject(Router);
+	const view = observeRoute(set, id);
+	function url(args) {
+		if (args.length !== 1 && args.length !== 2) throw new TypeError("Expected values or a selected destination and values");
+		let target = id;
+		let values = args[0];
+		if (args.length === 2) {
+			const selector = args[0];
+			values = args[1];
+			if (typeof selector === "string") {
+				if (selector !== ".") {
+					if (Object.hasOwn(set.absolute, selector)) target = set.absolute[selector];
+					else if (Object.hasOwn(set.relative[id], selector)) target = set.relative[id][selector];
+					else throw new TypeError(`Unknown generated selector: ${selector}`);
+				}
+			} else {
+				if (typeof selector !== "object" || selector === null) throw new TypeError("Expected a literal selector or genuine generated destination");
+				const destination = destinations.get(selector);
+				if (!destination || destination.getSet() !== set || !Object.hasOwn(set.records, destination.id)) throw new TypeError("Expected a destination from the same generated set");
+				target = destination.id;
+			}
+		}
+		return createUrl(set.destinations[target](), values);
+	}
+	return {
+		params: view.params,
+		search: view.search,
+		data: view.data,
+		link: ((...args) => router.parseUrl(url(args))),
+		navigate: ((...args) => router.navigateByUrl(url(args)))
+	};
 }
-
-/**
- * Generated bundle index. Do not edit.
- */
-
 export { assertIdentity, callbacks, createDestination, injectGeneratedRoute, nativeOptions, parseInputs, redirect };
-//# sourceMappingURL=loozo-angular-router-_generated.mjs.map
+
+//# sourceMappingURL=loozo-angular-router-_generated.mjs.map