ngwr 10.2.1 → 11.0.0

package/types/ngwr-pagination-testing.d.ts

@@ -0,0 +1,291 @@
+import { BaseHarnessFilters, ComponentHarness, HarnessPredicate } from '@angular/cdk/testing';
+import { WrPaginationSize } from 'ngwr/pagination';
+import { WrSelectHarness } from 'ngwr/select/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
+ */
+
+/** Narrows which `<wr-pagination>` a harness query matches. */
+interface WrPaginationHarnessFilters extends BaseHarnessFilters {
+    /**
+     * Match the `role="navigation"` landmark's accessible name — the `label` input,
+     * the `pagination.label` catalog entry, or the built-in fallback. A string is an
+     * exact match, a RegExp is tested. This is how two pagers on one page are told
+     * apart, which is also why each of them should be named.
+     */
+    readonly label?: string | RegExp;
+    /**
+     * Match the page the pager announces as current via `aria-current="page"`. A
+     * pager announcing none — `currentPage` set below 1 — matches no value here
+     * rather than throwing, so one broken pager cannot fail a query for its
+     * neighbour.
+     */
+    readonly currentPage?: number;
+    /** Match only enabled (`false`) or only disabled (`true`) pagers. */
+    readonly disabled?: boolean;
+}
+
+/**
+ * @license
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://github.com/thekhegay/ngwr/blob/main/LICENSE
+ */
+
+/**
+ * Test harness for `<wr-pagination>` — the numbered strip, its two step controls,
+ * the total label and the page-size changer.
+ *
+ * The strip is not the page list: it is a WINDOW over it, at most seven pages wide,
+ * with an `…` standing in for every page it skipped. So "which pages can I click"
+ * and "how many pages are there" are different questions and this harness keeps
+ * them apart —
+ * {@link getPages} answers the first, {@link getTotalPages} the second, and
+ * {@link getStrip} shows the gaps for what they are. A gap is a `<span>`, not a
+ * control; counting the strip's children as pages is the mistake this API exists to
+ * make impossible.
+ *
+ * **Which page is current has two answers, and this reads the ARIA one.** The
+ * current cell is also PAINTED — the template binds
+ * `[color]="isCurrent(page) ? 'primary' : null"`, so `.wr-btn--primary` sits on it
+ * too. But colour is a theming decision (`ngwr/config` names this very binding as
+ * the reason it ships no app-wide `color` default), while `aria-current="page"` is
+ * the navigation contract: it is what a screen-reader user hears, what the
+ * component's own spec pins, and the only one of the two that still means
+ * "you are here" after a restyle. A harness that read the class would be reporting
+ * on the paint.
+ *
+ * **No roving tab stop to disambiguate.** Every cell is a `<wr-btn>` ELEMENT with
+ * its own tab stop (`tabindex="0"`, dropped only while the control is off), so the
+ * pager has no separate "focused" item that could drift from the current page —
+ * unlike a tab strip or a radio group, there is one active state here and
+ * {@link getCurrentPage} is it.
+ *
+ * Composed rather than re-queried: the cells and step controls are driven through
+ * {@link WrButtonHarness}, which already knows how a `<wr-btn>` says it is off —
+ * both the `disabled` attribute (written on every shape, though inert on a custom
+ * element) and `aria-disabled`, in that order — and the size changer through
+ * {@link WrSelectHarness}, whose panel is a portal in the overlay container and
+ * nowhere inside the pager.
+ *
+ * jsdom notes: every method here is a class / attribute read or a no-arg click, so
+ * none of it needs layout. Two things are therefore invisible in a unit test and
+ * deliberately absent from this API — the responsive collapse, which is a container
+ * query ({@link isResponsive} reports only that it is ALLOWED), and the compact
+ * `‹ 3 / 10 ›` pager it swaps in, which is `aria-hidden` decoration duplicating
+ * {@link getCurrentPage} and {@link getTotalPages} and which a real browser would
+ * read as empty text while CSS keeps it hidden.
+ *
+ * @example
+ * ```ts
+ * const pager = await loader.getHarness(WrPaginationHarness);
+ *
+ * expect(await pager.getPages()).toEqual([1, 2, 3, 4, 5, 10]);
+ * await pager.goToPage(3);
+ * expect(await pager.getCurrentPage()).toBe(3);
+ * ```
+ *
+ * @see https://ngwr.dev/guides/testing
+ */
+declare class WrPaginationHarness extends ComponentHarness {
+    static hostSelector: string;
+    /** Build a predicate that narrows the query — pass to `getHarness` / `getAllHarnesses`. */
+    static with(options?: WrPaginationHarnessFilters): HarnessPredicate<WrPaginationHarness>;
+    /** The numbered cells, in DOM order — ascending, and never a gap. */
+    private readonly pageCells;
+    /**
+     * The two controls bracketing the strip: previous, then next.
+     *
+     * Located by POSITION, not by their labels. `prevLabel` / `nextLabel` are inputs
+     * and both fall back to the `pagination.prev` / `pagination.next` catalog entries,
+     * so an English `aria-label` match works right up until someone ships a locale —
+     * whereas the nav's shape (one step control, the strip, one step control) is
+     * structural. `:not(.wr-pagination__page)` is what keeps the cells out of it.
+     */
+    private readonly stepControls;
+    /** Both kinds of strip slot, in DOM order — cells and the gaps between them. */
+    private readonly stripSlots;
+    private readonly totalLabel;
+    private readonly sizeChanger;
+    /**
+     * The accessible name of the `role="navigation"` landmark.
+     *
+     * `''` only if the landmark lost its name, which is a bug rather than a state: a
+     * page with two unnamed pagers gives a screen-reader user two identical
+     * "navigation" landmarks.
+     */
+    getLabel(): Promise<string>;
+    /**
+     * The size the pager RENDERS at, from its host modifier.
+     *
+     * The modifier is always emitted — `sm` included — so the fall-through below is
+     * only ever reached for the default, and a size the strip is not wearing cannot
+     * come back from here.
+     *
+     * The STRIP resolves nothing through `provideWrConfig()`, which is worth knowing
+     * before an app-wide default is blamed for a cell size: the pager passes its own
+     * `size` down to every `<wr-btn>` explicitly, so a configured `button.size` never
+     * reaches a cell. The page-size changer is the exception and not covered by this
+     * value — it is a bare `<wr-select>`, so `provideWrConfig({ select: … })` does
+     * reach it.
+     */
+    getSize(): Promise<WrPaginationSize>;
+    /**
+     * Whether the pager is ALLOWED to collapse into its compact pager.
+     *
+     * Whether it HAS collapsed is a container query on the control's own box, and a
+     * unit test has no layout for one to answer — assert this input in jsdom and the
+     * reflow itself in a real browser.
+     */
+    isResponsive(): Promise<boolean>;
+    /**
+     * Whether the whole control refuses interaction.
+     *
+     * Read from the host modifier, because a `role="navigation"` landmark has no ARIA
+     * disabled state to prefer — the per-control answer lives on the buttons
+     * themselves (`disabled` plus `aria-disabled` on each), which is what
+     * {@link isPreviousDisabled} and {@link isNextDisabled} read.
+     */
+    isDisabled(): Promise<boolean>;
+    /**
+     * The whole strip in DOM order: a `number` for every page cell, and the gap
+     * marker's own text (`…`) for every ellipsis.
+     *
+     * The marker is read from the DOM rather than compared against a literal, so a
+     * component that changes what it draws in a gap changes this too instead of
+     * quietly reporting a page.
+     */
+    getStrip(): Promise<(number | string)[]>;
+    /**
+     * The pages that can be clicked right now, ascending. Gaps are not pages and are
+     * not here — `[1, 8, 9, 10, 11, 12, 20]` for a twenty-page list sitting on 10.
+     */
+    getPages(): Promise<number[]>;
+    /**
+     * How many pages there are — not how many are on the strip.
+     *
+     * Taken from the LAST cell, which the window always pins to the final page (the
+     * first is pinned the same way), so this survives the gap that usually precedes
+     * it. Deliberately not read from the compact `3 / 10` pager: that span is
+     * `aria-hidden` and CSS-hidden outside responsive mode, so a browser-based
+     * harness environment would read it as empty.
+     */
+    getTotalPages(): Promise<number>;
+    /**
+     * The page the pager announces as current, from `aria-current="page"`.
+     *
+     * Throws when no cell claims it. The window always keeps the current page on the
+     * strip, so getting here means `currentPage` is not one of the pages at all — it
+     * is below 1, or not a whole number. The component clamps a page ABOVE the last
+     * one and nothing else, and either survivor leaves every cell looking equally
+     * inactive to an assistive tech user.
+     */
+    getCurrentPage(): Promise<number>;
+    /**
+     * Click the cell for a page.
+     *
+     * Throws when that page is not on the strip — a seven-slot window over twenty
+     * pages simply has no cell for page 15, and a silent no-op there reads as
+     * "navigation is broken" three assertions later. Step with {@link next} /
+     * {@link previous}, or move the host's own `currentPage` model.
+     *
+     * A disabled pager is still clicked; the component's own guard is what refuses
+     * the move, so assert the page rather than assume it. Clicking the CURRENT page
+     * is a no-op by the same guard.
+     */
+    goToPage(page: number): Promise<void>;
+    /**
+     * Jump to page 1.
+     *
+     * There is no dedicated first / last control in this component; the window pins
+     * the first and last page to the ends of the strip instead, so these two click
+     * cells like any other page.
+     */
+    goToFirst(): Promise<void>;
+    /** Jump to the last page — the trailing cell, not the last one before a gap. */
+    goToLast(): Promise<void>;
+    /**
+     * Click the next-page control.
+     *
+     * Disabled on the last page, and a disabled `<wr-btn>` is still clicked here (see
+     * {@link goToPage}) — {@link isNextDisabled} is the question, this is the action.
+     */
+    next(): Promise<void>;
+    /** Click the previous-page control. Disabled on the first page. */
+    previous(): Promise<void>;
+    /**
+     * Whether the next-page control refuses the move — true on the last page, and
+     * true for every control while the pager is disabled.
+     *
+     * Answered by {@link WrButtonHarness}, which reads the `disabled` attribute first
+     * and `aria-disabled` second. A `<wr-btn>` element carries both: the attribute is
+     * inert on anything but a real `<button>`, which is why the component adds the
+     * ARIA state as well — so this is the accessible answer whichever branch supplies
+     * it.
+     */
+    isNextDisabled(): Promise<boolean>;
+    /** Whether the previous-page control refuses the move — true on the first page. */
+    isPreviousDisabled(): Promise<boolean>;
+    /** Whether the pager shows its "X–Y of Z" label (the `showTotal` input). */
+    hasTotal(): Promise<boolean>;
+    /**
+     * The total label exactly as rendered, e.g. `1-10 of 95`.
+     *
+     * Both halves are localizable — the word between range and total comes from
+     * `ofLabel` or the `pagination.of` catalog entry — so a spec asserting the whole
+     * string should own the copy it asserts.
+     *
+     * Throws when the label is not rendered, which is a `showTotal` that was never
+     * set rather than a total of zero (a zero total still renders `0-0 of 0`).
+     */
+    getTotalText(): Promise<string>;
+    /** Whether the pager renders its page-size changer (the `showSizeChanger` input). */
+    hasPageSizeChanger(): Promise<boolean>;
+    /**
+     * The page-size changer as a {@link WrSelectHarness} — for anything this harness
+     * does not wrap: the offered labels, the open state, keyboard driving.
+     *
+     * Composed rather than re-queried on purpose: the changer is a real
+     * `<wr-select>`, its options live in the overlay container rather than inside the
+     * pager, and the select harness is the thing that already knows how to scope them
+     * to their own trigger.
+     *
+     * Throws when there is no changer — an `undefined` here would turn into a
+     * confusing failure inside a select call.
+     */
+    getPageSizeSelect(): Promise<WrSelectHarness>;
+    /**
+     * The page size currently in effect.
+     *
+     * The changer's trigger is the only place the size reaches the DOM, so this reads
+     * it there and takes the digits: the label is localizable (`pagination.perPage`,
+     * `{{size}} / page`) but interpolates the number in every language — unless a
+     * catalog entry drops the placeholder, which is the second throw below.
+     *
+     * Throws when there is no changer at all: a pager without one says nothing on
+     * screen about its page size, and the host's own model is where to assert it.
+     */
+    getPageSize(): Promise<number>;
+    /**
+     * Pick a page size through the changer, the way a user does.
+     *
+     * Matched on the digits rather than the whole label, for the same reason
+     * {@link getPageSize} reads them: `20 / page` and `20 / стр.` are the same option.
+     * Throws when no option offers that size, naming what is on offer.
+     *
+     * Changing the size can move the page — the component pulls `currentPage` back
+     * when the new size leaves it past the end — so re-read {@link getCurrentPage}
+     * afterwards rather than assuming it held.
+     */
+    setPageSize(size: number): Promise<void>;
+    /** The current page, or `null` when no cell announces one. @see getCurrentPage */
+    private currentPageOrNull;
+    private stepControl;
+}
+
+export { WrPaginationHarness };
+export type { WrPaginationHarnessFilters };

