npm - @real-router/angular - Versions diffs - 0.3.0 → 0.5.0 - Mend

@real-router/angular 0.3.0 → 0.5.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (18) hide show

package/README.md +60 -1
package/dist/README.md +60 -1
package/dist/fesm2022/real-router-angular.mjs +408 -8
package/dist/fesm2022/real-router-angular.mjs.map +1 -1
package/dist/types/real-router-angular.d.ts +171 -4
package/dist/types/real-router-angular.d.ts.map +1 -1
package/package.json +5 -5
package/src/components/RouteView.ts +14 -0
package/src/directives/RouteSelf.ts +6 -0
package/src/dom-utils/direction-tracker.ts +70 -0
package/src/dom-utils/index.ts +8 -0
package/src/dom-utils/route-announcer.ts +1 -1
package/src/dom-utils/view-transitions.ts +142 -0
package/src/functions/index.ts +16 -0
package/src/functions/injectRouteEnter.ts +129 -0
package/src/functions/injectRouteExit.ts +118 -0
package/src/index.ts +13 -0
package/src/providers.ts +35 -1

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

@@ -1,11 +1,69 @@
 import * as i0 from '@angular/core';
-import { signal, inject, DestroyRef, InjectionToken, provideEnvironmentInitializer, makeEnvironmentProviders, input, TemplateRef, Directive, contentChildren, computed, Component, output, effect, ElementRef } from '@angular/core';
+import { signal, inject, DestroyRef, InjectionToken, provideEnvironmentInitializer, ApplicationRef, makeEnvironmentProviders, assertInInjectionContext, effect, input, TemplateRef, Directive, contentChildren, computed, Component, output, ElementRef } from '@angular/core';
 import { getNavigator, UNKNOWN_ROUTE } from '@real-router/core';
 import { createRouteSource, createRouteNodeSource, getTransitionSource, createActiveRouteSource, createDismissableError } from '@real-router/sources';
 import { getPluginApi } from '@real-router/core/api';
 import { getRouteUtils, startsWithSegment } from '@real-router/route-utils';
 import { NgTemplateOutlet } from '@angular/common';
+const NOOP_INSTANCE$2 = Object.freeze({
+    destroy: () => {
+        /* no-op */
+    },
+});
+/**
+ * Track navigation direction (forward / back) and write it to
+ * `<html data-nav-direction>` on every leave. CSS / JS readers consume
+ * the attribute via `html[data-nav-direction="back"]` selectors or
+ * `document.documentElement.dataset.navDirection`.
+ *
+ * Mechanism-agnostic — works identically whether downstream UI uses CSS
+ * `@keyframes`, View Transitions pseudo-elements, or library state
+ * (motion's `motion.div initial={{ x: ... }}`).
+ *
+ * Implementation:
+ *   - On install, set `data-nav-direction="forward"` baseline.
+ *   - Attach a `popstate` listener that flips an internal flag to
+ *     `true`. Browser back/forward navigation triggers popstate; user
+ *     clicks on `<Link>` / programmatic `router.navigate(...)` do not.
+ *   - On every `subscribeLeave`, write
+ *     `popstateFlag ? "back" : "forward"` and reset the flag.
+ *
+ * Returns `{ destroy }` to clean up the listener and clear the dataset
+ * attribute.
+ */
+function createDirectionTracker(router) {
+    if (typeof document === "undefined") {
+        return NOOP_INSTANCE$2;
+    }
+    let popstateFlag = false;
+    document.documentElement.dataset.navDirection = "forward";
+    const onPopstate = () => {
+        popstateFlag = true;
+    };
+    // IMPORTANT — listener-ordering: `popstate` fires on `window`, which
+    // has no DOM descendants, so capture phase is moot. Listeners are
+    // dispatched in registration order. To beat the browser-plugin's own
+    // popstate handler, this tracker must be installed **before**
+    // `router.usePlugin(browserPluginFactory())` in user code. Otherwise
+    // the plugin's handler runs first and synchronously fires
+    // `subscribeLeave` while `popstateFlag` is still `false`.
+    globalThis.addEventListener("popstate", onPopstate);
+    const offLeave = router.subscribeLeave(() => {
+        document.documentElement.dataset.navDirection = popstateFlag
+            ? "back"
+            : "forward";
+        popstateFlag = false;
+    });
+    return {
+        destroy: () => {
+            offLeave();
+            globalThis.removeEventListener("popstate", onPopstate);
+            delete document.documentElement.dataset.navDirection;
+        },
+    };
+}
 const CLEAR_DELAY = 7000;
 const SAFARI_READY_DELAY = 100;
 const ANNOUNCER_ATTR = "data-real-router-announcer";
