@cdevhub/ngx-tw 0.2.0

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

@@ -0,0 +1,479 @@
+import * as _angular_core from '@angular/core';
+import { TemplateRef, TrackByFunction } from '@angular/core';
+import { CdkNoDataRow, CdkTableDataSourceInput, CdkTable } from '@angular/cdk/table';
+import { TwBreakpoint, TwSize } from '@cdevhub/ngx-tw/core';
+export { DataSource } from '@angular/cdk/collections';
+
+/** Possible values for the `aria-sort` attribute on a sortable column header. */
+type TwColumnAriaSort = 'ascending' | 'descending' | 'none' | null;
+/** Re-export of CDK's accepted data-source shapes: plain array, Observable, or `DataSource<T>`. */
+type TwTableDataSourceInput<T> = CdkTableDataSourceInput<T>;
+/** Visual variant of the table. `'default'` — clean row dividers. `'striped'` — alternating rows. `'bordered'` — full grid with outer rounded border. */
+type TwTableVariant = 'default' | 'striped' | 'bordered';
+/** Row density. `'comfortable'` — larger vertical padding. `'compact'` — tighter padding for dense data. */
+type TwTableDensity = 'comfortable' | 'compact';
+/** Responsive behaviour mode. `'scroll'` — horizontal overflow. `'stack'` — cards per row below a breakpoint. `'hide'` — columns with `hideBelow` are hidden. */
+type TwTableResponsiveMode = 'scroll' | 'stack' | 'hide';
+/** Table layout algorithm. `'auto'` — content-sized columns. `'fixed'` — respects `<tw-column display.width>`. */
+type TwTableLayout = 'auto' | 'fixed';
+/** Horizontal alignment of a column's cells. */
+type TwColumnAlign = 'start' | 'center' | 'end';
+/** Column stickiness. `'start'` pins to leading edge; `'end'` pins to trailing edge; `false` disables. */
+type TwColumnSticky = 'start' | 'end' | false;
+/** Visual configuration. Pass any subset; unset keys fall back to the defaults. */
+interface TwTableAppearance {
+    /** Visual variant. Defaults to `'default'`. */
+    variant?: TwTableVariant;
+    /** Row density (vertical padding only — independent of font size). Defaults to `'comfortable'`. */
+    density?: TwTableDensity;
+    /** Base font-size scale for header and data cells. Defaults to `'md'`. */
+    size?: TwSize;
+    /** Table layout algorithm. Defaults to `'auto'`. */
+    layout?: TwTableLayout;
+    /** When `true`, rows fade in on enter via `animate.enter="fade-in"`. Off by default to avoid flicker on frequent data updates. Defaults to `false`. */
+    rowAnimations?: boolean;
+}
+/** Sticky configuration — pinned header/footer rows and an internal scroll region. */
+interface TwTableSticky {
+    /** When `true`, the `<thead>` row stays visible while the body scrolls. Requires `scrollHeight` or a scrolling ancestor. Defaults to `false`. */
+    header?: boolean;
+    /** When `true`, the `<tfoot>` row stays pinned while the body scrolls. Defaults to `false`. */
+    footer?: boolean;
+    /** Max-height of the internal scroll container. A number is treated as pixels; a string is passed through as a CSS length. When `null`, the table flows with its content. Defaults to `null`. */
+    scrollHeight?: string | number | null;
+}
+/** Responsive configuration — how the table adapts to narrow viewports. */
+interface TwTableResponsive {
+    /** Narrow-viewport strategy. Defaults to `'scroll'`. */
+    mode?: TwTableResponsiveMode;
+    /** Breakpoint below which the `'stack'` mode engages. Ignored when `mode !== 'stack'`. Defaults to `'md'`. */
+    stackBelow?: TwBreakpoint;
+}
+/** Selection configuration. */
+interface TwTableSelection {
+    /** When `true`, exposes a leading `_selection` column slot for checkbox rendering. Defaults to `false`. */
+    enabled?: boolean;
+}
+/** Per-column display configuration. */
+interface TwColumnDisplay {
+    /** Sticky positioning. `'start'` pins to the leading edge; `'end'` pins to the trailing edge; `false` disables stickiness. Defaults to `false`. */
+    sticky?: TwColumnSticky;
+    /** Horizontal text alignment. `'end'` is idiomatic for numeric columns. Defaults to `'start'`. */
+    align?: TwColumnAlign;
+    /** Convenience flag equivalent to `align: 'end'` plus tabular numerals. Overridden by an explicit `align`. Defaults to `false`. */
+    numeric?: boolean;
+    /** Responsive visibility: when set and the viewport is below this breakpoint, the column is hidden (applies when the table's `responsive.mode === 'hide'`). Defaults to `null`. */
+    hideBelow?: TwBreakpoint | null;
+    /** CSS column width applied to header and data cells. A number is treated as pixels; a string is passed through. Only honoured when the table's `appearance.layout === 'fixed'`. Defaults to `null`. */
+    width?: string | number | null;
+}
+/** String labels used by the table. All keys optional on the `labels` input; unset keys fall back to the English defaults. */
+interface TwTableLabels {
+    /** Accessible name used when neither `<caption>`, `ariaLabel`, nor `ariaLabelledby` is provided. Triggers a dev-mode warning. */
+    ariaLabel: string;
+    /** Default empty-state message rendered when no `[slot="empty"]` content is projected. */
+    empty: string;
+    /** Default loading message announced politely via `LiveAnnouncer`. */
+    loading: string;
+    /** Prefix prepended to `String(error)` when no `[slot="error"]` content is projected. */
+    errorPrefix: string;
+    /** `LiveAnnouncer` template announced on row-count changes. Variable: `{count}`. */
+    rowsUpdatedAnnouncement: string;
+    /** `LiveAnnouncer` template for selection-change announcements. Variable: `{count}`. */
+    selectionAnnouncement: string;
+    /** Accessible label for the row-expansion toggle button. */
+    expandRowLabel: string;
+    /** Accessible label for the collapse-row toggle button. */
+    collapseRowLabel: string;
+    /** Accessible label for the master "select all" checkbox in the leading selection column. */
+    selectAllLabel: string;
+    /** Accessible label template for each per-row selection checkbox. Variable: `{index}` (1-based). */
+    selectRowLabel: string;
+}
+/** Default English labels for the table. */
+declare const DEFAULT_TABLE_LABELS: Readonly<TwTableLabels>;
+/** Context provided to every data-cell template (`*twCellDef`). Generic over the row type `T`. */
+interface TwCellContext<T> {
+    /** The row data (implicit `let-row`). */
+    $implicit: T;
+    /** The row, aliased for readability. */
+    row: T;
+    /** The column's declared `name`. */
+    column: string;
+    /** Zero-based index within the rendered row list. */
+    index: number;
+    /** Zero-based column index in the visible column set. */
+    columnIndex: number;
+    /** True when this cell is in the first row. */
+    first: boolean;
+    /** True when this cell is in the last row. */
+    last: boolean;
+    /** True when the row index is even. */
+    even: boolean;
+    /** True when the row index is odd. */
+    odd: boolean;
+    /** Total number of rendered rows. */
+    count: number;
+}
+/** Context provided to every header-cell template (`*twHeaderCellDef`). */
+interface TwHeaderCellContext {
+    /** The column's declared `name` (implicit `let-column`). */
+    $implicit: string;
+    /** The column's declared `name`, aliased. */
+    column: string;
+    /** Zero-based column index in the visible column set. */
+    columnIndex: number;
+}
+/** Context provided to every footer-cell template (`*twFooterCellDef`). Generic over the row type `T`. */
+interface TwFooterCellContext<T> {
+    /** The column's declared `name` (implicit). */
+    $implicit: string;
+    /** The column's declared `name`. */
+    column: string;
+    /** Zero-based column index in the visible column set. */
+    columnIndex: number;
+    /** Snapshot of all rows (useful for total/summary computation). */
+    rows: readonly T[];
+}
+/** Context surfaced to a `*twRowDef` template. Mirrors `TwCellContext<T>` minus the column-specific fields. */
+interface TwRowContext<T> {
+    /** The row data (implicit `let-row`). */
+    $implicit: T;
+    /** The row, aliased. */
+    row: T;
+    /** Zero-based index within the rendered row list. */
+    index: number;
+    /** True when this row is the first rendered row. */
+    first: boolean;
+    /** True when this row is the last rendered row. */
+    last: boolean;
+    /** True when the row index is even. */
+    even: boolean;
+    /** True when the row index is odd. */
+    odd: boolean;
+    /** Total rendered row count. */
+    count: number;
+}
+/** Context provided to `*twRowExpansion`. */
+interface TwRowExpansionContext<T> {
+    /** The row whose expansion panel this template renders. */
+    $implicit: T;
+    /** The row, aliased. */
+    row: T;
+    /** The data index. */
+    index: number;
+    /** Collapses this row (removes it from `expandedRows`). */
+    collapse: () => void;
+}
+/** Payload emitted by `rowClicked`. */
+interface TwRowClickEvent<T> {
+    /** The clicked row. */
+    row: T;
+    /** Zero-based index in the rendered data. */
+    index: number;
+    /** The original DOM event. */
+    event: MouseEvent;
+}
+/** Payload emitted by `selectionChange`. */
+interface TwSelectionChangeEvent<T> {
+    /** The full current selection. */
+    selected: readonly T[];
+    /** Rows added since the previous selection. */
+    added: readonly T[];
+    /** Rows removed since the previous selection. */
+    removed: readonly T[];
+    /** The previous selection. */
+    previous: readonly T[];
+}
+/** Payload emitted by `expansionChange`. */
+interface TwRowExpansionChangeEvent<T> {
+    /** The row whose expansion state changed. */
+    row: T;
+    /** Whether the row is now expanded. */
+    expanded: boolean;
+    /** The full set of expanded rows after the change. */
+    expandedRows: ReadonlySet<T>;
+}
+/** Structural directive on an `<ng-template>` (or a star-directive host) defining a column's data-cell template. Typed as `TwCellContext<T>`. */
+declare class CellDefDirective<T = unknown> {
+    /** @internal */
+    readonly template: TemplateRef<any>;
+    /** @internal */
+    static ngTemplateContextGuard<T>(_dir: CellDefDirective<T>, _ctx: unknown): _ctx is TwCellContext<T>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CellDefDirective<any>, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<CellDefDirective<any>, "[twCellDef]", never, {}, {}, never, never, true, never>;
+}
+/** Structural directive defining a column's header-cell template. Typed as `TwHeaderCellContext`. */
+declare class HeaderCellDefDirective {
+    /** @internal */
+    readonly template: TemplateRef<any>;
+    /** @internal */
+    static ngTemplateContextGuard(_dir: HeaderCellDefDirective, _ctx: unknown): _ctx is TwHeaderCellContext;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<HeaderCellDefDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<HeaderCellDefDirective, "[twHeaderCellDef]", never, {}, {}, never, never, true, never>;
+}
+/** Structural directive defining a column's footer-cell template. Typed as `TwFooterCellContext<T>`. */
+declare class FooterCellDefDirective<T = unknown> {
+    /** @internal */
+    readonly template: TemplateRef<any>;
+    /** @internal */
+    static ngTemplateContextGuard<T>(_dir: FooterCellDefDirective<T>, _ctx: unknown): _ctx is TwFooterCellContext<T>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FooterCellDefDirective<any>, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<FooterCellDefDirective<any>, "[twFooterCellDef]", never, {}, {}, never, never, true, never>;
+}
+/** Structural directive on an `<ng-template>` declaring the no-data row fallback. Takes precedence over `[slot="empty"]` when both are present. */
+declare class NoDataRowDirective extends CdkNoDataRow {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NoDataRowDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NoDataRowDirective, "ng-template[twNoDataRow]", never, {}, {}, never, never, true, never>;
+}
+/** 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). */
+    readonly predicate: _angular_core.InputSignal<((row: T, index: number) => boolean) | undefined>;
+    /** @internal */
+    readonly template: TemplateRef<any>;
+    /** @internal */
+    static ngTemplateContextGuard<T>(_dir: RowExpansionDirective<T>, _ctx: unknown): _ctx is TwRowExpansionContext<T>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RowExpansionDirective<any>, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RowExpansionDirective<any>, "ng-template[twRowExpansion]", never, { "predicate": { "alias": "twRowExpansionWhen"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+/**
+ * Declares a single column of a `<tw-table>`. Pure-metadata component — its
+ * host element is `display: none`; the column's `<th>` / `<td>` / `<tfoot>`
+ * renderers are emitted by the parent `<tw-table>` using the projected cell
+ * templates (`*twHeaderCellDef`, `*twCellDef`, `*twFooterCellDef`).
+ */
+declare class ColumnComponent<T = unknown> {
+    /** Unique identifier for this column. Required — referenced by `*twRowDef` / `*twHeaderRowDef` and used as the CDK `cdkColumnDef` name. */
+    readonly name: _angular_core.InputSignal<string>;
+    /** Visual configuration: sticky, align, numeric, hideBelow, width. Accepts any subset; unset keys fall back to the defaults. */
+    readonly display: _angular_core.InputSignal<TwColumnDisplay>;
+    /** When true, removes this column from the visible column set. Defaults to `false`. */
+    readonly hidden: _angular_core.InputSignal<boolean>;
+    /** Ordering hint for the default visible-columns list when no `*twRowDef` is declared. Lower renders first. Defaults to `0`. */
+    readonly priority: _angular_core.InputSignal<number>;
+    /** Plain text header label. Used when no `*twHeaderCellDef` template is projected. Defaults to `undefined`. */
+    readonly headerLabel: _angular_core.InputSignal<string | undefined>;
+    /** Label used as `data-label` on cells in responsive `'stack'` mode. Falls back to `headerLabel`, then `name`. Defaults to `undefined`. */
+    readonly stackLabel: _angular_core.InputSignal<string | undefined>;
+    /**
+     * Explicit override for the column header's `aria-sort` attribute. When unset (the default),
+     * the column derives its `aria-sort` from a parent `[twSort]` directive via the `TW_SORT_HANDLE`
+     * token — the column is treated as active when the directive's `active` id matches this column's
+     * `name`. Set explicitly to `'ascending'` / `'descending'` / `'none'` to override; `null` disables
+     * the attribute entirely. Defaults to `null`.
+     */
+    readonly sortState: _angular_core.InputSignal<TwColumnAriaSort>;
+    /** @internal Stable identifier used for DOM `data-*` hooks. */
+    readonly columnId: string;
+    private readonly sortHandle;
+    /** @internal Consumer-projected header-cell template (optional). */
+    readonly headerCellDef: _angular_core.Signal<HeaderCellDefDirective | undefined>;
+    /** @internal Consumer-projected data-cell template. */
+    readonly cellDef: _angular_core.Signal<CellDefDirective<any> | undefined>;
+    /** @internal Consumer-projected footer-cell template (optional). */
+    readonly footerCellDef: _angular_core.Signal<FooterCellDefDirective<any> | undefined>;
+    /** @internal Index in the visible column set — pushed by the parent table. */
+    readonly columnIndex: _angular_core.WritableSignal<number>;
+    /** @internal Row snapshot pushed by the parent for footer-cell contexts. */
+    readonly rowsSnapshot: _angular_core.WritableSignal<readonly T[]>;
+    /** @internal Table-pushed extra classes (sticky / hide-below / responsive decorations). */
+    readonly extraCellClass: _angular_core.WritableSignal<string>;
+    readonly extraHeaderClass: _angular_core.WritableSignal<string>;
+    readonly extraFooterClass: _angular_core.WritableSignal<string>;
+    /** Resolved display config — partial input merged with `DISPLAY_DEFAULTS`. */
+    readonly resolvedDisplay: _angular_core.Signal<Required<TwColumnDisplay>>;
+    /** @internal Convenience accessor for the cdkColumnDef `[sticky]` binding. */
+    readonly stickyStart: _angular_core.Signal<boolean>;
+    /** @internal Convenience accessor for the cdkColumnDef `[stickyEnd]` binding. */
+    readonly stickyEnd: _angular_core.Signal<boolean>;
+    /** @internal Effective align — `numeric` forces `'end'` unless `align` is explicitly set to a non-default value. */
+    readonly effectiveAlign: _angular_core.Signal<TwColumnAlign>;
+    /** @internal CSS width string applied to cells. */
+    readonly resolvedWidth: _angular_core.Signal<string | null>;
+    /** @internal `data-label` emitted on cells in stack mode. */
+    readonly stackDataLabel: _angular_core.Signal<string>;
+    /** @internal Align class plus tabular-numerals when `numeric` is true — shared by data and footer cells. */
+    private readonly dataCellPrefix;
+    readonly cellClasses: _angular_core.Signal<string>;
+    readonly headerCellClasses: _angular_core.Signal<string>;
+    readonly footerCellClasses: _angular_core.Signal<string>;
+    /**
+     * @internal `aria-sort` value for the column's `<th>`. Explicit `sortState` wins; otherwise the
+     * column auto-resolves against a parent `[twSort]` directive (`TW_SORT_HANDLE`). Returns `null`
+     * when no sort is wired or the column is not the active sort, so the attribute is omitted.
+     */
+    readonly ariaSort: _angular_core.Signal<TwColumnAriaSort>;
+    readonly headerContext: _angular_core.Signal<TwHeaderCellContext>;
+    readonly footerContext: _angular_core.Signal<TwFooterCellContext<T>>;
+    /** @internal Builds the per-cell template context from CDK-provided row variables. */
+    buildCellContext(row: T, index: number, count: number, first: boolean, last: boolean, even: boolean, odd: boolean): TwCellContext<T>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ColumnComponent<any>, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ColumnComponent<any>, "tw-column", never, { "name": { "alias": "name"; "required": true; "isSignal": true; }; "display": { "alias": "display"; "required": false; "isSignal": true; }; "hidden": { "alias": "hidden"; "required": false; "isSignal": true; }; "priority": { "alias": "priority"; "required": false; "isSignal": true; }; "headerLabel": { "alias": "headerLabel"; "required": false; "isSignal": true; }; "stackLabel": { "alias": "stackLabel"; "required": false; "isSignal": true; }; "sortState": { "alias": "sortState"; "required": false; "isSignal": true; }; }, {}, ["headerCellDef", "cellDef", "footerCellDef"], never, true, never>;
+}
+/**
+ * A highly customizable data-table component wrapping `@angular/cdk/table`.
+ *
+ * Composes with other ngx-tw primitives:
+ * - Sortable headers: place `[twSort]` on `<tw-table>` and `[tw-sort-header]` inside `*twHeaderCellDef`.
+ * - Pagination: project `<tw-paginator slot="pagination">` as a child.
+ * - Loading spinner: project `<tw-spinner slot="loading">` or rely on the built-in fallback.
+ */
+declare class TableComponent<T = unknown> {
+    /** The table's rows. Accepts a plain array, an `Observable<readonly T[]>`, or a CDK `DataSource<T>`. Wired directly to `CdkTable.dataSource`. Defaults to an empty array. */
+    readonly data: _angular_core.InputSignal<TwTableDataSourceInput<T>>;
+    /** Tracking function used by CDK to identify rows across data changes. When unset, CDK uses identity. */
+    readonly trackBy: _angular_core.InputSignal<TrackByFunction<T> | undefined>;
+    /** When true, renders the loading slot as an overlay and applies `opacity-60 pointer-events-none` to the body. Defaults to `false`. */
+    readonly loading: _angular_core.InputSignal<boolean>;
+    /** When non-null, renders the error slot in place of the body. Defaults to `null`. */
+    readonly error: _angular_core.InputSignal<unknown>;
+    /** Visual configuration — `variant`, `density`, `size`, `layout`, `rowAnimations`. Accepts a partial; unset keys fall back to the defaults. */
+    readonly appearance: _angular_core.InputSignal<TwTableAppearance>;
+    /** Sticky configuration — `header`, `footer`, `scrollHeight`. Accepts a partial; unset keys fall back to the defaults. */
+    readonly sticky: _angular_core.InputSignal<TwTableSticky>;
+    /** Responsive configuration — `mode`, `stackBelow`. Accepts a partial; unset keys fall back to the defaults. */
+    readonly responsive: _angular_core.InputSignal<TwTableResponsive>;
+    /** Selection configuration — `enabled`. Accepts a partial; unset keys fall back to the defaults. */
+    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>;
+    /** 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. */
+    readonly ariaLabel: _angular_core.InputSignal<string | undefined>;
+    /** Id of an external element labelling the table. Mirrored to `aria-labelledby` on the `<table>`. */
+    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. */
+    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`. */
+    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>>;
+    /** Fires after `selected` changes via user interaction (not on programmatic writes). */
+    readonly selectionChange: _angular_core.OutputEmitterRef<TwSelectionChangeEvent<T>>;
+    /** Fires after a row is expanded or collapsed by user interaction. */
+    readonly expansionChange: _angular_core.OutputEmitterRef<TwRowExpansionChangeEvent<T>>;
+    /** @internal Projected columns. */
+    readonly columns: _angular_core.Signal<readonly ColumnComponent<any>[]>;
+    /** @internal Projected custom no-data row (takes precedence over the fallback empty state). */
+    readonly noDataRow: _angular_core.Signal<NoDataRowDirective | undefined>;
+    /** @internal Projected expansion row template. */
+    readonly expansionTemplate: _angular_core.Signal<RowExpansionDirective<T> | undefined>;
+    /** @internal The CDK table inside our view. */
+    readonly cdkTable: _angular_core.Signal<CdkTable<T>>;
+    private readonly _liveAnnouncer;
+    private readonly _elementRef;
+    private readonly _destroyRef;
+    /** Unique per-instance id used to scope row/expansion DOM ids. */
+    readonly hostId: string;
+    /** Returns the DOM id used for the expansion row of the given data row at the given index. Useful for wiring `aria-controls` from a trigger cell. */
+    readonly expansionId: (_row: T, index: number) => string;
+    /** @internal Resolved visual configuration. */
+    readonly resolvedAppearance: _angular_core.Signal<Required<TwTableAppearance>>;
+    /** @internal Resolved sticky configuration. */
+    readonly resolvedSticky: _angular_core.Signal<Required<TwTableSticky>>;
+    /** @internal Resolved responsive configuration. */
+    readonly resolvedResponsive: _angular_core.Signal<Required<TwTableResponsive>>;
+    /** @internal Resolved selection configuration. */
+    readonly resolvedSelection: _angular_core.Signal<Required<TwTableSelection>>;
+    /** @internal Snapshot of the data array (for footer-cell context). Empty array for async data sources. */
+    readonly resolvedRows: _angular_core.Signal<readonly T[]>;
+    /** @internal Whether the data input is a plain array. */
+    readonly dataIsArray: _angular_core.Signal<boolean>;
+    /** @internal Snapshot-based empty check; `false` for async sources (we can't know without subscribing). */
+    readonly isEmptySnapshot: _angular_core.Signal<boolean>;
+    /** @internal Whether the empty overlay fallback should render (no no-data-row projected). */
+    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 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. */
+    readonly maxHeightStyle: _angular_core.Signal<string | null>;
+    /** @internal The visible (non-hidden) columns in render order (by ascending `priority`). */
+    readonly visibleColumns: _angular_core.Signal<readonly ColumnComponent<T>[]>;
+    /** @internal Column names of the visible set, prefixed with `_selection` when `selection.enabled === true`. */
+    readonly visibleColumnNames: _angular_core.Signal<readonly string[]>;
+    /** @internal Whether any column has a projected footer-cell template. */
+    readonly hasFooterRow: _angular_core.Signal<boolean>;
+    /** @internal Whether an expansion template has been declared and multi-template rows are enabled. */
+    readonly hasExpansion: _angular_core.Signal<boolean>;
+    /** @internal Colspan to use for the expansion `<td>`. */
+    readonly expansionColspan: _angular_core.Signal<number>;
+    /** @internal Pulled by the template for the `*cdkHeaderRowDef`/`*cdkFooterRowDef` `sticky:` field. */
+    readonly stickyHeader: _angular_core.Signal<boolean>;
+    readonly stickyFooter: _angular_core.Signal<boolean>;
+    private readonly _variantResult;
+    readonly hostClasses: _angular_core.Signal<string>;
+    readonly toolbarClasses: _angular_core.Signal<string>;
+    readonly scrollWrapperClasses: _angular_core.Signal<string>;
+    readonly scrollContainerClasses: _angular_core.Signal<string>;
+    readonly tableClasses: _angular_core.Signal<string>;
+    readonly thClasses: _angular_core.Signal<string>;
+    readonly tdClasses: _angular_core.Signal<string>;
+    readonly footerTdClasses: _angular_core.Signal<string>;
+    readonly emptyStateClasses: _angular_core.Signal<string>;
+    readonly emptyIconClasses: _angular_core.Signal<string>;
+    readonly emptyMessageClasses: _angular_core.Signal<string>;
+    readonly loadingOverlayClasses: _angular_core.Signal<string>;
+    readonly loadingMessageClasses: _angular_core.Signal<string>;
+    readonly errorStateClasses: _angular_core.Signal<string>;
+    readonly errorIconClasses: _angular_core.Signal<string>;
+    readonly errorMessageClasses: _angular_core.Signal<string>;
+    readonly footerSlotClasses: _angular_core.Signal<string>;
+    readonly paginationSlotClasses: _angular_core.Signal<string>;
+    readonly expansionRowClasses: _angular_core.Signal<string>;
+    readonly expansionCellClasses: _angular_core.Signal<string>;
+    readonly selectionHeaderClasses: _angular_core.Signal<string>;
+    readonly selectionCellClasses: _angular_core.Signal<string>;
+    constructor();
+    /** @internal Called by the template when a data row is clicked. */
+    handleRowClick(row: T, index: number, event: MouseEvent): void;
+    /** @internal Whether a row is currently expanded. */
+    isRowExpanded(row: T): boolean;
+    /** @internal CDK `when` predicate used for the auto-generated expansion row. */
+    readonly expansionWhen: (index: number, row: T) => boolean;
+    /** @internal Context object for the expansion template. */
+    expansionContext(row: T, index: number): TwRowExpansionContext<T>;
+    /** Expands the given row if not already expanded and emits `expansionChange`. */
+    expand(row: T): void;
+    /** Collapses the given row if currently expanded and emits `expansionChange`. */
+    collapse(row: T): void;
+    /** Toggles the expansion state of the given row. */
+    toggleExpansion(row: T): void;
+    /** Whether a given row is currently in the `selected` list. */
+    isSelected(row: T): boolean;
+    /** Selects or deselects a row and emits `selectionChange`. */
+    setSelected(row: T, nextSelected: boolean): void;
+    /**
+     * Adds every row in the current data snapshot to `selected` that isn't already selected.
+     * Emits `selectionChange` if anything changed. Only the array data-source path can compute a
+     * full snapshot — for `Observable<T[]>` or `DataSource<T>` data inputs this is a no-op.
+     */
+    selectAll(): void;
+    /** Clears every currently-selected row. Emits `selectionChange` if anything was selected. */
+    clearSelection(): void;
+    /** @internal Returns `aria-selected` for a data row, or `null` to omit the attribute when selection is disabled. */
+    rowAriaSelected(row: T): 'true' | 'false' | null;
+    /**
+     * @internal Tri-state summary of the current selection vs. the visible data snapshot.
+     * `'none'` — nothing selected; `'some'` — partial; `'all'` — every snapshot row is selected.
+     */
+    readonly masterSelectionState: _angular_core.Signal<"none" | "some" | "all">;
+    /** @internal Whether the master "select all" checkbox should render checked. */
+    readonly masterChecked: _angular_core.Signal<boolean>;
+    /** @internal Whether the master "select all" checkbox should render indeterminate. */
+    readonly masterIndeterminate: _angular_core.Signal<boolean>;
+    /** @internal Wires the master checkbox change event to `selectAll` / `clearSelection`. */
+    toggleMasterSelection(checked: boolean): void;
+    /** @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>;
+}
+
+export { CellDefDirective, ColumnComponent, DEFAULT_TABLE_LABELS, FooterCellDefDirective, HeaderCellDefDirective, NoDataRowDirective, RowExpansionDirective, TableComponent };
+export type { TwCellContext, TwColumnAlign, TwColumnAriaSort, TwColumnDisplay, TwColumnSticky, TwFooterCellContext, TwHeaderCellContext, TwRowClickEvent, TwRowContext, TwRowExpansionChangeEvent, TwRowExpansionContext, TwSelectionChangeEvent, TwTableAppearance, TwTableDataSourceInput, TwTableDensity, TwTableLabels, TwTableLayout, TwTableResponsive, TwTableResponsiveMode, TwTableSelection, TwTableSticky, TwTableVariant };

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

@@ -0,0 +1,121 @@
+import * as _angular_core from '@angular/core';
+import { TemplateRef, AfterViewInit, ElementRef } from '@angular/core';
+import { FocusableOption } from '@angular/cdk/a11y';
+import { TabTriggerVariant, TwColor, TwSize } from '@cdevhub/ngx-tw/core';
+
+/** Visual style of the tab strip. */
+type TabsVariant = TabTriggerVariant;
+declare class TabTriggerDirective {
+    readonly templateRef: TemplateRef<any>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TabTriggerDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<TabTriggerDirective, "ng-template[twTabTrigger]", never, {}, {}, never, never, true, never>;
+}
+declare class TabContentDirective {
+    readonly templateRef: TemplateRef<any>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TabContentDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<TabContentDirective, "ng-template[twTabContent]", never, {}, {}, never, never, true, never>;
+}
+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. */
+    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. */
+    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>;
+    /** @internal Custom trigger template, if provided. */
+    readonly triggerTemplate: _angular_core.Signal<TabTriggerDirective | undefined>;
+    /** @internal Custom content template, if provided via twTabContent. */
+    readonly contentTemplate: _angular_core.Signal<TabContentDirective | undefined>;
+    /** @internal Implicit content template wrapping ng-content. */
+    readonly implicitContentTemplate: _angular_core.Signal<TemplateRef<unknown> | undefined>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TabComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TabComponent, "tw-tab", never, { "value": { "alias": "value"; "required": true; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "closable": { "alias": "closable"; "required": false; "isSignal": true; }; "lazy": { "alias": "lazy"; "required": false; "isSignal": true; }; }, {}, ["triggerTemplate", "contentTemplate"], ["*"], true, never>;
+}
+declare class TabTriggerElementDirective implements FocusableOption {
+    readonly elementRef: ElementRef<any>;
+    readonly isActive: _angular_core.InputSignal<boolean>;
+    readonly isDisabled: _angular_core.InputSignal<boolean>;
+    readonly tabIndex: _angular_core.Signal<0 | -1>;
+    focus(): void;
+    /**
+     * FocusableOption getter. NOTE: we cannot expose the `isDisabled` input
+     * signal directly — the signal function itself is always truthy, which would
+     * make FocusKeyManager treat every trigger as disabled. We resolve the
+     * signal here so the manager skips the right items.
+     */
+    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>;
+}
+declare class TabsComponent implements AfterViewInit {
+    /** Controls the visual style of the tab strip. Defaults to 'underline'. */
+    readonly variant: _angular_core.InputSignal<TabTriggerVariant>;
+    /** Sets the semantic color for active tab indicators and highlights. Defaults to 'primary'. */
+    readonly color: _angular_core.InputSignal<TwColor>;
+    /** Controls padding, font size, and icon size of tab triggers. Defaults to 'md'. */
+    readonly size: _angular_core.InputSignal<TwSize>;
+    /** Layout direction of the tab strip. Defaults to 'horizontal'. */
+    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. */
+    readonly value: _angular_core.ModelSignal<string>;
+    /** Fires when a closable tab's close button is clicked. Payload is the tab's value. */
+    readonly closed: _angular_core.OutputEmitterRef<string>;
+    private readonly destroyRef;
+    private readonly liveAnnouncer;
+    /** @internal */
+    readonly tabs: _angular_core.Signal<readonly TabComponent[]>;
+    /** @internal */
+    readonly triggerElements: _angular_core.Signal<readonly TabTriggerElementDirective[]>;
+    /** @internal */
+    readonly tablistInnerRef: _angular_core.Signal<ElementRef<HTMLElement> | undefined>;
+    private readonly componentId;
+    readonly activeValue: _angular_core.WritableSignal<string>;
+    readonly activatedTabs: _angular_core.WritableSignal<Set<string>>;
+    readonly canScrollStart: _angular_core.WritableSignal<boolean>;
+    readonly canScrollEnd: _angular_core.WritableSignal<boolean>;
+    private resizeObserver;
+    private scrollCleanup;
+    private readonly layoutResult;
+    private readonly triggerResult;
+    readonly rootClasses: _angular_core.Signal<string>;
+    readonly tablistClasses: _angular_core.Signal<string>;
+    readonly tablistInnerClasses: _angular_core.Signal<string>;
+    readonly baseTriggerClasses: _angular_core.Signal<string>;
+    readonly panelClasses: _angular_core.Signal<string>;
+    readonly scrollButtonClasses: _angular_core.Signal<string>;
+    readonly closeButtonClasses: _angular_core.Signal<string>;
+    /** @internal Get combined trigger classes for a given tab. */
+    getTriggerClasses(_tabValue: string, isActive: boolean): string;
+    getTabId(tabValue: string): string;
+    getPanelId(tabValue: string): string;
+    isTabActive(tabValue: string): boolean;
+    shouldRenderPanel(tab: TabComponent): boolean;
+    selectTab(tab: TabComponent): void;
+    closeTab(tab: TabComponent, event: Event): void;
+    private findNearestEnabledTab;
+    private keyManager;
+    /**
+     * @internal Handles keyboard navigation. The manager handles Arrow/Home/End;
+     * we layer Enter/Space to select the focused tab (the wrapper is a `<div role="tab">`
+     * so we lose the native button activation) and Delete to close a closable tab.
+     */
+    onKeydown(event: KeyboardEvent): void;
+    scrollStart(): void;
+    scrollEnd(): void;
+    private updateScrollState;
+    ngAfterViewInit(): void;
+    constructor();
+    private initializeActiveTab;
+    private setupScrollDetection;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TabsComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TabsComponent, "tw-tabs", never, { "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "color": { "alias": "color"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "orientation": { "alias": "orientation"; "required": false; "isSignal": true; }; "fitted": { "alias": "fitted"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; "closed": "closed"; }, ["tabs"], ["*"], true, never>;
+}
+
+export { TabComponent, TabContentDirective, TabTriggerDirective, TabsComponent };
+export type { TabsVariant };