ngwr 11.1.0 → 11.2.0

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

@@ -0,0 +1,186 @@
+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-falling-text>` a harness query matches. */
+interface WrFallingTextHarnessFilters extends BaseHarnessFilters {
+    /**
+     * Match the rendered sentence — the only thing that tells two of these apart, the
+     * component having no name, id or role of its own. A string is an exact match, a
+     * RegExp is tested.
+     *
+     * Compared against `WrFallingTextHarness.getText()`, so the non-breaking spaces the
+     * component types between the words are already back to plain ones: pass the sentence
+     * as it was written.
+     */
+    readonly text?: 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-falling-text>`.
+ *
+ * **The assertion that matters here is that the animation did not eat the text.** The
+ * component cuts the sentence into one span per word so a physics loop can throw them
+ * around, and {@link getText} is the check that a screen reader still gets prose out of
+ * the other end. It normalises whitespace on the way, because the separators are real
+ * `&nbsp;` characters rather than plain spaces — so `textContent` is never byte-identical
+ * to the `[text]` input, and a spec comparing the two raw would fail on a component that
+ * works perfectly.
+ *
+ * The rest of the readable surface is the split itself: {@link getWords} pins the rule
+ * (split on spaces, empty tokens dropped) and {@link getHighlightedWords} pins the
+ * prefix match, which is genuine logic — `grav` highlights `gravity`, and a whole-word
+ * implementation would satisfy every naive test but not this one.
+ *
+ * **Nothing positional is offered, and that is not a jsdom concession.** The words'
+ * `transform` values are one frame of a loop that never stops, seeded by `Math.random()`,
+ * so they are not reproducible even in a real browser; there is no rest state to call
+ * settled; the drag path needs `setPointerCapture` and AABB hit-testing over boxes that
+ * a unit test measures as 0×0 at the origin, where every word contains every point. Nor
+ * is `[gravity]` or `[trigger]` readable — neither reaches the DOM, and answering them
+ * would mean reaching into the component instance. There is no `isReducedMotion()`
+ * either: under reduced motion the component simply returns before touching anything, so
+ * the only honest proxy is {@link hasReleased}, which reports what it did rather than
+ * what it was told.
+ *
+ * **{@link hasReleased} and {@link release} have a precondition, and without it they are
+ * worthless.** The simulator measures the host and each word before it starts, and bails
+ * on a zero-sized box — which is every box in a test with no layout. So the spec has to
+ * give them one, and it has to do it BEFORE the trigger fires: the component marks itself
+ * started on the way past that guard, and the trigger listener is `{ once: true }`, so a
+ * failed first attempt is permanent.
+ *
+ * ```ts
+ * // In your spec, on a fixture mounted with trigger="click", before calling release():
+ * const box = { width: 300, height: 120, left: 0, top: 0, right: 300, bottom: 120 } as DOMRect;
+ * for (const el of fixture.nativeElement.querySelectorAll('wr-falling-text, .wr-falling-text__word')) {
+ *   el.getBoundingClientRect = () => box;
+ * }
+ * ```
+ *
+ * Assert `hasReleased()` is `true` in that control case before you assert it is `false`
+ * anywhere else, or a spec proves only that the guard fired.
+ *
+ * @example
+ * ```ts
+ * const loader = TestbedHarnessEnvironment.loader(fixture);
+ * const text = await loader.getHarness(WrFallingTextHarness);
+ *
+ * expect(await text.getText()).toBe('gravity pulls every word down');
+ * expect(await text.getHighlightedWords()).toEqual(['gravity']);
+ * ```
+ *
+ * @see https://ngwr.dev/guides/testing
+ */
+declare class WrFallingTextHarness extends ComponentHarness {
+    static hostSelector: string;
+    /** Build a predicate that narrows the query — pass to `getHarness` / `getAllHarnesses`. */
+    static with(options?: WrFallingTextHarnessFilters): HarnessPredicate<WrFallingTextHarness>;
+    private readonly wordEls;
+    /**
+     * The whole sentence, as a screen reader reads it: whitespace collapsed and trimmed.
+     *
+     * The one assertion worth making about a component that dismantles a paragraph. The
+     * words are separated by `.wr-falling-text__space` spans holding U+00A0, so this
+     * collapses them back to ordinary spaces — losing those spans would be invisible to
+     * every other check here while turning the announcement into one run-on word.
+     *
+     * DOM order never changes once the physics starts. The words are absolutely positioned
+     * and scattered on screen, but they are still read in the order they were typeset, so
+     * this answers the same before and after {@link release}.
+     */
+    getText(): Promise<string>;
+    /**
+     * Each word, in DOM order.
+     *
+     * Pins the split rule: on a literal space, with empty tokens dropped. Each of these is
+     * also one body in the simulator, so the length is the body count — which is why there
+     * is no separate `getWordCount()`, a method that would invite asserting how many
+     * without asserting which.
+     */
+    getWords(): Promise<string[]>;
+    /**
+     * The words carrying the highlight, in DOM order.
+     *
+     * `[highlightWords]` is matched as a PREFIX and case-sensitively, so `['grav']` picks
+     * up `gravity` and `['Grav']` picks up nothing. The highlight is colour alone with no
+     * non-visual counterpart, which is acceptable only because it adds no meaning the
+     * sentence does not already carry.
+     */
+    getHighlightedWords(): Promise<string[]>;
+    /**
+     * Whether one word is highlighted — for asserting a keyword without depending on the
+     * order or the completeness of the whole list.
+     *
+     * Takes the word as it is rendered, not the keyword that matched it: ask for `gravity`,
+     * not for `grav`. Throws for a word the sentence does not contain, since `false` there
+     * would read as "present and not highlighted" and quietly survive a typo. A word that
+     * appears twice is answered once, which is safe — matching is on the text alone, so
+     * both copies always agree.
+     */
+    isHighlighted(word: string): Promise<boolean>;
+    /**
+     * The font size as the consumer wrote it — `'2rem'`, not `'32px'`.
+     *
+     * Read off the inline `style` attribute rather than through `getCssValue()`. The two
+     * agree here and would part company in a real browser, which resolves `font-size` to
+     * pixels; `[fontSize]` takes a CSS length and handing back a different unit than the
+     * one that went in is the sort of green unit test that hides a broken assertion.
+     *
+     * Throws when nothing is written, which takes an empty `[fontSize]` — the component
+     * writes this on every render otherwise, default included.
+     */
+    getFontSize(): Promise<string>;
+    /**
+     * Whether the simulator has taken the words over.
+     *
+     * Reads the `position: absolute` the component writes onto every word before its first
+     * frame — a value it wrote itself, not a measurement, and the only difference in the
+     * DOM between "the physics is running" and "the words are still in normal flow". That
+     * makes it the way to observe the trigger contract and the reduced-motion escape, since
+     * neither leaves anything else behind.
+     *
+     * **It is `false` by default in a test, for a reason that has nothing to do with the
+     * component.** Without layout every box measures 0×0 and the simulator refuses to start
+     * — see this class's docs for the stub, and assert a `true` before you trust a `false`.
+     *
+     * Throws for a component rendering no words at all, where the question does not apply.
+     */
+    hasReleased(): Promise<boolean>;
+    /**
+     * Fire the events a `click` or `hover` trigger is waiting for.
+     *
+     * Both, because the harness cannot tell which one it is: `[trigger]` never reaches the
+     * DOM. The component consumes at most one — its listener is registered `{ once: true }`
+     * and the simulator refuses to start twice — so this is safe to call whatever the
+     * trigger is, and safe to call again.
+     *
+     * It does nothing for `auto`, which released on mount, and nothing for `scroll`, which
+     * waits on an `IntersectionObserver`: jsdom has none, so a spec has to stub the global
+     * and fire the callback itself. Same precondition as {@link hasReleased} — stub the
+     * boxes BEFORE calling this, because a start that bails on a zero-sized host still
+     * burns the trigger.
+     *
+     * Both are dispatched as bare events rather than through the harness's `click()` and
+     * `hover()` helpers, which would bring a whole pointer sequence with them. Released
+     * words listen for `pointerdown` so they can be picked up and thrown, and that handler
+     * calls `setPointerCapture` — which a unit environment does not implement, so the
+     * realistic version of this method would throw the moment the simulator was running.
+     */
+    release(): Promise<void>;
+}
+
+export { WrFallingTextHarness };
+export type { WrFallingTextHarnessFilters };

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

