ngwr 10.2.0 → 11.0.0

package/types/ngwr-context-menu.d.ts

@@ -1,4 +1,4 @@
-import * as i0 from '@angular/core';
+import * as _angular_core from '@angular/core';
 import { TemplateRef } from '@angular/core';
 
 /**
@@ -17,9 +17,9 @@ import { TemplateRef } from '@angular/core';
  */
 declare class WrContextMenuPanel {
     /** The internal template the directive portals into the overlay. @internal */
-    readonly contentTpl: i0.Signal<TemplateRef<any>>;
-    static ɵfac: i0.ɵɵFactoryDeclaration<WrContextMenuPanel, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<WrContextMenuPanel, "wr-context-menu", ["wrContextMenu"], {}, {}, never, ["*"], true, never>;
+    readonly contentTpl: _angular_core.Signal<TemplateRef<any>>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<WrContextMenuPanel, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<WrContextMenuPanel, "wr-context-menu", ["wrContextMenu"], {}, {}, never, ["*"], true, never>;
 }
 
 /**
@@ -41,13 +41,30 @@ declare class WrContextMenuPanel {
  */
 declare class WrContextMenu {
     /** Menu to open. Pass a `<wr-context-menu>` template reference. */
-    readonly menu: i0.InputSignal<WrContextMenuPanel>;
+    readonly menu: _angular_core.InputSignal<WrContextMenuPanel>;
     private readonly host;
     private readonly overlay;
     private readonly outsideClick;
     private readonly vcr;
     private readonly scrollStrategies;
     private readonly destroyRef;
+    /**
+     * Id of the menu element while this trigger's menu is open, published on the
+     * host as `aria-controls`. The pane is portalled into the overlay container, a
+     * sibling of the whole app, so this reference is the ONLY link between a
+     * trigger and the menu it opened — for a screen reader, and for anything else
+     * that has to find it. Cleared on close, which is also what tells an open
+     * trigger from a closing one: the pane itself lingers for the exit animation.
+     *
+     * A signal, not a plain field: host bindings re-run only when something they
+     * READ has changed, and this one flips outside change detection (from a
+     * pointer handler, and from `onDestroy`). Held as a plain string it published
+     * the id on open — the overlay attach happens to dirty the host view — and
+     * then kept it forever, so the trigger still pointed at a menu that was gone.
+     *
+     * @internal
+     */
+    protected readonly openMenuId: _angular_core.WritableSignal<string | null>;
     private overlayRef;
     private closingTimer;
     private leaveTimer;
@@ -120,8 +137,8 @@ declare class WrContextMenu {
     private closeOverlay;
     private cancelLeaveTimer;
     private scheduleLeave;
-    static ɵfac: i0.ɵɵFactoryDeclaration<WrContextMenu, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<WrContextMenu, "[wrContextMenu]", never, { "menu": { "alias": "wrContextMenu"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<WrContextMenu, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<WrContextMenu, "[wrContextMenu]", never, { "menu": { "alias": "wrContextMenu"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 
 /**
@@ -144,17 +161,18 @@ declare class WrContextMenu {
  */
 declare class WrContextMenuItem {
     /** Optional leading icon name. @default null */
-    readonly icon: i0.InputSignal<string | null>;
+    readonly icon: _angular_core.InputSignal<string | null>;
     /** Disable interaction (suppresses pointer + keyboard). @default false */
-    readonly disabled: i0.InputSignalWithTransform<boolean, any>;
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, any>;
     /**
      * Optional nested `<wr-context-menu>`. When set, hovering the item
      * (or pressing →) opens it to the right with a chevron indicator.
      */
-    readonly submenu: i0.InputSignal<WrContextMenuPanel | null>;
-    protected readonly classes: i0.Signal<string>;
+    readonly submenu: _angular_core.InputSignal<WrContextMenuPanel | null>;
+    protected readonly classes: _angular_core.Signal<string>;
     private readonly host;
     private readonly overlay;
+    private readonly dir;
     private readonly vcr;
     private readonly scrollStrategies;
     private readonly destroyRef;
@@ -162,6 +180,21 @@ declare class WrContextMenuItem {
     private openTimer;
     private closeTimer;
     protected submenuOpen: boolean;
+    /**
+     * Id of the submenu's menu element while it is open, published on the item as
+     * `aria-controls` — the same contract the root trigger keeps (see
+     * {@link WrContextMenu}). Each submenu pane is its own overlay in the shared
+     * container, so `aria-haspopup` / `aria-expanded` say that a submenu EXISTS
+     * and is showing, and this says WHICH one.
+     *
+     * A signal, not a plain field like `submenuOpen`: host bindings re-run only
+     * when something they read has changed, and this flips outside change
+     * detection. Writing it is also what now refreshes `aria-expanded` next to
+     * it, which used to depend on some unrelated work dirtying the view.
+     *
+     * @internal
+     */
+    protected readonly submenuId: _angular_core.WritableSignal<string | null>;
     /**
      * Global registry of open submenus keyed by the host element of the
      * item that owns them. Used to cascade-close descendants when a
@@ -190,10 +223,17 @@ declare class WrContextMenuItem {
     protected onClick(): void;
     /** @internal Keyboard activation — Enter / Space. */
     protected activate(event: Event): void;
-    /** @internal Right-arrow opens the submenu. */
+    /**
+     * @internal The arrow that walks INTO a submenu, which is the one pointing the
+     * way the menu cascades: right in LTR, left in RTL. The panes mirror with the
+     * reading direction (the CDK flips their placement), so a fixed ArrowRight
+     * would ask an RTL user to press toward the parent to open the child.
+     */
     protected onArrowRight(event: Event): void;
-    /** @internal Left-arrow closes the submenu (if open). */
+    /** @internal The arrow that walks back OUT — the mirror of {@link onArrowRight}. */
     protected onArrowLeft(event: Event): void;
+    private openFromKey;
+    private closeFromKey;
     /** @internal Hover schedules a submenu open after a small delay. */
     protected onMouseEnter(): void;
     /** @internal Hover-out schedules a close with a grace window. */
@@ -222,8 +262,16 @@ declare class WrContextMenuItem {
      */
     private relatedTargetIsInsideDescendantSubmenu;
     private disposeSubmenu;
-    static ɵfac: i0.ɵɵFactoryDeclaration<WrContextMenuItem, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<WrContextMenuItem, "wr-context-menu-item", never, { "icon": { "alias": "icon"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "submenu": { "alias": "submenu"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+    /**
+     * Whether the app reads right-to-left.
+     *
+     * Optional inject: `Directionality` is root-provided, so this is never null in
+     * an app — but a bare `TestBed` that provides nothing should still get a
+     * component that works, and defaulting to LTR is the honest fallback.
+     */
+    private isRtl;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<WrContextMenuItem, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<WrContextMenuItem, "wr-context-menu-item", never, { "icon": { "alias": "icon"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "submenu": { "alias": "submenu"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
 }
 
 /**
@@ -242,8 +290,8 @@ declare class WrContextMenuItem {
  * ```
  */
 declare class WrContextMenuDivider {
-    static ɵfac: i0.ɵɵFactoryDeclaration<WrContextMenuDivider, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<WrContextMenuDivider, "wr-context-menu-divider", never, {}, {}, never, never, true, never>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<WrContextMenuDivider, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<WrContextMenuDivider, "wr-context-menu-divider", never, {}, {}, never, never, true, never>;
 }
 
 export { WrContextMenu, WrContextMenuDivider, WrContextMenuItem, WrContextMenuPanel };

package/types/ngwr-counter.d.ts

@@ -50,7 +50,11 @@ type Cell = {
  */
 declare class WrCounter {
     /** Target value. */
-    readonly value: _angular_core.InputSignal<number>;
+    /**
+     * The number to show. Coerced like every other numeric input here — it was the only one
+     * without it, and `Intl.NumberFormat().format(NaN)` renders the literal text `NaN`.
+     */
+    readonly value: _angular_core.InputSignalWithTransform<number, unknown>;
     /** Animation mode. @default 'odometer' */
     readonly mode: _angular_core.InputSignal<WrCounterMode>;
     /** Duration (ms). @default 900 */
@@ -68,6 +72,7 @@ declare class WrCounter {
     private readonly current;
     private readonly locale;
     private readonly isBrowser;
+    private readonly platform;
     private rafId;
     /** Tween-mode formatted output. */
     protected readonly tweenText: _angular_core.Signal<string>;

package/types/ngwr-date-adapter-luxon.d.ts

@@ -35,6 +35,32 @@ declare class WrLuxonAdapter extends WrDateAdapter<DateTime> {
     addMonths(date: DateTime, amount: number): DateTime;
     addDays(date: DateTime, amount: number): DateTime;
     setTime(date: DateTime, hours: number, minutes: number, seconds: number): DateTime;
+    /**
+     * The comparison trio, all three answering the same question: what CALENDAR DAY
+     * does each value display?
+     *
+     * Field comparison rather than Luxon's own helpers, and deliberately. This
+     * adapter exists for zone-aware apps, so its values do not all share a zone —
+     * the grid is built with `createDate` in the app's zone while the selected value
+     * may arrive as `DateTime.utc()`. Two things went wrong when the zone was left
+     * in the answer:
+     *
+     * `compareDate` subtracted `startOf('day')` millis, and `startOf` respects each
+     * value's OWN zone, so two values both reading "1 August" came out three hours
+     * apart. Non-zero means "different day" to every caller — including
+     * `isWithinRange`, which the base class documents as inclusive and which
+     * therefore dropped its own endpoint.
+     *
+     * `hasSame` is the other tempting one-liner, and it asks a third question: it
+     * re-expresses one side in the other's zone and tests that instant against the
+     * day's bounds. That mostly agrees with a field comparison — but only mostly,
+     * and only in this version of luxon, whose `hasSame` keeps the local time
+     * while an earlier one kept the instant. Where a date's midnight is ambiguous
+     * or missing (Cuba rewinds 01:00 to 00:00 on 2 November 2025) the bounds stop
+     * lining up and it answers false for two values a user reads as the same date.
+     * The native adapter compares fields; agreeing with it is what keeps a
+     * calendar built on either adapter rendering the same thing.
+     */
     isSameDay(a: DateTime, b: DateTime): boolean;
     isSameMonth(a: DateTime, b: DateTime): boolean;
     compareDate(a: DateTime, b: DateTime): number;