ngwr 11.1.0 → 11.2.0

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

@@ -0,0 +1,191 @@
+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-rotating-text>` a harness query matches. */
+interface WrRotatingTextHarnessFilters extends BaseHarnessFilters {
+    /**
+     * Match the string showing right now — the readable copy, not the animated pieces.
+     * A string is an exact match, a RegExp is tested.
+     *
+     * It matches a MOMENT, not a rotator: the component cycles, so a filter that hits today
+     * misses two seconds later. Use it to address the one that is currently showing a known
+     * word, and prefer `selector` for a rotator you need to hold on to.
+     */
+    readonly text?: string | RegExp;
+    /**
+     * Match on how many word groups the split produced. Word boundaries survive every
+     * granularity — three words stay three groups even when each is exploded into
+     * characters — so this is stable across the split, unlike the piece count.
+     */
+    readonly wordCount?: number;
+}
+
+/**
+ * @license
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://github.com/thekhegay/ngwr/blob/main/LICENSE
+ */
+
+/**
+ * Test harness for `<wr-rotating-text>`.
+ *
+ * **What is announced and what is drawn are two questions, and this component is worth a
+ * harness mostly because it answers them separately.** The string showing now is carried
+ * verbatim in a visually-hidden span; the animated layer beside it is one span per
+ * grapheme, word or line and is `aria-hidden` as a whole, so a screen reader hears `one`
+ * rather than `o. n. e.` {@link getAccessibleText} is the first, {@link getRenderedText}
+ * and {@link getPieces} the second, and {@link isAnimatedLayerHidden} together with
+ * {@link hasAccessibleCopy} is the pairing that regresses silently when someone
+ * restructures the template — pieces hidden AND no readable copy is an element with no
+ * accessible text at all, which reads as a pass on either check alone.
+ *
+ * **The sr-only span is deliberately not a live region, and no method here implies
+ * otherwise.** `auto` advances every two seconds by default, and the APG's answer for
+ * self-advancing content is silence, not an announcement on a timer. What the harness
+ * pins is that the announced copy TRACKS the current word — nothing about it being
+ * spoken.
+ *
+ * **There is no `getIndex()`, and no `next()` / `previous()` / `jumpTo()` / `reset()`.**
+ * The index appears nowhere in the DOM — no attribute, no data hook — so deriving it
+ * would mean matching the shown string against a list the harness was never given, and
+ * guessing between duplicates. And the component renders no controls at all: rotation is
+ * a timer or a method call on the instance, so a harness "click" would have nothing to
+ * click and reaching into the component would make this a wrapper around the class rather
+ * than a reader of the DOM. Drive it from the spec — through the instance, or by
+ * advancing the interval — and assert the `nextChange` output for the index.
+ *
+ * **Nothing here reports the tween.** `duration`, `easing`, `staggerDuration` and
+ * `staggerFrom` are passed straight into Web Animation options and never written to the
+ * document; `delayFor()` is arithmetic with no rendered trace. So no `getDuration()`, no
+ * `getStagger()`, no `isAnimating()`. The pieces do carry inline `opacity` and
+ * `transform`, but on the animated path those are the FIRST keyframe — `opacity: 0` on
+ * text the user can see perfectly well — which is why the only reading offered is
+ * {@link isSettled}, and why it is spelled as a commitment rather than as a state of
+ * motion. The host's `overflow: hidden` clipping is layout, and every rect in a unit test
+ * is 0×0, so there is no `isClipped()` either.
+ *
+ * jsdom implements no Web Animations API, so the animated path throws on the first
+ * `el.animate` — before any assertion runs. Every spec supplies one half or the other:
+ *
+ * ```ts
+ * // Either: mount under reduced motion, where each swap is instant and nothing tweens.
+ * // (jsdom has no matchMedia, so WrPlatform must be provided as a value.)
+ * TestBed.configureTestingModule({ providers: [{ provide: WrPlatform, useValue: reducedMotion }] });
+ *
+ * // Or: stub the API — and remember a stub that never fires `onfinish` never resolves
+ * // the exit step, so the rotator stops after one swap.
+ * Reflect.set(Element.prototype, 'animate', () => ({ cancel: () => undefined, onfinish: null }));
+ * ```
+ *
+ * @example
+ * ```ts
+ * const rotator = await loader.getHarness(WrRotatingTextHarness);
+ *
+ * expect(await rotator.getAccessibleText()).toBe('design');
+ * expect(await rotator.getPieces()).toEqual(['d', 'e', 's', 'i', 'g', 'n']);
+ * expect(await rotator.isAnimatedLayerHidden()).toBe(true);
+ * ```
+ *
+ * @see https://ngwr.dev/guides/testing
+ */
+declare class WrRotatingTextHarness extends ComponentHarness {
+    static hostSelector: string;
+    /** Build a predicate that narrows the query — pass to `getHarness` / `getAllHarnesses`. */
+    static with(options?: WrRotatingTextHarnessFilters): HarnessPredicate<WrRotatingTextHarness>;
+    private readonly chars;
+    /**
+     * The string showing right now, as the one readable copy holds it.
+     *
+     * Literally what a screen reader gets, the animated layer being out of the tree — and
+     * the thing to assert a rotation against, since it is where `next()`, `previous()`, a
+     * clamped `jumpTo()`, `reset()`, the wrap at either end, the stop when `loop` is off and
+     * the shrinking-list clamp all become visible.
+     *
+     * Throws when the copy is missing rather than answering with the pieces' text: an empty
+     * string is what a rotator holding an empty list correctly reports, so a plausible
+     * nothing here is indistinguishable from the component having lost its accessible name
+     * entirely. Ask {@link hasAccessibleCopy} when presence is the question.
+     */
+    getAccessibleText(): Promise<string>;
+    /**
+     * Everything the animated layer draws, in document order, as one string.
+     *
+     * A different fact from {@link getAccessibleText}, and the comparison between them is
+     * the point: a split that drops its spacer renders `hellothere` while the readable copy
+     * stays perfect, and nothing else in the DOM says so.
+     *
+     * The spacer between words is a non-breaking space (`&nbsp;`), which is a rendering
+     * choice rather than a contract, so it is normalized to a plain space here — otherwise
+     * every round-trip assertion would have to spell U+00A0 out to pass against a working
+     * component. Note that `splitBy="lines"` genuinely does not round-trip: the newline the
+     * readable copy carries is drawn as that same spacer.
+     */
+    getRenderedText(): Promise<string>;
+    /**
+     * The animated pieces, in document order.
+     *
+     * The granularity actually applied: one piece per grapheme for `splitBy="characters"`,
+     * one per word for `"words"`, one per line for `"lines"`. It is also where the grapheme
+     * contract shows — `a🚀b` must come back as three pieces, not four with two broken
+     * halves of a surrogate pair.
+     */
+    getPieces(): Promise<string[]>;
+    /**
+     * How many word groups the split produced.
+     *
+     * Word boundaries survive every granularity: three words stay three groups even when
+     * each is exploded into characters, which is what keeps the line wrapping sane. A
+     * splitter that flattened the grouping would leave {@link getPieces} correct and break
+     * only this.
+     */
+    getWordCount(): Promise<number>;
+    /**
+     * Whether the animated layer is out of the accessibility tree.
+     *
+     * ONE attribute answers it — `aria-hidden` sits on the `__inner` wrapper, so the pieces
+     * inherit it and none carries it itself, which keeps the attribute off the nodes the
+     * tween writes to. Asserting it per piece would fail on a component that is behaving.
+     *
+     * If it regresses, every rotation is spelled out letter by letter beside the copy that
+     * was already read, and nothing changes on screen — so no other check catches it.
+     */
+    isAnimatedLayerHidden(): Promise<boolean>;
+    /**
+     * Whether the readable copy is rendered at all.
+     *
+     * The other half of {@link isAnimatedLayerHidden}, and it exists as a separate question
+     * because the failure the two catch together is invisible to each alone: a layer
+     * correctly hidden with no readable copy beside it is a control with no accessible text
+     * whatsoever, and `isAnimatedLayerHidden() === true` is exactly what it reports.
+     */
+    hasAccessibleCopy(): Promise<boolean>;
+    /**
+     * Whether the enter step committed its end state on every piece — NOT whether an
+     * animation finished.
+     *
+     * The component writes `opacity: 1` inline on each piece when the swap settles: instantly
+     * under reduced motion, and from the tween's `onfinish` otherwise. So this answers "the
+     * new word was actually taken over", which is the bug the deferred enter exists to
+     * prevent — a swap that animates the OLD spans leaves the new ones staged at `opacity: 0`
+     * and the text invisible, while the readable copy reports the new word correctly.
+     *
+     * It is all-or-nothing: one piece left staged is one invisible glyph in the middle of a
+     * word. On the animated path it stays `false` until each tween finishes, which in a unit
+     * test means forever, since a stubbed `Element.animate` never fires anything — that is
+     * an honest answer about a swap that never landed, not a limitation to work around.
+     *
+     * Throws when there are no pieces: "every piece is settled" is true of none of them,
+     * and that is also what a component that stopped rendering its text would report.
+     */
+    isSettled(): Promise<boolean>;
+}
+
+export { WrRotatingTextHarness };
+export type { WrRotatingTextHarnessFilters };

package/types/ngwr-select.d.ts

@@ -478,6 +478,15 @@ declare class WrSelect implements FormValueControl<unknown>, WrSelectContext {
      * Virtualization engaged: opt-in, search mode, a non-empty filtered array, and
      * NO projected `<wr-option>` children (those keep the full-render registry path
      * so their DOM-derived labels / selection still work).
+     *
+     * NOT gated on there being matches. It used to also require
+     * `filteredDynamicOptions().length > 0`, which meant a query matching nothing
+     * fell back to the full-render path and mounted the ENTIRE unfiltered array —
+     * 2000 `<wr-option>` hosts, every one of them `--hidden`, behind a "No
+     * results" line — and then tore all of them down again on the next keystroke
+     * that matched. The empty window is handled where it belongs: `virtualWindow`
+     * already short-circuits on `total === 0`, and `firstEnabled` / `lastEnabled`
+     * already answer -1.
      */
     protected readonly virtualActive: _angular_core.Signal<boolean>;
     private readonly scrollTop;
@@ -537,6 +546,7 @@ declare class WrSelect implements FormValueControl<unknown>, WrSelectContext {
     protected onChipsBlur(): void;
     protected onSearchInput(event: Event): void;
     protected onSearchFocus(): void;
+    protected onSearchBlur(): void;
     protected onSearchKey(event: KeyboardEvent): void;
     /**
      * Display text for the search input. Shows the selected option's
@@ -544,6 +554,15 @@ declare class WrSelect implements FormValueControl<unknown>, WrSelectContext {
      * @internal
      */
     protected readonly searchDisplay: _angular_core.Signal<string>;
+    /**
+     * Whether the search field holds focus.
+     *
+     * Read by `searchDisplay`, so it has to be a signal — and it is also what
+     * lets the panel-close effect tell "the user walked away" (reset the query)
+     * from "the query dropped under `minChars` and they are still typing" (keep
+     * it).
+     */
+    private readonly searchHasFocus;
     private readonly host;
     private readonly overlay;
     private readonly outsideClick;
@@ -573,6 +592,19 @@ declare class WrSelect implements FormValueControl<unknown>, WrSelectContext {
     protected onTriggerKey(event: KeyboardEvent): void;
     private seedActiveIndex;
     private moveActive;
+    /**
+     * Both scan `orderedRegistry`, and that is not interchangeable with
+     * `registry`.
+     *
+     * They RETURN an index, and every reader of `activeIndex` — `activeOptionId`,
+     * `moveActive`, `seedActiveIndex`, the Enter branch of `onTriggerKey` —
+     * resolves it against DOM order. Scanning creation order here produced an
+     * index into the other list: with projected `<wr-option>` children next to
+     * `[options]` rows the two differ, so opening or searching left the cursor on
+     * a row the user was not looking at, and Enter committed whatever happened to
+     * sit at that position in DOM order — a filter-hidden option, which commits
+     * nothing at all.
+     */
     private firstEnabled;
     private lastEnabled;
     /** Coerce the multi-mode value into an array (tolerates a scalar or null write). */

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

@@ -0,0 +1,165 @@
+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
+ */
+
+/**
+ * Which way the bright stripe travels. Mirrors the component's `direction` input, which
+ * declares the union inline and exports no name for it.
+ */
+type WrShinyTextSweepDirection = 'left' | 'right';
+/** Narrows which `<wr-shiny-text>` a harness query matches. */
+interface WrShinyTextHarnessFilters extends BaseHarnessFilters {
+    /** Match the rendered text — a string is an exact match, a RegExp is tested. */
+    readonly text?: string | RegExp;
+    /**
+     * Match only the stopped (`true`) or only the running (`false`) instances. Named for the
+     * DOM contract rather than for the input: `[disabled]` writes `wr-shiny-text--paused`.
+     */
+    readonly paused?: boolean;
+    /** Match the sweep direction — `'left'` is the absence of the reverse modifier. */
+    readonly direction?: WrShinyTextSweepDirection;
+}
+
+/**
+ * @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-shiny-text>`.
+ *
+ * **The duration is the assertion that matters.** The pause between sweeps is not
+ * `animation-delay` and not a second animation — it is folded INTO `animation-duration`,
+ * because the keyframe finishes at 50% and holds there. So `[speed]="2"` with
+ * `[delay]="3"` has to read 5 seconds, and anyone reimplementing the pause the obvious
+ * way passes every other check here and fails {@link getCycleDurationSeconds}.
+ *
+ * **The stripe is five stops and only one of them is the shine.** The base colour fills
+ * 0%, 35%, 65% and 100%; the highlight sits alone at 50%. {@link getBaseColor} and
+ * {@link getShineColor} are offered as a pair because swapping the two inputs is
+ * otherwise undetectable — the gradient stays well-formed, the angle is unchanged, and
+ * the text simply stops shimmering.
+ *
+ * **Both gradient reads come off the inline `style` attribute**, not through computed
+ * style. Unset colours fall through to the literal `var(--wr-shiny-text-base)` /
+ * `var(--wr-shiny-text-shine)` tokens, which is exactly what makes the dark-theme
+ * override work — and a computed read resolves those tokens in a real browser while
+ * handing them back verbatim in a unit test. Reading what the component wrote gives the
+ * same answer in both places.
+ *
+ * The colours still pass through the CSSOM on their way back out, and it has its own
+ * spelling: a hex literal is re-serialised, so `[color]="'#444'"` reads
+ * `rgb(68, 68, 68)`. Functional notations and `var()` tokens survive untouched. Assert
+ * the form the CSSOM returns, not the one the template passed in.
+ *
+ * There is no inner element to query: the template is the bare interpolation, so the text
+ * is a node on the host. A locator copied from the gradient-text harness finds nothing.
+ *
+ * **What the harness deliberately does not offer**, and why. There is no `isAnimating()`
+ * / `getBackgroundPosition()`: the sweep is a stylesheet keyframe over
+ * `background-position`, and a unit test neither loads the sheet nor runs the animation.
+ * There is no `getAnimationName()` / `getIterationCount()` / `getPlayState()`: every
+ * animation property except the duration lives in the stylesheet, so those reads answer
+ * the same empty string for a working component and a deleted one. {@link isPaused} and
+ * {@link pausesOnHover} claim the CLASSES and not the pauses — `:hover` is a selector and
+ * `animation-play-state` is a stylesheet rule, so what they honestly pin is that the
+ * input arrived. There is no `respectsReducedMotion()`: the handling is a `@media` block
+ * with no TypeScript counterpart. And there is nothing reporting the painted text colour,
+ * because `-webkit-text-fill-color: transparent` is a stylesheet declaration and a read
+ * would report the inherited colour as if the text were solid.
+ *
+ * The `[wrShimmer]` directive shipped from the same entry point has no harness: it adds
+ * one static class and nothing else, so a harness could only restate its own selector.
+ *
+ * @example
+ * ```ts
+ * const shiny = await loader.getHarness(WrShinyTextHarness);
+ *
+ * expect(await shiny.getCycleDurationSeconds()).toBe(5);
+ * expect(await shiny.getShineColor()).toBe('var(--wr-shiny-text-shine)');
+ * ```
+ *
+ * @see https://ngwr.dev/guides/testing
+ */
+declare class WrShinyTextHarness extends ComponentHarness {
+    static hostSelector: string;
+    /** Build a predicate that narrows the query — pass to `getHarness` / `getAllHarnesses`. */
+    static with(options?: WrShinyTextHarnessFilters): HarnessPredicate<WrShinyTextHarness>;
+    /** The rendered text, trimmed. It is a text node on the host — there is no inner span. */
+    getText(): Promise<string>;
+    /**
+     * The whole stripe gradient the component computed, as written.
+     *
+     * Unresolved on purpose. With no `[color]` / `[shineColor]` given this string contains
+     * the theme's own custom-property tokens rather than colours, and that is the working
+     * state, not a gap — resolving them would need the stylesheet, and the resolved answer
+     * would differ between a unit test and a browser.
+     */
+    getGradient(): Promise<string>;
+    /**
+     * The gradient's angle in degrees, from `[spread]`.
+     *
+     * The only observable effect that input has, `numAttr` coercion included. Note the name
+     * is inherited vocabulary and describes the ANGLE, not the width of the bright stripe:
+     * the stop positions are hard-coded, so no input narrows the shine.
+     */
+    getSpreadDegrees(): Promise<number>;
+    /**
+     * The colour outside the bright stripe — the 0% stop.
+     *
+     * The same colour fills 35%, 65% and 100%; only the 50% stop differs. Assert it next to
+     * {@link getShineColor}: a `[color]` that lands in the shine slot instead leaves a
+     * perfectly valid gradient that no longer shimmers.
+     */
+    getBaseColor(): Promise<string>;
+    /** The highlight colour — the lone 50% stop the stripe is made of. */
+    getShineColor(): Promise<string>;
+    /**
+     * One full cycle in seconds — the sweep AND the pause after it.
+     *
+     * `[delay]` is not `animation-delay` and not a second animation: the keyframe reaches
+     * its end at 50% and holds, so the wait is bought by making the animation twice as long.
+     * That is why this reads `speed + delay` and why the method is named for the cycle
+     * rather than for the sweep.
+     *
+     * Read from the inline declaration rather than from computed style, so a missing binding
+     * is reported as missing instead of being answered from the stylesheet.
+     */
+    getCycleDurationSeconds(): Promise<number>;
+    /**
+     * Whether the animation is stopped (`disabled`).
+     *
+     * Three names for one thing, which is why this method exists rather than a spec reading
+     * the class: the input is `disabled`, its JSDoc says "pause", and the DOM contract is
+     * `wr-shiny-text--paused`. Only the last of those is public API.
+     */
+    isPaused(): Promise<boolean>;
+    /** Whether the opt-in reached the class the `:hover` rule needs. */
+    pausesOnHover(): Promise<boolean>;
+    /**
+     * Whether the stripe bounces instead of restarting (`yoyo`).
+     *
+     * Defaults to `false` here — the opposite of the same-named input on `wr-gradient-text`,
+     * which is worth pinning in a spec that uses both. Together with {@link getDirection}
+     * this is the whole four-way matrix the stylesheet derives `animation-direction` from.
+     */
+    isYoyo(): Promise<boolean>;
+    /** Which way the stripe travels — `'left'` is the absence of the reverse modifier. */
+    getDirection(): Promise<WrShinyTextSweepDirection>;
+    /** The five stops of the stripe, positions attached, in gradient order. */
+    private gradientStops;
+    /** The gradient's arguments — the angle first, then the stops. */
+    private gradientArguments;
+    /** One of the host's two inline declarations, or a failure that says which one is missing. */
+    private require;
+}
+
+export { WrShinyTextHarness };
+export type { WrShinyTextHarnessFilters, WrShinyTextSweepDirection };

