ngwr 10.2.1 → 11.0.0

package/fesm2022/ngwr-slider-testing.mjs

@@ -0,0 +1,478 @@
+import { ComponentHarness, HarnessPredicate, TestKey } 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
+ */
+/** How many key presses {@link WrSliderThumbHarness.setValue} spends before it gives up. */
+const MAX_PRESSES = 1000;
+/**
+ * Test harness for one thumb of a `<wr-slider>`.
+ *
+ * A single-thumb slider has exactly one; a `range` one has two, and each thumb
+ * is the other's limit — the lower thumb's `aria-valuemax` is wherever the upper
+ * thumb is standing, and vice versa. So {@link getMin} / {@link getMax} answer
+ * the room THIS thumb has, not the slider's bounds, which is exactly what a
+ * screen reader announces and exactly the window {@link setValue} can reach.
+ *
+ * Every write here is a KEY PRESS, because a drag is not something a unit test
+ * can perform — see {@link setValue}.
+ *
+ * Every press is on the BLOCK axis — `ArrowUp` / `ArrowDown`, `PageUp` /
+ * `PageDown`, `Home` / `End` — so the harness means the same thing in both
+ * reading directions. That is not a detail: the component's ← / → follow the
+ * VISUAL track, so under `dir="rtl"` a right-arrow LOWERS the value, and a
+ * harness that pressed it would have `stepUp()` stepping down while every LTR
+ * spec stayed green. It cannot detect the direction to compensate either —
+ * `Directionality` is injected, not published to the DOM — so it stays on the
+ * axis `dir` does not govern.
+ *
+ * @example
+ * ```ts
+ * const upper = await slider.getHighThumb();
+ *
+ * await upper.setValue(90);
+ * expect(await upper.getValue()).toBe(90);
+ * ```
+ *
+ * @see https://ngwr.dev/guides/testing
+ */
+class WrSliderThumbHarness extends ComponentHarness {
+    /**
+     * The thumb is a real `<button role="slider">`, so it is focusable without a
+     * `tabindex` and leaves the tab order by itself when disabled. Anchored on the
+     * BEM class rather than on `[role="slider"]`: the class also carries the
+     * `--low` / `--high` modifier this harness reads.
+     */
+    static hostSelector = '.wr-slider__thumb';
+    /** Build a predicate that narrows the query — pass to `getHarness` / `getAllHarnesses`. */
+    static with(options = {}) {
+        return new HarnessPredicate(WrSliderThumbHarness, options)
+            .addOption('position', options.position, async (harness, position) => (await harness.getPosition()) === position)
+            .addOption('value', options.value, async (harness, value) => (await harness.getValue()) === value)
+            .addOption('label', options.label, (harness, label) => HarnessPredicate.stringMatches(harness.getLabel(), label));
+    }
+    /** Which end this thumb is. A single-thumb slider's thumb is the `'low'` one. */
+    async getPosition() {
+        return (await (await this.host()).hasClass('wr-slider__thumb--high')) ? 'high' : 'low';
+    }
+    /** Where the thumb is standing, from `aria-valuenow` — the number a screen reader reads out. */
+    async getValue() {
+        return this.numeric('aria-valuenow');
+    }
+    /**
+     * The lowest value THIS thumb can reach (`aria-valuemin`).
+     *
+     * On a range slider's upper thumb that is the lower thumb, not the slider's
+     * `min` — the two cannot cross, so the neighbour is the real floor.
+     */
+    async getMin() {
+        return this.numeric('aria-valuemin');
+    }
+    /**
+     * The highest value THIS thumb can reach (`aria-valuemax`).
+     *
+     * On a range slider's lower thumb that is the upper thumb, not the slider's
+     * `max`.
+     */
+    async getMax() {
+        return this.numeric('aria-valuemax');
+    }
+    /** The thumb's accessible name — `'Value'`, or `'Lower value'` / `'Upper value'` in range mode. */
+    async getLabel() {
+        return (await this.host()).getAttribute('aria-label');
+    }
+    /** What a screen reader is told this control is. The role is why the arrows mean anything here. */
+    async getRole() {
+        return (await this.host()).getAttribute('role');
+    }
+    /** Whether the thumb refuses the keyboard. Read from the button's native `disabled`. */
+    async isDisabled() {
+        return (await this.host()).getProperty('disabled');
+    }
+    async focus() {
+        return (await this.host()).focus();
+    }
+    async isFocused() {
+        return (await this.host()).isFocused();
+    }
+    /**
+     * One step up (`ArrowUp`). A disabled thumb does not move.
+     *
+     * `ArrowRight` is the same key press in an LTR slider and the OPPOSITE one in
+     * an RTL slider, so the vertical arrow is the one that means "up" everywhere.
+     */
+    async stepUp() {
+        return this.press(TestKey.UP_ARROW);
+    }
+    /** One step down (`ArrowDown`; `ArrowLeft` only agrees in LTR — see {@link stepUp}). */
+    async stepDown() {
+        return this.press(TestKey.DOWN_ARROW);
+    }
+    /** Ten steps up (`PageUp`; `Shift`+arrow is the same stride). */
+    async largeStepUp() {
+        return this.press(TestKey.PAGE_UP);
+    }
+    /** Ten steps down (`PageDown`; `Shift`+arrow is the same stride). */
+    async largeStepDown() {
+        return this.press(TestKey.PAGE_DOWN);
+    }
+    /**
+     * `Home` — jump to the lowest value this thumb can reach.
+     *
+     * On a range slider's UPPER thumb that lands on the lower thumb, not on the
+     * slider's `min`: the component asks for `min` and then refuses to let the
+     * ends cross, so the range collapses instead of inverting.
+     */
+    async toMin() {
+        return this.press(TestKey.HOME);
+    }
+    /**
+     * `End` — jump to the highest value this thumb can reach.
+     *
+     * On a range slider's LOWER thumb that lands on the upper thumb, not on the
+     * slider's `max`, for the same reason as {@link toMin}.
+     */
+    async toMax() {
+        return this.press(TestKey.END);
+    }
+    /**
+     * Walk the thumb to `value` FROM THE KEYBOARD — `PageUp` / `PageDown` for the
+     * distance, arrows for the last stretch, `Home` / `End` for the bounds. That
+     * is the accessible path, and the only one a unit test can trust.
+     *
+     * There is deliberately no drag. jsdom has no layout: the track measures 0×0
+     * and `getBoundingClientRect()` answers all zeros, while the component turns a
+     * pointer into a value by dividing the offset by the track width. Every
+     * positive offset therefore divides by zero, clamps to a ratio of 1 and writes
+     * the slider's MAX — quietly, with no error to notice. A coordinate cannot
+     * mean anything here.
+     *
+     * It costs one press per stride, so the walk is not free: crossing most of a
+     * 0–100 range costs ~19 presses at `step="1"` and ~109 at `step="0.1"`.
+     * Landing exactly on a bound is one press, whatever the step. The walk gives
+     * up after 1000 presses — a 0–100 range reaches that at `step="0.01"` or finer
+     * — and throws rather than spin.
+     *
+     * A bound the step grid misses is announced but not reachable: `aria-valuemax`
+     * is the `max` input, while the component snaps every key press onto whole
+     * steps from `min`, so `max="100" step="3"` stops at 99. That is the off-grid
+     * throw, arriving for `setValue(100)`.
+     *
+     * Either the thumb ends up exactly on `value` or this throws: when `value` is
+     * outside the thumb's window (the other thumb is one end of it in range mode),
+     * when the thumb is disabled, and when `value` is not on the step grid — on
+     * the last one the thumb is left at the nearest value it could reach.
+     */
+    async setValue(value) {
+        if (await this.isDisabled()) {
+            throw new Error('WrSliderThumbHarness.setValue(): the slider is disabled, so the keyboard cannot move it.');
+        }
+        const [min, max] = [await this.getMin(), await this.getMax()];
+        if (value < min || value > max) {
+            throw new Error(`WrSliderThumbHarness.setValue(): ${value} is outside the [${min}, ${max}] window this thumb can ` +
+                'reach. On a range slider the other thumb is one end of that window — move it first.');
+        }
+        let current = await this.getValue();
+        if (current === value)
+            return;
+        // The bounds are one key press, and on a range thumb `Home` / `End` stop at
+        // the neighbour — which is precisely this window's end. The landing is still
+        // checked: a `max` that is not a whole number of steps from `min` is
+        // announced by `aria-valuemax` and refused by the component's snapping.
+        if (value === min || value === max) {
+            await (value === min ? this.toMin() : this.toMax());
+            return this.assertSettled(await this.getValue(), value, min);
+        }
+        let presses = 0;
+        // Start on the ten-step stride: neither stride is published to the DOM, so
+        // the only way to learn one is to take it and look. One overshoot is pressed
+        // back off and the rest of the walk goes a single step at a time.
+        let striding = true;
+        while (current !== value) {
+            if (presses >= MAX_PRESSES) {
+                throw new Error(`WrSliderThumbHarness.setValue(): gave up walking to ${value} after ${MAX_PRESSES} key presses ` +
+                    `(reached ${current}). A step this fine is not something a keyboard reaches — write the ` +
+                    'slider through its `[(value)]` model instead.');
+            }
+            // Re-derived every pass so the walk follows wherever the thumb actually
+            // landed rather than where a stride aimed. It never has to reverse: the
+            // window check above keeps the target inside [min, max], so pressing back
+            // off an overshoot lands at or short of where the stride began — on the
+            // same side of the target it started on.
+            const direction = value > current ? 1 : -1;
+            await this.press(this.strideKey(direction, striding));
+            presses++;
+            const next = await this.getValue();
+            // Nothing moved: the thumb is pinned against a bound or its neighbour, and
+            // pressing again would only spin. The final check below reports where.
+            if (next === current)
+                break;
+            const overshot = direction === 1 ? next > value : next < value;
+            current = next;
+            if (!overshot)
+                continue;
+            await this.press(this.strideKey(direction === 1 ? -1 : 1, striding));
+            presses++;
+            current = await this.getValue();
+            // Single steps straddling the target means it is not on the step grid.
+            if (!striding)
+                break;
+            striding = false;
+        }
+        this.assertSettled(current, value, min);
+    }
+    /**
+     * The landing check every path through {@link setValue} ends on: exactly the
+     * value asked for, or an error naming where the thumb stopped instead.
+     */
+    assertSettled(current, value, min) {
+        if (current === value)
+            return;
+        throw new Error(`WrSliderThumbHarness.setValue(): the keyboard settled on ${current} instead of ${value}. The thumb ` +
+            `moves in whole steps from ${min}, so only values on that grid are reachable.`);
+    }
+    /** The key that moves the thumb one stride in `direction`. */
+    strideKey(direction, striding) {
+        if (striding)
+            return direction === 1 ? TestKey.PAGE_UP : TestKey.PAGE_DOWN;
+        // The vertical arrows, for the reason {@link stepUp} gives: the horizontal
+        // pair swaps meaning under `dir="rtl"`, which would send the fine stretch of
+        // the walk away from its target.
+        return direction === 1 ? TestKey.UP_ARROW : TestKey.DOWN_ARROW;
+    }
+    /**
+     * Press a key on the thumb.
+     *
+     * `sendKeys` focuses the element first, so this is the whole gesture a user
+     * makes — the component listens for `keydown` on the thumb itself.
+     */
+    async press(key) {
+        return (await this.host()).sendKeys(key);
+    }
+    /**
+     * One of the ARIA range attributes as a number.
+     *
+     * Throws instead of handing back `NaN`: a slider whose `aria-valuenow` is not
+     * a number is broken in a way every later assertion would describe badly.
+     */
+    async numeric(attribute) {
+        const raw = await (await this.host()).getAttribute(attribute);
+        const value = raw === null ? Number.NaN : Number.parseFloat(raw);
+        if (Number.isNaN(value)) {
+            throw new Error(`WrSliderThumbHarness: the thumb's ${attribute} is ${JSON.stringify(raw)}, not a number.`);
+        }
+        return value;
+    }
+}
+
+/**
+ * @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
+ */
+/** Element-wise comparison for the `value` filter — a tuple never matches a plain number. */
+function sameValue(actual, expected) {
+    if (typeof actual === 'number')
+        return actual === expected;
+    if (typeof expected === 'number')
+        return false;
+    return actual[0] === expected[0] && actual[1] === expected[1];
+}
+/**
+ * Test harness for `<wr-slider>` — single-thumb and `range`.
+ *
+ * Every NUMBER it reads comes off the thumbs' ARIA range trio (`aria-valuenow`,
+ * `aria-valuemin`, `aria-valuemax`), which is what a screen reader is told and
+ * the only place the slider publishes its value. The mode comes off the host's
+ * `wr-slider--range` class and {@link getLabelText} off the rendered text.
+ *
+ * Everything it WRITES is a key press. A slider is a pointer control, but a
+ * pointer control cannot be driven by coordinates in jsdom — there is no layout,
+ * so the track measures 0×0 and the component divides every offset by that
+ * width: a positive one writes the slider's MAX and `clientX: 0` writes `NaN`,
+ * neither of them the value asked for. The keyboard is both the accessible path
+ * and the only honest one here; {@link WrSliderThumbHarness.setValue} spells out
+ * what the walk costs, and {@link WrSliderThumbHarness} why every one of those
+ * presses is on the block axis, which `dir` does not turn around.
+ *
+ * The `step` is deliberately not readable: the component publishes it nowhere in
+ * the DOM (ARIA has no attribute for it), so a spec that needs the number should
+ * measure it — `stepUp()` moves by exactly one step.
+ *
+ * @example
+ * ```ts
+ * const volume = await loader.getHarness(WrSliderHarness);
+ *
+ * await volume.setValue(70);
+ * expect(await volume.getValue()).toBe(70);
+ *
+ * const span = await loader.getHarness(WrSliderHarness.with({ range: true }));
+ * await span.setRange(30, 60);
+ * ```
+ *
+ * @see https://ngwr.dev/guides/testing
+ */
+class WrSliderHarness extends ComponentHarness {
+    static hostSelector = 'wr-slider';
+    /** Build a predicate that narrows the query — pass to `getHarness` / `getAllHarnesses`. */
+    static with(options = {}) {
+        return new HarnessPredicate(WrSliderHarness, options)
+            .addOption('value', options.value, async (harness, value) => sameValue(await harness.getValue(), value))
+            .addOption('range', options.range, async (harness, range) => (await harness.isRange()) === range)
+            .addOption('disabled', options.disabled, async (harness, disabled) => (await harness.isDisabled()) === disabled)
+            .addOption('labelText', options.labelText, (harness, text) => HarnessPredicate.stringMatches(harness.getLabelText(), text));
+    }
+    /** Whether the slider has two thumbs and answers with a `[low, high]` tuple. */
+    async isRange() {
+        return (await this.host()).hasClass('wr-slider--range');
+    }
+    /**
+     * Whether the slider refuses interaction.
+     *
+     * Read from the thumb's native `disabled` rather than from the
+     * `wr-slider--disabled` class: the class is paint, while `disabled` on the
+     * button is what takes the thumb out of the tab order and what assistive tech
+     * reports.
+     */
+    async isDisabled() {
+        return (await this.getLowThumb()).isDisabled();
+    }
+    /**
+     * The current value, in the shape the model uses: a plain number for one
+     * thumb, `[low, high]` for two.
+     */
+    async getValue() {
+        const values = await Promise.all((await this.getThumbs()).map(thumb => thumb.getValue()));
+        return values.length > 1 ? [values[0], values[1]] : values[0];
+    }
+    /** The slider's lower bound. */
+    async getMin() {
+        return (await this.getThumbs())[0].getMin();
+    }
+    /**
+     * The slider's upper bound.
+     *
+     * Taken from the LAST thumb, because in range mode the thumbs bound each
+     * other: the lower one's `aria-valuemax` is wherever the upper one is
+     * standing, so only the upper thumb knows the real ceiling.
+     */
+    async getMax() {
+        const thumbs = await this.getThumbs();
+        return thumbs[thumbs.length - 1].getMax();
+    }
+    /**
+     * The text the slider prints under the track, or `null` when `showLabel` is
+     * off.
+     *
+     * A range slider joins its ends with an EN DASH — `'20 – 80'`, U+2013 — so an
+     * assertion typed with a hyphen will not match.
+     */
+    async getLabelText() {
+        const label = await this.locatorForOptional('.wr-slider__label')();
+        return label ? label.text() : null;
+    }
+    /** The slider's thumbs in DOM order: the lower one first. */
+    async getThumbs(filters = {}) {
+        return this.locatorForAll(WrSliderThumbHarness.with(filters))();
+    }
+    /** The only thumb of a single-thumb slider, or the lower one of a range slider. */
+    async getLowThumb() {
+        return this.locatorFor(WrSliderThumbHarness.with({ position: 'low' }))();
+    }
+    /** The upper thumb. Throws on a single-thumb slider, which has no such part. */
+    async getHighThumb() {
+        const thumb = await this.locatorForOptional(WrSliderThumbHarness.with({ position: 'high' }))();
+        if (!thumb) {
+            throw new Error('WrSliderHarness.getHighThumb(): this slider has one thumb — only a `range` slider has two.');
+        }
+        return thumb;
+    }
+    /**
+     * Walk the slider to `value` from the keyboard.
+     *
+     * Single-thumb only — {@link setRange} moves both ends. See
+     * {@link WrSliderThumbHarness.setValue} for what the walk costs and when it
+     * throws.
+     */
+    async setValue(value) {
+        return (await this.single('setValue')).setValue(value);
+    }
+    /**
+     * Walk both ends of a range slider to `[low, high]`.
+     *
+     * The far end moves FIRST. The thumbs bound each other, so writing `[90, 95]`
+     * over `[20, 80]` lower-end-first would be refused outright — 90 is outside
+     * the `[0, 80]` window the upper thumb leaves the lower one.
+     */
+    async setRange(low, high) {
+        if (!(await this.isRange())) {
+            throw new Error('WrSliderHarness.setRange(): this slider has one thumb — add `range` to it, or call setValue().');
+        }
+        if (low > high) {
+            throw new Error(`WrSliderHarness.setRange(): ${low} is above ${high}, and the thumbs cannot cross.`);
+        }
+        const lowThumb = await this.getLowThumb();
+        const highThumb = await this.getHighThumb();
+        if (high >= (await highThumb.getValue())) {
+            await highThumb.setValue(high);
+            await lowThumb.setValue(low);
+            return;
+        }
+        await lowThumb.setValue(low);
+        await highThumb.setValue(high);
+    }
+    /** One step up (`ArrowUp`). Single-thumb only. A disabled slider does not move. */
+    async stepUp() {
+        return (await this.single('stepUp')).stepUp();
+    }
+    /** One step down (`ArrowDown`). Single-thumb only. A disabled slider does not move. */
+    async stepDown() {
+        return (await this.single('stepDown')).stepDown();
+    }
+    /** `Home` — jump to the slider's `min`. Single-thumb only. */
+    async toMin() {
+        return (await this.single('toMin')).toMin();
+    }
+    /** `End` — jump to the slider's `max`. Single-thumb only. */
+    async toMax() {
+        return (await this.single('toMax')).toMax();
+    }
+    /**
+     * Move keyboard focus to the slider's first thumb. A range slider's thumbs are
+     * two separate tab stops (both are plain buttons — there is no roving
+     * `tabindex`), so reach the other one through {@link getHighThumb}.
+     */
+    async focus() {
+        return (await this.getLowThumb()).focus();
+    }
+    /** Whether any of the slider's thumbs holds focus. */
+    async isFocused() {
+        const focused = await Promise.all((await this.getThumbs()).map(thumb => thumb.isFocused()));
+        return focused.includes(true);
+    }
+    /**
+     * The one thumb a single-thumb convenience call means.
+     *
+     * Range mode gets an error rather than a guess: "step this slider up" has two
+     * possible answers there, and picking one silently is how a spec ends up
+     * asserting against the end it did not move.
+     */
+    async single(caller) {
+        if (await this.isRange()) {
+            throw new Error(`WrSliderHarness.${caller}(): this slider has two thumbs — use setRange(), or reach for one end ` +
+                'with getLowThumb() / getHighThumb().');
+        }
+        return this.getLowThumb();
+    }
+}
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { WrSliderHarness, WrSliderThumbHarness };
+//# sourceMappingURL=ngwr-slider-testing.mjs.map

