ngwr 10.2.0 → 11.0.0

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

@@ -0,0 +1,470 @@
+import { BaseHarnessFilters, ContentContainerComponentHarness, HarnessPredicate, HarnessLoader, ComponentHarness } 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
+ */
+
+/**
+ * The sizes a strip renders — the `size` input as the host actually paints it.
+ *
+ * `md` is the default and carries no modifier class, so it is read as the ABSENCE
+ * of the other two. `<wr-tabs>` resolves this input on its own rather than through
+ * `provideWrConfig()`, so what the harness reports and what the consumer wrote are
+ * the same thing here.
+ */
+type WrTabsHarnessSize = 'sm' | 'md' | 'lg';
+/** Narrows which `<wr-tabs>` a harness query matches. */
+interface WrTabsHarnessFilters extends BaseHarnessFilters {
+    /**
+     * Match a strip that offers a tab with this label — a string is an exact match,
+     * a RegExp is tested. Any of its tabs, not the selected one; see `selectedLabel`.
+     */
+    readonly tabLabel?: string | RegExp;
+    /**
+     * Match the label of the SELECTED tab — a string is an exact match, a RegExp is
+     * tested. A strip with no selected tab (a router strip whose route matches none
+     * of them) never matches.
+     */
+    readonly selectedLabel?: string | RegExp;
+    /** Match the size the strip renders at. */
+    readonly size?: WrTabsHarnessSize;
+    /**
+     * Match only router strips (`true`) or only content strips (`false`).
+     *
+     * One `routerLink` anywhere in the strip switches the whole thing over, so this
+     * is a property of the strip and not of one tab.
+     */
+    readonly router?: boolean;
+}
+/**
+ * Narrows which tab of a `<wr-tabs>` strip a harness query matches.
+ *
+ * Tabs are addressed by their LABEL rather than by their `key`: the key names the
+ * tab in the `active` model and reaches the DOM only buried inside the generated
+ * header and panel ids, and a tab that never set one carries a random id instead.
+ */
+interface WrTabHarnessFilters extends BaseHarnessFilters {
+    /** Match the tab's visible label — a string is an exact match, a RegExp is tested. */
+    readonly label?: string | RegExp;
+    /** Match only the selected tab (`true`) or only the others (`false`). */
+    readonly selected?: boolean;
+    /** Match only disabled (`true`) or only enabled (`false`) tabs. */
+    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 tab of a `<wr-tabs>` strip — the header, and the panel it
+ * controls.
+ *
+ * Its host is the RENDERED HEADER, not the `<wr-tab>` element. A `<wr-tab>` is
+ * `display:none` and holds nothing but a `<ng-template>`: the label, the selection
+ * state, the tab stop and the click target all live on the element the parent
+ * renders for it, which is a `<button role="tab">` in content mode and an
+ * `<a role="tab">` in router mode. A harness hosted on `wr-tab` would answer every
+ * question with nothing.
+ *
+ * Also a CONTENT CONTAINER, scoped to the panel this tab controls, so
+ * `tab.getHarness(WrButtonHarness…)` reaches the consumer's own components inside
+ * the tab's content. The panel is not a descendant of the header — it is a sibling
+ * of the whole strip — so it is resolved through the `aria-controls` id, which is
+ * also the pairing {@link isPanelBound} checks. Only the SELECTED tab has a panel
+ * to reach: `<wr-tabs>` renders one panel and destroys it on every switch.
+ *
+ * @example
+ * ```ts
+ * const tabs = await loader.getHarness(WrTabsHarness);
+ * const [first] = await tabs.getTabs();
+ *
+ * expect(await first.isSelected()).toBe(true);
+ * expect(await first.isPanelBound()).toBe(true);
+ * await (await first.getHarness(WrButtonHarness.with({ text: 'Save' }))).click();
+ * ```
+ *
+ * @see https://ngwr.dev/guides/testing
+ */
+declare class WrTabHarness extends ContentContainerComponentHarness {
+    /** The header the strip renders for a `<wr-tab>` — a `<button>`, or an `<a>` in router mode. */
+    static hostSelector: string;
+    /** Build a predicate that narrows the query — pass to `getHarness` / `getAllHarnesses`. */
+    static with(options?: WrTabHarnessFilters): HarnessPredicate<WrTabHarness>;
+    /** The tab's visible label, trimmed — the `<wr-tab>`'s `title`. */
+    getLabel(): Promise<string>;
+    /**
+     * The header's own id, which is what the panel points back at with
+     * `aria-labelledby` — the tab is the panel's accessible name.
+     *
+     * Generated from the tab's `key`, so two strips on one page whose tabs share keys
+     * publish the same ids and each panel then names whichever header came first.
+     */
+    getId(): Promise<string | null>;
+    /**
+     * Whether this is the strip's selected tab.
+     *
+     * `aria-selected` first, because that is the state a screen reader acts on and
+     * the `--active` class is only what it looks like. A ROUTER tab carries no
+     * `aria-selected` at all — the router paints the class through
+     * `routerLinkActive` and nothing announces the selection — so the class is the
+     * fallback rather than the first choice, and the two branches are not
+     * interchangeable: reading the class first would report a content tab as selected
+     * while `aria-selected="false"` told assistive tech otherwise.
+     */
+    isSelected(): Promise<boolean>;
+    /**
+     * Whether the tab refuses activation.
+     *
+     * The two shapes say it differently and both are read: a content tab is a real
+     * `<button>` and carries the native `disabled`, a router tab is an `<a>` — which
+     * cannot be disabled natively — and carries `aria-disabled` with `tabindex="-1"`.
+     * The `--disabled` class is on both and is deliberately not the source: a class
+     * says how the tab looks, these two say what it refuses.
+     */
+    isDisabled(): Promise<boolean>;
+    /** Whether this tab is a link — the router shape, where selection follows the route. */
+    isLink(): Promise<boolean>;
+    /**
+     * The resolved href of a router tab, or `null` for a content tab.
+     *
+     * `null` is the answer for a `<button>` rather than a gap — a content tab
+     * navigates nowhere, it swaps a panel.
+     */
+    getHref(): Promise<string | null>;
+    /**
+     * Whether a Tab press can land on this header.
+     *
+     * A content strip is ONE tab stop and hands it to the selected tab; a router
+     * strip makes every enabled tab a stop of its own. See
+     * `WrTabsHarness.getTabStopLabels()` — the difference is a mode difference, not
+     * a rounding error.
+     *
+     * A non-negative `tabindex` is not enough on its own, which is why `disabled` is
+     * read too: `<wr-tabs>` gives the roving `tabindex="0"` to whatever `active`
+     * names without checking whether that tab is disabled, so a host binding `active`
+     * to a disabled tab's key renders a `<button disabled tabindex="0">` — which no
+     * Tab press reaches. jsdom will focus such a button anyway, so this is the only
+     * place a unit test can tell the difference.
+     */
+    isTabStop(): Promise<boolean>;
+    /**
+     * The id of the panel this tab controls, or `null` when it controls none.
+     *
+     * `null` for a router tab — the strip renders no panel in that mode, the consumer
+     * drops a `<router-outlet>` after it — and that missing `aria-controls` is the
+     * honest report: there is nothing for the header to point at.
+     */
+    getPanelId(): Promise<string | null>;
+    /** Whether this tab's panel is in the DOM right now — true only for the selected tab. */
+    hasPanel(): Promise<boolean>;
+    /**
+     * Whether the panel and this header really name each other.
+     *
+     * Both halves, because each covers a different failure: the header's
+     * `aria-controls` has to reach the panel that is showing, and the panel's
+     * `aria-labelledby` has to come back to THIS header. A panel wired to the wrong
+     * tab looks perfect on screen — the right content is under the right header — and
+     * announces the wrong name, which is the whole of a tabbed interface for anyone
+     * not looking at it. It also has to be a `tabpanel`: the reference resolving to
+     * some other element is a broken pairing, not a styling detail.
+     *
+     * Throws when there is no panel at all, which is a different fact from a broken
+     * pairing — see {@link getPanelText}.
+     */
+    isPanelBound(): Promise<boolean>;
+    /**
+     * The text of this tab's panel, trimmed.
+     *
+     * Throws rather than answering `''` for a tab whose panel is not rendered, and
+     * the message says which of the two reasons it is: `<wr-tabs>` keeps only the
+     * selected tab's panel in the DOM (the content of every other tab sits in an
+     * unrendered `<ng-template>`, so switching tabs destroys a panel and builds the
+     * next one), and a router strip renders no panel at all.
+     */
+    getPanelText(): Promise<string>;
+    /**
+     * Activate this tab the way a pointer does.
+     *
+     * A disabled CONTENT tab is left alone: it is a real `<button disabled>`, which
+     * fires no click at all. A disabled ROUTER tab is NOT — the anchor carries
+     * `aria-disabled="true"` and `tabindex="-1"`, and nothing cancels its
+     * `routerLink`, so a click on it still navigates. That is a gap in the component
+     * rather than in this harness, and it is why a router strip's expectations belong
+     * on the resolved route rather than on the click.
+     */
+    click(): Promise<void>;
+    /** Move keyboard focus onto this header. */
+    focus(): Promise<void>;
+    /** Take focus off this header. */
+    blur(): Promise<void>;
+    /** Whether this header holds keyboard focus — the roving cursor, not the selection. */
+    isFocused(): Promise<boolean>;
+    /** `getHarness(…)` searches this tab's PANEL, which is where its content is. */
+    protected getRootHarnessLoader(): Promise<HarnessLoader>;
+    /** The panel element, or `null` when this tab has none rendered. */
+    private panelOrNull;
+    /** The panel element, or a failure naming which of the two reasons there isn't one. */
+    private panelOrThrow;
+    /** This tab's `aria-controls`, or a failure saying a router strip has no panels. */
+    private panelIdOrThrow;
+    /**
+     * An id selector that survives the id it is given.
+     *
+     * `[id="…"]` rather than `#…`: the ids here are built from the consumer's `key`,
+     * and a key holding a dot, a colon or a leading digit turns `#id` into a selector
+     * that either throws or matches something else entirely.
+     */
+    private static byId;
+}
+
+/**
+ * @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-tabs>`, with {@link WrTabHarness} for one tab and the panel
+ * it controls.
+ *
+ * The component has two modes and they answer "which tab is active" differently,
+ * which is most of what this harness exists to keep straight:
+ *
+ * - **Content** — the tabs are `<button role="tab">`s, the strip is ONE tab stop
+ *   (the roving `tabindex` sits on the selected tab), and the arrow keys ACTIVATE
+ *   the tab they move to, the APG's automatic-activation pattern. `<wr-tabs>`
+ *   renders exactly one panel: the selected tab's.
+ * - **Router** — one `routerLink` on any child switches the whole strip over. The
+ *   tabs become `<a role="tab">`s, they announce no `aria-selected` at all (the
+ *   router paints `--active` and nothing else), the strip renders NO panel, and it
+ *   stops being one tab stop — every enabled tab is a Tab stop of its own. The
+ *   arrow keys still move focus, but they select nothing: the route does that.
+ *
+ * So {@link getSelectedLabel} and {@link getFocusedLabel} are two different
+ * questions, and {@link getTabStopLabels} is a third. They coincide in content mode
+ * and come apart in router mode; a spec that asserts one and means another passes
+ * through the bug.
+ *
+ * Everything here is driven from the KEYBOARD rather than by clicking a coordinate:
+ * a unit test has no layout, so a hit test would answer with nothing, and the
+ * keyboard is the accessible path anyway. {@link select} is the exception — a
+ * no-arg click needs no coordinate.
+ *
+ * @example
+ * ```ts
+ * const tabs = await loader.getHarness(WrTabsHarness);
+ *
+ * expect(await tabs.getTabLabels()).toEqual(['One', 'Two', 'Three']);
+ * await tabs.select({ label: 'Two' });
+ * expect(await tabs.getPanelText()).toContain('Second panel');
+ * ```
+ *
+ * @see https://ngwr.dev/reference/components/tabs
+ * @see https://ngwr.dev/guides/testing
+ */
+declare class WrTabsHarness extends ComponentHarness {
+    static hostSelector: string;
+    /** Build a predicate that narrows the query — pass to `getHarness` / `getAllHarnesses`. */
+    static with(options?: WrTabsHarnessFilters): HarnessPredicate<WrTabsHarness>;
+    /**
+     * The role the strip announces — `tablist`.
+     *
+     * Read off the strip, not the host: `<wr-tabs>` carries the `wr-tabs` class and no
+     * role of its own, and the `tablist` is the scrolling `.wr-tabs__strip` inside it.
+     * Without that role the headers are a row of buttons: nothing tells a screen
+     * reader how many tabs there are or which one of them is showing.
+     */
+    getRole(): Promise<string | null>;
+    /**
+     * The axis the strip announces, which decides which arrow keys a screen-reader
+     * user is told to press.
+     *
+     * `<wr-tabs>` ships one orientation — the strip is a horizontal scroller and hard
+     * codes `aria-orientation="horizontal"` — so today this always answers
+     * `'horizontal'`. It is read from the DOM and normalized the way ARIA reads it:
+     * anything that is not `vertical`, a missing attribute included, is `'horizontal'`,
+     * the default for a `tablist`.
+     *
+     * Which means an assertion here catches a strip that starts ANNOUNCING `vertical`
+     * while its arrow keys still walk the horizontal axis — and cannot catch the
+     * mirror image, a vertical mode that forgets to update the attribute: that one
+     * answers `'horizontal'` and looks unchanged. One attribute is all this reads.
+     */
+    getOrientation(): Promise<'horizontal' | 'vertical'>;
+    /**
+     * The size the strip renders at, from the host modifier.
+     *
+     * `md` is the default and paints no modifier of its own, so its absence is the
+     * answer rather than a missing one.
+     */
+    getSize(): Promise<WrTabsHarnessSize>;
+    /**
+     * Whether this strip navigates instead of swapping panels.
+     *
+     * Derived from what got RENDERED — a router tab is an `<a>` — rather than from the
+     * `routerLink` inputs, because the switch is all-or-nothing: one `routerLink`
+     * anywhere in the strip turns every tab into a link and drops the panel. A strip
+     * with no tabs at all is content mode, which is what the component does with it.
+     */
+    isRouterMode(): Promise<boolean>;
+    /**
+     * This strip's tabs, in render order.
+     *
+     * Scoped to this strip rather than to the host, which is what keeps a `<wr-tabs>`
+     * NESTED in a panel from answering for its parent: the inner strip is a descendant
+     * of the outer host, so a host-wide query would hand back both sets of tabs as one
+     * flat list.
+     */
+    getTabs(filters?: WrTabHarnessFilters): Promise<WrTabHarness[]>;
+    /** The label of every tab, in render order. */
+    getTabLabels(): Promise<string[]>;
+    /**
+     * The selected tab, or `null` when none is.
+     *
+     * A content strip always has one — it falls back to the first tab when `active`
+     * matches nothing — so `null` means a router strip whose current route matches no
+     * tab, or a strip with no tabs.
+     */
+    getSelectedTab(): Promise<WrTabHarness | null>;
+    /** The label of the selected tab, or `null` when none is selected. */
+    getSelectedLabel(): Promise<string | null>;
+    /**
+     * Select the first tab matching the filters, the way a pointer does.
+     *
+     * Throws when nothing matches, naming the tabs that do exist, and throws again
+     * when the tab is still unselected afterwards — with both causes named, because a
+     * click that quietly did nothing surfaces as an unrelated assertion three lines
+     * later. Those causes are a disabled CONTENT tab (a `<button disabled>` never sees
+     * the click at all) and a router strip whose navigation did not land on this tab.
+     *
+     * A router strip is otherwise fine here: the click starts a route change, the
+     * harness stabilizes the pending navigation before it re-reads the strip, and
+     * `routerLinkActive` has painted the selection by then — so this resolves. It is a
+     * guard, a redirect or an unmatched path that leaves the tab unselected. Note that
+     * `disabled` does not stop a router tab at all; see {@link WrTabHarness.click}.
+     */
+    select(filters: WrTabHarnessFilters): Promise<void>;
+    /**
+     * Select the tab at this position in render order, counting from 0.
+     *
+     * Throws on an index the strip does not have, naming its length: a silent no-op
+     * there reads as "the tab did not react" when the tab was never addressed.
+     */
+    selectByIndex(index: number): Promise<void>;
+    /**
+     * The labels of every tab a Tab press can land on, in render order.
+     *
+     * A LIST rather than one label, because the count is the mode: a content strip
+     * roves a single `tabindex="0"` and answers with exactly one label — the selected
+     * tab — while a router strip makes every enabled tab its own stop and answers with
+     * all of them. Either way a disabled tab is never in here.
+     */
+    getTabStopLabels(): Promise<string[]>;
+    /**
+     * Whether the strip is a single tab stop — the roving-`tabindex` pattern the APG
+     * asks a `tablist` for.
+     *
+     * True for a content strip, false for a router one, which puts every enabled tab
+     * in the page tab order. A strip whose every tab is disabled has no stop at all
+     * and answers `true`: nothing to rove, and Tab skips it.
+     */
+    isRoving(): Promise<boolean>;
+    /**
+     * The label of the tab holding keyboard focus, or `null` when focus is elsewhere.
+     *
+     * The other answer to "which tab is active", and not the same as
+     * {@link getSelectedLabel}: the arrow keys move this. In content mode they also
+     * select what they land on, so the two stay together; in router mode focus walks
+     * the strip while the selection stays on whatever the route resolved to.
+     */
+    getFocusedLabel(): Promise<string | null>;
+    /**
+     * Put focus where a Tab press would put it — the first tab stop in render order.
+     *
+     * That is the selected tab in content mode, and the first enabled tab in a router
+     * strip. Throws when the strip has no stop at all, because Tab then skips past it
+     * rather than entering it — a content strip whose selected tab is disabled has
+     * none, and neither has one whose every tab is disabled, or one with no tabs.
+     */
+    focusTabStop(): Promise<void>;
+    /**
+     * ArrowRight on the strip — one tab toward the visual RIGHT, wrapping at the end
+     * and skipping disabled tabs.
+     *
+     * The physical key, because that is what a keyboard has. The component follows
+     * visual order per the APG, so under `dir="rtl"` this moves to the PREVIOUS tab —
+     * a spec exercising a mirrored strip swaps this and {@link pressArrowLeft}.
+     *
+     * In content mode the tab it lands on is also SELECTED (automatic activation); in
+     * router mode only focus moves.
+     */
+    pressArrowRight(): Promise<void>;
+    /** ArrowLeft on the strip — one tab toward the visual LEFT, mirrored under `dir="rtl"`. */
+    pressArrowLeft(): Promise<void>;
+    /**
+     * Home on the strip — the FIRST enabled tab.
+     *
+     * Home and End name a position in the tab list rather than an edge of the strip,
+     * so unlike the arrows they read the same in both reading directions.
+     */
+    pressHome(): Promise<void>;
+    /** End on the strip — the LAST enabled tab, in both reading directions. */
+    pressEnd(): Promise<void>;
+    /** Whether this strip is showing a panel at all — false for a router strip. */
+    hasPanel(): Promise<boolean>;
+    /**
+     * The text of the panel that is showing, trimmed — the selected tab's content, and
+     * the only tab content in the DOM.
+     *
+     * Throws when nothing is selected. Delegates to the selected tab, so the panel it
+     * reads is the one that tab's `aria-controls` points at rather than "the first
+     * `.wr-tabs__panel` around" — the two are only the same page when the wiring is
+     * right, and {@link WrTabHarness.isPanelBound} is what says whether it is.
+     */
+    getPanelText(): Promise<string>;
+    /**
+     * Which edges of the strip are faded out, from the public `--fade-start` /
+     * `--fade-end` host modifiers — the cue that there are more tabs than fit, on the
+     * side they are on.
+     *
+     * The component computes these from the strip's scroll metrics, so in a unit test
+     * both are always `false`: jsdom lays nothing out, every element measures 0x0, and
+     * a strip that never overflows never fades. Assert this in a real browser, or
+     * declare the metrics and dispatch a `scroll` the way the component's own spec
+     * does.
+     */
+    getFades(): Promise<{
+        start: boolean;
+        end: boolean;
+    }>;
+    /** Click a tab and check it took, or say which of the two reasons it did not. */
+    private activate;
+    /**
+     * Send a key to the `role="tablist"` strip.
+     *
+     * The strip owns the keydown handler, and a real user's keypress on the focused
+     * header bubbles to exactly here — so this is the honest target, and the one that
+     * still works when jsdom has left real focus on `<body>`. It is also the target
+     * that leaves the headers alone: the CDK types into whatever element it is handed,
+     * which on a `<button>` means writing a `value` attribute onto a tab.
+     */
+    private press;
+    /** This strip's own `role="tablist"` element — the first one under the host. */
+    private strip;
+    /**
+     * A loader rooted at this strip, so tab queries cannot reach a nested strip's tabs:
+     * a nested `<wr-tabs>` lives in the PANEL, which is outside this element.
+     */
+    private stripLoader;
+}
+
+export { WrTabHarness, WrTabsHarness };
+export type { WrTabHarnessFilters, WrTabsHarnessFilters, WrTabsHarnessSize };

package/types/ngwr-tabs.d.ts

@@ -99,6 +99,15 @@ declare class WrTabs implements WrTabsContext {
     /** Visual size variant. */
     readonly size: _angular_core.InputSignal<"sm" | "md" | "lg">;
     protected readonly tabs: _angular_core.Signal<readonly WrTab[]>;
+    private readonly dir;
+    /**
+     * Reading direction of the strip. `Directionality` is root-provided, so this
+     * always resolves — `optional` only guards a consumer who has deliberately
+     * torn the provider out. It reads the document once at construction; a
+     * subtree that overrides the direction does it with the CDK's `Dir`
+     * directive, which writes `valueSignal`, so the read stays reactive.
+     */
+    private readonly isRtl;
     /** When any child has a routerLink, the whole strip switches to router mode. */
     protected readonly isRouter: _angular_core.Signal<boolean>;
     /** Content-mode: the tab whose key matches `active()` (or the first tab if none yet). */

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

@@ -0,0 +1,184 @@
+import { BaseHarnessFilters, ComponentHarness, HarnessPredicate } from '@angular/cdk/testing';
+import { WrTextareaSize, WrTextareaResize } from 'ngwr/textarea';
+
+/**
+ * @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-textarea>` a harness query matches. */
+interface WrTextareaHarnessFilters extends BaseHarnessFilters {
+    /** Match the current value — a string is an exact match, a RegExp is tested. */
+    readonly value?: string | RegExp;
+    /** Match the placeholder — a string is an exact match, a RegExp is tested. */
+    readonly placeholder?: string | RegExp;
+    /**
+     * Match the accessible name the field answers to — the explicit `ariaLabel`,
+     * or the `placeholder` it falls back to. A string is an exact match, a RegExp
+     * is tested.
+     */
+    readonly label?: string | RegExp;
+    /** Match only enabled (`false`) or only disabled (`true`) fields. */
+    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 `<wr-textarea>` — the multi-line COMPONENT.
+ *
+ * Not to be confused with `WrInputHarness` (`ngwr/input/testing`), which drives
+ * `[wrInput]` — the directive form, applied to a real `<textarea>` the consumer
+ * wrote themselves. Pick by the markup: `<wr-textarea …>` is this harness,
+ * `<textarea wrInput>` is that one. They are not interchangeable, because here
+ * the native element is INSIDE the component: the value, the name and every
+ * native state below are read off `.wr-textarea__native` (the host carries only
+ * the `wr-textarea--*` modifiers), and the accessible name has to be forwarded
+ * onto it — a `<label for>` in the consumer's template cannot reach inside.
+ *
+ * Two things this deliberately does NOT offer:
+ *
+ * - **A character counter or `maxlength`.** `<wr-textarea>` has neither — it
+ *   forwards only `placeholder`, `rows`, `readonly`, `disabled`, `value` and the
+ *   resolved `aria-label` to the native element, so there is no counter to read, and a
+ *   `maxlength` attribute written on `<wr-textarea>` lands on the wrapper where
+ *   nothing consumes it. A `getMaxLength()` could only ever answer `null`, which
+ *   would read as "no limit set" rather than "no limit possible". Cap the text in
+ *   the model instead.
+ * - **A height, or a grip drag.** Autosize fits from `scrollHeight`, and the grip
+ *   is driven by pointer coordinates. A DOM with no layout reports 0 for both, so
+ *   either method would answer confidently and wrongly. What survives without
+ *   layout is who OWNS the height ({@link hasFittedHeight}) and which direction
+ *   the grip advertises ({@link getResizeDirection}); the grip is also
+ *   `aria-hidden` and has no keyboard path, so there is no accessible route for a
+ *   harness to drive it down.
+ *
+ * @example
+ * ```ts
+ * const notes = await loader.getHarness(WrTextareaHarness.with({ placeholder: 'Notes' }));
+ *
+ * await notes.setValue('first draft');
+ * expect(await notes.getValue()).toBe('first draft');
+ * ```
+ *
+ * @see https://ngwr.dev/guides/testing
+ */
+declare class WrTextareaHarness extends ComponentHarness {
+    static hostSelector: string;
+    /** Build a predicate that narrows the query — pass to `getHarness` / `getAllHarnesses`. */
+    static with(options?: WrTextareaHarnessFilters): HarnessPredicate<WrTextareaHarness>;
+    private readonly native;
+    /**
+     * The text currently in the field.
+     *
+     * The `value` PROPERTY, never the element's text: a `<textarea>`'s text content
+     * is only its initial content, and this one is bound with `[value]`, so the
+     * text content stays empty for the field's whole life no matter what is typed.
+     */
+    getValue(): Promise<string>;
+    /**
+     * Type a value in, the way a user would as far as the component can tell.
+     *
+     * No `change` is dispatched: `sendKeys` fires one `input` per character (plus the
+     * key events around it), and `input` is the only value event the component
+     * listens to. It hands the result out through the `value` model, so signal forms,
+     * `[formField]`, `[(ngModel)]` and `[(value)]` all hear that single write.
+     * `WrInputHarness` dispatches a `change` on top for the directive form; that is
+     * belt-and-braces rather than a requirement, since Angular's own accessors for
+     * text controls listen to `input` too.
+     *
+     * Throws on a disabled or read-only field — see {@link assertWritable}.
+     */
+    setValue(value: string): Promise<void>;
+    /** Empty the field, dispatching the same `input` a user's last backspace would. */
+    clear(): Promise<void>;
+    /** The placeholder text, or `''` when the field has none. */
+    getPlaceholder(): Promise<string>;
+    /**
+     * The accessible name the field answers to, or `null` when it has none.
+     *
+     * Read from the native element's `aria-label`, which is the only place a name
+     * can live for this component: the `<textarea>` is inside it, so a
+     * `<label for>` outside cannot reach it and an `aria-label` on `<wr-textarea>`
+     * names the wrapper rather than the control. The component forwards `ariaLabel`
+     * and falls back to `placeholder` — and an empty placeholder is treated as no
+     * name at all rather than an empty one, so this answers `null`, not `''`.
+     */
+    getLabel(): Promise<string | null>;
+    /** The visible row count (`rows`) — the field's height until autosize takes over. */
+    getRows(): Promise<number>;
+    /** The control size. `md` is the default and earns no modifier, so a bare host IS `md`. */
+    getSize(): Promise<WrTextareaSize>;
+    /**
+     * Whether the field refuses input.
+     *
+     * The native element's `disabled` property, not the host's `--disabled` class:
+     * the property is what actually blocks typing and what the accessibility tree
+     * reports, while the class only paints it.
+     */
+    isDisabled(): Promise<boolean>;
+    /** Whether the field shows its value but refuses edits (`readonly`). */
+    isReadonly(): Promise<boolean>;
+    /**
+     * Whether the field is marked invalid.
+     *
+     * The native element is checked first, because that is the element a screen
+     * reader reports on — but `<wr-textarea>` forwards nothing here (it takes no
+     * `ariaInvalid` input and, unlike `[wrInput]`, does not read the surrounding
+     * `<wr-form-field>`), so a consumer marks the field by binding `aria-invalid`
+     * on the host. Both are read for that reason, and a native `aria-invalid="false"`
+     * wins over the wrapper rather than falling through to it.
+     */
+    isInvalid(): Promise<boolean>;
+    /**
+     * Whether the field grows with its content (`autosize`).
+     *
+     * Read from `wr-textarea--no-resize`, which is named for what it does to the
+     * grip but is added by `autosize` and by nothing else — `[resizable]="false"`
+     * takes the grip away without it.
+     */
+    isAutosizing(): Promise<boolean>;
+    /**
+     * Whether autosize currently OWNS the field's height: the inline `height` it
+     * writes on the native element, and hands back when `autosize` goes off.
+     *
+     * The fitted number itself is not exposed — see the class docs. What is worth
+     * asserting is the handover: a field left frozen at the last fitted height
+     * ignores `rows` from then on, which reads as the input having done nothing.
+     *
+     * An inline `height` a consumer wrote themselves is indistinguishable from a
+     * fitted one; pair this with {@link isAutosizing} when that matters.
+     */
+    hasFittedHeight(): Promise<boolean>;
+    /**
+     * The direction the corner grip will drag in, or `'none'` when there is no grip
+     * to drag — which is any of `[resizable]="false"`, `autosize` or `disabled`.
+     * {@link isAutosizing} and {@link isDisabled} tell those three apart.
+     */
+    getResizeDirection(): Promise<WrTextareaResize>;
+    /** Move keyboard focus onto the native element — the host itself is not focusable. */
+    focus(): Promise<void>;
+    /** Take focus away, which is what makes the component emit `touch`. */
+    blur(): Promise<void>;
+    isFocused(): Promise<boolean>;
+    /**
+     * The native element, or a targeted failure when writing to it would prove
+     * nothing.
+     *
+     * A browser drops every keystroke aimed at a disabled or read-only field, but a
+     * DOM with no input gating accepts them and the model updates — so a harness
+     * that typed anyway would hand a consumer a green spec for behaviour that
+     * cannot happen in their app.
+     */
+    private assertWritable;
+}
+
+export { WrTextareaHarness };
+export type { WrTextareaHarnessFilters };