@cdevhub/ngx-tw 0.7.0 → 0.8.0

package/fesm2022/cdevhub-ngx-tw-popover-testing.mjs

@@ -0,0 +1,213 @@
+import { ComponentHarness, manualChangeDetection, HarnessPredicate, TestKey } from '@angular/cdk/testing';
+
+/**
+ * Lets the zoneless change-detection scheduler run its pending tick.
+ *
+ * `ApplicationRef` schedules a tick with `setTimeout(cb)` raced against
+ * `requestAnimationFrame`. A timer registered *after* the notify that dirtied a
+ * signal therefore fires *after* that tick, so one macrotask is enough to
+ * observe everything already scheduled. It is a fixed, bounded yield, not a
+ * stabilization await, so it cannot hang.
+ *
+ * Every method spends one: an action yields after dispatching, so the effects
+ * the directive applied synchronously are rendered; a read yields before
+ * looking, so it sees any tick that was already pending. The composition is what
+ * matters — `open()` returns while the panel's first render is still pending,
+ * and the following read's own yield is what picks the rendered content up.
+ */
+function afterSchedulerTick() {
+    return new Promise((resolve) => setTimeout(resolve));
+}
+/**
+ * Harness for a `[twPopover]` trigger and the panel it opens.
+ *
+ * ## Nothing here awaits application stabilization, and that is load-bearing
+ *
+ * `TestbedHarnessEnvironment` routes every `TestElement` operation through
+ * `forceStabilize()` — `fixture.detectChanges()` then
+ * `await fixture.whenStable()` — and that await resolves only when Angular's
+ * `PendingTasks` set is empty. Under full-suite contention it was observed
+ * **not to resolve at all**, and everything built on it hung for the whole test
+ * budget instead of failing. This harness was withdrawn twice for that.
+ *
+ * Every method body therefore runs inside CDK's `manualChangeDetection()`,
+ * which sets the flag `forceStabilize()` early-returns on, and so does
+ * acquisition, via {@link load} / {@link loadAll}. The spec beside this file
+ * adds the third piece: it never awaits `fixture.whenStable()` either, not even
+ * in `beforeEach`. All three were needed — each of the two CI failures during
+ * this restoration was traced to one of them, and the second landed on
+ * `tooltip` rather than here, which is how it became clear the fault belongs to
+ * whichever harness spec lands in the unlucky worker slot rather than to any
+ * one component. `grep -c whenStable` over this file and its spec returns zero,
+ * which is the whole claim and is checkable in one command rather than by
+ * counting green runs. The spec pins the rest with tests that hold a real
+ * `PendingTasks` entry open across acquisition and every method.
+ *
+ * Why the application stops stabilizing is **not** known; this removes the
+ * dependency rather than curing it.
+ *
+ * The cost is that change detection is not forced on your behalf. Instead every
+ * method spends one macrotask on the scheduler (see {@link afterSchedulerTick}),
+ * which covers everything already scheduled — including the panel's first
+ * render. What it does not cover is state behind the component's own timers:
+ * {@link close} dispatches Escape and returns, and the panel detaches only after
+ * the 120 ms leave window in `popover.ts`. Wait for that by polling the DOM —
+ * `document.querySelector` needs no stabilization and so can neither hang nor
+ * burn a fixed interval — and only then read through the harness.
+ *
+ * ## Loading it
+ *
+ * The host is the trigger, which lives in the fixture, so the ordinary
+ * `TestbedHarnessEnvironment.loader(fixture)` is correct. The panel renders into
+ * the CDK overlay container outside the fixture, and this harness resolves it
+ * internally via `documentRootLocatorFactory()` — a consumer never needs
+ * `documentRootLoader`.
+ *
+ * The host selector is the directive's static `data-tw-popover-trigger` marker.
+ * `[twPopover]` cannot be used: it takes a required `TemplateRef` or component
+ * type, so it is always property-bound and Angular renders no attribute for a
+ * bound input. The marker also makes the match exact, so no disambiguation
+ * against `aria-haspopup="dialog"` — which the two date-picker triggers also
+ * carry — is needed.
+ *
+ * ## The panel is detached, not disposed
+ *
+ * Unlike `tw-select`, closing a popover **detaches** the portal and keeps the
+ * `OverlayRef` for reuse; it is only rebuilt when `twPopoverBackdrop` or
+ * `twPopoverScrollStrategy` changes. The panel element is therefore absent while
+ * closed and present again after a reopen, on the same overlay.
+ */
+class PopoverHarness extends ComponentHarness {
+    static hostSelector = '[data-tw-popover-trigger]';
+    /**
+     * Acquires one harness without waiting for the application to stabilize —
+     * the counterpart to the guarantee the methods below make.
+     *
+     * `loader.getHarness(...)` is CDK's own acquisition path and it stabilizes:
+     * `getAllRawElements` calls `forceStabilize()`, and `HarnessPredicate`
+     * filtering routes through `parallel()`, which asks *every* active fixture in
+     * the worker to settle. Both await `fixture.whenStable()`, which is the one
+     * thing this harness exists to avoid — and the failure that withdrew it was
+     * observed there, at acquisition, before any method had run.
+     *
+     * So acquisition is wrapped too, and `manualChangeDetection()` nests: the
+     * inner `parallel()` sees the flag already set and skips the stabilization
+     * entirely. **Render the fixture first** (`fixture.detectChanges()`), because
+     * nothing here will do it for you; an unrendered fixture fails loudly with
+     * CDK's "failed to find element" rather than returning something wrong.
+     *
+     * Plain `loader.getHarness(PopoverHarness)` still works and is still supported.
+     * This is the path to use when a suite must not be able to hang.
+     */
+    static load(loader, options = {}) {
+        return manualChangeDetection(() => loader.getHarness(PopoverHarness.with(options)));
+    }
+    /** {@link load} for every matching trigger rather than the first. */
+    static loadAll(loader, options = {}) {
+        return manualChangeDetection(() => loader.getAllHarnesses(PopoverHarness.with(options)));
+    }
+    /** Predicate for `locatorFor` / `locatorForAll`. */
+    static with(options = {}) {
+        return new HarnessPredicate(PopoverHarness, options).addOption('triggerText', options.triggerText, async (h, text) => HarnessPredicate.stringMatches(await h.getTriggerText(), text));
+    }
+    /** The text currently rendered in the trigger, trimmed. */
+    async getTriggerText() {
+        return manualChangeDetection(async () => {
+            await afterSchedulerTick();
+            return (await (await this.host()).text()).trim();
+        });
+    }
+    /** Whether the popover is open, read from the trigger's `aria-expanded`. */
+    async isOpen() {
+        return manualChangeDetection(async () => {
+            await afterSchedulerTick();
+            return (await (await this.host()).getAttribute('aria-expanded')) === 'true';
+        });
+    }
+    /**
+     * Opens the popover by clicking the trigger. No-op when already open.
+     *
+     * This is the gesture for the default `twPopoverTriggerOn="click"`. A
+     * `'focus'`- or `'manual'`-triggered popover is opened through the directive's
+     * own `open()` (reachable via `exportAs: 'twPopover'`), not through a click.
+     */
+    async open() {
+        await manualChangeDetection(async () => {
+            await afterSchedulerTick();
+            const host = await this.host();
+            if ((await host.getAttribute('aria-expanded')) === 'true')
+                return;
+            await host.click();
+            await afterSchedulerTick();
+        });
+    }
+    /**
+     * Closes the popover by sending Escape to the trigger — the one dismissal
+     * that works for click, focus and manual triggers alike. No-op when already
+     * closed, and deliberately inert when `twPopoverCloseOnEscape` is `false`.
+     *
+     * Returns as soon as the key is dispatched. The panel detaches only after the
+     * 120 ms leave window; poll the DOM for its removal before asserting.
+     */
+    async close() {
+        await manualChangeDetection(async () => {
+            await afterSchedulerTick();
+            const host = await this.host();
+            if ((await host.getAttribute('aria-expanded')) !== 'true')
+                return;
+            await host.sendKeys(TestKey.ESCAPE);
+            await afterSchedulerTick();
+        });
+    }
+    /**
+     * Text rendered inside the panel, trimmed, or `null` when the popover is
+     * closed and the panel is detached.
+     */
+    async getText() {
+        return manualChangeDetection(async () => {
+            await afterSchedulerTick();
+            const panel = await this.getPanel();
+            return panel ? (await panel.text()).trim() : null;
+        });
+    }
+    /**
+     * Whether the panel renders its directional arrow (`twPopoverArrow`). `false`
+     * while the popover is closed, because the panel does not exist then.
+     */
+    async hasArrow() {
+        return manualChangeDetection(async () => {
+            await afterSchedulerTick();
+            const id = await this.getPanelId();
+            if (!id)
+                return false;
+            // The arrow has no dedicated attribute hook: it is the panel wrapper's only
+            // `aria-hidden` grandchild span, with the content nested one level deeper.
+            const arrow = await this.documentRootLocatorFactory().locatorForOptional(`#${id} > div > span[aria-hidden="true"]`)();
+            return arrow !== null;
+        });
+    }
+    /**
+     * The panel element, or `null` when the popover is closed. Callers are already
+     * inside `manualChangeDetection`.
+     */
+    async getPanel() {
+        const id = await this.getPanelId();
+        if (!id)
+            return null;
+        return this.documentRootLocatorFactory().locatorForOptional(`#${id}`)();
+    }
+    /**
+     * The id of this trigger's own panel, or `null` when closed. Scoping by
+     * `aria-controls` keeps sibling popovers apart.
+     */
+    async getPanelId() {
+        return (await this.host()).getAttribute('aria-controls');
+    }
+}
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { PopoverHarness };
+//# sourceMappingURL=cdevhub-ngx-tw-popover-testing.mjs.map