package/types/ngwr-pagination.d.ts

@@ -128,6 +128,7 @@ declare class WrPagination {
      * untyped and is narrowed here. It used to arrive as `any` through
      * `[ngModel]`, which hid the coercion rather than removing the need for it.
      */
+    constructor();
     protected onSizeChange(size: unknown): void;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<WrPagination, never>;
     static ɵcmp: _angular_core.ɵɵComponentDeclaration<WrPagination, "wr-pagination", never, { "currentPage": { "alias": "currentPage"; "required": false; "isSignal": true; }; "pageSize": { "alias": "pageSize"; "required": false; "isSignal": true; }; "total": { "alias": "total"; "required": false; "isSignal": true; }; "pageSizeOptions": { "alias": "pageSizeOptions"; "required": false; "isSignal": true; }; "showSizeChanger": { "alias": "showSizeChanger"; "required": false; "isSignal": true; }; "showTotal": { "alias": "showTotal"; "required": false; "isSignal": true; }; "align": { "alias": "align"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "shape": { "alias": "shape"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "responsive": { "alias": "responsive"; "required": false; "isSignal": true; }; "ofLabel": { "alias": "ofLabel"; "required": false; "isSignal": true; }; "prevLabel": { "alias": "prevLabel"; "required": false; "isSignal": true; }; "nextLabel": { "alias": "nextLabel"; "required": false; "isSignal": true; }; "itemsPerPageLabel": { "alias": "itemsPerPageLabel"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; }, { "currentPage": "currentPageChange"; "pageSize": "pageSizeChange"; }, never, never, true, never>;

package/types/ngwr-popconfirm-testing.d.ts

@@ -0,0 +1,235 @@
+import { BaseHarnessFilters, ContentContainerComponentHarness, HarnessPredicate, HarnessLoader } from '@angular/cdk/testing';
+import { WrPopconfirmPosition } from 'ngwr/popconfirm';
+import { WrColor } from 'ngwr/theme';
+
+/**
+ * @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
+ */
+
+/** Narrows which `[wrPopconfirm]` trigger a harness query matches. */
+interface WrPopconfirmHarnessFilters extends BaseHarnessFilters {
+    /**
+     * Match the trigger's own visible text — the label of the button the directive
+     * sits on, not the question in the panel. A string is an exact match, a RegExp
+     * is tested.
+     */
+    readonly triggerText?: string | RegExp;
+    /** Match only open (`true`) or only closed (`false`) popconfirms. */
+    readonly open?: boolean;
+}
+
+/**
+ * @license
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://github.com/thekhegay/ngwr/blob/main/LICENSE
+ */
+
+/**
+ * Test harness for `[wrPopconfirm]` — the "are you sure?" dialog anchored to its
+ * trigger.
+ *
+ * The panel is NOT inside the trigger: it is a component portal in the overlay
+ * container, a sibling of the whole app. So everything about it is reached
+ * through the document root, scoped by the `aria-controls` id the trigger
+ * publishes while the dialog is showing — which is what keeps two popconfirms
+ * from reading each other's question, and why every panel reader throws while the
+ * dialog is shut: there is no element to answer about.
+ *
+ * **The two actions are told apart by their own modifiers**, never by position.
+ * `.wr-popconfirm__action--cancel` and `--confirm` are what `cancel()` and
+ * `confirm()` click, so a template that ever reorders the pair cannot silently
+ * turn a spec's "cancel" into a delete.
+ *
+ * Being a CONTENT CONTAINER means a consumer's own harnesses resolve INSIDE this
+ * instance's panel — `popconfirm.getHarness(WrButtonHarness…)` reaches the
+ * buttons without the spec ever naming the overlay.
+ *
+ * @example
+ * ```ts
+ * const loader = TestbedHarnessEnvironment.loader(fixture);
+ * const remove = await loader.getHarness(WrPopconfirmHarness.with({ triggerText: 'Delete' }));
+ *
+ * await remove.open();
+ * expect(await remove.getMessage()).toBe('Delete this item?');
+ * await remove.confirm();
+ * ```
+ *
+ * @see https://ngwr.dev/guides/testing
+ */
+declare class WrPopconfirmHarness extends ContentContainerComponentHarness {
+    /**
+     * The directive's host — whatever element the consumer put `[wrPopconfirm]` on.
+     *
+     * Matched by the marker class, not by `[wrPopconfirm]`: the question is normally
+     * BOUND (`[wrPopconfirm]="question"`), and a property binding leaves no
+     * attribute in the DOM at all. Same shape as `.wr-popover-trigger` and
+     * `.wr-dropdown-trigger`.
+     */
+    static hostSelector: string;
+    /** Build a predicate that narrows the query — pass to `getHarness` / `getAllHarnesses`. */
+    static with(options?: WrPopconfirmHarnessFilters): HarnessPredicate<WrPopconfirmHarness>;
+    /** The trigger's own visible label. The question inside the panel is `getMessage()`. */
+    getTriggerText(): Promise<string>;
+    /**
+     * Whether the dialog is showing.
+     *
+     * Read from `aria-expanded` rather than from a class, because that is the whole
+     * of what the trigger tells a screen reader — the directive puts no state class
+     * on its host at all.
+     */
+    isOpen(): Promise<boolean>;
+    /** Whether the trigger currently has keyboard focus — the state it is handed back on close. */
+    isTriggerFocused(): Promise<boolean>;
+    /**
+     * Press the trigger to open the dialog.
+     *
+     * Throws when nothing opens, because the reason is always worth failing on: a
+     * native `<button disabled>` trigger never receives the click at all. (A
+     * DISABLED `<wr-btn>` is a jsdom blind spot in the other direction — it is kept
+     * inert by `pointer-events: none`, which jsdom does not apply, so it opens here
+     * and would not in a browser.)
+     */
+    open(): Promise<void>;
+    /**
+     * Press the trigger again to take the question back.
+     *
+     * This is the ONE way out that answers nothing: the directive treats a second
+     * press as withdrawing the question, so `cancelled` does NOT fire — unlike
+     * `cancel()`, `sendEscape()` and `clickOutside()`, which all emit it. Use this
+     * when a spec needs the panel gone without recording an answer.
+     */
+    close(): Promise<void>;
+    /** The question being asked. */
+    getMessage(): Promise<string>;
+    /**
+     * The confirm button's label.
+     *
+     * Resolved, not given: `confirmText` falls back to the `popconfirm.confirm`
+     * catalog entry, so a localized app reads its own word here and a spec that
+     * asserted the English default would be asserting the wrong thing.
+     */
+    getConfirmText(): Promise<string>;
+    /** The cancel button's label — `cancelText`, or the `popconfirm.cancel` catalog entry. */
+    getCancelText(): Promise<string>;
+    /**
+     * Both action labels in the order they are rendered: cancel first, confirm
+     * second.
+     *
+     * That order is deliberate and worth reading — the destructive choice is the one
+     * being confirmed, so the safe one comes first and takes the initial focus.
+     */
+    getActionLabels(): Promise<string[]>;
+    /**
+     * The confirm button's intent colour.
+     *
+     * Checked against `WR_COLORS` rather than pattern-matched out of the class list:
+     * `wr-btn--*` also spells the size, the shape and the icon position, so only the
+     * intent list can say which of them is a colour. Today `WrButton` happens to
+     * emit the colour first, so a first-match regex would agree — but that order is
+     * not a contract, and the same regex on a button with no colour answers `sm`.
+     * Never `null` in practice — `confirmColor` defaults to `primary` — but typed
+     * for it, since the button itself allows no colour at all.
+     */
+    getConfirmColor(): Promise<WrColor | null>;
+    /** Which action holds keyboard focus, by label, or `null` when focus is elsewhere. */
+    getFocusedActionLabel(): Promise<string | null>;
+    /** Answer the question: click confirm, which emits `confirmed` and closes the dialog. */
+    confirm(): Promise<void>;
+    /** Decline: click cancel, which emits `cancelled` and closes the dialog. */
+    cancel(): Promise<void>;
+    /**
+     * Dismiss with Escape, which emits `cancelled`.
+     *
+     * Sent at the pane rather than at the focused button, because the target makes
+     * no difference: the key is picked up by the overlay's keyboard dispatcher,
+     * which keeps one listener on the document and routes to the topmost overlay.
+     * The pane is the one element guaranteed to be there.
+     */
+    sendEscape(): Promise<void>;
+    /**
+     * Dismiss by pressing outside the panel, which emits `cancelled`.
+     *
+     * The press lands on the overlay CONTAINER — an ancestor of the pane (the CDK
+     * puts a host `<div>` between the two), and so outside the panel by the only
+     * measure that matters here, since the dismissal is decided by whether the press
+     * started inside the pane. With two dialogs showing it dismisses BOTH: neither
+     * pane contains the container. jsdom has no layout
+     * and no `document.elementFromPoint`, so a harness cannot aim at "whatever is
+     * under the pointer"; to dismiss by pressing a specific element instead, click
+     * that element's own `TestElement`.
+     */
+    clickOutside(): Promise<void>;
+    /**
+     * The role the open panel announces — `'dialog'`.
+     *
+     * Worth asserting rather than assuming: the directive sets it on the OVERLAY
+     * PANE, not on the panel component a consumer can see in the template.
+     */
+    getRole(): Promise<string | null>;
+    /**
+     * The dialog's accessible name — the `ariaLabel` input, or the catalog's
+     * `popconfirm.label`.
+     *
+     * A `role="dialog"` with no name announces as a bare "dialog" and trips axe's
+     * `aria-dialog-name`, which is why there is always one.
+     */
+    getLabel(): Promise<string | null>;
+    /**
+     * Whether the dialog claims modality.
+     *
+     * `false`, deliberately, and worth pinning: focus is moved into the panel but
+     * NOT trapped, because Escape and an outside click both dismiss — trapping
+     * would only make it harder to leave.
+     */
+    isModal(): Promise<boolean>;
+    /**
+     * The text a screen reader reads as the dialog's DESCRIPTION, resolved through
+     * `aria-describedby` the way an assistive technology would.
+     *
+     * This is the question, and it is the entire content of a confirmation: without
+     * the link the dialog announces its name and then nothing at all.
+     */
+    getDescriptionText(): Promise<string | null>;
+    /**
+     * Which side of the trigger the panel is anchored to.
+     *
+     * The side that was ASKED for, read off the pane's public modifier class —
+     * `position` is an input, so a bound one never reaches the DOM, and the panel's
+     * own offset is a CDK inline style that says nothing in a layout-less jsdom.
+     * Not where the panel ended up: the position strategy is flexible and pushes,
+     * so a panel with no room on that side moves without the class changing.
+     */
+    getPosition(): Promise<WrPopconfirmPosition | null>;
+    /**
+     * Harnesses for anything inside the panel resolve within THIS instance's dialog.
+     *
+     * Scoped by the published id rather than by `.wr-popconfirm`: the overlay
+     * container is shared, so a class query would answer with whichever popconfirm
+     * opened first.
+     */
+    protected getRootHarnessLoader(): Promise<HarnessLoader>;
+    /**
+     * One of the two action buttons.
+     *
+     * By its own modifier class, never by index: both are a `<wr-btn size="sm">`, so
+     * before the modifiers existed the only thing telling them apart was document
+     * order — and a harness that clicked "the second button" would go on passing
+     * while it started confirming what a spec meant to cancel.
+     */
+    private action;
+    /** One element inside THIS instance's panel. */
+    private inPanel;
+    /** Every matching element inside THIS instance's panel, in document order. */
+    private allInPanel;
+    /** This instance's overlay pane — the element carrying the dialog semantics. */
+    private pane;
+    /** The id the trigger publishes for its dialog, which exists only while the dialog does. */
+    private panelId;
+}
+
+export { WrPopconfirmHarness };
+export type { WrPopconfirmHarnessFilters };

package/types/ngwr-popconfirm.d.ts

@@ -9,32 +9,25 @@ import * as _angular_core from '@angular/core';
 
 type WrPopconfirmPosition = 'top' | 'bottom' | 'left' | 'right';
 
-/**
- * Small "Are you sure?" panel anchored to its trigger. Fires `confirmed`
- * or `cancelled` and closes automatically. Built on CDK Overlay.
- *
- * @example
- * ```html
- * <wr-btn
- *   color="danger"
- *   [wrPopconfirm]="'Delete this item?'"
- *   confirmColor="danger"
- *   confirmText="Delete"
- *   (confirmed)="remove()"
- * >Delete</wr-btn>
- * ```
- *
- * @see https://ngwr.dev/reference/components/popconfirm
- */
 declare class WrPopconfirm {
     /** Confirmation message. */
     readonly message: _angular_core.InputSignal<string>;
     /** Anchor side. @default 'top' */
     readonly position: _angular_core.InputSignal<WrPopconfirmPosition>;
     /** Label for the confirm button. @default 'Confirm' */
-    readonly confirmText: _angular_core.InputSignal<string>;
+    /** Confirm button text. Falls back to `popconfirm.confirm`. */
+    readonly confirmText: _angular_core.InputSignal<string | null>;
     /** Label for the cancel button. @default 'Cancel' */
-    readonly cancelText: _angular_core.InputSignal<string>;
+    /** Cancel button text. Falls back to `popconfirm.cancel`. */
+    readonly cancelText: _angular_core.InputSignal<string | null>;
+    /**
+     * Accessible name of the confirmation dialog. `role="dialog"` with no name
+     * announces as a bare "dialog". Falls back to `popconfirm.label`.
+     */
+    readonly ariaLabel: _angular_core.InputSignal<string | null>;
+    private readonly resolvedConfirm;
+    private readonly resolvedCancel;
+    private readonly resolvedAriaLabel;
     /** Color of the confirm button. @default 'primary' */
     readonly confirmColor: _angular_core.InputSignal<"primary" | "secondary" | "success" | "warning" | "danger" | "info" | "light" | "medium" | "dark">;
     /** Fires when the user clicks confirm. */
@@ -43,11 +36,18 @@ declare class WrPopconfirm {
     readonly cancelled: _angular_core.OutputEmitterRef<void>;
     private readonly host;
     private readonly overlay;
+    private readonly dir;
     private readonly outsideClick;
     private readonly vcr;
     private readonly scrollStrategies;
     private readonly destroyRef;
+    /** @internal Public so the host bindings can read it. */
+    readonly isOpen: _angular_core.WritableSignal<boolean>;
     private overlayRef;
+    private readonly uid;
+    /** @internal Public so the host binding can read it. */
+    protected readonly panelId: string;
+    private readonly messageId;
     constructor();
     /** @internal */
     protected toggle(event: MouseEvent): void;
@@ -55,8 +55,16 @@ declare class WrPopconfirm {
     close(): void;
     private dismiss;
     private dispose;
+    /**
+     * Whether the app reads right-to-left.
+     *
+     * Optional inject: `Directionality` is root-provided, so this is never null in
+     * an app — but a bare `TestBed` that provides nothing should still get a
+     * component that works, and defaulting to LTR is the honest fallback.
+     */
+    private isRtl;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<WrPopconfirm, never>;
-    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<WrPopconfirm, "[wrPopconfirm]", never, { "message": { "alias": "wrPopconfirm"; "required": true; "isSignal": true; }; "position": { "alias": "position"; "required": false; "isSignal": true; }; "confirmText": { "alias": "confirmText"; "required": false; "isSignal": true; }; "cancelText": { "alias": "cancelText"; "required": false; "isSignal": true; }; "confirmColor": { "alias": "confirmColor"; "required": false; "isSignal": true; }; }, { "confirmed": "confirmed"; "cancelled": "cancelled"; }, never, never, true, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<WrPopconfirm, "[wrPopconfirm]", never, { "message": { "alias": "wrPopconfirm"; "required": true; "isSignal": true; }; "position": { "alias": "position"; "required": false; "isSignal": true; }; "confirmText": { "alias": "confirmText"; "required": false; "isSignal": true; }; "cancelText": { "alias": "cancelText"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; "confirmColor": { "alias": "confirmColor"; "required": false; "isSignal": true; }; }, { "confirmed": "confirmed"; "cancelled": "cancelled"; }, never, never, true, never>;
 }
 
 /**
@@ -67,13 +75,15 @@ declare class WrPopconfirm {
  */
 declare class WrPopconfirmPanel {
     readonly message: _angular_core.InputSignal<string>;
+    /** Id the anchoring directive points `aria-describedby` at. */
+    readonly messageId: _angular_core.InputSignal<string | null>;
     readonly confirmText: _angular_core.InputSignal<string>;
     readonly cancelText: _angular_core.InputSignal<string>;
     readonly confirmColor: _angular_core.InputSignal<"primary" | "secondary" | "success" | "warning" | "danger" | "info" | "light" | "medium" | "dark">;
     readonly confirmed: _angular_core.OutputEmitterRef<void>;
     readonly cancelled: _angular_core.OutputEmitterRef<void>;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<WrPopconfirmPanel, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<WrPopconfirmPanel, "wr-popconfirm", never, { "message": { "alias": "message"; "required": true; "isSignal": true; }; "confirmText": { "alias": "confirmText"; "required": false; "isSignal": true; }; "cancelText": { "alias": "cancelText"; "required": false; "isSignal": true; }; "confirmColor": { "alias": "confirmColor"; "required": false; "isSignal": true; }; }, { "confirmed": "confirmed"; "cancelled": "cancelled"; }, never, never, true, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<WrPopconfirmPanel, "wr-popconfirm", never, { "message": { "alias": "message"; "required": true; "isSignal": true; }; "messageId": { "alias": "messageId"; "required": false; "isSignal": true; }; "confirmText": { "alias": "confirmText"; "required": false; "isSignal": true; }; "cancelText": { "alias": "cancelText"; "required": false; "isSignal": true; }; "confirmColor": { "alias": "confirmColor"; "required": false; "isSignal": true; }; }, { "confirmed": "confirmed"; "cancelled": "cancelled"; }, never, never, true, never>;
 }
 
 export { WrPopconfirm, WrPopconfirmPanel };