package/fesm2022/ngwr-slider-testing.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"ngwr-slider-testing.mjs","sources":["../../../projects/lib/slider/testing/wr-slider-thumb-harness.ts","../../../projects/lib/slider/testing/wr-slider-harness.ts","../../../projects/lib/slider/testing/ngwr-slider-testing.ts"],"sourcesContent":["/**\n * @license\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://github.com/thekhegay/ngwr/blob/main/LICENSE\n */\n\nimport { ComponentHarness, HarnessPredicate, TestKey } from '@angular/cdk/testing';\n\nimport type { WrSliderThumbHarnessFilters, WrSliderThumbPosition } from './interfaces';\n\n/** How many key presses {@link WrSliderThumbHarness.setValue} spends before it gives up. */\nconst MAX_PRESSES = 1000;\n\n/**\n * Test harness for one thumb of a `<wr-slider>`.\n *\n * A single-thumb slider has exactly one; a `range` one has two, and each thumb\n * is the other's limit — the lower thumb's `aria-valuemax` is wherever the upper\n * thumb is standing, and vice versa. So {@link getMin} / {@link getMax} answer\n * the room THIS thumb has, not the slider's bounds, which is exactly what a\n * screen reader announces and exactly the window {@link setValue} can reach.\n *\n * Every write here is a KEY PRESS, because a drag is not something a unit test\n * can perform — see {@link setValue}.\n *\n * Every press is on the BLOCK axis — `ArrowUp` / `ArrowDown`, `PageUp` /\n * `PageDown`, `Home` / `End` — so the harness means the same thing in both\n * reading directions. That is not a detail: the component's ← / → follow the\n * VISUAL track, so under `dir=\"rtl\"` a right-arrow LOWERS the value, and a\n * harness that pressed it would have `stepUp()` stepping down while every LTR\n * spec stayed green. It cannot detect the direction to compensate either —\n * `Directionality` is injected, not published to the DOM — so it stays on the\n * axis `dir` does not govern.\n *\n * @example\n * ```ts\n * const upper = await slider.getHighThumb();\n *\n * await upper.setValue(90);\n * expect(await upper.getValue()).toBe(90);\n * ```\n *\n * @see https://ngwr.dev/guides/testing\n */\nexport class WrSliderThumbHarness extends ComponentHarness {\n  /**\n   * The thumb is a real `<button role=\"slider\">`, so it is focusable without a\n   * `tabindex` and leaves the tab order by itself when disabled. Anchored on the\n   * BEM class rather than on `[role=\"slider\"]`: the class also carries the\n   * `--low` / `--high` modifier this harness reads.\n   */\n  static hostSelector = '.wr-slider__thumb';\n\n  /** Build a predicate that narrows the query — pass to `getHarness` / `getAllHarnesses`. */\n  static with(options: WrSliderThumbHarnessFilters = {}): HarnessPredicate<WrSliderThumbHarness> {\n    return new HarnessPredicate(WrSliderThumbHarness, options)\n      .addOption('position', options.position, async (harness, position) => (await harness.getPosition()) === position)\n      .addOption('value', options.value, async (harness, value) => (await harness.getValue()) === value)\n      .addOption('label', options.label, (harness, label) => HarnessPredicate.stringMatches(harness.getLabel(), label));\n  }\n\n  /** Which end this thumb is. A single-thumb slider's thumb is the `'low'` one. */\n  async getPosition(): Promise<WrSliderThumbPosition> {\n    return (await (await this.host()).hasClass('wr-slider__thumb--high')) ? 'high' : 'low';\n  }\n\n  /** Where the thumb is standing, from `aria-valuenow` — the number a screen reader reads out. */\n  async getValue(): Promise<number> {\n    return this.numeric('aria-valuenow');\n  }\n\n  /**\n   * The lowest value THIS thumb can reach (`aria-valuemin`).\n   *\n   * On a range slider's upper thumb that is the lower thumb, not the slider's\n   * `min` — the two cannot cross, so the neighbour is the real floor.\n   */\n  async getMin(): Promise<number> {\n    return this.numeric('aria-valuemin');\n  }\n\n  /**\n   * The highest value THIS thumb can reach (`aria-valuemax`).\n   *\n   * On a range slider's lower thumb that is the upper thumb, not the slider's\n   * `max`.\n   */\n  async getMax(): Promise<number> {\n    return this.numeric('aria-valuemax');\n  }\n\n  /** The thumb's accessible name — `'Value'`, or `'Lower value'` / `'Upper value'` in range mode. */\n  async getLabel(): Promise<string | null> {\n    return (await this.host()).getAttribute('aria-label');\n  }\n\n  /** What a screen reader is told this control is. The role is why the arrows mean anything here. */\n  async getRole(): Promise<string | null> {\n    return (await this.host()).getAttribute('role');\n  }\n\n  /** Whether the thumb refuses the keyboard. Read from the button's native `disabled`. */\n  async isDisabled(): Promise<boolean> {\n    return (await this.host()).getProperty<boolean>('disabled');\n  }\n\n  async focus(): Promise<void> {\n    return (await this.host()).focus();\n  }\n\n  async isFocused(): Promise<boolean> {\n    return (await this.host()).isFocused();\n  }\n\n  /**\n   * One step up (`ArrowUp`). A disabled thumb does not move.\n   *\n   * `ArrowRight` is the same key press in an LTR slider and the OPPOSITE one in\n   * an RTL slider, so the vertical arrow is the one that means \"up\" everywhere.\n   */\n  async stepUp(): Promise<void> {\n    return this.press(TestKey.UP_ARROW);\n  }\n\n  /** One step down (`ArrowDown`; `ArrowLeft` only agrees in LTR — see {@link stepUp}). */\n  async stepDown(): Promise<void> {\n    return this.press(TestKey.DOWN_ARROW);\n  }\n\n  /** Ten steps up (`PageUp`; `Shift`+arrow is the same stride). */\n  async largeStepUp(): Promise<void> {\n    return this.press(TestKey.PAGE_UP);\n  }\n\n  /** Ten steps down (`PageDown`; `Shift`+arrow is the same stride). */\n  async largeStepDown(): Promise<void> {\n    return this.press(TestKey.PAGE_DOWN);\n  }\n\n  /**\n   * `Home` — jump to the lowest value this thumb can reach.\n   *\n   * On a range slider's UPPER thumb that lands on the lower thumb, not on the\n   * slider's `min`: the component asks for `min` and then refuses to let the\n   * ends cross, so the range collapses instead of inverting.\n   */\n  async toMin(): Promise<void> {\n    return this.press(TestKey.HOME);\n  }\n\n  /**\n   * `End` — jump to the highest value this thumb can reach.\n   *\n   * On a range slider's LOWER thumb that lands on the upper thumb, not on the\n   * slider's `max`, for the same reason as {@link toMin}.\n   */\n  async toMax(): Promise<void> {\n    return this.press(TestKey.END);\n  }\n\n  /**\n   * Walk the thumb to `value` FROM THE KEYBOARD — `PageUp` / `PageDown` for the\n   * distance, arrows for the last stretch, `Home` / `End` for the bounds. That\n   * is the accessible path, and the only one a unit test can trust.\n   *\n   * There is deliberately no drag. jsdom has no layout: the track measures 0×0\n   * and `getBoundingClientRect()` answers all zeros, while the component turns a\n   * pointer into a value by dividing the offset by the track width. Every\n   * positive offset therefore divides by zero, clamps to a ratio of 1 and writes\n   * the slider's MAX — quietly, with no error to notice. A coordinate cannot\n   * mean anything here.\n   *\n   * It costs one press per stride, so the walk is not free: crossing most of a\n   * 0–100 range costs ~19 presses at `step=\"1\"` and ~109 at `step=\"0.1\"`.\n   * Landing exactly on a bound is one press, whatever the step. The walk gives\n   * up after 1000 presses — a 0–100 range reaches that at `step=\"0.01\"` or finer\n   * — and throws rather than spin.\n   *\n   * A bound the step grid misses is announced but not reachable: `aria-valuemax`\n   * is the `max` input, while the component snaps every key press onto whole\n   * steps from `min`, so `max=\"100\" step=\"3\"` stops at 99. That is the off-grid\n   * throw, arriving for `setValue(100)`.\n   *\n   * Either the thumb ends up exactly on `value` or this throws: when `value` is\n   * outside the thumb's window (the other thumb is one end of it in range mode),\n   * when the thumb is disabled, and when `value` is not on the step grid — on\n   * the last one the thumb is left at the nearest value it could reach.\n   */\n  async setValue(value: number): Promise<void> {\n    if (await this.isDisabled()) {\n      throw new Error('WrSliderThumbHarness.setValue(): the slider is disabled, so the keyboard cannot move it.');\n    }\n\n    const [min, max] = [await this.getMin(), await this.getMax()];\n    if (value < min || value > max) {\n      throw new Error(\n        `WrSliderThumbHarness.setValue(): ${value} is outside the [${min}, ${max}] window this thumb can ` +\n          'reach. On a range slider the other thumb is one end of that window — move it first.'\n      );\n    }\n\n    let current = await this.getValue();\n    if (current === value) return;\n    // The bounds are one key press, and on a range thumb `Home` / `End` stop at\n    // the neighbour — which is precisely this window's end. The landing is still\n    // checked: a `max` that is not a whole number of steps from `min` is\n    // announced by `aria-valuemax` and refused by the component's snapping.\n    if (value === min || value === max) {\n      await (value === min ? this.toMin() : this.toMax());\n      return this.assertSettled(await this.getValue(), value, min);\n    }\n\n    let presses = 0;\n    // Start on the ten-step stride: neither stride is published to the DOM, so\n    // the only way to learn one is to take it and look. One overshoot is pressed\n    // back off and the rest of the walk goes a single step at a time.\n    let striding = true;\n\n    while (current !== value) {\n      if (presses >= MAX_PRESSES) {\n        throw new Error(\n          `WrSliderThumbHarness.setValue(): gave up walking to ${value} after ${MAX_PRESSES} key presses ` +\n            `(reached ${current}). A step this fine is not something a keyboard reaches — write the ` +\n            'slider through its `[(value)]` model instead.'\n        );\n      }\n\n      // Re-derived every pass so the walk follows wherever the thumb actually\n      // landed rather than where a stride aimed. It never has to reverse: the\n      // window check above keeps the target inside [min, max], so pressing back\n      // off an overshoot lands at or short of where the stride began — on the\n      // same side of the target it started on.\n      const direction: 1 | -1 = value > current ? 1 : -1;\n      await this.press(this.strideKey(direction, striding));\n      presses++;\n\n      const next = await this.getValue();\n      // Nothing moved: the thumb is pinned against a bound or its neighbour, and\n      // pressing again would only spin. The final check below reports where.\n      if (next === current) break;\n\n      const overshot = direction === 1 ? next > value : next < value;\n      current = next;\n      if (!overshot) continue;\n\n      await this.press(this.strideKey(direction === 1 ? -1 : 1, striding));\n      presses++;\n      current = await this.getValue();\n\n      // Single steps straddling the target means it is not on the step grid.\n      if (!striding) break;\n      striding = false;\n    }\n\n    this.assertSettled(current, value, min);\n  }\n\n  /**\n   * The landing check every path through {@link setValue} ends on: exactly the\n   * value asked for, or an error naming where the thumb stopped instead.\n   */\n  private assertSettled(current: number, value: number, min: number): void {\n    if (current === value) return;\n    throw new Error(\n      `WrSliderThumbHarness.setValue(): the keyboard settled on ${current} instead of ${value}. The thumb ` +\n        `moves in whole steps from ${min}, so only values on that grid are reachable.`\n    );\n  }\n\n  /** The key that moves the thumb one stride in `direction`. */\n  private strideKey(direction: 1 | -1, striding: boolean): TestKey {\n    if (striding) return direction === 1 ? TestKey.PAGE_UP : TestKey.PAGE_DOWN;\n    // The vertical arrows, for the reason {@link stepUp} gives: the horizontal\n    // pair swaps meaning under `dir=\"rtl\"`, which would send the fine stretch of\n    // the walk away from its target.\n    return direction === 1 ? TestKey.UP_ARROW : TestKey.DOWN_ARROW;\n  }\n\n  /**\n   * Press a key on the thumb.\n   *\n   * `sendKeys` focuses the element first, so this is the whole gesture a user\n   * makes — the component listens for `keydown` on the thumb itself.\n   */\n  private async press(key: TestKey): Promise<void> {\n    return (await this.host()).sendKeys(key);\n  }\n\n  /**\n   * One of the ARIA range attributes as a number.\n   *\n   * Throws instead of handing back `NaN`: a slider whose `aria-valuenow` is not\n   * a number is broken in a way every later assertion would describe badly.\n   */\n  private async numeric(attribute: string): Promise<number> {\n    const raw = await (await this.host()).getAttribute(attribute);\n    const value = raw === null ? Number.NaN : Number.parseFloat(raw);\n\n    if (Number.isNaN(value)) {\n      throw new Error(`WrSliderThumbHarness: the thumb's ${attribute} is ${JSON.stringify(raw)}, not a number.`);\n    }\n    return value;\n  }\n}\n","/**\n * @license\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://github.com/thekhegay/ngwr/blob/main/LICENSE\n */\n\nimport { ComponentHarness, HarnessPredicate } from '@angular/cdk/testing';\n\nimport type { WrSliderValue } from 'ngwr/slider';\n\nimport type { WrSliderHarnessFilters, WrSliderThumbHarnessFilters } from './interfaces';\nimport { WrSliderThumbHarness } from './wr-slider-thumb-harness';\n\n/** Element-wise comparison for the `value` filter — a tuple never matches a plain number. */\nfunction sameValue(actual: WrSliderValue, expected: WrSliderValue): boolean {\n  if (typeof actual === 'number') return actual === expected;\n  if (typeof expected === 'number') return false;\n  return actual[0] === expected[0] && actual[1] === expected[1];\n}\n\n/**\n * Test harness for `<wr-slider>` — single-thumb and `range`.\n *\n * Every NUMBER it reads comes off the thumbs' ARIA range trio (`aria-valuenow`,\n * `aria-valuemin`, `aria-valuemax`), which is what a screen reader is told and\n * the only place the slider publishes its value. The mode comes off the host's\n * `wr-slider--range` class and {@link getLabelText} off the rendered text.\n *\n * Everything it WRITES is a key press. A slider is a pointer control, but a\n * pointer control cannot be driven by coordinates in jsdom — there is no layout,\n * so the track measures 0×0 and the component divides every offset by that\n * width: a positive one writes the slider's MAX and `clientX: 0` writes `NaN`,\n * neither of them the value asked for. The keyboard is both the accessible path\n * and the only honest one here; {@link WrSliderThumbHarness.setValue} spells out\n * what the walk costs, and {@link WrSliderThumbHarness} why every one of those\n * presses is on the block axis, which `dir` does not turn around.\n *\n * The `step` is deliberately not readable: the component publishes it nowhere in\n * the DOM (ARIA has no attribute for it), so a spec that needs the number should\n * measure it — `stepUp()` moves by exactly one step.\n *\n * @example\n * ```ts\n * const volume = await loader.getHarness(WrSliderHarness);\n *\n * await volume.setValue(70);\n * expect(await volume.getValue()).toBe(70);\n *\n * const span = await loader.getHarness(WrSliderHarness.with({ range: true }));\n * await span.setRange(30, 60);\n * ```\n *\n * @see https://ngwr.dev/guides/testing\n */\nexport class WrSliderHarness extends ComponentHarness {\n  static hostSelector = 'wr-slider';\n\n  /** Build a predicate that narrows the query — pass to `getHarness` / `getAllHarnesses`. */\n  static with(options: WrSliderHarnessFilters = {}): HarnessPredicate<WrSliderHarness> {\n    return new HarnessPredicate(WrSliderHarness, options)\n      .addOption('value', options.value, async (harness, value) => sameValue(await harness.getValue(), value))\n      .addOption('range', options.range, async (harness, range) => (await harness.isRange()) === range)\n      .addOption('disabled', options.disabled, async (harness, disabled) => (await harness.isDisabled()) === disabled)\n      .addOption('labelText', options.labelText, (harness, text) =>\n        HarnessPredicate.stringMatches(harness.getLabelText(), text)\n      );\n  }\n\n  /** Whether the slider has two thumbs and answers with a `[low, high]` tuple. */\n  async isRange(): Promise<boolean> {\n    return (await this.host()).hasClass('wr-slider--range');\n  }\n\n  /**\n   * Whether the slider refuses interaction.\n   *\n   * Read from the thumb's native `disabled` rather than from the\n   * `wr-slider--disabled` class: the class is paint, while `disabled` on the\n   * button is what takes the thumb out of the tab order and what assistive tech\n   * reports.\n   */\n  async isDisabled(): Promise<boolean> {\n    return (await this.getLowThumb()).isDisabled();\n  }\n\n  /**\n   * The current value, in the shape the model uses: a plain number for one\n   * thumb, `[low, high]` for two.\n   */\n  async getValue(): Promise<WrSliderValue> {\n    const values = await Promise.all((await this.getThumbs()).map(thumb => thumb.getValue()));\n    return values.length > 1 ? ([values[0], values[1]] as const) : values[0];\n  }\n\n  /** The slider's lower bound. */\n  async getMin(): Promise<number> {\n    return (await this.getThumbs())[0].getMin();\n  }\n\n  /**\n   * The slider's upper bound.\n   *\n   * Taken from the LAST thumb, because in range mode the thumbs bound each\n   * other: the lower one's `aria-valuemax` is wherever the upper one is\n   * standing, so only the upper thumb knows the real ceiling.\n   */\n  async getMax(): Promise<number> {\n    const thumbs = await this.getThumbs();\n    return thumbs[thumbs.length - 1].getMax();\n  }\n\n  /**\n   * The text the slider prints under the track, or `null` when `showLabel` is\n   * off.\n   *\n   * A range slider joins its ends with an EN DASH — `'20 – 80'`, U+2013 — so an\n   * assertion typed with a hyphen will not match.\n   */\n  async getLabelText(): Promise<string | null> {\n    const label = await this.locatorForOptional('.wr-slider__label')();\n    return label ? label.text() : null;\n  }\n\n  /** The slider's thumbs in DOM order: the lower one first. */\n  async getThumbs(filters: WrSliderThumbHarnessFilters = {}): Promise<WrSliderThumbHarness[]> {\n    return this.locatorForAll(WrSliderThumbHarness.with(filters))();\n  }\n\n  /** The only thumb of a single-thumb slider, or the lower one of a range slider. */\n  async getLowThumb(): Promise<WrSliderThumbHarness> {\n    return this.locatorFor(WrSliderThumbHarness.with({ position: 'low' }))();\n  }\n\n  /** The upper thumb. Throws on a single-thumb slider, which has no such part. */\n  async getHighThumb(): Promise<WrSliderThumbHarness> {\n    const thumb = await this.locatorForOptional(WrSliderThumbHarness.with({ position: 'high' }))();\n    if (!thumb) {\n      throw new Error('WrSliderHarness.getHighThumb(): this slider has one thumb — only a `range` slider has two.');\n    }\n    return thumb;\n  }\n\n  /**\n   * Walk the slider to `value` from the keyboard.\n   *\n   * Single-thumb only — {@link setRange} moves both ends. See\n   * {@link WrSliderThumbHarness.setValue} for what the walk costs and when it\n   * throws.\n   */\n  async setValue(value: number): Promise<void> {\n    return (await this.single('setValue')).setValue(value);\n  }\n\n  /**\n   * Walk both ends of a range slider to `[low, high]`.\n   *\n   * The far end moves FIRST. The thumbs bound each other, so writing `[90, 95]`\n   * over `[20, 80]` lower-end-first would be refused outright — 90 is outside\n   * the `[0, 80]` window the upper thumb leaves the lower one.\n   */\n  async setRange(low: number, high: number): Promise<void> {\n    if (!(await this.isRange())) {\n      throw new Error('WrSliderHarness.setRange(): this slider has one thumb — add `range` to it, or call setValue().');\n    }\n    if (low > high) {\n      throw new Error(`WrSliderHarness.setRange(): ${low} is above ${high}, and the thumbs cannot cross.`);\n    }\n\n    const lowThumb = await this.getLowThumb();\n    const highThumb = await this.getHighThumb();\n\n    if (high >= (await highThumb.getValue())) {\n      await highThumb.setValue(high);\n      await lowThumb.setValue(low);\n      return;\n    }\n\n    await lowThumb.setValue(low);\n    await highThumb.setValue(high);\n  }\n\n  /** One step up (`ArrowUp`). Single-thumb only. A disabled slider does not move. */\n  async stepUp(): Promise<void> {\n    return (await this.single('stepUp')).stepUp();\n  }\n\n  /** One step down (`ArrowDown`). Single-thumb only. A disabled slider does not move. */\n  async stepDown(): Promise<void> {\n    return (await this.single('stepDown')).stepDown();\n  }\n\n  /** `Home` — jump to the slider's `min`. Single-thumb only. */\n  async toMin(): Promise<void> {\n    return (await this.single('toMin')).toMin();\n  }\n\n  /** `End` — jump to the slider's `max`. Single-thumb only. */\n  async toMax(): Promise<void> {\n    return (await this.single('toMax')).toMax();\n  }\n\n  /**\n   * Move keyboard focus to the slider's first thumb. A range slider's thumbs are\n   * two separate tab stops (both are plain buttons — there is no roving\n   * `tabindex`), so reach the other one through {@link getHighThumb}.\n   */\n  async focus(): Promise<void> {\n    return (await this.getLowThumb()).focus();\n  }\n\n  /** Whether any of the slider's thumbs holds focus. */\n  async isFocused(): Promise<boolean> {\n    const focused = await Promise.all((await this.getThumbs()).map(thumb => thumb.isFocused()));\n    return focused.includes(true);\n  }\n\n  /**\n   * The one thumb a single-thumb convenience call means.\n   *\n   * Range mode gets an error rather than a guess: \"step this slider up\" has two\n   * possible answers there, and picking one silently is how a spec ends up\n   * asserting against the end it did not move.\n   */\n  private async single(caller: string): Promise<WrSliderThumbHarness> {\n    if (await this.isRange()) {\n      throw new Error(\n        `WrSliderHarness.${caller}(): this slider has two thumbs — use setRange(), or reach for one end ` +\n          'with getLowThumb() / getHighThumb().'\n      );\n    }\n    return this.getLowThumb();\n  }\n}\n","/**\n * Generated bundle index. Do not edit.\n */\n\nexport * from './public-api';\n"],"names":[],"mappings":"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"}