ngwr 11.1.0 → 11.2.0

package/fesm2022/ngwr-speed-dial-testing.mjs

@@ -0,0 +1,279 @@
+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
+ */
+/**
+ * Test harness for one action inside a {@link WrSpeedDialHarness}.
+ *
+ * The label is read from `aria-label` rather than from the button's text, and that
+ * is the whole point of the control: an action renders an ICON, or — with no icon —
+ * the first glyph of its label. Its visible text is therefore `"S"` for "Share", or
+ * nothing at all. {@link getInitial} answers what is drawn; {@link getLabel} answers
+ * what it is.
+ *
+ * @see https://ngwr.dev/guides/testing
+ */
+class WrSpeedDialActionHarness extends ComponentHarness {
+    /** The action button. `role="menuitem"` sits on this element too. */
+    static hostSelector = '.wr-speed-dial__action';
+    /** Build a predicate that narrows the query — pass to `getHarness` / `getAllHarnesses`. */
+    static with(options = {}) {
+        return new HarnessPredicate(WrSpeedDialActionHarness, options)
+            .addOption('label', options.label, (harness, label) => HarnessPredicate.stringMatches(harness.getLabel(), label))
+            .addOption('disabled', options.disabled, async (harness, disabled) => (await harness.isDisabled()) === disabled);
+    }
+    /** The action's accessible name — what a screen reader reads, and what `title` shows. */
+    async getLabel() {
+        return (await this.host()).getAttribute('aria-label');
+    }
+    /** The role the action announces — `menuitem`. */
+    async getRole() {
+        return (await this.host()).getAttribute('role');
+    }
+    /** Whether the action draws an icon rather than a letter. */
+    async hasIcon() {
+        return (await this.locatorForOptional('wr-icon')()) !== null;
+    }
+    /** The icon's registered name, from `wr-icon`'s reflected `data-icon`, or `null`. */
+    async getIconName() {
+        const icon = await this.locatorForOptional('wr-icon')();
+        return icon ? icon.getAttribute('data-icon') : null;
+    }
+    /**
+     * The single glyph drawn in place of a missing icon, or `null` when there is one.
+     *
+     * A GLYPH, not a character: the component splits the label by code point, so an
+     * emoji label draws the whole emoji rather than the broken half of a surrogate pair.
+     */
+    async getInitial() {
+        if (await this.hasIcon())
+            return null;
+        return (await this.host()).text();
+    }
+    /**
+     * Whether the action refuses interaction.
+     *
+     * Every action follows the DIAL's `disabled` — there is no per-action flag — so
+     * this is really "is the dial disabled", asked at the action. Worth having anyway:
+     * it is what the DOM and the CDK consult before delivering a click.
+     */
+    async isDisabled() {
+        return (await this.host()).getProperty('disabled');
+    }
+    /** Pick this action — emitting `pick` and closing the dial. */
+    async click() {
+        if (await this.isDisabled()) {
+            throw new Error(`WrSpeedDialActionHarness.click(): "${await this.getLabel()}" is disabled. The DOM swallows the click ` +
+                'and the component checks `disabled` again before emitting, so nothing would happen.');
+        }
+        await (await this.host()).click();
+    }
+    /** Move keyboard focus to the action. */
+    async focus() {
+        return (await this.host()).focus();
+    }
+    /** Whether the action currently holds focus. */
+    async isFocused() {
+        return (await this.host()).isFocused();
+    }
+}
+
+/**
+ * @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
+ */
+const DIRECTIONS = ['up', 'down', 'left', 'right'];
+/**
+ * Test harness for `<wr-speed-dial>` — the floating trigger and the actions that fan
+ * out of it.
+ *
+ * **The actions never leave the DOM.** They are hidden with `visibility`, which is
+ * what actually takes them out of the tab order and the accessibility tree —
+ * `opacity: 0` alone would leave them focusable — and CSS is exactly what a unit
+ * test does not have. So a closed dial's buttons are queryable, clickable and
+ * readable from a spec while being unreachable in a browser. {@link getActions} and
+ * {@link pick} therefore REFUSE while the dial is closed rather than answering with
+ * elements nobody can see; open it first, which is what a user has to do too.
+ *
+ * @example
+ * ```ts
+ * const dial = await loader.getHarness(WrSpeedDialHarness);
+ *
+ * await dial.open();
+ * expect(await dial.getActionLabels()).toEqual(['Share', 'Copy link']);
+ *
+ * await dial.pick({ label: 'Share' });
+ * expect(await dial.isOpen()).toBe(false);
+ * ```
+ *
+ * @see https://ngwr.dev/guides/testing
+ */
+class WrSpeedDialHarness extends ComponentHarness {
+    static hostSelector = 'wr-speed-dial';
+    /** Build a predicate that narrows the query — pass to `getHarness` / `getAllHarnesses`. */
+    static with(options = {}) {
+        return new HarnessPredicate(WrSpeedDialHarness, options)
+            .addOption('triggerLabel', options.triggerLabel, (harness, label) => HarnessPredicate.stringMatches(harness.getTriggerLabel(), label))
+            .addOption('direction', options.direction, async (harness, direction) => (await harness.getDirection()) === direction)
+            .addOption('open', options.open, async (harness, open) => (await harness.isOpen()) === open)
+            .addOption('disabled', options.disabled, async (harness, disabled) => (await harness.isDisabled()) === disabled);
+    }
+    trigger = this.locatorFor('.wr-speed-dial__trigger');
+    menu = this.locatorFor('.wr-speed-dial__actions');
+    /** Whether the dial is fanned out, from the trigger's `aria-expanded`. */
+    async isOpen() {
+        return (await (await this.trigger()).getAttribute('aria-expanded')) === 'true';
+    }
+    /** The direction the actions travel, from the host modifier. */
+    async getDirection() {
+        const host = await this.host();
+        for (const direction of DIRECTIONS) {
+            if (await host.hasClass(`wr-speed-dial--${direction}`))
+                return direction;
+        }
+        throw new Error('WrSpeedDialHarness.getDirection(): this host carries no `wr-speed-dial--<direction>` class, which ' +
+            'every dial sets — the element matched is probably not an ngwr speed dial.');
+    }
+    /**
+     * The trigger's accessible name.
+     *
+     * The trigger is icon-only, so this is its ONLY name — there is no text to fall
+     * back on, and a dial that loses it is announced as an unnamed button.
+     */
+    async getTriggerLabel() {
+        return (await this.trigger()).getAttribute('aria-label');
+    }
+    /** The trigger icon's registered name, from `wr-icon`'s reflected `data-icon`. */
+    async getTriggerIcon() {
+        const icon = await this.locatorForOptional('.wr-speed-dial__trigger wr-icon')();
+        return icon ? icon.getAttribute('data-icon') : null;
+    }
+    /** Whether the dial refuses interaction, from the trigger's own `disabled` property. */
+    async isDisabled() {
+        return (await this.trigger()).getProperty('disabled');
+    }
+    /** Whether the host is padded for the device's safe area (`safeArea`). */
+    async hasSafeArea() {
+        return (await this.host()).hasClass('wr-speed-dial--safe-area');
+    }
+    /** The role the action list announces — `menu`. */
+    async getMenuRole() {
+        return (await this.menu()).getAttribute('role');
+    }
+    /**
+     * Whether the trigger's `aria-controls` names THIS dial's menu, and nothing else on
+     * the page.
+     *
+     * Both halves matter. The id is resolved inside the host first, so a trigger
+     * pointing at a SIBLING dial's menu — which resolves perfectly well from the
+     * document — fails here. Then it is counted across the document, because two menus
+     * answering to one id hand every reference to whichever comes first.
+     */
+    async isMenuBound() {
+        const id = await (await this.trigger()).getAttribute('aria-controls');
+        if (!id)
+            return false;
+        const own = await this.locatorForOptional(`.wr-speed-dial__actions#${id}`)();
+        if (!own)
+            return false;
+        const everywhere = await this.documentRootLocatorFactory().locatorForAll(`#${id}`)();
+        return everywhere.length === 1;
+    }
+    /**
+     * The actions, in DOM order.
+     *
+     * Throws while the dial is closed. The buttons are still in the DOM then — they
+     * have to be, for the fan-out to animate — and jsdom applies no `visibility`, so
+     * they would come back looking perfectly reachable when a real user cannot tab to
+     * one. A spec that read them closed would pass on a dial that never opens.
+     */
+    async getActions(filters = {}) {
+        await this.requireOpen('getActions');
+        return this.locatorForAll(WrSpeedDialActionHarness.with(filters))();
+    }
+    /** The accessible names of the actions, in DOM order. Throws while closed. */
+    async getActionLabels() {
+        const actions = await this.getActions();
+        return Promise.all(actions.map(action => action.getLabel()));
+    }
+    /** How many actions the dial holds — readable while closed, since it is not a reach. */
+    async getActionCount() {
+        return (await this.locatorForAll('.wr-speed-dial__action')()).length;
+    }
+    /** Open the dial. An already-open one is left alone; a disabled one throws. */
+    async open() {
+        if (await this.isOpen())
+            return;
+        await this.toggle();
+        if (!(await this.isOpen())) {
+            throw new Error('WrSpeedDialHarness.open(): the dial did not open. A disabled trigger refuses the click twice over — ' +
+                'the DOM swallows it, and the component checks `disabled` again.');
+        }
+    }
+    /** Close the dial. An already-closed one is left alone. */
+    async close() {
+        if (!(await this.isOpen()))
+            return;
+        await this.toggle();
+    }
+    /** Click the trigger once, whichever way that takes it. */
+    async toggle() {
+        return (await this.trigger()).click();
+    }
+    /**
+     * Pick the first action matching the filters — emitting `pick` and closing the dial.
+     *
+     * Opens first if it has to, the way `WrDropdownHarness.clickItem` does: a spec that
+     * says "pick Share" means the whole gesture. Throws when nothing matches, naming
+     * what the dial does offer.
+     */
+    async pick(filters) {
+        await this.open();
+        const [action] = await this.getActions(filters);
+        if (!action) {
+            const offered = await this.getActionLabels();
+            throw new Error(`WrSpeedDialHarness.pick(): no action matched ${JSON.stringify(filters)}. ` +
+                `The dial offers: ${offered.join(', ')}.`);
+        }
+        await action.click();
+    }
+    /**
+     * Press Escape — closing the dial and putting focus back on the trigger.
+     *
+     * Sent to the host, which is where the component listens. The focus return is the
+     * half worth asserting: `role="menu"` promises a way out, and the actions are
+     * ordinary tab stops, so without it a keyboard user has to walk through every
+     * action to leave.
+     */
+    async sendEscape() {
+        await (await this.host()).sendKeys(TestKey.ESCAPE);
+    }
+    /** Move keyboard focus to the trigger. */
+    async focusTrigger() {
+        return (await this.trigger()).focus();
+    }
+    /** Whether the trigger currently holds focus. */
+    async isTriggerFocused() {
+        return (await this.trigger()).isFocused();
+    }
+    async requireOpen(method) {
+        if (await this.isOpen())
+            return;
+        throw new Error(`WrSpeedDialHarness.${method}(): the dial is closed. Its actions stay in the DOM while collapsed — the ` +
+            'fan-out animates them — and only `visibility` hides them, which a unit test does not apply. Reading ' +
+            'them now would assert buttons nobody can reach. Call open() first, or getActionCount().');
+    }
+}
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { WrSpeedDialActionHarness, WrSpeedDialHarness };
+//# sourceMappingURL=ngwr-speed-dial-testing.mjs.map

