@craft-ts/core 0.7.0-beta.13

package/src/lib/craft-router-outlet.js

@@ -0,0 +1,735 @@
+import { DestroyRef, EnvironmentInjector, inject, Injector, InjectionToken, runInInjectionContext, } from './host/craft-compat';
+import { DOCUMENT } from './host/craft-compat';
+import { CRAFT_A11Y_NAVIGATION_FOCUS } from './craft-a11y';
+import { isCraftException } from './craft-exception';
+import { evaluateCraftGuardSync, runCraftRouteChainAsync, } from './craft-guard-runtime';
+import { CRAFT_BLANK_MS, CRAFT_ERROR_COMPONENT, CRAFT_PENDING_COMPONENT, CRAFT_PENDING_MIN_MS, CRAFT_STAY_MS, } from './craft-pending';
+import { CRAFT_GLOBAL_ERROR, } from './craft-route-exceptions';
+import { createRouteLoadError, isCraftRouteLoadError, setActiveCraftRouteLoadError, } from './craft-route-load-error';
+import { getCraftRouteMeta, } from './craft-route-meta';
+import { CRAFT_START_VIEW_TRANSITION, CRAFT_VIEW_TRANSITION, CRAFT_VIEW_TRANSITION_SKIP_BLANK, CRAFT_VIEW_TRANSITION_STATE_KEY, CRAFT_VIEW_TRANSITIONS_ENABLED, } from './craft-view-transition';
+import { CRAFT_TEMPORAL_RUNTIME, } from './temporal-runtime';
+import { craftRouteTarget, CRAFT_ROUTE_TARGET, isCraftRouteTarget, normalizeCraftRouteTarget, } from './craft-route-target';
+import { craftSignal, craftWatch, } from './host/craft-signal';
+import { serializeLocation, sliceCraftMatchForOutlet, } from './host/craft-router-runtime';
+import { CRAFT_CHILD_MATCH, CRAFT_HISTORY, CRAFT_MATCH, CRAFT_ROUTER, } from './craft-router-tokens';
+import { CRAFT_SSR_RUNTIME } from './craft-ssr';
+import { CRAFT_PLATFORM } from './craft-platform';
+const ROUTE_PROP_SKIP = new Set(['craftComponent', 'craftPendingComponent']);
+export function collectMatchProps(match) {
+    if (!match) {
+        return {};
+    }
+    const props = {};
+    for (const route of match.routes) {
+        assignRoutePropBag(props, route.data);
+    }
+    assignRoutePropBag(props, match.params);
+    assignRoutePropBag(props, match.queryParams);
+    return props;
+}
+/** @deprecated Use {@link collectMatchProps}. */
+export const collectActivatedRouteProps = collectMatchProps;
+function assignRoutePropBag(target, bag) {
+    if (!bag) {
+        return;
+    }
+    for (const [key, value] of Object.entries(bag)) {
+        if (ROUTE_PROP_SKIP.has(key) || typeof value === 'function') {
+            continue;
+        }
+        target[key] = value;
+    }
+}
+export const CRAFT_ROUTE_CHAIN_RUNNER = new InjectionToken('CRAFT_ROUTE_CHAIN_RUNNER', {
+    providedIn: 'root',
+    factory: () => runCraftRouteChainAsync,
+});
+const syncTemplateFlushers = new Set();
+/** Registers a synchronous template patch invoked from view-transition commits. */
+export function registerCraftSyncTemplateFlush(fn) {
+    syncTemplateFlushers.add(fn);
+    return () => {
+        syncTemplateFlushers.delete(fn);
+    };
+}
+function runRegisteredSyncTemplateFlush() {
+    for (const flush of syncTemplateFlushers) {
+        flush();
+    }
+}
+/**
+ * Runs inside `startViewTransition`'s callback after Craft signals commit, so
+ * the displayed DOM is patched before the callback returns. Templates driven by
+ * `craftEffect` otherwise bump an Angular signal asynchronously.
+ */
+export const CRAFT_SYNC_TEMPLATE_FLUSH = new InjectionToken('CRAFT_SYNC_TEMPLATE_FLUSH', {
+    providedIn: 'root',
+    factory: () => runRegisteredSyncTemplateFlush,
+});
+/**
+ * A non-blocking replacement for `<router-outlet>`. The URL commits immediately
+ * (history.push); this outlet reads the route's {@link CraftRouteMeta} and
+ * drives canMatch → canActivate → resolve **after** commit.
+ */
+export class CraftRouterOutletController {
+    name = 'primary';
+    rootInjector = inject(EnvironmentInjector);
+    router = inject(CRAFT_ROUTER, { optional: true }) ?? silentRouter();
+    history = inject(CRAFT_HISTORY, { optional: true });
+    destroyRef = inject(DestroyRef);
+    temporalRuntime = inject(CRAFT_TEMPORAL_RUNTIME);
+    defaultPendingComponent = inject(CRAFT_PENDING_COMPONENT);
+    defaultErrorComponent = inject(CRAFT_ERROR_COMPONENT);
+    defaultStayMs = inject(CRAFT_STAY_MS);
+    defaultBlankMs = inject(CRAFT_BLANK_MS);
+    defaultPendingMinMs = inject(CRAFT_PENDING_MIN_MS);
+    chainRunner = inject(CRAFT_ROUTE_CHAIN_RUNNER);
+    viewTransitionsEnabled = inject(CRAFT_VIEW_TRANSITIONS_ENABLED);
+    viewTransitionSkipBlank = inject(CRAFT_VIEW_TRANSITION_SKIP_BLANK);
+    startViewTransition = inject(CRAFT_START_VIEW_TRANSITION);
+    syncTemplateFlush = inject(CRAFT_SYNC_TEMPLATE_FLUSH);
+    viewTransitionSink = inject(CRAFT_VIEW_TRANSITION);
+    a11yNavigationFocus = inject(CRAFT_A11Y_NAVIGATION_FOCUS);
+    platform = inject(CRAFT_PLATFORM, { optional: true });
+    document = this.platform?.document ?? inject(DOCUMENT);
+    ssrRuntime = inject(CRAFT_SSR_RUNTIME, { optional: true });
+    a11yHasCompletedInitialActivation = false;
+    displayedComponent = craftSignal(null);
+    displayedTarget = craftSignal(null);
+    displayedInjector = craftSignal(undefined);
+    displayedProps = craftSignal({});
+    state = craftSignal('idle');
+    targetComponent = craftSignal(null);
+    pendingComponent = craftSignal(null);
+    errorComponent = craftSignal(null);
+    pendingTarget = craftSignal(null);
+    errorTarget = craftSignal(null);
+    _match = null;
+    _liveMatch = null;
+    _childMatch = null;
+    _activeRouteInjector = null;
+    _meta = null;
+    _navId = 0;
+    _stayTimer = null;
+    _blankTimer = null;
+    _pendingCommitTimer = null;
+    _pendingShownAt = 0;
+    _previousUrl = this.router.url;
+    _pendingDeactivation = false;
+    _reactiveWatch = null;
+    _matchWatch = null;
+    _frozen = false;
+    _displayVersion = 0;
+    get isActivated() {
+        return this._match !== null;
+    }
+    get component() {
+        if (!this._match) {
+            throw new Error('CraftRouterOutlet is not activated');
+        }
+        return (this.targetComponent() ?? {});
+    }
+    constructor() {
+        const matchSignal = inject(CRAFT_CHILD_MATCH, { optional: true }) ??
+            inject(CRAFT_MATCH, { optional: true });
+        if (matchSignal) {
+            this._matchWatch = craftWatch(() => {
+                const match = matchSignal();
+                if (match) {
+                    this.activateMatch(match, this.rootInjector);
+                }
+                else if (this._match) {
+                    this.deactivate();
+                }
+            });
+        }
+        this.destroyRef.onDestroy(() => this.destroy());
+    }
+    destroy() {
+        this._matchWatch?.destroy();
+        this._matchWatch = null;
+        this.teardown();
+    }
+    deactivate() {
+        this.teardown();
+        this._match = null;
+        this._liveMatch = null;
+        this._childMatch = null;
+        this._activeRouteInjector = null;
+        this._meta = null;
+        this._previousUrl = this.router.url;
+        this._pendingDeactivation = true;
+        queueMicrotask(() => {
+            if (this._pendingDeactivation) {
+                this._pendingDeactivation = false;
+                this.state.set('idle');
+                this.displayedComponent.set(null);
+                this.displayedTarget.set(null);
+                this.targetComponent.set(null);
+                this.errorComponent.set(null);
+            }
+        });
+    }
+    activateMatch(match, environmentInjector) {
+        this._pendingDeactivation = false;
+        const previousMatchUrl = this._match
+            ? serializeLocation(this._match)
+            : this._previousUrl;
+        const { activated, child } = sliceCraftMatchForOutlet(match);
+        if (this._match &&
+            this._liveMatch &&
+            this._childMatch &&
+            this._activeRouteInjector &&
+            this.state() !== 'error' &&
+            canReuseActivation(this._match, activated, this._meta)) {
+            this._liveMatch.set(activated);
+            this._childMatch.set(child);
+            this.displayedProps.set(collectMatchProps(activated));
+            this.publishViewTransitionPayload();
+            return;
+        }
+        this._previousUrl = previousMatchUrl;
+        this.teardown();
+        this._match = activated;
+        this._liveMatch = craftSignal(activated);
+        this._childMatch = craftSignal(child);
+        const routeProviders = activated.route.providers;
+        this._activeRouteInjector = Injector.create({
+            providers: [
+                { provide: CRAFT_MATCH, useValue: this._liveMatch },
+                { provide: CRAFT_CHILD_MATCH, useValue: this._childMatch },
+                ...(Array.isArray(routeProviders) ? routeProviders : []),
+            ],
+            parent: environmentInjector ?? this.rootInjector,
+            name: 'CraftRouterOutlet',
+        });
+        this.publishViewTransitionPayload();
+        const leafMeta = getCraftRouteMeta((activated.route.data ?? activated.data));
+        const meta = composeRouteMetas(collectAncestorGuardMetas(match, activated), leafMeta ?? null);
+        this._meta = meta ?? null;
+        this.clearExceptionSinks(meta);
+        const activation = this.finishActivation(activated, meta ?? null);
+        if (this.ssrRuntime) {
+            this.ssrRuntime.track(`route:${activated.route.path}`, activation);
+        }
+        else {
+            void activation;
+        }
+    }
+    async finishActivation(match, meta) {
+        if (!this.isCurrentActivation(match)) {
+            return;
+        }
+        if (typeof match.route.loadComponent === 'function' &&
+            !match.route.component) {
+            try {
+                const loaded = await runInInjectionContext(this._activeRouteInjector ?? this.rootInjector, () => Promise.resolve(match.route.loadComponent()));
+                if (!this.isCurrentActivation(match)) {
+                    return;
+                }
+                const component = loaded && typeof loaded === 'object' && 'default' in loaded
+                    ? loaded.default
+                    : loaded;
+                match.route.component = component;
+            }
+            catch (error) {
+                if (!this.isCurrentActivation(match)) {
+                    return;
+                }
+                const exception = isCraftRouteLoadError(error)
+                    ? error
+                    : createRouteLoadError({
+                        phase: 'component',
+                        routePath: match.route.path,
+                        targetUrl: this.router.url,
+                        cause: error,
+                        attempt: 1,
+                    });
+                setActiveCraftRouteLoadError(exception, this.rootInjector);
+                this.publishGlobalError(exception);
+                void this.showErrorComponent(this._meta?.errorComponent ?? this.defaultErrorComponent, exception);
+                return;
+            }
+        }
+        const component = this.resolveRouteComponent(match);
+        this.displayedProps.set(collectMatchProps(match));
+        if (!meta || (!meta.match && !meta.guard && !meta.resolve)) {
+            this.showComponent(component, this._activeRouteInjector, this.resolveRouteTarget(component));
+            this.targetComponent.set(component);
+            this.state.set('loaded');
+            return;
+        }
+        await this.runChain(meta, component, 'enter');
+    }
+    runChain(meta, component, phase) {
+        const navId = ++this._navId;
+        const injector = this._activeRouteInjector ?? this.rootInjector;
+        const routeSnapshot = matchToSnapshot(this._match);
+        const stateSnapshot = { url: this.router.url, root: routeSnapshot };
+        this.state.set('stay');
+        void this.resolvePendingComponent(meta);
+        const stayMs = meta.stayMs ?? this.defaultStayMs;
+        const skipBlank = this.shouldSkipBlank(meta);
+        const blankMs = skipBlank ? 0 : (meta.blankMs ?? this.defaultBlankMs);
+        if (!skipBlank) {
+            this._stayTimer = this.temporalRuntime.schedule(() => {
+                if (this._navId === navId && this.state() === 'stay') {
+                    this.state.set('blank');
+                    this.displayedComponent.set(null);
+                    this.displayedTarget.set(null);
+                }
+            }, stayMs, {
+                kind: 'router-stay',
+                owner: 'craft-router-outlet',
+                destroyRef: this.destroyRef,
+            });
+        }
+        this._blankTimer = this.temporalRuntime.schedule(() => {
+            if (this._navId === navId &&
+                (this.state() === 'stay' || this.state() === 'blank')) {
+                this._pendingShownAt = this.temporalRuntime.now();
+                this.state.set('pending');
+                this.showComponent(this.pendingComponent(), injector, this.pendingTarget());
+            }
+        }, stayMs + blankMs, {
+            kind: 'router-pending',
+            owner: 'craft-router-outlet',
+            destroyRef: this.destroyRef,
+        });
+        return this.chainRunner({
+            match: meta.match?.(routeSnapshot, stateSnapshot),
+            guard: meta.guard?.(routeSnapshot, stateSnapshot),
+            resolve: phase === 'enter'
+                ? meta.resolve?.(routeSnapshot, stateSnapshot)
+                : undefined,
+        }, injector, this.router, meta.handleExceptions, phase).then((outcome) => {
+            if (this._navId === navId) {
+                this.applyOutcome(outcome, meta, component, phase);
+            }
+        }, (error) => {
+            if (this._navId === navId) {
+                this.applyOutcome({ kind: 'thrownError', error }, meta, component, phase);
+            }
+        });
+    }
+    applyOutcome(outcome, meta, component, _phase) {
+        this.clearTimers();
+        switch (outcome.kind) {
+            case 'data':
+                meta.guardDataSink?.set(outcome.guardData);
+                meta.resolveDataSink?.set(outcome.resolveData);
+                this.showTarget(component, meta);
+                this.installReactiveGuard(meta, component);
+                return;
+            case 'noop':
+                this.showTarget(component, meta);
+                this.installReactiveGuard(meta, component);
+                return;
+            case 'redirect':
+                void this.router.navigateByUrl(String(outcome.target));
+                return;
+            case 'stay':
+                if (this._previousUrl !== this.router.url) {
+                    void this.router.navigateByUrl(this._previousUrl);
+                }
+                return;
+            case 'render':
+                meta.exceptionSinks[outcome.exception._tag]?.set(outcome.exception);
+                void this.showErrorComponent(outcome.component, outcome.exception);
+                return;
+            case 'global':
+                this.publishGlobalError(outcome.exception);
+                void this.showErrorComponent(meta.errorComponent ?? this.defaultErrorComponent, outcome.exception);
+                return;
+            case 'thrownError': {
+                const exception = isCraftException(outcome.error)
+                    ? outcome.error
+                    : null;
+                this.publishGlobalError(exception);
+                void this.showErrorComponent(meta.errorComponent ?? this.defaultErrorComponent, exception);
+                return;
+            }
+        }
+    }
+    showComponent(component, injector, target = component
+        ? craftRouteTarget(component)
+        : null) {
+        const activationId = this._navId;
+        const displayVersion = ++this._displayVersion;
+        const props = this.routeProps();
+        const commit = () => {
+            // The browser may invoke a View Transition callback after a newer
+            // activation or swap has already been requested. Such a callback must
+            // not resurrect its old component, and its props must belong to the
+            // component captured at request time rather than the current route.
+            if (this._navId !== activationId ||
+                this._displayVersion !== displayVersion) {
+                return;
+            }
+            this.displayedInjector.set(injector ?? undefined);
+            this.displayedProps.set(props);
+            // Publish the target last: CraftRouterOutlet mounts it as soon as the
+            // target becomes visible, so its route injector and inputs must already
+            // be available or the first render is created with the parent injector
+            // and immediately remounted when the injector signal catches up.
+            this.displayedTarget.set(target);
+            this.displayedComponent.set(component);
+            this.syncTemplateFlush();
+        };
+        if (!this.viewTransitionsEnabled) {
+            commit();
+            this.scheduleA11yNavigationFocus();
+            return;
+        }
+        this.startViewTransition(() => {
+            commit();
+        });
+        this.scheduleA11yNavigationFocus();
+    }
+    scheduleA11yNavigationFocus() {
+        if (!this.a11yNavigationFocus) {
+            return;
+        }
+        if (!this.a11yHasCompletedInitialActivation) {
+            this.a11yHasCompletedInitialActivation = true;
+            return;
+        }
+        queueMicrotask(() => {
+            const target = this.document.getElementById('main') ??
+                this.document.querySelector('main');
+            if (!target || target.nodeType !== 1) {
+                return;
+            }
+            const element = target;
+            if (!element.hasAttribute('tabindex')) {
+                element.tabIndex = -1;
+            }
+            element.focus();
+        });
+    }
+    showTarget(component, meta) {
+        const injector = this._activeRouteInjector ?? this.rootInjector;
+        const commit = () => {
+            this.showComponent(component, injector, this.resolveRouteTarget(component));
+            this.targetComponent.set(component);
+            this.state.set('loaded');
+        };
+        this.commitWithAntiFlicker(commit, meta);
+    }
+    async showErrorComponent(input, _exception) {
+        const resolved = await resolveComponentInput(input);
+        const target = resolved ? normalizeCraftRouteTarget(resolved) : null;
+        // Removing the Angular interop left this pinned at `null`, which silently
+        // emptied the error surface: nothing was reported through
+        // `errorComponent()` and nothing was mounted. The component IS the
+        // normalized target's — everything Craft renders is a Craft component.
+        const component = (target?.component ?? null);
+        this.errorComponent.set(component);
+        this.errorTarget.set(target);
+        this.showComponent(component, this._activeRouteInjector ?? this.rootInjector, target);
+        this.state.set('error');
+        this._frozen = true;
+    }
+    commitWithAntiFlicker(commit, meta) {
+        const minMs = meta.pendingMinMs ?? this.defaultPendingMinMs;
+        if (this.state() === 'pending' && minMs > 0) {
+            const elapsed = this.temporalRuntime.now() - this._pendingShownAt;
+            const remaining = minMs - elapsed;
+            if (remaining > 0) {
+                const navId = this._navId;
+                this._pendingCommitTimer = this.temporalRuntime.schedule(() => {
+                    if (this._navId === navId) {
+                        commit();
+                    }
+                }, remaining, {
+                    kind: 'router-anti-flicker',
+                    owner: 'craft-router-outlet',
+                    destroyRef: this.destroyRef,
+                });
+                return;
+            }
+        }
+        commit();
+    }
+    installReactiveGuard(meta, component) {
+        this._frozen = false;
+        if (meta.reactiveGuards === false || !meta.guard) {
+            return;
+        }
+        const injector = this._activeRouteInjector ?? this.rootInjector;
+        const guardFactory = meta.guard;
+        const routeSnapshot = matchToSnapshot(this._match);
+        const stateSnapshot = { url: this.router.url, root: routeSnapshot };
+        this._reactiveWatch = runInInjectionContext(injector, () => craftWatch(() => {
+            const result = evaluateCraftGuardSync(guardFactory(routeSnapshot, stateSnapshot), injector);
+            if (this._frozen || result.kind !== 'exception') {
+                return;
+            }
+            void this.handleReactiveException(result.exception, meta, component);
+        }));
+    }
+    async handleReactiveException(exception, meta, component) {
+        const outcome = await this.chainRunner({
+            guard: (function* () {
+                return exception;
+            })(),
+        }, this._activeRouteInjector ?? this.rootInjector, this.router, meta.handleExceptions, 'active');
+        this.applyOutcome(outcome, meta, component, 'active');
+    }
+    shouldSkipBlank(meta) {
+        return (this.viewTransitionsEnabled &&
+            (meta.withLoaderViewTransitionImage === true ||
+                this.viewTransitionSkipBlank));
+    }
+    publishViewTransitionPayload() {
+        const extras = this.router.getCurrentNavigation()?.extras;
+        const fromNavigation = extras?.state;
+        const craftState = this.history?.getState();
+        const windowState = typeof history !== 'undefined'
+            ? history.state
+            : undefined;
+        const source = this.history
+            ? craftState
+            : extras?.skipLocationChange
+                ? fromNavigation
+                : windowState;
+        const raw = source?.[CRAFT_VIEW_TRANSITION_STATE_KEY] ??
+            fromNavigation?.[CRAFT_VIEW_TRANSITION_STATE_KEY] ??
+            null;
+        this.viewTransitionSink.set(raw);
+    }
+    publishGlobalError(exception) {
+        const sink = this.rootInjector.get(CRAFT_GLOBAL_ERROR);
+        sink.set(exception);
+    }
+    async resolvePendingComponent(meta) {
+        const resolved = await resolvePendingComponentInput(meta.pendingComponent ?? this.defaultPendingComponent);
+        const target = resolved ? normalizeCraftRouteTarget(resolved) : null;
+        const component = null;
+        this.pendingComponent.set(component);
+        this.pendingTarget.set(target);
+    }
+    resolveRouteComponent(match) {
+        const component = match.route.component;
+        return component ?? null;
+    }
+    resolveRouteTarget(component) {
+        return (this._activeRouteInjector?.get(CRAFT_ROUTE_TARGET, null) ??
+            (component ? craftRouteTarget(component) : null));
+    }
+    routeProps() {
+        return collectMatchProps(this._match);
+    }
+    clearTimers() {
+        if (this._stayTimer !== null) {
+            this._stayTimer.cancel();
+            this._stayTimer = null;
+        }
+        if (this._blankTimer !== null) {
+            this._blankTimer.cancel();
+            this._blankTimer = null;
+        }
+        if (this._pendingCommitTimer !== null) {
+            this._pendingCommitTimer.cancel();
+            this._pendingCommitTimer = null;
+        }
+    }
+    teardown() {
+        this._navId++;
+        this.clearTimers();
+        this._reactiveWatch?.destroy();
+        this._reactiveWatch = null;
+        this._frozen = false;
+        this.clearExceptionSinks(this._meta);
+    }
+    clearExceptionSinks(meta) {
+        if (!meta)
+            return;
+        for (const sink of Object.values(meta.exceptionSinks))
+            sink.set(null);
+    }
+    isCurrentActivation(match) {
+        return this._match !== null && isSameActivation(this._match, match);
+    }
+}
+export function createCraftRouterOutletController() {
+    return new CraftRouterOutletController();
+}
+export async function resolveComponentInput(input) {
+    if (!input) {
+        return null;
+    }
+    if (input.loadComponent) {
+        const loaded = await input.loadComponent();
+        return loaded && typeof loaded === 'object' && 'default' in loaded
+            ? loaded.default
+            : loaded;
+    }
+    return input.component;
+}
+async function resolvePendingComponentInput(input) {
+    if (!input)
+        return null;
+    if (isLazyPendingComponent(input)) {
+        return (await input()).default;
+    }
+    return input;
+}
+function isLazyPendingComponent(input) {
+    return (typeof input === 'function' &&
+        !isCraftRouteTarget(input) &&
+        input.prototype === undefined);
+}
+export function craftOutletStateOf(outlet) {
+    return outlet.state;
+}
+function silentRouter() {
+    return {
+        url: '/',
+        createUrlTree: (input) => ({
+            toString: () => `/${input.to}`,
+            __craftUrlTree: true,
+        }),
+        navigate: async () => true,
+        navigateByUrl: async () => true,
+        serializeUrl: (tree) => tree.toString(),
+        getCurrentNavigation: () => null,
+    };
+}
+function collectAncestorGuardMetas(fullMatch, activated) {
+    const index = fullMatch.routes.indexOf(activated.route);
+    if (index <= 0) {
+        return [];
+    }
+    const metas = [];
+    for (const route of fullMatch.routes.slice(0, index)) {
+        const meta = getCraftRouteMeta(route.data);
+        if (meta?.match || meta?.guard) {
+            metas.push(meta);
+        }
+    }
+    return metas;
+}
+function composeRouteMetas(ancestors, leaf) {
+    if (ancestors.length === 0) {
+        return leaf;
+    }
+    const guard = function* (route, state) {
+        for (const ancestor of ancestors) {
+            if (ancestor.match) {
+                const matchResult = yield* ancestor.match(route, state);
+                if (matchResult === false) {
+                    return false;
+                }
+            }
+            if (ancestor.guard) {
+                const guardResult = yield* ancestor.guard(route, state);
+                if (guardResult === false) {
+                    return false;
+                }
+            }
+        }
+        if (leaf?.match) {
+            const matchResult = yield* leaf.match(route, state);
+            if (matchResult === false) {
+                return false;
+            }
+        }
+        if (leaf?.guard) {
+            return yield* leaf.guard(route, state);
+        }
+        return true;
+    };
+    if (!leaf) {
+        return {
+            match: undefined,
+            guard,
+            resolve: undefined,
+            handleExceptions: Object.assign({}, ...ancestors.map((ancestor) => ancestor.handleExceptions)),
+            guardDataSink: null,
+            resolveDataSink: null,
+            exceptionSinks: {},
+            reactiveGuards: false,
+        };
+    }
+    return {
+        ...leaf,
+        match: undefined,
+        guard,
+    };
+}
+function paramNamesForPath(path) {
+    if (!path || path === '**') {
+        return [];
+    }
+    return path
+        .split('/')
+        .filter((segment) => segment.startsWith(':'))
+        .map((segment) => segment.slice(1).replace(/\?$/, ''));
+}
+function paramsForActivatedRoute(route, params) {
+    const names = paramNamesForPath(route.path);
+    const owned = {};
+    for (const name of names) {
+        if (params[name] !== undefined) {
+            owned[name] = params[name];
+        }
+    }
+    return owned;
+}
+/**
+ * Whether the live component survives this navigation.
+ *
+ * Angular decides this on the route config ALONE — `RouteReuseStrategy` keeps
+ * the instance when `future.routeConfig === curr.routeConfig`, and a separate
+ * `runGuardsAndResolvers` decides whether the chain re-runs on a param change.
+ * Craft drove both from one comparison, so changing `:userId` tore the
+ * component down and took with it whatever state it held — which is why a
+ * `preservePreviousValue` query could never preserve anything across a
+ * navigation.
+ *
+ * Craft keeps the component and lets reactivity carry the new params: the
+ * fast-path publishes them on the live match signal, `injectRouteParamsSignal`
+ * derives from it, and reactive guards re-evaluate off their own watch.
+ *
+ * Resolvers have no such reactivity yet — `meta.resolve` runs once, in the
+ * `'enter'` phase — so a route carrying one still gets a full activation
+ * instead of silently stale resolve data.
+ */
+function canReuseActivation(current, next, meta) {
+    if (current.route !== next.route) {
+        return false;
+    }
+    return meta?.resolve ? isSameActivation(current, next) : true;
+}
+function isSameActivation(current, next) {
+    if (current.route !== next.route) {
+        return false;
+    }
+    const currentParams = paramsForActivatedRoute(current.route, current.params);
+    const nextParams = paramsForActivatedRoute(next.route, next.params);
+    const currentKeys = Object.keys(currentParams);
+    const nextKeys = Object.keys(nextParams);
+    if (currentKeys.length !== nextKeys.length) {
+        return false;
+    }
+    return currentKeys.every((key) => currentParams[key] === nextParams[key]);
+}
+function matchToSnapshot(match) {
+    return {
+        params: match.params,
+        queryParams: match.queryParams,
+        data: match.data,
+        url: [],
+        routeConfig: { path: match.route.path },
+        pathFromRoot: match.routes.map((route) => ({
+            params: match.params,
+            data: route.data ?? {},
+            queryParams: match.queryParams,
+            routeConfig: route,
+        })),
+        component: match.route.component,
+    };
+}
+//# sourceMappingURL=craft-router-outlet.js.map