ngwr 11.1.0 → 11.2.0

package/fesm2022/ngwr-typewriter-testing.mjs

@@ -0,0 +1,228 @@
+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 one text node the state machine writes into — the whole of its observable output. */
+const CONTENT = '.wr-typewriter__content';
+/** The caret. Not hidden when it is unwanted — removed from the document entirely. */
+const CURSOR = '.wr-typewriter__cursor';
+/**
+ * A `color:` declaration in an inline `style` attribute.
+ *
+ * The run has to start at the beginning or just after a `;` so that `background-color`
+ * — or any other `-color` longhand a consumer's own style attribute might carry — cannot
+ * be mistaken for it.
+ */
+const INLINE_COLOR = /(?:^|;)\s*color\s*:\s*([^;]+)/;
+/** Exactly what the element holds — untrimmed, unlike `TestElement.text()`. */
+async function rawText(element) {
+    return (await element.getProperty('textContent')) ?? '';
+}
+/**
+ * Test harness for `<wr-typewriter>`.
+ *
+ * **The typed string is the entire component, and it is a moving target.**
+ * {@link getText} reads the one text node the machine writes into, which mid-run holds
+ * a FRAGMENT — `'Hell'` on the way to `'Hello'` — and between sentences holds whatever
+ * is left of the previous one. That is not a limitation to work around; it is what the
+ * component renders, and pinning it tick by tick is what proves the machine types one
+ * character at a time, deletes one at a time, pauses, cycles, and stops when told not to
+ * loop. Install fake timers for `setTimeout` / `clearTimeout` only and advance the clock
+ * yourself before every read — awaiting a harness method flushes microtasks, never
+ * timers, so an unadvanced read answers with the previous frame.
+ *
+ * **What is typed is also what is announced, and no second copy exists.** There is
+ * deliberately no `getAccessibleText()` here: the component renders one plain text node
+ * and nothing else, so a screen reader landing mid-word hears the fragment. (Its sibling
+ * `wr-rotating-text` carries a visually-hidden copy of the whole phrase; this one does
+ * not, and inventing a method that implied otherwise would report an accessible layer
+ * that is not there.) The single a11y decision the component does make is the caret, and
+ * {@link isCursorDecorative} is how a spec holds it: without `aria-hidden` every phrase
+ * is announced as `Hello pipe`, and nothing else in the DOM would change.
+ *
+ * **The methods that are missing are missing on purpose.** There is no `isTyping()` or
+ * `getPhase()` — the phase is a private signal that never reaches the document, and its
+ * only proxy, the caret vanishing, exists solely when `hideCursorWhileTyping` is set, so
+ * the method would report "not typing" for the DEFAULT configuration while the machine
+ * types. No `isComplete()` / `isFinished()`: a machine stopped on its last sentence and
+ * one pausing between sentences render the identical string and the identical caret, so
+ * assert the `sentenceComplete` output instead. No `isCursorBlinking()` /
+ * `getCursorOpacity()`: the blink is a `@keyframes` rule from a stylesheet a unit test
+ * never loads, and a mid-animation opacity is a number that means nothing.
+ * No `isVisible()` / `waitForVisible()`: `startOnVisible` hangs off an
+ * `IntersectionObserver` jsdom does not implement, so any answer would be the spec's own
+ * stub echoing back. And no `getTypingSpeed()` / `getDeletingSpeed()` /
+ * `getPauseDuration()` / `getInitialDelay()`: none of them is ever written to the DOM, so
+ * reading them would mean reading the component instance rather than the rendered
+ * control. They are observable exactly once — as the cadence of {@link getText}.
+ *
+ * What DOES survive a test with no layout, besides the string: the caret's presence,
+ * glyph and `aria-hidden`, and the two values the host writes inline —
+ * {@link getColor} and {@link getCursorBlinkDuration}.
+ *
+ * ```ts
+ * // jsdom implements no IntersectionObserver, so `[startOnVisible]` throws on boot.
+ * vi.stubGlobal('IntersectionObserver', StubObserver);
+ * // Fake these two and no more: faking the microtask queue deadlocks `whenStable`,
+ * // which is where the machine boots and where every harness read stabilizes.
+ * vi.useFakeTimers({ toFake: ['setTimeout', 'clearTimeout'] });
+ * ```
+ *
+ * @example
+ * ```ts
+ * const typewriter = await loader.getHarness(WrTypewriterHarness);
+ *
+ * vi.advanceTimersByTime(0);            // the first tick is scheduled at `initialDelay`
+ * expect(await typewriter.getText()).toBe('H');
+ *
+ * vi.advanceTimersByTime(50);
+ * expect(await typewriter.getText()).toBe('He');
+ * expect(await typewriter.isCursorDecorative()).toBe(true);
+ * ```
+ *
+ * @see https://ngwr.dev/guides/testing
+ */
+class WrTypewriterHarness extends ComponentHarness {
+    static hostSelector = 'wr-typewriter';
+    /** Build a predicate that narrows the query — pass to `getHarness` / `getAllHarnesses`. */
+    static with(options = {}) {
+        return new HarnessPredicate(WrTypewriterHarness, options)
+            .addOption('text', options.text, (harness, text) => HarnessPredicate.stringMatches(harness.getText(), text))
+            .addOption('hasCursor', options.hasCursor, async (harness, hasCursor) => (await harness.hasCursor()) === hasCursor);
+    }
+    content = this.locatorFor(CONTENT);
+    cursor = this.locatorForOptional(CURSOR);
+    /**
+     * What has been typed so far — a FRAGMENT while the machine is running.
+     *
+     * This is the whole state machine in one string, and every timing input is observable
+     * only through it: one character per `typingSpeed`, one fewer per `deletingSpeed`, the
+     * `pauseDuration` gap, the swap to the next entry in `[texts]`, and the stop that
+     * `[loop]="false"` puts on the last sentence. `reverseMode` shows up here too, and
+     * `[...await getText()].length` is what proves the reversal counted CODE POINTS: a
+     * `split('')` reversal turns one emoji into two lone surrogates, which is a pair of
+     * broken glyphs on screen and the same character count as a correct answer.
+     *
+     * Untrimmed, because the fragment is what it is: a phrase typed as far as `'Hello '`
+     * genuinely has a trailing space, and trimming would make that frame indistinguishable
+     * from the one before it.
+     *
+     * The empty string is a real state, not a failure — nothing has been typed until the
+     * first tick fires, and a deletion run passes back through it on its way to the next
+     * sentence.
+     */
+    async getText() {
+        return rawText(await this.content());
+    }
+    /**
+     * Whether a caret is in the document at all.
+     *
+     * The component removes the element rather than hiding it, which makes this two
+     * questions at once. Statically it answers `showCursor`. While the machine runs it
+     * also answers `hideCursorWhileTyping` — and the caret going away is the ONLY evidence
+     * anywhere in the DOM that the component considers itself mid-phase, since the phase
+     * signal is private. Do not read that as `isTyping()`, though: with
+     * `hideCursorWhileTyping` off, which is the default, the caret stays put from the first
+     * character to the last.
+     */
+    async hasCursor() {
+        return (await this.cursor()) !== null;
+    }
+    /**
+     * The caret glyph, or `null` when there is no caret.
+     *
+     * `null` rather than `''` on purpose: "no cursor element" and "a cursor element
+     * rendering nothing" are different failures, and an interpolated glyph that stopped
+     * arriving is exactly the second one. Untrimmed, since a caret can legitimately be a
+     * space-padded glyph and `TestElement.text()` would erase it.
+     */
+    async getCursorCharacter() {
+        const cursor = await this.cursor();
+        return cursor ? rawText(cursor) : null;
+    }
+    /**
+     * Whether the caret is kept out of the accessibility tree.
+     *
+     * The component's one deliberate a11y decision, and a silent one to lose: drop the
+     * attribute and nothing on screen changes while every phrase starts being announced as
+     * `Hello pipe`.
+     *
+     * Throws when there is no caret. `false` would read as "the caret is announced", which
+     * is the opposite of what an absent caret means — and it is the answer a component that
+     * stopped rendering its cursor entirely would also give. Ask {@link hasCursor} first
+     * when the caret's presence is itself in question.
+     */
+    async isCursorDecorative() {
+        const cursor = await this.cursor();
+        if (!cursor) {
+            throw new Error('WrTypewriterHarness.isCursorDecorative(): this <wr-typewriter> has no cursor element, so there is ' +
+                'nothing to be hidden from a screen reader and "false" would read as "the cursor is announced" — the ' +
+                'opposite of what an absent cursor means. `showCursor` is off, or `hideCursorWhileTyping` has taken ' +
+                'it away for this phase; ask hasCursor().');
+        }
+        return (await cursor.getAttribute('aria-hidden')) === 'true';
+    }
+    /**
+     * The caret's blink half-cycle in seconds, from the custom property the host writes.
+     *
+     * The blink itself is a CSS keyframe and unobservable, so this custom property is the
+     * only channel `[cursorBlinkDuration]` has into it — a binding that quietly stopped
+     * writing it would leave the blink stuck at the stylesheet's default with no other
+     * symptom anywhere.
+     *
+     * Throws rather than answering when the property is missing or unparseable, and says
+     * which it was. The stylesheet's own `0.5s` fallback is never applied in a test that
+     * loads no stylesheets, so an absent property reads as the empty string here — and
+     * `0.5` returned from a `parseFloat('')` would be indistinguishable from the component
+     * writing the default correctly.
+     */
+    async getCursorBlinkDuration() {
+        const raw = (await (await this.host()).getCssValue('--wr-typewriter-cursor-blink')).trim();
+        const seconds = Number.parseFloat(raw);
+        if (!Number.isFinite(seconds)) {
+            throw new Error(`WrTypewriterHarness.getCursorBlinkDuration(): --wr-typewriter-cursor-blink reads ${JSON.stringify(raw)}, ` +
+                'which is not a number of seconds. The component writes this property inline on every render; the ' +
+                'stylesheet default behind it never applies in a test, so an empty read means the binding stopped ' +
+                'reaching the DOM rather than that the caret blinks at 0.5s.');
+        }
+        return seconds;
+    }
+    /**
+     * The colour the host paints the phrase in, exactly as it is written inline.
+     *
+     * `[textColors]` cycles per SENTENCE, so this is how a spec pins that the colour index
+     * follows the sentence index rather than drifting; and with no colours given the
+     * component writes the literal `inherit`, which is a value worth asserting rather than
+     * an absence.
+     *
+     * Read off the `style` ATTRIBUTE rather than through `getCssValue`, which would answer
+     * from a computed style. jsdom hands `inherit` straight back, so `getCssValue` would
+     * agree here and lie in a real browser, where the keyword resolves to whatever rgb
+     * triple the parent happens to carry.
+     *
+     * Throws when the host carries no `color` declaration: the component writes one on
+     * every render, so its absence means the binding is gone, and any string returned in
+     * its place would be a guess at what the page inherits.
+     */
+    async getColor() {
+        const style = (await (await this.host()).getAttribute('style')) ?? '';
+        const declaration = INLINE_COLOR.exec(style);
+        if (!declaration) {
+            throw new Error(`WrTypewriterHarness.getColor(): the host carries no inline color — its style attribute is ` +
+                `${JSON.stringify(style)}. The component writes one on every render, "inherit" when [textColors] is ` +
+                'empty, so nothing there means the binding stopped reaching the DOM.');
+        }
+        return declaration[1].trim();
+    }
+}
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { WrTypewriterHarness };
+//# sourceMappingURL=ngwr-typewriter-testing.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ngwr-typewriter-testing.mjs","sources":["../../../projects/lib/typewriter/testing/wr-typewriter-harness.ts","../../../projects/lib/typewriter/testing/ngwr-typewriter-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, type TestElement } from '@angular/cdk/testing';\n\nimport type { WrTypewriterHarnessFilters } from './interfaces';\n\n/** The one text node the state machine writes into — the whole of its observable output. */\nconst CONTENT = '.wr-typewriter__content';\n\n/** The caret. Not hidden when it is unwanted — removed from the document entirely. */\nconst CURSOR = '.wr-typewriter__cursor';\n\n/**\n * A `color:` declaration in an inline `style` attribute.\n *\n * The run has to start at the beginning or just after a `;` so that `background-color`\n * — or any other `-color` longhand a consumer's own style attribute might carry — cannot\n * be mistaken for it.\n */\nconst INLINE_COLOR = /(?:^|;)\\s*color\\s*:\\s*([^;]+)/;\n\n/** Exactly what the element holds — untrimmed, unlike `TestElement.text()`. */\nasync function rawText(element: TestElement): Promise<string> {\n  return (await element.getProperty<string | null>('textContent')) ?? '';\n}\n\n/**\n * Test harness for `<wr-typewriter>`.\n *\n * **The typed string is the entire component, and it is a moving target.**\n * {@link getText} reads the one text node the machine writes into, which mid-run holds\n * a FRAGMENT — `'Hell'` on the way to `'Hello'` — and between sentences holds whatever\n * is left of the previous one. That is not a limitation to work around; it is what the\n * component renders, and pinning it tick by tick is what proves the machine types one\n * character at a time, deletes one at a time, pauses, cycles, and stops when told not to\n * loop. Install fake timers for `setTimeout` / `clearTimeout` only and advance the clock\n * yourself before every read — awaiting a harness method flushes microtasks, never\n * timers, so an unadvanced read answers with the previous frame.\n *\n * **What is typed is also what is announced, and no second copy exists.** There is\n * deliberately no `getAccessibleText()` here: the component renders one plain text node\n * and nothing else, so a screen reader landing mid-word hears the fragment. (Its sibling\n * `wr-rotating-text` carries a visually-hidden copy of the whole phrase; this one does\n * not, and inventing a method that implied otherwise would report an accessible layer\n * that is not there.) The single a11y decision the component does make is the caret, and\n * {@link isCursorDecorative} is how a spec holds it: without `aria-hidden` every phrase\n * is announced as `Hello pipe`, and nothing else in the DOM would change.\n *\n * **The methods that are missing are missing on purpose.** There is no `isTyping()` or\n * `getPhase()` — the phase is a private signal that never reaches the document, and its\n * only proxy, the caret vanishing, exists solely when `hideCursorWhileTyping` is set, so\n * the method would report \"not typing\" for the DEFAULT configuration while the machine\n * types. No `isComplete()` / `isFinished()`: a machine stopped on its last sentence and\n * one pausing between sentences render the identical string and the identical caret, so\n * assert the `sentenceComplete` output instead. No `isCursorBlinking()` /\n * `getCursorOpacity()`: the blink is a `@keyframes` rule from a stylesheet a unit test\n * never loads, and a mid-animation opacity is a number that means nothing.\n * No `isVisible()` / `waitForVisible()`: `startOnVisible` hangs off an\n * `IntersectionObserver` jsdom does not implement, so any answer would be the spec's own\n * stub echoing back. And no `getTypingSpeed()` / `getDeletingSpeed()` /\n * `getPauseDuration()` / `getInitialDelay()`: none of them is ever written to the DOM, so\n * reading them would mean reading the component instance rather than the rendered\n * control. They are observable exactly once — as the cadence of {@link getText}.\n *\n * What DOES survive a test with no layout, besides the string: the caret's presence,\n * glyph and `aria-hidden`, and the two values the host writes inline —\n * {@link getColor} and {@link getCursorBlinkDuration}.\n *\n * ```ts\n * // jsdom implements no IntersectionObserver, so `[startOnVisible]` throws on boot.\n * vi.stubGlobal('IntersectionObserver', StubObserver);\n * // Fake these two and no more: faking the microtask queue deadlocks `whenStable`,\n * // which is where the machine boots and where every harness read stabilizes.\n * vi.useFakeTimers({ toFake: ['setTimeout', 'clearTimeout'] });\n * ```\n *\n * @example\n * ```ts\n * const typewriter = await loader.getHarness(WrTypewriterHarness);\n *\n * vi.advanceTimersByTime(0);            // the first tick is scheduled at `initialDelay`\n * expect(await typewriter.getText()).toBe('H');\n *\n * vi.advanceTimersByTime(50);\n * expect(await typewriter.getText()).toBe('He');\n * expect(await typewriter.isCursorDecorative()).toBe(true);\n * ```\n *\n * @see https://ngwr.dev/guides/testing\n */\nexport class WrTypewriterHarness extends ComponentHarness {\n  static hostSelector = 'wr-typewriter';\n\n  /** Build a predicate that narrows the query — pass to `getHarness` / `getAllHarnesses`. */\n  static with(options: WrTypewriterHarnessFilters = {}): HarnessPredicate<WrTypewriterHarness> {\n    return new HarnessPredicate(WrTypewriterHarness, options)\n      .addOption('text', options.text, (harness, text) => HarnessPredicate.stringMatches(harness.getText(), text))\n      .addOption(\n        'hasCursor',\n        options.hasCursor,\n        async (harness, hasCursor) => (await harness.hasCursor()) === hasCursor\n      );\n  }\n\n  private readonly content = this.locatorFor(CONTENT);\n  private readonly cursor = this.locatorForOptional(CURSOR);\n\n  /**\n   * What has been typed so far — a FRAGMENT while the machine is running.\n   *\n   * This is the whole state machine in one string, and every timing input is observable\n   * only through it: one character per `typingSpeed`, one fewer per `deletingSpeed`, the\n   * `pauseDuration` gap, the swap to the next entry in `[texts]`, and the stop that\n   * `[loop]=\"false\"` puts on the last sentence. `reverseMode` shows up here too, and\n   * `[...await getText()].length` is what proves the reversal counted CODE POINTS: a\n   * `split('')` reversal turns one emoji into two lone surrogates, which is a pair of\n   * broken glyphs on screen and the same character count as a correct answer.\n   *\n   * Untrimmed, because the fragment is what it is: a phrase typed as far as `'Hello '`\n   * genuinely has a trailing space, and trimming would make that frame indistinguishable\n   * from the one before it.\n   *\n   * The empty string is a real state, not a failure — nothing has been typed until the\n   * first tick fires, and a deletion run passes back through it on its way to the next\n   * sentence.\n   */\n  async getText(): Promise<string> {\n    return rawText(await this.content());\n  }\n\n  /**\n   * Whether a caret is in the document at all.\n   *\n   * The component removes the element rather than hiding it, which makes this two\n   * questions at once. Statically it answers `showCursor`. While the machine runs it\n   * also answers `hideCursorWhileTyping` — and the caret going away is the ONLY evidence\n   * anywhere in the DOM that the component considers itself mid-phase, since the phase\n   * signal is private. Do not read that as `isTyping()`, though: with\n   * `hideCursorWhileTyping` off, which is the default, the caret stays put from the first\n   * character to the last.\n   */\n  async hasCursor(): Promise<boolean> {\n    return (await this.cursor()) !== null;\n  }\n\n  /**\n   * The caret glyph, or `null` when there is no caret.\n   *\n   * `null` rather than `''` on purpose: \"no cursor element\" and \"a cursor element\n   * rendering nothing\" are different failures, and an interpolated glyph that stopped\n   * arriving is exactly the second one. Untrimmed, since a caret can legitimately be a\n   * space-padded glyph and `TestElement.text()` would erase it.\n   */\n  async getCursorCharacter(): Promise<string | null> {\n    const cursor = await this.cursor();\n    return cursor ? rawText(cursor) : null;\n  }\n\n  /**\n   * Whether the caret is kept out of the accessibility tree.\n   *\n   * The component's one deliberate a11y decision, and a silent one to lose: drop the\n   * attribute and nothing on screen changes while every phrase starts being announced as\n   * `Hello pipe`.\n   *\n   * Throws when there is no caret. `false` would read as \"the caret is announced\", which\n   * is the opposite of what an absent caret means — and it is the answer a component that\n   * stopped rendering its cursor entirely would also give. Ask {@link hasCursor} first\n   * when the caret's presence is itself in question.\n   */\n  async isCursorDecorative(): Promise<boolean> {\n    const cursor = await this.cursor();\n\n    if (!cursor) {\n      throw new Error(\n        'WrTypewriterHarness.isCursorDecorative(): this <wr-typewriter> has no cursor element, so there is ' +\n          'nothing to be hidden from a screen reader and \"false\" would read as \"the cursor is announced\" — the ' +\n          'opposite of what an absent cursor means. `showCursor` is off, or `hideCursorWhileTyping` has taken ' +\n          'it away for this phase; ask hasCursor().'\n      );\n    }\n\n    return (await cursor.getAttribute('aria-hidden')) === 'true';\n  }\n\n  /**\n   * The caret's blink half-cycle in seconds, from the custom property the host writes.\n   *\n   * The blink itself is a CSS keyframe and unobservable, so this custom property is the\n   * only channel `[cursorBlinkDuration]` has into it — a binding that quietly stopped\n   * writing it would leave the blink stuck at the stylesheet's default with no other\n   * symptom anywhere.\n   *\n   * Throws rather than answering when the property is missing or unparseable, and says\n   * which it was. The stylesheet's own `0.5s` fallback is never applied in a test that\n   * loads no stylesheets, so an absent property reads as the empty string here — and\n   * `0.5` returned from a `parseFloat('')` would be indistinguishable from the component\n   * writing the default correctly.\n   */\n  async getCursorBlinkDuration(): Promise<number> {\n    const raw = (await (await this.host()).getCssValue('--wr-typewriter-cursor-blink')).trim();\n    const seconds = Number.parseFloat(raw);\n\n    if (!Number.isFinite(seconds)) {\n      throw new Error(\n        `WrTypewriterHarness.getCursorBlinkDuration(): --wr-typewriter-cursor-blink reads ${JSON.stringify(raw)}, ` +\n          'which is not a number of seconds. The component writes this property inline on every render; the ' +\n          'stylesheet default behind it never applies in a test, so an empty read means the binding stopped ' +\n          'reaching the DOM rather than that the caret blinks at 0.5s.'\n      );\n    }\n\n    return seconds;\n  }\n\n  /**\n   * The colour the host paints the phrase in, exactly as it is written inline.\n   *\n   * `[textColors]` cycles per SENTENCE, so this is how a spec pins that the colour index\n   * follows the sentence index rather than drifting; and with no colours given the\n   * component writes the literal `inherit`, which is a value worth asserting rather than\n   * an absence.\n   *\n   * Read off the `style` ATTRIBUTE rather than through `getCssValue`, which would answer\n   * from a computed style. jsdom hands `inherit` straight back, so `getCssValue` would\n   * agree here and lie in a real browser, where the keyword resolves to whatever rgb\n   * triple the parent happens to carry.\n   *\n   * Throws when the host carries no `color` declaration: the component writes one on\n   * every render, so its absence means the binding is gone, and any string returned in\n   * its place would be a guess at what the page inherits.\n   */\n  async getColor(): Promise<string> {\n    const style = (await (await this.host()).getAttribute('style')) ?? '';\n    const declaration = INLINE_COLOR.exec(style);\n\n    if (!declaration) {\n      throw new Error(\n        `WrTypewriterHarness.getColor(): the host carries no inline color — its style attribute is ` +\n          `${JSON.stringify(style)}. The component writes one on every render, \"inherit\" when [textColors] is ` +\n          'empty, so nothing there means the binding stopped reaching the DOM.'\n      );\n    }\n\n    return declaration[1].trim();\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-version.mjs