package/fesm2022/cdevhub-ngx-tw-popover-testing.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"cdevhub-ngx-tw-popover-testing.mjs","sources":["../../../projects/ngx-tw/popover/testing/popover-harness.ts","../../../projects/ngx-tw/popover/testing/cdevhub-ngx-tw-popover-testing.ts"],"sourcesContent":["import {\n  ComponentHarness,\n  HarnessPredicate,\n  TestKey,\n  manualChangeDetection,\n} from '@angular/cdk/testing';\nimport type { BaseHarnessFilters, HarnessLoader, TestElement } from '@angular/cdk/testing';\n\n/** Filters accepted by `PopoverHarness.with`. */\nexport interface PopoverHarnessFilters extends BaseHarnessFilters {\n  /** Match by the text rendered in the trigger. */\n  triggerText?: string | RegExp;\n}\n\n/**\n * Lets the zoneless change-detection scheduler run its pending tick.\n *\n * `ApplicationRef` schedules a tick with `setTimeout(cb)` raced against\n * `requestAnimationFrame`. A timer registered *after* the notify that dirtied a\n * signal therefore fires *after* that tick, so one macrotask is enough to\n * observe everything already scheduled. It is a fixed, bounded yield, not a\n * stabilization await, so it cannot hang.\n *\n * Every method spends one: an action yields after dispatching, so the effects\n * the directive applied synchronously are rendered; a read yields before\n * looking, so it sees any tick that was already pending. The composition is what\n * matters — `open()` returns while the panel's first render is still pending,\n * and the following read's own yield is what picks the rendered content up.\n */\nfunction afterSchedulerTick(): Promise<void> {\n  return new Promise((resolve) => setTimeout(resolve));\n}\n\n/**\n * Harness for a `[twPopover]` trigger and the panel it opens.\n *\n * ## Nothing here awaits application stabilization, and that is load-bearing\n *\n * `TestbedHarnessEnvironment` routes every `TestElement` operation through\n * `forceStabilize()` — `fixture.detectChanges()` then\n * `await fixture.whenStable()` — and that await resolves only when Angular's\n * `PendingTasks` set is empty. Under full-suite contention it was observed\n * **not to resolve at all**, and everything built on it hung for the whole test\n * budget instead of failing. This harness was withdrawn twice for that.\n *\n * Every method body therefore runs inside CDK's `manualChangeDetection()`,\n * which sets the flag `forceStabilize()` early-returns on, and so does\n * acquisition, via {@link load} / {@link loadAll}. The spec beside this file\n * adds the third piece: it never awaits `fixture.whenStable()` either, not even\n * in `beforeEach`. All three were needed — each of the two CI failures during\n * this restoration was traced to one of them, and the second landed on\n * `tooltip` rather than here, which is how it became clear the fault belongs to\n * whichever harness spec lands in the unlucky worker slot rather than to any\n * one component. `grep -c whenStable` over this file and its spec returns zero,\n * which is the whole claim and is checkable in one command rather than by\n * counting green runs. The spec pins the rest with tests that hold a real\n * `PendingTasks` entry open across acquisition and every method.\n *\n * Why the application stops stabilizing is **not** known; this removes the\n * dependency rather than curing it.\n *\n * The cost is that change detection is not forced on your behalf. Instead every\n * method spends one macrotask on the scheduler (see {@link afterSchedulerTick}),\n * which covers everything already scheduled — including the panel's first\n * render. What it does not cover is state behind the component's own timers:\n * {@link close} dispatches Escape and returns, and the panel detaches only after\n * the 120 ms leave window in `popover.ts`. Wait for that by polling the DOM —\n * `document.querySelector` needs no stabilization and so can neither hang nor\n * burn a fixed interval — and only then read through the harness.\n *\n * ## Loading it\n *\n * The host is the trigger, which lives in the fixture, so the ordinary\n * `TestbedHarnessEnvironment.loader(fixture)` is correct. The panel renders into\n * the CDK overlay container outside the fixture, and this harness resolves it\n * internally via `documentRootLocatorFactory()` — a consumer never needs\n * `documentRootLoader`.\n *\n * The host selector is the directive's static `data-tw-popover-trigger` marker.\n * `[twPopover]` cannot be used: it takes a required `TemplateRef` or component\n * type, so it is always property-bound and Angular renders no attribute for a\n * bound input. The marker also makes the match exact, so no disambiguation\n * against `aria-haspopup=\"dialog\"` — which the two date-picker triggers also\n * carry — is needed.\n *\n * ## The panel is detached, not disposed\n *\n * Unlike `tw-select`, closing a popover **detaches** the portal and keeps the\n * `OverlayRef` for reuse; it is only rebuilt when `twPopoverBackdrop` or\n * `twPopoverScrollStrategy` changes. The panel element is therefore absent while\n * closed and present again after a reopen, on the same overlay.\n */\nexport class PopoverHarness extends ComponentHarness {\n  static hostSelector = '[data-tw-popover-trigger]';\n\n  /**\n   * Acquires one harness without waiting for the application to stabilize —\n   * the counterpart to the guarantee the methods below make.\n   *\n   * `loader.getHarness(...)` is CDK's own acquisition path and it stabilizes:\n   * `getAllRawElements` calls `forceStabilize()`, and `HarnessPredicate`\n   * filtering routes through `parallel()`, which asks *every* active fixture in\n   * the worker to settle. Both await `fixture.whenStable()`, which is the one\n   * thing this harness exists to avoid — and the failure that withdrew it was\n   * observed there, at acquisition, before any method had run.\n   *\n   * So acquisition is wrapped too, and `manualChangeDetection()` nests: the\n   * inner `parallel()` sees the flag already set and skips the stabilization\n   * entirely. **Render the fixture first** (`fixture.detectChanges()`), because\n   * nothing here will do it for you; an unrendered fixture fails loudly with\n   * CDK's \"failed to find element\" rather than returning something wrong.\n   *\n   * Plain `loader.getHarness(PopoverHarness)` still works and is still supported.\n   * This is the path to use when a suite must not be able to hang.\n   */\n  static load(loader: HarnessLoader, options: PopoverHarnessFilters = {}): Promise<PopoverHarness> {\n    return manualChangeDetection(() => loader.getHarness(PopoverHarness.with(options)));\n  }\n\n  /** {@link load} for every matching trigger rather than the first. */\n  static loadAll(\n    loader: HarnessLoader,\n    options: PopoverHarnessFilters = {},\n  ): Promise<PopoverHarness[]> {\n    return manualChangeDetection(() => loader.getAllHarnesses(PopoverHarness.with(options)));\n  }\n\n  /** Predicate for `locatorFor` / `locatorForAll`. */\n  static with(options: PopoverHarnessFilters = {}): HarnessPredicate<PopoverHarness> {\n    return new HarnessPredicate(PopoverHarness, options).addOption(\n      'triggerText',\n      options.triggerText,\n      async (h, text) => HarnessPredicate.stringMatches(await h.getTriggerText(), text),\n    );\n  }\n\n  /** The text currently rendered in the trigger, trimmed. */\n  async getTriggerText(): Promise<string> {\n    return manualChangeDetection(async () => {\n      await afterSchedulerTick();\n      return (await (await this.host()).text()).trim();\n    });\n  }\n\n  /** Whether the popover is open, read from the trigger's `aria-expanded`. */\n  async isOpen(): Promise<boolean> {\n    return manualChangeDetection(async () => {\n      await afterSchedulerTick();\n      return (await (await this.host()).getAttribute('aria-expanded')) === 'true';\n    });\n  }\n\n  /**\n   * Opens the popover by clicking the trigger. No-op when already open.\n   *\n   * This is the gesture for the default `twPopoverTriggerOn=\"click\"`. A\n   * `'focus'`- or `'manual'`-triggered popover is opened through the directive's\n   * own `open()` (reachable via `exportAs: 'twPopover'`), not through a click.\n   */\n  async open(): Promise<void> {\n    await manualChangeDetection(async () => {\n      await afterSchedulerTick();\n      const host = await this.host();\n      if ((await host.getAttribute('aria-expanded')) === 'true') return;\n      await host.click();\n      await afterSchedulerTick();\n    });\n  }\n\n  /**\n   * Closes the popover by sending Escape to the trigger — the one dismissal\n   * that works for click, focus and manual triggers alike. No-op when already\n   * closed, and deliberately inert when `twPopoverCloseOnEscape` is `false`.\n   *\n   * Returns as soon as the key is dispatched. The panel detaches only after the\n   * 120 ms leave window; poll the DOM for its removal before asserting.\n   */\n  async close(): Promise<void> {\n    await manualChangeDetection(async () => {\n      await afterSchedulerTick();\n      const host = await this.host();\n      if ((await host.getAttribute('aria-expanded')) !== 'true') return;\n      await host.sendKeys(TestKey.ESCAPE);\n      await afterSchedulerTick();\n    });\n  }\n\n  /**\n   * Text rendered inside the panel, trimmed, or `null` when the popover is\n   * closed and the panel is detached.\n   */\n  async getText(): Promise<string | null> {\n    return manualChangeDetection(async () => {\n      await afterSchedulerTick();\n      const panel = await this.getPanel();\n      return panel ? (await panel.text()).trim() : null;\n    });\n  }\n\n  /**\n   * Whether the panel renders its directional arrow (`twPopoverArrow`). `false`\n   * while the popover is closed, because the panel does not exist then.\n   */\n  async hasArrow(): Promise<boolean> {\n    return manualChangeDetection(async () => {\n      await afterSchedulerTick();\n      const id = await this.getPanelId();\n      if (!id) return false;\n      // The arrow has no dedicated attribute hook: it is the panel wrapper's only\n      // `aria-hidden` grandchild span, with the content nested one level deeper.\n      const arrow = await this.documentRootLocatorFactory().locatorForOptional(\n        `#${id} > div > span[aria-hidden=\"true\"]`,\n      )();\n      return arrow !== null;\n    });\n  }\n\n  /**\n   * The panel element, or `null` when the popover is closed. Callers are already\n   * inside `manualChangeDetection`.\n   */\n  private async getPanel(): Promise<TestElement | null> {\n    const id = await this.getPanelId();\n    if (!id) return null;\n    return this.documentRootLocatorFactory().locatorForOptional(`#${id}`)();\n  }\n\n  /**\n   * The id of this trigger's own panel, or `null` when closed. Scoping by\n   * `aria-controls` keeps sibling popovers apart.\n   */\n  private async getPanelId(): Promise<string | null> {\n    return (await this.host()).getAttribute('aria-controls');\n  }\n}\n","/**\n * Generated bundle index. Do not edit.\n */\n\nexport * from './index';\n"],"names":[],"mappings":";;AAcA;;;;;;;;;;;;;;AAcG;AACH,SAAS,kBAAkB,GAAA;AACzB,IAAA,OAAO,IAAI,OAAO,CAAC,CAAC,OAAO,KAAK,UAAU,CAAC,OAAO,CAAC,CAAC;AACtD;AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA0DG;AACG,MAAO,cAAe,SAAQ,gBAAgB,CAAA;AAClD,IAAA,OAAO,YAAY,GAAG,2BAA2B;AAEjD;;;;;;;;;;;;;;;;;;;AAmBG;AACH,IAAA,OAAO,IAAI,CAAC,MAAqB,EAAE,UAAiC,EAAE,EAAA;AACpE,QAAA,OAAO,qBAAqB,CAAC,MAAM,MAAM,CAAC,UAAU,CAAC,cAAc,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC;IACrF;;AAGA,IAAA,OAAO,OAAO,CACZ,MAAqB,EACrB,UAAiC,EAAE,EAAA;AAEnC,QAAA,OAAO,qBAAqB,CAAC,MAAM,MAAM,CAAC,eAAe,CAAC,cAAc,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC;IAC1F;;AAGA,IAAA,OAAO,IAAI,CAAC,OAAA,GAAiC,EAAE,EAAA;AAC7C,QAAA,OAAO,IAAI,gBAAgB,CAAC,cAAc,EAAE,OAAO,CAAC,CAAC,SAAS,CAC5D,aAAa,EACb,OAAO,CAAC,WAAW,EACnB,OAAO,CAAC,EAAE,IAAI,KAAK,gBAAgB,CAAC,aAAa,CAAC,MAAM,CAAC,CAAC,cAAc,EAAE,EAAE,IAAI,CAAC,CAClF;IACH;;AAGA,IAAA,MAAM,cAAc,GAAA;AAClB,QAAA,OAAO,qBAAqB,CAAC,YAAW;YACtC,MAAM,kBAAkB,EAAE;AAC1B,YAAA,OAAO,CAAC,MAAM,CAAC,MAAM,IAAI,CAAC,IAAI,EAAE,EAAE,IAAI,EAAE,EAAE,IAAI,EAAE;AAClD,QAAA,CAAC,CAAC;IACJ;;AAGA,IAAA,MAAM,MAAM,GAAA;AACV,QAAA,OAAO,qBAAqB,CAAC,YAAW;YACtC,MAAM,kBAAkB,EAAE;AAC1B,YAAA,OAAO,CAAC,MAAM,CAAC,MAAM,IAAI,CAAC,IAAI,EAAE,EAAE,YAAY,CAAC,eAAe,CAAC,MAAM,MAAM;AAC7E,QAAA,CAAC,CAAC;IACJ;AAEA;;;;;;AAMG;AACH,IAAA,MAAM,IAAI,GAAA;AACR,QAAA,MAAM,qBAAqB,CAAC,YAAW;YACrC,MAAM,kBAAkB,EAAE;AAC1B,YAAA,MAAM,IAAI,GAAG,MAAM,IAAI,CAAC,IAAI,EAAE;YAC9B,IAAI,CAAC,MAAM,IAAI,CAAC,YAAY,CAAC,eAAe,CAAC,MAAM,MAAM;gBAAE;AAC3D,YAAA,MAAM,IAAI,CAAC,KAAK,EAAE;YAClB,MAAM,kBAAkB,EAAE;AAC5B,QAAA,CAAC,CAAC;IACJ;AAEA;;;;;;;AAOG;AACH,IAAA,MAAM,KAAK,GAAA;AACT,QAAA,MAAM,qBAAqB,CAAC,YAAW;YACrC,MAAM,kBAAkB,EAAE;AAC1B,YAAA,MAAM,IAAI,GAAG,MAAM,IAAI,CAAC,IAAI,EAAE;YAC9B,IAAI,CAAC,MAAM,IAAI,CAAC,YAAY,CAAC,eAAe,CAAC,MAAM,MAAM;gBAAE;YAC3D,MAAM,IAAI,CAAC,QAAQ,CAAC,OAAO,CAAC,MAAM,CAAC;YACnC,MAAM,kBAAkB,EAAE;AAC5B,QAAA,CAAC,CAAC;IACJ;AAEA;;;AAGG;AACH,IAAA,MAAM,OAAO,GAAA;AACX,QAAA,OAAO,qBAAqB,CAAC,YAAW;YACtC,MAAM,kBAAkB,EAAE;AAC1B,YAAA,MAAM,KAAK,GAAG,MAAM,IAAI,CAAC,QAAQ,EAAE;AACnC,YAAA,OAAO,KAAK,GAAG,CAAC,MAAM,KAAK,CAAC,IAAI,EAAE,EAAE,IAAI,EAAE,GAAG,IAAI;AACnD,QAAA,CAAC,CAAC;IACJ;AAEA;;;AAGG;AACH,IAAA,MAAM,QAAQ,GAAA;AACZ,QAAA,OAAO,qBAAqB,CAAC,YAAW;YACtC,MAAM,kBAAkB,EAAE;AAC1B,YAAA,MAAM,EAAE,GAAG,MAAM,IAAI,CAAC,UAAU,EAAE;AAClC,YAAA,IAAI,CAAC,EAAE;AAAE,gBAAA,OAAO,KAAK;;;AAGrB,YAAA,MAAM,KAAK,GAAG,MAAM,IAAI,CAAC,0BAA0B,EAAE,CAAC,kBAAkB,CACtE,CAAA,CAAA,EAAI,EAAE,CAAA,iCAAA,CAAmC,CAC1C,EAAE;YACH,OAAO,KAAK,KAAK,IAAI;AACvB,QAAA,CAAC,CAAC;IACJ;AAEA;;;AAGG;AACK,IAAA,MAAM,QAAQ,GAAA;AACpB,QAAA,MAAM,EAAE,GAAG,MAAM,IAAI,CAAC,UAAU,EAAE;AAClC,QAAA,IAAI,CAAC,EAAE;AAAE,YAAA,OAAO,IAAI;AACpB,QAAA,OAAO,IAAI,CAAC,0BAA0B,EAAE,CAAC,kBAAkB,CAAC,CAAA,CAAA,EAAI,EAAE,CAAA,CAAE,CAAC,EAAE;IACzE;AAEA;;;AAGG;AACK,IAAA,MAAM,UAAU,GAAA;AACtB,QAAA,OAAO,CAAC,MAAM,IAAI,CAAC,IAAI,EAAE,EAAE,YAAY,CAAC,eAAe,CAAC;IAC1D;;;ACzOF;;AAEG;;;;"}