package/fesm2022/ngwr-speed-dial-testing.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"ngwr-speed-dial-testing.mjs","sources":["../../../projects/lib/speed-dial/testing/wr-speed-dial-action-harness.ts","../../../projects/lib/speed-dial/testing/wr-speed-dial-harness.ts","../../../projects/lib/speed-dial/testing/ngwr-speed-dial-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 } from '@angular/cdk/testing';\n\nimport type { WrSpeedDialActionHarnessFilters } from './interfaces';\n\n/**\n * Test harness for one action inside a {@link WrSpeedDialHarness}.\n *\n * The label is read from `aria-label` rather than from the button's text, and that\n * is the whole point of the control: an action renders an ICON, or — with no icon —\n * the first glyph of its label. Its visible text is therefore `\"S\"` for \"Share\", or\n * nothing at all. {@link getInitial} answers what is drawn; {@link getLabel} answers\n * what it is.\n *\n * @see https://ngwr.dev/guides/testing\n */\nexport class WrSpeedDialActionHarness extends ComponentHarness {\n  /** The action button. `role=\"menuitem\"` sits on this element too. */\n  static hostSelector = '.wr-speed-dial__action';\n\n  /** Build a predicate that narrows the query — pass to `getHarness` / `getAllHarnesses`. */\n  static with(options: WrSpeedDialActionHarnessFilters = {}): HarnessPredicate<WrSpeedDialActionHarness> {\n    return new HarnessPredicate(WrSpeedDialActionHarness, options)\n      .addOption('label', options.label, (harness, label) => HarnessPredicate.stringMatches(harness.getLabel(), label))\n      .addOption('disabled', options.disabled, async (harness, disabled) => (await harness.isDisabled()) === disabled);\n  }\n\n  /** The action's accessible name — what a screen reader reads, and what `title` shows. */\n  async getLabel(): Promise<string | null> {\n    return (await this.host()).getAttribute('aria-label');\n  }\n\n  /** The role the action announces — `menuitem`. */\n  async getRole(): Promise<string | null> {\n    return (await this.host()).getAttribute('role');\n  }\n\n  /** Whether the action draws an icon rather than a letter. */\n  async hasIcon(): Promise<boolean> {\n    return (await this.locatorForOptional('wr-icon')()) !== null;\n  }\n\n  /** The icon's registered name, from `wr-icon`'s reflected `data-icon`, or `null`. */\n  async getIconName(): Promise<string | null> {\n    const icon = await this.locatorForOptional('wr-icon')();\n    return icon ? icon.getAttribute('data-icon') : null;\n  }\n\n  /**\n   * The single glyph drawn in place of a missing icon, or `null` when there is one.\n   *\n   * A GLYPH, not a character: the component splits the label by code point, so an\n   * emoji label draws the whole emoji rather than the broken half of a surrogate pair.\n   */\n  async getInitial(): Promise<string | null> {\n    if (await this.hasIcon()) return null;\n    return (await this.host()).text();\n  }\n\n  /**\n   * Whether the action refuses interaction.\n   *\n   * Every action follows the DIAL's `disabled` — there is no per-action flag — so\n   * this is really \"is the dial disabled\", asked at the action. Worth having anyway:\n   * it is what the DOM and the CDK consult before delivering a click.\n   */\n  async isDisabled(): Promise<boolean> {\n    return (await this.host()).getProperty<boolean>('disabled');\n  }\n\n  /** Pick this action — emitting `pick` and closing the dial. */\n  async click(): Promise<void> {\n    if (await this.isDisabled()) {\n      throw new Error(\n        `WrSpeedDialActionHarness.click(): \"${await this.getLabel()}\" is disabled. The DOM swallows the click ` +\n          'and the component checks `disabled` again before emitting, so nothing would happen.'\n      );\n    }\n    await (await this.host()).click();\n  }\n\n  /** Move keyboard focus to the action. */\n  async focus(): Promise<void> {\n    return (await this.host()).focus();\n  }\n\n  /** Whether the action currently holds focus. */\n  async isFocused(): Promise<boolean> {\n    return (await this.host()).isFocused();\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, TestKey } from '@angular/cdk/testing';\n\nimport type { WrSpeedDialDirection } from 'ngwr/speed-dial';\n\nimport type { WrSpeedDialActionHarnessFilters, WrSpeedDialHarnessFilters } from './interfaces';\nimport { WrSpeedDialActionHarness } from './wr-speed-dial-action-harness';\n\nconst DIRECTIONS: readonly WrSpeedDialDirection[] = ['up', 'down', 'left', 'right'];\n\n/**\n * Test harness for `<wr-speed-dial>` — the floating trigger and the actions that fan\n * out of it.\n *\n * **The actions never leave the DOM.** They are hidden with `visibility`, which is\n * what actually takes them out of the tab order and the accessibility tree —\n * `opacity: 0` alone would leave them focusable — and CSS is exactly what a unit\n * test does not have. So a closed dial's buttons are queryable, clickable and\n * readable from a spec while being unreachable in a browser. {@link getActions} and\n * {@link pick} therefore REFUSE while the dial is closed rather than answering with\n * elements nobody can see; open it first, which is what a user has to do too.\n *\n * @example\n * ```ts\n * const dial = await loader.getHarness(WrSpeedDialHarness);\n *\n * await dial.open();\n * expect(await dial.getActionLabels()).toEqual(['Share', 'Copy link']);\n *\n * await dial.pick({ label: 'Share' });\n * expect(await dial.isOpen()).toBe(false);\n * ```\n *\n * @see https://ngwr.dev/guides/testing\n */\nexport class WrSpeedDialHarness extends ComponentHarness {\n  static hostSelector = 'wr-speed-dial';\n\n  /** Build a predicate that narrows the query — pass to `getHarness` / `getAllHarnesses`. */\n  static with(options: WrSpeedDialHarnessFilters = {}): HarnessPredicate<WrSpeedDialHarness> {\n    return new HarnessPredicate(WrSpeedDialHarness, options)\n      .addOption('triggerLabel', options.triggerLabel, (harness, label) =>\n        HarnessPredicate.stringMatches(harness.getTriggerLabel(), label)\n      )\n      .addOption(\n        'direction',\n        options.direction,\n        async (harness, direction) => (await harness.getDirection()) === direction\n      )\n      .addOption('open', options.open, async (harness, open) => (await harness.isOpen()) === open)\n      .addOption('disabled', options.disabled, async (harness, disabled) => (await harness.isDisabled()) === disabled);\n  }\n\n  private readonly trigger = this.locatorFor('.wr-speed-dial__trigger');\n  private readonly menu = this.locatorFor('.wr-speed-dial__actions');\n\n  /** Whether the dial is fanned out, from the trigger's `aria-expanded`. */\n  async isOpen(): Promise<boolean> {\n    return (await (await this.trigger()).getAttribute('aria-expanded')) === 'true';\n  }\n\n  /** The direction the actions travel, from the host modifier. */\n  async getDirection(): Promise<WrSpeedDialDirection> {\n    const host = await this.host();\n    for (const direction of DIRECTIONS) {\n      if (await host.hasClass(`wr-speed-dial--${direction}`)) return direction;\n    }\n    throw new Error(\n      'WrSpeedDialHarness.getDirection(): this host carries no `wr-speed-dial--<direction>` class, which ' +\n        'every dial sets — the element matched is probably not an ngwr speed dial.'\n    );\n  }\n\n  /**\n   * The trigger's accessible name.\n   *\n   * The trigger is icon-only, so this is its ONLY name — there is no text to fall\n   * back on, and a dial that loses it is announced as an unnamed button.\n   */\n  async getTriggerLabel(): Promise<string | null> {\n    return (await this.trigger()).getAttribute('aria-label');\n  }\n\n  /** The trigger icon's registered name, from `wr-icon`'s reflected `data-icon`. */\n  async getTriggerIcon(): Promise<string | null> {\n    const icon = await this.locatorForOptional('.wr-speed-dial__trigger wr-icon')();\n    return icon ? icon.getAttribute('data-icon') : null;\n  }\n\n  /** Whether the dial refuses interaction, from the trigger's own `disabled` property. */\n  async isDisabled(): Promise<boolean> {\n    return (await this.trigger()).getProperty<boolean>('disabled');\n  }\n\n  /** Whether the host is padded for the device's safe area (`safeArea`). */\n  async hasSafeArea(): Promise<boolean> {\n    return (await this.host()).hasClass('wr-speed-dial--safe-area');\n  }\n\n  /** The role the action list announces — `menu`. */\n  async getMenuRole(): Promise<string | null> {\n    return (await this.menu()).getAttribute('role');\n  }\n\n  /**\n   * Whether the trigger's `aria-controls` names THIS dial's menu, and nothing else on\n   * the page.\n   *\n   * Both halves matter. The id is resolved inside the host first, so a trigger\n   * pointing at a SIBLING dial's menu — which resolves perfectly well from the\n   * document — fails here. Then it is counted across the document, because two menus\n   * answering to one id hand every reference to whichever comes first.\n   */\n  async isMenuBound(): Promise<boolean> {\n    const id = await (await this.trigger()).getAttribute('aria-controls');\n    if (!id) return false;\n\n    const own = await this.locatorForOptional(`.wr-speed-dial__actions#${id}`)();\n    if (!own) return false;\n\n    const everywhere = await this.documentRootLocatorFactory().locatorForAll(`#${id}`)();\n    return everywhere.length === 1;\n  }\n\n  /**\n   * The actions, in DOM order.\n   *\n   * Throws while the dial is closed. The buttons are still in the DOM then — they\n   * have to be, for the fan-out to animate — and jsdom applies no `visibility`, so\n   * they would come back looking perfectly reachable when a real user cannot tab to\n   * one. A spec that read them closed would pass on a dial that never opens.\n   */\n  async getActions(filters: WrSpeedDialActionHarnessFilters = {}): Promise<WrSpeedDialActionHarness[]> {\n    await this.requireOpen('getActions');\n    return this.locatorForAll(WrSpeedDialActionHarness.with(filters))();\n  }\n\n  /** The accessible names of the actions, in DOM order. Throws while closed. */\n  async getActionLabels(): Promise<(string | null)[]> {\n    const actions = await this.getActions();\n    return Promise.all(actions.map(action => action.getLabel()));\n  }\n\n  /** How many actions the dial holds — readable while closed, since it is not a reach. */\n  async getActionCount(): Promise<number> {\n    return (await this.locatorForAll('.wr-speed-dial__action')()).length;\n  }\n\n  /** Open the dial. An already-open one is left alone; a disabled one throws. */\n  async open(): Promise<void> {\n    if (await this.isOpen()) return;\n    await this.toggle();\n\n    if (!(await this.isOpen())) {\n      throw new Error(\n        'WrSpeedDialHarness.open(): the dial did not open. A disabled trigger refuses the click twice over — ' +\n          'the DOM swallows it, and the component checks `disabled` again.'\n      );\n    }\n  }\n\n  /** Close the dial. An already-closed one is left alone. */\n  async close(): Promise<void> {\n    if (!(await this.isOpen())) return;\n    await this.toggle();\n  }\n\n  /** Click the trigger once, whichever way that takes it. */\n  async toggle(): Promise<void> {\n    return (await this.trigger()).click();\n  }\n\n  /**\n   * Pick the first action matching the filters — emitting `pick` and closing the dial.\n   *\n   * Opens first if it has to, the way `WrDropdownHarness.clickItem` does: a spec that\n   * says \"pick Share\" means the whole gesture. Throws when nothing matches, naming\n   * what the dial does offer.\n   */\n  async pick(filters: WrSpeedDialActionHarnessFilters): Promise<void> {\n    await this.open();\n\n    const [action] = await this.getActions(filters);\n    if (!action) {\n      const offered = await this.getActionLabels();\n      throw new Error(\n        `WrSpeedDialHarness.pick(): no action matched ${JSON.stringify(filters)}. ` +\n          `The dial offers: ${offered.join(', ')}.`\n      );\n    }\n    await action.click();\n  }\n\n  /**\n   * Press Escape — closing the dial and putting focus back on the trigger.\n   *\n   * Sent to the host, which is where the component listens. The focus return is the\n   * half worth asserting: `role=\"menu\"` promises a way out, and the actions are\n   * ordinary tab stops, so without it a keyboard user has to walk through every\n   * action to leave.\n   */\n  async sendEscape(): Promise<void> {\n    await (await this.host()).sendKeys(TestKey.ESCAPE);\n  }\n\n  /** Move keyboard focus to the trigger. */\n  async focusTrigger(): Promise<void> {\n    return (await this.trigger()).focus();\n  }\n\n  /** Whether the trigger currently holds focus. */\n  async isTriggerFocused(): Promise<boolean> {\n    return (await this.trigger()).isFocused();\n  }\n\n  private async requireOpen(method: string): Promise<void> {\n    if (await this.isOpen()) return;\n    throw new Error(\n      `WrSpeedDialHarness.${method}(): the dial is closed. Its actions stay in the DOM while collapsed — the ` +\n        'fan-out animates them — and only `visibility` hides them, which a unit test does not apply. Reading ' +\n        'them now would assert buttons nobody can reach. Call open() first, or getActionCount().'\n    );\n  }\n}\n","/**\n * Generated bundle index. Do not edit.\n */\n\nexport * from './public-api';\n"],"names":[],"mappings":"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"}

