ngwr 10.2.1 → 11.0.0

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

@@ -0,0 +1,221 @@
+import { BaseHarnessFilters, ContentContainerComponentHarness, HarnessPredicate, HarnessLoader } from '@angular/cdk/testing';
+import { WrPopoverPosition } from 'ngwr/popover';
+
+/**
+ * @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 `[wrPopover]` trigger a harness query matches. */
+interface WrPopoverHarnessFilters extends BaseHarnessFilters {
+    /**
+     * Match the trigger's own visible text — the label of the button (or link, or
+     * whatever the directive sits on), not the panel's content. A string is an
+     * exact match, a RegExp is tested.
+     */
+    readonly triggerText?: string | RegExp;
+    /** Match only popovers (`'popover'`) or only tooltips (`'tooltip'`). */
+    readonly mode?: 'popover' | 'tooltip';
+    /** Match only showing (`true`) or only hidden (`false`) panels. */
+    readonly open?: 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 `[wrPopover]` — both shapes the one directive ships:
+ *
+ * - **popover** — template content, opens on click (or hover), announces
+ *   `role="dialog"` and is what the trigger's `aria-expanded` describes;
+ * - **tooltip** — string content, opens on hover AND focus after a delay,
+ *   announces `role="tooltip"` and DESCRIBES its trigger instead of being
+ *   owned by it.
+ *
+ * The panel is never inside the trigger: it is a portal in the overlay
+ * container, a sibling of the whole app. It is reached through the document
+ * root, scoped by the id the trigger publishes while the panel is showing —
+ * `aria-controls` in popover mode, `aria-describedby` in tooltip mode. That id
+ * is what lets two popovers be open at once without reading each other's
+ * content, and it is why every panel reader throws while the panel is shut:
+ * there is no element to answer about.
+ *
+ * Being a CONTENT CONTAINER is the point in popover mode — the panel holds the
+ * consumer's own components, so `popover.getHarness(WrButtonHarness…)` reaches
+ * them without the spec ever touching the overlay.
+ *
+ * **Timing.** A tooltip opens on `showDelay` and hides on `hideDelay`; a hover
+ * popover hides 120ms after the pointer leaves. `open()`, `close()` and the two
+ * waiters sit out that REAL time, so a spec that installs fake timers should
+ * drive the clock itself and read `isOpen()` rather than call them.
+ *
+ * @example
+ * ```ts
+ * const loader = TestbedHarnessEnvironment.loader(fixture);
+ * const details = await loader.getHarness(WrPopoverHarness.with({ triggerText: 'Details' }));
+ *
+ * await details.open();
+ * expect(await details.getRole()).toBe('dialog');
+ * await (await details.getHarness(WrButtonHarness.with({ text: 'Confirm' }))).click();
+ * ```
+ *
+ * @see https://ngwr.dev/guides/testing
+ */
+declare class WrPopoverHarness extends ContentContainerComponentHarness {
+    /**
+     * The directive's host — whatever element the consumer put `[wrPopover]` on.
+     *
+     * Matched by the marker class, not by `[wrPopover]`: popover-mode content is a
+     * `TemplateRef` and so is always BOUND (`[wrPopover]="tpl"`), which leaves no
+     * attribute in the DOM at all, and a CLOSED tooltip publishes no ARIA either.
+     * (A tooltip written with the static string form, `wrPopover="Save changes"`,
+     * does keep the attribute — but only that one shape would be findable by it.)
+     * Same shape as `.wr-dropdown-trigger`.
+     */
+    static hostSelector: string;
+    /** Build a predicate that narrows the query — pass to `getHarness` / `getAllHarnesses`. */
+    static with(options?: WrPopoverHarnessFilters): HarnessPredicate<WrPopoverHarness>;
+    /**
+     * Which shape this trigger carries.
+     *
+     * Read from the ARIA contract, not from the `mode` input: a bound `[mode]`
+     * never reaches the DOM, while `aria-haspopup="dialog"` is on every popover
+     * trigger and on no tooltip trigger — a tooltip is a description of the
+     * control, not a popup it owns.
+     */
+    getMode(): Promise<'popover' | 'tooltip'>;
+    /** The trigger's own visible text. The panel's content is `getContentText()`. */
+    getTriggerText(): Promise<string>;
+    /**
+     * Whether the panel is showing.
+     *
+     * Two different signals because the two modes advertise different things: a
+     * popover flips `aria-expanded` on its trigger, a tooltip has none at all and
+     * links its description instead. So a tooltip's answer is only as good as the
+     * directive's claim on `aria-describedby` — put the tooltip on a control that
+     * is ALSO described by something else (a `<wr-form-field>` hint, say) and the
+     * two bindings fight over one attribute.
+     */
+    isOpen(): Promise<boolean>;
+    /**
+     * Open the panel with the gesture this trigger actually answers to, and wait
+     * until it is showing.
+     *
+     * `trigger` is an input, so the DOM does not say which gesture this popover
+     * wants — the harness moves the pointer on first and falls back to a click.
+     * Hover leads because a click is an outside pointer event for every OTHER open
+     * panel, so leading with it would dismiss someone else's popover on the way to
+     * opening this one; a click-driven popover ignores the hover outright. A
+     * tooltip is never clicked at all — hover and focus are its only gestures.
+     *
+     * Throws when nothing appears: a tooltip with an empty string never opens, and
+     * a spec on fake timers has to advance the clock itself.
+     */
+    open(timeout?: number): Promise<void>;
+    /**
+     * Dismiss the panel and wait until it is gone.
+     *
+     * Escape, because it is the one gesture both modes honour immediately: a
+     * popover is closed by the overlay's keyboard dispatcher, a tooltip by the
+     * directive's own binding — no delay in either. To exercise the delayed
+     * pointer path instead, call `mouseAway()` and then `waitUntilClosed()`.
+     */
+    close(timeout?: number): Promise<void>;
+    /** Click the trigger. Opens a click-driven popover, toggles it shut again, and does nothing else. */
+    click(): Promise<void>;
+    /** Move the pointer onto the trigger — opens a hover popover at once, a tooltip after `showDelay`. */
+    hover(): Promise<void>;
+    /** Move the pointer off the trigger. The panel goes after the grace period, not instantly. */
+    mouseAway(): Promise<void>;
+    /** Focus the trigger — a tooltip's other opening gesture, so keyboard users get the hint too. */
+    focus(): Promise<void>;
+    /** Blur the trigger, which hides a tooltip after `hideDelay`. */
+    blur(): Promise<void>;
+    /** Press Escape on the trigger. Both modes dismiss on it, and neither moves focus. */
+    sendEscape(): Promise<void>;
+    /** Wait out a pending show. Resolves at once when the panel is already up. */
+    waitUntilOpen(timeout?: number): Promise<void>;
+    /** Wait out a pending hide. Resolves at once when the panel is already gone. */
+    waitUntilClosed(timeout?: number): Promise<void>;
+    /**
+     * The panel's text.
+     *
+     * In tooltip mode that is the string itself, rendered into the small text
+     * panel; in popover mode it is everything the projected template renders.
+     */
+    getContentText(): Promise<string>;
+    /**
+     * The role the open panel announces: `'dialog'` for a popover, `'tooltip'` for
+     * a tooltip.
+     *
+     * Worth asserting rather than assuming, twice over: the directive sets it on
+     * the OVERLAY PANE, not on the content a consumer wrote, and in tooltip mode
+     * the pane is deliberately the only element carrying it — the text panel
+     * inside has none, or the description would nest a tooltip in a tooltip.
+     */
+    getRole(): Promise<string | null>;
+    /**
+     * The panel's accessible name — `null` in tooltip mode.
+     *
+     * A popover is a named `role="dialog"`: the `ariaLabel` input, or the i18n
+     * catalog's `popover.label` when the consumer says nothing, because an unnamed
+     * dialog announces as "dialog" and nothing else. A tooltip has no name of its
+     * own; it IS the trigger's description, which is `getDescriptionText()`.
+     */
+    getLabel(): Promise<string | null>;
+    /**
+     * Whether the panel claims modality.
+     *
+     * `false`, deliberately, and worth pinning: the popover sets
+     * `aria-modal="false"` because focus is NOT trapped and the panel dismisses on
+     * outside click / Escape rather than blocking the page.
+     */
+    isModal(): Promise<boolean>;
+    /**
+     * Where the panel sits relative to the trigger, or `null` when it is presented
+     * as a sheet and has no anchor.
+     *
+     * The resolved position — the directive defaults it per mode (`bottom` for a
+     * popover, `top` for a tooltip) — read off the pane's public modifier class.
+     * The arrow itself is a `::after` pseudo-element, so it exists for no DOM query
+     * at all; this class is the placement, and it is what the arrow's own CSS keys
+     * off.
+     */
+    getPosition(): Promise<WrPopoverPosition | null>;
+    /** Whether the popover is presented as a full-width bottom sheet instead of an anchored panel. */
+    isSheet(): Promise<boolean>;
+    /**
+     * The text a screen reader reads as the TRIGGER'S DESCRIPTION, or `null` when
+     * it describes nothing.
+     *
+     * This resolves `aria-describedby` the way an assistive technology would, so
+     * it answers the whole of tooltip mode's naming contract in one call. Always
+     * `null` for a popover, open or shut — a popover is a thing the trigger owns
+     * (`aria-haspopup` / `aria-expanded`), never a description of it.
+     */
+    getDescriptionText(): Promise<string | null>;
+    /**
+     * Harnesses for the consumer's own components are resolved inside THIS
+     * instance's panel.
+     *
+     * Scoped by the published id rather than by `.wr-popover-overlay`: the overlay
+     * container is shared, so a class query would answer with whichever popover
+     * opened first.
+     */
+    protected getRootHarnessLoader(): Promise<HarnessLoader>;
+    /** Poll until `isOpen()` reports `open`, and say whether it did. */
+    private settled;
+    /** This instance's overlay pane. */
+    private panel;
+    /** The id the trigger publishes for its panel, which only exists while the panel does. */
+    private panelId;
+}
+
+export { WrPopoverHarness };
+export type { WrPopoverHarnessFilters };

package/types/ngwr-popover.d.ts

@@ -58,6 +58,7 @@ declare class WrPopover {
     readonly closed: _angular_core.OutputEmitterRef<void>;
     private readonly host;
     private readonly overlay;
+    private readonly dir;
     private readonly outsideClick;
     private readonly responsiveConfig;
     private readonly vcr;
@@ -100,6 +101,14 @@ declare class WrPopover {
     private readonly onOverlayEnter;
     private scheduleHoverClose;
     private clearHoverClose;
+    /**
+     * Whether the app reads right-to-left.
+     *
+     * Optional inject: `Directionality` is root-provided, so this is never null in
+     * an app — but a bare `TestBed` that provides nothing should still get a
+     * component that works, and defaulting to LTR is the honest fallback.
+     */
+    private isRtl;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<WrPopover, never>;
     static ɵdir: _angular_core.ɵɵDirectiveDeclaration<WrPopover, "[wrPopover]", never, { "content": { "alias": "wrPopover"; "required": true; "isSignal": true; }; "mode": { "alias": "mode"; "required": false; "isSignal": true; }; "trigger": { "alias": "trigger"; "required": false; "isSignal": true; }; "position": { "alias": "position"; "required": false; "isSignal": true; }; "showDelay": { "alias": "showDelay"; "required": false; "isSignal": true; }; "hideDelay": { "alias": "hideDelay"; "required": false; "isSignal": true; }; "responsive": { "alias": "responsive"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; }, { "opened": "opened"; "closed": "closed"; }, never, never, true, never>;
 }

package/types/ngwr-pull-to-refresh.d.ts

@@ -61,6 +61,13 @@ declare class WrPullToRefresh {
     constructor();
     protected onTouchStart(event: TouchEvent): void;
     protected onTouchMove(event: TouchEvent): void;
+    /**
+     * A cancelled touch is an ABANDONED pull, not a completed one — the system took
+     * the gesture away (a call, a notification, a palm on the bezel). Routing it
+     * through `onTouchEnd` refreshed the list on an interruption the user did not
+     * ask for and could not take back.
+     */
+    protected onTouchCancel(): void;
     protected onTouchEnd(): void;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<WrPullToRefresh, never>;
     static ɵcmp: _angular_core.ɵɵComponentDeclaration<WrPullToRefresh, "wr-pull-to-refresh", never, { "refreshing": { "alias": "refreshing"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "threshold": { "alias": "threshold"; "required": false; "isSignal": true; }; }, { "refresh": "refresh"; }, never, ["*"], true, never>;

package/types/ngwr-qr.d.ts

@@ -45,11 +45,19 @@ declare class WrQr {
     readonly iconUrl: _angular_core.InputSignal<string | null>;
     /** Center icon size in logical pixels. @default 42 */
     readonly iconSize: _angular_core.InputSignalWithTransform<number, unknown>;
+    /**
+     * Accessible name. A QR code is content — it usually encodes a URL — and a
+     * `<canvas>` carries no implicit role and no text alternative, so without a name it
+     * is nothing at all to a screen reader. Say what the code is FOR when you can.
+     * Falls back to `qr.label`.
+     */
+    readonly ariaLabel: _angular_core.InputSignal<string | null>;
+    protected readonly resolvedAriaLabel: _angular_core.Signal<string>;
     protected readonly canvas: _angular_core.Signal<ElementRef<HTMLCanvasElement> | undefined>;
     protected readonly isBrowser: boolean;
     constructor();
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<WrQr, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<WrQr, "wr-qr", never, { "value": { "alias": "value"; "required": true; "isSignal": true; }; "level": { "alias": "level"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "padding": { "alias": "padding"; "required": false; "isSignal": true; }; "color": { "alias": "color"; "required": false; "isSignal": true; }; "bgColor": { "alias": "bgColor"; "required": false; "isSignal": true; }; "iconUrl": { "alias": "iconUrl"; "required": false; "isSignal": true; }; "iconSize": { "alias": "iconSize"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<WrQr, "wr-qr", never, { "value": { "alias": "value"; "required": true; "isSignal": true; }; "level": { "alias": "level"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "padding": { "alias": "padding"; "required": false; "isSignal": true; }; "color": { "alias": "color"; "required": false; "isSignal": true; }; "bgColor": { "alias": "bgColor"; "required": false; "isSignal": true; }; "iconUrl": { "alias": "iconUrl"; "required": false; "isSignal": true; }; "iconSize": { "alias": "iconSize"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 
 export { WrQr };

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

@@ -0,0 +1,296 @@
+import { BaseHarnessFilters, ComponentHarness, HarnessPredicate } from '@angular/cdk/testing';
+import { WrRadioSize } from 'ngwr/radio';
+
+/**
+ * @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-radio-group>` a harness query matches. */
+interface WrRadioGroupHarnessFilters extends BaseHarnessFilters {
+    /**
+     * Match the `name` the group shares with its radios — a string is an exact
+     * match, a RegExp is tested. Left unset, the group generates a random name, so
+     * this only identifies a group whose `name` the consumer wrote.
+     */
+    readonly name?: string | RegExp;
+    /** Match only groups that refuse every option (`true`) or offer at least one (`false`). */
+    readonly disabled?: boolean;
+}
+/** Narrows which `<wr-radio>` a harness query matches. */
+interface WrRadioHarnessFilters extends BaseHarnessFilters {
+    /** Match the projected label — a string is an exact match, a RegExp is tested. */
+    readonly label?: string | RegExp;
+    /**
+     * Match the option's `value`, which only works for a value the template wrote
+     * literally (`value="sm"`). A bound `[value]` never reaches the DOM, so no
+     * pattern matches it — see `WrRadioHarness.getValue`.
+     */
+    readonly value?: string | RegExp;
+    /** Match only the selected option (`true`) or only the others (`false`). */
+    readonly checked?: boolean;
+    /** Match only enabled (`false`) or only disabled (`true`) options. */
+    readonly disabled?: 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 `<wr-radio>` — an option, not a control.
+ *
+ * The visible dot is a `<span>` the stylesheet paints; the state lives on a real
+ * `<input type="radio">` inside the label, and that is what this reads and clicks.
+ * A radio cannot exist alone — the component throws when it is constructed outside
+ * a `<wr-radio-group>` — so `WrRadioGroupHarness` is where the SELECTION lives and
+ * this answers questions about one option.
+ *
+ * There is no `aria-checked` here to prefer over the DOM, and that is right: a
+ * native radio carries its state in the `checked` IDL property, so the ARIA
+ * attribute would only be a second source of truth for a screen reader to
+ * disagree with. {@link isChecked} reads the property, which is the state.
+ *
+ * @example
+ * ```ts
+ * const medium = await loader.getHarness(WrRadioHarness.with({ label: 'Medium' }));
+ * await medium.check();
+ * expect(await medium.isChecked()).toBe(true);
+ * ```
+ *
+ * @see https://ngwr.dev/guides/testing
+ */
+declare class WrRadioHarness extends ComponentHarness {
+    static hostSelector: string;
+    /** Build a predicate that narrows the query — pass to `getHarness` / `getAllHarnesses`. */
+    static with(options?: WrRadioHarnessFilters): HarnessPredicate<WrRadioHarness>;
+    private readonly input;
+    private readonly label;
+    /** The projected label text, trimmed. An icon lives in the dot, so it is not part of it. */
+    getLabel(): Promise<string>;
+    /**
+     * The option's value as the template WROTE it, or `null` when it was bound.
+     *
+     * The gap worth knowing about before a spec leans on this: `value` is `unknown`,
+     * and the component never puts it on the native input — the group holds the
+     * selection and a radio only says which one it is. So the only `value` in the
+     * DOM is the static attribute Angular leaves behind for a literal `value="sm"`;
+     * `[value]="size"` reaches the component without ever touching the page and
+     * reads `null` here whatever it holds, which for an object value it always will.
+     *
+     * Address options by their LABEL when it matters, and assert the picked value on
+     * the host's own model, which is the only place it exists.
+     */
+    getValue(): Promise<string | null>;
+    /**
+     * The `name` the group stamps on this radio's native input.
+     *
+     * It is the whole of the group's keyboard behaviour: one shared name is what
+     * makes a browser treat the radios as a single tab stop, walk the arrow keys
+     * between them and announce "1 of 3". None of that is implemented in the
+     * component, so a name that stops being shared takes all of it away silently.
+     */
+    getName(): Promise<string>;
+    /**
+     * Whether this option is the group's answer.
+     *
+     * Read from the input's `checked` PROPERTY: `[checked]` is a property binding,
+     * so the attribute is never written and reading it would report `null` for a
+     * radio with a visible dot.
+     */
+    isChecked(): Promise<boolean>;
+    /**
+     * Whether the option refuses selection — for either reason.
+     *
+     * The native input is disabled by this radio's own `disabled` OR by the group's,
+     * and from outside they are the same thing: the option cannot be picked.
+     */
+    isDisabled(): Promise<boolean>;
+    /**
+     * The control size, from the host modifier.
+     *
+     * `md` is the default and carries NO modifier class, so its absence is the
+     * answer rather than a missing one.
+     */
+    getSize(): Promise<WrRadioSize>;
+    /** Whether the dot is filled by an icon instead of the default solid circle. */
+    hasIcon(): Promise<boolean>;
+    /**
+     * Whether the `<label for>` really points at this radio's input.
+     *
+     * Not the option's only naming route, and worth being precise about: the input
+     * sits INSIDE the `<label>`, so the implicit association already names it and a
+     * `for` that misses does not leave the radio unnamed. What a stray `for` does
+     * take away is the pairing every consumer assumes — it hands label clicks, and
+     * anything that references the label, to whatever else on the page owns that id.
+     */
+    isLabelBound(): Promise<boolean>;
+    /**
+     * Pick this option, the way a user does — a click on the native input.
+     *
+     * Nothing happens when it is already checked (a radio has no untick), and
+     * nothing happens when it is disabled, so assert the result rather than assume
+     * it — or reach for `WrRadioGroupHarness.select()`, which says which of the two
+     * it was.
+     *
+     * A click rather than a keypress, despite jsdom having no layout: the events are
+     * dispatched onto the input itself, so nothing is hit-tested and the zero-sized
+     * rect jsdom reports for every element cannot miss its target, and the
+     * `change` event it produces is exactly the one the component listens for. The
+     * arrow keys that would move a real user between options are the BROWSER's
+     * behaviour over a shared `name`, not the component's, and jsdom implements none
+     * of it — there is nothing here for a keyboard to drive.
+     */
+    check(): Promise<void>;
+    /** Move keyboard focus onto the real control. */
+    focus(): Promise<void>;
+    /**
+     * Take focus off the radio — which is what makes the GROUP emit `touch`, since a
+     * blur from any child is what marks a bound field touched.
+     */
+    blur(): Promise<void>;
+    isFocused(): Promise<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-radio-group>` — the control a `<wr-radio>` only means
+ * anything inside of, and the root of a two-part family with {@link WrRadioHarness}.
+ *
+ * Options are addressed by their LABEL rather than by their value, and there is
+ * deliberately no `getValue()` here. The group's value is a signal of `unknown`
+ * that the component never writes to the DOM: not to the group element, not to a
+ * radio's native input. The one thing on the page is whatever static attribute the
+ * template happened to leave behind, so a selection made through `[(value)]`, a
+ * `[formField]` or an object is not there at all, and a harness reporting it would
+ * be guessing. {@link getSelectedLabel} says what the page says, and a spec that
+ * needs the value itself asserts the host's own model — which is the assertion that
+ * would have caught the bug anyway.
+ *
+ * Arrow-key navigation is not this component's either: the radios share one `name`
+ * attribute and the browser does the rest, so jsdom — which implements none of it
+ * — leaves nothing for a keyboard to drive. {@link getName} is what a spec should
+ * pin instead, because losing the shared name is what actually takes arrow
+ * navigation away, and {@link getTabStopLabel} answers the other half.
+ *
+ * @example
+ * ```ts
+ * const size = await loader.getHarness(WrRadioGroupHarness.with({ name: 'size' }));
+ *
+ * expect(await size.getRadioLabels()).toEqual(['Small', 'Medium', 'Large']);
+ * await size.select({ label: 'Large' });
+ * expect(await size.getSelectedLabel()).toBe('Large');
+ * ```
+ *
+ * @see https://ngwr.dev/guides/testing
+ */
+declare class WrRadioGroupHarness extends ComponentHarness {
+    static hostSelector: string;
+    /** Build a predicate that narrows the query — pass to `getHarness` / `getAllHarnesses`. */
+    static with(options?: WrRadioGroupHarnessFilters): HarnessPredicate<WrRadioGroupHarness>;
+    /**
+     * The role the group announces — `radiogroup`, which is what tells a screen
+     * reader that the options belong to one question and how many of them there are.
+     */
+    getRole(): Promise<string | null>;
+    /**
+     * The group's accessible name, resolved in the order a screen reader resolves it:
+     * the text of every element `aria-labelledby` points at, and `aria-label` only
+     * when that named nothing. `null` when the consumer wired neither.
+     *
+     * The order is not interchangeable — `aria-labelledby` WINS over `aria-label` in
+     * the accessible-name computation, so a group carrying both is announced by the
+     * heading it points at and reporting the `aria-label` would describe a name
+     * nobody hears.
+     *
+     * That `null` is a finding rather than a detail — a `radiogroup` with no name
+     * announces three answers and never the question. The component ships no label
+     * input on purpose (the question is the consumer's own heading), so this is the
+     * only way to check the wiring held.
+     */
+    getAccessibleName(): Promise<string | null>;
+    /**
+     * The `name` every radio in the group shares.
+     *
+     * Read off the radios because they are the only place it is RELIABLY written: the
+     * group's `name` input reaches the page as an attribute on each native input, and
+     * a bound `[name]="…"` never lands on the group element at all. A literal
+     * `name="size"` does survive on the group element — Angular leaves a static
+     * attribute alone — which is exactly the trap: reading it there works for the
+     * literal form and quietly returns nothing for the bound one.
+     */
+    getName(): Promise<string>;
+    /**
+     * Whether the group refuses every option.
+     *
+     * Answered from the radios, and it could not be otherwise: a bound `[disabled]`
+     * on the group reaches the page only by disabling each native input, so a group
+     * disabled as a whole and a group whose every option is individually disabled
+     * are the same page. They are also the same thing to the person using it, which
+     * is the question a harness should be answering.
+     */
+    isDisabled(): Promise<boolean>;
+    /** The group's own options, in DOM order. A sibling group's radios are not here. */
+    getRadios(filters?: WrRadioHarnessFilters): Promise<WrRadioHarness[]>;
+    /** The label of every option, in DOM order. */
+    getRadioLabels(): Promise<string[]>;
+    /** The checked option, or `null` while the group is unanswered. */
+    getSelectedRadio(): Promise<WrRadioHarness | null>;
+    /**
+     * The label of the checked option, or `null` while the group is unanswered.
+     *
+     * Also `null` for a value that matches no radio — the group holds it, nothing is
+     * checked, and the page shows an unanswered question.
+     */
+    getSelectedLabel(): Promise<string | null>;
+    /**
+     * Pick the first option matching the filters — this is how the group's value
+     * changes.
+     *
+     * Throws when nothing matches, naming the options that do exist, and throws
+     * again when the option is still unchecked afterwards. That second failure has
+     * exactly two causes and reports both, because a click that quietly did nothing
+     * surfaces as an unrelated assertion three lines later.
+     */
+    select(filters: WrRadioHarnessFilters): Promise<void>;
+    /**
+     * The label of the option a Tab press would land on, or `null` when every option
+     * is disabled and the group is skipped over entirely.
+     *
+     * A radio group is ONE tab stop, and which radio it is is written down nowhere:
+     * the component authors no roving `tabindex`, because the browser already
+     * applies the native rule to a shared `name` — the checked radio, or the first
+     * enabled one while nothing is checked. So this is DERIVED from the rendered
+     * state rather than read off an attribute, there being no attribute to read.
+     *
+     * Worth asking precisely because those two answers are different radios exactly
+     * when a form opens unanswered, which is the state most specs start in.
+     */
+    getTabStopLabel(): Promise<string | null>;
+    /** Put focus where a Tab press would put it. Throws when the group has no tab stop. */
+    focusTabStop(): Promise<void>;
+    /**
+     * The label of the option that currently holds focus, or `null` when focus is
+     * elsewhere. The counterpart to {@link focusTabStop}: in a real browser the
+     * arrow keys move this, and moving it is also what picks a new answer.
+     */
+    getFocusedLabel(): Promise<string | null>;
+    /** The radio Tab would enter on, applying the browser's rule to the rendered state. */
+    private tabStop;
+    /** The options, or a failure saying why an empty group has nothing to report. */
+    private radiosOrThrow;
+}
+
+export { WrRadioGroupHarness, WrRadioHarness };
+export type { WrRadioGroupHarnessFilters, WrRadioHarnessFilters };

package/types/ngwr-radio.d.ts

@@ -27,8 +27,14 @@ declare class WrRadio {
      * default solid circle. Use any registered NGWR icon.
      */
     readonly icon: _angular_core.InputSignal<string | null>;
-    /** Control size — shares the `--wr-control-*` contract. @default 'md' */
-    readonly size: _angular_core.InputSignal<WrRadioSize>;
+    /**
+     * Control size — shares the `--wr-control-*` contract. Set per option (the
+     * group has no `size`); unset falls back to the `radio.size` app default from
+     * `provideWrConfig()`. @default 'md'
+     */
+    readonly size: _angular_core.InputSignal<WrRadioSize | null>;
+    /** `size`, then the app config, then `md`. @internal */
+    protected readonly resolvedSize: _angular_core.Signal<"sm" | "md" | "lg">;
     /**
      * Disable just this option. The group can also be disabled as a whole via
      * `<wr-radio-group disabled>`; either source disables this radio.