ngwr 11.1.0 → 11.2.0

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

@@ -0,0 +1,173 @@
+import { BaseHarnessFilters, ComponentHarness, HarnessPredicate } from '@angular/cdk/testing';
+import { WrGradientTextDirection } from 'ngwr/gradient-text';
+
+/**
+ * @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-gradient-text>` a harness query matches. */
+interface WrGradientTextHarnessFilters extends BaseHarnessFilters {
+    /** Match the projected text — a string is an exact match, a RegExp is tested. */
+    readonly text?: string | RegExp;
+    /**
+     * Match the sweep direction. `'horizontal'` is the ABSENCE of a modifier rather than a
+     * class of its own — see `WrGradientTextHarness.getDirection`, which resolves it.
+     */
+    readonly direction?: WrGradientTextDirection;
+    /** Match only the pill variant (`true`) or only the bare one (`false`). */
+    readonly border?: 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-gradient-text>`.
+ *
+ * **The gradient string is the component.** Everything `[colors]` and `[direction]`
+ * decide ends up in one inline custom property — the angle keyword, the stop list, and
+ * the first colour repeated at the end, which is what makes the loop seamless instead of
+ * snapping back at the wrap. {@link getColors} returns that list AS WRITTEN, wrap stop
+ * included, because the duplicate is the thing worth asserting and stripping it would
+ * hide the day it goes missing.
+ *
+ * **Direction is two facts, not one.** The modifier class says which way the gradient
+ * travels and {@link getBackgroundSize} says which axis it was stretched along, and they
+ * are computed separately: a direction change that forgets the size leaves every class
+ * looking right while the effect is squashed flat. Note too that `horizontal` writes NO
+ * class at all — {@link getDirection} resolves the absence, which is the mapping a
+ * refactor breaks most easily.
+ *
+ * **What the harness deliberately does not offer**, and why. There is no `isAnimating()`
+ * / `isPaused()`: the sweep is a stylesheet keyframe, and a unit test loads no
+ * stylesheet, so the answer would be the same constant for a working component and a
+ * broken one. There is no `getBackgroundPosition()`: the swept value exists only
+ * mid-animation, and the static declaration it would return corresponds to no frame the
+ * user ever sees. {@link pausesOnHover} claims the CLASS and not the pause, deliberately
+ * — `:hover` is a selector, and the DOM after a dispatched mouse event is identical to
+ * the DOM before it. There is no `respectsReducedMotion()`: the only handling is a
+ * `@media` block with no TypeScript counterpart, so nothing in the DOM changes in either
+ * state. And there is nothing that reports the painted text colour: the fill comes from
+ * `background-clip: text` over a `color: transparent` declared in the stylesheet, so a
+ * read would describe the inherited colour and call the text readable where the browser
+ * paints a gradient.
+ *
+ * @example
+ * ```ts
+ * const gradient = await loader.getHarness(WrGradientTextHarness);
+ *
+ * expect(await gradient.getColors()).toEqual(['#111111', '#222222', '#111111']);
+ * expect(await gradient.getBackgroundSize()).toBe('300% 100%');
+ * ```
+ *
+ * @see https://ngwr.dev/guides/testing
+ */
+declare class WrGradientTextHarness extends ComponentHarness {
+    static hostSelector: string;
+    /** Build a predicate that narrows the query — pass to `getHarness` / `getAllHarnesses`. */
+    static with(options?: WrGradientTextHarnessFilters): HarnessPredicate<WrGradientTextHarness>;
+    private readonly text;
+    private readonly ring;
+    /**
+     * The projected text, trimmed.
+     *
+     * Read from the text span rather than from the host, so the answer stays correct on the
+     * day the decorative ring gains content of its own — it is a sibling of this span, and
+     * the host's text would include both.
+     */
+    getText(): Promise<string>;
+    /**
+     * Which way the gradient travels.
+     *
+     * `horizontal` is reported for the absence of both modifiers, because the component
+     * writes no `--horizontal` class — there is nothing to read for the default, only the
+     * two exceptions.
+     */
+    getDirection(): Promise<WrGradientTextDirection>;
+    /**
+     * The whole gradient the component computed, as written.
+     *
+     * Unresolved on purpose: a consumer may pass theme tokens, and resolving `var()` needs
+     * the stylesheet. The stops come back spelled as they were written — a custom property
+     * holds an unparsed token stream, so `#111111` stays `#111111` rather than being
+     * re-serialised as `rgb()` the way it would be inside a standard `background-image`.
+     * Whitespace is the exception, so prefer {@link getColors} over string-equalling the
+     * whole gradient.
+     */
+    getGradient(): Promise<string>;
+    /**
+     * The gradient's colour stops, in order, INCLUDING the repeated first colour at the end.
+     *
+     * So the list is one longer than the `[colors]` input, and that extra entry is the
+     * point: it is what lets the sweep wrap without a visible snap, and nothing else in the
+     * DOM records it. An empty `[colors]` falls back to the three built-in stops, which
+     * shows up here as four entries rather than one.
+     *
+     * Throws rather than guessing when the property holds something that is not a
+     * `linear-gradient()` — an empty read means the host binding is gone, and a list of
+     * fragments parsed out of the wreckage would look like a colour set.
+     */
+    getColors(): Promise<string[]>;
+    /**
+     * How far the gradient is stretched, as the `background-size` pair.
+     *
+     * The other half of direction: the gradient has to be oversized along the axis it
+     * travels — `300% 100%` horizontal, `100% 300%` vertical, `300% 300%` diagonal — or
+     * there is nothing outside the box to slide in. Worth asserting beside
+     * {@link getDirection}, since the two are computed independently and only agree by
+     * intent.
+     */
+    getBackgroundSize(): Promise<string>;
+    /**
+     * One full sweep in seconds, from `[animationSpeed]`.
+     *
+     * Proves the input reaches CSS at all, `numAttr` coercion included — a string attribute
+     * arrives as a number and garbage falls back to the documented default. Throws when the
+     * property holds no number, which is the only way the read can fail.
+     */
+    getAnimationDurationSeconds(): Promise<number>;
+    /**
+     * Whether the decorative ring element was rendered (`showBorder`).
+     *
+     * Strictly more than the `wr-gradient-text--border` class says: the class is a host
+     * binding and the ring is an `@if` branch in the template, two mechanisms reading one
+     * input, and they can drift. This asks whether the element that paints the pill is
+     * actually there.
+     */
+    hasBorderRing(): Promise<boolean>;
+    /**
+     * Whether the ring is hidden from assistive tech, or `null` when there is no ring.
+     *
+     * The ring is an empty, nameless span. Paired with {@link hasBorderRing} this is the
+     * component's whole a11y contract: if it ever loses `aria-hidden`, a screen reader stops
+     * on an element with nothing to say. `null` rather than `false` for the absent case, so
+     * "no ring" cannot be mistaken for "an exposed ring".
+     */
+    isBorderDecorative(): Promise<boolean | null>;
+    /**
+     * Whether the sweep bounces instead of restarting (`yoyo`).
+     *
+     * Defaults to `true` here, unlike every other boolean on this component and unlike the
+     * same-named input on `wr-shiny-text` — worth pinning in both directions. The class is
+     * the only thing the `animation-direction: alternate` rule keys off.
+     */
+    isYoyo(): Promise<boolean>;
+    /**
+     * Whether the opt-in reached the class the `:hover` rule needs.
+     *
+     * Named for the class and not for the pause on purpose: the pause itself is a CSS
+     * selector match, which no unit test can observe. What this catches is the input never
+     * arriving, which is the half that can go wrong in TypeScript.
+     */
+    pausesOnHover(): Promise<boolean>;
+}
+
+export { WrGradientTextHarness };
+export type { WrGradientTextHarnessFilters };