package/fesm2022/ngwr-splash-cursor-testing.mjs

@@ -0,0 +1,89 @@
+import { ComponentHarness, HarnessPredicate } from '@angular/cdk/testing';
+
+/**
+ * @license
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://github.com/thekhegay/ngwr/blob/main/LICENSE
+ */
+/**
+ * Test harness for `<wr-splash-cursor>` — a WebGL fluid that splashes dye under the
+ * pointer.
+ *
+ * **This is a deliberately small surface, and the reason is the component.** The
+ * simulation is GL programs and framebuffers driven by `window` pointer listeners; the
+ * layout is `position: fixed`, `inset: 0`, `z-index: 50` and a `100dvh` canvas, all of
+ * it in the stylesheet. A unit test gets no WebGL context — the simulation is never
+ * constructed — and loads no stylesheet, so asking `getCssValue('position')` would
+ * answer `static` about a component whose whole layout contract is `fixed`. Three
+ * questions survive that, and they are the three below.
+ *
+ * There is no `isSimulating()`, `getSplatCount()` or `splat()`: the simulation returns
+ * `null` the moment the context is refused, so every one of those would report on
+ * something that was never built. No `moveMouse()` either — the listeners live on
+ * `window` and are only attached once a context exists, so a dispatched move reaches
+ * nothing. And no `isReducedMotion()` or `hasWebGL()`: the component renders
+ * byte-identical DOM whether it is running, standing down for reduced motion, or on a
+ * machine with no WebGL at all, so any answer would be the same for a working component
+ * and a broken one.
+ *
+ * @example
+ * ```ts
+ * const splash = await loader.getHarness(WrSplashCursorHarness);
+ *
+ * expect(await splash.isFullscreen()).toBe(true);
+ * expect(await splash.isDecorative()).toBe(true);
+ * ```
+ *
+ * @see https://ngwr.dev/guides/testing
+ */
+class WrSplashCursorHarness extends ComponentHarness {
+    static hostSelector = 'wr-splash-cursor';
+    /** Build a predicate that narrows the query — pass to `getHarness` / `getAllHarnesses`. */
+    static with(options = {}) {
+        return new HarnessPredicate(WrSplashCursorHarness, options).addOption('fullscreen', options.fullscreen, async (harness, fullscreen) => (await harness.isFullscreen()) === fullscreen);
+    }
+    /**
+     * Whether the effect covers the whole viewport, rather than filling the nearest
+     * positioned ancestor.
+     *
+     * The component's one behavioural switch: fullscreen is a fixed, click-through
+     * overlay above the page, contained is an absolutely positioned box whose walls the
+     * dye collides with. Note what is being read — there is no `--fullscreen` class, only
+     * a `--contained` one written from a NEGATED binding, so this method answers the
+     * absence of a class. That inversion is exactly the kind that gets flipped in a
+     * refactor and looks fine on a page where the effect is full-viewport anyway, which
+     * is the whole reason the method exists.
+     */
+    async isFullscreen() {
+        return !(await (await this.host()).hasClass('wr-splash-cursor--contained'));
+    }
+    /**
+     * Whether the effect is hidden from assistive tech.
+     *
+     * It has no text and nothing to say, and at full size it sits in front of the entire
+     * page — so losing this puts a nameless graphic over everything a screen reader is
+     * trying to get through.
+     */
+    async isDecorative() {
+        return (await (await this.locatorFor('.wr-splash-cursor__canvas')()).getAttribute('aria-hidden')) === 'true';
+    }
+    /**
+     * Whether the drawing surface is in the markup.
+     *
+     * It is there in all three states where nothing is ever drawn on it — prerendered on
+     * the server, WebGL refused, or reduced motion — because the documented contract is
+     * that the component renders nothing VISIBLE and stops, never that it renders no
+     * element and never that it throws on a null context.
+     */
+    async hasCanvas() {
+        return (await this.locatorForOptional('.wr-splash-cursor__canvas')()) !== null;
+    }
+}
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { WrSplashCursorHarness };
+//# sourceMappingURL=ngwr-splash-cursor-testing.mjs.map

