@mmstack/router-core 19.3.13 → 19.3.15

package/lib/nav/nav-store.d.ts

@@ -0,0 +1,42 @@
+import { type Signal } from '@angular/core';
+import { type InternalNavItem, type NavItem } from './nav';
+import * as i0 from "@angular/core";
+/** @internal */
+export declare const DEFAULT_NAV_SCOPE: unique symbol;
+type ScopeName = string | typeof DEFAULT_NAV_SCOPE;
+type AnyInternalNavItem = InternalNavItem<unknown>;
+export declare class NavStore {
+    private readonly map;
+    private readonly leafRoutes;
+    /** @internal */
+    register(scope: ScopeName, routePath: string, items: AnyInternalNavItem[]): void;
+    /** @internal */
+    scope<TMeta = Record<string, unknown>>(name: ScopeName): Signal<NavItem<TMeta>[]>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NavStore, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<NavStore>;
+}
+/**
+ * Returns a reactive list of nav items for the requested scope.
+ *
+ * The returned signal reflects the nearest active ancestor route that registered items
+ * for `name` via `createNavItems`. Hidden items are filtered out.
+ *
+ * @typeParam TMeta The shape of `NavItem.meta` for the consuming code. Untyped at the
+ * registration site — this is a consumer-side assertion.
+ *
+ * @example
+ * ```typescript
+ * @Component({
+ *   template: `
+ *     @for (item of items(); track item) {
+ *       <a [href]="item.link()" [class.active]="item.active()">{{ item.label() }}</a>
+ *     }
+ *   `,
+ * })
+ * export class TopBar {
+ *   protected readonly items = injectNavItems();
+ * }
+ * ```
+ */
+export declare function injectNavItems<TMeta = Record<string, unknown>>(name?: string): Signal<NavItem<TMeta>[]>;
+export {};

package/lib/nav/nav.d.ts

@@ -0,0 +1,88 @@
+import { type Signal } from '@angular/core';
+import { type ActivatedRouteSnapshot, type IsActiveMatchOptions, type Router } from '@angular/router';
+/**
+ * Description of a single navigation item.
+ *
+ * Reactive fields accept either a static value or a zero-arg function — the function
+ * form is wrapped in a `computed` so reading signals inside it produces a reactive value.
+ *
+ * @typeParam TMeta Arbitrary consumer-defined metadata round-tripped to {@link NavItem.meta}.
+ *
+ * @see createNavItems
+ * @see NavItem
+ */
+export type CreateNavItem<TMeta = Record<string, unknown>> = {
+    /** Visible text. */
+    label: string | (() => string);
+    /**
+     * The navigation target. Resolved relative to the route the resolver is attached to —
+     * the same convention as Angular's `routerLink`:
+     *
+     * - `'a'` / `'a/b'` / `['a', 'b']` — relative segments, resolve to `${mount}/a` etc.
+     * - `'/foo'` / `['/foo', 'bar']` — absolute, leading-slash escape hatch.
+     * - A pre-built `UrlTree` is passed through unchanged.
+     *
+     * Omit (or return `null`) for a pure grouping header — `active` will then fall through
+     * to the children-active check.
+     */
+    link?: string | any[] | (() => string | any[] | null) | null;
+    /** Accessible label. Defaults to `label`. */
+    ariaLabel?: string | (() => string);
+    /** When true, the item is rendered but non-interactive. Cascades to descendants. */
+    disabled?: boolean | (() => boolean);
+    /** When true, the item (and its subtree) is filtered out of the consumer-facing array. */
+    hidden?: boolean | (() => boolean);
+    /** Arbitrary metadata round-tripped on the resulting `NavItem`. */
+    meta?: TMeta | (() => TMeta);
+    /**
+     * Override the match options used to compute `active`. Merged on top of the global default
+     * from `provideNavConfig`, which is in turn merged on top of `@angular/router`'s
+     * `subsetMatchOptions` defaults.
+     *
+     * Setting this also implicitly disables the default child-active OR — see
+     * {@link matchesWhenChildActive} to opt back in.
+     */
+    activeMatch?: Partial<IsActiveMatchOptions>;
+    /**
+     * Controls whether `active` ORs with descendant `active`.
+     *
+     * Default: `true` when `activeMatch` is omitted, `false` when `activeMatch` is set.
+     * Explicit values override the default.
+     */
+    matchesWhenChildActive?: boolean;
+    /** Optional stable id. Defaults to the serialized link when present. */
+    id?: string | (() => string);
+    /** Nested items. */
+    children?: CreateNavItem<TMeta>[];
+};
+/**
+ * A navigation item exposed by `injectNavItems`. All fields are signals so consumers can
+ * read reactively without caring whether the source was static or signal-derived.
+ *
+ * @typeParam TMeta Same as the corresponding {@link CreateNavItem}.
+ */
+export type NavItem<TMeta = Record<string, unknown>> = {
+    id: Signal<string>;
+    label: Signal<string>;
+    ariaLabel: Signal<string>;
+    /** Serialized URL, or `null` for pure grouping items with no link. */
+    link: Signal<string | null>;
+    active: Signal<boolean>;
+    disabled: Signal<boolean>;
+    meta: Signal<TMeta>;
+    /** Children that survive the hidden filter. */
+    children: Signal<NavItem<TMeta>[]>;
+};
+/** @internal */
+export type InternalNavItem<TMeta = Record<string, unknown>> = NavItem<TMeta> & {
+    hidden: Signal<boolean>;
+};
+/** @internal */
+export declare const NEVER_TRUE: Signal<boolean>;
+/**
+ * @internal
+ * Recursively builds an {@link InternalNavItem} tree from {@link CreateNavItem} input.
+ * Cascades parent `disabled`/`hidden` to descendants and computes `active` against the
+ * current router URL using `Router.isActive`.
+ */
+export declare function createInternalNavItem<TMeta = Record<string, unknown>>(input: CreateNavItem<TMeta>, router: Router, relativeTo: ActivatedRouteSnapshot, configActiveMatch: Partial<IsActiveMatchOptions> | undefined, parentDisabled: Signal<boolean>, parentHidden: Signal<boolean>, fallbackId: string): InternalNavItem<TMeta>;