@@ -0,0 +1,130 @@
+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-fuzzy-text>` a harness query matches. */
+interface WrFuzzyTextHarnessFilters extends BaseHarnessFilters {
+    /**
+     * Match the headline — a string is an exact match, a RegExp is tested.
+     *
+     * The only filter, and the only one possible: everything else this component is told
+     * ends up as a canvas font string or a fill style and never reaches the DOM, so the
+     * readable copy of the text is the sole thing that tells two headlines apart. Matched
+     * through `WrFuzzyTextHarness.getText`, which reads the screen-reader span rather than
+     * the pixels.
+     */
+    readonly text?: 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-fuzzy-text>` — a headline drawn into a canvas, one row of pixels
+ * at a time, with a random offset per row.
+ *
+ * **The drawing is out of reach and the accessible half is not, which is the whole shape
+ * of this harness.** There is no 2D context in a unit test — `getContext('2d')` returns
+ * `null`, and the component's `init()` gives up on the line after — so nothing downstream
+ * of that ever happens: no font load, no animation frame, no canvas listeners, no sizing.
+ * What survives is the markup, and the markup is the part that regressed: everything this
+ * component rendered used to be a canvas, so a screen reader got an empty element where
+ * the page showed a headline. {@link getText} and {@link isDecorative} are that fix,
+ * asserted as the PAIR it has to be — a readable copy plus a hidden pixel copy. Reading
+ * one without the other passes just as happily on a component that announces the headline
+ * twice.
+ *
+ * **The canvas is selected by tag, not by a class.** It carries no BEM name, unlike the
+ * two sibling animation canvases — this entry point ships no stylesheet at all, which is
+ * also why {@link isTextVisuallyHidden} is a real question rather than a formality.
+ *
+ * Nothing about the animation is offered, and none of it is a gap that could be closed by
+ * trying harder. There is no `getIntensity()` / `isFuzzing()` / `isGlitching()`: those are
+ * closure variables inside `init()` that only ever manifest as pixels, and in a test the
+ * function returns before they exist. No `hover()` / `click()` / `getHoverIntensity()`:
+ * the pointer listeners are attached only after a real context AND a resolved
+ * `document.fonts` — neither of which a unit test has — so a dispatched event would land
+ * on nothing and the assertion would pass vacuously; the hit test also measures the canvas
+ * box, which is all zeros. No `getCanvasSize()`, which would be asserting jsdom's untouched
+ * 300×150 default rather than the component's layout maths. No `getColor()` /
+ * `getFontSize()` / `getFontFamily()` / `getGradient()`: every one of those becomes a
+ * canvas font string or a fill style and never reaches the DOM. No `getRenderedText()` or
+ * `readPixel()` — there are no pixels, and faking a context would change what every spec
+ * here is testing. And no `isReducedMotion()`: the preference is honoured by taking a
+ * different DRAWING path, with identical markup, classes and attributes either way, so the
+ * method would answer the same for a component that honoured it and one that ignored it.
+ *
+ * @example
+ * ```ts
+ * const headline = await loader.getHarness(WrFuzzyTextHarness.with({ text: '404' }));
+ *
+ * expect(await headline.getText()).toBe('404');
+ * expect(await headline.isDecorative()).toBe(true);
+ * ```
+ *
+ * @see https://ngwr.dev/guides/testing
+ */
+declare class WrFuzzyTextHarness extends ComponentHarness {
+    static hostSelector: string;
+    /** Build a predicate that narrows the query — pass to `getHarness` / `getAllHarnesses`. */
+    static with(options?: WrFuzzyTextHarnessFilters): HarnessPredicate<WrFuzzyTextHarness>;
+    private readonly srOnly;
+    private readonly canvas;
+    /**
+     * The headline as TEXT, trimmed.
+     *
+     * From the screen-reader span, which is the only place the string exists as characters —
+     * the visible copy is glyphs painted into a canvas. This is the single assertion that
+     * separates the component from an empty box for anyone not looking at the screen, and it
+     * is the one that has already regressed once.
+     *
+     * There is no letter-by-letter split to worry about here, unlike the other text
+     * animations in the library: the span holds one text node, so what a reader announces is
+     * what {@link WrFuzzyTextHarness.getText} returns.
+     */
+    getText(): Promise<string>;
+    /**
+     * Whether the pixel copy stays out of the accessibility tree.
+     *
+     * The other half of {@link getText}. The canvas has no text and no name, so without its
+     * `aria-hidden` a reader meets an anonymous element next to the headline it already
+     * read — or, if the span ever goes away again, only the anonymous element. Asserting the
+     * two together is what pins the arrangement; asserting either alone does not.
+     */
+    isDecorative(): Promise<boolean>;
+    /**
+     * Whether the drawing surface is in the markup.
+     *
+     * True even where it can never be painted — under SSR, in a prerender, in a browser that
+     * refuses a 2D context, and in every unit test — because the element is rendered
+     * unconditionally and only the drawing depends on a context. That is precisely the state
+     * the readable copy exists to cover, so this is the method that says "the fallback is
+     * carrying the page right now".
+     */
+    hasCanvas(): Promise<boolean>;
+    /**
+     * Whether the readable copy hides itself without a stylesheet.
+     *
+     * This entry point ships no CSS. The span is therefore hidden with inline declarations
+     * rather than an `.sr-only` class, and that is load-bearing rather than a style choice:
+     * move the block into a class and every consumer who imported no CSS sees the headline
+     * twice — once as pixels, once as a stray line of markup underneath.
+     *
+     * Three of the declarations are checked, not one, because they fail apart: `position`
+     * takes the span out of flow, the 1px box collapses it, and `clip-path` is what keeps
+     * the character still reachable by a reader instead of `display: none`-ing it away.
+     */
+    isTextVisuallyHidden(): Promise<boolean>;
+}
+
+export { WrFuzzyTextHarness };
+export type { WrFuzzyTextHarnessFilters };

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