@@ -102,7 +160,7 @@ function resolveText(route, prefix, getCustomText, h1) {
     if (getCustomText) {
         return getCustomText(route);
     }
-    const h1Text = h1?.textContent.trim() ?? "";
+    const h1Text = (h1?.textContent ?? "").trim();
     const routeName = route.name.startsWith(INTERNAL_ROUTE_PREFIX)
         ? ""
         : route.name;
@@ -120,21 +178,21 @@ function manageFocus(h1) {
 }
 const STORAGE_KEY = "real-router:scroll";
-const NOOP_INSTANCE = Object.freeze({
+const NOOP_INSTANCE$1 = Object.freeze({
     destroy: () => {
         /* no-op */
     },
 });
 function createScrollRestoration(router, options) {
     if (typeof globalThis.window === "undefined") {
-        return NOOP_INSTANCE;
+        return NOOP_INSTANCE$1;
     }
     const mode = options?.mode ?? "restore";
     // mode "manual" = utility does nothing. Don't flip history.scrollRestoration,
     // don't subscribe, don't register pagehide — leave the browser's native
     // auto-restore intact for the app to override if it wants to.
     if (mode === "manual") {
-        return NOOP_INSTANCE;
+        return NOOP_INSTANCE$1;
     }
     const anchorEnabled = options?.anchorScrolling ?? true;
     const getContainer = options?.scrollContainer;
@@ -277,6 +335,125 @@ function canonicalReplacer(_key, val) {
     return val;
 }
+const NOOP_INSTANCE = Object.freeze({
+    destroy: () => {
+        /* no-op */
+    },
+});
+function createViewTransitions(router) {
+    if (typeof document === "undefined" ||
+        typeof document.startViewTransition !== "function") {
+        return NOOP_INSTANCE;
+    }
+    let closeVT = null;
+    let currentVT = null;
+    // Tracks whether TRANSITION_SUCCESS fired for the current leave. Used to
+    // distinguish "benign cleanup abort" (router's async path aborts its own
+    // controller in a finally block after successful navigation) from "real
+    // cancellation" (concurrent navigate, guard rejection, dispose).
+    let successFired = false;
+    const resolveAndClear = () => {
+        closeVT?.();
+        closeVT = null;
+    };
+    const offLeave = router.subscribeLeave(({ signal }) => {
+        // Reentrant abort: signal already aborted when we're called. Open no VT
+        // — router will fall through to TRANSITION_CANCELLED via isCurrentNav()
+        // after leave resolves. addEventListener("abort", ...) does not re-fire
+        // for past events, so skipping startViewTransition is the safe path.
+        if (signal.aborted) {
+            return;
+        }
+        successFired = false;
+        resolveAndClear();
+        // Return a Promise so the router awaits until the browser invokes
+        // updateCallback. This ensures old DOM snapshot is captured BEFORE the
+        // router commits the new state — giving correct exit→state→entry
+        // ordering (vs fire-and-forget, where URL changes before VT captures).
+        return new Promise((resolveLeave) => {
+            // Capture the resolver synchronously BEFORE startViewTransition() is
+            // called. The browser invokes updateCallback in a later task, but
+            // router.subscribe (TRANSITION_SUCCESS) can fire before that. If we
+            // captured `resolve` inside the callback, subscribe would see closeVT
+            // still null and skip resolving — the deferred would hang for 4s
+            // until the VT API aborts with TimeoutError.
+            const deferred = new Promise((resolve) => {
+                closeVT = resolve;
+            });
+            signal.addEventListener("abort", () => {
+                if (successFired) {
+                    // Router's async path (#finishAsyncNavigation) aborts its own
+                    // controller in a finally block AFTER completeTransition (and
+                    // thus AFTER subscribe fired). This is cleanup, not
+                    // cancellation — VT is progressing normally, do nothing.
+                    return;
+                }
+                // Real cancellation (concurrent navigate, dispose). Resolve the
+                // deferred so updateCallback can complete, skip the VT so no
+                // stale animation leaks, and unblock the router if the abort
+                // fires before updateCallback was invoked.
+                resolveAndClear();
+                currentVT?.skipTransition?.();
+                resolveLeave();
+            }, { once: true });
+            try {
+                currentVT = document.startViewTransition(() => {
+                    // Resolving here unblocks the router at the moment the browser
+                    // enters updateCallback — by spec, old DOM snapshot is captured
+                    // before this callback runs. Router now proceeds through
+                    // activation guards and setState; the VT animation waits on
+                    // `deferred`, which is resolved from router.subscribe after a
+                    // task-queue tick (see NOTE on setTimeout below).
+                    resolveLeave();
+                    return deferred;
+                });
+            }
+            catch {
+                // Defensive: spec says startViewTransition doesn't throw under
+                // normal conditions, but Chromium has had edge cases (detached
+                // document, extension interference). Clean up and unblock router.
+                resolveAndClear();
+                resolveLeave();
+            }
+        });
+    });
+    const offSuccess = router.subscribe(() => {
+        const resolver = closeVT;
+        successFired = true;
+        closeVT = null;
+        if (resolver === null) {
+            currentVT = null;
+        }
+        else {
+            // CRITICAL: CANNOT use requestAnimationFrame here. When the router
+            // takes the async path (leave returned a Promise), subscribe fires
+            // AFTER the browser has already transitioned VT into the
+            // "update-callback-called" phase. In that phase Chromium sets
+            // rendering suppression to true, which ALSO blocks rAF callbacks.
+            // rAF would never fire → deferred never resolves → browser aborts
+            // vt.ready with TimeoutError after 4s (observed in Chromium).
+            //
+            // setTimeout runs on the task queue independent of the rendering
+            // pipeline, so it fires regardless of suppression. React's scheduler
+            // uses MessageChannel tasks, which are queued before our setTimeout,
+            // so the new DOM is committed by the time our callback runs.
+            setTimeout(() => {
+                resolver();
+                currentVT = null;
+            }, 0);
+        }
+    });
+    return {
+        destroy: () => {
+            offLeave();
+            offSuccess();
+            currentVT?.skipTransition?.();
+            currentVT = null;
+            resolveAndClear();
+        },
+    };
+}
 function shouldNavigate(evt) {
     return (evt.button === 0 &&
         !evt.metaKey &&
@@ -399,6 +576,32 @@ function provideRealRouter(router, options) {
             });
         }));
     }
+    if (options?.viewTransitions === true) {
+        providers.push(provideEnvironmentInitializer(() => {
+            const appRef = inject(ApplicationRef);
+            // Force synchronous change detection on every transition success
+            // BEFORE the VT utility resolves its deferred. The utility uses
+            // `setTimeout(0)` to release the new-snapshot capture, which is
+            // load-bearing because Chromium blocks rAF callbacks while VT sits
+            // in the `update-callback-called` phase. Angular's zoneless CD is
+            // rAF-driven by default — without this synchronous tick the new
+            // DOM is not committed when the browser captures the new snapshot,
+            // so old and new snapshots end up identical and animations finish
+            // in ~0 ms with no visible work (the inner-route `products.list ↔
+            // products.detail` morph in the example example was the canary).
+            // Subscribers fire in registration order; this one runs BEFORE
+            // `createViewTransitions` registers its own subscriber,
+            // guaranteeing CD completes first.
+            const offTick = router.subscribe(() => {
+                appRef.tick();
+            });
+            const vt = createViewTransitions(router);
+            inject(DestroyRef).onDestroy(() => {
+                offTick();
+                vt.destroy();
+            });
+        }));
+    }
     return makeEnvironmentProviders(providers);
 }
