ngwr 14.3.1 → 14.5.0

package/types/ngwr-tree.d.ts

@@ -186,7 +186,8 @@ declare class WrTree<TId = string> implements FormValueControl<unknown> {
      * 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`.
+     * subscription to `change` — the overlay is the half that does, and
+     * `wrFollowDirection` in `openOverlay()` is where that lives.
      */
     private readonly dir;
     /** Currently focused row's index in the flattened visible list. */
@@ -291,7 +292,48 @@ declare class WrTree<TId = string> implements FormValueControl<unknown> {
     protected onKeydown(event: KeyboardEvent): void;
     protected onTriggerClick(): void;
     /** Trigger blur — mark the bound field touched. */
+    /**
+     * Leaving an INLINE tree marks it touched.
+     *
+     * `onBlur` below belongs to the overlay trigger, which only renders under
+     * `openOn="overlay"` — so an inline tree emitted `touch` on SELECTION and
+     * nowhere else. Focusing it and walking away without choosing anything left
+     * the control neither touched nor dirty, which is exactly the state a
+     * `<wr-form-field>` waits for before it will show a message: a `required`
+     * tree the user considered and skipped stayed silent, and the form looked
+     * fine while being invalid.
+     *
+     * `relatedTarget` inside the host means focus only moved BETWEEN rows, which
+     * is not leaving. A `null` one — clicking the page background, or a browser
+     * that withholds it — counts as leaving, which is the safe direction: marking
+     * touched too eagerly shows a message the field already had grounds for.
+     */
+    protected onFocusOut(event: FocusEvent): void;
     protected onBlur(): void;
+    /**
+     * Backspace on the CLOSED overlay trigger — the keyboard twin of the two ×
+     * controls inside it.
+     *
+     * Both the clear × and every chip's remove × are `tabindex="-1"` spans inside
+     * this `<button>`, and they carried `(keydown.enter)` / `(keydown.space)`
+     * bindings that could never fire: a keydown goes to the focused element, and
+     * those spans cannot be focused. The spans stay unfocusable, since a focusable
+     * child of a button is `nested-interactive`.
+     *
+     * What that cost differs by mode, and the difference is worth keeping straight.
+     * In SINGLE mode it was a real WCAG 2.1.1 failure: Enter on the selected row
+     * re-selects it, so the × was the only way back to nothing. In MULTI mode it
+     * was not — Ctrl/Cmd+Enter on a row in the panel toggles it off, which is the
+     * route {@link WrTreeHarness.selectNode} drives with `additive`. The multi
+     * branch below is parity with `wr-select` and a shorter path, not a repair.
+     *
+     * The same key and the same split `wr-select` uses, so the two read alike:
+     * in MULTI mode Backspace drops the last chip — chip removal is its own
+     * control, not gated on `clearable()` — and in SINGLE mode it clears, gated on
+     * `clearable()`, because that input IS the clear control. Only while closed:
+     * an open panel owns the keyboard.
+     */
+    protected onTriggerKey(event: KeyboardEvent): void;
     protected removeChip(id: TId, event: Event): void;
     protected clearSelection(event: Event): void;
     private toggleExpanded;

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 = "14.3.1";
+declare const NGWR_VERSION = "14.5.0";
 
 /**
  * @license

package/types/ngwr-window.d.ts

@@ -376,6 +376,7 @@ declare class WrWindowManager {
     private readonly parentInjector;
     private readonly storage;
     private readonly isBrowser;
+    private readonly dir;
     private readonly baseZ;
     private topZ;
     private openCount;
@@ -467,7 +468,7 @@ declare class WrWindowManager {
     /** Drop a saved workspace. */
     clearLayout(name: string): void;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<WrWindowManager, never>;
-    static ɵprov: _angular_core.ɵɵInjectableDeclaration<WrWindowManager>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<any>;
 }
 
 /**

package/typography/styles/_index.scss

@@ -149,17 +149,39 @@
     }
   }
 
-  // Links — flowbite default: medium weight, brand color, underline on
-  // hover. Add your own `underline` class for the always-underlined look.
+  // Links are underlined ALWAYS, and the underline is the whole point rather
+  // than a style preference.
+  //
+  // WCAG technique G183 lets a link be marked by colour alone only when it
+  // clears 3:1 against the prose around it. `--wr-color-primary-ink` on
+  // `--wr-color-on-surface` measures 2.72:1 in LIGHT, so it never did — the
+  // underline was the missing half, and putting it on `:hover` gave it to a
+  // mouse and to nobody else. `ngwr/markdown` had this right all along, which
+  // made the library disagree with itself about its own links.
+  //
+  // The dark figure is deliberately not quoted here: `-ink` is a `color-mix`
+  // there, so it cannot be read off the source, and a hand-composited guess is
+  // the mistake `_colors.scss` already warns about. `check:contrast` measures
+  // it in a browser; the underline does not depend on the answer either way.
+  //
+  // Hover thickens rather than adds, so the interaction still answers. And the
+  // focus ring is here because it was nowhere: this variant is the one piece of
+  // typography that is reliably INTERACTIVE, and it had no `:focus-visible`
+  // rule at all, so a keyboard reached it and nothing on screen said so.
   &--link {
     font-weight: var(--wr-font-weight-medium);
     color: var(--wr-color-primary-ink);
-    text-decoration: none;
+    text-decoration: underline;
+    text-decoration-thickness: 1px;
     text-underline-offset: 2px;
     cursor: pointer;
 
     &:hover {
-      text-decoration: underline;
+      text-decoration-thickness: 2px;
+    }
+
+    &:focus-visible {
+      @include theme.focus-ring;
     }
   }