ngwr 11.1.0 → 12.0.0

package/types/ngwr-calendar-testing.d.ts

@@ -0,0 +1,277 @@
+import { BaseHarnessFilters, ComponentHarness, HarnessPredicate } from '@angular/cdk/testing';
+import { WrCalendarMode } from 'ngwr/calendar';
+
+/**
+ * @license
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://github.com/thekhegay/ngwr/blob/main/LICENSE
+ */
+
+/** Which of the three sub-views the calendar is showing. */
+type WrCalendarView = 'day' | 'month' | 'year';
+/** One month or year chip, as the picker views render them. */
+interface WrCalendarChip {
+    /** The label as printed — a short month name, or the year. */
+    readonly label: string;
+    /** Whether it is the current selection. */
+    readonly selected: boolean;
+    /** Whether it is the month / year containing today. */
+    readonly current: boolean;
+    /** Whether `min` / `max` ruled it out. */
+    readonly disabled: boolean;
+}
+/** Narrows which `<wr-calendar>` a harness query matches. */
+interface WrCalendarHarnessFilters extends BaseHarnessFilters {
+    /** Match the header label as printed, e.g. `March 2026`. */
+    readonly headerLabel?: string | RegExp;
+    /** Match single- or range-selection calendars. */
+    readonly mode?: WrCalendarMode;
+    /** Match only enabled (`false`) or only disabled (`true`) calendars. */
+    readonly disabled?: boolean;
+}
+/** Narrows which day cell a harness query matches. */
+interface WrCalendarDayHarnessFilters extends BaseHarnessFilters {
+    /**
+     * Match the cell's day number as rendered (`'1'` … `'31'`). A string is an exact
+     * match, a RegExp is tested — note the grid spills into the neighbouring months,
+     * so most numbers appear twice.
+     */
+    readonly text?: string | RegExp;
+    /** Match only selected (`true`) or only unselected (`false`) cells. */
+    readonly selected?: boolean;
+    /** Match only enabled (`false`) or only disabled (`true`) cells. */
+    readonly disabled?: boolean;
+    /**
+     * Match cells strictly BETWEEN the two ends of a picked range — the ends
+     * themselves are `selected`, not `inRange`.
+     */
+    readonly inRange?: boolean;
+}
+
+/**
+ * @license
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://github.com/thekhegay/ngwr/blob/main/LICENSE
+ */
+
+/**
+ * Test harness for one day cell of a `<wr-calendar>` grid.
+ *
+ * The cell belongs to the calendar, and a date-picker's popup is a calendar in an
+ * overlay — so this is the harness for both, re-exported from
+ * `ngwr/date-picker/testing` under the name it shipped as
+ * (`WrDatePickerDayHarness`). Reach it through `WrCalendarHarness.getDays()`, or
+ * through `WrDatePickerHarness.getDay()` / `getDays()`, which scope it to ONE
+ * picker's panel — those cells are in the shared overlay container, so a bare query
+ * would answer with whichever picker opened first.
+ *
+ * State is read the way a screen reader reads it (`role`, `aria-selected`,
+ * `aria-disabled`) with the `.wr-calendar__day--*` modifiers filling in what
+ * ARIA has no word for: today, the spill days of the neighbouring months, and
+ * the interior of a picked range.
+ *
+ * @see https://ngwr.dev/guides/testing
+ */
+declare class WrCalendarDayHarness extends ComponentHarness {
+    static hostSelector: string;
+    /** Build a predicate that narrows the query. */
+    static with(options?: WrCalendarDayHarnessFilters): HarnessPredicate<WrCalendarDayHarness>;
+    /** The day number as rendered. */
+    getText(): Promise<string>;
+    /** The day number as a number, for mapping a list of cells to dates. */
+    getDayOfMonth(): Promise<number>;
+    /** `'gridcell'` — the cell is a button, and the grid semantics are what a spec should assert. */
+    getRole(): Promise<string | null>;
+    /** Whether this day is (one end of) the current selection. */
+    isSelected(): Promise<boolean>;
+    /**
+     * Whether the day refuses selection — `min` / `max` or `dateFilter` ruled it
+     * out, or the whole calendar is disabled.
+     */
+    isDisabled(): Promise<boolean>;
+    /** Whether the cell is today's date. */
+    isToday(): Promise<boolean>;
+    /**
+     * Whether the cell belongs to a neighbouring month. The grid is always 6x7, so
+     * every month is padded with days that are selectable but not "in" the month —
+     * which is why `WrDatePickerHarness.getDay` and {@link WrCalendarHarness.getDay} skip them.
+     */
+    isOutOfMonth(): Promise<boolean>;
+    /** Whether the day lies strictly between the two ends of a picked range. */
+    isInRange(): Promise<boolean>;
+    /**
+     * Whether this is the roving cell — the grid's single tab stop, and where the
+     * arrow keys move from.
+     *
+     * At most ONE cell answers `true`, and it is not always one: the calendar's
+     * roving date does not follow `next()` / `previous()`, so a grid navigated away
+     * from that month has no active cell (and, deliberately or not, no tab stop)
+     * until a cell is clicked or the arrows move it.
+     */
+    isActive(): Promise<boolean>;
+    /** Click the cell. A disabled cell swallows the click — assert, do not assume. */
+    click(): Promise<void>;
+}
+
+/**
+ * @license
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://github.com/thekhegay/ngwr/blob/main/LICENSE
+ */
+
+/** The arrow keys, by the direction a user would say out loud. */
+type Arrow = 'left' | 'right' | 'up' | 'down';
+/**
+ * Test harness for `<wr-calendar>` — the standalone month grid, and the one
+ * `<wr-date-picker>` puts in an overlay.
+ *
+ * **It is three views behind one header.** Clicking the header label walks
+ * `day → month → year`, and each view renders something different: a
+ * `role="grid"` of day cells, or a `role="listbox"` of chips. Every day method
+ * throws off the day view rather than answering `[]`, which would read as "this
+ * month has no days".
+ *
+ * **The roving cell is not the selection.** The grid has one tab stop and the
+ * arrows move it; it starts on the selected date, or on today when nothing is
+ * picked. And it does NOT follow {@link next} / {@link previous} — a grid paged
+ * away from the roving month has no active cell at all, and so no tab stop, until
+ * a key or a click puts one back. That is the component's behaviour, and
+ * {@link getActiveDayNumber} is how a spec sees it.
+ *
+ * **Keys go to the host, not to a cell.** The component listens on its own element,
+ * so {@link pressArrow} works whether or not jsdom managed to put real focus
+ * anywhere — which it often does not, since the calendar moves focus in an
+ * `afterNextRender` and a disabled cell cannot take it.
+ *
+ * @example
+ * ```ts
+ * const calendar = await loader.getHarness(WrCalendarHarness);
+ *
+ * expect(await calendar.getHeaderLabel()).toBe('March 2026');
+ * await (await calendar.getDay(14)).click();
+ * expect(await calendar.getSelectedDayNumbers()).toEqual([14]);
+ * ```
+ *
+ * @see https://ngwr.dev/guides/testing
+ */
+declare class WrCalendarHarness extends ComponentHarness {
+    static hostSelector: string;
+    /** Build a predicate that narrows the query — pass to `getHarness` / `getAllHarnesses`. */
+    static with(options?: WrCalendarHarnessFilters): HarnessPredicate<WrCalendarHarness>;
+    private readonly header;
+    private readonly prevButton;
+    private readonly nextButton;
+    /** Which sub-view is showing. */
+    getView(): Promise<WrCalendarView>;
+    /** Single- or range-selection, from the host modifier. */
+    getMode(): Promise<WrCalendarMode>;
+    /** Whether the whole calendar refuses interaction. */
+    isDisabled(): Promise<boolean>;
+    /** The header text — `March 2026`, `2026`, or `2016 – 2027` depending on the view. */
+    getHeaderLabel(): Promise<string>;
+    /**
+     * Click the header — stepping `day → month → year`.
+     *
+     * The year view is the end of the walk: the header is disabled there, so this
+     * throws rather than clicking a button the DOM would ignore.
+     */
+    clickHeader(): Promise<void>;
+    /**
+     * Step back — a month, a year or twelve years, depending on the view.
+     *
+     * The roving day cell does NOT come along: paging is a view change, not a
+     * navigation, and the tab stop stays on the month it was in.
+     */
+    previous(): Promise<void>;
+    /** Step forward — a month, a year or twelve years, depending on the view. */
+    next(): Promise<void>;
+    /**
+     * The back arrow's accessible name, which changes with the view — the arrows are
+     * icon-only, so this is the only name they have.
+     */
+    getPreviousLabel(): Promise<string | null>;
+    /** The forward arrow's accessible name. */
+    getNextLabel(): Promise<string | null>;
+    /** The weekday column headers, in the order the adapter's first day of week puts them. */
+    getWeekdayNames(): Promise<string[]>;
+    /**
+     * Every day cell, in DOM order — 42 of them, since the grid is always six weeks.
+     *
+     * That includes the spill days of the neighbouring months, which are selectable
+     * and not "in" the month; {@link getDay} skips them, and
+     * `WrCalendarDayHarness.isOutOfMonth()` tells them apart.
+     */
+    getDays(filters?: WrCalendarDayHarnessFilters): Promise<WrCalendarDayHarness[]>;
+    /**
+     * The cell for a day of THIS month.
+     *
+     * The number alone is ambiguous — a 42-cell grid shows most numbers twice — so
+     * the spill days are skipped rather than matched, which is what "the 3rd" means
+     * to someone reading the calendar.
+     */
+    getDay(dayOfMonth: number): Promise<WrCalendarDayHarness>;
+    /** The day numbers currently selected — one in single mode, both ends in range mode. */
+    getSelectedDayNumbers(): Promise<number[]>;
+    /** The day numbers strictly inside a picked range — never the ends. */
+    getInRangeDayNumbers(): Promise<number[]>;
+    /**
+     * The day number holding the roving tab stop, or `null` when the grid has none.
+     *
+     * `null` is a real answer, not a failure: paging with {@link next} leaves the
+     * roving date behind in another month, and the grid then has no `tabindex="0"`
+     * at all until a key or a click puts one back.
+     */
+    getActiveDayNumber(): Promise<number | null>;
+    /** The month chips, with their state. Throws off the month view. */
+    getMonths(): Promise<WrCalendarChip[]>;
+    /** The year chips, with their state. Throws off the year view. */
+    getYears(): Promise<WrCalendarChip[]>;
+    /**
+     * Click a month or year chip by its printed label — which drops the calendar back
+     * one view, the way clicking the header climbed up.
+     *
+     * Throws on the day view, where there are no chips, and on a label the view does
+     * not offer, naming what it does.
+     */
+    selectChip(label: string): Promise<void>;
+    /**
+     * Press an arrow key — one day left or right, one WEEK up or down.
+     *
+     * Sent to the host, where the component listens, so this does not depend on jsdom
+     * having managed to focus a cell. Under `dir="rtl"` the horizontal pair mirrors:
+     * ArrowRight goes back a day, because the grid itself is mirrored.
+     */
+    pressArrow(arrow: Arrow): Promise<void>;
+    /** Press Home — the first day of the roving cell's week, not of the month. */
+    pressHome(): Promise<void>;
+    /** Press End — the last day of the roving cell's week. */
+    pressEnd(): Promise<void>;
+    /** Press PageUp — a month back, or a YEAR back with `shift`. */
+    pressPageUp(options?: {
+        shift?: boolean;
+    }): Promise<void>;
+    /** Press PageDown — a month on, or a YEAR on with `shift`. */
+    pressPageDown(options?: {
+        shift?: boolean;
+    }): Promise<void>;
+    /** Press Enter — picking the roving day, exactly as clicking it would. */
+    pressEnter(): Promise<void>;
+    /**
+     * The role of the element that owns the day rows.
+     *
+     * Worth asserting rather than assuming: the grid is NOT the host. The host also
+     * holds the nav header, and a `role="grid"` may only own rows — so the role sits
+     * on the body, and the weekday strip is a row inside it rather than a sibling.
+     */
+    getGridRole(): Promise<string | null>;
+    /** How many week rows the grid renders — always six, which is what keeps it from reflowing. */
+    getWeekCount(): Promise<number>;
+    private readChips;
+    private requireView;
+}
+
+export { WrCalendarDayHarness, WrCalendarHarness };
+export type { WrCalendarChip, WrCalendarDayHarnessFilters, WrCalendarHarnessFilters, WrCalendarView };

