ngwr 11.0.0 → 11.2.0

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

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

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

@@ -104,9 +104,22 @@ class WrSplitText {
     isBrowser = isPlatformBrowser(inject(PLATFORM_ID));
     platform = inject(WrPlatform);
     hasAnimated = false;
+    /**
+     * The ONE observer, replaced rather than stacked.
+     *
+     * `startObserver()` used to `new IntersectionObserver(…)` and register its own
+     * `destroyRef.onDestroy` every time, and the effect below calls it on every
+     * `text` change after setting `hasAnimated = false` — so the guard at the top
+     * of `startObserver` never blocked that path. An off-screen element (the only
+     * case where the observer does not immediately disconnect itself) therefore
+     * leaked one live observer AND one destroy callback per change, all of them
+     * watching the same host and all of them able to fire `animate()`.
+     */
+    observer = null;
     constructor() {
         if (!this.isBrowser)
             return;
+        this.destroyRef.onDestroy(() => this.observer?.disconnect());
         afterNextRender(() => this.startObserver());
         // Re-run animation if `text` (and therefore the split pieces) changes.
         effect(() => {
@@ -123,6 +136,7 @@ class WrSplitText {
         const observe = () => {
             if (this.hasAnimated)
                 return;
+            this.observer?.disconnect();
             const io = new IntersectionObserver((entries, obs) => {
                 for (const e of entries) {
                     if (e.isIntersecting) {
@@ -132,8 +146,8 @@ class WrSplitText {
                     }
                 }
             }, { threshold: this.threshold(), rootMargin: this.rootMargin() });
+            this.observer = io;
             io.observe(host);
-            this.destroyRef.onDestroy(() => io.disconnect());
         };
         void ready.then(observe);
     }

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

@@ -1 +1 @@
-{"version":3,"file":"ngwr-split-text.mjs","sources":["../../../projects/lib/split-text/split-text.ts","../../../projects/lib/split-text/split-text.html","../../../projects/lib/split-text/ngwr-split-text.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 * Angular adaptation of the SplitText effect by David Haz / reactbits.dev.\n * Original: https://www.reactbits.dev/text-animations/split-text\n *\n * The reactbits version uses GSAP's paid `SplitText` plugin. This port is\n * GSAP-free — splits via plain DOM spans, animates via the Web Animations\n * API, triggers on viewport entry via `IntersectionObserver`.\n */\n\nimport { isPlatformBrowser } from '@angular/common';\nimport {\n  Component,\n  DestroyRef,\n  ElementRef,\n  PLATFORM_ID,\n  ViewEncapsulation,\n  afterNextRender,\n  computed,\n  effect,\n  inject,\n  input,\n  output,\n} from '@angular/core';\n\nimport { WrPlatform } from 'ngwr/platform';\nimport { numAttr } from 'ngwr/utils';\n\nimport type { WrSplitTextUnit, WrSplitTextMotion } from './interfaces';\n\ntype Piece = { readonly kind: 'piece'; readonly text: string } | { readonly kind: 'space'; readonly text: string };\n\n/** Split `text` into render pieces, preserving whitespace as `kind: 'space'`. */\nfunction splitPieces(text: string, unit: WrSplitTextUnit): readonly Piece[] {\n  if (!text) return [];\n  if (unit === 'words') {\n    // Split on whitespace, keeping spaces as separate pieces.\n    return text.split(/(\\s+)/).flatMap<Piece>(seg => {\n      if (seg.length === 0) return [];\n      if (/^\\s+$/.test(seg)) return [{ kind: 'space', text: seg } as const];\n      return [{ kind: 'piece', text: seg } as const];\n    });\n  }\n  // chars: each character is its own piece; whitespace becomes 'space'.\n  return [...text].map<Piece>(ch => (/\\s/.test(ch) ? { kind: 'space', text: ch } : { kind: 'piece', text: ch }));\n}\n\nfunction motionToStyle(m: WrSplitTextMotion): { opacity: number; transform: string } {\n  const opacity = m.opacity ?? 1;\n  const parts: string[] = [];\n  if (m.x !== undefined || m.y !== undefined) {\n    parts.push(`translate3d(${m.x ?? 0}px, ${m.y ?? 0}px, 0)`);\n  }\n  if (m.scale !== undefined) parts.push(`scale(${m.scale})`);\n  if (m.rotate !== undefined) parts.push(`rotate(${m.rotate}deg)`);\n  return { opacity, transform: parts.length ? parts.join(' ') : 'none' };\n}\n\n/**\n * Animated text reveal — splits the input string into chars or words and\n * staggers each piece in from a `from` motion state to a `to` motion\n * state when the host scrolls into view. Whitespace is preserved.\n *\n * @example\n * ```html\n * <wr-split-text\n *   text=\"Hello, ngwr!\"\n *   splitType=\"chars\"\n *   [delay]=\"40\"\n *   [duration]=\"1.2\"\n *   [from]=\"{ opacity: 0, y: 40 }\"\n *   [to]=\"{ opacity: 1, y: 0 }\"\n *   (animationComplete)=\"onDone()\"\n * />\n * ```\n *\n * @see https://www.reactbits.dev/text-animations/split-text\n */\n@Component({\n  selector: 'wr-split-text',\n  templateUrl: './split-text.html',\n  styleUrl: './split-text.scss',\n  encapsulation: ViewEncapsulation.None,\n  host: { class: 'wr-split-text', '[style.text-align]': 'textAlign()' },\n})\nexport class WrSplitText {\n  /** Text to animate. Required. */\n  readonly text = input.required<string>();\n\n  /** Split granularity. @default 'chars' */\n  readonly splitType = input<WrSplitTextUnit>('chars');\n\n  /** Stagger delay between pieces in ms. @default 50 */\n  readonly delay = input(50, { transform: numAttr(50) });\n\n  /** Animation duration in seconds (matches reactbits' API). @default 1.25 */\n  readonly duration = input(1.25, { transform: numAttr(1.25) });\n\n  /** CSS easing function. @default 'cubic-bezier(0.16, 1, 0.3, 1)' (~power3.out) */\n  readonly easing = input('cubic-bezier(0.16, 1, 0.3, 1)');\n\n  /** Start state for each piece. @default { opacity: 0, y: 40 } */\n  readonly from = input<WrSplitTextMotion>({ opacity: 0, y: 40 });\n\n  /** End state for each piece. @default { opacity: 1, y: 0 } */\n  readonly to = input<WrSplitTextMotion>({ opacity: 1, y: 0 });\n\n  /** `IntersectionObserver.threshold` — 0..1. @default 0.1 */\n  readonly threshold = input(0.1, { transform: numAttr(0.1) });\n\n  /** `IntersectionObserver.rootMargin`. @default '-100px' */\n  readonly rootMargin = input('-100px');\n\n  /** Text alignment of the host. @default 'center' */\n  readonly textAlign = input<'left' | 'center' | 'right' | 'justify'>('center');\n\n  /** Emitted once all pieces finish animating. */\n  readonly animationComplete = output<void>();\n\n  /** Pieces to render. Each piece is `{ kind: 'piece', text }` or `{ kind: 'space' }`. */\n  protected readonly pieces = computed(() => splitPieces(this.text(), this.splitType()));\n\n  private readonly host = inject<ElementRef<HTMLElement>>(ElementRef);\n  private readonly destroyRef = inject(DestroyRef);\n  private readonly isBrowser = isPlatformBrowser(inject(PLATFORM_ID));\n  private readonly platform = inject(WrPlatform);\n\n  private hasAnimated = false;\n\n  constructor() {\n    if (!this.isBrowser) return;\n\n    afterNextRender(() => this.startObserver());\n\n    // Re-run animation if `text` (and therefore the split pieces) changes.\n    effect(() => {\n      this.text();\n      this.splitType();\n      this.hasAnimated = false;\n      queueMicrotask(() => this.startObserver());\n    });\n  }\n\n  private startObserver(): void {\n    const host = this.host.nativeElement;\n    const fonts = (document as Document & { fonts?: FontFaceSet }).fonts;\n    const ready = fonts?.status === 'loaded' ? Promise.resolve() : (fonts?.ready ?? Promise.resolve());\n\n    const observe = (): void => {\n      if (this.hasAnimated) return;\n      const io = new IntersectionObserver(\n        (entries, obs) => {\n          for (const e of entries) {\n            if (e.isIntersecting) {\n              obs.disconnect();\n              this.animate();\n              break;\n            }\n          }\n        },\n        { threshold: this.threshold(), rootMargin: this.rootMargin() }\n      );\n      io.observe(host);\n      this.destroyRef.onDestroy(() => io.disconnect());\n    };\n\n    void ready.then(observe);\n  }\n\n  private animate(): void {\n    if (this.hasAnimated) return;\n    this.hasAnimated = true;\n\n    // Reduced motion: pieces already render at their natural (final)\n    // state — skip the tween and report completion right away.\n    if (this.platform.prefersReducedMotion()) {\n      this.animationComplete.emit();\n      return;\n    }\n\n    const host = this.host.nativeElement;\n    const targets = host.querySelectorAll<HTMLElement>('.wr-split-text__piece');\n    if (targets.length === 0) {\n      this.animationComplete.emit();\n      return;\n    }\n\n    const fromStyle = motionToStyle(this.from());\n    const toStyle = motionToStyle(this.to());\n    const durationMs = this.duration() * 1000;\n    const stagger = this.delay();\n    const easing = this.easing();\n\n    let remaining = targets.length;\n    targets.forEach((el, i) => {\n      // Set initial state immediately so there's no flash of final state\n      // before the animation kicks in.\n      el.style.opacity = String(fromStyle.opacity);\n      el.style.transform = fromStyle.transform;\n      const animation = el.animate(\n        [\n          { opacity: fromStyle.opacity, transform: fromStyle.transform },\n          { opacity: toStyle.opacity, transform: toStyle.transform },\n        ],\n        { duration: durationMs, delay: i * stagger, easing, fill: 'forwards' }\n      );\n      animation.onfinish = (): void => {\n        // Commit final styles + clean up the WAAPI tween.\n        el.style.opacity = String(toStyle.opacity);\n        el.style.transform = toStyle.transform;\n        try {\n          animation.cancel();\n        } catch {\n          /* noop */\n        }\n        remaining -= 1;\n        if (remaining === 0) this.animationComplete.emit();\n      };\n    });\n  }\n}\n\nexport type { WrSplitTextUnit, WrSplitTextMotion } from './interfaces';\n","<!-- The readable text, once: the pieces below are per-character spans. -->\n<span class=\"wr-split-text__sr-only\">{{ text() }}</span>\n@for (p of pieces(); track $index) {\n  @if (p.kind === 'piece') {\n    <span class=\"wr-split-text__piece\" aria-hidden=\"true\">{{ p.text }}</span>\n  } @else {\n    <span class=\"wr-split-text__space\" aria-hidden=\"true\">{{ p.text }}</span>\n  }\n}\n","/**\n * Generated bundle index. Do not edit.\n */\n\nexport * from './public-api';\n"],"names":[],"mappings":"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"}
+{"version":3,"file":"ngwr-split-text.mjs","sources":["../../../projects/lib/split-text/split-text.ts","../../../projects/lib/split-text/split-text.html","../../../projects/lib/split-text/ngwr-split-text.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 * Angular adaptation of the SplitText effect by David Haz / reactbits.dev.\n * Original: https://www.reactbits.dev/text-animations/split-text\n *\n * The reactbits version uses GSAP's paid `SplitText` plugin. This port is\n * GSAP-free — splits via plain DOM spans, animates via the Web Animations\n * API, triggers on viewport entry via `IntersectionObserver`.\n */\n\nimport { isPlatformBrowser } from '@angular/common';\nimport {\n  Component,\n  DestroyRef,\n  ElementRef,\n  PLATFORM_ID,\n  ViewEncapsulation,\n  afterNextRender,\n  computed,\n  effect,\n  inject,\n  input,\n  output,\n} from '@angular/core';\n\nimport { WrPlatform } from 'ngwr/platform';\nimport { numAttr } from 'ngwr/utils';\n\nimport type { WrSplitTextUnit, WrSplitTextMotion } from './interfaces';\n\ntype Piece = { readonly kind: 'piece'; readonly text: string } | { readonly kind: 'space'; readonly text: string };\n\n/** Split `text` into render pieces, preserving whitespace as `kind: 'space'`. */\nfunction splitPieces(text: string, unit: WrSplitTextUnit): readonly Piece[] {\n  if (!text) return [];\n  if (unit === 'words') {\n    // Split on whitespace, keeping spaces as separate pieces.\n    return text.split(/(\\s+)/).flatMap<Piece>(seg => {\n      if (seg.length === 0) return [];\n      if (/^\\s+$/.test(seg)) return [{ kind: 'space', text: seg } as const];\n      return [{ kind: 'piece', text: seg } as const];\n    });\n  }\n  // chars: each character is its own piece; whitespace becomes 'space'.\n  return [...text].map<Piece>(ch => (/\\s/.test(ch) ? { kind: 'space', text: ch } : { kind: 'piece', text: ch }));\n}\n\nfunction motionToStyle(m: WrSplitTextMotion): { opacity: number; transform: string } {\n  const opacity = m.opacity ?? 1;\n  const parts: string[] = [];\n  if (m.x !== undefined || m.y !== undefined) {\n    parts.push(`translate3d(${m.x ?? 0}px, ${m.y ?? 0}px, 0)`);\n  }\n  if (m.scale !== undefined) parts.push(`scale(${m.scale})`);\n  if (m.rotate !== undefined) parts.push(`rotate(${m.rotate}deg)`);\n  return { opacity, transform: parts.length ? parts.join(' ') : 'none' };\n}\n\n/**\n * Animated text reveal — splits the input string into chars or words and\n * staggers each piece in from a `from` motion state to a `to` motion\n * state when the host scrolls into view. Whitespace is preserved.\n *\n * @example\n * ```html\n * <wr-split-text\n *   text=\"Hello, ngwr!\"\n *   splitType=\"chars\"\n *   [delay]=\"40\"\n *   [duration]=\"1.2\"\n *   [from]=\"{ opacity: 0, y: 40 }\"\n *   [to]=\"{ opacity: 1, y: 0 }\"\n *   (animationComplete)=\"onDone()\"\n * />\n * ```\n *\n * @see https://www.reactbits.dev/text-animations/split-text\n */\n@Component({\n  selector: 'wr-split-text',\n  templateUrl: './split-text.html',\n  styleUrl: './split-text.scss',\n  encapsulation: ViewEncapsulation.None,\n  host: { class: 'wr-split-text', '[style.text-align]': 'textAlign()' },\n})\nexport class WrSplitText {\n  /** Text to animate. Required. */\n  readonly text = input.required<string>();\n\n  /** Split granularity. @default 'chars' */\n  readonly splitType = input<WrSplitTextUnit>('chars');\n\n  /** Stagger delay between pieces in ms. @default 50 */\n  readonly delay = input(50, { transform: numAttr(50) });\n\n  /** Animation duration in seconds (matches reactbits' API). @default 1.25 */\n  readonly duration = input(1.25, { transform: numAttr(1.25) });\n\n  /** CSS easing function. @default 'cubic-bezier(0.16, 1, 0.3, 1)' (~power3.out) */\n  readonly easing = input('cubic-bezier(0.16, 1, 0.3, 1)');\n\n  /** Start state for each piece. @default { opacity: 0, y: 40 } */\n  readonly from = input<WrSplitTextMotion>({ opacity: 0, y: 40 });\n\n  /** End state for each piece. @default { opacity: 1, y: 0 } */\n  readonly to = input<WrSplitTextMotion>({ opacity: 1, y: 0 });\n\n  /** `IntersectionObserver.threshold` — 0..1. @default 0.1 */\n  readonly threshold = input(0.1, { transform: numAttr(0.1) });\n\n  /** `IntersectionObserver.rootMargin`. @default '-100px' */\n  readonly rootMargin = input('-100px');\n\n  /** Text alignment of the host. @default 'center' */\n  readonly textAlign = input<'left' | 'center' | 'right' | 'justify'>('center');\n\n  /** Emitted once all pieces finish animating. */\n  readonly animationComplete = output<void>();\n\n  /** Pieces to render. Each piece is `{ kind: 'piece', text }` or `{ kind: 'space' }`. */\n  protected readonly pieces = computed(() => splitPieces(this.text(), this.splitType()));\n\n  private readonly host = inject<ElementRef<HTMLElement>>(ElementRef);\n  private readonly destroyRef = inject(DestroyRef);\n  private readonly isBrowser = isPlatformBrowser(inject(PLATFORM_ID));\n  private readonly platform = inject(WrPlatform);\n\n  private hasAnimated = false;\n\n  /**\n   * The ONE observer, replaced rather than stacked.\n   *\n   * `startObserver()` used to `new IntersectionObserver(…)` and register its own\n   * `destroyRef.onDestroy` every time, and the effect below calls it on every\n   * `text` change after setting `hasAnimated = false` — so the guard at the top\n   * of `startObserver` never blocked that path. An off-screen element (the only\n   * case where the observer does not immediately disconnect itself) therefore\n   * leaked one live observer AND one destroy callback per change, all of them\n   * watching the same host and all of them able to fire `animate()`.\n   */\n  private observer: IntersectionObserver | null = null;\n\n  constructor() {\n    if (!this.isBrowser) return;\n    this.destroyRef.onDestroy(() => this.observer?.disconnect());\n\n    afterNextRender(() => this.startObserver());\n\n    // Re-run animation if `text` (and therefore the split pieces) changes.\n    effect(() => {\n      this.text();\n      this.splitType();\n      this.hasAnimated = false;\n      queueMicrotask(() => this.startObserver());\n    });\n  }\n\n  private startObserver(): void {\n    const host = this.host.nativeElement;\n    const fonts = (document as Document & { fonts?: FontFaceSet }).fonts;\n    const ready = fonts?.status === 'loaded' ? Promise.resolve() : (fonts?.ready ?? Promise.resolve());\n\n    const observe = (): void => {\n      if (this.hasAnimated) return;\n      this.observer?.disconnect();\n      const io = new IntersectionObserver(\n        (entries, obs) => {\n          for (const e of entries) {\n            if (e.isIntersecting) {\n              obs.disconnect();\n              this.animate();\n              break;\n            }\n          }\n        },\n        { threshold: this.threshold(), rootMargin: this.rootMargin() }\n      );\n      this.observer = io;\n      io.observe(host);\n    };\n\n    void ready.then(observe);\n  }\n\n  private animate(): void {\n    if (this.hasAnimated) return;\n    this.hasAnimated = true;\n\n    // Reduced motion: pieces already render at their natural (final)\n    // state — skip the tween and report completion right away.\n    if (this.platform.prefersReducedMotion()) {\n      this.animationComplete.emit();\n      return;\n    }\n\n    const host = this.host.nativeElement;\n    const targets = host.querySelectorAll<HTMLElement>('.wr-split-text__piece');\n    if (targets.length === 0) {\n      this.animationComplete.emit();\n      return;\n    }\n\n    const fromStyle = motionToStyle(this.from());\n    const toStyle = motionToStyle(this.to());\n    const durationMs = this.duration() * 1000;\n    const stagger = this.delay();\n    const easing = this.easing();\n\n    let remaining = targets.length;\n    targets.forEach((el, i) => {\n      // Set initial state immediately so there's no flash of final state\n      // before the animation kicks in.\n      el.style.opacity = String(fromStyle.opacity);\n      el.style.transform = fromStyle.transform;\n      const animation = el.animate(\n        [\n          { opacity: fromStyle.opacity, transform: fromStyle.transform },\n          { opacity: toStyle.opacity, transform: toStyle.transform },\n        ],\n        { duration: durationMs, delay: i * stagger, easing, fill: 'forwards' }\n      );\n      animation.onfinish = (): void => {\n        // Commit final styles + clean up the WAAPI tween.\n        el.style.opacity = String(toStyle.opacity);\n        el.style.transform = toStyle.transform;\n        try {\n          animation.cancel();\n        } catch {\n          /* noop */\n        }\n        remaining -= 1;\n        if (remaining === 0) this.animationComplete.emit();\n      };\n    });\n  }\n}\n\nexport type { WrSplitTextUnit, WrSplitTextMotion } from './interfaces';\n","<!-- The readable text, once: the pieces below are per-character spans. -->\n<span class=\"wr-split-text__sr-only\">{{ text() }}</span>\n@for (p of pieces(); track $index) {\n  @if (p.kind === 'piece') {\n    <span class=\"wr-split-text__piece\" aria-hidden=\"true\">{{ p.text }}</span>\n  } @else {\n    <span class=\"wr-split-text__space\" aria-hidden=\"true\">{{ p.text }}</span>\n  }\n}\n","/**\n * Generated bundle index. Do not edit.\n */\n\nexport * from './public-api';\n"],"names":[],"mappings":";;;;;;AAAA;;;;;;;;;;;;AAYG;AAwBH;AACA,SAAS,WAAW,CAAC,IAAY,EAAE,IAAqB,EAAA;AACtD,IAAA,IAAI,CAAC,IAAI;AAAE,QAAA,OAAO,EAAE;AACpB,IAAA,IAAI,IAAI,KAAK,OAAO,EAAE;;QAEpB,OAAO,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,OAAO,CAAQ,GAAG,IAAG;AAC9C,YAAA,IAAI,GAAG,CAAC,MAAM,KAAK,CAAC;AAAE,gBAAA,OAAO,EAAE;AAC/B,YAAA,IAAI,OAAO,CAAC,IAAI,CAAC,GAAG,CAAC;gBAAE,OAAO,CAAC,EAAE,IAAI,EAAE,OAAO,EAAE,IAAI,EAAE,GAAG,EAAW,CAAC;YACrE,OAAO,CAAC,EAAE,IAAI,EAAE,OAAO,EAAE,IAAI,EAAE,GAAG,EAAW,CAAC;AAChD,QAAA,CAAC,CAAC;IACJ;;IAEA,OAAO,CAAC,GAAG,IAAI,CAAC,CAAC,GAAG,CAAQ,EAAE,KAAK,IAAI,CAAC,IAAI,CAAC,EAAE,CAAC,GAAG,EAAE,IAAI,EAAE,OAAO,EAAE,IAAI,EAAE,EAAE,EAAE,GAAG,EAAE,IAAI,EAAE,OAAO,EAAE,IAAI,EAAE,EAAE,EAAE,CAAC,CAAC;AAChH;AAEA,SAAS,aAAa,CAAC,CAAoB,EAAA;AACzC,IAAA,MAAM,OAAO,GAAG,CAAC,CAAC,OAAO,IAAI,CAAC;IAC9B,MAAM,KAAK,GAAa,EAAE;AAC1B,IAAA,IAAI,CAAC,CAAC,CAAC,KAAK,SAAS,IAAI,CAAC,CAAC,CAAC,KAAK,SAAS,EAAE;AAC1C,QAAA,KAAK,CAAC,IAAI,CAAC,CAAA,YAAA,EAAe,CAAC,CAAC,CAAC,IAAI,CAAC,CAAA,IAAA,EAAO,CAAC,CAAC,CAAC,IAAI,CAAC,CAAA,MAAA,CAAQ,CAAC;IAC5D;AACA,IAAA,IAAI,CAAC,CAAC,KAAK,KAAK,SAAS;QAAE,KAAK,CAAC,IAAI,CAAC,CAAA,MAAA,EAAS,CAAC,CAAC,KAAK,CAAA,CAAA,CAAG,CAAC;AAC1D,IAAA,IAAI,CAAC,CAAC,MAAM,KAAK,SAAS;QAAE,KAAK,CAAC,IAAI,CAAC,CAAA,OAAA,EAAU,CAAC,CAAC,MAAM,CAAA,IAAA,CAAM,CAAC;IAChE,OAAO,EAAE,OAAO,EAAE,SAAS,EAAE,KAAK,CAAC,MAAM,GAAG,KAAK,CAAC,IAAI,CAAC,GAAG,CAAC,GAAG,MAAM,EAAE;AACxE;AAEA;;;;;;;;;;;;;;;;;;;AAmBG;MAQU,WAAW,CAAA;;IAEb,IAAI,GAAG,KAAK,CAAC,QAAQ;6EAAU;;IAG/B,SAAS,GAAG,KAAK,CAAkB,OAAO;kFAAC;;AAG3C,IAAA,KAAK,GAAG,KAAK,CAAC,EAAE,EAAA,EAAA,IAAA,SAAA,GAAA,EAAA,SAAA,EAAA,OAAA,EAAA,8BAAA,EAAA,CAAA,EAAI,SAAS,EAAE,OAAO,CAAC,EAAE,CAAC,EAAA,CAAG;;AAG7C,IAAA,QAAQ,GAAG,KAAK,CAAC,IAAI,EAAA,EAAA,IAAA,SAAA,GAAA,EAAA,SAAA,EAAA,UAAA,EAAA,8BAAA,EAAA,CAAA,EAAI,SAAS,EAAE,OAAO,CAAC,IAAI,CAAC,EAAA,CAAG;;IAGpD,MAAM,GAAG,KAAK,CAAC,+BAA+B;+EAAC;;IAG/C,IAAI,GAAG,KAAK,CAAoB,EAAE,OAAO,EAAE,CAAC,EAAE,CAAC,EAAE,EAAE,EAAE;6EAAC;;IAGtD,EAAE,GAAG,KAAK,CAAoB,EAAE,OAAO,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE;2EAAC;;AAGnD,IAAA,SAAS,GAAG,KAAK,CAAC,GAAG,EAAA,EAAA,IAAA,SAAA,GAAA,EAAA,SAAA,EAAA,WAAA,EAAA,8BAAA,EAAA,CAAA,EAAI,SAAS,EAAE,OAAO,CAAC,GAAG,CAAC,EAAA,CAAG;;IAGnD,UAAU,GAAG,KAAK,CAAC,QAAQ;mFAAC;;IAG5B,SAAS,GAAG,KAAK,CAA0C,QAAQ;kFAAC;;IAGpE,iBAAiB,GAAG,MAAM,EAAQ;;AAGxB,IAAA,MAAM,GAAG,QAAQ,CAAC,MAAM,WAAW,CAAC,IAAI,CAAC,IAAI,EAAE,EAAE,IAAI,CAAC,SAAS,EAAE,CAAC;+EAAC;AAErE,IAAA,IAAI,GAAG,MAAM,CAA0B,UAAU,CAAC;AAClD,IAAA,UAAU,GAAG,MAAM,CAAC,UAAU,CAAC;IAC/B,SAAS,GAAG,iBAAiB,CAAC,MAAM,CAAC,WAAW,CAAC,CAAC;AAClD,IAAA,QAAQ,GAAG,MAAM,CAAC,UAAU,CAAC;IAEtC,WAAW,GAAG,KAAK;AAE3B;;;;;;;;;;AAUG;IACK,QAAQ,GAAgC,IAAI;AAEpD,IAAA,WAAA,GAAA;QACE,IAAI,CAAC,IAAI,CAAC,SAAS;YAAE;AACrB,QAAA,IAAI,CAAC,UAAU,CAAC,SAAS,CAAC,MAAM,IAAI,CAAC,QAAQ,EAAE,UAAU,EAAE,CAAC;QAE5D,eAAe,CAAC,MAAM,IAAI,CAAC,aAAa,EAAE,CAAC;;QAG3C,MAAM,CAAC,MAAK;YACV,IAAI,CAAC,IAAI,EAAE;YACX,IAAI,CAAC,SAAS,EAAE;AAChB,YAAA,IAAI,CAAC,WAAW,GAAG,KAAK;YACxB,cAAc,CAAC,MAAM,IAAI,CAAC,aAAa,EAAE,CAAC;AAC5C,QAAA,CAAC,CAAC;IACJ;IAEQ,aAAa,GAAA;AACnB,QAAA,MAAM,IAAI,GAAG,IAAI,CAAC,IAAI,CAAC,aAAa;AACpC,QAAA,MAAM,KAAK,GAAI,QAA+C,CAAC,KAAK;QACpE,MAAM,KAAK,GAAG,KAAK,EAAE,MAAM,KAAK,QAAQ,GAAG,OAAO,CAAC,OAAO,EAAE,IAAI,KAAK,EAAE,KAAK,IAAI,OAAO,CAAC,OAAO,EAAE,CAAC;QAElG,MAAM,OAAO,GAAG,MAAW;YACzB,IAAI,IAAI,CAAC,WAAW;gBAAE;AACtB,YAAA,IAAI,CAAC,QAAQ,EAAE,UAAU,EAAE;YAC3B,MAAM,EAAE,GAAG,IAAI,oBAAoB,CACjC,CAAC,OAAO,EAAE,GAAG,KAAI;AACf,gBAAA,KAAK,MAAM,CAAC,IAAI,OAAO,EAAE;AACvB,oBAAA,IAAI,CAAC,CAAC,cAAc,EAAE;wBACpB,GAAG,CAAC,UAAU,EAAE;wBAChB,IAAI,CAAC,OAAO,EAAE;wBACd;oBACF;gBACF;AACF,YAAA,CAAC,EACD,EAAE,SAAS,EAAE,IAAI,CAAC,SAAS,EAAE,EAAE,UAAU,EAAE,IAAI,CAAC,UAAU,EAAE,EAAE,CAC/D;AACD,YAAA,IAAI,CAAC,QAAQ,GAAG,EAAE;AAClB,YAAA,EAAE,CAAC,OAAO,CAAC,IAAI,CAAC;AAClB,QAAA,CAAC;AAED,QAAA,KAAK,KAAK,CAAC,IAAI,CAAC,OAAO,CAAC;IAC1B;IAEQ,OAAO,GAAA;QACb,IAAI,IAAI,CAAC,WAAW;YAAE;AACtB,QAAA,IAAI,CAAC,WAAW,GAAG,IAAI;;;AAIvB,QAAA,IAAI,IAAI,CAAC,QAAQ,CAAC,oBAAoB,EAAE,EAAE;AACxC,YAAA,IAAI,CAAC,iBAAiB,CAAC,IAAI,EAAE;YAC7B;QACF;AAEA,QAAA,MAAM,IAAI,GAAG,IAAI,CAAC,IAAI,CAAC,aAAa;QACpC,MAAM,OAAO,GAAG,IAAI,CAAC,gBAAgB,CAAc,uBAAuB,CAAC;AAC3E,QAAA,IAAI,OAAO,CAAC,MAAM,KAAK,CAAC,EAAE;AACxB,YAAA,IAAI,CAAC,iBAAiB,CAAC,IAAI,EAAE;YAC7B;QACF;QAEA,MAAM,SAAS,GAAG,aAAa,CAAC,IAAI,CAAC,IAAI,EAAE,CAAC;QAC5C,MAAM,OAAO,GAAG,aAAa,CAAC,IAAI,CAAC,EAAE,EAAE,CAAC;QACxC,MAAM,UAAU,GAAG,IAAI,CAAC,QAAQ,EAAE,GAAG,IAAI;AACzC,QAAA,MAAM,OAAO,GAAG,IAAI,CAAC,KAAK,EAAE;AAC5B,QAAA,MAAM,MAAM,GAAG,IAAI,CAAC,MAAM,EAAE;AAE5B,QAAA,IAAI,SAAS,GAAG,OAAO,CAAC,MAAM;QAC9B,OAAO,CAAC,OAAO,CAAC,CAAC,EAAE,EAAE,CAAC,KAAI;;;YAGxB,EAAE,CAAC,KAAK,CAAC,OAAO,GAAG,MAAM,CAAC,SAAS,CAAC,OAAO,CAAC;YAC5C,EAAE,CAAC,KAAK,CAAC,SAAS,GAAG,SAAS,CAAC,SAAS;AACxC,YAAA,MAAM,SAAS,GAAG,EAAE,CAAC,OAAO,CAC1B;gBACE,EAAE,OAAO,EAAE,SAAS,CAAC,OAAO,EAAE,SAAS,EAAE,SAAS,CAAC,SAAS,EAAE;gBAC9D,EAAE,OAAO,EAAE,OAAO,CAAC,OAAO,EAAE,SAAS,EAAE,OAAO,CAAC,SAAS,EAAE;AAC3D,aAAA,EACD,EAAE,QAAQ,EAAE,UAAU,EAAE,KAAK,EAAE,CAAC,GAAG,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,UAAU,EAAE,CACvE;AACD,YAAA,SAAS,CAAC,QAAQ,GAAG,MAAW;;gBAE9B,EAAE,CAAC,KAAK,CAAC,OAAO,GAAG,MAAM,CAAC,OAAO,CAAC,OAAO,CAAC;gBAC1C,EAAE,CAAC,KAAK,CAAC,SAAS,GAAG,OAAO,CAAC,SAAS;AACtC,gBAAA,IAAI;oBACF,SAAS,CAAC,MAAM,EAAE;gBACpB;AAAE,gBAAA,MAAM;;gBAER;gBACA,SAAS,IAAI,CAAC;gBACd,IAAI,SAAS,KAAK,CAAC;AAAE,oBAAA,IAAI,CAAC,iBAAiB,CAAC,IAAI,EAAE;AACpD,YAAA,CAAC;AACH,QAAA,CAAC,CAAC;IACJ;uGArJW,WAAW,EAAA,IAAA,EAAA,EAAA,EAAA,MAAA,EAAA,EAAA,CAAA,eAAA,CAAA,SAAA,EAAA,CAAA;AAAX,IAAA,OAAA,IAAA,GAAA,EAAA,CAAA,oBAAA,CAAA,EAAA,UAAA,EAAA,QAAA,EAAA,OAAA,EAAA,QAAA,EAAA,IAAA,EAAA,WAAW,u8CCzFxB,0YASA,EAAA,MAAA,EAAA,CAAA,obAAA,CAAA,EAAA,aAAA,EAAA,EAAA,CAAA,iBAAA,CAAA,IAAA,EAAA,CAAA;;2FDgFa,WAAW,EAAA,UAAA,EAAA,CAAA;kBAPvB,SAAS;AACE,YAAA,IAAA,EAAA,CAAA,EAAA,QAAA,EAAA,eAAe,EAAA,aAAA,EAGV,iBAAiB,CAAC,IAAI,EAAA,IAAA,EAC/B,EAAE,KAAK,EAAE,eAAe,EAAE,oBAAoB,EAAE,aAAa,EAAE,EAAA,QAAA,EAAA,0YAAA,EAAA,MAAA,EAAA,CAAA,obAAA,CAAA,EAAA;;;AEvFvE;;AAEG;;;;"}

package/fesm2022/ngwr-splitter-testing.mjs

@@ -0,0 +1,245 @@
+import { TestKey, 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
+ */
+const ARROWS = {
+    left: TestKey.LEFT_ARROW,
+    right: TestKey.RIGHT_ARROW,
+    up: TestKey.UP_ARROW,
+    down: TestKey.DOWN_ARROW,
+};
+/**
+ * Test harness for `<wr-splitter>` — two panes and the divider between them.
+ *
+ * **Everything here is the keyboard, and that is not a workaround.** The divider is
+ * dragged with a pointer in a browser, but the drag reads
+ * `getBoundingClientRect()` and turns a client coordinate into a percentage; jsdom
+ * lays nothing out, so every rect is 0×0 and a synthetic drag writes `NaN` into the
+ * position. The arrow keys reach the same state, are the accessible path anyway, and
+ * are what the WAI-ARIA separator pattern is judged on.
+ *
+ * **Two words for the axis, and they are opposites.** The component's
+ * `orientation="horizontal"` means the panes sit side by side, which needs a
+ * VERTICAL divider — so that is what `aria-orientation` says. {@link getOrientation}
+ * answers the component's word and {@link getDividerOrientation} the divider's; both
+ * are here because a spec that conflated them would look right and assert nothing.
+ *
+ * **Arrows follow the VISUAL axis.** Under `dir="rtl"` the start pane is the one on
+ * the right, so ArrowRight SHRINKS the position. {@link pressArrow} takes the key a
+ * user presses rather than a semantic direction, which is the only way a spec can
+ * pin that mirroring; {@link setPosition} walks with whichever key currently grows
+ * the number, and reports where it landed.
+ *
+ * @example
+ * ```ts
+ * const splitter = await loader.getHarness(WrSplitterHarness);
+ *
+ * expect(await splitter.getPosition()).toBe(50);
+ * await splitter.setPosition(70);
+ * expect(await splitter.getPaneSizes()).toEqual({ start: 70, end: 30 });
+ * ```
+ *
+ * @see https://ngwr.dev/guides/testing
+ */
+class WrSplitterHarness extends ComponentHarness {
+    static hostSelector = 'wr-splitter';
+    /** Build a predicate that narrows the query — pass to `getHarness` / `getAllHarnesses`. */
+    static with(options = {}) {
+        return new HarnessPredicate(WrSplitterHarness, options)
+            .addOption('orientation', options.orientation, async (harness, orientation) => (await harness.getOrientation()) === orientation)
+            .addOption('dividerLabel', options.dividerLabel, (harness, label) => HarnessPredicate.stringMatches(harness.getDividerLabel(), label))
+            .addOption('disabled', options.disabled, async (harness, disabled) => (await harness.isDisabled()) === disabled);
+    }
+    divider = this.locatorFor('.wr-splitter__divider');
+    /**
+     * The splitter's own axis: `horizontal` when the panes sit side by side.
+     *
+     * Read from the host modifier rather than from `aria-orientation`, which says the
+     * opposite thing about the same layout — see {@link getDividerOrientation}.
+     */
+    async getOrientation() {
+        return (await (await this.host()).hasClass('wr-splitter--vertical')) ? 'vertical' : 'horizontal';
+    }
+    /**
+     * What the divider announces — the INVERSE of {@link getOrientation}, and correct:
+     * a separator's orientation is the line it draws, not the axis it travels along.
+     */
+    async getDividerOrientation() {
+        return (await this.divider()).getAttribute('aria-orientation');
+    }
+    /** The divider's position as a percentage, from `aria-valuenow`. */
+    async getPosition() {
+        return this.numeric('aria-valuenow');
+    }
+    /** The lowest position the divider will accept, from `aria-valuemin`. */
+    async getMinPosition() {
+        return this.numeric('aria-valuemin');
+    }
+    /** The highest position the divider will accept, from `aria-valuemax`. */
+    async getMaxPosition() {
+        return this.numeric('aria-valuemax');
+    }
+    /**
+     * What each pane is asking for, in percent, from the `flex-basis` the component
+     * writes inline.
+     *
+     * This is the only evidence a spec without layout has that the panes followed the
+     * divider — a measured width is zero for both. They should always sum to 100:
+     * the end pane is `100 - position`, so a pair that does not is a component bug
+     * rather than a rounding artefact.
+     */
+    async getPaneSizes() {
+        const start = await this.locatorFor('.wr-splitter__pane--start')();
+        const end = await this.locatorFor('.wr-splitter__pane--end')();
+        return {
+            start: Number.parseFloat(await start.getCssValue('flex-basis')),
+            end: Number.parseFloat(await end.getCssValue('flex-basis')),
+        };
+    }
+    /** The start pane's projected text, trimmed. */
+    async getStartText() {
+        return (await this.locatorFor('.wr-splitter__pane--start')()).text();
+    }
+    /** The end pane's projected text, trimmed. */
+    async getEndText() {
+        return (await this.locatorFor('.wr-splitter__pane--end')()).text();
+    }
+    /** The divider's accessible name — a focusable separator is a widget and needs one. */
+    async getDividerLabel() {
+        return (await this.divider()).getAttribute('aria-label');
+    }
+    /**
+     * Whether the splitter refuses to resize.
+     *
+     * From the divider's `aria-disabled`, which is the half a screen reader acts on.
+     * The component also drops the divider out of the tab order and paints a modifier
+     * on the host, and {@link isDividerFocusable} answers the first of those — worth
+     * asking separately, because a divider that is announced as disabled and still a
+     * tab stop is a control the keyboard can reach and not use.
+     */
+    async isDisabled() {
+        return (await (await this.divider()).getAttribute('aria-disabled')) === 'true';
+    }
+    /** Whether the divider is a tab stop (`tabindex="0"`). */
+    async isDividerFocusable() {
+        return (await (await this.divider()).getAttribute('tabindex')) === '0';
+    }
+    /** Move keyboard focus to the divider. */
+    async focusDivider() {
+        return (await this.divider()).focus();
+    }
+    /** Whether the divider currently holds focus. */
+    async isDividerFocused() {
+        return (await this.divider()).isFocused();
+    }
+    /**
+     * Press one arrow key on the divider.
+     *
+     * The key rather than a direction, deliberately: which way the position moves is a
+     * function of the key AND the reading direction, and a `grow()` / `shrink()` pair
+     * would hide exactly the behaviour worth asserting. An arrow off the splitter's own
+     * axis does nothing at all — the horizontal splitter ignores Up and Down.
+     *
+     * `shift` is the coarse step: 10 instead of 1.
+     */
+    async pressArrow(arrow, options = {}) {
+        const divider = await this.divider();
+        await (options.shift ? divider.sendKeys({ shift: true }, ARROWS[arrow]) : divider.sendKeys(ARROWS[arrow]));
+    }
+    /** Press Home — jumping to `minPosition`, whatever the reading direction. */
+    async pressHome() {
+        return (await this.divider()).sendKeys(TestKey.HOME);
+    }
+    /** Press End — jumping to `maxPosition`. Semantic, so it never mirrors under RTL. */
+    async pressEnd() {
+        return (await this.divider()).sendKeys(TestKey.END);
+    }
+    /**
+     * Walk the divider to a position with the keyboard, and assert it landed there.
+     *
+     * Ten-unit hops first, then single steps — the same two strides a user has. It
+     * walks rather than assigning, because assigning would prove the harness can write
+     * a signal and nothing about the component: the clamp, the min / max and the
+     * mirroring all live on this path.
+     *
+     * Throws rather than half-arriving. A target outside `[min, max]` is unreachable by
+     * construction, and so is any target the walk cannot hit exactly — the position is a
+     * float that a previous drag may have left mid-step, and whole-unit keys cannot get
+     * off a fractional offset. Both say so, with where it actually stopped.
+     */
+    async setPosition(target) {
+        const [min, max] = [await this.getMinPosition(), await this.getMaxPosition()];
+        if (target < min || target > max) {
+            throw new Error(`WrSplitterHarness.setPosition(${target}): out of range — this splitter accepts ${min}–${max}. ` +
+                'The component clamps, so the walk would stop at the bound and never reach the number asked for.');
+        }
+        if (target === min)
+            return this.pressHome();
+        if (target === max)
+            return this.pressEnd();
+        await this.focusDivider();
+        // The block axis never mirrors, so only the horizontal splitter needs the probe.
+        const vertical = (await this.getOrientation()) === 'vertical';
+        const [grow, shrink] = vertical
+            ? ['down', 'up']
+            : (await this.growsWithRight())
+                ? ['right', 'left']
+                : ['left', 'right'];
+        for (const shift of [true, false]) {
+            const step = shift ? 10 : 1;
+            // Recomputed each pass: the coarse hops clamp at the bounds, so the remaining
+            // distance is not what simple arithmetic on the starting point would predict.
+            let delta = target - (await this.getPosition());
+            while (Math.abs(delta) >= step) {
+                const before = await this.getPosition();
+                await this.pressArrow(delta > 0 ? grow : shrink, { shift });
+                const now = await this.getPosition();
+                if (now === before) {
+                    throw new Error(`WrSplitterHarness.setPosition(${target}): the divider stopped moving at ${now}. A disabled ` +
+                        'splitter ignores its arrows, which is the usual reason this happens.');
+                }
+                delta = target - now;
+            }
+        }
+        const landed = await this.getPosition();
+        if (landed !== target) {
+            throw new Error(`WrSplitterHarness.setPosition(${target}): the walk stopped at ${landed}. The arrows move in whole ` +
+                'units, so a position left on a fraction by a drag cannot be walked onto a whole number.');
+        }
+    }
+    /**
+     * Whether ArrowRight is currently the key that GROWS the position — true in LTR,
+     * false in RTL, where the start pane is the one on the right.
+     *
+     * Probed rather than read off `Directionality`, which a harness has no access to:
+     * press, look, and put it back. At the top of the range a growing press is clamped
+     * and would prove nothing, so the probe presses the other way there instead. The
+     * undo is conditional — a press that moved nothing has nothing to undo, and undoing
+     * it anyway would move the divider by one in the direction the probe was testing.
+     */
+    async growsWithRight() {
+        const before = await this.getPosition();
+        const atCeiling = before >= (await this.getMaxPosition());
+        const [probe, undo] = atCeiling ? ['left', 'right'] : ['right', 'left'];
+        await this.pressArrow(probe);
+        const after = await this.getPosition();
+        if (after !== before)
+            await this.pressArrow(undo);
+        return atCeiling ? after < before : after > before;
+    }
+    async numeric(attribute) {
+        const raw = await (await this.divider()).getAttribute(attribute);
+        return raw === null ? Number.NaN : Number(raw);
+    }
+}
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { WrSplitterHarness };
+//# sourceMappingURL=ngwr-splitter-testing.mjs.map