@real-router/angular 0.8.0 → 0.9.0

package/dist/types/real-router-angular-ssr.d.ts

@@ -0,0 +1,227 @@
+import * as i0 from '@angular/core';
+import { TemplateRef, OnInit, Signal, InjectionToken, EnvironmentProviders } from '@angular/core';
+
+declare class ClientOnly {
+    readonly fallback: i0.InputSignal<TemplateRef<unknown> | undefined>;
+    readonly mounted: i0.WritableSignal<boolean>;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<ClientOnly, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ClientOnly, "client-only", never, { "fallback": { "alias": "fallback"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+declare class ServerOnly {
+    readonly fallback: i0.InputSignal<TemplateRef<unknown> | undefined>;
+    readonly mounted: i0.WritableSignal<boolean>;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<ServerOnly, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ServerOnly, "server-only", never, { "fallback": { "alias": "fallback"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+/**
+ * Render-time HTTP status declaration. Mount inside a route component
+ * (typical use case: a glob `*` route's NotFound page) when the status is
+ * decided by the rendered tree rather than a loader.
+ *
+ * Writes `code` to the optionally injected `HTTP_STATUS_SINK` in `ngOnInit`
+ * (after the input binding has fired) and renders nothing. Without a provider
+ * registered (the standard client-side case) the component is a silent no-op
+ * — same component tree hydrates without touching the DOM or warning about
+ * mismatches.
+ *
+ * Loader-driven errors (`LoaderNotFound` → 404, `LoaderRedirect` → 30x) keep
+ * working as before; this component covers render-time decisions only.
+ *
+ * Last write wins when several `<http-status-code />` instances mount in the
+ * same render pass — sink reflects the last component whose `ngOnInit` ran.
+ *
+ * ```ts
+ * // entry-server.ts
+ * import { bootstrapApplication } from "@angular/platform-browser";
+ * import {
+ *   createHttpStatusSink,
+ *   provideHttpStatusSink,
+ * } from "@real-router/angular/ssr";
+ *
+ * const sink = createHttpStatusSink();
+ * await bootstrapApplication(AppRoot, {
+ *   providers: [
+ *     provideRealRouterFactory({ ... }),
+ *     provideHttpStatusSink(sink),
+ *   ],
+ * });
+ * response.status(sink.code ?? 200).send(html);
+ * ```
+ *
+ * ```html
+ * <!-- inside not-found.component.ts template -->
+ * <http-status-code [code]="404" />
+ * ```
+ *
+ * **Per-request wiring with `AngularNodeAppEngine`:** the sink must be
+ * passed via the second arg of `handle(req, requestContext)` — Angular
+ * surfaces it through the `REQUEST_CONTEXT` token. Attaching to `req`
+ * directly does NOT work: `AngularNodeAppEngine.handle` constructs a fresh
+ * Web `Request` from the Express `IncomingMessage` and discards every
+ * custom property. See the `ssr/` example's `app.config.ts` factory for
+ * the canonical pattern (`inject(REQUEST_CONTEXT, { optional: true })`
+ * → `(ctx as { httpStatusSink? } | null)?.httpStatusSink`).
+ *
+ * **`@angular/ssr` streaming + `@defer` blocks:** `@defer` blocks hydrate
+ * lazily on the client; their server-side rendering is fully synchronous,
+ * so `<http-status-code />` inside or outside a `@defer` writes to the
+ * sink before `AngularNodeAppEngine.handle` resolves. No streaming
+ * ordering concern in Angular's current SSR model.
+ *
+ * **JIT vs AOT:** the `code` input is declared as `input<number>()` (not
+ * `input.required<number>()`) because `input.required` trips `NG0950` in
+ * JIT/TestBed even after `componentRef.setInput(...)`. `ngOnInit` skips
+ * the write when `code()` is `undefined`. AOT (production build) binds
+ * the value normally and the skip never fires.
+ *
+ * **Valid `code` range:** Node's `res.end()` throws `Invalid status code`
+ * on `NaN`, `0`, negative values, or values `> 999` — this surfaces as a
+ * 5xx / dropped connection, not silent corruption. Pass a real HTTP status
+ * integer (commonly 4xx/5xx; 100-999 is what Node accepts).
+ */
+declare class HttpStatusCode implements OnInit {
+    /**
+     * HTTP status to apply to the response. Common values: 404, 410, 451, 503.
+     *
+     * Declared as optional so the signal is safe to read in `ngOnInit` under
+     * both AOT (template binding fires before init hooks) and JIT/TestBed
+     * (`componentRef.setInput("code", N)` writes the value before the first
+     * change detection). `input.required` would trip `NG0950` in the JIT path
+     * because the required-flag is asserted independently of the runtime
+     * value. Consumers should always pass a value — `undefined` makes
+     * `ngOnInit` skip the sink write rather than throw.
+     */
+    readonly code: i0.InputSignal<number | undefined>;
+    private readonly sink;
+    ngOnInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HttpStatusCode, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<HttpStatusCode, "http-status-code", never, { "code": { "alias": "code"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Read a deferred promise published by `defer({ deferred: { <key>: Promise } })`
+ * inside an SSR data loader. Returns an Angular `Signal<T | undefined>` that
+ * tracks the active route — re-keying picks up the new state's deferred map.
+ *
+ * The signal starts `undefined` and updates to the resolved value once the
+ * promise settles. Use with native Angular control flow:
+ *
+ * ```ts
+ * @Component({
+ *   template: `
+ *     @if (reviews()) {
+ *       <ul>
+ *         @for (r of reviews(); track r.id) {
+ *           <li>{{ r.author }}</li>
+ *         }
+ *       </ul>
+ *     } @else {
+ *       <p>Loading reviews…</p>
+ *     }
+ *   `,
+ * })
+ * export class Reviews {
+ *   readonly reviews = injectDeferred<Review[]>("reviews");
+ * }
+ * ```
+ *
+ * **Asymmetric Angular** (see `.claude/SSR_FEATURE_GAPS_RU.md` §8): Angular
+ * does not ship `<Await>` / `<Streamed>` adapter components — Angular has no
+ * direct analogue to React's `use(promise)` or Svelte's `{#await}`. Use
+ * `@if (signal()) { … } @else { … }` or the `async` pipe with
+ * `from(deferredPromise)` instead.
+ */
+declare function injectDeferred<T = unknown>(key: string): Signal<T | undefined>;
+
+/**
+ * Render-scoped HTTP status sink. Created per request on the server and
+ * provided via `provideHttpStatusSink(sink)` (or directly through
+ * `{ provide: HTTP_STATUS_SINK, useValue: sink }`). Read after the SSR pass
+ * (`renderApplication` / `AngularNodeAppEngine` rendering) to apply the value
+ * to the HTTP response.
+ *
+ * Last write wins: if the rendered tree mounts more than one
+ * `<http-status-code [code]="N" />`, the value reflects the last component
+ * that ran during the render pass.
+ *
+ * No-op on the client — `<http-status-code />` injects `HTTP_STATUS_SINK`
+ * with `{ optional: true }` and skips the write when no provider is
+ * registered, so the same component tree can be hydrated without changing
+ * behaviour.
+ *
+ * Constraints:
+ * - **Per-request only.** Don't share a sink across requests; the rendered
+ *   tree mutates `code` in place. Module-level singletons leak status
+ *   between concurrent requests.
+ * - **Don't `Object.freeze` the sink.** The component writes to `.code`;
+ *   freezing makes the assignment throw under ESM strict mode.
+ * - **Pass through `REQUEST_CONTEXT`, not via `req` properties.** Wire the
+ *   sink with `angularApp.handle(req, { httpStatusSink })` and read it back
+ *   in the `HTTP_STATUS_SINK` factory via `inject(REQUEST_CONTEXT)`.
+ *   `AngularNodeAppEngine` builds a fresh Web `Request` from the
+ *   `IncomingMessage` and discards every custom property, so attaching to
+ *   `req` directly silently no-ops.
+ */
+interface HttpStatusSink {
+    code: number | undefined;
+}
+declare function createHttpStatusSink(): HttpStatusSink;
+/**
+ * DI token for the request-scoped HTTP status sink. Application-side wiring:
+ *
+ * ```ts
+ * import { bootstrapApplication } from "@angular/platform-browser";
+ * import { provideHttpStatusSink, createHttpStatusSink } from "@real-router/angular/ssr";
+ *
+ * const sink = createHttpStatusSink();
+ *
+ * await bootstrapApplication(AppRoot, {
+ *   providers: [
+ *     provideRealRouterFactory({ ... }),
+ *     provideHttpStatusSink(sink),
+ *   ],
+ * });
+ *
+ * response.status(sink.code ?? 200).send(html);
+ * ```
+ */
+declare const HTTP_STATUS_SINK: InjectionToken<HttpStatusSink>;
+
+/**
+ * Environment providers for a request-scoped `HttpStatusSink`. Pair with
+ * `createHttpStatusSink()` and read `sink.code` after the SSR render pass
+ * completes.
+ *
+ * Application bootstrap:
+ *
+ * ```ts
+ * const sink = createHttpStatusSink();
+ *
+ * await bootstrapApplication(AppRoot, {
+ *   providers: [
+ *     provideRealRouterFactory({ ... }),
+ *     provideHttpStatusSink(sink),
+ *   ],
+ * });
+ *
+ * response.status(sink.code ?? 200).send(html);
+ * ```
+ *
+ * Equivalent to:
+ *
+ * ```ts
+ * { provide: HTTP_STATUS_SINK, useValue: sink }
+ * ```
+ *
+ * Use the explicit `useValue` form when you need to compose with other
+ * application providers in a single `providers: [...]` block.
+ */
+declare function provideHttpStatusSink(sink: HttpStatusSink): EnvironmentProviders;
+
+export { ClientOnly, HTTP_STATUS_SINK, HttpStatusCode, ServerOnly, createHttpStatusSink, injectDeferred, provideHttpStatusSink };
+export type { HttpStatusSink };
+//# sourceMappingURL=real-router-angular-ssr.d.ts.map

package/dist/types/real-router-angular-ssr.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"real-router-angular-ssr.d.ts","sources":["../../ssr/components/ClientOnly.ts","../../ssr/components/ServerOnly.ts","../../ssr/components/HttpStatusCode.ts","../../ssr/functions/injectDeferred.ts","../../ssr/utils/createHttpStatusSink.ts","../../ssr/functions/provideHttpStatusSink.ts"],"mappings":";;;AAKA,cAWa,UAAU;uBACJA,EAAA,CAAA,WAAA,CAAA,WAAA;sBAEDA,EAAA,CAAA,cAAA;;yCAHL,UAAU;2CAAV,UAAU;AAUtB;;ACrBD,cAWa,UAAU;uBACJA,EAAA,CAAA,WAAA,CAAA,WAAA;sBAEDA,EAAA,CAAA,cAAA;;yCAHL,UAAU;2CAAV,UAAU;AAUtB;;ACpBD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAiEG;AACH,cAIa,cAAe,YAAW,MAAM;AAC3C;;;;;;;;;;AAUG;mBACUA,EAAA,CAAA,WAAA;AAIb;AAEA;yCAlBW,cAAc;2CAAd,cAAc;AA6B1B;;ACzFD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAgCG;AACH,iBAAgB,cAAc,4BAE3B,MAAM;;ACjDT;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA4BG;UACc,cAAc;AAC7B;AACD;AAED,iBAAgB,oBAAoB,IAAI,cAAc;AAItD;;;;;;;;;;;;;;;;;;AAkBG;AACH,cAAa,gBAAgB,EAAA,cAAA,CAAA,cAAA;;ACnD7B;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA4BG;AACH,iBAAgB,qBAAqB,OAC7B,cAAc,GACnB,oBAAoB;;;;","names":["_angular_core"]}

package/dist/types/real-router-angular.d.ts

@@ -1,7 +1,7 @@
 import * as _real_router_types from '@real-router/types';
 import * as _angular_core from '@angular/core';
-import { Signal, InjectionToken, EnvironmentProviders, TemplateRef, OnInit } from '@angular/core';
-import { Params, Navigator, Router, State, RouterError, NavigationOptions } from '@real-router/core';
+import { Signal, InjectionToken, EnvironmentProviders, TemplateRef } from '@angular/core';
+import { RouterError, Params, Navigator, Router, DefaultDependencies, PluginFactory, State, NavigationOptions } from '@real-router/core';
 export { Navigator } from '@real-router/core';
 import { RouteSnapshot, RouterSource, RouterTransitionSnapshot } from '@real-router/sources';
 export { RouteSnapshot, RouterErrorSnapshot, RouterTransitionSnapshot } from '@real-router/sources';
@@ -39,6 +39,10 @@ interface RouteSignals<P extends Params = Params> {
     readonly routeState: Signal<RouteSnapshot<P>>;
     readonly navigator: Navigator;
 }
+interface ErrorContext {
+    $implicit: RouterError;
+    resetError: () => void;
+}
 
 declare const ROUTER: InjectionToken<Router<object>>;
 declare const NAVIGATOR: InjectionToken<Navigator>;
@@ -49,6 +53,102 @@ interface RealRouterOptions {
 }
 declare function provideRealRouter(router: Router, options?: RealRouterOptions): EnvironmentProviders;
 
+/**
+ * Factory function for deriving per-request dependencies from an SSR `Request`.
+ *
+ * - **Server:** receives the real `Request` exposed via Angular's `REQUEST` token.
+ * - **SSG:** receives a mocked `Request` injected via `platformProviders`.
+ * - **Client:** receives `null` — derive deps from `document.cookie` etc.
+ *
+ * The returned object becomes the second argument to
+ * `cloneRouter(baseRouter, deps)`. Returning `undefined` clones the router with
+ * no extra deps (cloneRouter accepts the optional 2nd argument).
+ */
+type RequestDepsFactory<TDeps extends DefaultDependencies = DefaultDependencies> = (request: Request | null) => TDeps | undefined;
+/**
+ * Function form for conditional plugins (different sets server vs client).
+ *
+ * Use this when the plugin set must differ — typically because some plugins
+ * (e.g. `browser-plugin`, `navigation-plugin`, `hash-plugin`) touch
+ * `window.history` / `window.location` and cannot run on the server.
+ */
+type RequestPluginsFactory<TDeps extends DefaultDependencies = DefaultDependencies> = (request: Request | null) => readonly PluginFactory<TDeps>[];
+interface RealRouterFactoryOptions<TDeps extends DefaultDependencies = DefaultDependencies> {
+    /**
+     * Base router instance — created once at app bootstrap (typically inside
+     * `app.config.ts` module scope). Each request clones this router via
+     * `cloneRouter(baseRouter, deps?.(request))`, producing an isolated
+     * router with its own state, plugins, and subscriptions.
+     *
+     * **Important:** the `baseRouter` MUST NOT be started ahead of time —
+     * `provideAppInitializer` is responsible for calling `router.start(url)`
+     * inside the per-request DI scope.
+     */
+    baseRouter: Router<TDeps>;
+    /**
+     * Plugins applied to every per-request router clone.
+     *
+     * **Static form** — same plugins on both sides:
+     * ```ts
+     * plugins: [ssrDataPluginFactory(loaders)]
+     * ```
+     *
+     * **Function form** — conditional client vs server (recommended when any
+     * browser-only plugin is involved):
+     * ```ts
+     * plugins: (request) => request
+     *   ? [ssrDataPluginFactory(loaders)]
+     *   : [browserPluginFactory(), ssrDataPluginFactory(loaders)],
+     * ```
+     *
+     * Function form is required if the plugin list contains
+     * `browser-plugin`, `navigation-plugin`, or `hash-plugin` — those plugins
+     * read `window.history` / `window.location` and crash on the server.
+     */
+    plugins?: readonly PluginFactory<TDeps>[] | RequestPluginsFactory<TDeps>;
+    /**
+     * Derive request-scoped deps (e.g. `currentUser` from cookies). The result
+     * is passed to `cloneRouter(baseRouter, deps)` and merged with any deps
+     * already registered on the base router.
+     *
+     * Receives `request: Request | null`:
+     * - non-null on server (real `Request` from `@angular/ssr` runtime)
+     * - non-null on SSG (mocked `Request` via `platformProviders`)
+     * - null on client (derive deps externally — e.g. parse `document.cookie`)
+     */
+    deps?: RequestDepsFactory<TDeps>;
+    /** Optional scroll restoration — same semantics as `provideRealRouter`. */
+    scrollRestoration?: ScrollRestorationOptions;
+    /** Optional view transitions — same semantics as `provideRealRouter`. */
+    viewTransitions?: boolean;
+}
+/**
+ * `provideRealRouterFactory` — environment providers for SSR / SSG scenarios.
+ *
+ * Unlike `provideRealRouter(router)` (single instance via `useValue`), this
+ * factory uses `useFactory` to produce a per-request router clone:
+ *
+ * 1. Reads Angular's `REQUEST` token (`{ optional: true }`).
+ * 2. Calls `cloneRouter(baseRouter, deps?.(request))` to create a request-scoped clone.
+ * 3. Applies plugins (`plugins` array or `plugins(request)` factory).
+ * 4. Registers `provideAppInitializer` that calls `await router.start(url)`.
+ * 5. Schedules `router.dispose()` via `DestroyRef.onDestroy` — the request
+ *    Injector is destroyed after the response is sent, releasing all
+ *    subscriptions and plugins.
+ *
+ * Use cases:
+ * - Angular SSR with `@angular/ssr` (`outputMode: "server"`).
+ * - SSG build-time render via `renderApplication` + `platformProviders` `REQUEST` mock.
+ * - Multi-tenant request-scoped routing.
+ *
+ * Existing single-instance scenarios (SPA, SSG client after hydration) continue
+ * to use `provideRealRouter(router)` — both APIs ship in parallel.
+ *
+ * @param options - Factory configuration — see `RealRouterFactoryOptions`.
+ * @returns `EnvironmentProviders` to spread into `ApplicationConfig.providers`.
+ */
+declare function provideRealRouterFactory<TDeps extends DefaultDependencies = DefaultDependencies>(options: RealRouterFactoryOptions<TDeps>): EnvironmentProviders;
+
 /** Must be called within an injection context (constructor, field initializer, runInInjectionContext). */
 declare function sourceToSignal<T>(source: RouterSource<T>): Signal<T>;
 
@@ -56,11 +156,12 @@ declare function injectRouter(): Router;
 
 declare function injectNavigator(): Navigator;
 
-declare function injectRoute<P extends Params = Params>(): Omit<RouteSignals<P>, "routeState"> & {
+type NonNullRouteSignals<P extends Params> = Omit<RouteSignals<P>, "routeState"> & {
     readonly routeState: Signal<Omit<RouteSnapshot<P>, "route"> & {
         route: State<P>;
     }>;
 };
+declare function injectRoute<P extends Params = Params>(): NonNullRouteSignals<P>;
 
 declare function injectRouteNode(nodeName: string): RouteSignals;
 
@@ -252,25 +353,22 @@ declare class RouteSelf {
     static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RouteSelf, "ng-template[routeSelf]", never, {}, {}, never, never, true, never>;
 }
 
-declare class RouteView implements OnInit {
+declare class RouteView {
     readonly nodeName: _angular_core.InputSignal<string>;
     readonly matches: _angular_core.Signal<readonly RouteMatch[]>;
     readonly selfs: _angular_core.Signal<readonly RouteSelf[]>;
     readonly notFounds: _angular_core.Signal<readonly RouteNotFound[]>;
     readonly activeTemplate: _angular_core.Signal<TemplateRef<unknown> | null>;
-    private readonly matchEntries;
     private readonly router;
-    private readonly destroyRef;
     private readonly routeState;
-    ngOnInit(): void;
+    private readonly matchEntries;
+    private readonly matchedTemplate;
+    private readonly fallbackTemplate;
+    constructor();
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<RouteView, never>;
     static ɵcmp: _angular_core.ɵɵComponentDeclaration<RouteView, "route-view", never, { "nodeName": { "alias": "routeNode"; "required": false; "isSignal": true; }; }, {}, ["matches", "selfs", "notFounds"], never, true, never>;
 }
 
-interface ErrorContext {
-    $implicit: RouterError;
-    resetError: () => void;
-}
 declare class RouterErrorBoundary {
     readonly errorTemplate: _angular_core.InputSignal<TemplateRef<ErrorContext> | undefined>;
     readonly onError: _angular_core.OutputEmitterRef<{
@@ -293,7 +391,7 @@ declare class NavigationAnnouncer {
     static ɵcmp: _angular_core.ɵɵComponentDeclaration<NavigationAnnouncer, "navigation-announcer", never, {}, {}, never, never, true, never>;
 }
 
-declare class RealLink implements OnInit {
+declare class RealLink {
     readonly routeName: _angular_core.InputSignal<string>;
     readonly routeParams: _angular_core.InputSignal<Params>;
     readonly routeOptions: _angular_core.InputSignal<NavigationOptions>;
@@ -308,35 +406,36 @@ declare class RealLink implements OnInit {
      */
     readonly hash: _angular_core.InputSignal<string | undefined>;
     private readonly router;
-    private readonly destroyRef;
     private readonly anchor;
     private readonly isActive;
     private readonly href;
     private prevActiveClass;
-    ngOnInit(): void;
+    private prevHref;
+    private prevActive;
+    constructor();
     onClick(event: MouseEvent): void;
-    private updateDom;
+    private updateHref;
+    private updateActiveClass;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<RealLink, never>;
     static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RealLink, "a[realLink]", never, { "routeName": { "alias": "routeName"; "required": false; "isSignal": true; }; "routeParams": { "alias": "routeParams"; "required": false; "isSignal": true; }; "routeOptions": { "alias": "routeOptions"; "required": false; "isSignal": true; }; "activeClassName": { "alias": "activeClassName"; "required": false; "isSignal": true; }; "activeStrict": { "alias": "activeStrict"; "required": false; "isSignal": true; }; "ignoreQueryParams": { "alias": "ignoreQueryParams"; "required": false; "isSignal": true; }; "hash": { "alias": "hash"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 
-declare class RealLinkActive implements OnInit {
+declare class RealLinkActive {
     readonly realLinkActive: _angular_core.InputSignal<string>;
     readonly routeName: _angular_core.InputSignal<string>;
     readonly routeParams: _angular_core.InputSignal<Params>;
     readonly activeStrict: _angular_core.InputSignal<boolean>;
     readonly ignoreQueryParams: _angular_core.InputSignal<boolean>;
     private readonly router;
-    private readonly destroyRef;
     private readonly element;
     private readonly isActive;
+    private prevActive;
     constructor();
-    ngOnInit(): void;
     private updateClass;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<RealLinkActive, never>;
     static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RealLinkActive, "[realLinkActive]", never, { "realLinkActive": { "alias": "realLinkActive"; "required": false; "isSignal": true; }; "routeName": { "alias": "routeName"; "required": false; "isSignal": true; }; "routeParams": { "alias": "routeParams"; "required": false; "isSignal": true; }; "activeStrict": { "alias": "activeStrict"; "required": false; "isSignal": true; }; "ignoreQueryParams": { "alias": "ignoreQueryParams"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 
-export { NAVIGATOR, NavigationAnnouncer, ROUTE, ROUTER, RealLink, RealLinkActive, RouteMatch, RouteNotFound, RouteSelf, RouteView, RouterErrorBoundary, injectIsActiveRoute, injectNavigator, injectRoute, injectRouteEnter, injectRouteExit, injectRouteNode, injectRouteUtils, injectRouter, injectRouterTransition, provideRealRouter, sourceToSignal };
-export type { ErrorContext, RouteEnterContext, RouteEnterHandler, RouteExitContext, RouteExitHandler, RouteSignals, UseRouteEnterOptions, UseRouteExitOptions };
+export { NAVIGATOR, NavigationAnnouncer, ROUTE, ROUTER, RealLink, RealLinkActive, RouteMatch, RouteNotFound, RouteSelf, RouteView, RouterErrorBoundary, injectIsActiveRoute, injectNavigator, injectRoute, injectRouteEnter, injectRouteExit, injectRouteNode, injectRouteUtils, injectRouter, injectRouterTransition, provideRealRouter, provideRealRouterFactory, sourceToSignal };
+export type { ErrorContext, RealRouterFactoryOptions, RealRouterOptions, RequestDepsFactory, RequestPluginsFactory, RouteEnterContext, RouteEnterHandler, RouteExitContext, RouteExitHandler, RouteSignals, UseRouteEnterOptions, UseRouteExitOptions };
 //# sourceMappingURL=real-router-angular.d.ts.map

package/dist/types/real-router-angular.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"real-router-angular.d.ts","sources":["../../src/dom-utils/scroll-restore.ts","../../src/types.ts","../../src/providers.ts","../../src/sourceToSignal.ts","../../src/functions/injectRouter.ts","../../src/functions/injectNavigator.ts","../../src/functions/injectRoute.ts","../../src/functions/injectRouteNode.ts","../../src/functions/injectRouteUtils.ts","../../src/functions/injectRouterTransition.ts","../../src/functions/injectIsActiveRoute.ts","../../src/functions/injectRouteExit.ts","../../src/functions/injectRouteEnter.ts","../../src/directives/RouteMatch.ts","../../src/directives/RouteNotFound.ts","../../src/directives/RouteSelf.ts","../../src/components/RouteView.ts","../../src/components/RouterErrorBoundary.ts","../../src/components/NavigationAnnouncer.ts","../../src/directives/RealLink.ts","../../src/directives/RealLinkActive.ts"],"mappings":"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","names":[]}
+{"version":3,"file":"real-router-angular.d.ts","sources":["../../src/dom-utils/scroll-restore.ts","../../src/types.ts","../../src/providers.ts","../../src/providersFactory.ts","../../src/sourceToSignal.ts","../../src/functions/injectRouter.ts","../../src/functions/injectNavigator.ts","../../src/functions/injectRoute.ts","../../src/functions/injectRouteNode.ts","../../src/functions/injectRouteUtils.ts","../../src/functions/injectRouterTransition.ts","../../src/functions/injectIsActiveRoute.ts","../../src/functions/injectRouteExit.ts","../../src/functions/injectRouteEnter.ts","../../src/directives/RouteMatch.ts","../../src/directives/RouteNotFound.ts","../../src/directives/RouteSelf.ts","../../src/components/RouteView.ts","../../src/components/RouterErrorBoundary.ts","../../src/components/NavigationAnnouncer.ts","../../src/directives/RealLink.ts","../../src/directives/RealLinkActive.ts"],"mappings":"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","names":[]}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@real-router/angular",
-  "version": "0.8.0",
+  "version": "0.9.0",
   "type": "commonjs",
   "description": "Angular 21 integration for Real-Router",
   "exports": {
@@ -8,11 +8,17 @@
       "@real-router/internal-source": "./src/index.ts",
       "types": "./dist/types/real-router-angular.d.ts",
       "default": "./dist/fesm2022/real-router-angular.mjs"
+    },
+    "./ssr": {
+      "@real-router/internal-source": "./ssr/public_api.ts",
+      "types": "./dist/types/real-router-angular-ssr.d.ts",
+      "default": "./dist/fesm2022/real-router-angular-ssr.mjs"
     }
   },
   "files": [
     "dist",
-    "src"
+    "src",
+    "ssr"
   ],
   "homepage": "https://github.com/greydragon888/real-router",
   "repository": {
@@ -35,19 +41,19 @@
   "license": "MIT",
   "sideEffects": false,
   "dependencies": {
-    "@real-router/core": "^0.51.0",
+    "@real-router/core": "^0.53.0",
     "@real-router/route-utils": "^0.2.2",
-    "@real-router/sources": "^0.8.0"
+    "@real-router/sources": "^0.8.2"
   },
   "devDependencies": {
     "@analogjs/vitest-angular": "2.4.7",
-    "@angular/common": "21.2.8",
-    "@angular/compiler": "21.2.8",
-    "@angular/compiler-cli": "21.2.8",
-    "@angular/core": "21.2.8",
-    "@angular/platform-browser": "21.2.8",
+    "@angular/common": "21.2.9",
+    "@angular/compiler": "21.2.9",
+    "@angular/compiler-cli": "21.2.9",
+    "@angular/core": "21.2.9",
+    "@angular/platform-browser": "21.2.9",
     "ng-packagr": "21.2.2",
-    "typescript": "6.0.2"
+    "typescript": "6.0.3"
   },
   "peerDependencies": {
     "@angular/common": ">=21.0.0",
@@ -55,9 +61,10 @@
   },
   "scripts": {
     "test": "vitest",
+    "test:properties": "vitest run --config vitest.config.properties.mts",
     "test:stress": "vitest -c vitest.config.stress.mts",
     "type-check": "tsc --noEmit",
-    "lint": "eslint --cache src/ tests/ --fix --max-warnings 0",
+    "lint": "eslint --cache src/ ssr/ tests/ --fix --max-warnings 0",
     "prebundle": "node scripts/sync-dom-utils.mjs",
     "bundle": "ng-packagr -p ng-package.json -c tsconfig.lib.json"
   }