ngwr 11.1.0 → 11.2.0

package/types/ngwr-circular-text-testing.d.ts

@@ -0,0 +1,196 @@
+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-circular-text>` a harness query matches. */
+interface WrCircularTextHarnessFilters extends BaseHarnessFilters {
+    /**
+     * Match the string the ring announces — the readable copy, not the characters.
+     * A string is an exact match, a RegExp is tested.
+     *
+     * Matched against the accessible copy rather than the host's text because the host
+     * carries both: one readable span AND one span per character, so its text reads back
+     * as the string twice over and a filter written against it would depend on the split.
+     */
+    readonly text?: string | RegExp;
+    /**
+     * Match on how many characters the ring was laid out from — the divisor every angle is
+     * derived from, and the blunt way to address one of two rings without spelling their
+     * strings out.
+     */
+    readonly characterCount?: 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-circular-text>`.
+ *
+ * **The ring's geometry is the component's real output, and it is exact without a
+ * browser.** Each character is placed by an inline `transform` the component computes —
+ * `rotate(360 / N × i deg)` and then a push outward by the orbit radius — so
+ * {@link getCharacterAngles} reads the entire layout back as numbers. A broken circle
+ * shows up as uneven angles, as an offset that varies per character, or as a surrogate
+ * pair torn into two glyphs, and none of those need a single measured pixel.
+ *
+ * **The spin does not exist in the DOM, and every method that would report it is absent
+ * on purpose.** The rotation is one Web Animation on the ring wrapper, advanced by a
+ * compositor, and `spinDuration` reaches nothing but that animation's `duration` option
+ * — so there is no `getSpinDurationSeconds()` (it would report whatever the spec's own
+ * `animate` stub recorded, which is the test reading back its own fixture), no
+ * `isSpinning()` and no `getRotationAngle()` (both live on `Animation.currentTime`, in an
+ * API jsdom does not implement). There is no `hover()` either: hovering swaps that
+ * duration through listeners on the host and changes not one attribute, so a harness
+ * hover would appear to work and assert nothing. `pause()` / `resume()` are missing for
+ * the same reason — the state is the private `Animation` object, never the document.
+ * `respectsReducedMotion()` is the same shape once more: the component honours it by NOT
+ * calling `animate`, which is a spec assertion against a stub rather than something a
+ * harness can read.
+ *
+ * **The radius is exposed as text, not as pixels.** `--wr-circular-text-size` and
+ * `--wr-circular-text-radius` are declared in the stylesheet, so a test running no
+ * stylesheets reads them back empty — hence {@link getOrbitOffsets} hands over the CSS
+ * each character carries verbatim instead of a `getRadiusPx()` nobody could compute, and
+ * there is no `getCharacterPositions()`: every rect in a unit test is 0×0.
+ *
+ * **{@link isBonkers} is the one hover mode with a DOM footprint, and the INPUT sets it,
+ * not the pointer.** `onHover="goBonkers"` puts the modifier on the host at render time;
+ * the scale it enables is a CSS `:hover` rule the harness cannot see. Reading it as "the
+ * pointer is over the ring" is exactly backwards.
+ *
+ * **What is announced and what is drawn are two questions.** The string is carried once
+ * in a visually-hidden span, and the ring as a whole is `aria-hidden` so a screen reader
+ * hears the word rather than spelling it out — {@link getAccessibleText} is the first,
+ * {@link getText} the second, and a spec that read only the second would pass on a
+ * component announcing `N. G. W. R.`
+ *
+ * jsdom implements no Web Animations API and this component animates on mount, so a spec
+ * has to supply one of the two halves before the fixture is created — either the API, or
+ * a reason not to reach for it:
+ *
+ * ```ts
+ * // Either: mount under reduced motion, where the component never animates at all.
+ * // (jsdom has no matchMedia, so WrPlatform must be provided as a value.)
+ * TestBed.configureTestingModule({ providers: [{ provide: WrPlatform, useValue: reducedMotion }] });
+ *
+ * // Or: stub the API. Save the descriptor and put it back by hand in afterEach — this
+ * // is an assignment, not a spy, so it leaks into whichever file vitest runs next.
+ * Reflect.set(Element.prototype, 'animate', () => ({ cancel: () => undefined }));
+ * ```
+ *
+ * @example
+ * ```ts
+ * const ring = await loader.getHarness(WrCircularTextHarness.with({ text: 'NGWR' }));
+ *
+ * expect(await ring.getCharacters()).toEqual(['N', 'G', 'W', 'R']);
+ * expect(await ring.getCharacterAngles()).toEqual([0, 90, 180, 270]);
+ * expect(await ring.getText()).toBe(await ring.getAccessibleText());
+ * ```
+ *
+ * @see https://ngwr.dev/guides/testing
+ */
+declare class WrCircularTextHarness extends ComponentHarness {
+    static hostSelector: string;
+    /** Build a predicate that narrows the query — pass to `getHarness` / `getAllHarnesses`. */
+    static with(options?: WrCircularTextHarnessFilters): HarnessPredicate<WrCircularTextHarness>;
+    private readonly chars;
+    /**
+     * The whole string, as the one readable copy holds it.
+     *
+     * All a screen reader gets, the ring itself being out of the tree — lose this span and
+     * the component becomes a nameless pile of hidden letters, with no other symptom
+     * anywhere in the DOM.
+     *
+     * Untrimmed, deliberately: a ring is usually given a separator-padded string like
+     * `'HELLO * NGWR * '`, whose trailing space is a real character that takes a slot on
+     * the circle. {@link getText} is meant to compare equal to this, and a trimmed read on
+     * either side would forgive losing it.
+     */
+    getAccessibleText(): Promise<string>;
+    /**
+     * The characters laid out around the circle, in DOM order.
+     *
+     * Pins the splitting rule — `Array.from(text())`, so a surrogate pair is ONE slot and
+     * not two broken halves, and a space is its own slot rather than being collapsed away.
+     * DOM order is the only order there is: every character is absolutely positioned, so
+     * the sequence here is what the angles below are indexed by.
+     */
+    getCharacters(): Promise<string[]>;
+    /**
+     * Everything the ring draws, put back together in DOM order.
+     *
+     * The assertion this exists for is `getText() === getAccessibleText()`: the split has
+     * to be lossless. Read from the character spans rather than from the host, because the
+     * host also holds the readable copy and would report the string twice over.
+     */
+    getText(): Promise<string>;
+    /** How many slots the circle was divided into — the divisor every angle is derived from. */
+    getCharacterCount(): Promise<number>;
+    /**
+     * Where each character sits on the circle, in degrees, in DOM order.
+     *
+     * The component's whole geometric output, and the one thing that tells a ring from a
+     * crowded arc: the angles must start at 0 and be exactly `360 / N` apart. Empty text
+     * yields an empty array — no characters, no angles.
+     *
+     * Throws for a character carrying no rotation of its own rather than reporting `0` or
+     * `NaN` for it. Both of those describe a ring collapsed onto a single point as though
+     * nothing were wrong, and that is precisely the failure this method exists to catch.
+     */
+    getCharacterAngles(): Promise<number[]>;
+    /**
+     * How far each character is pushed out from the centre, as the CSS the component wrote.
+     *
+     * A string rather than a number, and that is the honest answer: the distance is
+     * `calc(-1 * var(--wr-circular-text-radius))`, a custom property the STYLESHEET
+     * declares, so there is no pixel value to resolve in a test that loads no stylesheet.
+     * What matters is assertable anyway — every character must be pushed out by the SAME
+     * offset, along the same axis. A per-character or axis-mixed one is the classic bug
+     * that turns the ring into a diagonal line, and it survives every other check here
+     * because the angles stay perfect while it happens.
+     *
+     * Throws on the same unplaced character {@link getCharacterAngles} does, for the same
+     * reason.
+     */
+    getOrbitOffsets(): Promise<string[]>;
+    /**
+     * Whether the host carries the `wr-circular-text--bonkers` modifier.
+     *
+     * Set from the `onHover` INPUT being `'goBonkers'` — at render time, before anyone has
+     * hovered anything — which is the one assumption a spec author makes backwards here.
+     * It is also the only one of the four hover modes with any DOM footprint at all; the
+     * other three exist purely as a number handed to a Web Animation.
+     */
+    isBonkers(): Promise<boolean>;
+    /**
+     * Whether the ring is out of the accessibility tree.
+     *
+     * ONE attribute answers this, and that is the contract rather than an approximation:
+     * `aria-hidden` sits on the `__spin` wrapper, so the letters underneath inherit it and
+     * none of them carries the attribute itself — which keeps it off the nodes the rotation
+     * touches. Asserting it per character would fail on a component that is behaving.
+     *
+     * Answers for the wrapper even when the text is empty, and that is deliberate: the
+     * wrapper is always rendered, so there is no vacuous case to guard against — a ring
+     * with nothing in it is still correctly hidden or incorrectly readable.
+     *
+     * Assert it together with {@link getAccessibleText}: hidden letters AND no readable
+     * copy is an element with no accessible name at all, which passes either check alone.
+     */
+    areCharactersHiddenFromAssistiveTech(): Promise<boolean>;
+    /** Each character's placement, parsed once out of the inline transform it carries. */
+    private placements;
+}
+
+export { WrCircularTextHarness };
+export type { WrCircularTextHarnessFilters };