package/fesm2022/cdevhub-ngx-tw-tooltip-testing.mjs

@@ -0,0 +1,195 @@
+import { ComponentHarness, manualChangeDetection, HarnessPredicate } from '@angular/cdk/testing';
+
+/**
+ * Lets the zoneless change-detection scheduler run its pending tick.
+ *
+ * `ApplicationRef` schedules a tick with `setTimeout(cb)` raced against
+ * `requestAnimationFrame`. A timer registered *after* the notify that dirtied a
+ * signal therefore fires *after* that tick, so one macrotask is enough to
+ * observe everything already scheduled. It is a fixed, bounded yield, not a
+ * stabilization await, so it cannot hang.
+ *
+ * Every method spends one: an action yields after dispatching, so the effects
+ * the directive applied synchronously are rendered; a read yields before
+ * looking, so it sees any tick that was already pending. The composition is what
+ * matters — `show()` returns while the panel is still behind
+ * `twTooltipShowDelay`, and the following read's own yield is what picks the
+ * rendered content up.
+ */
+function afterSchedulerTick() {
+    return new Promise((resolve) => setTimeout(resolve));
+}
+/**
+ * Harness for a `[twTooltip]` trigger and the panel it shows.
+ *
+ * Deliberately narrow: a tooltip's whole observable surface is *whether it is
+ * showing and what it says*. Position, delays, color, size and arrow are
+ * configuration, not state, and a harness method for any of them would freeze an
+ * API that may still move — so none is offered.
+ *
+ * ## Nothing here awaits application stabilization, and that is load-bearing
+ *
+ * `TestbedHarnessEnvironment` routes every `TestElement` operation through
+ * `forceStabilize()` — `fixture.detectChanges()` then
+ * `await fixture.whenStable()` — and that await resolves only when Angular's
+ * `PendingTasks` set is empty. Under full-suite contention it was observed
+ * **not to resolve at all**, and everything built on it hung for the whole test
+ * budget instead of failing. This harness was withdrawn once for that, on five
+ * green local runs followed by one red CI run.
+ *
+ * Every method body therefore runs inside CDK's `manualChangeDetection()`,
+ * which sets the flag `forceStabilize()` early-returns on, and so does
+ * acquisition, via {@link load} / {@link loadAll}. The spec beside this file
+ * adds the third piece: it never awaits `fixture.whenStable()` either, not even
+ * in `beforeEach`. All three were needed — each of the two CI failures during
+ * this restoration was traced to one of them, and the second landed on
+ * `popover` rather than here, which is how it became clear the fault belongs to
+ * whichever harness spec lands in the unlucky worker slot rather than to any
+ * one component. `grep -c whenStable` over this file and its spec returns zero,
+ * which is the whole claim and is checkable in one command rather than by
+ * counting green runs. The spec pins the rest with tests that hold a real
+ * `PendingTasks` entry open across acquisition and every method.
+ *
+ * Why the application stops stabilizing is **not** known; this removes the
+ * dependency rather than curing it.
+ *
+ * The cost is that change detection is not forced on your behalf. Instead every
+ * method spends one macrotask on the scheduler (see {@link afterSchedulerTick}),
+ * which covers everything already scheduled — including the panel's first
+ * render, which is why {@link getTooltipText} does not come back empty on a
+ * tooltip that has only just attached. What it does not cover is state behind
+ * the component's own timers: {@link show} and {@link hide} dispatch the
+ * interaction and return, and the panel appears or detaches only once
+ * `twTooltipShowDelay` (200 ms by default) or `twTooltipHideDelay` (150 ms)
+ * elapses. Set both to `0` in a fixture, poll the DOM for the panel —
+ * `document.querySelector` needs no stabilization and so can neither hang nor
+ * burn a fixed interval — and only then read through the harness.
+ *
+ * ## Loading it
+ *
+ * The host is the trigger, which lives in the fixture, so the ordinary
+ * `TestbedHarnessEnvironment.loader(fixture)` is correct. The panel renders into
+ * the CDK overlay container outside the fixture, and this harness resolves it
+ * internally via `documentRootLocatorFactory()` — a consumer never needs
+ * `documentRootLoader`.
+ *
+ * The host selector is the directive's static `data-tw-tooltip-trigger` marker,
+ * which matches both spellings of the input: `twTooltip="literal"` and the bound
+ * `[twTooltip]="expr()"`, for which Angular renders no attribute at all. A
+ * harness matching the directive's own selector would silently miss every bound
+ * trigger.
+ *
+ * Unlike `MenuHarness` and `PopoverHarness`, a tooltip trigger carries no
+ * `aria-controls` linking it to its panel (`aria-describedby` points at CDK
+ * `AriaDescriber`'s shared hidden message element for string content), so the
+ * panel is resolved as "the tooltip showing in the document". That is exact for
+ * the hover/focus model, where only one tooltip is visible at a time, but a test
+ * that forces two open at once cannot tell them apart.
+ */
+class TooltipHarness extends ComponentHarness {
+    static hostSelector = '[data-tw-tooltip-trigger]';
+    /** Resolves the tooltip panel, which lives outside this harness's host. */
+    panel = this.documentRootLocatorFactory().locatorForOptional('tw-tooltip-overlay');
+    /**
+     * Acquires one harness without waiting for the application to stabilize —
+     * the counterpart to the guarantee the methods below make.
+     *
+     * `loader.getHarness(...)` is CDK's own acquisition path and it stabilizes:
+     * `getAllRawElements` calls `forceStabilize()`, and `HarnessPredicate`
+     * filtering routes through `parallel()`, which asks *every* active fixture in
+     * the worker to settle. Both await `fixture.whenStable()`, which is the one
+     * thing this harness exists to avoid — and the failure that withdrew it was
+     * observed there, at acquisition, before any method had run.
+     *
+     * So acquisition is wrapped too, and `manualChangeDetection()` nests: the
+     * inner `parallel()` sees the flag already set and skips the stabilization
+     * entirely. **Render the fixture first** (`fixture.detectChanges()`), because
+     * nothing here will do it for you; an unrendered fixture fails loudly with
+     * CDK's "failed to find element" rather than returning something wrong.
+     *
+     * Plain `loader.getHarness(TooltipHarness)` still works and is still supported.
+     * This is the path to use when a suite must not be able to hang.
+     */
+    static load(loader, options = {}) {
+        return manualChangeDetection(() => loader.getHarness(TooltipHarness.with(options)));
+    }
+    /** {@link load} for every matching trigger rather than the first. */
+    static loadAll(loader, options = {}) {
+        return manualChangeDetection(() => loader.getAllHarnesses(TooltipHarness.with(options)));
+    }
+    /** Predicate for `locatorFor` / `locatorForAll`. */
+    static with(options = {}) {
+        return new HarnessPredicate(TooltipHarness, options).addOption('triggerText', options.triggerText, async (h, text) => HarnessPredicate.stringMatches(await h.getTriggerText(), text));
+    }
+    /** The text currently rendered in the trigger, trimmed. */
+    async getTriggerText() {
+        return manualChangeDetection(async () => {
+            await afterSchedulerTick();
+            return (await (await this.host()).text()).trim();
+        });
+    }
+    /** Whether a tooltip panel is currently showing. */
+    async isOpen() {
+        return manualChangeDetection(async () => {
+            await afterSchedulerTick();
+            return (await this.panel()) !== null;
+        });
+    }
+    /**
+     * The tooltip's message, trimmed, or `null` when nothing is showing. Works
+     * for string and `TemplateRef` content alike.
+     */
+    async getTooltipText() {
+        return manualChangeDetection(async () => {
+            await afterSchedulerTick();
+            const panel = await this.panel();
+            return panel ? (await panel.text()).trim() : null;
+        });
+    }
+    /** Hovers the trigger. The panel appears once `twTooltipShowDelay` elapses. */
+    async show() {
+        await manualChangeDetection(async () => {
+            await (await this.host()).hover();
+            await afterSchedulerTick();
+        });
+    }
+    /** Moves the pointer off the trigger. The panel detaches once `twTooltipHideDelay` elapses. */
+    async hide() {
+        await manualChangeDetection(async () => {
+            await (await this.host()).mouseAway();
+            await afterSchedulerTick();
+        });
+    }
+    /**
+     * Focuses the trigger — the keyboard equivalent of {@link show}, and the path
+     * WCAG 2.1 SC 1.4.13 requires to work.
+     *
+     * Moves real DOM focus *and* dispatches `focusin`, because a programmatic
+     * `focus()` does not reliably raise `focusin` in every test DOM. The directive
+     * treats a repeated show as a no-op, so the belt-and-braces pair is safe.
+     */
+    async focusTrigger() {
+        await manualChangeDetection(async () => {
+            const host = await this.host();
+            await host.focus();
+            await host.dispatchEvent('focusin');
+            await afterSchedulerTick();
+        });
+    }
+    /** Blurs the trigger — the keyboard equivalent of {@link hide}. */
+    async blurTrigger() {
+        await manualChangeDetection(async () => {
+            const host = await this.host();
+            await host.blur();
+            await host.dispatchEvent('focusout');
+            await afterSchedulerTick();
+        });
+    }
+}
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { TooltipHarness };
+//# sourceMappingURL=cdevhub-ngx-tw-tooltip-testing.mjs.map

