ngwr 14.10.0 → 14.12.0

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

@@ -1 +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":";;AAAA;;;;;AAKG;AAMH;AACA,MAAM,WAAW,GAAG,IAAI;AAExB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA8BG;AACG,MAAO,oBAAqB,SAAQ,gBAAgB,CAAA;AACxD;;;;;AAKG;AACH,IAAA,OAAO,YAAY,GAAG,mBAAmB;;AAGzC,IAAA,OAAO,IAAI,CAAC,OAAA,GAAuC,EAAE,EAAA;AACnD,QAAA,OAAO,IAAI,gBAAgB,CAAC,oBAAoB,EAAE,OAAO;aACtD,SAAS,CAAC,UAAU,EAAE,OAAO,CAAC,QAAQ,EAAE,OAAO,OAAO,EAAE,QAAQ,KAAK,CAAC,MAAM,OAAO,CAAC,WAAW,EAAE,MAAM,QAAQ;aAC/G,SAAS,CAAC,OAAO,EAAE,OAAO,CAAC,KAAK,EAAE,OAAO,OAAO,EAAE,KAAK,KAAK,CAAC,MAAM,OAAO,CAAC,QAAQ,EAAE,MAAM,KAAK;aAChG,SAAS,CAAC,OAAO,EAAE,OAAO,CAAC,KAAK,EAAE,CAAC,OAAO,EAAE,KAAK,KAAK,gBAAgB,CAAC,aAAa,CAAC,OAAO,CAAC,QAAQ,EAAE,EAAE,KAAK,CAAC,CAAC;IACrH;;AAGA,IAAA,MAAM,WAAW,GAAA;QACf,OAAO,CAAC,MAAM,CAAC,MAAM,IAAI,CAAC,IAAI,EAAE,EAAE,QAAQ,CAAC,wBAAwB,CAAC,IAAI,MAAM,GAAG,KAAK;IACxF;;AAGA,IAAA,MAAM,QAAQ,GAAA;AACZ,QAAA,OAAO,IAAI,CAAC,OAAO,CAAC,eAAe,CAAC;IACtC;AAEA;;;;;AAKG;AACH,IAAA,MAAM,MAAM,GAAA;AACV,QAAA,OAAO,IAAI,CAAC,OAAO,CAAC,eAAe,CAAC;IACtC;AAEA;;;;;AAKG;AACH,IAAA,MAAM,MAAM,GAAA;AACV,QAAA,OAAO,IAAI,CAAC,OAAO,CAAC,eAAe,CAAC;IACtC;;AAGA,IAAA,MAAM,QAAQ,GAAA;AACZ,QAAA,OAAO,CAAC,MAAM,IAAI,CAAC,IAAI,EAAE,EAAE,YAAY,CAAC,YAAY,CAAC;IACvD;;AAGA,IAAA,MAAM,OAAO,GAAA;AACX,QAAA,OAAO,CAAC,MAAM,IAAI,CAAC,IAAI,EAAE,EAAE,YAAY,CAAC,MAAM,CAAC;IACjD;;AAGA,IAAA,MAAM,UAAU,GAAA;AACd,QAAA,OAAO,CAAC,MAAM,IAAI,CAAC,IAAI,EAAE,EAAE,WAAW,CAAU,UAAU,CAAC;IAC7D;AAEA,IAAA,MAAM,KAAK,GAAA;QACT,OAAO,CAAC,MAAM,IAAI,CAAC,IAAI,EAAE,EAAE,KAAK,EAAE;IACpC;AAEA,IAAA,MAAM,SAAS,GAAA;QACb,OAAO,CAAC,MAAM,IAAI,CAAC,IAAI,EAAE,EAAE,SAAS,EAAE;IACxC;AAEA;;;;;AAKG;AACH,IAAA,MAAM,MAAM,GAAA;QACV,OAAO,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,QAAQ,CAAC;IACrC;;AAGA,IAAA,MAAM,QAAQ,GAAA;QACZ,OAAO,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,UAAU,CAAC;IACvC;;AAGA,IAAA,MAAM,WAAW,GAAA;QACf,OAAO,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,OAAO,CAAC;IACpC;;AAGA,IAAA,MAAM,aAAa,GAAA;QACjB,OAAO,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,SAAS,CAAC;IACtC;AAEA;;;;;;AAMG;AACH,IAAA,MAAM,KAAK,GAAA;QACT,OAAO,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,IAAI,CAAC;IACjC;AAEA;;;;;AAKG;AACH,IAAA,MAAM,KAAK,GAAA;QACT,OAAO,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,GAAG,CAAC;IAChC;AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;AA2BG;IACH,MAAM,QAAQ,CAAC,KAAa,EAAA;AAC1B,QAAA,IAAI,MAAM,IAAI,CAAC,UAAU,EAAE,EAAE;AAC3B,YAAA,MAAM,IAAI,KAAK,CAAC,0FAA0F,CAAC;QAC7G;AAEA,QAAA,MAAM,CAAC,GAAG,EAAE,GAAG,CAAC,GAAG,CAAC,MAAM,IAAI,CAAC,MAAM,EAAE,EAAE,MAAM,IAAI,CAAC,MAAM,EAAE,CAAC;QAC7D,IAAI,KAAK,GAAG,GAAG,IAAI,KAAK,GAAG,GAAG,EAAE;YAC9B,MAAM,IAAI,KAAK,CACb,CAAA,iCAAA,EAAoC,KAAK,CAAA,iBAAA,EAAoB,GAAG,CAAA,EAAA,EAAK,GAAG,CAAA,wBAAA,CAA0B;AAChG,gBAAA,qFAAqF,CACxF;QACH;AAEA,QAAA,IAAI,OAAO,GAAG,MAAM,IAAI,CAAC,QAAQ,EAAE;QACnC,IAAI,OAAO,KAAK,KAAK;YAAE;;;;;QAKvB,IAAI,KAAK,KAAK,GAAG,IAAI,KAAK,KAAK,GAAG,EAAE;AAClC,YAAA,OAAO,KAAK,KAAK,GAAG,GAAG,IAAI,CAAC,KAAK,EAAE,GAAG,IAAI,CAAC,KAAK,EAAE,CAAC;AACnD,YAAA,OAAO,IAAI,CAAC,aAAa,CAAC,MAAM,IAAI,CAAC,QAAQ,EAAE,EAAE,KAAK,EAAE,GAAG,CAAC;QAC9D;QAEA,IAAI,OAAO,GAAG,CAAC;;;;QAIf,IAAI,QAAQ,GAAG,IAAI;AAEnB,QAAA,OAAO,OAAO,KAAK,KAAK,EAAE;AACxB,YAAA,IAAI,OAAO,IAAI,WAAW,EAAE;AAC1B,gBAAA,MAAM,IAAI,KAAK,CACb,uDAAuD,KAAK,CAAA,OAAA,EAAU,WAAW,CAAA,aAAA,CAAe;AAC9F,oBAAA,CAAA,SAAA,EAAY,OAAO,CAAA,oEAAA,CAAsE;AACzF,oBAAA,+CAA+C,CAClD;YACH;;;;;;AAOA,YAAA,MAAM,SAAS,GAAW,KAAK,GAAG,OAAO,GAAG,CAAC,GAAG,CAAC,CAAC;AAClD,YAAA,MAAM,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,SAAS,CAAC,SAAS,EAAE,QAAQ,CAAC,CAAC;AACrD,YAAA,OAAO,EAAE;AAET,YAAA,MAAM,IAAI,GAAG,MAAM,IAAI,CAAC,QAAQ,EAAE;;;YAGlC,IAAI,IAAI,KAAK,OAAO;gBAAE;AAEtB,YAAA,MAAM,QAAQ,GAAG,SAAS,KAAK,CAAC,GAAG,IAAI,GAAG,KAAK,GAAG,IAAI,GAAG,KAAK;YAC9D,OAAO,GAAG,IAAI;AACd,YAAA,IAAI,CAAC,QAAQ;gBAAE;YAEf,MAAM,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,SAAS,CAAC,SAAS,KAAK,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,EAAE,QAAQ,CAAC,CAAC;AACpE,YAAA,OAAO,EAAE;AACT,YAAA,OAAO,GAAG,MAAM,IAAI,CAAC,QAAQ,EAAE;;AAG/B,YAAA,IAAI,CAAC,QAAQ;gBAAE;YACf,QAAQ,GAAG,KAAK;QAClB;QAEA,IAAI,CAAC,aAAa,CAAC,OAAO,EAAE,KAAK,EAAE,GAAG,CAAC;IACzC;AAEA;;;AAGG;AACK,IAAA,aAAa,CAAC,OAAe,EAAE,KAAa,EAAE,GAAW,EAAA;QAC/D,IAAI,OAAO,KAAK,KAAK;YAAE;AACvB,QAAA,MAAM,IAAI,KAAK,CACb,4DAA4D,OAAO,CAAA,YAAA,EAAe,KAAK,CAAA,YAAA,CAAc;YACnG,CAAA,0BAAA,EAA6B,GAAG,CAAA,4CAAA,CAA8C,CACjF;IACH;;IAGQ,SAAS,CAAC,SAAiB,EAAE,QAAiB,EAAA;AACpD,QAAA,IAAI,QAAQ;AAAE,YAAA,OAAO,SAAS,KAAK,CAAC,GAAG,OAAO,CAAC,OAAO,GAAG,OAAO,CAAC,SAAS;;;;AAI1E,QAAA,OAAO,SAAS,KAAK,CAAC,GAAG,OAAO,CAAC,QAAQ,GAAG,OAAO,CAAC,UAAU;IAChE;AAEA;;;;;AAKG;IACK,MAAM,KAAK,CAAC,GAAY,EAAA;AAC9B,QAAA,OAAO,CAAC,MAAM,IAAI,CAAC,IAAI,EAAE,EAAE,QAAQ,CAAC,GAAG,CAAC;IAC1C;AAEA;;;;;AAKG;IACK,MAAM,OAAO,CAAC,SAAiB,EAAA;AACrC,QAAA,MAAM,GAAG,GAAG,MAAM,CAAC,MAAM,IAAI,CAAC,IAAI,EAAE,EAAE,YAAY,CAAC,SAAS,CAAC;QAC7D,MAAM,KAAK,GAAG,GAAG,KAAK,IAAI,GAAG,MAAM,CAAC,GAAG,GAAG,MAAM,CAAC,UAAU,CAAC,GAAG,CAAC;AAEhE,QAAA,IAAI,MAAM,CAAC,KAAK,CAAC,KAAK,CAAC,EAAE;AACvB,YAAA,MAAM,IAAI,KAAK,CAAC,CAAA,kCAAA,EAAqC,SAAS,CAAA,IAAA,EAAO,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,CAAA,eAAA,CAAiB,CAAC;QAC5G;AACA,QAAA,OAAO,KAAK;IACd;;;AC/SF;;;;;AAKG;AASH;AACA,SAAS,SAAS,CAAC,MAAqB,EAAE,QAAuB,EAAA;IAC/D,IAAI,OAAO,MAAM,KAAK,QAAQ;QAAE,OAAO,MAAM,KAAK,QAAQ;IAC1D,IAAI,OAAO,QAAQ,KAAK,QAAQ;AAAE,QAAA,OAAO,KAAK;AAC9C,IAAA,OAAO,MAAM,CAAC,CAAC,CAAC,KAAK,QAAQ,CAAC,CAAC,CAAC,IAAI,MAAM,CAAC,CAAC,CAAC,KAAK,QAAQ,CAAC,CAAC,CAAC;AAC/D;AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAiCG;AACG,MAAO,eAAgB,SAAQ,gBAAgB,CAAA;AACnD,IAAA,OAAO,YAAY,GAAG,WAAW;;AAGjC,IAAA,OAAO,IAAI,CAAC,OAAA,GAAkC,EAAE,EAAA;AAC9C,QAAA,OAAO,IAAI,gBAAgB,CAAC,eAAe,EAAE,OAAO;aACjD,SAAS,CAAC,OAAO,EAAE,OAAO,CAAC,KAAK,EAAE,OAAO,OAAO,EAAE,KAAK,KAAK,SAAS,CAAC,MAAM,OAAO,CAAC,QAAQ,EAAE,EAAE,KAAK,CAAC;aACtG,SAAS,CAAC,OAAO,EAAE,OAAO,CAAC,KAAK,EAAE,OAAO,OAAO,EAAE,KAAK,KAAK,CAAC,MAAM,OAAO,CAAC,OAAO,EAAE,MAAM,KAAK;aAC/F,SAAS,CAAC,UAAU,EAAE,OAAO,CAAC,QAAQ,EAAE,OAAO,OAAO,EAAE,QAAQ,KAAK,CAAC,MAAM,OAAO,CAAC,UAAU,EAAE,MAAM,QAAQ;aAC9G,SAAS,CAAC,WAAW,EAAE,OAAO,CAAC,SAAS,EAAE,CAAC,OAAO,EAAE,IAAI,KACvD,gBAAgB,CAAC,aAAa,CAAC,OAAO,CAAC,YAAY,EAAE,EAAE,IAAI,CAAC,CAC7D;IACL;;AAGA,IAAA,MAAM,OAAO,GAAA;AACX,QAAA,OAAO,CAAC,MAAM,IAAI,CAAC,IAAI,EAAE,EAAE,QAAQ,CAAC,kBAAkB,CAAC;IACzD;AAEA;;;;;;;AAOG;AACH,IAAA,MAAM,UAAU,GAAA;QACd,OAAO,CAAC,MAAM,IAAI,CAAC,WAAW,EAAE,EAAE,UAAU,EAAE;IAChD;AAEA;;;AAGG;AACH,IAAA,MAAM,QAAQ,GAAA;QACZ,MAAM,MAAM,GAAG,MAAM,OAAO,CAAC,GAAG,CAAC,CAAC,MAAM,IAAI,CAAC,SAAS,EAAE,EAAE,GAAG,CAAC,KAAK,IAAI,KAAK,CAAC,QAAQ,EAAE,CAAC,CAAC;QACzF,OAAO,MAAM,CAAC,MAAM,GAAG,CAAC,GAAI,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,MAAM,CAAC,CAAC,CAAC,CAAW,GAAG,MAAM,CAAC,CAAC,CAAC;IAC1E;;AAGA,IAAA,MAAM,MAAM,GAAA;AACV,QAAA,OAAO,CAAC,MAAM,IAAI,CAAC,SAAS,EAAE,EAAE,CAAC,CAAC,CAAC,MAAM,EAAE;IAC7C;AAEA;;;;;;AAMG;AACH,IAAA,MAAM,MAAM,GAAA;AACV,QAAA,MAAM,MAAM,GAAG,MAAM,IAAI,CAAC,SAAS,EAAE;QACrC,OAAO,MAAM,CAAC,MAAM,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,MAAM,EAAE;IAC3C;AAEA;;;;;;AAMG;AACH,IAAA,MAAM,YAAY,GAAA;QAChB,MAAM,KAAK,GAAG,MAAM,IAAI,CAAC,kBAAkB,CAAC,mBAAmB,CAAC,EAAE;AAClE,QAAA,OAAO,KAAK,GAAG,KAAK,CAAC,IAAI,EAAE,GAAG,IAAI;IACpC;;AAGA,IAAA,MAAM,SAAS,CAAC,OAAA,GAAuC,EAAE,EAAA;AACvD,QAAA,OAAO,IAAI,CAAC,aAAa,CAAC,oBAAoB,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC,EAAE;IACjE;;AAGA,IAAA,MAAM,WAAW,GAAA;AACf,QAAA,OAAO,IAAI,CAAC,UAAU,CAAC,oBAAoB,CAAC,IAAI,CAAC,EAAE,QAAQ,EAAE,KAAK,EAAE,CAAC,CAAC,EAAE;IAC1E;;AAGA,IAAA,MAAM,YAAY,GAAA;AAChB,QAAA,MAAM,KAAK,GAAG,MAAM,IAAI,CAAC,kBAAkB,CAAC,oBAAoB,CAAC,IAAI,CAAC,EAAE,QAAQ,EAAE,MAAM,EAAE,CAAC,CAAC,EAAE;QAC9F,IAAI,CAAC,KAAK,EAAE;AACV,YAAA,MAAM,IAAI,KAAK,CAAC,4FAA4F,CAAC;QAC/G;AACA,QAAA,OAAO,KAAK;IACd;AAEA;;;;;;AAMG;IACH,MAAM,QAAQ,CAAC,KAAa,EAAA;AAC1B,QAAA,OAAO,CAAC,MAAM,IAAI,CAAC,MAAM,CAAC,UAAU,CAAC,EAAE,QAAQ,CAAC,KAAK,CAAC;IACxD;AAEA;;;;;;AAMG;AACH,IAAA,MAAM,QAAQ,CAAC,GAAW,EAAE,IAAY,EAAA;QACtC,IAAI,EAAE,MAAM,IAAI,CAAC,OAAO,EAAE,CAAC,EAAE;AAC3B,YAAA,MAAM,IAAI,KAAK,CAAC,gGAAgG,CAAC;QACnH;AACA,QAAA,IAAI,GAAG,GAAG,IAAI,EAAE;YACd,MAAM,IAAI,KAAK,CAAC,CAAA,4BAAA,EAA+B,GAAG,CAAA,UAAA,EAAa,IAAI,CAAA,8BAAA,CAAgC,CAAC;QACtG;AAEA,QAAA,MAAM,QAAQ,GAAG,MAAM,IAAI,CAAC,WAAW,EAAE;AACzC,QAAA,MAAM,SAAS,GAAG,MAAM,IAAI,CAAC,YAAY,EAAE;QAE3C,IAAI,IAAI,KAAK,MAAM,SAAS,CAAC,QAAQ,EAAE,CAAC,EAAE;AACxC,YAAA,MAAM,SAAS,CAAC,QAAQ,CAAC,IAAI,CAAC;AAC9B,YAAA,MAAM,QAAQ,CAAC,QAAQ,CAAC,GAAG,CAAC;YAC5B;QACF;AAEA,QAAA,MAAM,QAAQ,CAAC,QAAQ,CAAC,GAAG,CAAC;AAC5B,QAAA,MAAM,SAAS,CAAC,QAAQ,CAAC,IAAI,CAAC;IAChC;;AAGA,IAAA,MAAM,MAAM,GAAA;AACV,QAAA,OAAO,CAAC,MAAM,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,EAAE,MAAM,EAAE;IAC/C;;AAGA,IAAA,MAAM,QAAQ,GAAA;AACZ,QAAA,OAAO,CAAC,MAAM,IAAI,CAAC,MAAM,CAAC,UAAU,CAAC,EAAE,QAAQ,EAAE;IACnD;;AAGA,IAAA,MAAM,KAAK,GAAA;AACT,QAAA,OAAO,CAAC,MAAM,IAAI,CAAC,MAAM,CAAC,OAAO,CAAC,EAAE,KAAK,EAAE;IAC7C;;AAGA,IAAA,MAAM,KAAK,GAAA;AACT,QAAA,OAAO,CAAC,MAAM,IAAI,CAAC,MAAM,CAAC,OAAO,CAAC,EAAE,KAAK,EAAE;IAC7C;AAEA;;;;AAIG;AACH,IAAA,MAAM,KAAK,GAAA;QACT,OAAO,CAAC,MAAM,IAAI,CAAC,WAAW,EAAE,EAAE,KAAK,EAAE;IAC3C;;AAGA,IAAA,MAAM,SAAS,GAAA;QACb,MAAM,OAAO,GAAG,MAAM,OAAO,CAAC,GAAG,CAAC,CAAC,MAAM,IAAI,CAAC,SAAS,EAAE,EAAE,GAAG,CAAC,KAAK,IAAI,KAAK,CAAC,SAAS,EAAE,CAAC,CAAC;AAC3F,QAAA,OAAO,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAC;IAC/B;AAEA;;;;;;AAMG;IACK,MAAM,MAAM,CAAC,MAAc,EAAA;AACjC,QAAA,IAAI,MAAM,IAAI,CAAC,OAAO,EAAE,EAAE;AACxB,YAAA,MAAM,IAAI,KAAK,CACb,CAAA,gBAAA,EAAmB,MAAM,CAAA,sEAAA,CAAwE;AAC/F,gBAAA,sCAAsC,CACzC;QACH;AACA,QAAA,OAAO,IAAI,CAAC,WAAW,EAAE;IAC3B;;;ACxOF;;AAEG;;"}
+{"version":3,"file":"ngwr-slider-testing.mjs","names":[],"sources":["../../../projects/lib/slider/testing/wr-slider-thumb-harness.ts","../../../projects/lib/slider/testing/wr-slider-harness.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"],"mappings":"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"}