@@ -0,0 +1,71 @@
+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-gauge>` a harness query matches. */
+interface WrGaugeHarnessFilters extends BaseHarnessFilters {
+    /** Match the dial's accessible name. */
+    readonly ariaLabel?: string | RegExp;
+    /** Match the value the dial announces. */
+    readonly value?: 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-gauge>`.
+ *
+ * **The dial is `aria-hidden` and the printed number is optional, so the ARIA is the
+ * whole readable surface.** The component carries `role="meter"` with the value
+ * trio and an `aria-valuetext` that includes the suffix — which is what makes a
+ * gauge with `showValue` off readable at all. {@link getValue} is what it announces;
+ * {@link getDisplayValue} is what is drawn, and it is `null` when nothing is.
+ *
+ * The arc is an SVG path, and its `d` is a rendering detail rather than an
+ * assertion — it moves with the size, the stroke width and the sweep.
+ *
+ * @see https://ngwr.dev/guides/testing
+ */
+declare class WrGaugeHarness extends ComponentHarness {
+    static hostSelector: string;
+    /** Build a predicate that narrows the query — pass to `getHarness` / `getAllHarnesses`. */
+    static with(options?: WrGaugeHarnessFilters): HarnessPredicate<WrGaugeHarness>;
+    private readonly surface;
+    /** The role the dial announces — `meter`, which is what a gauge is. */
+    getRole(): Promise<string | null>;
+    /** The dial's accessible name. */
+    getAccessibleName(): Promise<string | null>;
+    /** The value it 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 spoken form of the value — the number with its suffix.
+     *
+     * The reason a gauge with no printed value is still readable, and worth asserting
+     * separately from {@link getValue}: a percentage announced as a bare `72` says
+     * something different from `72%`.
+     */
+    getValueText(): Promise<string | null>;
+    /** The number printed in the middle, suffix included, or `null` when `showValue` is off. */
+    getDisplayValue(): Promise<string | null>;
+    /** The suffix alone, or `null` when there is none — or nothing is printed. */
+    getSuffix(): Promise<string | null>;
+    /** The dial's width in pixels, as the component writes it inline. */
+    getSize(): Promise<number>;
+}
+
+export { WrGaugeHarness };
+export type { WrGaugeHarnessFilters };

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

