@cdevhub/ngx-tw 0.4.0 → 0.6.0

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;

package/types/cdevhub-ngx-tw-tags-input-testing.d.ts

@@ -0,0 +1,135 @@
+import { BaseHarnessFilters, ComponentHarness, HarnessPredicate } from '@angular/cdk/testing';
+
+/** Filters accepted by `TagsInputTagHarness.with`. */
+interface TagsInputTagHarnessFilters extends BaseHarnessFilters {
+    /** Match by the chip's visible label. */
+    text?: string | RegExp;
+}
+/**
+ * Harness for a single committed chip inside a `tw-tags-input`.
+ *
+ * Chips are rendered by composing `[twBadge]`, so that attribute is the host
+ * selector. Reach these through {@link TagsInputHarness.getTags} rather than
+ * locating them directly against a fixture — located from a document root the
+ * selector would also match every unrelated badge on the page.
+ */
+declare class TagsInputTagHarness extends ComponentHarness {
+    static hostSelector: string;
+    /**
+     * The chip's remove control. It is the only `<button>` a chip contains: the
+     * badge's own `dismissible` button is not enabled here, so this always
+     * resolves to the tags-input remove control.
+     */
+    private readonly removeButton;
+    /** Predicate for `locatorFor` / `locatorForAll`. */
+    static with(options?: TagsInputTagHarnessFilters): HarnessPredicate<TagsInputTagHarness>;
+    /**
+     * The chip's visible label, trimmed. This is `tagLabel(tag)`, not the tag
+     * value — for object tags the two differ.
+     */
+    getText(): Promise<string>;
+    /**
+     * The remove control's accessible name (`Remove <label>`). Useful for
+     * asserting the control is announced, which is the only signal a screen
+     * reader gets for a chip.
+     */
+    getRemoveLabel(): Promise<string | null>;
+    /**
+     * Clicks the chip's remove control. The component restores focus to the
+     * neighbouring chip (or the text input when none remain), so the caller may
+     * assert focus immediately afterwards.
+     */
+    remove(): Promise<void>;
+}
+
+/** Filters accepted by `TagsInputHarness.with`. */
+interface TagsInputHarnessFilters extends BaseHarnessFilters {
+    /** Match by the control's accessible name (its `aria-label`). */
+    label?: string | RegExp;
+    /** Match disabled / enabled controls. */
+    disabled?: boolean;
+}
+/**
+ * Harness for `tw-tags-input`.
+ *
+ * The control renders committed tags as chips followed by a single text input;
+ * everything lives inside the `tw-tags-input` host, so no overlay handling is
+ * needed and the ordinary fixture loader is enough.
+ *
+ * Note where the ARIA lives: the host is a `role="group"`, which ARIA 1.2 does
+ * not allow to carry `aria-required` / `aria-invalid`, so those sit on the
+ * inner text input — the element that actually owns the pending value.
+ * {@link isRequired} and {@link isInvalid} read them from there;
+ * {@link isDisabled} reads `aria-disabled` from the group, which is allowed.
+ */
+declare class TagsInputHarness extends ComponentHarness {
+    static hostSelector: string;
+    private readonly textInput;
+    /** Predicate for `locatorFor` / `locatorForAll`. */
+    static with(options?: TagsInputHarnessFilters): HarnessPredicate<TagsInputHarness>;
+    /** The control's accessible name, from `aria-label` when one is set. */
+    getLabel(): Promise<string | null>;
+    /** Whether the group reports `aria-disabled="true"`. */
+    isDisabled(): Promise<boolean>;
+    /** Whether the text input reports `aria-required="true"`. */
+    isRequired(): Promise<boolean>;
+    /** Whether the text input reports `aria-invalid="true"`. */
+    isInvalid(): Promise<boolean>;
+    /**
+     * Every committed chip, in render order. Remove by index by indexing this
+     * array — `(await input.getTags())[1].remove()` — which is why no
+     * `removeTagAt(index)` exists.
+     */
+    getTags(filters?: TagsInputTagHarnessFilters): Promise<TagsInputTagHarness[]>;
+    /** The visible label of every committed chip, in render order. */
+    getTagTexts(): Promise<string[]>;
+    /** The in-progress (uncommitted) text currently in the input. */
+    getInputValue(): Promise<string>;
+    /**
+     * Types `text` into the input and commits it with Enter. Typing appends, so
+     * any pending text already in the input is committed along with it.
+     *
+     * Enter is the commit gesture only while `separatorKeys` contains `'Enter'`
+     * (the default). A control configured with, say, `[separatorKeys]="[';']"`
+     * commits through {@link typeInput} instead — `typeInput('alpha;')`.
+     *
+     * The commit may be dropped by the component (empty, duplicate, or `maxTags`
+     * reached); assert against {@link getTagTexts} rather than assuming it
+     * landed.
+     */
+    addTag(text: string): Promise<void>;
+    /**
+     * Types `text` into the input character by character, appending to whatever
+     * is already there. Use it to stage pending text that {@link addTag} would
+     * commit for you — reading it back, discarding it, or letting `addOnBlur`
+     * pick it up.
+     *
+     * A separator character in `text` does commit the text before it, but CDK's
+     * synthetic typing appends every character to the input regardless of the
+     * component's `preventDefault()`, so the separator itself is left behind in
+     * the input where a real browser swallows it. Commit with {@link addTag},
+     * and treat a trailing separator here as staging, not as a commit gesture.
+     */
+    typeInput(text: string): Promise<void>;
+    /**
+     * Removes the first chip whose label matches. Throws when nothing matches,
+     * rather than failing silently.
+     */
+    removeTag(text: string | RegExp): Promise<void>;
+    /**
+     * Discards the in-progress text with Escape — the control's own clear
+     * gesture. A no-op when the input is already empty. Does not touch committed
+     * chips.
+     */
+    clearInput(): Promise<void>;
+    /** Moves focus to the text input. */
+    focus(): Promise<void>;
+    /**
+     * Moves focus out of the control. This is the gesture that marks the control
+     * touched and, with `addOnBlur`, commits the pending text.
+     */
+    blur(): Promise<void>;
+}
+
+export { TagsInputHarness, TagsInputTagHarness };
+export type { TagsInputHarnessFilters, TagsInputTagHarnessFilters };

