@loozo/angular-router 0.0.0-stage → 0.0.1

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

@@ -0,0 +1,658 @@
+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';
+
+function hasIdentity(snapshot, 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}`);
+    }
+}
+function inputError(source, key, reason, cause) {
+    return Object.assign(new Error(`Invalid ${source} input ${key}: ${reason}`, { cause }), {
+        source,
+        key,
+        reason,
+    });
+}
+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 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;
+}
+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) });
+}
+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 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;
+    });
+}
+function parseInputs(set, id, snapshot) {
+    return fullOperation(set, id, snapshot).promise;
+}
+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;
+}
+
+function isPromiseResult(value) {
+    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 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;
+    };
+}
+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("/")}`;
+}
+
+// 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 destinations = new WeakMap();
+function createDestination(getSet, id) {
+    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;
+}
+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))),
+    };
+}
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { assertIdentity, callbacks, createDestination, injectGeneratedRoute, nativeOptions, parseInputs, redirect };
+//# sourceMappingURL=loozo-angular-router-_generated.mjs.map