package/types/ngwr-slider.d.ts

@@ -77,7 +77,22 @@ declare class WrSlider implements FormValueControl<WrSliderValue> {
     /** Emitted on blur so a bound field can mark itself touched. */
     readonly touch: _angular_core.OutputEmitterRef<void>;
     protected readonly low: _angular_core.WritableSignal<number>;
+    /**
+     * The high thumb's cell. Its literal default stands in for `maxValue()`,
+     * which cannot be read at field-initialisation time — see `highSeeded` and
+     * the constructor effect.
+     */
     protected readonly high: _angular_core.WritableSignal<number>;
+    /**
+     * Whether `high` has ever been told a real value by the model.
+     *
+     * `<wr-slider range [min]="200" [max]="300" />` binds no value, so the model
+     * holds its own scalar default and the tuple branch below never runs: `high`
+     * kept the literal 100, which is not inside every `[min, max]`. The thumb
+     * rendered off the track and the first interaction committed `[low, 100]` —
+     * a value the slider itself calls out of range.
+     */
+    private highSeeded;
     protected readonly track: _angular_core.Signal<ElementRef<HTMLElement>>;
     /**
      * Ambient reading direction. Optional so a bare `TestBed` — or any consumer

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

@@ -0,0 +1,69 @@
+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-sparkline>` a harness query matches. */
+interface WrSparklineHarnessFilters extends BaseHarnessFilters {
+    /** Match the sparkline's accessible name — `null` for the decorative ones. */
+    readonly ariaLabel?: string | RegExp;
+}
+
+/**
+ * @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-sparkline>`.
+ *
+ * **The interesting assertion here is the ARIA one.** A sparkline is a trend line
+ * with no axes and no labels, so it is either given an `ariaLabel` — in which case it
+ * announces itself as an image — or it is decoration, and must be `aria-hidden` so a
+ * screen reader does not stop on a nameless graphic. The component switches between
+ * those two states on one input, and {@link isDecorative} is how a spec pins which
+ * one it is in.
+ *
+ * The line itself is an SVG path, and a path's `d` is not something a spec should
+ * assert: it is a rendering detail that changes with the viewBox, the stroke width
+ * and the smoothing. What IS worth asserting is whether the parts are there —
+ * {@link hasLine}, {@link hasArea}, {@link hasTip} — since each is an input the
+ * consumer set, and an empty dataset draws none of them.
+ *
+ * @see https://ngwr.dev/guides/testing
+ */
+declare class WrSparklineHarness extends ComponentHarness {
+    static hostSelector: string;
+    /** Build a predicate that narrows the query — pass to `getHarness` / `getAllHarnesses`. */
+    static with(options?: WrSparklineHarnessFilters): HarnessPredicate<WrSparklineHarness>;
+    private readonly svg;
+    /** The name the chart announces, or `null` when it is decoration. */
+    getAccessibleName(): Promise<string | null>;
+    /** The role the chart claims — `img` when it is named, `null` when it is not. */
+    getRole(): Promise<string | null>;
+    /**
+     * Whether the chart is hidden from assistive tech.
+     *
+     * The other half of {@link getAccessibleName}, and the pairing worth asserting
+     * together: a named sparkline must NOT be hidden, and an unnamed one must be, or a
+     * screen reader announces a graphic with nothing to say about it.
+     */
+    isDecorative(): Promise<boolean>;
+    /** Whether a trend line was drawn — `false` for an empty or single-point dataset. */
+    hasLine(): Promise<boolean>;
+    /** Whether the area under the line is filled (`showArea`). */
+    hasArea(): Promise<boolean>;
+    /** Whether the last point is marked with a dot (`showTip`). */
+    hasTip(): Promise<boolean>;
+    /** The stroke colour as the component passed it through — a CSS value, not a resolved one. */
+    getColor(): Promise<string | null>;
+}
+
+export { WrSparklineHarness };
+export type { WrSparklineHarnessFilters };