@@ -16,7 +16,7 @@ import { InjectionToken } from '@angular/core';
  * Distinct from `Version` exported by `@angular/core`, which reports the
  * loaded Angular runtime version (e.g. `'22.0.0'`), not ngwr's.
  */
-const NGWR_VERSION = '11.1.0';
+const NGWR_VERSION = '11.2.0';
 
 /**
  * @license

package/fesm2022/ngwr-version.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"ngwr-version.mjs","sources":["../../../projects/lib/version/version.ts","../../../projects/lib/version/version.token.ts","../../../projects/lib/version/ngwr-version.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\n/**\n * The ngwr library version string, kept in sync with\n * `projects/lib/package.json` by `scripts/release-prepare.ts`.\n *\n * Prefer this over reading `package.json` at runtime — that requires a JSON\n * import or `require`, neither of which tree-shakes well in Angular builds.\n *\n * Distinct from `Version` exported by `@angular/core`, which reports the\n * loaded Angular runtime version (e.g. `'22.0.0'`), not ngwr's.\n */\nexport const NGWR_VERSION = '11.1.0';\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 { InjectionToken } from '@angular/core';\n\nimport { NGWR_VERSION } from './version';\n\n/**\n * Injection token holding the ngwr library version string.\n *\n * Default factory returns {@link NGWR_VERSION}. Override it in tests or in\n * apps that want to surface a custom build identifier.\n *\n * @example\n * ```ts\n * @Component({...})\n * export class FooterComponent {\n *   readonly version = inject(NGWR_VERSION_TOKEN);\n * }\n * ```\n */\nexport const NGWR_VERSION_TOKEN = new InjectionToken<string>('NGWR_VERSION_TOKEN', {\n  providedIn: 'root',\n  factory: () => NGWR_VERSION,\n});\n","/**\n * Generated bundle index. Do not edit.\n */\n\nexport * from './public-api';\n"],"names":[],"mappings":";;AAAA;;;;;AAKG;AAEH;;;;;;;;;AASG;AACI,MAAM,YAAY,GAAG;;ACjB5B;;;;;AAKG;AAMH;;;;;;;;;;;;;AAaG;MACU,kBAAkB,GAAG,IAAI,cAAc,CAAS,oBAAoB,EAAE;AACjF,IAAA,UAAU,EAAE,MAAM;AAClB,IAAA,OAAO,EAAE,MAAM,YAAY;AAC5B,CAAA;;AC5BD;;AAEG;;;;"}
+{"version":3,"file":"ngwr-version.mjs","sources":["../../../projects/lib/version/version.ts","../../../projects/lib/version/version.token.ts","../../../projects/lib/version/ngwr-version.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\n/**\n * The ngwr library version string, kept in sync with\n * `projects/lib/package.json` by `scripts/release-prepare.ts`.\n *\n * Prefer this over reading `package.json` at runtime — that requires a JSON\n * import or `require`, neither of which tree-shakes well in Angular builds.\n *\n * Distinct from `Version` exported by `@angular/core`, which reports the\n * loaded Angular runtime version (e.g. `'22.0.0'`), not ngwr's.\n */\nexport const NGWR_VERSION = '11.2.0';\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 { InjectionToken } from '@angular/core';\n\nimport { NGWR_VERSION } from './version';\n\n/**\n * Injection token holding the ngwr library version string.\n *\n * Default factory returns {@link NGWR_VERSION}. Override it in tests or in\n * apps that want to surface a custom build identifier.\n *\n * @example\n * ```ts\n * @Component({...})\n * export class FooterComponent {\n *   readonly version = inject(NGWR_VERSION_TOKEN);\n * }\n * ```\n */\nexport const NGWR_VERSION_TOKEN = new InjectionToken<string>('NGWR_VERSION_TOKEN', {\n  providedIn: 'root',\n  factory: () => NGWR_VERSION,\n});\n","/**\n * Generated bundle index. Do not edit.\n */\n\nexport * from './public-api';\n"],"names":[],"mappings":";;AAAA;;;;;AAKG;AAEH;;;;;;;;;AASG;AACI,MAAM,YAAY,GAAG;;ACjB5B;;;;;AAKG;AAMH;;;;;;;;;;;;;AAaG;MACU,kBAAkB,GAAG,IAAI,cAAc,CAAS,oBAAoB,EAAE;AACjF,IAAA,UAAU,EAAE,MAAM;AAClB,IAAA,OAAO,EAAE,MAAM,YAAY;AAC5B,CAAA;;AC5BD;;AAEG;;;;"}