@@ -0,0 +1,172 @@
+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-glitch-text>` a harness query matches. */
+interface WrGlitchTextHarnessFilters extends BaseHarnessFilters {
+    /** Match the rendered text — a string is an exact match, a RegExp is tested. */
+    readonly text?: string | RegExp;
+    /**
+     * Match only the hover-gated variant (`true`) or only the always-on one (`false`).
+     * Note that hover-gated is the DEFAULT, so `{ hoverOnly: false }` selects the
+     * component that was explicitly told `[enableOnHover]="false"`.
+     */
+    readonly hoverOnly?: boolean;
+}
+/** How long each clone layer takes to complete one tear cycle, in seconds. */
+interface WrGlitchTextDurations {
+    /** The `::before` clone — `speed × 2`. */
+    readonly before: number;
+    /** The `::after` clone — `speed × 3`. */
+    readonly after: number;
+}
+/** The two clone `text-shadow`s, exactly as the component wrote them. */
+interface WrGlitchTextColourSplit {
+    /** The `::before` clone's shadow — offset right, and tinted `info`. */
+    readonly before: string;
+    /** The `::after` clone's shadow — offset left, and tinted `danger`. */
+    readonly after: string;
+}
+
+/**
+ * @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-glitch-text>`.
+ *
+ * **The one thing worth testing here is the pairing.** The two torn clones are
+ * `::before` / `::after` pseudo-elements whose glyphs come from `content:
+ * attr(data-text)`, so the string has to be in the host's text node AND in the host's
+ * `data-text` attribute. Drop either binding and the visible text stays flawless while
+ * the effect disappears — no error, no missing element, nothing else in the DOM
+ * changes. {@link isCloneTextInSync} is that assertion in one call.
+ *
+ * **Everything else the harness reads is an inline custom property**, because that is
+ * everything the component writes: the two clone durations, the two colour-split
+ * shadows and the optional slice background. They are worth pinning for the unit
+ * transforms — a duration that loses its `s`, or two clones that end up on the same
+ * multiple and tear in lockstep, is a regression that changes no class, no attribute
+ * and no text.
+ *
+ * **What the harness deliberately does not offer**, and why. There is no
+ * `isGlitching()`: the tear is a `@keyframes` animation on a pseudo-element, applied by
+ * a stylesheet a unit test never loads, so the only available answer is a class name
+ * repackaged as a state. There is no `hover()` / `isGlitchingOnHover()`: the gate is a
+ * `:hover` SELECTOR, and the DOM after a dispatched mouse event is byte-identical to
+ * the DOM before it — a spec built on that would pass against a component whose hover
+ * rules had been deleted. There is no `getCloneOffset()` / `getClipPath()`: the ±10px
+ * offsets and the tear bands live in the stylesheet and are pure layout besides. There
+ * is no `respectsReducedMotion()`: the handling is a `@media` block with no TypeScript
+ * counterpart, so the DOM is identical in both states and there is nothing to read.
+ * There is no resolver for the shadow colours — they hold `var(--wr-color-info)` /
+ * `var(--wr-color-danger)`, and resolving those needs the theme stylesheet. And there
+ * is no `getSpeed()`: the input is never written to the DOM, only its two products are,
+ * and dividing one back would invent a precision the component never published (at
+ * `[speed]="0.3"` the after-duration is literally `0.8999999999999999s`).
+ *
+ * @example
+ * ```ts
+ * const glitch = await loader.getHarness(WrGlitchTextHarness);
+ *
+ * expect(await glitch.isCloneTextInSync()).toBe(true);
+ * expect((await glitch.getDurations()).after).toBeCloseTo(3);
+ * ```
+ *
+ * @see https://ngwr.dev/guides/testing
+ */
+declare class WrGlitchTextHarness extends ComponentHarness {
+    static hostSelector: string;
+    /** Build a predicate that narrows the query — pass to `getHarness` / `getAllHarnesses`. */
+    static with(options?: WrGlitchTextHarnessFilters): HarnessPredicate<WrGlitchTextHarness>;
+    /**
+     * The rendered text, trimmed.
+     *
+     * The half a sighted user reads, and the half every other check would notice
+     * breaking. The component interpolates the input straight onto the host, so there is
+     * no inner element to query.
+     */
+    getText(): Promise<string>;
+    /**
+     * The string the two clone layers draw from — the host's `data-text`.
+     *
+     * The half nothing else notices. `content: attr(data-text)` is how both pseudo-clones
+     * get their glyphs, so this attribute IS the effect. `null` means the mirror is gone
+     * and the component is rendering plain text with extra classes.
+     */
+    getCloneText(): Promise<string | null>;
+    /**
+     * Whether the clone attribute still mirrors the rendered text.
+     *
+     * The component's defining silent failure, as a single assertion — two separate reads
+     * are two things a spec can forget to write together. Compared raw on both sides,
+     * with no trimming: the template is the bare interpolation, so the text node and the
+     * attribute are byte-identical or the mirror is broken. An empty `text` is legal and
+     * counts as in sync — `data-text=""` is a mirror of nothing, not a missing binding,
+     * which is why {@link getCloneText} reports the absent case as `null` instead.
+     */
+    isCloneTextInSync(): Promise<boolean>;
+    /**
+     * Whether the effect idles until the pointer arrives (`enableOnHover`).
+     *
+     * The `wr-glitch-text--hover-only` class is the only DOM trace of that input, the gate
+     * itself being a `:hover` rule. It defaults to `true`, so this is also how a spec
+     * catches the day someone "fixes" the default to match the component's own JSDoc,
+     * which describes the opposite.
+     */
+    isHoverOnly(): Promise<boolean>;
+    /**
+     * How long each clone takes to complete a cycle, in seconds.
+     *
+     * The two must NOT be equal: they run at 2× and 3× the `speed` multiplier so the tears
+     * fall out of phase, and clones tearing in lockstep read as one shifted copy rather
+     * than as a glitch. That regression changes no class, no attribute and no text, and no
+     * visual gate in this repo can see it either.
+     *
+     * These are raw JavaScript floats — `[speed]="0.3"` writes `0.8999999999999999s` —
+     * so compare with `toBeCloseTo`, never against a formatted string.
+     */
+    getDurations(): Promise<WrGlitchTextDurations>;
+    /**
+     * Whether the red / cyan colour split is switched on (`enableShadows`).
+     *
+     * The component writes the literal `none` rather than removing the properties when the
+     * split is off, so "disabled" and "never set" stay distinguishable — an absent property
+     * would mean a broken binding, and this reports that as no split either.
+     */
+    hasColourSplit(): Promise<boolean>;
+    /**
+     * The two clone `text-shadow`s, exactly as written — `var()` tokens and all.
+     *
+     * Returned unresolved on purpose: resolving `var(--wr-color-info)` needs the theme
+     * stylesheet, and a unit test that answered with a colour would be inventing one.
+     * What the raw pair does prove is the thing a copy-paste breaks — the offsets must
+     * have OPPOSITE signs and the two tints must be DIFFERENT intents. Give both clones
+     * the same colour, or the same sign, and the chromatic aberration is gone while every
+     * other reading stays green.
+     */
+    getColourSplit(): Promise<WrGlitchTextColourSplit>;
+    /**
+     * The masking colour behind the clone slices, or `null` when none was given.
+     *
+     * The binding emits `null` for an empty input, so the property is ABSENT rather than
+     * set to `transparent`, and the stylesheet's own `var(--wr-glitch-text-bg, transparent)`
+     * fallback does the work. A component that started writing `transparent` inline would
+     * look identical and break nothing until a consumer relied on that fallback — which is
+     * the whole reason this reports the absent case as `null` instead of as a colour.
+     */
+    getSliceBackground(): Promise<string | null>;
+    /** One of the host's inline duration properties, as a number of seconds. */
+    private seconds;
+}
+
+export { WrGlitchTextHarness };
+export type { WrGlitchTextColourSplit, WrGlitchTextDurations, WrGlitchTextHarnessFilters };