package/fesm2022/ngwr-splash-cursor-testing.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"ngwr-splash-cursor-testing.mjs","sources":["../../../projects/lib/splash-cursor/testing/wr-splash-cursor-harness.ts","../../../projects/lib/splash-cursor/testing/ngwr-splash-cursor-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 } from '@angular/cdk/testing';\n\nimport type { WrSplashCursorHarnessFilters } from './interfaces';\n\n/**\n * Test harness for `<wr-splash-cursor>` — a WebGL fluid that splashes dye under the\n * pointer.\n *\n * **This is a deliberately small surface, and the reason is the component.** The\n * simulation is GL programs and framebuffers driven by `window` pointer listeners; the\n * layout is `position: fixed`, `inset: 0`, `z-index: 50` and a `100dvh` canvas, all of\n * it in the stylesheet. A unit test gets no WebGL context — the simulation is never\n * constructed — and loads no stylesheet, so asking `getCssValue('position')` would\n * answer `static` about a component whose whole layout contract is `fixed`. Three\n * questions survive that, and they are the three below.\n *\n * There is no `isSimulating()`, `getSplatCount()` or `splat()`: the simulation returns\n * `null` the moment the context is refused, so every one of those would report on\n * something that was never built. No `moveMouse()` either — the listeners live on\n * `window` and are only attached once a context exists, so a dispatched move reaches\n * nothing. And no `isReducedMotion()` or `hasWebGL()`: the component renders\n * byte-identical DOM whether it is running, standing down for reduced motion, or on a\n * machine with no WebGL at all, so any answer would be the same for a working component\n * and a broken one.\n *\n * @example\n * ```ts\n * const splash = await loader.getHarness(WrSplashCursorHarness);\n *\n * expect(await splash.isFullscreen()).toBe(true);\n * expect(await splash.isDecorative()).toBe(true);\n * ```\n *\n * @see https://ngwr.dev/guides/testing\n */\nexport class WrSplashCursorHarness extends ComponentHarness {\n  static hostSelector = 'wr-splash-cursor';\n\n  /** Build a predicate that narrows the query — pass to `getHarness` / `getAllHarnesses`. */\n  static with(options: WrSplashCursorHarnessFilters = {}): HarnessPredicate<WrSplashCursorHarness> {\n    return new HarnessPredicate(WrSplashCursorHarness, options).addOption(\n      'fullscreen',\n      options.fullscreen,\n      async (harness, fullscreen) => (await harness.isFullscreen()) === fullscreen\n    );\n  }\n\n  /**\n   * Whether the effect covers the whole viewport, rather than filling the nearest\n   * positioned ancestor.\n   *\n   * The component's one behavioural switch: fullscreen is a fixed, click-through\n   * overlay above the page, contained is an absolutely positioned box whose walls the\n   * dye collides with. Note what is being read — there is no `--fullscreen` class, only\n   * a `--contained` one written from a NEGATED binding, so this method answers the\n   * absence of a class. That inversion is exactly the kind that gets flipped in a\n   * refactor and looks fine on a page where the effect is full-viewport anyway, which\n   * is the whole reason the method exists.\n   */\n  async isFullscreen(): Promise<boolean> {\n    return !(await (await this.host()).hasClass('wr-splash-cursor--contained'));\n  }\n\n  /**\n   * Whether the effect is hidden from assistive tech.\n   *\n   * It has no text and nothing to say, and at full size it sits in front of the entire\n   * page — so losing this puts a nameless graphic over everything a screen reader is\n   * trying to get through.\n   */\n  async isDecorative(): Promise<boolean> {\n    return (await (await this.locatorFor('.wr-splash-cursor__canvas')()).getAttribute('aria-hidden')) === 'true';\n  }\n\n  /**\n   * Whether the drawing surface is in the markup.\n   *\n   * It is there in all three states where nothing is ever drawn on it — prerendered on\n   * the server, WebGL refused, or reduced motion — because the documented contract is\n   * that the component renders nothing VISIBLE and stops, never that it renders no\n   * element and never that it throws on a null context.\n   */\n  async hasCanvas(): Promise<boolean> {\n    return (await this.locatorForOptional('.wr-splash-cursor__canvas')()) !== null;\n  }\n}\n","/**\n * Generated bundle index. Do not edit.\n */\n\nexport * from './public-api';\n"],"names":[],"mappings":";;AAAA;;;;;AAKG;AAMH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA8BG;AACG,MAAO,qBAAsB,SAAQ,gBAAgB,CAAA;AACzD,IAAA,OAAO,YAAY,GAAG,kBAAkB;;AAGxC,IAAA,OAAO,IAAI,CAAC,OAAA,GAAwC,EAAE,EAAA;AACpD,QAAA,OAAO,IAAI,gBAAgB,CAAC,qBAAqB,EAAE,OAAO,CAAC,CAAC,SAAS,CACnE,YAAY,EACZ,OAAO,CAAC,UAAU,EAClB,OAAO,OAAO,EAAE,UAAU,KAAK,CAAC,MAAM,OAAO,CAAC,YAAY,EAAE,MAAM,UAAU,CAC7E;IACH;AAEA;;;;;;;;;;;AAWG;AACH,IAAA,MAAM,YAAY,GAAA;AAChB,QAAA,OAAO,EAAE,MAAM,CAAC,MAAM,IAAI,CAAC,IAAI,EAAE,EAAE,QAAQ,CAAC,6BAA6B,CAAC,CAAC;IAC7E;AAEA;;;;;;AAMG;AACH,IAAA,MAAM,YAAY,GAAA;QAChB,OAAO,CAAC,MAAM,CAAC,MAAM,IAAI,CAAC,UAAU,CAAC,2BAA2B,CAAC,EAAE,EAAE,YAAY,CAAC,aAAa,CAAC,MAAM,MAAM;IAC9G;AAEA;;;;;;;AAOG;AACH,IAAA,MAAM,SAAS,GAAA;AACb,QAAA,OAAO,CAAC,MAAM,IAAI,CAAC,kBAAkB,CAAC,2BAA2B,CAAC,EAAE,MAAM,IAAI;IAChF;;;AC3FF;;AAEG;;;;"}