package/types/ngwr-calendar.d.ts

@@ -79,6 +79,26 @@ declare class WrCalendar {
     protected readonly hoverDate: _angular_core.WritableSignal<Date | null>;
     /** Which sub-view is currently shown. Cycles `day → month → year` on header click. */
     protected readonly viewMode: _angular_core.WritableSignal<"day" | "month" | "year">;
+    /**
+     * Chip the month / year listbox has moved its ring to, as an index into
+     * `monthsView()` / `yearsView()`. `null` means "nobody has pressed an arrow
+     * yet", which resolves to the month or year on screen — see {@link activeChip}.
+     *
+     * Reset on every view change rather than remembered: coming back to the month
+     * list should ring the month you are looking at, not the one an earlier visit
+     * happened to leave the ring on.
+     */
+    private readonly rovedChip;
+    private readonly prevMonthLabel;
+    private readonly nextMonthLabel;
+    private readonly prevYearLabel;
+    private readonly nextYearLabel;
+    private readonly prevYearsLabel;
+    private readonly nextYearsLabel;
+    /** What the ← button does from here — a month, a year, or a 12-year page. */
+    protected readonly prevLabel: _angular_core.Signal<string>;
+    /** What the → button does from here. */
+    protected readonly nextLabel: _angular_core.Signal<string>;
     protected readonly today: _angular_core.Signal<Date>;
     protected readonly weekdayNames: _angular_core.Signal<readonly string[]>;
     protected readonly monthsView: _angular_core.Signal<readonly string[]>;
@@ -87,6 +107,22 @@ declare class WrCalendar {
     protected readonly headerLabel: _angular_core.Signal<string>;
     /** 6×7 day grid covering the current month plus spillover. */
     protected readonly weeks: _angular_core.Signal<readonly (readonly Date[])[]>;
+    /**
+     * The chip carrying the listbox's only `tabindex="0"` — where the ring is, and
+     * where Tab lands.
+     *
+     * A listbox owns its arrows, and these two did not: twelve months were twelve
+     * tab stops, so the role promised an interaction model the component never
+     * implemented. One tab stop plus arrow keys is the roving-tabindex half of the
+     * pattern the day grid already uses.
+     *
+     * Routed through {@link nearestEnabledChip} on BOTH paths — the seed and every
+     * arrow — for the reason the grid learned first: `.focus()` on a
+     * `<button disabled>` is a no-op, so parking the sole tab stop on a month a
+     * `[min]` has closed off leaves the whole view unreachable by keyboard.
+     * `-1` on the day view, where there are no chips at all.
+     */
+    protected readonly activeChip: _angular_core.Signal<number>;
     protected readonly classes: _angular_core.Signal<string>;
     constructor();
     /** Header `‹` button — steps by month / year / decade based on the active view. */
@@ -97,6 +133,14 @@ declare class WrCalendar {
     protected onLabelClick(): void;
     protected onMonthSelect(monthIdx: number): void;
     protected onYearSelect(year: number): void;
+    /**
+     * Switch views and drop the chip ring with them.
+     *
+     * Every view change is the only thing that changes what the chips MEAN, so it
+     * is the one place the ring has to forget where it was — otherwise a year
+     * picked at index 7 rings the eighth MONTH on the way back down.
+     */
+    private setViewMode;
     private stepViewDate;
     protected isToday(date: Date): boolean;
     protected isOutOfMonth(date: Date): boolean;
@@ -116,6 +160,38 @@ declare class WrCalendar {
     protected onCellLeave(): void;
     private applyRangeClick;
     protected onKeyDown(event: KeyboardEvent): void;
+    /**
+     * Arrow / Home / End inside the month or year listbox — the roving half of the
+     * pattern their `role` has always claimed.
+     *
+     * Steps by one along the row and by a full row vertically, and the inline pair
+     * mirrors under `dir="rtl"` for the same reason the grid's does: those two keys
+     * name a side of the screen. The page does NOT wrap or spill into the next
+     * one — a month list is twelve fixed cells, and the header's `‹` / `›` are what
+     * change which twelve. Anything else (Enter, Space, Tab, Escape) is left to the
+     * button and to whatever owns the calendar.
+     */
+    private onChipKeyDown;
+    /** How many chips the current view renders — twelve either way, read rather than assumed. */
+    private chipCount;
+    /** Whether the chip at `index` refuses selection in the current view. */
+    private isChipDisabled;
+    /** The chip the view itself points at: the month or year currently on screen. */
+    private currentChip;
+    /**
+     * The first selectable chip at or after `from`, else the first before it, else
+     * `from` unchanged when the whole page is closed off — the chip version of
+     * {@link nearestEnabled}, and it exists for the same reason: the ring carries
+     * the only `tabindex="0"`, and a disabled button cannot hold it.
+     */
+    private nearestEnabledChip;
+    /**
+     * The first selectable chip at `from` or beyond it in `step`'s direction, else
+     * null when that whole direction is closed off — which is the answer for an
+     * ArrowLeft on the first chip: stay put.
+     */
+    private enabledChipToward;
+    private focusActiveChip;
     /**
      * The first selectable day at or after `candidate`, else the first before it,
      * else `candidate` unchanged when everything nearby is closed off. Bounded at

package/types/ngwr-carousel.d.ts

@@ -1,14 +1,74 @@
 import * as ngwr_i18n from 'ngwr/i18n';
 import * as _angular_core from '@angular/core';
+import { InjectionToken, Signal } from '@angular/core';
 
 /**
  * One slide in a {@link WrCarousel}. Holds whatever content you
  * project — image, card, video, anything.
+ *
+ * **An off-screen slide is `inert`.** Only one slide is visible, but the track
+ * merely translates the others out of view: without this they stay in the tab
+ * order and in the accessibility tree, so a keyboard user tabs into a link they
+ * cannot see and a screen reader announces every slide as if they were all on
+ * screen. `inert` takes the whole subtree out of both at once, which is why it
+ * is preferred here over `tabindex="-1"` (which reaches only the host) — the
+ * same answer `wr-collapse` and `wr-marquee` use.
+ *
+ * `aria-hidden` rides along for the same reason it does on the marquee's
+ * duplicate copies: it states the intent for anything reading the attribute
+ * rather than honouring `inert`.
  */
 declare class WrCarouselSlide {
+    private readonly carousel;
+    /**
+     * Word a screen reader speaks IN PLACE OF the `group` role. Falls back to
+     * `carousel.slideRoledescription`, then `'slide'`.
+     */
+    readonly roledescription: _angular_core.InputSignal<string | null>;
+    protected readonly resolvedRoledescription: _angular_core.Signal<string>;
+    /**
+     * Whether this slide is one of the ones translated out of view.
+     *
+     * `false` while the index is `-1`: content children resolve after the first
+     * render, and a slide that hid itself in that window would make the carousel
+     * open with everything inert. `false` too when there is no parent — the
+     * component is exported, so it can be used on its own.
+     */
+    protected readonly offScreen: _angular_core.Signal<boolean>;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<WrCarouselSlide, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<WrCarouselSlide, "wr-carousel-slide", never, {}, {}, never, ["*"], true, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<WrCarouselSlide, "wr-carousel-slide", never, { "roledescription": { "alias": "roledescription"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+/**
+ * @license
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://github.com/thekhegay/ngwr/blob/main/LICENSE
+ */
+
+/**
+ * Contract a `<wr-carousel-slide>` uses to ask its parent whether it is the one
+ * on screen.
+ *
+ * A token rather than an input, because slides arrive through `<ng-content />`:
+ * nothing in `carousel.html` can bind to them, so the child has to reach up.
+ * Same shape as {@link WR_TABS}.
+ *
+ * @internal
+ */
+interface WrCarouselContext {
+    /** Index of the slide currently on screen. */
+    readonly active: Signal<number>;
+    /**
+     * Position of a slide in projection order, or `-1` before it has registered.
+     *
+     * Reads the content-children signal, so a `computed()` calling this tracks
+     * both the active index and slides being added or removed.
+     */
+    indexOf(slide: object): number;
 }
+/** Token a `<wr-carousel-slide>` injects to find its parent `<wr-carousel>`. */
+declare const WR_CAROUSEL: InjectionToken<WrCarouselContext>;
 
 /**
  * Slide carousel. Project `<wr-carousel-slide>` children — the carousel
@@ -25,7 +85,7 @@ declare class WrCarouselSlide {
  *
  * @see https://ngwr.dev/reference/components/carousel
  */
-declare class WrCarousel {
+declare class WrCarousel implements WrCarouselContext {
     /** Accessible name of the previous-slide button. Falls back to `carousel.prev`. */
     readonly prevLabel: _angular_core.InputSignal<string | null>;
     /** Accessible name of the next-slide button. Falls back to `carousel.next`. */
@@ -38,6 +98,12 @@ declare class WrCarousel {
     /** Accessible name of the carousel itself. Falls back to `carousel.label`. */
     readonly ariaLabel: _angular_core.InputSignal<string | null>;
     protected readonly resolvedAriaLabel: _angular_core.Signal<string>;
+    /**
+     * Word a screen reader speaks IN PLACE OF the `group` role. Falls back to
+     * `carousel.roledescription`, then `'carousel'`.
+     */
+    readonly roledescription: _angular_core.InputSignal<string | null>;
+    protected readonly resolvedRoledescription: _angular_core.Signal<string>;
     protected readonly slideLabel: (params?: ngwr_i18n.WrI18nParams) => string;
     /** Active slide index. Two-way bindable. @default 0 */
     readonly active: _angular_core.ModelSignal<number>;
@@ -53,6 +119,14 @@ declare class WrCarousel {
     readonly loop: _angular_core.InputSignalWithTransform<boolean, any>;
     protected readonly slides: _angular_core.Signal<readonly WrCarouselSlide[]>;
     protected readonly count: _angular_core.Signal<number>;
+    /**
+     * Where a slide sits in projection order — {@link WrCarouselContext}.
+     *
+     * Public only because the child injects the parent through `WR_CAROUSEL`;
+     * reading `slides()` here is what makes the child's `computed()` re-run when a
+     * slide is added or removed.
+     */
+    indexOf(slide: object): number;
     /** Live horizontal drag offset (px) during a touch swipe. */
     protected readonly dragX: _angular_core.WritableSignal<number>;
     protected readonly dragging: _angular_core.WritableSignal<boolean>;
@@ -69,12 +143,16 @@ declare class WrCarousel {
     /** CSS transform for the track — the per-slide offset plus any live drag. */
     protected readonly trackStyle: _angular_core.Signal<string>;
     private timer;
+    private readonly hovered;
+    private readonly focusWithin;
     private readonly paused;
     private readonly destroyRef;
     private readonly isBrowser;
     constructor();
-    protected onPauseIn(): void;
-    protected onPauseOut(): void;
+    protected onHoverIn(): void;
+    protected onHoverOut(): void;
+    protected onFocusIn(): void;
+    protected onFocusOut(): void;
     goTo(index: number): void;
     next(): void;
     prev(): void;
@@ -83,7 +161,8 @@ declare class WrCarousel {
     protected onSwipeMove(event: TouchEvent): void;
     protected onSwipeEnd(event: TouchEvent, viewport: HTMLElement): void;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<WrCarousel, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<WrCarousel, "wr-carousel", never, { "prevLabel": { "alias": "prevLabel"; "required": false; "isSignal": true; }; "nextLabel": { "alias": "nextLabel"; "required": false; "isSignal": true; }; "paginationLabel": { "alias": "paginationLabel"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; "active": { "alias": "active"; "required": false; "isSignal": true; }; "showArrows": { "alias": "showArrows"; "required": false; "isSignal": true; }; "showDots": { "alias": "showDots"; "required": false; "isSignal": true; }; "autoplay": { "alias": "autoplay"; "required": false; "isSignal": true; }; "intervalMs": { "alias": "intervalMs"; "required": false; "isSignal": true; }; "loop": { "alias": "loop"; "required": false; "isSignal": true; }; }, { "active": "activeChange"; }, ["slides"], ["*"], true, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<WrCarousel, "wr-carousel", never, { "prevLabel": { "alias": "prevLabel"; "required": false; "isSignal": true; }; "nextLabel": { "alias": "nextLabel"; "required": false; "isSignal": true; }; "paginationLabel": { "alias": "paginationLabel"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; "roledescription": { "alias": "roledescription"; "required": false; "isSignal": true; }; "active": { "alias": "active"; "required": false; "isSignal": true; }; "showArrows": { "alias": "showArrows"; "required": false; "isSignal": true; }; "showDots": { "alias": "showDots"; "required": false; "isSignal": true; }; "autoplay": { "alias": "autoplay"; "required": false; "isSignal": true; }; "intervalMs": { "alias": "intervalMs"; "required": false; "isSignal": true; }; "loop": { "alias": "loop"; "required": false; "isSignal": true; }; }, { "active": "activeChange"; }, ["slides"], ["*"], true, never>;
 }
 
-export { WrCarousel, WrCarouselSlide };
+export { WR_CAROUSEL, WrCarousel, WrCarouselSlide };
+export type { WrCarouselContext };

package/types/ngwr-cascader.d.ts

@@ -116,14 +116,31 @@ declare class WrCascader<T = string> implements FormValueControl<unknown> {
     private readonly vcr;
     private readonly scrollStrategies;
     private readonly destroyRef;
+    private readonly injector;
     private overlayRef;
     constructor();
     protected onTriggerClick(): void;
+    /**
+     * ArrowDown / ArrowUp open the panel, Alt+ArrowDown included — the combobox way in,
+     * and the shape `wr-dropdown`'s trigger uses. Enter and Space need no branch: the
+     * trigger is a real `<button>`, so the browser turns them into the click above.
+     *
+     * Only while closed. Once the panel is up the caret is inside it, and its options
+     * own their own keys.
+     */
+    protected onTriggerKeydown(event: KeyboardEvent): void;
     protected onOptionClick(colIndex: number, opt: WrCascaderOption<T>, event: Event): void;
     protected clearSelection(event: Event): void;
     protected isActiveAt(colIndex: number, value: T): boolean;
     private pathsEqual;
     private openOverlay;
+    /**
+     * The option the panel opens on: the selected one in the first column when there is
+     * a selection, otherwise the first enabled root. A disabled option is skipped — it
+     * still carries `tabindex="-1"`, so `focus()` would land on it and answer for a
+     * choice nobody can make.
+     */
+    private focusPanelOption;
     private closeOverlay;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<WrCascader<any>, never>;
     static ɵcmp: _angular_core.ɵɵComponentDeclaration<WrCascader<any>, "wr-cascader", never, { "clearLabel": { "alias": "clearLabel"; "required": false; "isSignal": true; }; "options": { "alias": "options"; "required": true; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "clearable": { "alias": "clearable"; "required": false; "isSignal": true; }; "changeOnSelect": { "alias": "changeOnSelect"; "required": false; "isSignal": true; }; "separator": { "alias": "separator"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; "touch": "touch"; }, never, never, true, never>;

package/types/ngwr-checkbox.d.ts

@@ -120,6 +120,17 @@ interface WrCheckboxGroupContext {
     isSelected(value: unknown): boolean;
     /** Toggle the given value in the group. */
     toggle(value: unknown): void;
+    /**
+     * A child lost focus.
+     *
+     * The group is the control a form binds to, so it is the group that has to
+     * report touched — and a child's own `touch` output goes nowhere, since the
+     * group never listens to it. Without this channel the only way to mark a
+     * group touched was to CHANGE it: tabbing through every box and picking none
+     * left the field pristine, so a `required` group showed no error until the
+     * user toggled something, which is the one thing they had decided not to do.
+     */
+    blurred(): void;
     /** Whether the entire group is disabled. */
     readonly isDisabled: Signal<boolean>;
 }
@@ -167,6 +178,8 @@ declare class WrCheckboxGroup implements FormValueControl<unknown[]>, WrCheckbox
     readonly isDisabled: _angular_core.Signal<boolean>;
     isSelected(value: unknown): boolean;
     toggle(value: unknown): void;
+    /** @internal A child checkbox lost focus — see {@link WrCheckboxGroupContext.blurred}. */
+    blurred(): void;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<WrCheckboxGroup, never>;
     static ɵcmp: _angular_core.ɵɵComponentDeclaration<WrCheckboxGroup, "wr-checkbox-group", never, { "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; "touch": "touch"; }, never, ["*"], true, never>;
 }