@@ -450,6 +653,182 @@ function injectIsActiveRoute(routeName, params, options) {
     return sourceToSignal(source);
 }
+/**
+ * Subscribe to the router's leave-window with the universal guards baked
+ * in. Wraps `router.subscribeLeave` so consumers don't repeat the same
+ * boilerplate every time:
+ *
+ *   - **Reentrant abort pre-check**: if `signal.aborted` is already `true`
+ *     when the handler would run (rapid navigation superseded a slower
+ *     one), the handler is skipped entirely.
+ *   - **Same-route skip**: by default, `route.name === nextRoute.name`
+ *     short-circuits the handler — query-only navigations skip the work.
+ *     Opt out with `skipSameRoute: false`.
+ *
+ * Cleanup is bound to the injection context's `DestroyRef`. Must be
+ * called within an injection context (constructor, field initializer,
+ * or `runInInjectionContext`).
+ *
+ * If the handler returns a Promise, the router blocks on it. If the
+ * Promise resolves, navigation proceeds. If it rejects, the router emits
+ * `TRANSITION_CANCELLED`.
+ *
+ * **Handler reactivity (Angular):** `inject*` functions run **once**
+ * during component construction; `handler` is captured in closure at the
+ * call site. The common Angular pattern is to pass a class method
+ * (`this.onExit.bind(this)` or an arrow-property) — its identity is
+ * stable across change detection. To vary behavior over time, read
+ * signals **inside** the handler body — do not rely on swapping the
+ * handler reference.
+ *
+ * @example Animation
+ * ```ts
+ * \@Component({ ... })
+ * class FadeOutComponent {
+ *   private el = inject(ElementRef<HTMLElement>);
+ *
+ *   constructor() {
+ *     injectRouteExit(async ({ signal }) => {
+ *       const el = this.el.nativeElement;
+ *       el.classList.add("fade-out");
+ *       const cleanup = () => el.classList.remove("fade-out");
+ *       signal.addEventListener("abort", cleanup, { once: true });
+ *       try {
+ *         el.getBoundingClientRect();
+ *         await Promise.allSettled(el.getAnimations().map((a) => a.finished));
+ *       } finally {
+ *         cleanup();
+ *       }
+ *     });
+ *   }
+ * }
+ * ```
+ *
+ * @example Auto-save form draft
+ * ```ts
+ * injectRouteExit(async ({ signal }) => {
+ *   if (this.formState.dirty) {
+ *     await this.api.saveDraft(this.formState, { signal });
+ *   }
+ * });
+ * ```
+ */
+function injectRouteExit(handler, options) {
+    assertInInjectionContext(injectRouteExit);
+    const router = injectRouter();
+    const destroyRef = inject(DestroyRef);
+    const skipSameRoute = options?.skipSameRoute ?? true;
+    const off = router.subscribeLeave(({ route, nextRoute, signal }) => {
+        if (skipSameRoute && route.name === nextRoute.name) {
+            return;
+        }
+        if (signal.aborted) {
+            return;
+        }
+        return handler({ route, nextRoute, signal });
+    });
+    destroyRef.onDestroy(off);
+}
+/**
+ * Fire `handler` once when the component is created as a result of a
+ * navigation. Mirror of `injectRouteExit` for the entry side.
+ *
+ * What this function covers that an ad-hoc `effect()` + `injectRoute()`
+ * doesn't:
+ *
+ *   - **Skip-initial**: handler is skipped when there is no
+ *     `route.transition.from` (i.e. first-load mount). Most consumers
+ *     want to fire side effects only on real navigations, not on
+ *     hydration.
+ *   - **Same-route skip** (default): handler is skipped when
+ *     `route.transition.from === route.name`. Sort/filter/query-only
+ *     navigations re-run the effect (because the `route` reference
+ *     changes), but they are not "entries" in the animation / analytics
+ *     sense. Opt out with `skipSameRoute: false`.
+ *   - **Mount-time `route` / `previousRoute` snapshot**: handler receives
+ *     the values that were live at the moment of effect activation.
+ *
+ * Effect cleanup is wired through the injection context's `DestroyRef`
+ * (Angular's `effect()` ties into the active context automatically).
+ * Must be called within an injection context (constructor, field
+ * initializer, or `runInInjectionContext`).
+ *
+ * **Handler reactivity (Angular):** `inject*` functions run **once**
+ * during component construction; `handler` is captured in closure at the
+ * call site. The common Angular pattern is to pass a class method —
+ * its identity is stable across change detection. To vary behavior
+ * over time, read signals **inside** the handler body.
+ *
+ * @example Direction-aware entry animation
+ * ```ts
+ * \@Component({ ... })
+ * class PageComponent {
+ *   private el = inject(ElementRef<HTMLElement>);
+ *
+ *   constructor() {
+ *     injectRouteEnter(({ route }) => {
+ *       const direction = route.context.browser?.direction;
+ *       this.el.nativeElement.classList.add(
+ *         direction === "back" ? "slide-from-left" : "slide-from-right",
+ *       );
+ *     });
+ *   }
+ * }
+ * ```
+ *
+ * @example Analytics page-enter event (skip-initial built-in)
+ * ```ts
+ * injectRouteEnter(({ route, previousRoute }) => {
+ *   analytics.track("page_enter", {
+ *     route: route.name,
+ *     from: previousRoute.name,
+ *   });
+ * });
+ * ```
+ */
+function injectRouteEnter(handler, options) {
+    assertInInjectionContext(injectRouteEnter);
+    const { routeState } = injectRoute();
+    const skipSameRoute = options?.skipSameRoute ?? true;
+    let lastHandledRoute = null;
+    effect(() => {
+        const { route, previousRoute } = routeState();
+        // Early-exit guards, top-down:
+        //
+        //   - **Defensive**: `route` may be undefined during SSR or
+        //     pre-start hydration. Not testable from vitest, v8-ignored.
+        //   - **Skip-initial**: `state.transition.from` is undefined only
+        //     for the very first state committed by `router.start()`.
+        //   - **Skip-same-route**: query-only navigations have
+        //     `transition.from === route.name`. Opt-out via
+        //     `skipSameRoute: false`.
+        //   - **Defensive dedupe + missing `previousRoute`**: same `route`
+        //     ref between effect re-runs is unexpected on Angular (the
+        //     signal only fires on real reference changes); `!previousRoute`
+        //     is unreachable once `transition.from` is set (core populates
+        //     them together). Both kept for parity with React; v8-ignored.
+        /* v8 ignore start */
+        if (!route) {
+            return;
+        }
+        /* v8 ignore stop */
+        if (!route.transition.from) {
+            return;
+        }
+        if (skipSameRoute && route.transition.from === route.name) {
+            return;
+        }
+        /* v8 ignore start */
+        if (lastHandledRoute === route || !previousRoute) {
+            return;
+        }
+        /* v8 ignore stop */
+        lastHandledRoute = route;
+        handler({ route, previousRoute });
+    });
+}
 class RouteMatch {
     routeMatch = input.required(...(ngDevMode ? [{ debugName: "routeMatch" }] : /* istanbul ignore next */ []));
     templateRef = inject(TemplateRef);
@@ -471,6 +850,16 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.8", ngImpor
             args: [{ selector: "ng-template[routeNotFound]" }]
         }] });