package/fesm2022/cdevhub-ngx-tw-tooltip-testing.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"cdevhub-ngx-tw-tooltip-testing.mjs","sources":["../../../projects/ngx-tw/tooltip/testing/tooltip-harness.ts","../../../projects/ngx-tw/tooltip/testing/cdevhub-ngx-tw-tooltip-testing.ts"],"sourcesContent":["import { ComponentHarness, HarnessPredicate, manualChangeDetection } from '@angular/cdk/testing';\nimport type { BaseHarnessFilters, HarnessLoader, TestElement } from '@angular/cdk/testing';\n\n/** Filters accepted by `TooltipHarness.with`. */\nexport interface TooltipHarnessFilters extends BaseHarnessFilters {\n  /** Match by the text rendered in the trigger. */\n  triggerText?: string | RegExp;\n}\n\n/**\n * Lets the zoneless change-detection scheduler run its pending tick.\n *\n * `ApplicationRef` schedules a tick with `setTimeout(cb)` raced against\n * `requestAnimationFrame`. A timer registered *after* the notify that dirtied a\n * signal therefore fires *after* that tick, so one macrotask is enough to\n * observe everything already scheduled. It is a fixed, bounded yield, not a\n * stabilization await, so it cannot hang.\n *\n * Every method spends one: an action yields after dispatching, so the effects\n * the directive applied synchronously are rendered; a read yields before\n * looking, so it sees any tick that was already pending. The composition is what\n * matters — `show()` returns while the panel is still behind\n * `twTooltipShowDelay`, and the following read's own yield is what picks the\n * rendered content up.\n */\nfunction afterSchedulerTick(): Promise<void> {\n  return new Promise((resolve) => setTimeout(resolve));\n}\n\n/**\n * Harness for a `[twTooltip]` trigger and the panel it shows.\n *\n * Deliberately narrow: a tooltip's whole observable surface is *whether it is\n * showing and what it says*. Position, delays, color, size and arrow are\n * configuration, not state, and a harness method for any of them would freeze an\n * API that may still move — so none is offered.\n *\n * ## Nothing here awaits application stabilization, and that is load-bearing\n *\n * `TestbedHarnessEnvironment` routes every `TestElement` operation through\n * `forceStabilize()` — `fixture.detectChanges()` then\n * `await fixture.whenStable()` — and that await resolves only when Angular's\n * `PendingTasks` set is empty. Under full-suite contention it was observed\n * **not to resolve at all**, and everything built on it hung for the whole test\n * budget instead of failing. This harness was withdrawn once for that, on five\n * green local runs followed by one red CI run.\n *\n * Every method body therefore runs inside CDK's `manualChangeDetection()`,\n * which sets the flag `forceStabilize()` early-returns on, and so does\n * acquisition, via {@link load} / {@link loadAll}. The spec beside this file\n * adds the third piece: it never awaits `fixture.whenStable()` either, not even\n * in `beforeEach`. All three were needed — each of the two CI failures during\n * this restoration was traced to one of them, and the second landed on\n * `popover` rather than here, which is how it became clear the fault belongs to\n * whichever harness spec lands in the unlucky worker slot rather than to any\n * one component. `grep -c whenStable` over this file and its spec returns zero,\n * which is the whole claim and is checkable in one command rather than by\n * counting green runs. The spec pins the rest with tests that hold a real\n * `PendingTasks` entry open across acquisition and every method.\n *\n * Why the application stops stabilizing is **not** known; this removes the\n * dependency rather than curing it.\n *\n * The cost is that change detection is not forced on your behalf. Instead every\n * method spends one macrotask on the scheduler (see {@link afterSchedulerTick}),\n * which covers everything already scheduled — including the panel's first\n * render, which is why {@link getTooltipText} does not come back empty on a\n * tooltip that has only just attached. What it does not cover is state behind\n * the component's own timers: {@link show} and {@link hide} dispatch the\n * interaction and return, and the panel appears or detaches only once\n * `twTooltipShowDelay` (200 ms by default) or `twTooltipHideDelay` (150 ms)\n * elapses. Set both to `0` in a fixture, poll the DOM for the panel —\n * `document.querySelector` needs no stabilization and so can neither hang nor\n * burn a fixed interval — and only then read through the harness.\n *\n * ## Loading it\n *\n * The host is the trigger, which lives in the fixture, so the ordinary\n * `TestbedHarnessEnvironment.loader(fixture)` is correct. The panel renders into\n * the CDK overlay container outside the fixture, and this harness resolves it\n * internally via `documentRootLocatorFactory()` — a consumer never needs\n * `documentRootLoader`.\n *\n * The host selector is the directive's static `data-tw-tooltip-trigger` marker,\n * which matches both spellings of the input: `twTooltip=\"literal\"` and the bound\n * `[twTooltip]=\"expr()\"`, for which Angular renders no attribute at all. A\n * harness matching the directive's own selector would silently miss every bound\n * trigger.\n *\n * Unlike `MenuHarness` and `PopoverHarness`, a tooltip trigger carries no\n * `aria-controls` linking it to its panel (`aria-describedby` points at CDK\n * `AriaDescriber`'s shared hidden message element for string content), so the\n * panel is resolved as \"the tooltip showing in the document\". That is exact for\n * the hover/focus model, where only one tooltip is visible at a time, but a test\n * that forces two open at once cannot tell them apart.\n */\nexport class TooltipHarness extends ComponentHarness {\n  static hostSelector = '[data-tw-tooltip-trigger]';\n\n  /** Resolves the tooltip panel, which lives outside this harness's host. */\n  private readonly panel =\n    this.documentRootLocatorFactory().locatorForOptional('tw-tooltip-overlay');\n\n  /**\n   * Acquires one harness without waiting for the application to stabilize —\n   * the counterpart to the guarantee the methods below make.\n   *\n   * `loader.getHarness(...)` is CDK's own acquisition path and it stabilizes:\n   * `getAllRawElements` calls `forceStabilize()`, and `HarnessPredicate`\n   * filtering routes through `parallel()`, which asks *every* active fixture in\n   * the worker to settle. Both await `fixture.whenStable()`, which is the one\n   * thing this harness exists to avoid — and the failure that withdrew it was\n   * observed there, at acquisition, before any method had run.\n   *\n   * So acquisition is wrapped too, and `manualChangeDetection()` nests: the\n   * inner `parallel()` sees the flag already set and skips the stabilization\n   * entirely. **Render the fixture first** (`fixture.detectChanges()`), because\n   * nothing here will do it for you; an unrendered fixture fails loudly with\n   * CDK's \"failed to find element\" rather than returning something wrong.\n   *\n   * Plain `loader.getHarness(TooltipHarness)` still works and is still supported.\n   * This is the path to use when a suite must not be able to hang.\n   */\n  static load(loader: HarnessLoader, options: TooltipHarnessFilters = {}): Promise<TooltipHarness> {\n    return manualChangeDetection(() => loader.getHarness(TooltipHarness.with(options)));\n  }\n\n  /** {@link load} for every matching trigger rather than the first. */\n  static loadAll(\n    loader: HarnessLoader,\n    options: TooltipHarnessFilters = {},\n  ): Promise<TooltipHarness[]> {\n    return manualChangeDetection(() => loader.getAllHarnesses(TooltipHarness.with(options)));\n  }\n\n  /** Predicate for `locatorFor` / `locatorForAll`. */\n  static with(options: TooltipHarnessFilters = {}): HarnessPredicate<TooltipHarness> {\n    return new HarnessPredicate(TooltipHarness, options).addOption(\n      'triggerText',\n      options.triggerText,\n      async (h, text) => HarnessPredicate.stringMatches(await h.getTriggerText(), text),\n    );\n  }\n\n  /** The text currently rendered in the trigger, trimmed. */\n  async getTriggerText(): Promise<string> {\n    return manualChangeDetection(async () => {\n      await afterSchedulerTick();\n      return (await (await this.host()).text()).trim();\n    });\n  }\n\n  /** Whether a tooltip panel is currently showing. */\n  async isOpen(): Promise<boolean> {\n    return manualChangeDetection(async () => {\n      await afterSchedulerTick();\n      return (await this.panel()) !== null;\n    });\n  }\n\n  /**\n   * The tooltip's message, trimmed, or `null` when nothing is showing. Works\n   * for string and `TemplateRef` content alike.\n   */\n  async getTooltipText(): Promise<string | null> {\n    return manualChangeDetection(async () => {\n      await afterSchedulerTick();\n      const panel: TestElement | null = await this.panel();\n      return panel ? (await panel.text()).trim() : null;\n    });\n  }\n\n  /** Hovers the trigger. The panel appears once `twTooltipShowDelay` elapses. */\n  async show(): Promise<void> {\n    await manualChangeDetection(async () => {\n      await (await this.host()).hover();\n      await afterSchedulerTick();\n    });\n  }\n\n  /** Moves the pointer off the trigger. The panel detaches once `twTooltipHideDelay` elapses. */\n  async hide(): Promise<void> {\n    await manualChangeDetection(async () => {\n      await (await this.host()).mouseAway();\n      await afterSchedulerTick();\n    });\n  }\n\n  /**\n   * Focuses the trigger — the keyboard equivalent of {@link show}, and the path\n   * WCAG 2.1 SC 1.4.13 requires to work.\n   *\n   * Moves real DOM focus *and* dispatches `focusin`, because a programmatic\n   * `focus()` does not reliably raise `focusin` in every test DOM. The directive\n   * treats a repeated show as a no-op, so the belt-and-braces pair is safe.\n   */\n  async focusTrigger(): Promise<void> {\n    await manualChangeDetection(async () => {\n      const host = await this.host();\n      await host.focus();\n      await host.dispatchEvent('focusin');\n      await afterSchedulerTick();\n    });\n  }\n\n  /** Blurs the trigger — the keyboard equivalent of {@link hide}. */\n  async blurTrigger(): Promise<void> {\n    await manualChangeDetection(async () => {\n      const host = await this.host();\n      await host.blur();\n      await host.dispatchEvent('focusout');\n      await afterSchedulerTick();\n    });\n  }\n}\n","/**\n * Generated bundle index. Do not edit.\n */\n\nexport * from './index';\n"],"names":[],"mappings":"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"}