package/types/ngwr-color-picker-testing.d.ts

@@ -0,0 +1,291 @@
+import { BaseHarnessFilters, ComponentHarness, HarnessPredicate } from '@angular/cdk/testing';
+import { WrSegmentedHarness } from 'ngwr/segmented/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
+ */
+
+/** Which set of numeric fields the picker is showing. */
+type WrColorPickerTab = 'hex' | 'rgb' | 'hsl';
+/** Narrows which `<wr-color-picker>` a harness query matches. */
+interface WrColorPickerHarnessFilters extends BaseHarnessFilters {
+    /**
+     * Match the picker's current colour, as the preview swatch paints it — always
+     * hex, whatever `format` writes into `value`. A string is an exact match, a
+     * RegExp is tested.
+     */
+    readonly color?: string | RegExp;
+    /** Match only pickers showing this tab. */
+    readonly tab?: WrColorPickerTab;
+    /** Match only enabled (`false`) or only disabled (`true`) pickers. */
+    readonly disabled?: boolean;
+}
+/** Narrows which `[wrColorPickerTrigger]` a harness query matches. */
+interface WrColorPickerTriggerHarnessFilters extends BaseHarnessFilters {
+    /** Match the trigger's own text, an exact string or a RegExp. */
+    readonly text?: string | RegExp;
+    /** Match only open (`true`) or only closed (`false`) triggers. */
+    readonly open?: boolean;
+}
+/** The percentage each of the picker's thumbs sits at along its surface. */
+interface WrColorPickerThumbs {
+    /** Saturation across, value down — both 0–100, and `y` is inverted (0 % is full brightness). */
+    readonly sv: {
+        readonly x: number;
+        readonly y: number;
+    };
+    /** Hue along its slider, 0–100 (so 50 is 180°). */
+    readonly hue: number;
+    /** Alpha along its slider, 0–100, or `null` when the picker has no alpha. */
+    readonly alpha: number | null;
+}
+
+/**
+ * @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-color-picker>` — the inline picker, and the one the
+ * `[wrColorPickerTrigger]` directive mounts in an overlay.
+ *
+ * **What this harness will not do: drag.** The SV canvas and the hue / alpha
+ * sliders are pointer surfaces that read `getBoundingClientRect()` and divide by
+ * its width. A unit test has no layout, so every box is 0×0 and the division is
+ * `NaN` — a `setHue()` built on a synthetic pointer event would report success and
+ * write nothing, or write garbage. The numeric fields reach the same state and are
+ * also the only keyboard path the component has, so they are the whole write API
+ * here. {@link getThumbs} reads where the thumbs ARE, from the percentages the
+ * component writes inline, which is how a spec checks a surface followed a value.
+ *
+ * **And it will not read the preview swatch.** The preview paints the current
+ * colour as a CSS background, and jsdom normalises that to `rgb(…)` — dropping the
+ * alpha channel entirely, so `#ff880080` and `#ff8800ff` come back identical. A
+ * `getColor()` reading it would answer one thing in a unit test and another in a
+ * browser. {@link getHex} is the colour: the field holds the canonical 8-digit
+ * string, alpha included, whatever `format` writes into `value`.
+ *
+ * @example
+ * ```ts
+ * const picker = await loader.getHarness(WrColorPickerHarness);
+ *
+ * await picker.setHex('#3969e2');
+ * expect(await picker.getHex()).toBe('#3969e2ff');
+ *
+ * await picker.setTab('rgb');
+ * expect(await picker.getRgb()).toEqual({ r: 57, g: 105, b: 226 });
+ * ```
+ *
+ * @see https://ngwr.dev/guides/testing
+ */
+declare class WrColorPickerHarness extends ComponentHarness {
+    static hostSelector: string;
+    /** Build a predicate that narrows the query — pass to `getHarness` / `getAllHarnesses`. */
+    static with(options?: WrColorPickerHarnessFilters): HarnessPredicate<WrColorPickerHarness>;
+    private readonly hexField;
+    private readonly tabs;
+    /**
+     * The tab switcher, as a {@link WrSegmentedHarness}.
+     *
+     * Handed back rather than re-queried: the switcher IS a `<wr-segmented>`, which
+     * already knows that the roving tab stop is not the selection and how the sliding
+     * thumb reports itself. Re-reading its buttons here would be a second, worse copy.
+     */
+    getTabs(): Promise<WrSegmentedHarness>;
+    /** Which set of numeric fields is showing. */
+    getTab(): Promise<WrColorPickerTab>;
+    /** Show a different set of numeric fields. An already-active tab is left alone. */
+    setTab(tab: WrColorPickerTab): Promise<void>;
+    /**
+     * The canonical hex string, as the HEX field shows it — 8 digits while `alpha` is
+     * on, 6 while it is off.
+     *
+     * This is the picker's colour, and deliberately not the same thing as its `value`:
+     * `format` decides whether `value` is written as hex, `rgb()` or `hsl()`, while the
+     * field always shows hex. A spec that cares about the emitted string should read
+     * the bound signal; one that cares about the COLOUR should read this.
+     *
+     * Throws off the HEX tab, where the field does not exist — see {@link setTab}.
+     */
+    getHex(): Promise<string>;
+    /**
+     * Type a colour into the HEX field.
+     *
+     * Typed rather than assigned, because that is the path the component is built
+     * around: it re-parses on every keystroke and applies the first spelling that
+     * parses, so a partial `#ff8` commits a colour on its way to `#ff8800`. An
+     * unparseable string leaves the committed colour ALONE and lives in the field
+     * until {@link blurHex} snaps it back — assert that rather than expecting a throw.
+     */
+    setHex(value: string): Promise<void>;
+    /**
+     * Blur the HEX field — re-syncing it with the committed colour and emitting
+     * `touch`.
+     *
+     * The re-sync is the visible half: a field left holding text that never parsed
+     * goes back to the canonical hex here, and nowhere else.
+     */
+    blurHex(): Promise<void>;
+    /** Whether the HEX field currently holds focus. */
+    isHexFocused(): Promise<boolean>;
+    /** The three RGB channels as the RGB tab shows them. Throws off that tab. */
+    getRgb(): Promise<{
+        r: number;
+        g: number;
+        b: number;
+    }>;
+    /** Write one RGB channel, 0–255. Out-of-range numbers are clamped by the component. */
+    setRgbChannel(channel: 'r' | 'g' | 'b', value: number): Promise<void>;
+    /**
+     * Hue, saturation and lightness as the HSL tab shows them — degrees and whole
+     * percents, already rounded for display. Throws off that tab.
+     */
+    getHsl(): Promise<{
+        h: number;
+        s: number;
+        l: number;
+    }>;
+    /** Write one HSL channel — `h` in degrees, `s` / `l` in percent. */
+    setHslChannel(channel: 'h' | 's' | 'l', value: number): Promise<void>;
+    /**
+     * Alpha as the whole percent the numeric tabs show, or `null` when the picker was
+     * built without alpha.
+     *
+     * Only the RGB and HSL tabs carry the field — the HEX tab spells alpha into the
+     * hex string instead — so this throws on the HEX tab rather than answering `null`,
+     * which would read as "this picker has no alpha".
+     */
+    getAlphaPercent(): Promise<number | null>;
+    /** Write alpha as a whole percent, 0–100. */
+    setAlphaPercent(value: number): Promise<void>;
+    /**
+     * Whether the picker offers alpha at all.
+     *
+     * From the host modifier, which is the one answer that holds on every tab: the
+     * alpha SLIDER is always rendered when it is on, while the `A%` field only exists
+     * on the two numeric tabs.
+     */
+    hasAlpha(): Promise<boolean>;
+    /**
+     * Whether the picker refuses interaction.
+     *
+     * Read from the modifier the host paints rather than from a field's `disabled`
+     * property, because the fields come and go with the tab while the state does not —
+     * and the drag surfaces, which have no `disabled` of their own, are gated by the
+     * same signal.
+     */
+    isDisabled(): Promise<boolean>;
+    /** The preset colours offered under the fields, as the strings the consumer passed. */
+    getSwatches(): Promise<string[]>;
+    /**
+     * Click a preset.
+     *
+     * Matched on the string the consumer passed, which is what the button publishes as
+     * its accessible name — the rendered background is a CSS colour and would come back
+     * normalised and alpha-stripped. Throws when nothing matches, naming what is offered.
+     */
+    pickSwatch(color: string): Promise<void>;
+    /**
+     * Where the three thumbs sit, in percent along their surfaces.
+     *
+     * The component writes these as inline `left` / `top` percentages, so they are
+     * readable with no layout at all — which makes them the only evidence a spec has
+     * that the surfaces followed a colour set through the fields. A measured position
+     * would be zero for all three.
+     */
+    getThumbs(): Promise<WrColorPickerThumbs>;
+    /** The HEX field's value without the tab check — for filters, which must not throw. */
+    private readHex;
+    private requireHexField;
+    private channelValues;
+    private writeChannel;
+    private requireTab;
+    /** Every numeric input of the current tab, keyed by the label printed under it. */
+    private inputsByLabel;
+}
+
+/**
+ * @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 `[wrColorPickerTrigger]` — the element that opens a
+ * `<wr-color-picker>` in an overlay.
+ *
+ * The trigger stays in your fixture; the picker it opens does not. So this harness
+ * is loaded from the fixture loader like any element, and {@link getPicker} reaches
+ * ACROSS into the overlay container for you — scoped by the panel id the trigger
+ * publishes through `aria-controls`, never by `.wr-color-picker-overlay`, which
+ * answers with whichever trigger opened first.
+ *
+ * @example
+ * ```ts
+ * const trigger = await loader.getHarness(WrColorPickerTriggerHarness);
+ * const picker = await trigger.open();
+ *
+ * await picker.setHex('#3969e2');
+ * await trigger.sendEscape();
+ * expect(await trigger.isOpen()).toBe(false);
+ * ```
+ *
+ * @see https://ngwr.dev/guides/testing
+ */
+declare class WrColorPickerTriggerHarness extends ComponentHarness {
+    static hostSelector: string;
+    /** Build a predicate that narrows the query — pass to `getHarness` / `getAllHarnesses`. */
+    static with(options?: WrColorPickerTriggerHarnessFilters): HarnessPredicate<WrColorPickerTriggerHarness>;
+    /** The trigger's own text, trimmed. */
+    getText(): Promise<string>;
+    /** Whether the picker is showing, from the trigger's `aria-expanded`. */
+    isOpen(): Promise<boolean>;
+    /**
+     * Whether the trigger refuses to open.
+     *
+     * From `aria-disabled`, which the directive writes for its own `disabled` input.
+     * The host is usually a `<button>`, but the directive does not touch its `disabled`
+     * PROPERTY — a consumer who binds that as well turns the element off at the DOM
+     * level, which is a stronger thing and reads here too.
+     */
+    isDisabled(): Promise<boolean>;
+    /**
+     * The picker this trigger opened, or `null` while it is closed.
+     *
+     * Scoped by the id in `aria-controls`, so two triggers open at once — which
+     * nothing in the component prevents, since only an outside click closes one —
+     * answer with their own panels rather than with whichever came first.
+     */
+    getPicker(): Promise<WrColorPickerHarness | null>;
+    /**
+     * Open the picker and hand it back. An already-open trigger is left alone.
+     *
+     * Throws on a disabled trigger rather than answering `null` three lines later:
+     * `toggle()` returns early while `disabled` is set, so the click lands and nothing
+     * happens at all.
+     */
+    open(): Promise<WrColorPickerHarness>;
+    /** Close the picker. An already-closed trigger is left alone. */
+    close(): Promise<void>;
+    /** Click the trigger once, whichever way that takes it. */
+    toggle(): Promise<void>;
+    /**
+     * Press Escape.
+     *
+     * Sent to the TRIGGER, and it still reaches the picker: the overlay listens through
+     * the CDK's keyboard dispatcher, which keeps one document listener and routes to
+     * the top-most overlay — so this does not depend on where focus happens to be.
+     */
+    sendEscape(): Promise<void>;
+    /** The role the trigger claims to open — `dialog`. */
+    getHasPopup(): Promise<string | null>;
+}
+
+export { WrColorPickerHarness, WrColorPickerTriggerHarness };
+export type { WrColorPickerHarnessFilters, WrColorPickerTab, WrColorPickerThumbs, WrColorPickerTriggerHarnessFilters };

