ngwr 11.1.0 → 11.2.0

package/types/ngwr-border-glow-testing.d.ts

@@ -0,0 +1,219 @@
+import { BaseHarnessFilters, ComponentHarness, HarnessPredicate } from '@angular/cdk/testing';
+
+/**
+ * @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
+ */
+
+/** Narrows which `<wr-border-glow>` a harness query matches. */
+interface WrBorderGlowHarnessFilters extends BaseHarnessFilters {
+    /**
+     * Match the card's projected text — a string is an exact match, a RegExp is tested.
+     * The component names itself nothing, so the content it wraps is the only readable
+     * way to tell two cards on a page apart.
+     */
+    readonly text?: string | RegExp;
+    /**
+     * Match only cards that are mid mount-sweep (`true`) or only cards that are not
+     * (`false`) — see `WrBorderGlowHarness.isSweeping`, where the four-second window
+     * this is true for is explained.
+     */
+    readonly sweeping?: 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 `<wr-border-glow>` — a card whose border lights up under the cursor.
+ *
+ * **Nearly all of this component is a bag of custom properties written onto the host,
+ * and that is what the harness reads.** The paint itself — the conic mask, the stacked
+ * `box-shadow` halo, the soft-light bloom — lives in the stylesheet, so a unit test can
+ * never see it. What it CAN see is the arithmetic that feeds it, and that is where the
+ * breakages are: the seven-step alpha ramp {@link getGlowAlphaRamp} derives from
+ * `glowIntensity`, the `[0,1,2,0,1,2,1]` palette mapping in {@link getGradientColors}
+ * with its clamp for short palettes, and the pointer maths behind
+ * {@link getPointerAngle} / {@link getEdgeProximity}.
+ *
+ * **Every custom-property getter reads the inline declaration** — see
+ * {@link parseInlineDeclarations} for why a computed read would be a different, and
+ * wrong, question.
+ *
+ * **A colour getter answering `null` means the component has never written that
+ * variable**, which is the contract when the input is unset: the stylesheet's per-theme
+ * default takes over. Note that it does not un-write them either — setting `[glowColor]`
+ * and then putting it back to `null` leaves the last value on the host — so `null` is
+ * "never set", not "not set now".
+ *
+ * There is deliberately no `getGlowOpacity()`, `isGlowVisible()` or `isHovered()`: the
+ * visible strength is a `calc()` in the stylesheet gated behind `:not(:hover)`, and
+ * jsdom loads no stylesheet and matches no `:hover`, so any number would be invented.
+ * There is no measured halo extent either — `.wr-border-glow__edge` is 0×0 in a test,
+ * and {@link getGlowRadius} reads what the component asked for instead. And there is no
+ * `getSweepProgress()` / `waitForSweep()`: the mount sweep is a four-second chain of
+ * `requestAnimationFrame` tweens, so awaiting it either hangs the spec or samples one
+ * frame and reports a value that was never settled. {@link isSweeping} answers the one
+ * durable fact — that the sweep started.
+ *
+ * @example
+ * ```ts
+ * const card = await loader.getHarness(WrBorderGlowHarness.with({ text: /Hover me/ }));
+ *
+ * expect(await card.getBorderRadius()).toBe(28);
+ * expect(await card.getPointerAngle()).toBeNull();   // nothing has pointed at it yet
+ * ```
+ *
+ * @see https://ngwr.dev/guides/testing
+ */
+declare class WrBorderGlowHarness extends ComponentHarness {
+    static hostSelector: string;
+    /** Build a predicate that narrows the query — pass to `getHarness` / `getAllHarnesses`. */
+    static with(options?: WrBorderGlowHarnessFilters): HarnessPredicate<WrBorderGlowHarness>;
+    private readonly edge;
+    /** The corner radius the stylesheet is told to round to, in pixels. */
+    getBorderRadius(): Promise<number>;
+    /** How far past the card edge the halo is told to reach, in pixels. */
+    getGlowRadius(): Promise<number>;
+    /**
+     * The width of the lit cone, as a share of the perimeter.
+     *
+     * Unitless by contract — the stylesheet multiplies it — so a `px` creeping in here is
+     * a real regression that leaves the mask with a length where it wants a number.
+     */
+    getConeSpread(): Promise<number>;
+    /** How sharply the halo fades as the cursor leaves an edge; lower is a wider falloff. */
+    getEdgeSensitivity(): Promise<number>;
+    /** Strength of the interior soft-light bloom, again unitless. */
+    getFillOpacity(): Promise<number>;
+    /**
+     * The card fill the author asked for, or `null` when they left it to the theme.
+     *
+     * The distinction is the whole point: an unset `[backgroundColor]` means the surface
+     * token decides, light or dark, and a card that starts declaring its own fill has
+     * stopped following the theme.
+     */
+    getBackgroundColor(): Promise<string | null>;
+    /**
+     * The halo colour at full strength, or `null` when the theme decides.
+     *
+     * Comes back as the `hsl(H deg S% L% / A%)` the component assembled from the bare
+     * `'H S L'` input, so this also pins that assembly. Be aware the parse is forgiving to
+     * a fault: anything that is not three bare numbers — a hex colour, `rgb(…)`, even
+     * `hsl(40deg 80% 80%)` with its units — silently becomes the default amber, so a
+     * plausible-looking value here does not mean the input was understood.
+     */
+    getGlowColor(): Promise<string | null>;
+    /**
+     * The seven halo alphas in percent, brightest first, or `null` when no glow colour
+     * was ever set.
+     *
+     * This is the whole of `[glowIntensity]`: the steps are `[100, 60, 50, 40, 30, 20,
+     * 10]` multiplied by the intensity and clamped at 100, so `0.5` gives
+     * `[50, 30, 25, 20, 15, 10, 5]` and anything above 1 saturates from the top down. The
+     * clamp is one-sided — a negative intensity produces negative percentages, which a
+     * browser drops as invalid declarations and the halo vanishes — so the numbers are
+     * returned as written rather than corrected, which is how a spec can see it.
+     */
+    getGlowAlphaRamp(): Promise<number[] | null>;
+    /**
+     * The seven mesh-gradient colours, in slot order, or `null` when no palette was set.
+     *
+     * The slots do not map one-to-one onto the palette: they take colours
+     * `[0, 1, 2, 0, 1, 2, 1]`, each index clamped to the last entry the palette actually
+     * has. So a two-colour palette repeats the second colour rather than reading past the
+     * end — which is the case worth a spec, since `undefined` in a `radial-gradient()`
+     * kills the whole declaration silently.
+     */
+    getGradientColors(): Promise<string[] | null>;
+    /**
+     * The flat colour behind the mesh, or `null` when no palette was set.
+     *
+     * Always the palette's FIRST entry. Worth its own method because the base slice is the
+     * one that shows where the gradients are transparent, and it drifting to the last
+     * colour changes the card's whole cast without touching a gradient.
+     */
+    getBaseGradientColor(): Promise<string | null>;
+    /**
+     * Where the cursor last sat, in degrees: `0` is straight up and the angle grows
+     * clockwise. `null` until something has pointed at the card.
+     *
+     * `null` is a state of its own rather than a stand-in for zero — the stylesheet's own
+     * default applies until the first pointer arrives, and dead centre legitimately
+     * reports `0`, so a harness that folded the two together could not tell an untouched
+     * card from one being pointed at from the middle.
+     */
+    getPointerAngle(): Promise<number | null>;
+    /**
+     * How close the cursor is to the perimeter: `0` at dead centre, `100` at the edge.
+     * `null` until something has pointed at the card.
+     *
+     * On a diagonal the NEARER axis wins rather than the two averaging, so a cursor level
+     * with the bottom edge reads 100 wherever it is along it.
+     */
+    getEdgeProximity(): Promise<number | null>;
+    /**
+     * Point at the card, in client coordinates.
+     *
+     * **Refuses on a card with no box, which in a unit test is every card.** The component
+     * measures the pointer against its own centre, and with a 0×0 rect that maths
+     * degenerates: the centre is the top-left corner, and `1 / Math.min(0, 0)` pins the
+     * proximity at 100 for every position on the page. Both would come back as confident
+     * numbers describing nothing. Give the host a box first, exactly as the component's own
+     * spec does:
+     *
+     * ```ts
+     * const card = fixture.nativeElement.querySelector('wr-border-glow');
+     * card.getBoundingClientRect = () => ({ left: 0, top: 0, width: 200, height: 100 }) as DOMRect;
+     * ```
+     *
+     * A `pointermove` is dispatched on the host itself, so it needs no hit test and cannot
+     * miss — the coordinates only ever reach the component's own arithmetic.
+     */
+    movePointerTo(clientX: number, clientY: number): Promise<void>;
+    /**
+     * Whether the one-shot mount sweep is running.
+     *
+     * The class is added synchronously when the sweep starts and removed when it ends
+     * about four seconds later, or when the component is torn down — so a spec asserts
+     * that it STARTED, and leaves the angle alone while it does. This is also the
+     * reduced-motion assertion: `[animated]="true"` for someone who asked for less motion
+     * must leave this `false`, and no angle written at all.
+     */
+    isSweeping(): Promise<boolean>;
+    /** Whether the halo layer is in the markup — the element the whole outer glow paints on. */
+    hasHaloLayer(): Promise<boolean>;
+    /**
+     * Whether the decoration stays out of the accessibility tree.
+     *
+     * The halo layer is the component's only decorative NODE — every other layer is a
+     * pseudo-element and so was never in the tree to begin with. It carries no text and no
+     * name, so losing its `aria-hidden` puts an anonymous element between the reader and
+     * the card's content.
+     */
+    isDecorationHiddenFromAssistiveTech(): Promise<boolean>;
+    /**
+     * The projected content's text, trimmed.
+     *
+     * Read from `.wr-border-glow__inner` rather than the host, which is the assertion:
+     * content that lands as a bare host child instead of inside the wrapper renders
+     * underneath the interior bloom, and reading the host would report the same string
+     * either way.
+     */
+    getContentText(): Promise<string>;
+    /** The host's inline declarations — the component's whole written output. */
+    private declarations;
+    /** One inline custom property, or `null` when the component has not written it. */
+    private readVar;
+    /** One inline custom property that is always written, as a number. */
+    private readNumberVar;
+}
+
+export { WrBorderGlowHarness };
+export type { WrBorderGlowHarnessFilters };

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

@@ -0,0 +1,79 @@
+import { BaseHarnessFilters, ComponentHarness, HarnessPredicate } from '@angular/cdk/testing';
+
+/**
+ * @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
+ */
+
+/** Narrows which `<wr-calendar-heatmap>` a harness query matches. */
+interface WrCalendarHeatmapHarnessFilters extends BaseHarnessFilters {
+    /** Match the grid's accessible name. */
+    readonly ariaLabel?: string | RegExp;
+}
+/** One day square, as its tooltip describes it. */
+interface WrCalendarHeatmapCell {
+    /** The ISO date the square stands for. */
+    readonly iso: string;
+    /** The value as printed in the tooltip. */
+    readonly value: string;
+    /** Which week column it sits in, one-based, as the grid places it. */
+    readonly week: number;
+    /** Which weekday row it sits in, one-based. */
+    readonly day: number;
+}
+
+/**
+ * @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 `<wr-calendar-heatmap>`.
+ *
+ * **Every square is `aria-hidden`, and that is the design.** The grid is one
+ * `role="img"` with a name; a year of individually announced days would be unusable
+ * with a screen reader. What each square carries instead is a `title` — its ISO date
+ * and value — which is the only text a spec can read, and what
+ * {@link getCells} parses.
+ *
+ * **Four of the seven weekday labels are blank on purpose**: seven do not fit beside
+ * a grid this dense. {@link getWeekdayLabels} returns them as they are, empties
+ * included, rather than filtering — a spec asserting seven entries with four blanks
+ * is pinning the real layout.
+ *
+ * @see https://ngwr.dev/guides/testing
+ */
+declare class WrCalendarHeatmapHarness extends ComponentHarness {
+    static hostSelector: string;
+    /** Build a predicate that narrows the query — pass to `getHarness` / `getAllHarnesses`. */
+    static with(options?: WrCalendarHeatmapHarnessFilters): HarnessPredicate<WrCalendarHeatmapHarness>;
+    private readonly grid;
+    /** The role the grid announces — `img`, for the whole picture. */
+    getRole(): Promise<string | null>;
+    /** The grid's accessible name — the only name a reader gets. */
+    getAccessibleName(): Promise<string | null>;
+    /** How many day squares were drawn. */
+    getCellCount(): Promise<number>;
+    /**
+     * Every square, from its tooltip and its grid placement.
+     *
+     * The `title` is `"<iso>: <value>"`, which is the component's own format and the
+     * only text on a square — everything else about it is colour.
+     */
+    getCells(): Promise<WrCalendarHeatmapCell[]>;
+    /** The value a given ISO date's square reports, or `null` when that day is not drawn. */
+    getValueFor(iso: string): Promise<string | null>;
+    /** Whether the weekday and month labels are drawn (`showLabels`). */
+    hasLabels(): Promise<boolean>;
+    /** The weekday labels as drawn — seven entries, four of them deliberately empty. */
+    getWeekdayLabels(): Promise<string[]>;
+    /** The month labels along the top, in order. */
+    getMonthLabels(): Promise<string[]>;
+}
+
+export { WrCalendarHeatmapHarness };
+export type { WrCalendarHeatmapCell, WrCalendarHeatmapHarnessFilters };

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 getActiveDay} 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,16 @@ 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">;
+    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[]>;

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>;
 }