package/lib/nav/public_api.d.ts

@@ -0,0 +1,4 @@
+export { type CreateNavItem, type NavItem } from './nav';
+export { type NavConfig, provideNavConfig } from './nav-config';
+export { createNavItems } from './nav-resolver';
+export { injectNavItems } from './nav-store';

package/lib/query-param.d.ts

@@ -31,7 +31,6 @@ import { ActivatedRoute } from '@angular/router';
  *
  * @Component({
  * selector: 'app-product-list',
- * standalone: true,
  * // imports: [FormsModule], // If using ngModel
  * template: `
  * <div>

package/lib/title/title-config.d.ts

@@ -5,6 +5,12 @@ import { Provider } from '@angular/core';
  * @see {createTitle}
  */
 export type TitleConfig = {
+    /**
+     * The base title to fallback to, by default Title.getTitle() is called on instantiation and that is used as a fallback,
+     * which in most cases should resolve to what is in index.html, unless you specifically call Title.setTitle() before any routes,
+     * are initialized.
+     */
+    initialTitle?: string;
     /**
      * The title to be used when no title is set.
      * If not provided it defaults to an empty string
@@ -21,6 +27,7 @@ export type TitleConfig = {
  * @internal
  */
 export type InternalTitleConfig = {
+    initialTitle: string;
     parser: (title: string) => string;
     keepLastKnown: boolean;
 };

package/lib/title/title-store.d.ts

@@ -1,10 +1,8 @@
-import { Signal } from '@angular/core';
+import { type Signal } from '@angular/core';
 import { ResolveFn } from '@angular/router';
 import * as i0 from "@angular/core";
 export declare class TitleStore {
-    private readonly title;
     private readonly map;
-    private readonly leafRoutes;
     constructor();
     register(id: string, titleFn: Signal<string>): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<TitleStore, never>;
@@ -14,10 +12,10 @@ export declare class TitleStore {
  *
  * Creates a title resolver function that can be used in Angular's router.
  *
- * @param fn
- * A function that returns a string or a Signal<string> representing the title.
+ * @param factoryOrValue
+ * A function that returns a string or a Signal<string> representing the title or just the string directly.
  * @param awaitValue
  * If `true`, the resolver will wait until the title signal has a value before resolving.
  * Defaults to `false`.
  */
-export declare function createTitle(fn: () => string | (() => string), awaitValue?: boolean): ResolveFn<string>;
+export declare function createTitle(factoryOrValue: (() => string | (() => string)) | string, awaitValue?: boolean): ResolveFn<string>;

package/lib/url.d.ts

@@ -1,4 +1,5 @@
 import { type Signal } from '@angular/core';
+import { Router } from '@angular/router';
 /**
  * Creates a Signal that tracks the current router URL.
  *
@@ -29,4 +30,4 @@ import { type Signal } from '@angular/core';
  * }
  * ```
  */
-export declare function url(): Signal<string>;
+export declare function url(router?: Router): Signal<string>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mmstack/router-core",
-  "version": "19.3.13",
+  "version": "19.3.15",
   "keywords": [
     "angular",
     "signals",