@cdevhub/ngx-tw 0.5.0 → 0.6.1

package/types/cdevhub-ngx-tw-sort.d.ts

@@ -49,13 +49,13 @@ declare class SortDirective {
     readonly active: _angular_core.ModelSignal<string | null>;
     /** Current sort direction. `null` represents the cleared state. Two-way bindable via `[(twSortDirection)]`. Defaults to `null`. */
     readonly direction: _angular_core.ModelSignal<SortDirection>;
-    /** Starting direction used when a header becomes active for the first time. Per-header `start` overrides this. Defaults to `'asc'`. */
+    /** Starting direction used when a header becomes active for the first time. Per-header `start` overrides this. Defaults to `'asc'`. Alias: `twSortStart`. */
     readonly start: _angular_core.InputSignal<"asc" | "desc">;
-    /** When true, the direction cycle skips the cleared (`null`) state — headers toggle between `'asc'` and `'desc'` only. Per-header `disableClear` overrides this. Defaults to `false`. */
+    /** When true, the direction cycle skips the cleared (`null`) state — headers toggle between `'asc'` and `'desc'` only. Per-header `disableClear` overrides this. Defaults to `false`. Alias: `twSortDisableClear`. */
     readonly disableClear: _angular_core.InputSignal<boolean>;
-    /** When true, all child sort headers are disabled. Defaults to `false`. */
+    /** When true, all child sort headers are disabled. Defaults to `false`. Alias: `twSortDisabled`. */
     readonly disabled: _angular_core.InputSignal<boolean>;
-    /** Fires whenever the user changes `active` or `direction` by interacting with a header. Programmatic writes to `[(twSortActive)]` / `[(twSortDirection)]` do NOT emit. */
+    /** Fires whenever the user changes `active` or `direction` by interacting with a header. Programmatic writes to `[(twSortActive)]` / `[(twSortDirection)]` do NOT emit. Alias: `twSortChange`. */
     readonly sortChange: _angular_core.OutputEmitterRef<TwSortEvent>;
     private readonly sortableIds;
     /** Registers a header id so duplicates can be detected. Called by `SortHeaderComponent` on init. Throws in dev mode if another header with the same id is already registered. */
@@ -76,6 +76,24 @@ type TwSortArrowPosition = 'before' | 'after';
  * Turns any element (e.g., `<th>`, `<div>`, `<button>`) into a sortable header under a parent
  * `SortDirective`. Renders the projected label plus an arrow that reflects the current direction.
  * Triggers a sort cycle on click or Enter/Space.
+ *
+ * @remarks
+ * **Where the control and `aria-sort` live depends on the host element.** Both are decided once,
+ * at construction, from the host's tag name and its *static* `role` attribute:
+ *
+ * | Host | `aria-sort` | Interactive element |
+ * |---|---|---|
+ * | `<th>` / `[role="columnheader"\|"rowheader"]` | on the host | inner container (`role="button"`) |
+ * | `<span>` / `<div>` (no role) | **not emitted** | inner container (`role="button"`) |
+ * | `<button>` / `<a href>` / `[role="button"\|"link"]` | **not emitted** | the host itself |
+ *
+ * `aria-sort` is only valid on a `columnheader` / `rowheader`, so emitting it on a `<span>` or
+ * `<button>` is an axe `aria-allowed-attr` failure and is silently ignored by assistive tech. When
+ * the header is composed *inside* a header cell — `<th><span tw-sort-header>…</span></th>`, the
+ * shape `tw-table` generates — the `<th>` owns `aria-sort` (see `tw-column`'s `sortState` input,
+ * which auto-resolves against the same `[twSort]` directive). Outside a table there is no
+ * `columnheader` to carry the state; the header remains a labelled button and the sort direction
+ * is conveyed by the arrow plus the consumer's own live region.
  */
 declare class SortHeaderComponent implements OnInit, AfterViewInit, OnDestroy {
     /** Unique id for this header. Required — identifies the field/column this header sorts. */
@@ -97,6 +115,15 @@ declare class SortHeaderComponent implements OnInit, AfterViewInit, OnDestroy {
     private readonly parent;
     private readonly focusMonitor;
     private readonly ariaDescriber;
+    private readonly hostEl;
+    /**
+     * Whether the host element can legally carry `aria-sort`. Resolved once, at construction — the
+     * host's tag name and static attributes are already applied by then, and a later `[attr.role]`
+     * binding would make this timing-dependent.
+     */
+    private readonly hostIsHeaderCell;
+    /** Whether the host is already a control, in which case the inner container must stay inert. */
+    private readonly hostIsControl;
     private readonly containerRef;
     private _describedBy;
     constructor();
@@ -108,8 +135,22 @@ declare class SortHeaderComponent implements OnInit, AfterViewInit, OnDestroy {
     readonly effectiveDirection: _angular_core.Signal<SortDirection>;
     /** `aria-sort` value: `'ascending' | 'descending' | 'none'`. */
     readonly ariaSort: _angular_core.Signal<"none" | "ascending" | "descending">;
+    /**
+     * @internal Value actually written to the host's `aria-sort` attribute. `null` — i.e. no
+     * attribute — unless the host is a `columnheader` / `rowheader`; see the class remarks.
+     */
+    readonly hostAriaSort: _angular_core.Signal<"none" | "ascending" | "descending" | null>;
+    /** @internal `role` for the inner container: `'button'` unless the host is already the control. */
+    readonly controlRole: _angular_core.Signal<"button" | null>;
+    /** @internal `tabindex` for the inner container. Mirrors `controlRole()`. */
+    readonly controlTabIndex: _angular_core.Signal<0 | null>;
     /** Whether the arrow element should render. Active headers always render; inactive render when not disabled so hover reveals the affordance. */
     readonly renderArrow: _angular_core.Signal<boolean>;
+    /**
+     * The element that carries focus and the accessible description — the host when the consumer
+     * mounted the header on a control, the inner container otherwise.
+     */
+    private controlElement;
     private readonly variantResult;
     /** @internal */
     readonly hostClasses: _angular_core.Signal<string>;

package/types/cdevhub-ngx-tw-split.d.ts

@@ -118,7 +118,7 @@ declare class SplitComponent {
     readonly direction: _angular_core.InputSignal<SplitDirection>;
     /** How sizes are expressed and reported. A single unit governs the whole container. Defaults to `'percent'`. */
     readonly unit: _angular_core.InputSignal<SplitUnit>;
-    /** Thickness of each gutter in pixels, perpendicular to the split axis. Defaults to `6`. */
+    /** Painted thickness of each gutter in pixels, perpendicular to the split axis, and the space it takes from the panes. The pointer target is padded out to a 24px minimum independently of this value (WCAG 2.2 SC 2.5.8), so a thin gutter stays thin without becoming hard to grab. Defaults to `6`. */
     readonly gutterSize: _angular_core.InputSignal<number>;
     /** When true, all resize interactions are disabled. Gutters are not focusable and do not respond to input. Defaults to `false`. */
     readonly disabled: _angular_core.InputSignal<boolean>;
@@ -168,7 +168,12 @@ declare class SplitComponent {
      * Pixel mode: values are absolute pixel sizes.
      */
     readonly _sizes: _angular_core.WritableSignal<number[]>;
-    /** Tracks the live `dir` attribute resolved through CDK Directionality. */
+    /**
+     * Live `dir` resolved through CDK `Directionality`. Read straight from
+     * `valueSignal` (CDK 22+) so `_isRtl` re-evaluates on a runtime `dir` flip
+     * with no manual subscription mirror. Falls back to 'ltr' when the consumer's
+     * injector cannot supply the token (`{ optional: true }`).
+     */
     private readonly _cdkDir;
     /** Resolves the effective RTL state: explicit `rtl` input overrides CDK `dir`. */
     readonly _isRtl: _angular_core.Signal<boolean>;
@@ -179,6 +184,31 @@ declare class SplitComponent {
     private readonly _classes;
     readonly _rootClass: _angular_core.Signal<string>;
     readonly _gutterClass: _angular_core.Signal<string>;
+    /**
+     * @internal
+     * Transparent padding added to each side of the gutter so its pointer target
+     * reaches the WCAG 2.2 SC 2.5.8 24x24 floor while the painted line stays
+     * `gutterSize` thick (the default gutter is 6px — a quarter of the floor).
+     *
+     * The padding is cancelled by an equal negative margin on the same side, so
+     * the gutter's *layout* footprint is still exactly `gutterSize` and the
+     * `availableSpace()` math is untouched; only its border box — which is what
+     * receives the pointer and what a target-size audit measures — grows. The
+     * overhang reaches `_gutterHitPad` px into each neighbouring pane and takes
+     * pointer events there (including over a pane's own scrollbar, if it has
+     * one); that is the accepted cost of the technique and mirrors how VS Code
+     * and every other thin-sash implementation reaches the floor.
+     *
+     * Zero once `gutterSize` is 24 or more — a gutter that already clears the
+     * floor needs no padding and no overhang.
+     */
+    readonly _gutterHitPad: _angular_core.Signal<number>;
+    /** @internal Horizontal half of `_gutterHitPad` — non-zero only for a horizontal split, where the gutter is thin across the X axis. Physical (not logical) properties: the padding is symmetric, so RTL needs no separate handling. */
+    readonly _gutterHitPadX: _angular_core.Signal<number>;
+    /** @internal Vertical half of `_gutterHitPad` — non-zero only for a vertical split. */
+    readonly _gutterHitPadY: _angular_core.Signal<number>;
+    /** @internal Gutter border-box thickness: `gutterSize` plus the SC 2.5.8 hit padding on both sides, i.e. `max(gutterSize, 24)`. The negative margins give back the padding, so the *layout* footprint stays `gutterSize`. */
+    readonly _gutterBoxPx: _angular_core.Signal<number>;
     /** Indices `0..panes.length - 2` representing the gutter between pane[i] and pane[i+1]. */
     readonly _gutterIndices: _angular_core.Signal<number[]>;
     /** @internal — drag state for the active pointer. */

package/types/cdevhub-ngx-tw-stat.d.ts

@@ -3,7 +3,14 @@ import { ElementRef } from '@angular/core';
 import { TwSize } from '@cdevhub/ngx-tw/core';
 
 /** Surface treatment for the stat tile. */
-type StatVariant = 'plain' | 'outlined' | 'elevated' | 'filled';
+type StatVariant = 'ghost' | 'outline' | 'elevated' | 'solid' | StatVariantLegacy;
+/**
+ * Legacy `variant` spellings, kept so existing templates keep compiling.
+ * @deprecated `'plain'` aliases `'ghost'`, `'outlined'` aliases `'outline'`
+ * and `'filled'` aliases `'solid'`. Each renders identically to its
+ * replacement and will be removed in the next major.
+ */
+type StatVariantLegacy = 'plain' | 'outlined' | 'filled';
 /** Direction of trend conveyed by the delta indicator. */
 type StatDeltaDirection = 'up' | 'down' | 'neutral';
 /** Display style of the trend delta. */
@@ -51,12 +58,13 @@ declare class StatDeltaComponent {
     readonly variant: _angular_core.InputSignal<StatDeltaVariant>;
     /** Optional comparison label rendered next to the delta value (e.g. `"vs last week"`, `"since launch"`). Defaults to `undefined`. */
     readonly comparisonLabel: _angular_core.InputSignal<string | undefined>;
-    /** Explicit accessible label. When omitted, the component composes one from `direction` + projected text + `comparisonLabel`. Override when projected content is purely symbolic or already localized. Defaults to `undefined`. */
+    /** Explicit accessible label, mirrored to `aria-label`. When omitted, the component composes one from `direction` + projected text + `comparisonLabel`. Override when projected content is purely symbolic or already localized. Defaults to `undefined`. */
     readonly ariaLabel: _angular_core.InputSignal<string | undefined>;
     /** @internal */
     protected readonly textEl: _angular_core.Signal<ElementRef<HTMLElement> | undefined>;
     /** @internal */
     protected readonly projectedText: _angular_core.WritableSignal<string>;
+    private readonly destroyRef;
     constructor();
     /** @internal */
     protected readonly effectiveColor: _angular_core.Signal<"neutral" | "success" | "error">;
@@ -70,7 +78,7 @@ declare class StatDeltaComponent {
     protected readonly textClasses: _angular_core.Signal<string>;
     protected readonly comparisonClasses: _angular_core.Signal<string>;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<StatDeltaComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StatDeltaComponent, "tw-stat-delta", never, { "direction": { "alias": "direction"; "required": false; "isSignal": true; }; "inverted": { "alias": "inverted"; "required": false; "isSignal": true; }; "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "comparisonLabel": { "alias": "comparisonLabel"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StatDeltaComponent, "tw-stat-delta", never, { "direction": { "alias": "direction"; "required": false; "isSignal": true; }; "inverted": { "alias": "inverted"; "required": false; "isSignal": true; }; "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "comparisonLabel": { "alias": "comparisonLabel"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "aria-label"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
 }
 /**
  * KPI tile — a compact display tile surfacing a single key performance
@@ -91,7 +99,7 @@ declare class StatDeltaComponent {
  * consumers can compose their own skeleton charts.
  */
 declare class StatComponent {
-    /** Surface treatment. `'plain'` removes border and background; `'outlined'` (default) adds a border on the surface token; `'elevated'` adds shadow and uses the raised surface; `'filled'` uses the muted surface with no border. */
+    /** Surface treatment. `'ghost'` removes border and background; `'outline'` (default) adds a border on the surface token; `'elevated'` adds shadow and uses the raised surface; `'solid'` uses the muted surface with no border. `'plain'`, `'outlined'` and `'filled'` are deprecated aliases for `'ghost'`, `'outline'` and `'solid'` and render identically. */
     readonly variant: _angular_core.InputSignal<StatVariant>;
     /** Density scale — drives padding, internal gaps, value/label typography, and the skeleton placeholder dimensions. Defaults to `'md'`. */
     readonly size: _angular_core.InputSignal<TwSize>;
@@ -120,6 +128,8 @@ declare class StatComponent {
     protected readonly loadingValueWidth: _angular_core.Signal<"4rem" | "5rem" | "6rem" | "8rem" | "10rem">;
     /** Skeleton height during loading state — matches the value font size. */
     protected readonly loadingValueHeight: _angular_core.Signal<"0.75rem" | "0.875rem" | "1rem">;
+    /** @internal Canonical variant with legacy spellings folded in. */
+    private readonly resolvedVariant;
     private readonly variantResult;
     protected readonly rootClasses: _angular_core.Signal<string>;
     protected readonly iconFlexClasses: _angular_core.Signal<string>;

package/types/cdevhub-ngx-tw-stepper.d.ts

@@ -50,9 +50,9 @@ declare class StepperComponent extends CdkStepper implements AfterViewInit {
     readonly color: _angular_core.InputSignal<TwColor>;
     /** Controls indicator size and label typography. Defaults to `'md'`. */
     readonly size: _angular_core.InputSignal<TwSize>;
-    /** When true, steps with `hasError` render error styling, icon, and `aria-invalid`. Defaults to `true`. */
+    /** When true, steps with `hasError` render error styling, icon, and `aria-invalid`. Defaults to `true` — error states must be visible by default, since silently swallowing a stepped flow's failure state is a UX regression; the special case is opting out per step. */
     readonly showError: _angular_core.InputSignal<boolean>;
-    /** When true, clicking a navigable step header selects it. Set to `false` to only allow advancement via `twStepperNext` / `twStepperPrevious`. Defaults to `true`. */
+    /** When true, clicking a navigable step header selects it. Set to `false` to only allow advancement via `twStepperNext` / `twStepperPrevious`. Defaults to `true` — free navigation is the standard stepper UX; the special case is a restricted flow such as a wizard that must complete in order. */
     readonly headerInteractive: _angular_core.InputSignal<boolean>;
     private readonly _liveAnnouncer;
     private readonly _destroyRef;
@@ -73,6 +73,19 @@ declare class StepperComponent extends CdkStepper implements AfterViewInit {
     readonly selectedIndexValue: _angular_core.Signal<number>;
     set orientation(value: StepperOrientation);
     get orientation(): StepperOrientation;
+    /** @internal Whether the header strip is exposed as a WAI-ARIA tablist. True for horizontal orientation only. */
+    readonly usesTabPattern: _angular_core.Signal<boolean>;
+    /** @internal Whether a step renders its panel inline beneath its own header (vertical orientation, selected step, step has content). */
+    hasInlinePanel(step: StepComponent, index: number): boolean;
+    /**
+     * @internal Id the step header's `aria-controls` points at, or `null`.
+     *
+     * Vertical headers only claim control of a panel that is actually in the
+     * DOM: an `aria-expanded="true"` button pointing at a missing id is an
+     * invalid reference, whereas the collapsed steps simply carry no
+     * `aria-controls` at all.
+     */
+    controlledPanelId(step: StepComponent, index: number): string | null;
     private readonly _variantResult;
     readonly rootClasses: _angular_core.Signal<string>;
     readonly headerClasses: _angular_core.Signal<string>;
@@ -134,6 +147,7 @@ declare class StepperComponent extends CdkStepper implements AfterViewInit {
     private syncFocusIndex;
     /** @internal Relays tablist keydown to CdkStepper, then republishes the tab stop. */
     onTablistKeydown(event: KeyboardEvent): void;
+    /** @internal Selects a step from a header click. Ignored when `headerInteractive` is false or the step is not navigable. */
     onHeaderClick(step: StepComponent, index: number): void;
     /** @internal Whether the stepper should render the error state for a step. */
     shouldRenderError(step: StepComponent): boolean;

package/types/cdevhub-ngx-tw-switch.d.ts

@@ -12,8 +12,19 @@ declare class SwitchComponent implements ControlValueAccessor, OnInit {
     readonly size: _angular_core.InputSignal<TwSize>;
     /** When true, prevents interaction and applies muted styling. Defaults to `false`. */
     readonly disabled: _angular_core.InputSignal<boolean>;
-    /** When true, sets `aria-required="true"` so assistive tech announces the control as required. Defaults to `false`. */
-    readonly required: _angular_core.InputSignal<boolean>;
+    /** When true, sets `aria-required="true"` so assistive tech announces the control as required. Also inferred from `Validators.required` / `Validators.requiredTrue` on a bound control, so a reactive/template-driven form does not have to state it twice. Defaults to `false`. */
+    readonly requiredInput: _angular_core.InputSignal<boolean>;
+    /**
+     * @internal Shared `errorState` / `required` / `errors` derivation — see
+     * `wireErrorState`. Declared here, above `required`, because class field
+     * initializers run in declaration order.
+     */
+    private readonly errorWiring;
+    /**
+     * @internal Resolved required state: the `required` input OR'd with
+     * `Validators.required` / `Validators.requiredTrue` on a bound `NgControl`.
+     */
+    readonly required: Signal<boolean>;
     /** Optional inline label rendered next to the switch. Use default content projection for rich label content instead. */
     readonly label: _angular_core.InputSignal<string | undefined>;
     /** Optional secondary description rendered under the label. Use `[slot="description"]` content projection for rich content instead. */
@@ -22,30 +33,41 @@ declare class SwitchComponent implements ControlValueAccessor, OnInit {
     readonly labelPosition: _angular_core.InputSignal<SwitchLabelPosition>;
     /** Optional name attribute, mirrored to the host for form association. */
     readonly name: _angular_core.InputSignal<string | undefined>;
-    /** Accessible name when no visible label is provided. Mirrored to `aria-label`. */
+    /** Accessible name when no visible label is provided. Mirrored to `aria-label`. Defaults to `undefined`. */
     readonly ariaLabel: _angular_core.InputSignal<string | undefined>;
-    /** ID of an external element that labels the switch. Mirrored to `aria-labelledby`. */
+    /** ID of an external element that labels the switch. Mirrored to `aria-labelledby`. Defaults to `undefined`. */
     readonly ariaLabelledby: _angular_core.InputSignal<string | undefined>;
-    /** ID of an external element that describes the switch. Mirrored to `aria-describedby`. */
+    /** ID of an external element that describes the switch. Mirrored to `aria-describedby`. Defaults to `undefined`. */
     readonly ariaDescribedby: _angular_core.InputSignal<string | undefined>;
-    /** Two-way bound checked state. Updates when the user toggles via click or Space. */
+    /**
+     * Two-way bound checked state. Updates when the user toggles via click or
+     * Space, **and** when a bound form writes into the control
+     * (`FormControl.setValue`, `ngModel`, `writeValue`). Defaults to `false`.
+     *
+     * The two-way binding mints a `checkedChange` output. That output is the
+     * *any-change* channel: it fires on programmatic writes as well as user
+     * gestures. `(change)` is the *user-gesture-only* channel. Bind
+     * `(checkedChange)` to mirror state; bind `(change)` for analytics or a
+     * confirmation prompt, where a programmatic write must not count as a click.
+     * Writing back into the same form from a `(checkedChange)` handler will echo.
+     */
     readonly checked: _angular_core.ModelSignal<boolean>;
     /** Per-instance override of the {@link ErrorStateMatcher}. When omitted, the switch uses the `TW_ERROR_STATE_MATCHER` token's value. */
     readonly errorStateMatcher: _angular_core.InputSignal<ErrorStateMatcher | undefined>;
-    /** Fires after the checked state changes from a user interaction. Does not fire when the value is updated programmatically via `writeValue`. */
+    /**
+     * Fires after the checked state changes from a user interaction (click or
+     * Space). Does **not** fire when the value is updated programmatically via
+     * `writeValue` / `FormControl.setValue` / `ngModel` — for those, bind the
+     * two-way binding's `(checkedChange)` instead, which fires on any change.
+     */
     readonly change: _angular_core.OutputEmitterRef<boolean>;
     private readonly focusMonitor;
     private readonly elementRef;
     private readonly destroyRef;
     private readonly ngControl;
-    private readonly parentForm;
-    private readonly parentFormGroup;
-    private readonly defaultMatcher;
     private onChange;
     private onTouched;
     private readonly cvaDisabled;
-    private readonly _ngControlRev;
-    private readonly _formSubmitRev;
     private readonly uid;
     readonly hostId: string;
     readonly labelId: string;
@@ -81,7 +103,7 @@ declare class SwitchComponent implements ControlValueAccessor, OnInit {
     ngOnInit(): void;
     private hasAccessibleNameHint;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<SwitchComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SwitchComponent, "tw-switch", never, { "color": { "alias": "color"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "required": { "alias": "required"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; "description": { "alias": "description"; "required": false; "isSignal": true; }; "labelPosition": { "alias": "labelPosition"; "required": false; "isSignal": true; }; "name": { "alias": "name"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "aria-label"; "required": false; "isSignal": true; }; "ariaLabelledby": { "alias": "aria-labelledby"; "required": false; "isSignal": true; }; "ariaDescribedby": { "alias": "aria-describedby"; "required": false; "isSignal": true; }; "checked": { "alias": "checked"; "required": false; "isSignal": true; }; "errorStateMatcher": { "alias": "errorStateMatcher"; "required": false; "isSignal": true; }; }, { "checked": "checkedChange"; "change": "change"; }, never, ["[slot='off-icon']", "[slot='on-icon']", "*", "[slot='description']"], true, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SwitchComponent, "tw-switch", never, { "color": { "alias": "color"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "requiredInput": { "alias": "required"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; "description": { "alias": "description"; "required": false; "isSignal": true; }; "labelPosition": { "alias": "labelPosition"; "required": false; "isSignal": true; }; "name": { "alias": "name"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "aria-label"; "required": false; "isSignal": true; }; "ariaLabelledby": { "alias": "aria-labelledby"; "required": false; "isSignal": true; }; "ariaDescribedby": { "alias": "aria-describedby"; "required": false; "isSignal": true; }; "checked": { "alias": "checked"; "required": false; "isSignal": true; }; "errorStateMatcher": { "alias": "errorStateMatcher"; "required": false; "isSignal": true; }; }, { "checked": "checkedChange"; "change": "change"; }, never, ["[slot='off-icon']", "[slot='on-icon']", "*", "[slot='description']"], true, never>;
 }
 
 export { SwitchComponent };

package/types/cdevhub-ngx-tw-tab-nav.d.ts

@@ -10,7 +10,7 @@ interface TabNavLabels {
     activeTabAnnouncement?: (label: string, index: number, total: number) => string;
 }
 declare class TabNavPanel {
-    /** Unique id for this panel. Referenced by the active link's `aria-controls`. Auto-generated when not provided. */
+    /** Unique id for this panel. Referenced by the active link's `aria-controls`. Defaults to an auto-generated `tw-tab-nav-panel-N` id. */
     readonly id: _angular_core.InputSignal<string>;
     /** @internal Id of the active link — set by the associated TabNavComponent. */
     readonly activeTabId: _angular_core.WritableSignal<string | undefined>;
@@ -30,9 +30,9 @@ declare class TabNavComponent {
     readonly tabPanel: _angular_core.InputSignal<TabNavPanel | undefined>;
     /** Additional classes merged onto the `<nav>` host. Useful for layout tweaks or borders that the default tv() config does not cover. */
     readonly navClass: _angular_core.InputSignal<string>;
-    /** Additional classes merged onto every tab link. Applied after base/active/disabled classes so consumer styles always win the cascade. */
+    /** Additional classes merged onto every tab link. Applied after base/active/disabled classes so consumer styles always win the cascade. Defaults to an empty string. */
     readonly linkClass: _angular_core.InputSignal<string>;
-    /** Optional label overrides for screen-reader announcements. Only used in the ARIA tabs pattern (i.e. when a panel is associated). */
+    /** Optional label overrides for screen-reader announcements. Only used in the ARIA tabs pattern (i.e. when a panel is associated). Defaults to an empty object — every field falls back to its own default. */
     readonly labels: _angular_core.InputSignal<TabNavLabels>;
     /** @internal Tab links discovered via content projection. */
     readonly links: _angular_core.Signal<readonly TabLinkDirective[]>;
@@ -42,11 +42,12 @@ declare class TabNavComponent {
     readonly resolvedPanel: _angular_core.Signal<TabNavPanel | undefined>;
     private readonly liveAnnouncer;
     private readonly directionality;
-    private readonly destroyRef;
     /**
      * Live layout direction. Hardcoding 'ltr' inverts ArrowLeft/ArrowRight in RTL
      * locales — the arrow moves to the next link in DOM order but the previous
-     * one visually. Mirrored into a signal so the key manager rebuilds on change.
+     * one visually. Read straight from CDK's `Directionality.valueSignal`
+     * (CDK 22+) so the key-manager effect rebuilds on a runtime `dir` flip with
+     * no manual subscription mirror.
      */
     private readonly layoutDirection;
     /** Tracks the previously-announced active link id so we only announce on actual changes. `null` = before the first sync. */
@@ -80,7 +81,7 @@ declare class TabLinkDirective {
     readonly active: _angular_core.InputSignal<boolean>;
     /** When true, the link is visually disabled and cannot be activated by click or keyboard. Defaults to `false`. */
     readonly disabled: _angular_core.InputSignal<boolean>;
-    /** Unique id for this link. Referenced by the panel's `aria-labelledby` when the link is active. Auto-generated when not provided. */
+    /** Unique id for this link. Referenced by the panel's `aria-labelledby` when the link is active. Defaults to an auto-generated `tw-tab-link-N` id. */
     readonly linkId: _angular_core.InputSignal<string>;
     /**
      * @internal ARIA role — `'tab'` when the nav is wired to a panel (APG

package/types/cdevhub-ngx-tw-table.d.ts

@@ -87,6 +87,18 @@ interface TwTableLabels {
     collapseRowLabel: string;
     /** Accessible label for the master "select all" checkbox in the leading selection column. */
     selectAllLabel: string;
+    /**
+     * Accessible name for the leading selection column's header cell, used when no master checkbox
+     * can be rendered (non-array data sources). Without it the `<th>` is literally empty, which is an
+     * axe `empty-table-header` failure and leaves the column unnamed in a screen reader's table
+     * summary. Rendered visually hidden.
+     *
+     * Optional on purpose: added after the interface shipped, so a required
+     * member would be a compile break for any consumer annotating a complete
+     * `TwTableLabels` literal — in exchange for a label that already has a
+     * sensible default. The component merges against `DEFAULT_TABLE_LABELS`.
+     */
+    selectionColumnLabel?: string;
     /** Accessible label template for each per-row selection checkbox. Variable: `{index}` (1-based). */
     selectRowLabel: string;
 }
@@ -171,8 +183,11 @@ interface TwRowClickEvent<T> {
     row: T;
     /** Zero-based index in the rendered data. */
     index: number;
-    /** The original DOM event. */
-    event: MouseEvent;
+    /**
+     * The original DOM event. A `MouseEvent` for pointer activation, or a `KeyboardEvent` when the
+     * row was activated with Enter / Space (only possible when `clickableRows` is `true`).
+     */
+    event: MouseEvent | KeyboardEvent;
 }
 /** Payload emitted by `selectionChange`. */
 interface TwSelectionChangeEvent<T> {
@@ -228,7 +243,7 @@ declare class NoDataRowDirective extends CdkNoDataRow {
 }
 /** Structural directive on an `<ng-template>` declaring the row-expansion template. Requires `[multiTemplateRows]="true"` on the parent `<tw-table>`. */
 declare class RowExpansionDirective<T = unknown> {
-    /** Optional predicate that decides whether this expansion renders for a given row. Defaults to `undefined` (render for every expanded row). */
+    /** Optional predicate that decides whether this expansion renders for a given row. Defaults to `undefined` (render for every expanded row). Alias: `twRowExpansionWhen`. */
     readonly predicate: _angular_core.InputSignal<((row: T, index: number) => boolean) | undefined>;
     /** @internal */
     readonly template: TemplateRef<any>;
@@ -347,15 +362,22 @@ declare class TableComponent<T = unknown> {
     readonly selection: _angular_core.InputSignal<TwTableSelection>;
     /** Whether multiple row templates may render per data object. Required for `*twRowExpansion` and advanced `*twRowDef [when]` usage. Defaults to `false`. */
     readonly multiTemplateRows: _angular_core.InputSignal<boolean>;
+    /**
+     * Whether data rows are activatable. Set this whenever you bind `(rowClicked)` — it is what puts
+     * each row in the tab order, wires Enter / Space to the same handler as a click, and paints the
+     * focus ring. Left `false`, `(rowClicked)` stays pointer-only, which keeps a static table out of
+     * the tab order. Defaults to `false`.
+     */
+    readonly clickableRows: _angular_core.InputSignal<boolean>;
     /** Overrides for user-facing strings. Unset keys fall back to the English defaults. Defaults to `{}`. */
     readonly labels: _angular_core.InputSignal<Partial<TwTableLabels>>;
-    /** Accessible name for the `<table>`. Required when no visible `<caption slot="caption">` is provided. */
+    /** Accessible name for the `<table>`. Required when no visible `<caption slot="caption">` is provided. Defaults to `undefined`. Alias: `aria-label`. */
     readonly ariaLabel: _angular_core.InputSignal<string | undefined>;
-    /** Id of an external element labelling the table. Mirrored to `aria-labelledby` on the `<table>`. */
+    /** Id of an external element labelling the table. Mirrored to `aria-labelledby` on the `<table>`. Defaults to `undefined`. */
     readonly ariaLabelledby: _angular_core.InputSignal<string | undefined>;
-    /** Two-way bound set of rows currently expanded. Immutable — set a new `Set` on every change; do not mutate in place. */
+    /** Two-way bound set of rows currently expanded. Immutable — set a new `Set` on every change; do not mutate in place. Defaults to an empty set. */
     readonly expandedRows: _angular_core.ModelSignal<ReadonlySet<T>>;
-    /** Two-way bound list of selected rows. Set a new array on every change; do not mutate. Only used when `selection.enabled` is `true`. */
+    /** Two-way bound list of selected rows. Set a new array on every change; do not mutate. Only used when `selection.enabled` is `true`. Defaults to an empty array. */
     readonly selected: _angular_core.ModelSignal<readonly T[]>;
     /** Fires when a row is clicked. Suppressed when the click originated inside an interactive descendant (button, link, input, etc.). */
     readonly rowClicked: _angular_core.OutputEmitterRef<TwRowClickEvent<T>>;
@@ -396,8 +418,16 @@ declare class TableComponent<T = unknown> {
     readonly shouldRenderEmptyOverlay: _angular_core.Signal<boolean>;
     /** @internal Whether the error overlay should render. */
     readonly shouldRenderErrorOverlay: _angular_core.Signal<boolean>;
-    /** @internal Resolved table labels (defaults merged with input overrides). */
-    readonly resolvedLabels: _angular_core.Signal<TwTableLabels>;
+    /**
+     * @internal Resolved table labels (defaults merged with input overrides).
+     *
+     * Explicitly-undefined keys are dropped before merging: a plain spread lets
+     * `{ selectionColumnLabel: undefined }` overwrite the default with undefined,
+     * which renders an empty `sr-only` span and reinstates the
+     * `empty-table-header` failure the label exists to prevent. `Required<>`
+     * then guarantees the template a string for every label.
+     */
+    readonly resolvedLabels: _angular_core.Signal<Required<TwTableLabels>>;
     /** @internal Computed error message for the default error overlay. Empty when no error is set. */
     readonly errorMessage: _angular_core.Signal<string>;
     /** @internal CSS max-height string for the scroll container. */
@@ -434,6 +464,7 @@ declare class TableComponent<T = unknown> {
     readonly errorMessageClasses: _angular_core.Signal<string>;
     readonly footerSlotClasses: _angular_core.Signal<string>;
     readonly paginationSlotClasses: _angular_core.Signal<string>;
+    readonly dataRowClasses: _angular_core.Signal<string>;
     readonly expansionRowClasses: _angular_core.Signal<string>;
     readonly expansionCellClasses: _angular_core.Signal<string>;
     readonly selectionHeaderClasses: _angular_core.Signal<string>;
@@ -441,6 +472,18 @@ declare class TableComponent<T = unknown> {
     constructor();
     /** @internal Called by the template when a data row is clicked. */
     handleRowClick(row: T, index: number, event: MouseEvent): void;
+    /**
+     * @internal Keyboard counterpart to `handleRowClick`. Only reachable when `clickableRows` is
+     * `true`, because that is the only state in which the `<tr>` carries `tabindex`.
+     *
+     * The `target !== currentTarget` guard is what keeps Enter on a button *inside* a cell from also
+     * activating the row: that keystroke's target is the button, and its own click already bubbles
+     * into `handleRowClick`, which suppresses it. Reusing the `composedPath()` walk here would let
+     * the row fire a second time.
+     */
+    handleRowKeydown(row: T, index: number, event: KeyboardEvent): void;
+    /** @internal `tabindex` for a data row — present only while rows are activatable. */
+    readonly rowTabIndex: _angular_core.Signal<0 | null>;
     /** @internal Whether a row is currently expanded. */
     isRowExpanded(row: T): boolean;
     /** @internal CDK `when` predicate used for the auto-generated expansion row. */
@@ -501,7 +544,7 @@ declare class TableComponent<T = unknown> {
     /** @internal Formatted accessible label for a per-row selection checkbox. */
     selectRowLabel(rowIndex: number): string;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<TableComponent<any>, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TableComponent<any>, "tw-table", ["twTable"], { "data": { "alias": "data"; "required": false; "isSignal": true; }; "trackBy": { "alias": "trackBy"; "required": false; "isSignal": true; }; "loading": { "alias": "loading"; "required": false; "isSignal": true; }; "error": { "alias": "error"; "required": false; "isSignal": true; }; "appearance": { "alias": "appearance"; "required": false; "isSignal": true; }; "sticky": { "alias": "sticky"; "required": false; "isSignal": true; }; "responsive": { "alias": "responsive"; "required": false; "isSignal": true; }; "selection": { "alias": "selection"; "required": false; "isSignal": true; }; "multiTemplateRows": { "alias": "multiTemplateRows"; "required": false; "isSignal": true; }; "labels": { "alias": "labels"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "aria-label"; "required": false; "isSignal": true; }; "ariaLabelledby": { "alias": "aria-labelledby"; "required": false; "isSignal": true; }; "expandedRows": { "alias": "expandedRows"; "required": false; "isSignal": true; }; "selected": { "alias": "selected"; "required": false; "isSignal": true; }; }, { "expandedRows": "expandedRowsChange"; "selected": "selectedChange"; "rowClicked": "rowClicked"; "selectionChange": "selectionChange"; "expansionChange": "expansionChange"; }, ["columns", "noDataRow", "expansionTemplate"], ["[slot='toolbar']", "[slot='caption']", "*", "[slot='empty']", "[slot='error']", "[slot='loading']", "[slot='footer']", "[slot='pagination']"], true, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TableComponent<any>, "tw-table", ["twTable"], { "data": { "alias": "data"; "required": false; "isSignal": true; }; "trackBy": { "alias": "trackBy"; "required": false; "isSignal": true; }; "loading": { "alias": "loading"; "required": false; "isSignal": true; }; "error": { "alias": "error"; "required": false; "isSignal": true; }; "appearance": { "alias": "appearance"; "required": false; "isSignal": true; }; "sticky": { "alias": "sticky"; "required": false; "isSignal": true; }; "responsive": { "alias": "responsive"; "required": false; "isSignal": true; }; "selection": { "alias": "selection"; "required": false; "isSignal": true; }; "multiTemplateRows": { "alias": "multiTemplateRows"; "required": false; "isSignal": true; }; "clickableRows": { "alias": "clickableRows"; "required": false; "isSignal": true; }; "labels": { "alias": "labels"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "aria-label"; "required": false; "isSignal": true; }; "ariaLabelledby": { "alias": "aria-labelledby"; "required": false; "isSignal": true; }; "expandedRows": { "alias": "expandedRows"; "required": false; "isSignal": true; }; "selected": { "alias": "selected"; "required": false; "isSignal": true; }; }, { "expandedRows": "expandedRowsChange"; "selected": "selectedChange"; "rowClicked": "rowClicked"; "selectionChange": "selectionChange"; "expansionChange": "expansionChange"; }, ["columns", "noDataRow", "expansionTemplate"], ["[slot='toolbar']", "[slot='caption']", "*", "[slot='empty']", "[slot='error']", "[slot='loading']", "[slot='footer']", "[slot='pagination']"], true, never>;
 }
 
 export { CellDefDirective, ColumnComponent, DEFAULT_TABLE_LABELS, FooterCellDefDirective, HeaderCellDefDirective, NoDataRowDirective, RowExpansionDirective, TableComponent };

package/types/cdevhub-ngx-tw-tabs.d.ts

@@ -18,11 +18,11 @@ declare class TabContentDirective {
 declare class TabComponent {
     /** Unique identifier for this tab. Used to match the active tab value. */
     readonly value: _angular_core.InputSignal<string>;
-    /** Plain text label shown in the trigger. Ignored when a custom trigger template is provided. */
+    /** Plain text label shown in the trigger. Ignored when a custom trigger template is provided. Defaults to an empty string. */
     readonly label: _angular_core.InputSignal<string>;
     /** When true, the tab cannot be selected and is skipped by keyboard navigation. Defaults to false. */
     readonly disabled: _angular_core.InputSignal<boolean>;
-    /** When true, a close button is rendered in the tab trigger. Defaults to false. */
+    /** When true, a dismiss control is rendered in the tab trigger. The control is pointer-only; the keyboard gesture is Delete on the focused tab. Defaults to false. */
     readonly closable: _angular_core.InputSignal<boolean>;
     /** When true, the tab panel content is only instantiated when the tab becomes active for the first time. Defaults to false. */
     readonly lazy: _angular_core.InputSignal<boolean>;
@@ -37,9 +37,17 @@ declare class TabComponent {
 }
 declare class TabTriggerElementDirective implements FocusableOption {
     readonly elementRef: ElementRef<any>;
-    readonly isActive: _angular_core.InputSignal<boolean>;
+    /**
+     * Whether this trigger owns the tablist's single tab stop. Drives
+     * `tabindex`. Normally the active tab, but the parent falls back to the
+     * first enabled tab when `value` matches nothing, so the tablist is never
+     * left with zero tab stops. Defaults to `false`.
+     */
+    readonly isFocusStop: _angular_core.InputSignal<boolean>;
+    /** Whether this trigger is disabled. Read by `FocusKeyManager` so disabled triggers are skipped during arrow navigation. Defaults to `false`. */
     readonly isDisabled: _angular_core.InputSignal<boolean>;
     readonly tabIndex: _angular_core.Signal<0 | -1>;
+    /** Moves DOM focus to the trigger element. Called by `FocusKeyManager` during arrow-key navigation. */
     focus(): void;
     /**
      * FocusableOption getter. NOTE: we cannot expose the `isDisabled` input
@@ -49,7 +57,7 @@ declare class TabTriggerElementDirective implements FocusableOption {
      */
     get disabled(): boolean;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<TabTriggerElementDirective, never>;
-    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<TabTriggerElementDirective, "[twTabTriggerElement]", never, { "isActive": { "alias": "isActive"; "required": false; "isSignal": true; }; "isDisabled": { "alias": "isDisabled"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<TabTriggerElementDirective, "[twTabTriggerElement]", never, { "isFocusStop": { "alias": "isFocusStop"; "required": false; "isSignal": true; }; "isDisabled": { "alias": "isDisabled"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 declare class TabsComponent implements AfterViewInit {
     /** Controls the visual style of the tab strip. Defaults to 'underline'. */
@@ -62,18 +70,20 @@ declare class TabsComponent implements AfterViewInit {
     readonly orientation: _angular_core.InputSignal<"vertical" | "horizontal">;
     /** When true, tab triggers stretch to fill the available width equally. Defaults to false. */
     readonly fitted: _angular_core.InputSignal<boolean>;
-    /** The value of the currently active tab. Two-way bound. Updates when the user selects a tab. */
+    /** The value of the currently active tab. Two-way bound. Updates when the user selects a tab. Defaults to an empty string. */
     readonly value: _angular_core.ModelSignal<string>;
-    /** Fires when a closable tab's close button is clicked. Payload is the tab's value. */
+    /** Fires when a closable tab is dismissed, either by clicking its close control or by pressing Delete while the tab has focus. Payload is the tab's value. */
     readonly closed: _angular_core.OutputEmitterRef<string>;
     private readonly destroyRef;
     private readonly liveAnnouncer;
     private readonly directionality;
     /**
-     * Live layout direction, mirrored into a signal so the key manager rebuilds
-     * when it changes. Without this the tablist hardcodes 'ltr' and ArrowRight
-     * moves to the next tab in DOM order but the *previous* tab visually in an
-     * RTL locale. CdkStepper and `tw-split` already honour Directionality.
+     * Live layout direction, read straight from CDK's `Directionality.valueSignal`
+     * (CDK 22+) so the key-manager effect re-runs on a runtime `dir` flip with no
+     * manual subscription mirror. Without a live direction the tablist hardcodes
+     * 'ltr' and ArrowRight moves to the next tab in DOM order but the *previous*
+     * tab visually in an RTL locale. CdkStepper and `tw-split` already honour
+     * Directionality; `tw-paginator` reads `valueSignal` the same way.
      */
     private readonly layoutDirection;
     /** @internal */
@@ -100,11 +110,30 @@ declare class TabsComponent implements AfterViewInit {
     readonly closeButtonClasses: _angular_core.Signal<string>;
     /** @internal Get combined trigger classes for a given tab. */
     getTriggerClasses(_tabValue: string, isActive: boolean): string;
+    /** Builds the DOM id for a tab trigger, used by the panel's `aria-labelledby`. */
     getTabId(tabValue: string): string;
+    /** Builds the DOM id for a tab panel, used by the trigger's `aria-controls`. */
     getPanelId(tabValue: string): string;
+    /** Whether the tab with the given value is the currently active one. */
     isTabActive(tabValue: string): boolean;
+    /**
+     * @internal Value of the tab that owns the tablist's single tab stop.
+     *
+     * The active tab whenever it exists and is enabled. When `value` matches no
+     * tab — a stale id, a value cleared after init, or an active tab that is
+     * disabled — the first enabled tab takes the tab stop instead (standard
+     * roving-tabindex recovery). Without the fallback every trigger renders
+     * `tabindex="-1"` and the whole tablist silently leaves the tab order
+     * (WCAG SC 2.1.1).
+     */
+    readonly focusStopValue: _angular_core.Signal<string | null>;
+    /** Whether the tab with the given value owns the tablist's single tab stop. */
+    isTabFocusStop(tabValue: string): boolean;
+    /** Whether a tab's panel content should be in the DOM. Always true for eager tabs; for lazy tabs, true only once the tab has been activated at least once. */
     shouldRenderPanel(tab: TabComponent): boolean;
+    /** Activates a tab, updating the two-way bound `value`, marking it rendered for lazy panels, and announcing the change via `LiveAnnouncer`. Ignored when the tab is disabled. */
     selectTab(tab: TabComponent): void;
+    /** Closes a closable tab, emitting `closed` with its value and moving activation to the nearest enabled sibling when the closed tab was active. */
     closeTab(tab: TabComponent, event: Event): void;
     private findNearestEnabledTab;
     private keyManager;
@@ -114,7 +143,9 @@ declare class TabsComponent implements AfterViewInit {
      * so we lose the native button activation) and Delete to close a closable tab.
      */
     onKeydown(event: KeyboardEvent): void;
+    /** Smoothly scrolls the tablist back toward its start by one step, along the current orientation's axis. */
     scrollStart(): void;
+    /** Smoothly scrolls the tablist forward toward its end by one step, along the current orientation's axis. */
     scrollEnd(): void;
     private updateScrollState;
     ngAfterViewInit(): void;