+class RouteSelf {
+    templateRef = inject(TemplateRef);
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.8", ngImport: i0, type: RouteSelf, deps: [], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "21.2.8", type: RouteSelf, isStandalone: true, selector: "ng-template[routeSelf]", ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.8", ngImport: i0, type: RouteSelf, decorators: [{
+            type: Directive,
+            args: [{ selector: "ng-template[routeSelf]" }]
+        }] });
 const EMPTY_SNAPSHOT = Object.freeze({
     route: undefined,
     previousRoute: undefined,
@@ -478,6 +867,7 @@ const EMPTY_SNAPSHOT = Object.freeze({
 class RouteView {
     nodeName = input("", { ...(ngDevMode ? { debugName: "nodeName" } : /* istanbul ignore next */ {}), alias: "routeNode" });
     matches = contentChildren(RouteMatch, { ...(ngDevMode ? { debugName: "matches" } : /* istanbul ignore next */ {}), descendants: true });
+    selfs = contentChildren(RouteSelf, { ...(ngDevMode ? { debugName: "selfs" } : /* istanbul ignore next */ {}), descendants: true });
     notFounds = contentChildren(RouteNotFound, { ...(ngDevMode ? { debugName: "notFounds" } : /* istanbul ignore next */ {}), descendants: true });
     activeTemplate = computed(() => {
         const snapshot = this.routeState();
@@ -492,6 +882,16 @@ class RouteView {
                 return match.templateRef;
             }
         }
+        // Self has priority over NotFound. First-wins to mirror NotFound's
+        // last-wins inversion would be inconsistent with React/Preact/Solid/Vue
+        // adapters where Self is "first wins"; Angular's contentChildren returns
+        // declaration order, so picking [0] gives first-wins.
+        if (routeName === this.nodeName()) {
+            const first = this.selfs().at(0);
+            if (first) {
+                return first.templateRef;
+            }
+        }
         if (routeName === UNKNOWN_ROUTE) {
             const last = this.notFounds().at(-1);
             if (last) {
@@ -525,7 +925,7 @@ class RouteView {
         });
     }
     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: `
+    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: "selfs", predicate: RouteSelf, descendants: true, isSignal: true }, { propertyName: "notFounds", predicate: RouteNotFound, descendants: true, isSignal: true }], ngImport: i0, template: `
     @if (activeTemplate()) {
       <ng-container [ngTemplateOutlet]="activeTemplate()!" />
     }
@@ -542,7 +942,7 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.8", ngImpor
   `,
                     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 }] }] } });
+        }], propDecorators: { nodeName: [{ type: i0.Input, args: [{ isSignal: true, alias: "routeNode", required: false }] }], matches: [{ type: i0.ContentChildren, args: [i0.forwardRef(() => RouteMatch), { ...{ descendants: true }, isSignal: true }] }], selfs: [{ type: i0.ContentChildren, args: [i0.forwardRef(() => RouteSelf), { ...{ 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 */ []));
@@ -731,5 +1131,5 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.8", ngImpor
  * 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 };
+export { NAVIGATOR, NavigationAnnouncer, ROUTE, ROUTER, RealLink, RealLinkActive, RouteMatch, RouteNotFound, RouteSelf, RouteView, RouterErrorBoundary, injectIsActiveRoute, injectNavigator, injectRoute, injectRouteEnter, injectRouteExit, injectRouteNode, injectRouteUtils, injectRouter, injectRouterTransition, provideRealRouter, sourceToSignal };
 //# sourceMappingURL=real-router-angular.mjs.map