ngwr 10.2.0 → 11.0.0

package/types/ngwr-transfer.d.ts

@@ -21,7 +21,15 @@ interface WrTransferItem<TValue = unknown> {
 /** A pane's rows plus the header state derived from them. */
 interface PaneState {
     readonly rows: readonly WrTransferItem[];
+    /**
+     * The staged values this pane is actually SHOWING — visible and enabled. The
+     * staging signals can hold more than that (a filter change hides rows without
+     * unstaging them), and every consumer of the staged set has to agree on which
+     * one it means: the count, the header checkbox and the move all read this.
+     */
+    readonly checked: readonly unknown[];
     readonly checkedCount: number;
+    readonly enabledCount: number;
     readonly allChecked: boolean;
     readonly someChecked: boolean;
 }
@@ -76,6 +84,11 @@ declare class WrTransfer implements FormValueControl<readonly unknown[]> {
     readonly searchPlaceholder: _angular_core.InputSignal<string | null>;
     /** Shown in a pane with no rows. Falls back to `transfer.empty`. */
     readonly emptyText: _angular_core.InputSignal<string | null>;
+    /**
+     * Accessible name of each pane's select-all checkbox, composed with the pane
+     * heading. Falls back to `transfer.selectAll`.
+     */
+    readonly selectAllLabel: _angular_core.InputSignal<string | null>;
     /** Accessible name of the move-right button. Falls back to `transfer.toTarget`. */
     readonly toTargetLabel: _angular_core.InputSignal<string | null>;
     /** Accessible name of the move-left button. Falls back to `transfer.toSource`. */
@@ -84,6 +97,7 @@ declare class WrTransfer implements FormValueControl<readonly unknown[]> {
     protected readonly resolvedTargetTitle: _angular_core.Signal<string>;
     protected readonly resolvedSearch: _angular_core.Signal<string>;
     protected readonly resolvedEmpty: _angular_core.Signal<string>;
+    protected readonly resolvedSelectAll: _angular_core.Signal<string>;
     protected readonly resolvedToTarget: _angular_core.Signal<string>;
     protected readonly resolvedToSource: _angular_core.Signal<string>;
     /** `{{checked}} / {{total}}` under each heading. @internal */
@@ -95,6 +109,7 @@ declare class WrTransfer implements FormValueControl<readonly unknown[]> {
     /** Staged rows, per pane. Cleared as soon as a move commits them. */
     private readonly sourceChecked;
     private readonly targetChecked;
+    private readonly selected;
     private readonly valueSet;
     protected readonly source: _angular_core.Signal<PaneState>;
     protected readonly target: _angular_core.Signal<PaneState>;
@@ -111,7 +126,7 @@ declare class WrTransfer implements FormValueControl<readonly unknown[]> {
     /** Filter, then derive the header state from what survived. */
     private pane;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<WrTransfer, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<WrTransfer, "wr-transfer", never, { "items": { "alias": "items"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "searchable": { "alias": "searchable"; "required": false; "isSignal": true; }; "sourceTitle": { "alias": "sourceTitle"; "required": false; "isSignal": true; }; "targetTitle": { "alias": "targetTitle"; "required": false; "isSignal": true; }; "searchPlaceholder": { "alias": "searchPlaceholder"; "required": false; "isSignal": true; }; "emptyText": { "alias": "emptyText"; "required": false; "isSignal": true; }; "toTargetLabel": { "alias": "toTargetLabel"; "required": false; "isSignal": true; }; "toSourceLabel": { "alias": "toSourceLabel"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; "touch": "touch"; }, never, never, true, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<WrTransfer, "wr-transfer", never, { "items": { "alias": "items"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "searchable": { "alias": "searchable"; "required": false; "isSignal": true; }; "sourceTitle": { "alias": "sourceTitle"; "required": false; "isSignal": true; }; "targetTitle": { "alias": "targetTitle"; "required": false; "isSignal": true; }; "searchPlaceholder": { "alias": "searchPlaceholder"; "required": false; "isSignal": true; }; "emptyText": { "alias": "emptyText"; "required": false; "isSignal": true; }; "selectAllLabel": { "alias": "selectAllLabel"; "required": false; "isSignal": true; }; "toTargetLabel": { "alias": "toTargetLabel"; "required": false; "isSignal": true; }; "toSourceLabel": { "alias": "toSourceLabel"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; "touch": "touch"; }, never, never, true, never>;
 }
 
 export { WrTransfer };

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

@@ -0,0 +1,501 @@
+import { BaseHarnessFilters, ComponentHarness, HarnessPredicate, ContentContainerComponentHarness, HarnessLoader } 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
+ */
+
+/** Narrows which `<wr-tree>` a harness query matches. */
+interface WrTreeHarnessFilters extends BaseHarnessFilters {
+    /**
+     * Match the trigger's selection text — the selected label, or the chip labels joined
+     * by `', '` (without the `+N more` count a `maxTagCount` adds); `''` while the
+     * placeholder is showing. A string is an exact match, a RegExp is tested. Only an
+     * `openOn="overlay"` tree has a trigger; an inline one never matches.
+     */
+    readonly text?: string | RegExp;
+    /**
+     * Match a tree that is SHOWING a node with this label — the readable way to tell
+     * two trees apart when neither has a trigger. A node inside a collapsed branch is
+     * not rendered and does not count, and neither does anything in an overlay tree
+     * whose panel is closed.
+     */
+    readonly nodeLabel?: string | RegExp;
+    /** Match only enabled (`false`) or only disabled (`true`) trees. */
+    readonly disabled?: boolean;
+    /**
+     * Match only open (`true`) or only closed (`false`) trees. An inline tree is
+     * always open — its rows are part of the host — so it only matches `true`.
+     */
+    readonly open?: boolean;
+}
+/** Narrows which node inside a tree a harness query matches. */
+interface WrTreeNodeHarnessFilters extends BaseHarnessFilters {
+    /** Match the node's label — a string is an exact match, a RegExp is tested. */
+    readonly label?: string | RegExp;
+    /** Match only selected (`true`) or only unselected (`false`) nodes. */
+    readonly selected?: boolean;
+    /**
+     * Match only enabled (`false`) or only disabled (`true`) nodes. Every node of a
+     * disabled TREE is disabled, so `false` matches nothing there.
+     */
+    readonly disabled?: boolean;
+    /**
+     * Match only open (`true`) or only closed (`false`) BRANCHES. A leaf announces no
+     * expanded state at all and matches neither — which is what makes
+     * `{ expanded: false }` mean "a branch waiting to be opened" rather than "every
+     * row that is not open".
+     */
+    readonly expanded?: boolean;
+    /** Match the node's 1-based `aria-level`, i.e. its depth in the tree. */
+    readonly level?: number;
+}
+
+/**
+ * @license
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://github.com/thekhegay/ngwr/blob/main/LICENSE
+ */
+
+/**
+ * Test harness for one node of a `<wr-tree>` — a `role="treeitem"` row.
+ *
+ * Everything about a tree's shape that a screen reader gets lives on these rows:
+ * the list itself is FLAT, with no `role="group"` and no nesting, so `aria-level`,
+ * `aria-posinset` and `aria-setsize` are the only place the hierarchy exists. The
+ * indent is decoration.
+ *
+ * @example
+ * ```ts
+ * const src = await tree.getNode({ label: 'src' });
+ *
+ * await src.expand();
+ * expect(await src.getLevel()).toBe(1);
+ * ```
+ *
+ * @see https://ngwr.dev/guides/testing
+ */
+declare class WrTreeNodeHarness extends ComponentHarness {
+    /**
+     * The row, and nothing else the list can hold.
+     *
+     * A windowed tree pads its list with `<li class="wr-tree__spacer" role="presentation">`
+     * at each end, so `li` would hand back up to two "nodes" with no label and no
+     * state. `[role="treeitem"]` selects exactly the same set as this class.
+     */
+    static hostSelector: string;
+    /** Build a predicate that narrows the query. */
+    static with(options?: WrTreeNodeHarnessFilters): HarnessPredicate<WrTreeNodeHarness>;
+    /**
+     * The node's label.
+     *
+     * Read from `.wr-tree__label` rather than from the row's text, so the answer stays
+     * the label alone however the row is decorated around it.
+     */
+    getLabel(): Promise<string>;
+    /** The node's 1-based depth, as the row announces it (`aria-level`). */
+    getLevel(): Promise<number>;
+    /**
+     * The node's 1-based position within its SIBLING GROUP (`aria-posinset`) — not its
+     * position in the flat list of visible rows.
+     *
+     * `src`'s first child is `posinset` 1 even though it is the second row on screen.
+     * That is what ARIA asks for, and the whole reason the attribute is needed here:
+     * the rendered list cannot express the nesting on its own.
+     */
+    getPosInSet(): Promise<number>;
+    /** How many nodes are in this node's sibling group, itself included (`aria-setsize`). */
+    getSetSize(): Promise<number>;
+    /**
+     * The node's index in the full list of VISIBLE nodes — every rendered row plus the
+     * ones a window left out, in the order the tree would show them.
+     *
+     * It is the index the tree's own keyboard code addresses rows by, and while the
+     * tree is windowed it is the only way to place a row: DOM order then says nothing,
+     * because the rows in the DOM are a slice.
+     */
+    getIndex(): Promise<number>;
+    /**
+     * The row's DOM id, or `null`.
+     *
+     * Only a windowed tree gives its rows ids, because that is the shape where the
+     * list keeps focus and names the cursor row with `aria-activedescendant` — the id
+     * exists to be pointed at.
+     */
+    getId(): Promise<string | null>;
+    /**
+     * Whether the node is a branch — it has children, whether or not they are showing.
+     *
+     * From `aria-expanded`: only a branch carries it, and a branch that does not is
+     * announced as a leaf, so the user never learns there is anything underneath. The
+     * toggle element cannot answer this — a leaf renders a `<span>` with the same
+     * `.wr-tree__toggle` class purely to hold the indent.
+     */
+    isExpandable(): Promise<boolean>;
+    /** Whether the branch is open. A leaf is never expanded. */
+    isExpanded(): Promise<boolean>;
+    /** Open the branch. Already-open branches are left alone; a leaf throws. */
+    expand(): Promise<void>;
+    /** Close the branch. Already-closed branches are left alone; a leaf throws. */
+    collapse(): Promise<void>;
+    /**
+     * Click the branch's expand toggle.
+     *
+     * Expanding is the TOGGLE's job and not the row's: a click anywhere else in the row
+     * selects instead, which is the one thing a spec driving this by hand tends to get
+     * wrong.
+     */
+    toggleExpand(): Promise<void>;
+    /**
+     * Whether the node is selected.
+     *
+     * From `aria-selected` rather than the `--selected` modifier: both are public, but
+     * the attribute is what a screen reader acts on, and a row that looks selected
+     * without saying so is the bug worth catching.
+     */
+    isSelected(): Promise<boolean>;
+    /**
+     * Whether the tree offers selection at all.
+     *
+     * A `selectionMode="none"` tree announces NO `aria-selected` on its rows, which is
+     * how an unselectable node differs from one that is merely unselected — the two
+     * look identical otherwise.
+     */
+    isSelectable(): Promise<boolean>;
+    /**
+     * Whether the node refuses interaction (`aria-disabled`).
+     *
+     * True for EVERY node while the whole tree is disabled, not just for the ones the
+     * data marks — the row announces the effective state, which is the one a user runs
+     * into.
+     */
+    isDisabled(): Promise<boolean>;
+    /**
+     * Whether the node is where the keyboard cursor sits.
+     *
+     * The two patterns publish the cursor differently, and this covers both: a tree
+     * that renders every row hands the single tab stop to the cursor row (roving
+     * tabindex), while a windowed one keeps focus on the list and marks the row with
+     * the `--active` modifier plus the list's `aria-activedescendant`.
+     * `WrTreeHarness.getActiveNodeLabel()` reads that reference itself.
+     */
+    isActive(): Promise<boolean>;
+    /**
+     * Whether the row holds real DOM focus.
+     *
+     * Deliberately separate from {@link isActive}: in a windowed tree the two DIVERGE
+     * by design — focus stays on the `role="tree"` list and only the announced cursor
+     * moves — so a spec asserting that a key press moved focus needs to know which of
+     * the two it is asking about.
+     */
+    isFocused(): Promise<boolean>;
+    /**
+     * Click the node — which SELECTS it. A disabled node, and any node of a
+     * `selectionMode="none"` tree, ignores the click.
+     *
+     * In multi mode a plain click REPLACES the selection rather than adding to it (the
+     * component's deliberate choice: one selected node clicked again clears it, and any
+     * other click starts over from that node). {@link ctrlClick} is how a selection is
+     * accumulated.
+     */
+    click(): Promise<void>;
+    /**
+     * Ctrl-click the node — ADDS it to the selection, or removes it, in multi mode.
+     *
+     * The component takes Cmd as well as Ctrl; the harness sends Ctrl because a unit
+     * test has no platform. In single mode it behaves exactly like {@link click}.
+     */
+    ctrlClick(): Promise<void>;
+    /** The branch's toggle button, or a failure that says this row is a leaf. */
+    private toggleElement;
+    /** A numeric attribute every row carries, or a failure that says the row is broken. */
+    private announcedNumber;
+}
+
+/**
+ * @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-tree>`, with {@link WrTreeNodeHarness} for one row.
+ *
+ * The component has two render shapes and this harness covers both:
+ * - `openOn="inline"` (default) — the rows live in the host, and the tree is always
+ *   showing them.
+ * - `openOn="overlay"` — a `role="combobox"` trigger opens a panel that is a template
+ *   portal in the shared overlay container, a sibling of the whole app. Nothing in it
+ *   is a descendant of the host, so every row is read through the document root,
+ *   SCOPED by the `aria-controls` id the trigger publishes — which is what keeps two
+ *   trees on one page from answering with each other's nodes.
+ *
+ * A tree is data-driven and projects nothing, so the scoped loader exists to point the
+ * node queries at the right shape rather than to reach a consumer's own components: the
+ * inherited `getHarness(…)` resolves wherever THIS tree's rows are, and there is nothing
+ * else in there.
+ *
+ * Two things the harness cannot do, both jsdom rather than the component:
+ * - it never clicks a row by coordinate, and it drives the cursor with the KEYBOARD,
+ *   which is the accessible path anyway. There is no layout in a unit test, so a
+ *   hit test would answer with nothing.
+ * - it offers no SCROLL for a windowed tree. jsdom does remember a `scrollTop` write,
+ *   but it fires no `scroll` event for it, so the tree — which learns its offset from
+ *   that event — would not move until the caller also dispatched one and waited a
+ *   frame: a scroll gesture that only works because the test faked the notification.
+ *   The keyboard moves the window honestly instead — see {@link focusLast}. (jsdom has
+ *   no `Element.scrollTo` at all, which the tree calls while windowed, so a spec for
+ *   that shape has to stub it.)
+ *
+ * @example
+ * ```ts
+ * const tree = await loader.getHarness(WrTreeHarness);
+ *
+ * await (await tree.getNode({ label: 'src' })).expand();
+ * await tree.selectNode({ label: 'main.ts' });
+ *
+ * expect(await tree.getSelectedLabels()).toEqual(['main.ts']);
+ * ```
+ *
+ * @see https://ngwr.dev/guides/testing
+ */
+declare class WrTreeHarness extends ContentContainerComponentHarness {
+    static hostSelector: string;
+    /** Build a predicate that narrows the query — pass to `getHarness` / `getAllHarnesses`. */
+    static with(options?: WrTreeHarnessFilters): HarnessPredicate<WrTreeHarness>;
+    /** Whether this tree is the combobox shape (`openOn="overlay"`) rather than inline. */
+    isOverlay(): Promise<boolean>;
+    /**
+     * Whether the rows are showing.
+     *
+     * From the trigger's `aria-expanded` rather than the `--open` modifier: both are
+     * public, but that attribute is the promise the combobox makes to a screen reader.
+     * An inline tree is always open — its rows are part of the host and there is
+     * nothing to open or close.
+     */
+    isOpen(): Promise<boolean>;
+    /**
+     * Open the panel. An already-open tree — and every inline one — is left alone.
+     *
+     * Note for a spec with two overlay trees: this clicks, and a click is an outside
+     * pointer event for every other open overlay, so it closes any panel already up.
+     * There is no second gesture to swap in: the trigger is opened by its `click`
+     * handler, and while a real keyboard user reaches that through a `<button>`'s native
+     * activation, a SYNTHETIC Enter / Space never produces a click — so a harness cannot
+     * open a panel any other way.
+     */
+    open(): Promise<void>;
+    /** Close the panel with Escape. An already-closed tree is left alone. */
+    close(): Promise<void>;
+    /**
+     * Whether the tree refuses interaction.
+     *
+     * The host modifier is the only answer both shapes carry: an inline tree has no
+     * control of its own to mark `disabled`, and a closed overlay tree has no rows to
+     * read `aria-disabled` from. The rows do announce it — see
+     * {@link WrTreeNodeHarness.isDisabled}.
+     */
+    isDisabled(): Promise<boolean>;
+    /**
+     * Whether the tree takes more than one selected node.
+     *
+     * From the list's `aria-multiselectable`, which is what a screen reader acts on. The
+     * list does not exist while an overlay panel is closed, so the host modifier answers
+     * then — it is only painted in the combobox shape, which is exactly the shape that
+     * can be asked while closed.
+     */
+    isMultiple(): Promise<boolean>;
+    /**
+     * How much the tree lets you select.
+     *
+     * `'none'` is not "nothing selected": it is a tree whose rows announce no
+     * `aria-selected` at all, and telling that from `'single'` needs a row — so an empty
+     * tree throws rather than guessing.
+     */
+    getSelectionMode(): Promise<'none' | 'single' | 'multi'>;
+    /**
+     * Whether the list is WINDOWED right now.
+     *
+     * Read from the list's modifier rather than from the input, and that is the point:
+     * `virtualScroll` only takes effect when there is something to window, so an empty
+     * tree renders the plain shape however the input is set.
+     */
+    isVirtual(): Promise<boolean>;
+    /**
+     * The role the list announces — `tree`.
+     *
+     * Worth asking: rendered without it, the rows are a bag of names, identical on
+     * screen and structureless to anyone not looking at it.
+     */
+    getRole(): Promise<string | null>;
+    /**
+     * What the trigger shows as the selection: the chip labels joined by `', '` in multi
+     * mode, the label in single mode, and `''` when nothing is selected (the placeholder
+     * is showing). The `+N more` chip a `maxTagCount` produces is NOT part of it — it is
+     * a count rather than a selection, and {@link getOverflowText} reads it. Inline trees
+     * have no trigger and throw.
+     */
+    getValueText(): Promise<string>;
+    /** The placeholder, or `null` when a selection is hiding it. */
+    getPlaceholder(): Promise<string | null>;
+    /**
+     * The chip labels on the trigger, in order (multi mode).
+     *
+     * The `+N more` overflow chip is not one of them — it is a count, not a selection.
+     * {@link getOverflowText} reads it.
+     */
+    getChipLabels(): Promise<string[]>;
+    /**
+     * The `+N more` chip's text, or `null` when every selected node has a chip of its
+     * own. Only a `maxTagCount` below the number selected produces one.
+     */
+    getOverflowText(): Promise<string | null>;
+    /** Remove one chip by its label. */
+    removeChip(label: string): Promise<void>;
+    /** Click the clear (×) control on the trigger. */
+    clear(): Promise<void>;
+    /**
+     * The nodes currently rendered, in the order they are shown.
+     *
+     * A collapsed branch's children are not rendered at all, so this is the VISIBLE
+     * tree — expand first to reach deeper.
+     *
+     * While {@link isVirtual} is true it is narrower still: the list holds only the
+     * window around the scroll offset — padded by a spacer at whichever end has rows
+     * outside it, so a window resting at the top has one and a window in the middle has
+     * two — and this returns the WINDOW, not the dataset. Nothing in the DOM carries a
+     * total —
+     * `aria-setsize` counts a SIBLING GROUP, not the flat list — so the harness cannot
+     * offer one; {@link WrTreeNodeHarness.getIndex} places each row in the full visible
+     * list, and the `[nodes]` data is where the total actually lives.
+     *
+     * Throws while an overlay panel is closed: the rows do not exist anywhere until it
+     * opens, and an empty array reads like a tree that rendered nothing.
+     */
+    getNodes(filters?: WrTreeNodeHarnessFilters): Promise<WrTreeNodeHarness[]>;
+    /** The labels of the nodes currently rendered, in order. */
+    getNodeLabels(): Promise<string[]>;
+    /** The first node matching the filters, or a failure that says what is showing. */
+    getNode(filters: WrTreeNodeHarnessFilters): Promise<WrTreeNodeHarness>;
+    /**
+     * Open the panel if needed, then select the first node matching the filters.
+     *
+     * `additive` ctrl-clicks instead, which is how a multi-mode selection is built up: a
+     * plain click there REPLACES the selection, by the component's own choice.
+     *
+     * Throws rather than clicking into the void on a disabled node or a
+     * `selectionMode="none"` tree — both ignore the click, and the silence turns into a
+     * confusing failure at the next assertion. Reach for `getNode().click()` when
+     * proving exactly that.
+     */
+    selectNode(filters: WrTreeNodeHarnessFilters, options?: {
+        additive?: boolean;
+    }): Promise<void>;
+    /**
+     * The labels of the selected nodes, in row order.
+     *
+     * Only among the rows that are RENDERED: a selected node inside a collapsed branch,
+     * or outside a window, is not here. The `[(selected)]` model is the whole set.
+     */
+    getSelectedLabels(): Promise<string[]>;
+    /**
+     * Open every branch, level by level — each pass reveals the next one down.
+     *
+     * Refuses on a windowed tree instead of half-doing it: only the window is rendered,
+     * so the branches outside it cannot be reached from the DOM at all. Write the
+     * `[(expanded)]` model there.
+     */
+    expandAll(): Promise<void>;
+    /**
+     * The label of the node the keyboard cursor is on, or `null`.
+     *
+     * Read the way the shape publishes it: a windowed tree keeps focus on the list and
+     * names the row with `aria-activedescendant` (which goes `null` while the cursor has
+     * been scrolled out of the window, so the reference never dangles at a row that was
+     * removed), while a plain one hands the single tab stop to the cursor row.
+     */
+    getActiveNodeLabel(): Promise<string | null>;
+    /** Move the cursor down one row — ArrowDown. Stops at the last row. */
+    focusNext(): Promise<void>;
+    /** Move the cursor up one row — ArrowUp. Stops at the first row. */
+    focusPrevious(): Promise<void>;
+    /** Move the cursor to the first row — Home. */
+    focusFirst(): Promise<void>;
+    /**
+     * Move the cursor to the last row — End.
+     *
+     * On a windowed tree this also moves the WINDOW: the tree writes its scroll offset
+     * synchronously so the row it is about to point at exists in the same change
+     * detection pass. It is the honest way to reach the far end of a window in a unit
+     * test — jsdom keeps a `scrollTop` write but never fires the `scroll` event the tree
+     * listens for, so a scroll gesture would move the window only for a test that also
+     * dispatched the notification itself.
+     */
+    focusLast(): Promise<void>;
+    /**
+     * ArrowRight on the cursor row — the APG's one key with two jobs: it OPENS a closed
+     * branch, and on an already-open one it steps into the first child. A leaf ignores
+     * it.
+     *
+     * These two send the PHYSICAL key, because that is what a keyboard has. Under
+     * `dir="rtl"` the tree follows the indent and swaps the pair, so a spec exercising
+     * an RTL tree opens with {@link collapseActive} and closes with this one. The
+     * names describe the LTR job, which is the one worth naming.
+     */
+    expandActive(): Promise<void>;
+    /**
+     * ArrowLeft on the cursor row — CLOSES an open branch, and on anything else steps
+     * out to the parent row. A root-level leaf ignores it.
+     *
+     * Physical, and mirrored by the component under `dir="rtl"` — see
+     * {@link expandActive}.
+     */
+    collapseActive(): Promise<void>;
+    /**
+     * Select the cursor row from the keyboard — Enter.
+     *
+     * `additive` holds Ctrl, the keyboard twin of {@link WrTreeNodeHarness.ctrlClick}:
+     * in multi mode a plain Enter replaces the selection, Ctrl-Enter adds to it. A
+     * disabled row is skipped by the component, silently — assert the model.
+     */
+    selectActive(options?: {
+        additive?: boolean;
+    }): Promise<void>;
+    /**
+     * The loader every node query runs through — the host inline, THIS tree's overlay
+     * panel otherwise.
+     *
+     * Scoped by the published panel id rather than by `.wr-tree-panel`: the overlay
+     * container is shared, so a bare class query would answer with whichever tree
+     * happened to open first.
+     */
+    protected getRootHarnessLoader(): Promise<HarnessLoader>;
+    /**
+     * Send a key to the `role="tree"` list.
+     *
+     * The list owns the keydown handler in both patterns — the roving-tabindex one
+     * focuses a row, whose event bubbles to exactly here — so this is the honest target
+     * either way, and the one that works when jsdom has left real focus on `<body>`.
+     */
+    private press;
+    /**
+     * The `<ul role="tree">` of THIS tree — in the host inline, in this tree's own
+     * overlay panel otherwise.
+     */
+    private list;
+    /** The combobox trigger, or a failure that says this tree renders inline. */
+    private trigger;
+    /** The id the trigger publishes as `aria-controls`, which its panel carries. */
+    private panelId;
+    /** The trigger's text for the `text` filter, or `null` for an inline tree (which never matches). */
+    private triggerTextIfAny;
+    /** The rendered labels for the `nodeLabel` filter — a closed tree matches nothing rather than failing. */
+    private nodeLabelsIfShowing;
+}
+
+export { WrTreeHarness, WrTreeNodeHarness };
+export type { WrTreeHarnessFilters, WrTreeNodeHarnessFilters };

package/types/ngwr-tree.d.ts

@@ -151,8 +151,27 @@ declare class WrTree<TId = string> implements FormValueControl<unknown> {
     private readonly scrollStrategies;
     private readonly destroyRef;
     private readonly platformId;
+    /**
+     * Ambient reading direction. Optional so a bare `TestBed` — or a consumer who
+     * never set a direction — needs no provider; `Directionality` is root-provided
+     * anyway, and a missing one simply reads as `ltr`.
+     *
+     * Read at keystroke time rather than cached, so a runtime `dir` flip needs no
+     * subscription to `change`.
+     */
+    private readonly dir;
     /** Currently focused row's index in the flattened visible list. */
     protected readonly focusedIndex: _angular_core.WritableSignal<number>;
+    /**
+     * The cursor as the DOM sees it, clamped to the list that exists RIGHT NOW.
+     *
+     * The raw index is only ever written when a row is focused, and nothing shrank
+     * it when the list did: collapsing a branch above the cursor left the index
+     * past the end, which gave the tree zero rows with `tabindex="0"` (no way back
+     * in with Tab) and made every arrow key a no-op, because `onKeydown` bails when
+     * `flat[i]` is undefined.
+     */
+    protected readonly cursorIndex: _angular_core.Signal<number>;
     /** Resolved ARIA labels — resolved once at construction, so a runtime locale switch needs a re-create. */
     protected readonly clearLabel: string;
     protected readonly expandLabel: string;
@@ -216,9 +235,23 @@ declare class WrTree<TId = string> implements FormValueControl<unknown> {
     private get listElement();
     /** Scroll flat index `i` just into view (sets the `scrollTop` signal synchronously). */
     private ensureVisible;
+    /** Whether this OPEN has already auto-expanded; reset when the panel closes. */
+    private didExpandAll;
     constructor();
     protected onRowClick(flat: FlatNode<TId>, event: MouseEvent): void;
     protected onToggleClick(node: WrTreeNode<TId>, event: MouseEvent): void;
+    /**
+     * Map a physical arrow onto the expand / collapse axis.
+     *
+     * The APG gives ArrowRight the job of opening a branch and ArrowLeft the job
+     * of closing it because the arrows follow the INDENT, and the indent grows
+     * rightward. Under `dir="rtl"` it grows leftward, so the two swap — without
+     * this an RTL user cannot open a node at all.
+     *
+     * Up / Down travel the block axis and Home / End name a semantic position
+     * (first / last), so all four are returned untouched in both directions.
+     */
+    private inlineKey;
     protected onKeydown(event: KeyboardEvent): void;
     protected onTriggerClick(): void;
     /** Trigger blur — mark the bound field touched. */

package/types/ngwr-version.d.ts

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

package/types/ngwr-virtual-scroll.d.ts

@@ -49,13 +49,25 @@ declare class WrVirtualScroll<T = unknown> {
     protected readonly rowTemplate: _angular_core.Signal<TemplateRef<any>>;
     protected readonly viewport: _angular_core.Signal<CdkVirtualScrollViewport>;
     protected readonly resolvedHeight: _angular_core.Signal<string>;
+    /**
+     * The two buffers, resolved as a PAIR. CDK requires `maxBufferPx >= minBufferPx` and
+     * throws `CDK virtual scroll: maxBufferPx must be greater than or equal to minBufferPx`
+     * outright otherwise — so resolving them independently meant that setting just one of
+     * them, the obvious thing to do, crashed the viewport on construction. Whichever a
+     * consumer gave is honoured and the other follows it.
+     */
+    private readonly buffers;
     protected readonly resolvedMinBuffer: _angular_core.Signal<number>;
     protected readonly resolvedMaxBuffer: _angular_core.Signal<number>;
     /** Scroll a specific index into view. Mirrors the CDK API. */
     scrollToIndex(index: number, behavior?: ScrollBehavior): void;
     /** Scroll to a pixel offset. */
     scrollToOffset(offset: number, behavior?: ScrollBehavior): void;
-    /** Manually trigger size recheck (e.g. after host resize outside ResizeObserver). */
+    /**
+     * Re-measure the viewport. CDK already watches the window with its `ViewportRuler`, so
+     * this is for a size change it cannot see — the host being resized by a layout the
+     * window never noticed, or a parent that was display:none until now.
+     */
     checkViewportSize(): void;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<WrVirtualScroll<any>, never>;
     static ɵcmp: _angular_core.ɵɵComponentDeclaration<WrVirtualScroll<any>, "wr-virtual-scroll", never, { "items": { "alias": "items"; "required": true; "isSignal": true; }; "itemSize": { "alias": "itemSize"; "required": false; "isSignal": true; }; "height": { "alias": "height"; "required": false; "isSignal": true; }; "minBufferPx": { "alias": "minBufferPx"; "required": false; "isSignal": true; }; "maxBufferPx": { "alias": "maxBufferPx"; "required": false; "isSignal": true; }; "trackBy": { "alias": "trackBy"; "required": false; "isSignal": true; }; }, {}, ["rowTemplate"], never, true, never>;