package/types/ngwr-image-cropper-testing.d.ts

@@ -0,0 +1,134 @@
+import { BaseHarnessFilters, ComponentHarness, HarnessPredicate } from '@angular/cdk/testing';
+import { WrCropHandle } from 'ngwr/image-cropper';
+
+/**
+ * @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-image-cropper>` a harness query matches. */
+interface WrImageCropperHarnessFilters extends BaseHarnessFilters {
+    /**
+     * Match croppers holding an image (`false`) or showing the empty state (`true`).
+     * A cropper with a `src` it has not measured yet is NOT empty — see
+     * `WrImageCropperHarness.isReady`.
+     */
+    readonly empty?: 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
+ */
+
+/** Where the crop window sits over the DISPLAYED image, in CSS pixels. */
+interface WrCropWindowBox {
+    readonly x: number;
+    readonly y: number;
+    readonly width: number;
+    readonly height: number;
+}
+/**
+ * Test harness for `<wr-image-cropper>`.
+ *
+ * **This is the smallest honest surface of any harness here, and the reason is worth
+ * reading before you reach for a method that is not on it.** Almost everything the
+ * cropper does is measured: it reads the `<img>`'s rendered box and its
+ * `naturalWidth`, converts between display and source pixels, and moves the crop
+ * window with pointer deltas. jsdom measures nothing — every rect is 0×0 and
+ * `naturalWidth` is 0 — so an image never "loads", the crop UI never renders, and a
+ * synthetic drag divides by zero. There is deliberately no `moveCrop()` or
+ * `resizeCrop()`: either would write `NaN` and report success.
+ *
+ * What a spec CAN do is give the image a box and a natural size itself, then call
+ * {@link dispatchImageLoad} — the two numbers `onImageLoad` reads are the whole
+ * stub, and from there {@link getCropBox} and {@link getHandles} are real answers,
+ * because the component writes the crop window's geometry as inline pixels.
+ *
+ * ```ts
+ * // In your spec, before dispatching the load:
+ * const img = fixture.nativeElement.querySelector('.wr-image-cropper__image');
+ * img.getBoundingClientRect = () => ({ width: 400, height: 400, x: 0, y: 0 }) as DOMRect;
+ * Object.defineProperty(img, 'naturalWidth', { value: 800 });
+ * Object.defineProperty(img, 'naturalHeight', { value: 800 });
+ * ```
+ *
+ * **There is also nothing to click.** The cropper renders no buttons: a consumer
+ * takes the result by calling `crop()` on the component through a `viewChild`, and
+ * reads `cropRect()` the same way. Those are component API rather than DOM, so they
+ * are outside what a harness can reach at all — which is worth knowing rather than
+ * discovering.
+ *
+ * @example
+ * ```ts
+ * const cropper = await loader.getHarness(WrImageCropperHarness);
+ *
+ * expect(await cropper.isEmpty()).toBe(false);
+ * expect(await cropper.isReady()).toBe(false);   // nothing measured yet
+ *
+ * await cropper.dispatchImageLoad();
+ * expect(await cropper.getCropBox()).toEqual({ x: 80, y: 80, width: 240, height: 240 });
+ * ```
+ *
+ * @see https://ngwr.dev/guides/testing
+ */
+declare class WrImageCropperHarness extends ComponentHarness {
+    static hostSelector: string;
+    /** Build a predicate that narrows the query — pass to `getHarness` / `getAllHarnesses`. */
+    static with(options?: WrImageCropperHarnessFilters): HarnessPredicate<WrImageCropperHarness>;
+    private readonly image;
+    private readonly cropWindow;
+    /** Whether the cropper has no source at all, and is showing its placeholder. */
+    isEmpty(): Promise<boolean>;
+    /** The placeholder's text, or `null` when there is an image. Comes from the catalog. */
+    getEmptyText(): Promise<string | null>;
+    /**
+     * Whether the crop UI is up.
+     *
+     * Not the same question as {@link isEmpty}: a cropper with a perfectly good `src`
+     * shows nothing but the image until it has been MEASURED, because the window's size
+     * is a fraction of the rendered box. In a browser that happens on load; in a unit
+     * test it happens when the spec stubs the box and calls
+     * {@link dispatchImageLoad}.
+     */
+    isReady(): Promise<boolean>;
+    /**
+     * What the `<img>` is pointing at.
+     *
+     * A `File` or `Blob` source becomes an object URL, so this is `blob:…` for those
+     * and the plain string for a string `src`. Comparing the two is not useful; asking
+     * whether it CHANGED is.
+     */
+    getImageSrc(): Promise<string | null>;
+    /**
+     * Fire the image's `load` event.
+     *
+     * The event, not a real load: jsdom fetches nothing, and the handler reads
+     * `getBoundingClientRect()` and `naturalWidth` off the element. Stub those first —
+     * see this class's docs — or the crop window will still not render and
+     * {@link isReady} will stay `false`, which is exactly what a real cropper does with
+     * a zero-sized image.
+     */
+    dispatchImageLoad(): Promise<void>;
+    /**
+     * Where the crop window sits over the displayed image, in CSS pixels.
+     *
+     * From the inline styles the component writes — a measured box would be 0×0 — and
+     * in DISPLAY pixels, which is not what a consumer receives: `cropRect()` converts
+     * to the image's natural pixels, and that conversion is the component's own contract
+     * rather than something the DOM shows.
+     */
+    getCropBox(): Promise<WrCropWindowBox>;
+    /** The eight resize handles, by their compass suffix. Throws before the crop UI is up. */
+    getHandles(): Promise<WrCropHandle[]>;
+    /** Whether the dimming backdrop with the cut-out is drawn. */
+    hasBackdrop(): Promise<boolean>;
+    private requireReady;
+}
+
+export { WrImageCropperHarness };
+export type { WrImageCropperHarnessFilters };

package/types/ngwr-image-cropper.d.ts

@@ -61,6 +61,7 @@ declare class WrImageCropper {
     readonly cropped: _angular_core.OutputEmitterRef<Blob>;
     protected readonly imgEl: _angular_core.Signal<ElementRef<HTMLImageElement>>;
     /** Resolved object URL for `src` (so File / Blob render in `<img>`). */
+    protected readonly emptyText: _angular_core.Signal<string>;
     protected readonly objectUrl: _angular_core.WritableSignal<string | null>;
     /** Previous object URL we created — kept off-signal so the resolve
      *  effect doesn't depend on its own writes (which would loop). */

package/types/ngwr-input-number.d.ts

@@ -79,6 +79,17 @@ declare class WrInputNumber implements FormValueControl<number | null> {
      */
     readonly ariaLabel: _angular_core.InputSignal<string | null>;
     protected readonly resolvedAriaLabel: _angular_core.Signal<string | null>;
+    /** Increment button aria-label. Falls back to `inputNumber.increment`. */
+    readonly incrementLabel: _angular_core.InputSignal<string | null>;
+    /** Decrement button aria-label. Falls back to `inputNumber.decrement`. */
+    readonly decrementLabel: _angular_core.InputSignal<string | null>;
+    /**
+     * The steppers are icon-only buttons, so these ARE their accessible names.
+     * They were hard-coded English while the catalog carried the keys for them
+     * unread — a Russian app announced "Increment".
+     */
+    protected readonly resolvedIncrement: _angular_core.Signal<string>;
+    protected readonly resolvedDecrement: _angular_core.Signal<string>;
     /** Disable interaction. @default false */
     readonly disabled: _angular_core.InputSignalWithTransform<boolean, any>;
     /** Read-only — values cannot be changed (steppers + typing disabled). @default false */
@@ -97,6 +108,27 @@ declare class WrInputNumber implements FormValueControl<number | null> {
     protected readonly atMin: _angular_core.Signal<boolean>;
     protected readonly atMax: _angular_core.Signal<boolean>;
     protected readonly classes: _angular_core.Signal<string>;
+    /**
+     * Fraction digits the stepper rounds its arithmetic to when `decimals` says
+     * nothing. High enough to leave a real value alone, low enough to erase the
+     * binary-float tail that repeated stepping accumulates.
+     */
+    private static readonly STEP_PRECISION;
+    /**
+     * Above this, the anti-drift round is skipped — it would MANUFACTURE drift.
+     *
+     * `round(v, 10)` is `Math.round((v + EPSILON) * 1e10) / 1e10`, and the scale
+     * factor is only exact while `v * 1e10` stays inside 2^53, i.e. |v| under
+     * about 900,720. In practice the round-trip still recovers up to ~9.2e8 and
+     * then breaks: `round(1000000001, 10)` is `1000000000.9999999`, and since
+     * `format` prints up to 20 fraction digits that tail reaches the screen —
+     * and compounds, because the next press starts from it. Integer stepping at
+     * that magnitude is exact in IEEE754 and needed no help; the only thing this
+     * rounding exists to defend is `0.1 + 0.1 + 0.1`.
+     */
+    private static readonly SAFE_ROUND_MAGNITUDE;
+    /** Steps finer than this would be rounded away by {@link STEP_PRECISION}. */
+    private static readonly SAFE_ROUND_STEP;
     constructor();
     protected onInput(event: Event): void;
     protected onFocus(): void;
@@ -112,7 +144,7 @@ declare class WrInputNumber implements FormValueControl<number | null> {
     /** Format a value using `Intl.NumberFormat` for the active locale. */
     private format;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<WrInputNumber, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<WrInputNumber, "wr-input-number", never, { "min": { "alias": "min"; "required": false; "isSignal": true; }; "max": { "alias": "max"; "required": false; "isSignal": true; }; "step": { "alias": "step"; "required": false; "isSignal": true; }; "decimals": { "alias": "decimals"; "required": false; "isSignal": true; }; "showSteppers": { "alias": "showSteppers"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "rounded": { "alias": "rounded"; "required": false; "isSignal": true; }; "prefix": { "alias": "prefix"; "required": false; "isSignal": true; }; "suffix": { "alias": "suffix"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "readonly": { "alias": "readonly"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; "touch": "touch"; }, never, never, true, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<WrInputNumber, "wr-input-number", never, { "min": { "alias": "min"; "required": false; "isSignal": true; }; "max": { "alias": "max"; "required": false; "isSignal": true; }; "step": { "alias": "step"; "required": false; "isSignal": true; }; "decimals": { "alias": "decimals"; "required": false; "isSignal": true; }; "showSteppers": { "alias": "showSteppers"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "rounded": { "alias": "rounded"; "required": false; "isSignal": true; }; "prefix": { "alias": "prefix"; "required": false; "isSignal": true; }; "suffix": { "alias": "suffix"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; "incrementLabel": { "alias": "incrementLabel"; "required": false; "isSignal": true; }; "decrementLabel": { "alias": "decrementLabel"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "readonly": { "alias": "readonly"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; "touch": "touch"; }, never, never, true, never>;
 }
 
 export { WrInputNumber };

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

@@ -0,0 +1,150 @@
+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-knob>` a harness query matches. */
+interface WrKnobHarnessFilters extends BaseHarnessFilters {
+    /** Match the dial's accessible name — a string is an exact match, a RegExp is tested. */
+    readonly label?: string | RegExp;
+    /** Match the current value, as `aria-valuenow` reports it. */
+    readonly value?: number;
+    /** Match only enabled (`false`) or only disabled (`true`) dials. */
+    readonly disabled?: boolean;
+    /** Match only writable (`false`) or only read-only (`true`) dials. */
+    readonly readonly?: 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
+ */
+
+/** The two arrow keys that raise the value, and the two that lower it. */
+type Arrow = 'left' | 'right' | 'up' | 'down';
+/**
+ * Test harness for `<wr-knob>` — the radial dial.
+ *
+ * **Driven by the keyboard, and the drag is not merely unsupported.** Turning the
+ * dial with a pointer takes `getBoundingClientRect()`, measures the angle from the
+ * centre to the cursor, and maps it onto a 270° arc. jsdom lays nothing out, so the
+ * centre is `(0, 0)` and every synthetic gesture writes the same corner of the arc
+ * whatever coordinates it is given — a `turnTo()` built on one would pass while
+ * proving nothing. The arrows reach every value on the grid and are the accessible
+ * path anyway.
+ *
+ * **Two questions about the value, not one.** {@link getValue} is the number
+ * `aria-valuenow` carries; {@link getDisplayValue} is the string in the middle of the
+ * dial, which the `suffix` input can make `"50%"` while the announced value stays
+ * `50`. They are separate methods because they can disagree, and because
+ * `showValue` can remove the text entirely without touching the value.
+ *
+ * @example
+ * ```ts
+ * const knob = await loader.getHarness(WrKnobHarness);
+ *
+ * await knob.setValue(60);
+ * expect(await knob.getValue()).toBe(60);
+ * expect(await knob.getDisplayValue()).toBe('60%');
+ * ```
+ *
+ * @see https://ngwr.dev/guides/testing
+ */
+declare class WrKnobHarness extends ComponentHarness {
+    static hostSelector: string;
+    /** Build a predicate that narrows the query — pass to `getHarness` / `getAllHarnesses`. */
+    static with(options?: WrKnobHarnessFilters): HarnessPredicate<WrKnobHarness>;
+    private readonly surface;
+    /** The value the dial announces, from `aria-valuenow`. */
+    getValue(): Promise<number>;
+    /** The bottom of the range, from `aria-valuemin`. */
+    getMin(): Promise<number>;
+    /** The top of the range, from `aria-valuemax`. */
+    getMax(): Promise<number>;
+    /**
+     * The text printed in the middle of the dial, suffix included, or `null` when the
+     * knob was built with `[showValue]="false"`.
+     *
+     * Not the same question as {@link getValue}: with a `suffix` the two disagree by
+     * design, and a screen reader is told the bare number — the component publishes no
+     * `aria-valuetext`, so `50` is what gets announced for a dial that reads `50%`.
+     */
+    getDisplayValue(): Promise<string | null>;
+    /** The suffix alone, or `null` when there is none (or no value text at all). */
+    getSuffix(): Promise<string | null>;
+    /** The dial's accessible name — `role="slider"` needs one. */
+    getLabel(): Promise<string | null>;
+    /** Whether the dial is disabled, from `aria-disabled`. */
+    isDisabled(): Promise<boolean>;
+    /** Whether the dial is read-only, from `aria-readonly`. */
+    isReadonly(): Promise<boolean>;
+    /**
+     * Whether the dial is a tab stop.
+     *
+     * The component drops it out of the tab order for BOTH disabled and read-only,
+     * which is worth knowing: a read-only slider that a keyboard user cannot reach is
+     * also one they cannot read, and this is the method that says so.
+     */
+    isFocusable(): Promise<boolean>;
+    /** Move keyboard focus to the dial. */
+    focus(): Promise<void>;
+    /** Whether the dial currently holds focus. */
+    isFocused(): Promise<boolean>;
+    /** Blur the dial — which is what emits `touch` for a knob moved with the keyboard. */
+    blur(): Promise<void>;
+    /**
+     * Press one arrow key.
+     *
+     * Right and Up raise the value, Left and Down lower it — all four are live on this
+     * component, which has one axis and no mirroring to do. `shift` multiplies the step
+     * by ten.
+     */
+    pressArrow(arrow: Arrow, options?: {
+        shift?: boolean;
+    }): Promise<void>;
+    /** Press Home — the bottom of the range. */
+    pressHome(): Promise<void>;
+    /**
+     * Press End — the top of the range, or the last value ON the grid below it: a range
+     * that is not a whole number of steps cannot reach its own maximum.
+     */
+    pressEnd(): Promise<void>;
+    /**
+     * Walk the dial to a value with the arrow keys, and assert it landed there.
+     *
+     * It measures the step as it goes rather than being told it — `step` is an input
+     * with no DOM presence, and the value can arrive off the grid, since an external
+     * write is clamped but never snapped. So the first press may move by less than a
+     * step (it snaps onto the grid) and the walk adapts, which also means the ten-step
+     * hops only start once a real step has been seen.
+     *
+     * Throws rather than half-arriving, and the two reasons read differently: a target
+     * outside `[min, max]` is refused before anything moves, while a target BETWEEN two
+     * grid points is only discovered by overshooting it, and says where it landed. A
+     * dial that will not move at all — disabled, read-only — is the third.
+     */
+    setValue(target: number): Promise<void>;
+    /**
+     * Where the handle dot sits, in the SVG's own 100×100 viewBox units.
+     *
+     * The dial's whole visual state is an arc path and this dot, and neither can be
+     * measured in a unit test — but the dot's centre is written as plain `cx` / `cy`
+     * attributes, so it reads with no layout at all. That makes it the evidence that
+     * the drawing followed the value: at `min` the handle is at the 7 o'clock end of
+     * the arc, at `max` the 5 o'clock end.
+     */
+    getHandlePosition(): Promise<{
+        x: number;
+        y: number;
+    }>;
+    private numeric;
+}
+
+export { WrKnobHarness };
+export type { WrKnobHarnessFilters };