@real-router/angular 0.0.1

package/dist/fesm2022/real-router-angular.mjs

@@ -0,0 +1,575 @@
+import * as i0 from '@angular/core';
+import { signal, inject, DestroyRef, InjectionToken, makeEnvironmentProviders, input, TemplateRef, Directive, contentChildren, computed, Component, output, effect, ElementRef } from '@angular/core';
+import { getNavigator, UNKNOWN_ROUTE } from '@real-router/core';
+import { createRouteSource, createRouteNodeSource, createTransitionSource, createActiveRouteSource, createErrorSource } from '@real-router/sources';
+import { getPluginApi } from '@real-router/core/api';
+import { getRouteUtils, startsWithSegment } from '@real-router/route-utils';
+import { NgTemplateOutlet } from '@angular/common';
+
+/** Must be called within an injection context (constructor, field initializer, runInInjectionContext). */
+function sourceToSignal(source) {
+    const sig = signal(source.getSnapshot(), ...(ngDevMode ? [{ debugName: "sig" }] : /* istanbul ignore next */ []));
+    const destroyRef = inject(DestroyRef);
+    const unsubscribe = source.subscribe(() => {
+        sig.set(source.getSnapshot());
+    });
+    destroyRef.onDestroy(() => {
+        unsubscribe();
+        source.destroy();
+    });
+    return sig.asReadonly();
+}
+
+const ROUTER = new InjectionToken("ROUTER");
+const NAVIGATOR = new InjectionToken("NAVIGATOR");
+const ROUTE = new InjectionToken("ROUTE");
+function provideRealRouter(router) {
+    const navigator = getNavigator(router);
+    return makeEnvironmentProviders([
+        { provide: ROUTER, useValue: router },
+        { provide: NAVIGATOR, useValue: navigator },
+        {
+            provide: ROUTE,
+            useFactory: () => ({
+                routeState: sourceToSignal(createRouteSource(router)),
+                navigator,
+            }),
+        },
+    ]);
+}
+
+function injectOrThrow(token, fnName) {
+    const value = inject(token, { optional: true });
+    if (!value) {
+        throw new Error(`${fnName} must be used within a provideRealRouter context`);
+    }
+    return value;
+}
+
+function injectRouter() {
+    return injectOrThrow(ROUTER, "injectRouter");
+}
+
+function injectNavigator() {
+    return injectOrThrow(NAVIGATOR, "injectNavigator");
+}
+
+function injectRoute() {
+    return injectOrThrow(ROUTE, "injectRoute");
+}
+
+function injectRouteNode(nodeName) {
+    const router = injectRouter();
+    const navigator = getNavigator(router);
+    const source = createRouteNodeSource(router, nodeName);
+    const routeState = sourceToSignal(source);
+    return { routeState, navigator };
+}
+
+function injectRouteUtils() {
+    const router = injectRouter();
+    return getRouteUtils(getPluginApi(router).getTree());
+}
+
+function injectRouterTransition() {
+    const router = injectRouter();
+    const source = createTransitionSource(router);
+    return sourceToSignal(source);
+}
+
+function injectIsActiveRoute(routeName, params, options) {
+    const router = injectRouter();
+    const source = createActiveRouteSource(router, routeName, params, {
+        strict: options?.strict ?? false,
+        ignoreQueryParams: options?.ignoreQueryParams ?? true,
+    });
+    return sourceToSignal(source);
+}
+
+class RouteMatch {
+    routeMatch = input.required(...(ngDevMode ? [{ debugName: "routeMatch" }] : /* istanbul ignore next */ []));
+    templateRef = inject(TemplateRef);
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.8", ngImport: i0, type: RouteMatch, deps: [], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "17.1.0", version: "21.2.8", type: RouteMatch, isStandalone: true, selector: "ng-template[routeMatch]", inputs: { routeMatch: { classPropertyName: "routeMatch", publicName: "routeMatch", isSignal: true, isRequired: true, transformFunction: null } }, ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.8", ngImport: i0, type: RouteMatch, decorators: [{
+            type: Directive,
+            args: [{ selector: "ng-template[routeMatch]" }]
+        }], propDecorators: { routeMatch: [{ type: i0.Input, args: [{ isSignal: true, alias: "routeMatch", required: true }] }] } });
+
+class RouteNotFound {
+    templateRef = inject(TemplateRef);
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.8", ngImport: i0, type: RouteNotFound, deps: [], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "21.2.8", type: RouteNotFound, isStandalone: true, selector: "ng-template[routeNotFound]", ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.8", ngImport: i0, type: RouteNotFound, decorators: [{
+            type: Directive,
+            args: [{ selector: "ng-template[routeNotFound]" }]
+        }] });
+
+const EMPTY_SNAPSHOT = Object.freeze({
+    route: undefined,
+    previousRoute: undefined,
+});
+class RouteView {
+    nodeName = input("", { ...(ngDevMode ? { debugName: "nodeName" } : /* istanbul ignore next */ {}), alias: "routeNode" });
+    matches = contentChildren(RouteMatch, { ...(ngDevMode ? { debugName: "matches" } : /* istanbul ignore next */ {}), descendants: true });
+    notFounds = contentChildren(RouteNotFound, { ...(ngDevMode ? { debugName: "notFounds" } : /* istanbul ignore next */ {}), descendants: true });
+    activeTemplate = computed(() => {
+        const snapshot = this.routeState();
+        const route = snapshot.route;
+        if (!route) {
+            return null;
+        }
+        const routeName = route.name;
+        const entries = this.matchEntries();
+        for (const { match, fullSegmentName } of entries) {
+            if (startsWithSegment(routeName, fullSegmentName)) {
+                return match.templateRef;
+            }
+        }
+        if (routeName === UNKNOWN_ROUTE) {
+            const last = this.notFounds().at(-1);
+            if (last) {
+                return last.templateRef;
+            }
+        }
+        return null;
+    }, ...(ngDevMode ? [{ debugName: "activeTemplate" }] : /* istanbul ignore next */ []));
+    matchEntries = computed(() => {
+        const nodeName = this.nodeName();
+        return this.matches().map((match) => {
+            const segment = match.routeMatch();
+            return {
+                match,
+                fullSegmentName: nodeName ? `${nodeName}.${segment}` : segment,
+            };
+        });
+    }, ...(ngDevMode ? [{ debugName: "matchEntries" }] : /* istanbul ignore next */ []));
+    router = injectRouter();
+    destroyRef = inject(DestroyRef);
+    routeState = signal(EMPTY_SNAPSHOT, ...(ngDevMode ? [{ debugName: "routeState" }] : /* istanbul ignore next */ []));
+    ngOnInit() {
+        const source = createRouteNodeSource(this.router, this.nodeName());
+        this.routeState.set(source.getSnapshot());
+        const unsub = source.subscribe(() => {
+            this.routeState.set(source.getSnapshot());
+        });
+        this.destroyRef.onDestroy(() => {
+            unsub();
+            source.destroy();
+        });
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.8", ngImport: i0, type: RouteView, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "21.2.8", type: RouteView, isStandalone: true, selector: "route-view", inputs: { nodeName: { classPropertyName: "nodeName", publicName: "routeNode", isSignal: true, isRequired: false, transformFunction: null } }, queries: [{ propertyName: "matches", predicate: RouteMatch, descendants: true, isSignal: true }, { propertyName: "notFounds", predicate: RouteNotFound, descendants: true, isSignal: true }], ngImport: i0, template: `
+    @if (activeTemplate()) {
+      <ng-container [ngTemplateOutlet]="activeTemplate()!" />
+    }
+  `, isInline: true, dependencies: [{ kind: "directive", type: NgTemplateOutlet, selector: "[ngTemplateOutlet]", inputs: ["ngTemplateOutletContext", "ngTemplateOutlet", "ngTemplateOutletInjector"] }] });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.8", ngImport: i0, type: RouteView, decorators: [{
+            type: Component,
+            args: [{
+                    selector: "route-view",
+                    template: `
+    @if (activeTemplate()) {
+      <ng-container [ngTemplateOutlet]="activeTemplate()!" />
+    }
+  `,
+                    imports: [NgTemplateOutlet],
+                }]
+        }], propDecorators: { nodeName: [{ type: i0.Input, args: [{ isSignal: true, alias: "routeNode", required: false }] }], matches: [{ type: i0.ContentChildren, args: [i0.forwardRef(() => RouteMatch), { ...{ descendants: true }, isSignal: true }] }], notFounds: [{ type: i0.ContentChildren, args: [i0.forwardRef(() => RouteNotFound), { ...{ descendants: true }, isSignal: true }] }] } });
+
+class RouterErrorBoundary {
+    errorTemplate = input(...(ngDevMode ? [undefined, { debugName: "errorTemplate" }] : /* istanbul ignore next */ []));
+    onError = output();
+    visibleError = computed(() => {
+        const snap = this.snapshot();
+        return snap.version > this.dismissedVersion() ? snap.error : null;
+    }, ...(ngDevMode ? [{ debugName: "visibleError" }] : /* istanbul ignore next */ []));
+    errorContext = computed(() => {
+        const error = this.visibleError();
+        if (!error) {
+            return null;
+        }
+        return {
+            $implicit: error,
+            resetError: this.resetError,
+        };
+    }, ...(ngDevMode ? [{ debugName: "errorContext" }] : /* istanbul ignore next */ []));
+    router = injectRouter();
+    snapshot = sourceToSignal(createErrorSource(this.router));
+    dismissedVersion = signal(-1, ...(ngDevMode ? [{ debugName: "dismissedVersion" }] : /* istanbul ignore next */ []));
+    constructor() {
+        effect(() => {
+            const snap = this.snapshot();
+            if (snap.error) {
+                this.onError.emit({
+                    error: snap.error,
+                    toRoute: snap.toRoute,
+                    fromRoute: snap.fromRoute,
+                });
+            }
+        });
+    }
+    resetError = () => {
+        this.dismissedVersion.set(this.snapshot().version);
+    };
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.8", ngImport: i0, type: RouterErrorBoundary, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "21.2.8", type: RouterErrorBoundary, isStandalone: true, selector: "router-error-boundary", inputs: { errorTemplate: { classPropertyName: "errorTemplate", publicName: "errorTemplate", isSignal: true, isRequired: false, transformFunction: null } }, outputs: { onError: "onError" }, ngImport: i0, template: `
+    <ng-content />
+    @if (errorContext() && errorTemplate()) {
+      <ng-container
+        [ngTemplateOutlet]="errorTemplate()!"
+        [ngTemplateOutletContext]="errorContext()!"
+      />
+    }
+  `, isInline: true, dependencies: [{ kind: "directive", type: NgTemplateOutlet, selector: "[ngTemplateOutlet]", inputs: ["ngTemplateOutletContext", "ngTemplateOutlet", "ngTemplateOutletInjector"] }] });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.8", ngImport: i0, type: RouterErrorBoundary, decorators: [{
+            type: Component,
+            args: [{
+                    selector: "router-error-boundary",
+                    template: `
+    <ng-content />
+    @if (errorContext() && errorTemplate()) {
+      <ng-container
+        [ngTemplateOutlet]="errorTemplate()!"
+        [ngTemplateOutletContext]="errorContext()!"
+      />
+    }
+  `,
+                    imports: [NgTemplateOutlet],
+                }]
+        }], ctorParameters: () => [], propDecorators: { errorTemplate: [{ type: i0.Input, args: [{ isSignal: true, alias: "errorTemplate", required: false }] }], onError: [{ type: i0.Output, args: ["onError"] }] } });
+
+const CLEAR_DELAY = 7000;
+const SAFARI_READY_DELAY = 100;
+const ANNOUNCER_ATTR = "data-real-router-announcer";
+const INTERNAL_ROUTE_PREFIX = "@@";
+const VISUALLY_HIDDEN = "position:absolute;width:1px;height:1px;padding:0;margin:-1px;overflow:hidden;clip:rect(0,0,0,0);clip-path:inset(50%);white-space:nowrap;border:0";
+function createRouteAnnouncer(router, options) {
+    const prefix = options?.prefix ?? "Navigated to ";
+    const getCustomText = options?.getAnnouncementText;
+    let isInitialNavigation = true;
+    let isReady = false;
+    let isDestroyed = false;
+    let lastAnnouncedText = "";
+    let pendingText = null;
+    let clearTimeoutId;
+    const announcer = getOrCreateAnnouncer();
+    const doAnnounce = (text, h1) => {
+        lastAnnouncedText = text;
+        clearTimeout(clearTimeoutId);
+        announcer.textContent = text;
+        clearTimeoutId = setTimeout(() => {
+            announcer.textContent = "";
+            lastAnnouncedText = "";
+        }, CLEAR_DELAY);
+        manageFocus(h1);
+    };
+    // Safari-ready delay: announcing before VoiceOver wires up the aria-live region
+    // causes the first announcement to be silently dropped. Wait SAFARI_READY_DELAY ms
+    // before marking the announcer "ready" — any navigation during that window is
+    // buffered in pendingText and flushed once the delay expires.
+    const safariTimeoutId = setTimeout(() => {
+        isReady = true;
+        if (pendingText !== null && !isDestroyed) {
+            const text = pendingText;
+            pendingText = null;
+            doAnnounce(text, document.querySelector("h1"));
+        }
+    }, SAFARI_READY_DELAY);
+    const unsubscribe = router.subscribe(({ route }) => {
+        if (isInitialNavigation) {
+            isInitialNavigation = false;
+            return;
+        }
+        // Double rAF: waits for two paint frames so the incoming route's DOM
+        // (including the new <h1>) is fully rendered before resolveText reads it.
+        // Single rAF fires before the new route's template has been attached,
+        // which would cause resolveText to pick up the OLD h1 or fall back to
+        // document.title / route.name prematurely.
+        requestAnimationFrame(() => {
+            requestAnimationFrame(() => {
+                if (isDestroyed) {
+                    return;
+                }
+                const h1 = document.querySelector("h1");
+                const text = resolveText(route, prefix, getCustomText, h1);
+                if (!text || text === lastAnnouncedText) {
+                    return;
+                }
+                if (!isReady) {
+                    // Defer announcement until Safari-ready window elapses (see safariTimeoutId).
+                    pendingText = text;
+                    return;
+                }
+                doAnnounce(text, h1);
+            });
+        });
+    });
+    return {
+        destroy() {
+            isDestroyed = true;
+            unsubscribe();
+            clearTimeout(clearTimeoutId);
+            clearTimeout(safariTimeoutId);
+            removeAnnouncer();
+        },
+    };
+}
+function getOrCreateAnnouncer() {
+    const existing = document.querySelector(`[${ANNOUNCER_ATTR}]`);
+    if (existing) {
+        return existing;
+    }
+    const element = document.createElement("div");
+    element.setAttribute("style", VISUALLY_HIDDEN);
+    element.setAttribute("aria-live", "assertive");
+    element.setAttribute("aria-atomic", "true");
+    element.setAttribute(ANNOUNCER_ATTR, "");
+    document.body.prepend(element);
+    return element;
+}
+function removeAnnouncer() {
+    document.querySelector(`[${ANNOUNCER_ATTR}]`)?.remove();
+}
+function resolveText(route, prefix, getCustomText, h1) {
+    if (getCustomText) {
+        return getCustomText(route);
+    }
+    const h1Text = h1?.textContent.trim() ?? "";
+    const routeName = route.name.startsWith(INTERNAL_ROUTE_PREFIX)
+        ? ""
+        : route.name;
+    const rawText = h1Text || document.title || routeName || globalThis.location.pathname;
+    return `${prefix}${rawText}`;
+}
+function manageFocus(h1) {
+    if (!h1) {
+        return;
+    }
+    if (!h1.hasAttribute("tabindex")) {
+        h1.setAttribute("tabindex", "-1");
+    }
+    h1.focus({ preventScroll: true });
+}
+
+function shouldNavigate(evt) {
+    return (evt.button === 0 &&
+        !evt.metaKey &&
+        !evt.altKey &&
+        !evt.ctrlKey &&
+        !evt.shiftKey);
+}
+function buildHref(router, routeName, routeParams) {
+    try {
+        const buildUrl = router.buildUrl;
+        if (buildUrl) {
+            const url = buildUrl(routeName, routeParams);
+            if (url !== undefined) {
+                return url;
+            }
+        }
+        return router.buildPath(routeName, routeParams);
+    }
+    catch {
+        console.error(`[real-router] Route "${routeName}" is not defined. The element will render without an href attribute.`);
+        return undefined;
+    }
+}
+function parseTokens(value) {
+    return value ? (value.match(/\S+/g) ?? []) : [];
+}
+function buildActiveClassName(isActive, activeClassName, baseClassName) {
+    if (isActive && activeClassName) {
+        const activeTokens = parseTokens(activeClassName);
+        if (activeTokens.length === 0) {
+            return baseClassName ?? undefined;
+        }
+        if (!baseClassName) {
+            return activeTokens.join(" ");
+        }
+        const baseTokens = parseTokens(baseClassName);
+        const seen = new Set(baseTokens);
+        for (const token of activeTokens) {
+            if (!seen.has(token)) {
+                seen.add(token);
+                baseTokens.push(token);
+            }
+        }
+        return baseTokens.join(" ");
+    }
+    return baseClassName ?? undefined;
+}
+function shallowEqual(prev, next) {
+    if (Object.is(prev, next)) {
+        return true;
+    }
+    if (!prev || !next) {
+        return false;
+    }
+    const prevKeys = Object.keys(prev);
+    if (prevKeys.length !== Object.keys(next).length) {
+        return false;
+    }
+    const prevRecord = prev;
+    const nextRecord = next;
+    for (const key of prevKeys) {
+        if (!Object.is(prevRecord[key], nextRecord[key])) {
+            return false;
+        }
+    }
+    return true;
+}
+function applyLinkA11y(element) {
+    if (!element) {
+        return;
+    }
+    if (element instanceof HTMLAnchorElement ||
+        element instanceof HTMLButtonElement) {
+        return;
+    }
+    if (!element.hasAttribute("role")) {
+        element.setAttribute("role", "link");
+    }
+    if (!element.hasAttribute("tabindex")) {
+        element.setAttribute("tabindex", "0");
+    }
+}
+
+class NavigationAnnouncer {
+    announcer = createRouteAnnouncer(injectRouter());
+    constructor() {
+        inject(DestroyRef).onDestroy(() => {
+            this.announcer.destroy();
+        });
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.8", ngImport: i0, type: NavigationAnnouncer, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "21.2.8", type: NavigationAnnouncer, isStandalone: true, selector: "navigation-announcer", ngImport: i0, template: "", isInline: true });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.8", ngImport: i0, type: NavigationAnnouncer, decorators: [{
+            type: Component,
+            args: [{
+                    selector: "navigation-announcer",
+                    template: "",
+                }]
+        }], ctorParameters: () => [] });
+
+class RealLink {
+    routeName = input("", ...(ngDevMode ? [{ debugName: "routeName" }] : /* istanbul ignore next */ []));
+    routeParams = input({}, ...(ngDevMode ? [{ debugName: "routeParams" }] : /* istanbul ignore next */ []));
+    routeOptions = input({}, ...(ngDevMode ? [{ debugName: "routeOptions" }] : /* istanbul ignore next */ []));
+    activeClassName = input("active", ...(ngDevMode ? [{ debugName: "activeClassName" }] : /* istanbul ignore next */ []));
+    activeStrict = input(false, ...(ngDevMode ? [{ debugName: "activeStrict" }] : /* istanbul ignore next */ []));
+    ignoreQueryParams = input(true, ...(ngDevMode ? [{ debugName: "ignoreQueryParams" }] : /* istanbul ignore next */ []));
+    router = injectRouter();
+    destroyRef = inject(DestroyRef);
+    anchor = inject(ElementRef)
+        .nativeElement;
+    isActive = signal(false, ...(ngDevMode ? [{ debugName: "isActive" }] : /* istanbul ignore next */ []));
+    href = computed(() => buildHref(this.router, this.routeName(), this.routeParams()), ...(ngDevMode ? [{ debugName: "href" }] : /* istanbul ignore next */ []));
+    prevActiveClass = "";
+    ngOnInit() {
+        const source = createActiveRouteSource(this.router, this.routeName(), this.routeParams(), {
+            strict: this.activeStrict(),
+            ignoreQueryParams: this.ignoreQueryParams(),
+        });
+        this.isActive.set(source.getSnapshot());
+        this.updateDom();
+        const unsub = source.subscribe(() => {
+            this.isActive.set(source.getSnapshot());
+            this.updateDom();
+        });
+        this.destroyRef.onDestroy(() => {
+            unsub();
+            source.destroy();
+        });
+    }
+    onClick(event) {
+        if (!shouldNavigate(event) || this.anchor.target === "_blank") {
+            return;
+        }
+        event.preventDefault();
+        this.router
+            .navigate(this.routeName(), this.routeParams(), this.routeOptions())
+            .catch(() => { });
+    }
+    updateDom() {
+        const href = this.href();
+        if (href !== undefined) {
+            this.anchor.setAttribute("href", href);
+        }
+        const activeClass = this.activeClassName();
+        if (this.prevActiveClass && this.prevActiveClass !== activeClass) {
+            this.anchor.classList.remove(this.prevActiveClass);
+        }
+        if (activeClass) {
+            this.anchor.classList.toggle(activeClass, this.isActive());
+        }
+        this.prevActiveClass = activeClass;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.8", ngImport: i0, type: RealLink, deps: [], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "17.1.0", version: "21.2.8", type: RealLink, isStandalone: true, selector: "a[realLink]", inputs: { routeName: { classPropertyName: "routeName", publicName: "routeName", isSignal: true, isRequired: false, transformFunction: null }, routeParams: { classPropertyName: "routeParams", publicName: "routeParams", isSignal: true, isRequired: false, transformFunction: null }, routeOptions: { classPropertyName: "routeOptions", publicName: "routeOptions", isSignal: true, isRequired: false, transformFunction: null }, activeClassName: { classPropertyName: "activeClassName", publicName: "activeClassName", isSignal: true, isRequired: false, transformFunction: null }, activeStrict: { classPropertyName: "activeStrict", publicName: "activeStrict", isSignal: true, isRequired: false, transformFunction: null }, ignoreQueryParams: { classPropertyName: "ignoreQueryParams", publicName: "ignoreQueryParams", isSignal: true, isRequired: false, transformFunction: null } }, host: { listeners: { "click": "onClick($event)" } }, ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.8", ngImport: i0, type: RealLink, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: "a[realLink]",
+                    host: {
+                        "(click)": "onClick($event)",
+                    },
+                }]
+        }], propDecorators: { routeName: [{ type: i0.Input, args: [{ isSignal: true, alias: "routeName", required: false }] }], routeParams: [{ type: i0.Input, args: [{ isSignal: true, alias: "routeParams", required: false }] }], routeOptions: [{ type: i0.Input, args: [{ isSignal: true, alias: "routeOptions", required: false }] }], activeClassName: [{ type: i0.Input, args: [{ isSignal: true, alias: "activeClassName", required: false }] }], activeStrict: [{ type: i0.Input, args: [{ isSignal: true, alias: "activeStrict", required: false }] }], ignoreQueryParams: [{ type: i0.Input, args: [{ isSignal: true, alias: "ignoreQueryParams", required: false }] }] } });
+
+class RealLinkActive {
+    realLinkActive = input("", ...(ngDevMode ? [{ debugName: "realLinkActive" }] : /* istanbul ignore next */ []));
+    routeName = input("", ...(ngDevMode ? [{ debugName: "routeName" }] : /* istanbul ignore next */ []));
+    routeParams = input({}, ...(ngDevMode ? [{ debugName: "routeParams" }] : /* istanbul ignore next */ []));
+    activeStrict = input(false, ...(ngDevMode ? [{ debugName: "activeStrict" }] : /* istanbul ignore next */ []));
+    ignoreQueryParams = input(true, ...(ngDevMode ? [{ debugName: "ignoreQueryParams" }] : /* istanbul ignore next */ []));
+    router = injectRouter();
+    destroyRef = inject(DestroyRef);
+    element = inject(ElementRef).nativeElement;
+    isActive = signal(false, ...(ngDevMode ? [{ debugName: "isActive" }] : /* istanbul ignore next */ []));
+    constructor() {
+        applyLinkA11y(this.element);
+    }
+    ngOnInit() {
+        const source = createActiveRouteSource(this.router, this.routeName(), this.routeParams(), {
+            strict: this.activeStrict(),
+            ignoreQueryParams: this.ignoreQueryParams(),
+        });
+        this.isActive.set(source.getSnapshot());
+        this.updateClass();
+        const unsub = source.subscribe(() => {
+            this.isActive.set(source.getSnapshot());
+            this.updateClass();
+        });
+        this.destroyRef.onDestroy(() => {
+            unsub();
+            source.destroy();
+        });
+    }
+    updateClass() {
+        const className = this.realLinkActive();
+        if (!className) {
+            return;
+        }
+        this.element.classList.toggle(className, this.isActive());
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.8", ngImport: i0, type: RealLinkActive, deps: [], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "17.1.0", version: "21.2.8", type: RealLinkActive, isStandalone: true, selector: "[realLinkActive]", inputs: { realLinkActive: { classPropertyName: "realLinkActive", publicName: "realLinkActive", isSignal: true, isRequired: false, transformFunction: null }, routeName: { classPropertyName: "routeName", publicName: "routeName", isSignal: true, isRequired: false, transformFunction: null }, routeParams: { classPropertyName: "routeParams", publicName: "routeParams", isSignal: true, isRequired: false, transformFunction: null }, activeStrict: { classPropertyName: "activeStrict", publicName: "activeStrict", isSignal: true, isRequired: false, transformFunction: null }, ignoreQueryParams: { classPropertyName: "ignoreQueryParams", publicName: "ignoreQueryParams", isSignal: true, isRequired: false, transformFunction: null } }, ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.8", ngImport: i0, type: RealLinkActive, decorators: [{
+            type: Directive,
+            args: [{ selector: "[realLinkActive]" }]
+        }], ctorParameters: () => [], propDecorators: { realLinkActive: [{ type: i0.Input, args: [{ isSignal: true, alias: "realLinkActive", required: false }] }], routeName: [{ type: i0.Input, args: [{ isSignal: true, alias: "routeName", required: false }] }], routeParams: [{ type: i0.Input, args: [{ isSignal: true, alias: "routeParams", required: false }] }], activeStrict: [{ type: i0.Input, args: [{ isSignal: true, alias: "activeStrict", required: false }] }], ignoreQueryParams: [{ type: i0.Input, args: [{ isSignal: true, alias: "ignoreQueryParams", required: false }] }] } });
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { NAVIGATOR, NavigationAnnouncer, ROUTE, ROUTER, RealLink, RealLinkActive, RouteMatch, RouteNotFound, RouteView, RouterErrorBoundary, injectIsActiveRoute, injectNavigator, injectRoute, injectRouteNode, injectRouteUtils, injectRouter, injectRouterTransition, provideRealRouter, sourceToSignal };
+//# sourceMappingURL=real-router-angular.mjs.map