package/fesm2022/ngwr-split-text-testing.mjs

@@ -0,0 +1,224 @@
+import { ComponentHarness, HarnessPredicate } from '@angular/cdk/testing';
+
+/**
+ * @license
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://github.com/thekhegay/ngwr/blob/main/LICENSE
+ */
+/** The animated pieces — one per character or per word, whitespace excluded. */
+const PIECE = '.wr-split-text__piece';
+/** The whitespace runs between them, rendered but never staggered. */
+const SPACE = '.wr-split-text__space';
+/** The readable copy of the string, carried once and hidden with CSS. */
+const SR_ONLY = '.wr-split-text__sr-only';
+/**
+ * An inline `opacity` declaration — written on every piece the tween touches.
+ *
+ * `motionToStyle` always produces an opacity, whether or not `from` declared one, and
+ * the same property is re-committed when the tween finishes. Matched off the `style`
+ * ATTRIBUTE, never through `getCssValue`: a computed style answers `1` for a piece
+ * nothing was ever written to, which is the exact case this has to distinguish.
+ */
+const INLINE_OPACITY = /(?:^|;)\s*opacity\s*:/;
+/** The host's own alignment declaration, as the host binding wrote it. */
+const INLINE_TEXT_ALIGN = /(?:^|;)\s*text-align\s*:\s*([^;]+)/;
+/** Exactly what the element holds — untrimmed, unlike `TestElement.text()`. */
+async function rawText(element) {
+    return (await element.getProperty('textContent')) ?? '';
+}
+/**
+ * Test harness for `<wr-split-text>`.
+ *
+ * **The tween is unreadable from a test, and the absent methods are absent for that
+ * reason.** Each piece is animated from a `from` motion state to a `to` one through the
+ * Web Animations API, started by an `IntersectionObserver`. A unit test has no layout,
+ * no compositor and no WAAPI, so there is no `getOpacity()` and no `getTransform()`:
+ * both would report the frozen staged value in jsdom and a value the compositor is not
+ * painting in a browser. There is no `getFromState()` / `getToState()` either — those
+ * objects only reach the DOM as staged inline styles, on the one path that throws here,
+ * so reporting them would mean re-deriving an input from a string the component may
+ * never have written. No `isAnimating()`, no `whenAnimationComplete()`: nothing in the
+ * document says a tween is running, and completion is the `animationComplete` OUTPUT,
+ * which the host binds. No `enterViewport()` / `trigger()`, because an observer is not
+ * reachable from a `TestElement` — and observation here is additionally gated behind
+ * `document.fonts.ready`, which jsdom does not have, so a `waitForFonts()` would resolve
+ * instantly and prove nothing about the gating it claimed to test. Nothing measures
+ * either: `getLineCount()` / `didItWrap()` would need layout (and `lines` is not a split
+ * this port supports), and the `overflow: hidden` mask with its descender compensation
+ * is a stylesheet, which a test runs none of.
+ *
+ * **What is real is the split, the accessible layer and the alignment.** The string is
+ * carried once in a visually-hidden span and every drawn piece is `aria-hidden`, so
+ * {@link getAccessibleText} is what is heard while {@link getPieces} is what is drawn —
+ * two questions, and a spec asserting only the second would pass on a component that
+ * spells the text out letter by letter. {@link getRenderedText} closes the loop by
+ * putting the pieces and the spaces back together: the split has to be lossless, and
+ * that comparison is what catches a dropped space or a halved surrogate pair. Whether
+ * the hidden copy is genuinely off-screen is CSS, so nothing here claims to know.
+ *
+ * **{@link getTextAlign} is the one input this component reflects**, written straight
+ * onto the host as an inline style — an honest read with no layout involved, unlike
+ * anything else about how the text is arranged. And {@link hasStagedMotion} is the one
+ * fact about the tween worth pinning: that the pieces were taken over, not that anything
+ * is moving.
+ *
+ * Driving the reveal is the spec's job — jsdom supplies neither half of it, and the font
+ * gate defers observation by a microtask:
+ *
+ * ```ts
+ * // Before TestBed.createComponent — keep the callbacks so the spec can fire them.
+ * vi.stubGlobal('IntersectionObserver', StubObserver);
+ * // Otherwise `el.animate(...)` throws mid-stagger and leaves the DOM half-staged.
+ * Reflect.set(Element.prototype, 'animate', () => ({ cancel: () => undefined, onfinish: null }));
+ * // …and always settle before tearing down: observation is queued off a promise, and
+ * // landing after destroy() registers a teardown on a dead DestroyRef (NG0911).
+ * await fixture.whenStable();
+ * ```
+ *
+ * @example
+ * ```ts
+ * const hero = await loader.getHarness(WrSplitTextHarness.with({ textAlign: 'center' }));
+ *
+ * expect(await hero.getPieces()).toEqual(['H', 'e', 'l', 'l', 'o']);
+ * expect(await hero.getRenderedText()).toBe(await hero.getAccessibleText());
+ * expect(await hero.isTextHidden()).toBe(true);
+ * ```
+ *
+ * @see https://ngwr.dev/guides/testing
+ */
+class WrSplitTextHarness extends ComponentHarness {
+    static hostSelector = 'wr-split-text';
+    /** Build a predicate that narrows the query — pass to `getHarness` / `getAllHarnesses`. */
+    static with(options = {}) {
+        return new HarnessPredicate(WrSplitTextHarness, options)
+            .addOption('text', options.text, (harness, text) => HarnessPredicate.stringMatches(harness.getAccessibleText(), text))
+            .addOption('pieceCount', options.pieceCount, async (harness, count) => (await harness.getPieceCount()) === count)
+            .addOption('textAlign', options.textAlign, async (harness, align) => (await harness.getTextAlign()) === align);
+    }
+    pieces = this.locatorForAll(PIECE);
+    spaces = this.locatorForAll(SPACE);
+    /**
+     * The whole string, as the one readable copy holds it.
+     *
+     * All a screen reader gets, since every drawn piece is out of the tree — lose this
+     * span and the component becomes a nameless pile of hidden spans, with no other
+     * symptom anywhere in the DOM.
+     *
+     * Untrimmed, deliberately: leading and trailing whitespace is content the split has to
+     * carry, and {@link getRenderedText} is meant to compare equal to this. A trimmed read
+     * on one side of that comparison would forgive the case it exists to catch.
+     */
+    async getAccessibleText() {
+        return rawText(await this.locatorFor(SR_ONLY)());
+    }
+    /**
+     * The animated pieces, in document order — one per character, or one per word.
+     *
+     * The split the stagger runs over: `['H', 'i']` at the default `splitType="chars"`
+     * against `['Hi', 'there']` for `"words"`, and `['a', '🚀']` for a surrogate pair the
+     * code-point split kept whole instead of halving into two broken glyphs. Whitespace is
+     * not here — it is drawn separately and never staggered, so see {@link getSpaceCount}.
+     */
+    async getPieces() {
+        return Promise.all((await this.pieces()).map(rawText));
+    }
+    /**
+     * How many pieces the stagger runs over.
+     *
+     * `delay` × this is the real length of the effect, and the only number about the
+     * animation present in the document.
+     */
+    async getPieceCount() {
+        return (await this.pieces()).length;
+    }
+    /**
+     * How many whitespace runs sit between the pieces.
+     *
+     * Its own method because whitespace is deliberately excluded from the animated set:
+     * reclassifying spaces as pieces would leave {@link getRenderedText} identical, change
+     * the stagger count and the rhythm of the reveal, and show up nowhere else.
+     */
+    async getSpaceCount() {
+        return (await this.spaces()).length;
+    }
+    /**
+     * Everything the component drew, pieces and spaces together, in document order.
+     *
+     * The assertion this exists for is `getRenderedText() === getAccessibleText()`: the
+     * split must be lossless. A swallowed space, a re-split that dropped a character or a
+     * surrogate pair cut in half all leave the accessible copy intact and are invisible
+     * from anywhere else.
+     */
+    async getRenderedText() {
+        const parts = await this.locatorForAll(`${PIECE}, ${SPACE}`)();
+        return (await Promise.all(parts.map(rawText))).join('');
+    }
+    /**
+     * Whether every drawn piece is out of the accessibility tree.
+     *
+     * The defect this component exists to avoid is a screen reader reading
+     * `H. e. l. l. o.`, and one piece missing `aria-hidden` brings it back — so this is
+     * all-or-nothing, across both element kinds: a readable space is heard as a pause in
+     * the middle of a word.
+     *
+     * Throws when the split produced nothing at all. An empty run of elements satisfies
+     * "every one of them is hidden" without anything being hidden, which is also what a
+     * component that stopped rendering its pieces would report.
+     */
+    async isTextHidden() {
+        const parts = await this.locatorForAll(`${PIECE}, ${SPACE}`)();
+        if (parts.length === 0) {
+            throw new Error('WrSplitTextHarness.isTextHidden(): this <wr-split-text> drew no pieces, so there is nothing to be ' +
+                'hidden from a screen reader and "true" would be a vacuous answer — the same one a component that ' +
+                'stopped splitting its text would give. Check `text` is set, or ask getPieceCount().');
+        }
+        const hidden = await Promise.all(parts.map(part => part.getAttribute('aria-hidden')));
+        return hidden.every(value => value === 'true');
+    }
+    /**
+     * The alignment the host was given, as the component wrote it.
+     *
+     * Off the inline `style` attribute rather than through `getCssValue`, and the
+     * difference is not pedantry: computed style answers for an element nobody wrote to —
+     * with the inherited or user-agent value — so a host that stopped reflecting the input
+     * altogether would keep reporting a plausible `left` or `start`. The attribute is the
+     * fact being asserted.
+     *
+     * `null` means the host carries no alignment at all, which the component never does:
+     * the binding is unconditional and the input defaults to `'center'`.
+     */
+    async getTextAlign() {
+        const match = INLINE_TEXT_ALIGN.exec((await (await this.host()).getAttribute('style')) ?? '');
+        return match ? match[1].trim() : null;
+    }
+    /**
+     * Whether the reveal has taken the pieces over — NOT whether anything is animating.
+     *
+     * Read off the inline `style` attribute the component writes itself, so it stays
+     * `true` once the reveal has finished: the tween commits its end state back to the
+     * same inline properties on `onfinish`. Anyone reaching for `isAnimating()` wants a
+     * frame, and there are no frames here.
+     *
+     * `false` is the answer worth asserting. It means no piece was written to, which is
+     * both the pre-trigger state and the reduced-motion promise — the component returns
+     * before staging anything, so a reader who asked for less motion cannot be left with
+     * text parked at `from.opacity: 0` by a tween that never runs.
+     *
+     * ANY piece counts, not all of them, and that is the conservative reading rather than
+     * a loose one: a stagger that stages the first piece and then throws leaves exactly
+     * one glyph invisible, which is a real failure — and one jsdom reproduces every time
+     * `Element.prototype.animate` is missing.
+     */
+    async hasStagedMotion() {
+        const styles = await Promise.all((await this.pieces()).map(piece => piece.getAttribute('style')));
+        return styles.some(style => INLINE_OPACITY.test(style ?? ''));
+    }
+}
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { WrSplitTextHarness };
+//# sourceMappingURL=ngwr-split-text-testing.mjs.map