package/types/cdevhub-ngx-tw-tags-input.d.ts

@@ -59,7 +59,7 @@ declare class TagsInputComponent<T = string> extends FormFieldControl<T[]> imple
     readonly disabledInput: _angular_core.InputSignal<boolean>;
     /** Marks the control as required. Mirrored to the input's `aria-required`. Also inferred from `Validators.required` on a bound control. Defaults to `false`. */
     readonly requiredInput: _angular_core.InputSignal<boolean>;
-    /** Placeholder shown in the text input only while there are no chips and the input is empty. */
+    /** Placeholder shown in the text input only while there are no chips and the input is empty. Defaults to `undefined`. */
     readonly placeholder: _angular_core.InputSignal<string | undefined>;
     /** Keys that commit the in-progress text as a tag. Each entry is a `KeyboardEvent.key` value (`'Enter'`) or a single separator character (`','`). Single-character separators also split pasted text. Defaults to `['Enter', ',']`. */
     readonly separatorKeys: _angular_core.InputSignal<readonly string[]>;
@@ -75,19 +75,30 @@ declare class TagsInputComponent<T = string> extends FormFieldControl<T[]> imple
     readonly tagLabel: _angular_core.InputSignal<TwTagLabelFn<T>>;
     /** Equality comparator used for dedup when `allowDuplicates` is false. Defaults to `Object.is` (reference / value identity). String tags dedupe case-sensitively by default; pass `(a, b) => a.toLowerCase() === b.toLowerCase()` for case-insensitive dedup. */
     readonly compareWith: _angular_core.InputSignal<TwTagCompareFn<T>>;
-    /** Applied to the text input for labeling and identification only; does not submit the tag array via native (non-Angular) form posting. */
+    /** Applied to the text input for labeling and identification only; does not submit the tag array via native (non-Angular) form posting. Defaults to `undefined`. */
     readonly name: _angular_core.InputSignal<string | undefined>;
     /** Id on the host element. Auto-generated as `tw-tags-input-N` when not provided. Used by the form-field's `<label for>` association. */
     readonly idInput: _angular_core.InputSignal<string | undefined>;
-    /** Accessible name applied to the control when no visible label is wired. Mirrored to `aria-label`. */
+    /** Accessible name applied to the control when no visible label is wired. Mirrored to `aria-label`. Defaults to `undefined`. */
     readonly ariaLabel: _angular_core.InputSignal<string | undefined>;
-    /** ID of an external element that labels the control. Mirrored to `aria-labelledby`. */
+    /** ID of an external element that labels the control. Mirrored to `aria-labelledby`. Defaults to `undefined`. */
     readonly ariaLabelledby: _angular_core.InputSignal<string | undefined>;
-    /** ID of an external element that describes the control. Form-field merges its hint / error ids alongside. */
+    /** ID of an external element that describes the control. Form-field merges its hint / error ids alongside. Defaults to `undefined`. Alias: `aria-describedby`. */
     readonly ariaDescribedby: _angular_core.InputSignal<string | undefined>;
     /** Per-instance override of the {@link ErrorStateMatcher}. When omitted, uses the `TW_ERROR_STATE_MATCHER` token's value. */
     readonly errorStateMatcher: _angular_core.InputSignal<ErrorStateMatcher | undefined>;