package/types/ngwr-color-picker.d.ts

@@ -236,7 +236,17 @@ declare class WrColorPicker implements FormValueControl<string> {
     protected readonly alphaPercent: _angular_core.Signal<number>;
     protected readonly tabOptions: readonly WrSegmentedOption<Tab>[];
     protected readonly classes: _angular_core.Signal<string>;
-    /** Last string we pushed into `value`; lets the sync effect ignore our own writes. */
+    /**
+     * The one write we just made, held only until the sync effect has seen it.
+     *
+     * It exists so a drag keeps its continuous HSV values instead of being
+     * re-quantised through its own hex round-trip. It used to be set and never
+     * cleared, which turned "ignore this write" into "ignore this STRING,
+     * forever": after the picker emitted `#ff0000` once, an app writing
+     * `#ff0000` back — a reset button, a form patch, an undo — was silently
+     * dropped for the rest of the component's life, and the surface kept
+     * whatever colour the user had dragged to.
+     */
     private lastEmitted;
     constructor();
     protected onPointerDown(event: PointerEvent, surface: Edges): void;
@@ -301,6 +311,8 @@ declare class WrColorPickerTrigger {
     private readonly destroyRef;
     protected readonly isOpen: _angular_core.WritableSignal<boolean>;
     private overlayRef;
+    /** @internal Public so the host binding can read it. */
+    protected readonly panelId: string;
     constructor();
     /** Toggle the picker. Open if closed, close if open. */
     toggle(): void;

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

@@ -66,7 +66,21 @@ declare class WrContextMenu {
      */
     protected readonly openMenuId: _angular_core.WritableSignal<string | null>;
     private overlayRef;
-    private closingTimer;
+    /**
+     * Panes waiting out their exit animation, keyed by the timer that disposes
+     * them.
+     *
+     * A SET, because one handle cannot hold two closings. It used to be a single
+     * `closingTimer`, and the second close inside the 220ms window cleared the
+     * first one's timer instead of its own — so the previous pane's `dispose()`
+     * never ran. `onContextMenu` closes and immediately re-opens, so right-clicking
+     * one target faster than the animation orphaned a pane per click: an
+     * `opacity: 0` box with `pointer-events: auto` eating clicks, a never-destroyed
+     * embedded view, a capture-phase document scroll listener still moving it, and
+     * an undetached ref still registered with CDK's keyboard dispatcher — which
+     * swallowed Escape for the whole page.
+     */
+    private readonly closingPanes;
     private leaveTimer;
     private pressTimer;
     private pressX;

package/types/ngwr-date-picker-testing.d.ts

@@ -1,4 +1,6 @@
-import { BaseHarnessFilters, ComponentHarness, HarnessPredicate, TestElement, HarnessLoader } from '@angular/cdk/testing';
+import { WrCalendarDayHarness } from 'ngwr/calendar/testing';
+export { WrCalendarDayHarness as WrDatePickerDayHarness } from 'ngwr/calendar/testing';
+import { BaseHarnessFilters, ComponentHarness, TestElement, HarnessLoader, HarnessPredicate } from '@angular/cdk/testing';
 
 /**
  * @license
@@ -77,68 +79,6 @@ interface WrDatePickerTimeFields {
     readonly seconds?: 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 one day cell of the calendar inside a date-picker popup.
- *
- * Reached through `WrDatePickerHarness.getDay()` / `getDays()` (or the range
- * picker's), which scope it to ONE picker's panel — the cells are in the 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 WrDatePickerDayHarness extends ComponentHarness {
-    static hostSelector: string;
-    /** Build a predicate that narrows the query. */
-    static with(options?: WrDatePickerDayHarnessFilters): HarnessPredicate<WrDatePickerDayHarness>;
-    /** 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 {@link WrDatePickerHarness.getDay} skips 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
  *
@@ -277,12 +217,12 @@ declare abstract class WrDatePickerHarnessBase extends ComponentHarness {
      * them, since the grid is always six weeks and pads into the neighbouring
      * months.
      */
-    getDays(filters?: WrDatePickerDayHarnessFilters): Promise<WrDatePickerDayHarness[]>;
+    getDays(filters?: WrDatePickerDayHarnessFilters): Promise<WrCalendarDayHarness[]>;
     /**
      * One day of the month on show. The padding days of the neighbouring months are
      * skipped, so `getDay(1)` is the 1st of THIS month and never the 1st of the next.
      */
-    getDay(dayOfMonth: number): Promise<WrDatePickerDayHarness>;
+    getDay(dayOfMonth: number): Promise<WrCalendarDayHarness>;
     /** Click a day of the month on show. */
     selectDay(dayOfMonth: number): Promise<void>;
     /** The trigger button. Both components render it with the same class. */
@@ -514,5 +454,5 @@ declare class WrDateRangePickerHarness extends WrDatePickerHarnessBase {
     private timePanel;
 }
 
-export { WrDatePickerDayHarness, WrDatePickerHarness, WrDateRangePickerHarness };
+export { WrDatePickerHarness, WrDateRangePickerHarness };
 export type { WrDatePickerDayHarnessFilters, WrDatePickerHarnessFilters, WrDatePickerTimeFields, WrDateRangePickerHarnessFilters };