ngwr 14.7.0 → 14.9.0

package/types/ngwr-editor.d.ts

@@ -0,0 +1,449 @@
+import * as ngwr_form from 'ngwr/form';
+import { WrFormFieldContext } from 'ngwr/form';
+import * as _angular_core from '@angular/core';
+import { Signal } from '@angular/core';
+import { FormValueControl } from '@angular/forms/signals';
+
+/**
+ * @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
+ */
+/**
+ * What `<wr-editor>` reads from and writes into its `value` model.
+ *
+ * - `html` — an HTML string, parsed without executing anything and rebuilt from
+ *   the editor's own schema on the way out, so only what the schema allows comes
+ *   back. `''` for an empty document.
+ * - `markdown` — the dialect `ngwr/markdown` reads and `<wr-markdown>` renders,
+ *   written back by `serializeMarkdown`. Markdown has no underline, so the
+ *   underline tool and its shortcut are absent in this format. `''` for an empty
+ *   document.
+ * - `json` — the document as a {@link WrEditorJson} tree. `null` for an empty
+ *   document.
+ */
+type WrEditorFormat = 'html' | 'markdown' | 'json';
+
+/**
+ * @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
+ */
+/**
+ * One mark on a {@link WrEditorJson} node — `strong`, `em`, `underline`,
+ * `strike`, `code`, or `link` with `{ href, title }`.
+ */
+interface WrEditorMarkJson {
+    readonly type: string;
+    readonly attrs?: Readonly<Record<string, unknown>>;
+}
+/**
+ * The editor's document as plain data — the shape ProseMirror's `toJSON()`
+ * writes, declared here so no ProseMirror type reaches the public API.
+ *
+ * Nodes: `doc`, `paragraph`, `heading` (`level` 1–3), `blockquote`,
+ * `code_block` (`language`), `horizontal_rule`, `bullet_list` (`tight`),
+ * `ordered_list` (`order`, `tight`), `list_item` (`checked`: `true`, `false`
+ * or `null` for an ordinary item), `hard_break`, `image` (`src`, `alt`,
+ * `title`), `table`, `table_row`, `table_header` / `table_cell` (`align`) and
+ * `text`.
+ *
+ * A value bound in `json` format is VALIDATED, not trusted: an unknown node or
+ * mark, an attribute outside its allowed set, a content rule broken, or a link
+ * or image whose URL `safeMarkdownUrl` refuses, and the whole value is refused —
+ * the editor keeps what it had and warns in dev mode.
+ */
+interface WrEditorJson {
+    readonly type: string;
+    readonly attrs?: Readonly<Record<string, unknown>>;
+    readonly content?: readonly WrEditorJson[];
+    readonly marks?: readonly WrEditorMarkJson[];
+    readonly text?: string;
+}
+
+/**
+ * @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
+ */
+/**
+ * One entry of `<wr-editor>`'s `toolbar` input.
+ *
+ * - Marks: `bold`, `italic`, `underline` (absent in `markdown` format, which
+ *   cannot express it), `strike`, `code`.
+ * - Blocks: `paragraph`, `heading1`, `heading2`, `heading3`, `bulletList`,
+ *   `orderedList`, `blockquote`, `codeBlock`.
+ * - Inserts: `link` (opens the link panel), `horizontalRule`.
+ * - History: `undo`, `redo`.
+ * - `'|'` draws a separator between two groups.
+ */
+type WrEditorTool = 'bold' | 'italic' | 'underline' | 'strike' | 'code' | 'paragraph' | 'heading1' | 'heading2' | 'heading3' | 'bulletList' | 'orderedList' | 'blockquote' | 'codeBlock' | 'link' | 'horizontalRule' | 'undo' | 'redo' | '|';
+
+/**
+ * @license
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://github.com/thekhegay/ngwr/blob/main/LICENSE
+ */
+
+/**
+ * The `value` model of `<wr-editor>`: a string in `html` and `markdown` format,
+ * a {@link WrEditorJson} tree in `json` format.
+ *
+ * An empty document is written as `''` in the two string formats and as `null`
+ * in `json`, so a Signal Forms `required()` rule reports an empty editor as
+ * empty — `'<p></p>'` would be a non-empty string. `null` and `''` are both
+ * read as an empty document in every format.
+ */
+type WrEditorValue = string | WrEditorJson | null;
+
+/**
+ * @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
+ */
+
+/** Every tool but the separator. */
+type WrEditorCommandTool = Exclude<WrEditorTool, '|'>;
+
+/**
+ * The field the link panel's URL input belongs to — provided as `WR_FORM_FIELD`
+ * for the editor's whole subtree.
+ *
+ * It does two jobs at once. It is the SHIELD every composite control needs: the
+ * editor is the control a `<wr-form-field>` wraps, and without a nearer provider
+ * the `[wrInput]` in its link panel would adopt the outer field's id, take over
+ * its label and announce its error as its own. And it is the input's own field:
+ * `[wrInput]` binds `id`, `aria-invalid` and `aria-describedby` from whatever
+ * field it finds, so answering here is how a refused URL reaches a screen reader
+ * without binding attributes the directive already owns.
+ *
+ * @internal
+ */
+declare class WrEditorLinkField implements WrFormFieldContext {
+    private readonly id;
+    /** The URL just submitted was refused by the link policy. */
+    readonly invalid: _angular_core.WritableSignal<boolean>;
+    readonly controlId: _angular_core.Signal<string>;
+    readonly errorId: string;
+    readonly panelId: string;
+    readonly errorKeys: _angular_core.Signal<readonly string[]>;
+    readonly describedBy: _angular_core.Signal<string | null>;
+    readonly labelId: _angular_core.Signal<string | null>;
+    adoptControlId(): void;
+}
+
+/** One toolbar button's state at the current selection. */
+interface WrToolState {
+    readonly tool: WrEditorCommandTool;
+    readonly active: boolean;
+    readonly available: boolean;
+}
+/**
+ * Rich-text editor on ProseMirror, with a toolbar, a link panel, keyboard
+ * shortcuts and markdown-style block shortcuts (`# `, `> `, `- `, `1. `,
+ * ` ``` `).
+ *
+ * A signal-forms native control: it implements `FormValueControl<WrEditorValue>`,
+ * so `[formField]` binds straight to its `value` model — no
+ * `ControlValueAccessor` in between. `[(value)]` works standalone.
+ *
+ * The value is an HTML string, a markdown string or the document as JSON, chosen
+ * by `format`. Whatever arrives is treated as untrusted and rebuilt from the
+ * editor's schema, so only what the schema allows survives, and links and images
+ * go through `safeMarkdownUrl` in all three. A value the editor cannot read is
+ * refused — the document it already shows is kept, a warning names the reason in
+ * dev mode, and nothing is written back. Until a value it CAN read arrives the
+ * editor is read-only and carries `wr-editor--refused`: the model still holds the
+ * refused value, and an edit would write the document on screen over it.
+ *
+ * Headings stop at three levels: an h4–h6 read from HTML or markdown becomes an
+ * h3 rather than a paragraph. Underline exists in `html` and `json` only —
+ * markdown cannot spell it, so in that format the tool, the shortcut and the mark
+ * itself are absent.
+ *
+ * ProseMirror is an OPTIONAL peer dependency: only an app that imports
+ * `ngwr/editor` installs `prosemirror-model`, `-state`, `-view`, `-commands`,
+ * `-keymap`, `-history`, `-schema-list` and `-inputrules`.
+ *
+ * @example
+ * ```html
+ * <!-- signal forms -->
+ * <wr-editor format="markdown" placeholder="Describe the change" [formField]="form.body" />
+ *
+ * <!-- standalone two-way binding -->
+ * <wr-editor [(value)]="html" />
+ * ```
+ *
+ * @see https://ngwr.dev/reference/components/editor
+ */
+declare class WrEditor implements FormValueControl<WrEditorValue> {
+    /**
+     * The document. A string in `html` and `markdown` format, a
+     * {@link WrEditorJson} tree in `json`; `''` / `null` when nothing is written.
+     * Bound by `[formField]`, or two-way via `[(value)]`.
+     */
+    readonly value: _angular_core.ModelSignal<WrEditorValue>;
+    /** Emitted on blur so a bound field can mark itself touched. */
+    readonly touch: _angular_core.OutputEmitterRef<void>;
+    /**
+     * Disable the editor and its toolbar. Bound automatically from the field's
+     * disabled state when used with `[formField]`.
+     *
+     * @default false
+     */
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, any>;
+    /**
+     * Refuse edits while the text stays focusable, selectable and announced.
+     * Bound automatically from the field's readonly state when used with
+     * `[formField]`.
+     *
+     * The surface keeps its tab stop and reports `aria-readonly`; typing, paste,
+     * drop, the shortcuts and every toolbar command are refused. The toolbar goes
+     * inert, since none of its tools can apply.
+     *
+     * @default false
+     */
+    readonly readonly: _angular_core.InputSignalWithTransform<boolean, any>;
+    /**
+     * Hint shown while the document is empty, and exposed as `aria-placeholder`.
+     *
+     * @default ''
+     */
+    readonly placeholder: _angular_core.InputSignal<string>;
+    /**
+     * Accessible name of the text surface. Falls back to the surrounding
+     * `<wr-form-field>`'s label, then to `editor.label`.
+     */
+    readonly ariaLabel: _angular_core.InputSignal<string | null>;
+    /**
+     * What `value` holds — see {@link WrEditorFormat}. Unset, it falls back to
+     * `provideWrConfig({ editor: { format } })`. Changing it re-reads `value` in
+     * the new format.
+     *
+     * @default 'html'
+     */
+    readonly format: _angular_core.InputSignal<WrEditorFormat | null>;
+    protected readonly resolvedFormat: Signal<"html" | "markdown" | "json">;
+    /**
+     * The toolbar's tools, in order, with `'|'` between groups; `false` hides it.
+     * `underline` is left out in `markdown` format, which cannot store it.
+     *
+     * @default WR_EDITOR_TOOLBAR
+     */
+    readonly toolbar: _angular_core.InputSignal<false | readonly WrEditorTool[]>;
+    private readonly document;
+    private readonly injector;
+    private readonly destroyRef;
+    private readonly host;
+    private readonly platform;
+    private readonly isBrowser;
+    /**
+     * Ambient reading direction, read by the toolbar's arrow keys. Optional so a
+     * bare `TestBed` needs no provider; `null` means LTR.
+     */
+    private readonly dir;
+    /** @internal */
+    protected readonly linkField: WrEditorLinkField;
+    /** The surrounding `<wr-form-field>`'s error state, read past the editor's own shield. @internal */
+    protected readonly fieldAria: ngwr_form.WrFormFieldAria;
+    protected readonly resolvedAriaLabel: Signal<string>;
+    /**
+     * The field's label names the surface, when there is one — a
+     * `contenteditable` is not labelable, so the field's `<label for>` cannot
+     * reach it. An explicit `ariaLabel` still wins over both.
+     */
+    protected readonly labelledBy: Signal<string | null>;
+    /** `null` while the field's label carries the name. */
+    protected readonly accessibleName: Signal<string | null>;
+    protected readonly surfaceId: string;
+    /** ProseMirror owns the surface from here on; until then the preview stands in. */
+    protected readonly mounted: _angular_core.WritableSignal<boolean>;
+    protected readonly focused: _angular_core.WritableSignal<boolean>;
+    private readonly editorState;
+    /**
+     * Whether `value` holds something the editor could not read, so the document
+     * on screen is not the one the model holds — empty at mount, or the previous
+     * record after a write. Edits are refused until a readable value arrives:
+     * the first keystroke would otherwise replace the stored value with whatever
+     * is on screen, and the only sign of it was a dev-mode warning.
+     */
+    private readonly refused;
+    /** Read-only by the input, or because the value was refused. @internal */
+    protected readonly locked: Signal<boolean>;
+    /** Apple keyboards name the modifier ⌘. Read in the browser only — see `mount()`. */
+    private readonly apple;
+    private readonly surface;
+    private readonly toolButtons;
+    private readonly linkPopover;
+    private view;
+    /** The format the live document was read in, which is the format it is written in. */
+    private viewFormat;
+    /**
+     * The value the live document was last read from or written as. A write from
+     * outside that equals it is the document already on screen — an echo of the
+     * editor's own emit, or a consumer writing back what it was handed — and must
+     * neither re-parse nor reset the selection.
+     */
+    private lastSerialized;
+    private linkToSurface;
+    protected readonly toolbarLabel: Signal<string>;
+    protected readonly linkUrlLabel: Signal<string>;
+    protected readonly linkApplyLabel: Signal<string>;
+    protected readonly linkRemoveLabel: Signal<string>;
+    protected readonly linkInvalidLabel: Signal<string>;
+    protected readonly taskDoneLabel: Signal<string>;
+    protected readonly taskTodoLabel: Signal<string>;
+    private readonly keyCtrl;
+    private readonly keyShift;
+    private readonly keyAlt;
+    private readonly headingLabel;
+    private readonly shortcutLabel;
+    private readonly toolLabels;
+    /**
+     * The bound tools as drawn: underline dropped where the format cannot store
+     * it, and separators only BETWEEN two groups — a leading, trailing or doubled
+     * one would be left behind by that filter or by a hand-built list.
+     */
+    protected readonly tools: Signal<readonly WrEditorTool[]>;
+    /** The tools that are buttons, in order — what the roving tab stop moves over. */
+    private readonly buttons;
+    /** Each drawn entry's index among the buttons, `-1` for a separator. @internal */
+    protected readonly buttonIndex: Signal<number[]>;
+    private readonly commands;
+    /** Every button's pressed and available state at the current selection. @internal */
+    protected readonly toolStates: Signal<ReadonlyMap<WrEditorCommandTool, WrToolState>>;
+    private readonly rovingIndex;
+    /**
+     * The one button in the tab order. It follows the user, and moves off a tool
+     * that stopped applying so the toolbar never loses its tab stop — unless NO
+     * tool applies (read-only, disabled), where it stays put, because there is
+     * nothing to reach.
+     */
+    private readonly tabStop;
+    /** Whether the live document is empty — pre-mount, whether the value is. */
+    private readonly empty;
+    /** The task-item words, handed to ProseMirror through its node views. */
+    private readonly nodeViews;
+    protected readonly ariaPlaceholder: Signal<string | null>;
+    protected readonly linkDraft: _angular_core.WritableSignal<string>;
+    /** Whether the selection is in a link — what the panel's remove button needs. */
+    protected readonly linkActive: Signal<boolean>;
+    /**
+     * The value rendered by Angular until ProseMirror takes over: on the server,
+     * and for the first browser frame. Read from the doc JSON, so it shows exactly
+     * what the schema kept — the same sanitised document the editor will mount.
+     */
+    protected readonly preview: Signal<WrEditorJson | null>;
+    protected readonly classes: Signal<string>;
+    constructor();
+    /** Focus the text surface — what Signal Forms calls to focus this control. */
+    focus(options?: FocusOptions): void;
+    protected label(tool: WrEditorCommandTool): string;
+    protected icon(tool: WrEditorCommandTool): readonly string[];
+    protected isToggle(tool: WrEditorCommandTool): boolean;
+    /** The tooltip: the label, with the shortcut when the tool has one. */
+    protected tooltip(tool: WrEditorCommandTool): string;
+    /** `aria-keyshortcuts` — key names from the ARIA spec, never localised. */
+    protected keyShortcuts(tool: WrEditorCommandTool): string | null;
+    protected state(tool: WrEditorCommandTool): WrToolState | undefined;
+    /**
+     * A toolbar button was activated.
+     *
+     * By pointer, focus never left the text (`mousedown` is cancelled), so the
+     * caret is put back where the command left it. By keyboard, focus stays on the
+     * button, as the toolbar pattern asks — unless the tool no longer applies,
+     * which disables it: a disabled button drops its focus on `<body>`, so the text
+     * takes it first.
+     */
+    protected onToolClick(tool: WrEditorCommandTool, event: MouseEvent): void;
+    protected onToolFocus(index: number): void;
+    /** The APG toolbar keys: the arrows rove and wrap, Home and End jump. */
+    protected onToolbarKeydown(event: KeyboardEvent): void;
+    /** `touch` once focus leaves the whole control — not when it moves between its own parts. */
+    protected onFocusOut(event: FocusEvent): void;
+    protected onLinkOpened(): void;
+    protected onLinkClosed(): void;
+    protected onLinkInput(event: Event): void;
+    protected applyLink(event: Event): void;
+    protected removeLink(): void;
+    protected nodesOf(raw: unknown): readonly WrEditorJson[];
+    protected nodeOf(raw: unknown): WrEditorJson;
+    protected markAt(node: WrEditorJson, depth: number): WrEditorMarkJson | null;
+    protected attr(node: WrEditorJson | WrEditorMarkJson, name: string): unknown;
+    protected text(node: WrEditorJson | WrEditorMarkJson, name: string): string | null;
+    protected textOf(node: WrEditorJson): string;
+    /** Whether an edit may happen at all — not while read-only, disabled or refused. */
+    private canEdit;
+    private mount;
+    private createState;
+    private dispatch;
+    private emit;
+    /**
+     * Bring an outside write into the view.
+     *
+     * Compared as DOCUMENTS, never as strings: `<b>` comes back as `<strong>`, so a
+     * normalised string differs from what the consumer wrote while the documents
+     * are equal — and an equal document is left alone, selection and history
+     * included. A different one replaces the state wholesale, history with it,
+     * which is right for a form reset or a server load: undo back into content the
+     * app replaced would be wrong. The normalised form is never written back —
+     * that would mark the field dirty on load. A write that arrives mid-composition
+     * (IME) replaces the composition too: the model is the source of truth.
+     */
+    private sync;
+    /**
+     * A new format whose value could not be read: keep the document, moved into
+     * the new format's schema — markdown's lacks underline, so that mark is
+     * dropped on the way. What is written from here on is in the new format.
+     */
+    private switchFormat;
+    private replaceState;
+    private placeholderDecorations;
+    /**
+     * Mod-K opens the link panel. Its propagation stops here: `<wr-command-palette>`
+     * binds the same chord on the document, and `WrHotkey` deliberately does not
+     * skip an event another listener already handled.
+     */
+    private onSurfaceKeydown;
+    private focusLinkInput;
+    /**
+     * Focus left the link panel for somewhere outside the control — Tab, Shift+Tab,
+     * a click elsewhere. The panel is not a focus trap, and left open it stays
+     * anchored to a control the user has left, whose next close would then pull
+     * focus back into the text. Closed with focus left where it went.
+     */
+    private leaveLinkPanel;
+    /** Whether a node is part of this control: the host, or its link panel. */
+    private withinControl;
+    private inLinkPanel;
+    private warnRefused;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<WrEditor, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<WrEditor, "wr-editor", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "readonly": { "alias": "readonly"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; "format": { "alias": "format"; "required": false; "isSignal": true; }; "toolbar": { "alias": "toolbar"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; "touch": "touch"; }, never, never, true, never>;
+}
+
+/**
+ * @license
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://github.com/thekhegay/ngwr/blob/main/LICENSE
+ */
+
+/**
+ * The toolbar `<wr-editor>` draws when `toolbar` is not bound — every tool, in
+ * five groups. Exported so a toolbar can be built from it rather than retyped:
+ *
+ * ```ts
+ * readonly tools = WR_EDITOR_TOOLBAR.filter(tool => tool !== 'code');
+ * ```
+ *
+ * `underline` is dropped in `markdown` format whether it is listed or not.
+ */
+declare const WR_EDITOR_TOOLBAR: readonly WrEditorTool[];
+
+export { WR_EDITOR_TOOLBAR, WrEditor };
+export type { WrEditorFormat, WrEditorJson, WrEditorMarkJson, WrEditorTool, WrEditorValue };

package/types/ngwr-event-calendar.d.ts

@@ -126,6 +126,11 @@ interface DayCell {
 interface MonthWeek {
     readonly key: string;
     readonly days: readonly DayCell[];
+    /**
+     * How many lanes the row's chips fill. The chips are absolutely positioned,
+     * so this is the only way the row's height can know about them.
+     */
+    readonly lanes: number;
 }
 interface TimeCell {
     readonly key: string;
@@ -291,6 +296,8 @@ declare class WrEventCalendar {
         bands: readonly BandChip[];
     }[]>;
     protected readonly hasAllDay: _angular_core.Signal<boolean>;
+    /** Lanes the all-day band fills — it has no `maxLanes` cap, so its row has to grow instead. */
+    protected readonly allDayLanes: _angular_core.Signal<number>;
     protected readonly rows: _angular_core.Signal<readonly TimeRow[]>;
     protected step(direction: -1 | 1): void;
     protected goToday(): void;
@@ -323,6 +330,7 @@ declare class WrEventCalendar {
      * the cell can say how much it is hiding.
      */
     private bandLayout;
+    private laneCount;
     /**
      * Column layout inside one day: events that overlap in time share the width.
      * Clusters are built by a running high-water mark — a new cluster starts the

package/types/ngwr-form.d.ts

@@ -1,7 +1,6 @@
 import * as _angular_core from '@angular/core';
-import { InjectionToken, Signal, EnvironmentProviders } from '@angular/core';
-import * as _angular_forms from '@angular/forms';
-import { NgControl } from '@angular/forms';
+import { InjectionToken, Signal, AfterContentChecked, EnvironmentProviders } from '@angular/core';
+import { NgControl, ValidationErrors } from '@angular/forms';
 import * as _angular_forms_signals from '@angular/forms/signals';
 
 /**
@@ -153,7 +152,7 @@ declare class WrFormError {
  *
  * @see https://ngwr.dev/reference/components/form-field
  */
-declare class WrFormField implements WrFormFieldContext {
+declare class WrFormField implements WrFormFieldContext, AfterContentChecked {
     /** Label text shown above the control. */
     readonly label: _angular_core.InputSignal<string>;
     /** Hint text shown below the control. Hidden when an error is visible. */
@@ -205,10 +204,41 @@ declare class WrFormField implements WrFormFieldContext {
      * Angular does expose, so the computed depends on this counter instead.
      * Signal Forms needs none of this — its interop getters read live signals —
      * and harmlessly contributes no events.
+     *
+     * Events are not the whole story, which is what {@link ngAfterContentChecked} is for.
      */
     private readonly revision;
+    /** What the last check saw on a reactive control — see {@link ngAfterContentChecked}. */
+    private seen;
+    /**
+     * Catch the changes a reactive control makes WITHOUT an event.
+     *
+     * `updateValueAndValidity({ emitEvent: false })`, `markAsTouched({ emitEvent: false })`
+     * and their siblings change `errors`, `touched` and `dirty` and emit nothing, so the
+     * subscription above never hears them and the message stays whatever it was. That is
+     * not only an app's own silent write: Angular reports a custom control's PARSE errors
+     * to a `FormControl` exactly that way — a validator re-run with `emitEvent: false` —
+     * so a `wr-date-picker` refusing typed text made its control invalid while the field
+     * went on showing the message from before, or nothing — and a later pass of change
+     * detection did not help, because the message was memoised on a revision only events
+     * move.
+     *
+     * This runs whenever the view holding the field is checked, which is when the page
+     * around the control changes — for the date picker, the moment its refusal turns
+     * visible. It is `ngAfterContentChecked` and not `ngDoCheck` for an ordering reason
+     * read out of Angular's `refreshView`: check hooks run BEFORE the view's effects, and
+     * Angular's parse-error validator is re-run from an effect in that same view, so a
+     * `DoCheck` saw the errors one pass late and lost the message whenever nothing
+     * refreshed the view again. Content-checked hooks run after those effects and before
+     * the field's own bindings. Only a change moves the revision.
+     *
+     * Signal Forms' interop control is skipped: it is reactive already, and its `errors`
+     * getter builds a fresh object on every read, which a reference check would call a
+     * change on every pass — and re-resolve every message with it.
+     */
+    ngAfterContentChecked(): void;
     constructor();
-    protected readonly errors: _angular_core.Signal<_angular_forms.ValidationErrors | null>;
+    protected readonly errors: _angular_core.Signal<ValidationErrors | null>;
     protected readonly hasError: _angular_core.Signal<boolean>;
     /** @internal Read by the projected `<wr-form-error>` children to decide which of them renders. */
     readonly errorKeys: _angular_core.Signal<readonly string[]>;

package/types/ngwr-gauge.d.ts

@@ -1,3 +1,4 @@
+import * as ngwr_popover from 'ngwr/popover';
 import * as _angular_core from '@angular/core';
 
 /**
@@ -33,6 +34,12 @@ declare class WrGauge {
     /** Show the value text in the center. @default true */
     readonly showValue: _angular_core.InputSignalWithTransform<boolean, any>;
     readonly suffix: _angular_core.InputSignal<string>;
+    /**
+     * Show a tooltip with the reading on hover, named by `ariaLabel` when one is
+     * given. Pointer only — the meter announces the same reading. @default true
+     */
+    readonly tooltip: _angular_core.InputSignalWithTransform<boolean, any>;
+    private readonly surface;
     protected readonly cx = 50;
     protected readonly cy = 50;
     protected readonly radius: _angular_core.Signal<number>;
@@ -47,8 +54,20 @@ declare class WrGauge {
     protected readonly trackPath: _angular_core.Signal<string>;
     protected readonly valuePath: _angular_core.Signal<string>;
     protected readonly viewBox = "0 0 100 56";
+    /**
+     * The reading as the meter announces it — `aria-valuetext`, the number plus the
+     * suffix — so the tooltip, the printed value and a screen reader all say one
+     * thing.
+     */
+    protected readonly valueText: _angular_core.Signal<string>;
+    /**
+     * One tooltip, pointing at the top of the dial. The whole gauge is one section.
+     * The label is the `ariaLabel` input and not the catalog fallback, which names
+     * the kind of widget rather than the reading.
+     */
+    protected readonly tip: ngwr_popover.WrChartTooltip;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<WrGauge, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<WrGauge, "wr-gauge", never, { "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": true; "isSignal": true; }; "min": { "alias": "min"; "required": false; "isSignal": true; }; "max": { "alias": "max"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "strokeWidth": { "alias": "strokeWidth"; "required": false; "isSignal": true; }; "trackColor": { "alias": "trackColor"; "required": false; "isSignal": true; }; "valueColor": { "alias": "valueColor"; "required": false; "isSignal": true; }; "showValue": { "alias": "showValue"; "required": false; "isSignal": true; }; "suffix": { "alias": "suffix"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<WrGauge, "wr-gauge", never, { "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": true; "isSignal": true; }; "min": { "alias": "min"; "required": false; "isSignal": true; }; "max": { "alias": "max"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "strokeWidth": { "alias": "strokeWidth"; "required": false; "isSignal": true; }; "trackColor": { "alias": "trackColor"; "required": false; "isSignal": true; }; "valueColor": { "alias": "valueColor"; "required": false; "isSignal": true; }; "showValue": { "alias": "showValue"; "required": false; "isSignal": true; }; "suffix": { "alias": "suffix"; "required": false; "isSignal": true; }; "tooltip": { "alias": "tooltip"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 
 export { WrGauge };

package/types/ngwr-input-number.d.ts

@@ -124,6 +124,13 @@ declare class WrInputNumber implements FormValueControl<number | null> {
     protected readonly interactive: _angular_core.Signal<boolean>;
     protected readonly atMin: _angular_core.Signal<boolean>;
     protected readonly atMax: _angular_core.Signal<boolean>;
+    /**
+     * The size and pill modifiers mirror what is bound down to the chrome, because
+     * the stepper column belongs to neither half of it: the field carries
+     * `wr-input--<size>`, the column is its SIBLING, and the group carries no size
+     * at all. Without a modifier of its own the column drew one 10x6 chevron at
+     * every size and ran its dividers into a pill's rounded end.
+     */
     protected readonly classes: _angular_core.Signal<string>;
     /**
      * Fraction digits the stepper rounds its arithmetic to when `decimals` says

package/types/ngwr-line-chart.d.ts

@@ -44,6 +44,12 @@ declare class WrLineChart {
     readonly showLegend: _angular_core.InputSignalWithTransform<boolean, any>;
     /** Show dots at each data point. @default true */
     readonly showDots: _angular_core.InputSignalWithTransform<boolean, any>;
+    /**
+     * Show the hover readout: the crosshair, the point markers and the tooltip. Off
+     * drops all three, since a crosshair with no values beside it points at nothing.
+     * @default true
+     */
+    readonly tooltip: _angular_core.InputSignalWithTransform<boolean, any>;
     protected readonly vbW = 600;
     protected readonly vbH = 300;
     protected readonly padding: {
@@ -55,6 +61,8 @@ declare class WrLineChart {
     private readonly host;
     /** Hovered point index (across all series) — null when no hover. */
     protected readonly hoveredIndex: _angular_core.WritableSignal<number | null>;
+    /** The hovered index while the readout is on, so turning `tooltip` off mid-hover clears it. */
+    protected readonly activeIndex: _angular_core.Signal<number | null>;
     /**
      * A dash pattern per series, so the lines are told apart by SHAPE and not
      * only by hue.
@@ -140,7 +148,7 @@ declare class WrLineChart {
     protected readonly viewBox: _angular_core.Signal<string>;
     protected readonly hostEl: HTMLElement;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<WrLineChart, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<WrLineChart, "wr-line-chart", never, { "series": { "alias": "series"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; "xLabels": { "alias": "xLabels"; "required": false; "isSignal": true; }; "height": { "alias": "height"; "required": false; "isSignal": true; }; "showGrid": { "alias": "showGrid"; "required": false; "isSignal": true; }; "showLegend": { "alias": "showLegend"; "required": false; "isSignal": true; }; "showDots": { "alias": "showDots"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<WrLineChart, "wr-line-chart", never, { "series": { "alias": "series"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; "xLabels": { "alias": "xLabels"; "required": false; "isSignal": true; }; "height": { "alias": "height"; "required": false; "isSignal": true; }; "showGrid": { "alias": "showGrid"; "required": false; "isSignal": true; }; "showLegend": { "alias": "showLegend"; "required": false; "isSignal": true; }; "showDots": { "alias": "showDots"; "required": false; "isSignal": true; }; "tooltip": { "alias": "tooltip"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 
 export { WrLineChart };