-    /** Fires when the tag array changes through user interaction (add, remove, clear). Emits a fresh array reference. Does not fire on `writeValue`. */
+    /**
+     * Fires when the tag array changes through user interaction (add, remove,
+     * clear). Emits a fresh array reference. Does **not** fire on `writeValue` /
+     * `FormControl.setValue` / `ngModel`.
+     *
+     * This is a hand-written, user-gesture-only output. The control exposes no
+     * `value` input and therefore no two-way binding, so — unlike
+     * `tw-checkbox` / `tw-switch` / `tw-radio-group`, where `(valueChange)` /
+     * `(checkedChange)` is minted by a `model()` and fires on programmatic writes
+     * too — there is no any-change channel here. Observe programmatic writes
+     * through the bound form control's own `valueChanges`.
+     */
     readonly valueChange: _angular_core.OutputEmitterRef<T[]>;
     /** Fires when a tag is committed via Enter, a separator key, paste, or `addTag()`. Does not fire for dropped duplicates, blocked-by-max commits, empty commits, or `writeValue`. */
     readonly tagAdded: _angular_core.OutputEmitterRef<TwTagAddedEvent<T>>;
@@ -98,10 +109,14 @@ declare class TagsInputComponent<T = string> extends FormFieldControl<T[]> imple
     private readonly elementRef;
     private readonly destroyRef;
     private readonly ngControl;
-    private readonly parentForm;
-    private readonly parentFormGroup;
-    private readonly defaultMatcher;
     private readonly formField;
+    /**
+     * Optional so a consumer that never imports `BidiModule` still gets a working
+     * control — chip navigation falls back to LTR when the token is absent. Read
+     * imperatively inside the keydown handlers; nothing here needs to re-render
+     * on a direction change.
+     */
+    private readonly directionality;
     private readonly textInputRef;
     private readonly removeButtons;
     private onChange;
@@ -113,8 +128,8 @@ declare class TagsInputComponent<T = string> extends FormFieldControl<T[]> imple
     protected readonly activeChipIndex: _angular_core.WritableSignal<number | null>;
     private readonly cvaDisabled;
     private readonly _focused;
-    private readonly _ngControlRev;
-    private readonly _formSubmitRev;
+    /** @internal Shared `errorState` / `required` / `errors` derivation — see `wireErrorState`. */
+    private readonly errorWiring;
     private readonly describedByIdsSignal;
     private readonly labelledByIdsSignal;
     /** Nonce bumped only on explicit focus intent — keeps the focus effect from stealing focus on unrelated renders. */

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

@@ -33,7 +33,8 @@ type TwTextareaResize = 'none' | 'vertical' | 'both';
  */
 declare class TextareaDirective extends InputDirective {
     private readonly cdkAutosize;
-    /** Density of a standalone textarea. Maps to the inline-padding + font scale (`xs` … `xl`). Ignored inside a `<tw-form-field>` — the wrapper's `size` carries density. Defaults to `'md'`. */
+    private readonly parentFormField;
+    /** Density of a standalone textarea. Maps to the inline-padding + font scale (`xs` … `xl`) and to a `min-h-*` floor on the control-height scale (24/32/36/44/48px) — a floor, not a fixed height, because a textarea must grow with its content. The floor is dropped while `autosize` is on (CDK owns the height then; `minRows` is the floor). Ignored inside a `<tw-form-field>` — the wrapper's `size` carries density. Defaults to `'md'`. */
     readonly size: _angular_core.InputSignal<TwSize>;
     /** Grows the textarea with its content (composed from CDK's `CdkTextareaAutosize`). When `true` the user-resize handle is forced off — autosize owns the height. Defaults to `false`. */
     readonly autosize: _angular_core.InputSignalWithTransform<boolean, unknown>;
@@ -49,7 +50,7 @@ declare class TextareaDirective extends InputDirective {
     readonly maxLength: _angular_core.InputSignalWithTransform<number | undefined, unknown>;
     /** Current value length, updates on every `input` event. Wire `<span twHint align="end">{{ ta.valueLength() }} / {{ ta.maxLength() }}</span>` for a character counter. */
     readonly valueLength: Signal<number>;
-    /** @internal Textarea-specific Tailwind classes (resize axis). Combined with the inherited `classes()` in the host `[class]` binding. */
+    /** @internal Textarea-specific Tailwind classes (resize axis + control-height floor). Combined with the inherited `classes()` in the host `[class]` binding — the two strings never emit conflicting utilities, so concatenating them needs no cross-config merge. */
     readonly textareaClasses: Signal<string>;
     constructor();
     /** Triggers a CDK autosize recalculation. Useful after programmatic value changes that bypass the native `(input)` event (e.g., clipboard write APIs). No-op when `autosize` is `false`. */