package/fesm2022/ngwr-waves-testing.mjs

@@ -0,0 +1,128 @@
+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
+ */
+/** `--wr-waves-x-gap: 40px` on the host's own `style` attribute — the pitch, as published. */
+const X_GAP = /(?:^|;)\s*--wr-waves-x-gap\s*:\s*([^;]+)/;
+/**
+ * Test harness for `<wr-waves>` — a field of lines drifting on perlin noise.
+ *
+ * **The lines themselves are unreadable and always will be.** They are strokes on a 2D
+ * canvas, seeded from the host's measured box and redrawn every frame; a unit test has
+ * no box and no drawing context, so there is nothing to count and nothing to compare.
+ * What the component publishes to the DOM is small, deliberate and worth pinning: the
+ * handover flag {@link isPainted}, the pitch {@link getLineGapPx} that the CSS stand-in
+ * grid draws at before the canvas takes over, and the surface itself.
+ *
+ * Two style reads, taken two different ways, and the difference is the point.
+ * {@link getBackgroundColor} is computed, because nothing but the component declares
+ * that property and the resolved value is what gets painted. {@link getLineGapPx} is
+ * read from the inline declaration, because the stylesheet declares
+ * `--wr-waves-x-gap` too — as the stand-in's own 10px fallback — so a computed read
+ * would answer `10px` on a component that had stopped publishing anything, which is
+ * precisely the break the method exists to catch.
+ *
+ * There is no `getLineCount()`, `getPoints()` or `getCanvasSize()`: the grid is seeded
+ * from `getBoundingClientRect()`, which is 0×0 here, and the numbers that fall out of
+ * that describe nothing. No `getLineColor()` either — it is a canvas `strokeStyle`
+ * resolved from a themed custom property that only a stylesheet can supply. No
+ * `moveMouse()`: the pointer listeners are on `window` and are only installed once a
+ * context exists. And no `isReducedMotion()`, which is the sharpest of them — the
+ * reduced-motion path draws one static grid through the same code and sets the same
+ * flag, so the DOM is identical either way and any answer would be a guess.
+ *
+ * @example
+ * ```ts
+ * const waves = await loader.getHarness(WrWavesHarness);
+ *
+ * expect(await waves.hasCanvas()).toBe(true);
+ * expect(await waves.isDecorative()).toBe(true);
+ * expect(await waves.getLineGapPx()).toBe(10);
+ * ```
+ *
+ * @see https://ngwr.dev/guides/testing
+ */
+class WrWavesHarness extends ComponentHarness {
+    static hostSelector = 'wr-waves';
+    /** Build a predicate that narrows the query — pass to `getHarness` / `getAllHarnesses`. */
+    static with(options = {}) {
+        return new HarnessPredicate(WrWavesHarness, options).addOption('painted', options.painted, async (harness, painted) => (await harness.isPainted()) === painted);
+    }
+    canvas = this.locatorFor('.wr-waves__canvas');
+    /**
+     * Whether the canvas has drawn a frame and retired the CSS stand-in grid.
+     *
+     * **In a unit test this is always `false`, and asserting exactly that is the point.**
+     * jsdom hands back no 2D context, so the component must leave the stand-in up rather
+     * than declare itself painted over a blank box — the flag is set inside the draw for
+     * that reason, not at the end of the boot. A spec that waits for this to turn `true`
+     * waits forever.
+     */
+    async isPainted() {
+        return (await this.host()).hasClass('wr-waves--painted');
+    }
+    /**
+     * The horizontal gap between lines, in pixels, as the component publishes it.
+     *
+     * `[xGap]` feeds the canvas maths, which is invisible here — but it is also published
+     * to the stand-in grid, and that is the half a spec can hold: a field whose stand-in
+     * draws at 10px and whose canvas then arrives at 40px changes pitch under the reader
+     * on hydration, a visible pop that nothing else can catch.
+     */
+    async getLineGapPx() {
+        const style = (await (await this.host()).getAttribute('style')) ?? '';
+        const match = X_GAP.exec(style);
+        const gap = match ? Number.parseFloat(match[1]) : Number.NaN;
+        if (Number.isNaN(gap)) {
+            throw new Error(`WrWavesHarness.getLineGapPx(): the host publishes no \`--wr-waves-x-gap\` (style: "${style}"). The ` +
+                'component writes it from `[xGap]` on every render, so its absence means the stand-in grid has fallen ' +
+                "back to the stylesheet's own 10px and no longer follows the input.");
+        }
+        return gap;
+    }
+    /**
+     * The fill behind the lines, resolved.
+     *
+     * Comes back as the browser reports it rather than as it was authored — the default
+     * `'transparent'` reads as `'rgba(0, 0, 0, 0)'` and `'#5227ff'` as
+     * `'rgb(82, 39, 255)'` — which is true in jsdom and in a real browser alike, so an
+     * assertion written against it travels. Worth pinning because the alternative
+     * implementation is to fill the canvas instead, and a canvas fill is invisible to
+     * everything until it has painted: the background has to be a real declaration on the
+     * host so the field is the right colour from the prerendered HTML onwards.
+     */
+    async getBackgroundColor() {
+        return (await this.host()).getCssValue('background-color');
+    }
+    /**
+     * Whether the field is hidden from assistive tech.
+     *
+     * A background canvas has nothing to announce, so losing this leaves a screen reader
+     * stopping on a nameless graphic in front of the section's actual content.
+     */
+    async isDecorative() {
+        return (await (await this.canvas()).getAttribute('aria-hidden')) === 'true';
+    }
+    /**
+     * Whether the drawing surface is in the markup.
+     *
+     * It is there in every state, including the ones where nothing is ever drawn on it —
+     * prerendered, no 2D context, reduced motion. That is the contract: the element goes
+     * up and the component stops, so the stand-in grid has something to sit behind and
+     * {@link isPainted} has something to answer about.
+     */
+    async hasCanvas() {
+        return (await this.locatorForOptional('.wr-waves__canvas')()) !== null;
+    }
+}
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { WrWavesHarness };
+//# sourceMappingURL=ngwr-waves-testing.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ngwr-waves-testing.mjs","sources":["../../../projects/lib/waves/testing/wr-waves-harness.ts","../../../projects/lib/waves/testing/ngwr-waves-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 { WrWavesHarnessFilters } from './interfaces';\n\n/** `--wr-waves-x-gap: 40px` on the host's own `style` attribute — the pitch, as published. */\nconst X_GAP = /(?:^|;)\\s*--wr-waves-x-gap\\s*:\\s*([^;]+)/;\n\n/**\n * Test harness for `<wr-waves>` — a field of lines drifting on perlin noise.\n *\n * **The lines themselves are unreadable and always will be.** They are strokes on a 2D\n * canvas, seeded from the host's measured box and redrawn every frame; a unit test has\n * no box and no drawing context, so there is nothing to count and nothing to compare.\n * What the component publishes to the DOM is small, deliberate and worth pinning: the\n * handover flag {@link isPainted}, the pitch {@link getLineGapPx} that the CSS stand-in\n * grid draws at before the canvas takes over, and the surface itself.\n *\n * Two style reads, taken two different ways, and the difference is the point.\n * {@link getBackgroundColor} is computed, because nothing but the component declares\n * that property and the resolved value is what gets painted. {@link getLineGapPx} is\n * read from the inline declaration, because the stylesheet declares\n * `--wr-waves-x-gap` too — as the stand-in's own 10px fallback — so a computed read\n * would answer `10px` on a component that had stopped publishing anything, which is\n * precisely the break the method exists to catch.\n *\n * There is no `getLineCount()`, `getPoints()` or `getCanvasSize()`: the grid is seeded\n * from `getBoundingClientRect()`, which is 0×0 here, and the numbers that fall out of\n * that describe nothing. No `getLineColor()` either — it is a canvas `strokeStyle`\n * resolved from a themed custom property that only a stylesheet can supply. No\n * `moveMouse()`: the pointer listeners are on `window` and are only installed once a\n * context exists. And no `isReducedMotion()`, which is the sharpest of them — the\n * reduced-motion path draws one static grid through the same code and sets the same\n * flag, so the DOM is identical either way and any answer would be a guess.\n *\n * @example\n * ```ts\n * const waves = await loader.getHarness(WrWavesHarness);\n *\n * expect(await waves.hasCanvas()).toBe(true);\n * expect(await waves.isDecorative()).toBe(true);\n * expect(await waves.getLineGapPx()).toBe(10);\n * ```\n *\n * @see https://ngwr.dev/guides/testing\n */\nexport class WrWavesHarness extends ComponentHarness {\n  static hostSelector = 'wr-waves';\n\n  /** Build a predicate that narrows the query — pass to `getHarness` / `getAllHarnesses`. */\n  static with(options: WrWavesHarnessFilters = {}): HarnessPredicate<WrWavesHarness> {\n    return new HarnessPredicate(WrWavesHarness, options).addOption(\n      'painted',\n      options.painted,\n      async (harness, painted) => (await harness.isPainted()) === painted\n    );\n  }\n\n  private readonly canvas = this.locatorFor('.wr-waves__canvas');\n\n  /**\n   * Whether the canvas has drawn a frame and retired the CSS stand-in grid.\n   *\n   * **In a unit test this is always `false`, and asserting exactly that is the point.**\n   * jsdom hands back no 2D context, so the component must leave the stand-in up rather\n   * than declare itself painted over a blank box — the flag is set inside the draw for\n   * that reason, not at the end of the boot. A spec that waits for this to turn `true`\n   * waits forever.\n   */\n  async isPainted(): Promise<boolean> {\n    return (await this.host()).hasClass('wr-waves--painted');\n  }\n\n  /**\n   * The horizontal gap between lines, in pixels, as the component publishes it.\n   *\n   * `[xGap]` feeds the canvas maths, which is invisible here — but it is also published\n   * to the stand-in grid, and that is the half a spec can hold: a field whose stand-in\n   * draws at 10px and whose canvas then arrives at 40px changes pitch under the reader\n   * on hydration, a visible pop that nothing else can catch.\n   */\n  async getLineGapPx(): Promise<number> {\n    const style = (await (await this.host()).getAttribute('style')) ?? '';\n    const match = X_GAP.exec(style);\n    const gap = match ? Number.parseFloat(match[1]) : Number.NaN;\n    if (Number.isNaN(gap)) {\n      throw new Error(\n        `WrWavesHarness.getLineGapPx(): the host publishes no \\`--wr-waves-x-gap\\` (style: \"${style}\"). The ` +\n          'component writes it from `[xGap]` on every render, so its absence means the stand-in grid has fallen ' +\n          \"back to the stylesheet's own 10px and no longer follows the input.\"\n      );\n    }\n    return gap;\n  }\n\n  /**\n   * The fill behind the lines, resolved.\n   *\n   * Comes back as the browser reports it rather than as it was authored — the default\n   * `'transparent'` reads as `'rgba(0, 0, 0, 0)'` and `'#5227ff'` as\n   * `'rgb(82, 39, 255)'` — which is true in jsdom and in a real browser alike, so an\n   * assertion written against it travels. Worth pinning because the alternative\n   * implementation is to fill the canvas instead, and a canvas fill is invisible to\n   * everything until it has painted: the background has to be a real declaration on the\n   * host so the field is the right colour from the prerendered HTML onwards.\n   */\n  async getBackgroundColor(): Promise<string> {\n    return (await this.host()).getCssValue('background-color');\n  }\n\n  /**\n   * Whether the field is hidden from assistive tech.\n   *\n   * A background canvas has nothing to announce, so losing this leaves a screen reader\n   * stopping on a nameless graphic in front of the section's actual content.\n   */\n  async isDecorative(): Promise<boolean> {\n    return (await (await this.canvas()).getAttribute('aria-hidden')) === 'true';\n  }\n\n  /**\n   * Whether the drawing surface is in the markup.\n   *\n   * It is there in every state, including the ones where nothing is ever drawn on it —\n   * prerendered, no 2D context, reduced motion. That is the contract: the element goes\n   * up and the component stops, so the stand-in grid has something to sit behind and\n   * {@link isPainted} has something to answer about.\n   */\n  async hasCanvas(): Promise<boolean> {\n    return (await this.locatorForOptional('.wr-waves__canvas')()) !== null;\n  }\n}\n","/**\n * Generated bundle index. Do not edit.\n */\n\nexport * from './public-api';\n"],"names":[],"mappings":";;AAAA;;;;;AAKG;AAMH;AACA,MAAM,KAAK,GAAG,0CAA0C;AAExD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAqCG;AACG,MAAO,cAAe,SAAQ,gBAAgB,CAAA;AAClD,IAAA,OAAO,YAAY,GAAG,UAAU;;AAGhC,IAAA,OAAO,IAAI,CAAC,OAAA,GAAiC,EAAE,EAAA;AAC7C,QAAA,OAAO,IAAI,gBAAgB,CAAC,cAAc,EAAE,OAAO,CAAC,CAAC,SAAS,CAC5D,SAAS,EACT,OAAO,CAAC,OAAO,EACf,OAAO,OAAO,EAAE,OAAO,KAAK,CAAC,MAAM,OAAO,CAAC,SAAS,EAAE,MAAM,OAAO,CACpE;IACH;AAEiB,IAAA,MAAM,GAAG,IAAI,CAAC,UAAU,CAAC,mBAAmB,CAAC;AAE9D;;;;;;;;AAQG;AACH,IAAA,MAAM,SAAS,GAAA;AACb,QAAA,OAAO,CAAC,MAAM,IAAI,CAAC,IAAI,EAAE,EAAE,QAAQ,CAAC,mBAAmB,CAAC;IAC1D;AAEA;;;;;;;AAOG;AACH,IAAA,MAAM,YAAY,GAAA;AAChB,QAAA,MAAM,KAAK,GAAG,CAAC,MAAM,CAAC,MAAM,IAAI,CAAC,IAAI,EAAE,EAAE,YAAY,CAAC,OAAO,CAAC,KAAK,EAAE;QACrE,MAAM,KAAK,GAAG,KAAK,CAAC,IAAI,CAAC,KAAK,CAAC;QAC/B,MAAM,GAAG,GAAG,KAAK,GAAG,MAAM,CAAC,UAAU,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,GAAG,MAAM,CAAC,GAAG;AAC5D,QAAA,IAAI,MAAM,CAAC,KAAK,CAAC,GAAG,CAAC,EAAE;AACrB,YAAA,MAAM,IAAI,KAAK,CACb,CAAA,mFAAA,EAAsF,KAAK,CAAA,QAAA,CAAU;gBACnG,uGAAuG;AACvG,gBAAA,oEAAoE,CACvE;QACH;AACA,QAAA,OAAO,GAAG;IACZ;AAEA;;;;;;;;;;AAUG;AACH,IAAA,MAAM,kBAAkB,GAAA;AACtB,QAAA,OAAO,CAAC,MAAM,IAAI,CAAC,IAAI,EAAE,EAAE,WAAW,CAAC,kBAAkB,CAAC;IAC5D;AAEA;;;;;AAKG;AACH,IAAA,MAAM,YAAY,GAAA;AAChB,QAAA,OAAO,CAAC,MAAM,CAAC,MAAM,IAAI,CAAC,MAAM,EAAE,EAAE,YAAY,CAAC,aAAa,CAAC,MAAM,MAAM;IAC7E;AAEA;;;;;;;AAOG;AACH,IAAA,MAAM,SAAS,GAAA;AACb,QAAA,OAAO,CAAC,MAAM,IAAI,CAAC,kBAAkB,CAAC,mBAAmB,CAAC,EAAE,MAAM,IAAI;IACxE;;;ACxIF;;AAEG;;;;"}