ngwr 7.3.0 → 9.0.0

package/types/ngwr-switch.d.ts

@@ -1,39 +1,47 @@
 import * as _angular_core from '@angular/core';
-import { ControlValueAccessor } from '@angular/forms';
+import { FormCheckboxControl } from '@angular/forms/signals';
 
 /**
- * Boolean toggle with an iOS-style slider. Implements `ControlValueAccessor`.
+ * Boolean toggle with an iOS-style slider.
+ *
+ * A signal-forms native control: it implements `FormCheckboxControl`, so
+ * `[formField]` binds straight to its `checked` model — no
+ * `ControlValueAccessor` in between. `[(checked)]` works standalone.
  *
  * @example
  * ```html
- * <wr-switch [(ngModel)]="enabled">Notifications</wr-switch>
+ * <!-- signal forms -->
+ * <wr-switch [formField]="form.notifications">Notifications</wr-switch>
+ *
+ * <!-- standalone two-way binding -->
+ * <wr-switch [(checked)]="enabled">Notifications</wr-switch>
  * ```
  *
- * @see https://ngwr.dev/components/switch
+ * @see https://ngwr.dev/reference/components/switch
  */
-declare class WrSwitch implements ControlValueAccessor {
+type WrSwitchSize = 'sm' | 'md' | 'lg';
+declare class WrSwitch implements FormCheckboxControl {
     /** Stable id used to associate the native input with its label. */
     readonly id: _angular_core.InputSignal<string>;
     /**
-     * Disable the switch. Also set by Angular forms via `setDisabledState`.
+     * Disable the switch. Bound automatically from the field's disabled state
+     * when used with `[formField]`.
      *
      * @default false
      */
     readonly disabled: _angular_core.InputSignalWithTransform<boolean, any>;
-    protected readonly checked: _angular_core.WritableSignal<boolean>;
-    private readonly disabledFromCva;
-    protected readonly effectiveDisabled: _angular_core.Signal<boolean>;
+    /** Control size — shares the `--wr-control-*` contract. @default 'md' */
+    readonly size: _angular_core.InputSignal<WrSwitchSize>;
+    /** On / off state. Bound by `[formField]`, or two-way via `[(checked)]`. */
+    readonly checked: _angular_core.ModelSignal<boolean>;
+    /** Emitted on blur so a bound field can mark itself touched. */
+    readonly touch: _angular_core.OutputEmitterRef<void>;
     protected readonly classes: _angular_core.Signal<string>;
-    private onChange;
-    private onTouched;
-    writeValue(value: boolean | null): void;
-    registerOnChange(fn: (value: boolean) => void): void;
-    registerOnTouched(fn: () => void): void;
-    setDisabledState(isDisabled: boolean): void;
     protected onInputChange(event: Event): void;
     protected onInputBlur(): void;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<WrSwitch, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<WrSwitch, "wr-switch", never, { "id": { "alias": "id"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<WrSwitch, "wr-switch", never, { "id": { "alias": "id"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "checked": { "alias": "checked"; "required": false; "isSignal": true; }; }, { "checked": "checkedChange"; "touch": "touch"; }, never, ["*"], true, never>;
 }
 
 export { WrSwitch };
+export type { WrSwitchSize };

package/types/ngwr-table.d.ts

@@ -1,5 +1,6 @@
 import * as _angular_core from '@angular/core';
 import { TemplateRef } from '@angular/core';
+import { CdkDragDrop } from '@angular/cdk/drag-drop';
 
 /**
  * @license
@@ -67,6 +68,11 @@ interface WrTableFilterChange {
  * found in the LICENSE file at https://github.com/thekhegay/ngwr/blob/main/LICENSE
  */
 
+/**
+ * A column's footer aggregate — a built-in over its numeric values, or a
+ * function given all rows that returns the value to display.
+ */
+type WrTableSummary = 'sum' | 'avg' | 'count' | 'min' | 'max' | ((rows: readonly Record<string, unknown>[]) => unknown);
 /** A single column definition. */
 interface WrTableColumn {
     /** Heading shown in the column's header. */
@@ -75,6 +81,22 @@ interface WrTableColumn {
     readonly sortable?: boolean;
     /** When non-empty, shows a filter dropdown in the header. */
     readonly filterItems?: readonly WrTableFilterItem[];
+    /**
+     * Freeze the column against the left or right edge — it stays visible while
+     * the rest of the table scrolls horizontally. Pin the leftmost columns
+     * `'left'` and the rightmost `'right'`; several per side stack in order.
+     */
+    readonly pin?: 'left' | 'right';
+    /** Show a drag handle on the header edge to resize the column. */
+    readonly resizable?: boolean;
+    /** Initial column width in px. Overridden once the user drags to resize. */
+    readonly width?: number;
+    /**
+     * Footer aggregate for this column — renders a summary row when any column
+     * sets it. Computed over the current `items`, so in server-side mode
+     * (`totalItems` set) it reflects the current page, not the whole dataset.
+     */
+    readonly summary?: WrTableSummary;
 }
 /**
  * Column map — keys are the row's property names; values are column defs.
@@ -109,6 +131,87 @@ interface WrTableCellContext {
     readonly column: WrTableColumn;
 }
 
+/**
+ * @license
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://github.com/thekhegay/ngwr/blob/main/LICENSE
+ */
+/** Options for `WrTable.toCsv()` / `WrTable.exportCsv()`. */
+interface WrTableCsvOptions {
+    /** Download filename. @default 'table.csv' */
+    readonly filename?: string;
+    /** Export only the selected rows (needs `rowSelection`). @default false */
+    readonly selectedOnly?: boolean;
+    /** Field delimiter — use `';'` for locales where Excel expects it. @default ',' */
+    readonly delimiter?: string;
+    /**
+     * Prefix string values starting with `= + - @` with a quote so spreadsheets
+     * treat them as text instead of formulas. @default true
+     */
+    readonly escapeFormulas?: boolean;
+}
+
+/**
+ * @license
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://github.com/thekhegay/ngwr/blob/main/LICENSE
+ */
+/**
+ * Context passed to a `[wrTableExpand]` detail template.
+ */
+interface WrTableExpandContext {
+    /** The expanded row. Use as `let-row`. */
+    readonly $implicit: Record<string, unknown>;
+    /** The expanded row (alias of `$implicit`). */
+    readonly row: Record<string, unknown>;
+}
+
+/**
+ * @license
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://github.com/thekhegay/ngwr/blob/main/LICENSE
+ */
+/**
+ * Context of one rendered row group — passed to a `[wrTableGroupHeader]`
+ * template and used to build the built-in band. One is produced per group on
+ * the current page (grouping runs after pagination).
+ */
+interface WrTableGroupContext {
+    /** The group value returned by `groupBy` (alias of `value`). Use as `let-group`. */
+    readonly $implicit: unknown;
+    /** The group value. Also the identity stored in `collapsedGroups`. */
+    readonly value: unknown;
+    /** Default label — `String(value)`, or `'—'` for `null` / `undefined` / `''`. */
+    readonly label: string;
+    /** The group's rows on the current page, in page order. */
+    readonly rows: readonly Record<string, unknown>[];
+    /** `rows.length` — the group's row count on the current page. */
+    readonly count: number;
+    /** Whether the group is currently collapsed. */
+    readonly collapsed: boolean;
+    /** 0-based index of the group on the current page. */
+    readonly index: number;
+    /** Collapse / expand this group — wire it to a custom header's own control. */
+    readonly toggle: () => void;
+}
+
+/** One `<tbody>` row descriptor. Not exported — same precedent as the tree's flat node. */
+type RenderRow = {
+    readonly kind: 'group';
+    readonly id: string;
+    readonly group: WrTableGroupContext;
+} | {
+    readonly kind: 'row';
+    readonly id: string;
+    readonly row: Record<string, unknown>;
+} | {
+    readonly kind: 'group-foot';
+    readonly id: string;
+    readonly summaries: ReadonlyMap<string, unknown>;
+};
 /**
  * Data table with sortable / filterable headers and custom cell templates.
  *
@@ -130,7 +233,7 @@ interface WrTableCellContext {
  * </wr-table>
  * ```
  *
- * @see https://ngwr.dev/components/table
+ * @see https://ngwr.dev/reference/components/table
  */
 declare class WrTable {
     /** Column definitions, keyed by row property name. */
@@ -145,6 +248,62 @@ declare class WrTable {
      * cell shows its column title as a label. @default false
      */
     readonly responsive: _angular_core.InputSignalWithTransform<boolean, any>;
+    /** Enable drag-to-reorder on the column headers. @default false */
+    readonly reorderable: _angular_core.InputSignalWithTransform<boolean, any>;
+    /**
+     * Two-way bindable column order — an array of column keys. Reflects and drives
+     * the header order: the table falls back to declaration order for any key not
+     * listed, and updates this on drag. Bind it to persist a user's arrangement.
+     */
+    readonly columnOrder: _angular_core.ModelSignal<readonly string[]>;
+    /**
+     * Row selection with a leading checkbox column — `'multiple'` adds a
+     * select-all header; `'single'` keeps one row selected. @default null (off)
+     */
+    readonly rowSelection: _angular_core.InputSignal<"single" | "multiple" | null>;
+    /**
+     * How to identify a row for selection — a property name or a function.
+     * Unset uses the row object itself (fine for a stable row array).
+     */
+    readonly rowKey: _angular_core.InputSignal<string | ((row: Record<string, unknown>) => unknown) | null>;
+    /** Two-way bindable selected row keys. */
+    readonly selection: _angular_core.ModelSignal<readonly unknown[]>;
+    /** Two-way bindable expanded row keys (needs a `[wrTableExpand]` template). */
+    readonly expanded: _angular_core.ModelSignal<readonly unknown[]>;
+    /**
+     * Group rows under collapsible band headers — a row property name, or a
+     * function returning the group value. `null` (default) renders the table
+     * exactly as before.
+     *
+     * Grouping runs AFTER pagination: it buckets the rows on the current page in
+     * first-appearance order (it never re-sorts your data — same contract as
+     * `[(sort)]`), so a group straddling a page boundary shows a band on both
+     * pages, and per-group counts / subtotals are page-scoped. Sort `items` by the
+     * same key upstream to keep groups whole, or pair with `pageSize = 0`.
+     *
+     * Group values are compared by identity (`Map`/`Set`, SameValueZero) — return
+     * a primitive, exactly as for `rowKey`. Objects / `Date`s bucket by reference.
+     *
+     * @default null
+     */
+    readonly groupBy: _angular_core.InputSignal<string | ((row: Record<string, unknown>) => unknown) | null>;
+    /**
+     * Two-way bindable collapsed group values (the values `groupBy` returns).
+     * Keyed by value, so a collapsed group stays collapsed across page changes and
+     * re-sorts. Empty (the default) shows every group expanded.
+     */
+    readonly collapsedGroups: _angular_core.ModelSignal<readonly unknown[]>;
+    /**
+     * Render an aggregate row under each group using the same `column.summary`
+     * definitions as the grand footer, computed over that group's rows on the
+     * current page. No-op unless at least one column defines a `summary`. The grand
+     * `<tfoot>` is unaffected and still aggregates the whole client dataset — with
+     * client-side pagination the two describe different scopes, so pair grouping
+     * with `pageSize = 0` when you need them to reconcile. @default false
+     */
+    readonly groupSummary: _angular_core.InputSignalWithTransform<boolean, any>;
+    /** Show the page-scoped row-count badge in each group band. @default true */
+    readonly showGroupCount: _angular_core.InputSignalWithTransform<boolean, any>;
     /** Two-way bindable sort array. Order in array = application order. */
     readonly sort: _angular_core.ModelSignal<readonly WrTableSortState[]>;
     /** Fires whenever a column's filter selection changes. */
@@ -162,6 +321,42 @@ declare class WrTable {
      * page's slice yourself and react to `(page)` changes).
      */
     readonly totalItems: _angular_core.InputSignal<number | null>;
+    /**
+     * Window the `<tbody>` so a table of thousands of rows keeps only ~one
+     * viewport of `<tr>`s in the DOM. Opt-in and OFF by default — a table
+     * without it renders byte-identically to today.
+     *
+     * Engages ONLY on the flat, fixed-height tier: it silently falls back to the
+     * full render whenever a variable-height layout is active — `groupBy`, a
+     * `[wrTableExpand]` template, `responsive` card mode, or a visible pager
+     * (`pageSize > 0` / `totalItems`). While on, it forces fixed layout for
+     * stable column widths and assumes a uniform row height (see `rowHeight`).
+     *
+     * Intended as static config. Give columns an explicit `width` so the frozen
+     * layout is exact (a virtualized table always renders fixed-layout); toggling
+     * it off at runtime leaves the frozen widths in place as column minimums.
+     * @default false
+     */
+    readonly virtualScroll: _angular_core.InputSignalWithTransform<boolean, any>;
+    /**
+     * Uniform body-row height in px used to map scroll offset to row index. `0`
+     * (default) measures the first rendered row once — matching the density at
+     * that point — and reuses it; pass an explicit value to remove the
+     * post-hydration measure and make SSR pixel-exact (recommended if the density
+     * can change at runtime). Read only when `virtualScroll` is on. Keep
+     * virtualized cells single-line and no taller than this — a taller custom
+     * `[wrTableCell]` template drifts the window. @default 0
+     */
+    readonly rowHeight: _angular_core.InputSignalWithTransform<number, unknown>;
+    /**
+     * Height of the scroll viewport when `virtualScroll` is on — a number (px) or
+     * any CSS length (`'70vh'`). Applied as `max-height` on `.wr-table__scroll`
+     * (a short table shrinks to fit; a long one caps and scrolls). A numeric px
+     * value lets the server prerender the exact first window. @default 480
+     */
+    readonly viewportHeight: _angular_core.InputSignal<string | number>;
+    /** Extra rows kept rendered above and below the viewport as scroll headroom. @default 6 */
+    readonly overscan: _angular_core.InputSignalWithTransform<number, unknown>;
     /** Total row count derived for the pager (server-mode wins). */
     protected readonly resolvedTotal: _angular_core.Signal<number>;
     /** Items visible on the current page (client mode slices; server mode passes through). */
@@ -171,8 +366,168 @@ declare class WrTable {
     private readonly cellTemplates;
     /** Map of column key → custom template (if provided via `[wrTableCell]`). */
     protected readonly cellMap: _angular_core.Signal<Map<string, TemplateRef<WrTableCellContext>>>;
-    /** Keep KeyValuePipe in declaration order (comparator that treats all keys as equal). */
-    protected readonly keepOrder: () => number;
+    private readonly platformId;
+    private readonly headerCells;
+    /**
+     * Columns in render order — declaration order, overridden by `columnOrder`
+     * once reordered; new keys append, removed keys drop out. Pin and resize
+     * measurement key off this, so it must equal the rendered order.
+     */
+    protected readonly displayColumns: _angular_core.Signal<readonly {
+        key: string;
+        column: WrTableColumn;
+    }[]>;
+    /**
+     * Sticky offsets for pinned columns, measured from the header cells so any
+     * number of columns can stack per side. Also names the inner-edge column on
+     * each side (where the separating shadow sits). Empty until measured in the
+     * browser; on the server the pins stay at offset 0, corrected on hydration.
+     */
+    private readonly pins;
+    constructor();
+    private measurePins;
+    /** Sticky `left` offset (px) for a left-pinned column, else `null`. */
+    protected leftPin(key: string): number | null;
+    /** Sticky `right` offset (px) for a right-pinned column, else `null`. */
+    protected rightPin(key: string): number | null;
+    /** Whether `key` is the inner-edge pinned column on `side` (carries the shadow). */
+    protected isPinEdge(key: string, side: 'left' | 'right'): boolean;
+    private readonly resizeWidths;
+    private resizeKey;
+    private resizeStartX;
+    private resizeStartWidth;
+    private lastColumnKeys;
+    /**
+     * Once a column has been dragged, the table switches to fixed layout so the
+     * `<col>` widths are honoured exactly (auto layout treats them as minimums).
+     */
+    protected readonly fixedLayout: _angular_core.WritableSignal<boolean>;
+    /** Current width (px) for a column, or `null` for auto — a live resize wins. */
+    protected colWidth(key: string): number | null;
+    /** Freeze every column at its current rendered header width (skips frozen keys). */
+    private freezeColumnWidths;
+    protected onResizeStart(event: PointerEvent, key: string, th: HTMLElement): void;
+    protected onResizeMove(event: PointerEvent): void;
+    protected onResizeEnd(event: PointerEvent): void;
+    /** md-density fallback row height (px), used before measuring / on the server. */
+    private static readonly FALLBACK_ROW_PX;
+    private static readonly FALLBACK_VIEWPORT_PX;
+    /** The `.wr-table__scroll` div (always in the template; only read when virtual). */
+    private readonly scrollEl;
+    /** Live vertical scroll offset (px); 0 on the server / before first scroll. */
+    private readonly scrollTop;
+    /** Measured viewport clientHeight (px); 0 until the browser observer fires. */
+    private readonly viewportPx;
+    /** Measured first-row height (px) when `rowHeight` is auto; 0 until measured. */
+    private readonly measuredRowPx;
+    /** Fixed layout forced ON by virtualization (distinct from the resize latch). */
+    private readonly virtualFixed;
+    /** `virtualScroll` requested AND the data shape is safe to window. SSR-deterministic. */
+    protected readonly virtualized: _angular_core.Signal<boolean>;
+    /** Effective uniform row height (px). */
+    protected readonly effRowH: _angular_core.Signal<number>;
+    /** Deterministic viewport px for SSR + first paint (numeric height, else fallback). */
+    private readonly fallbackViewportPx;
+    /** `viewportHeight` as a CSS length for the inline max-height. */
+    protected readonly resolvedViewportHeight: _angular_core.Signal<string>;
+    /** Rendered window [start,end) + spacer pads (px). Pure math, O(1) per scroll frame. */
+    protected readonly virtualWindow: _angular_core.Signal<{
+        start: number;
+        end: number;
+        padTop: number;
+        padBottom: number;
+    }>;
+    /** Flat index of the first rendered window row (for `aria-rowindex`). */
+    protected readonly windowStart: _angular_core.Signal<number>;
+    /** Rows placed in `<tbody>`. SAME array instance as `renderRows()` when off → byte-identical DOM. */
+    protected readonly windowRows: _angular_core.Signal<readonly RenderRow[]>;
+    /** Fixed layout is on when a resize drag latched it OR virtualization forces it. */
+    protected readonly fixedLayoutActive: _angular_core.Signal<boolean>;
+    /** Scroll a flat row index to the top of the virtual viewport. No-op on the server / when not virtual. */
+    scrollToRow(index: number, behavior?: ScrollBehavior): void;
+    protected onColumnDrop(event: CdkDragDrop<unknown>): void;
+    /**
+     * Keep pinned columns anchored — a drop can't land on a pinned column's slot,
+     * so a scrollable column can't be dragged into the frozen region at either edge.
+     */
+    protected readonly sortPredicate: (index: number) => boolean;
+    private rowKeyOf;
+    /** Keys of the rows on the current page — the select-all scope. */
+    private readonly pageRowKeys;
+    protected isRowSelected(row: Record<string, unknown>): boolean;
+    /** Every current-page row selected (drives the header checkbox). */
+    protected readonly allSelected: _angular_core.Signal<boolean>;
+    /** Some but not all selected (drives the header indeterminate). */
+    protected readonly someSelected: _angular_core.Signal<boolean>;
+    protected toggleRow(row: Record<string, unknown>, checked: boolean): void;
+    /** Add (or remove) a set of row keys from the selection in one update. */
+    private applySelection;
+    protected toggleAll(checked: boolean): void;
+    private readonly expandTpl;
+    /** Whether the expand column shows (a `[wrTableExpand]` template was projected). */
+    protected readonly expandable: _angular_core.Signal<boolean>;
+    /** Leading control columns — selection + expand. */
+    protected readonly leadingCols: _angular_core.Signal<number>;
+    /** Total rendered columns (data + leading), for detail-row / empty colspans. */
+    protected readonly totalCols: _angular_core.Signal<number>;
+    protected expandTemplate(): TemplateRef<WrTableExpandContext> | undefined;
+    protected isExpanded(row: Record<string, unknown>): boolean;
+    protected toggleExpand(row: Record<string, unknown>): void;
+    protected expandContext(row: Record<string, unknown>): WrTableExpandContext;
+    /** Whether any column defines a `summary` (so the footer row shows). */
+    protected readonly hasSummary: _angular_core.Signal<boolean>;
+    /** Per-column footer values, computed over `items` (the current page in server mode). */
+    private readonly summaries;
+    protected summaryFor(key: string): unknown;
+    private readonly groupTpl;
+    protected groupTemplate(): TemplateRef<WrTableGroupContext> | undefined;
+    /**
+     * Rows on the current page bucketed by `groupBy`, in first-appearance order.
+     * Depends only on `visibleItems()` + `groupBy` (not on collapse / summary), so
+     * a collapse toggle never re-buckets. The ungrouped path returns one synthetic
+     * bucket holding the same array instance `visibleItems()` returned.
+     */
+    private readonly groupBuckets;
+    /**
+     * The flat `<tbody>` render list. Ungrouped it is exactly today's rows in
+     * order (the rendered elements are unchanged; only the `@for` track identity
+     * moves to a stable id). Returns `[]` for both no-rows and loading — the
+     * template's `@if (visibleItems())` guard keeps the loading case from showing
+     * the empty row.
+     */
+    protected readonly renderRows: _angular_core.Signal<readonly RenderRow[]>;
+    /** Default band label — the primitive as text, `'—'` for empty, JSON for objects. */
+    private groupLabelOf;
+    protected toggleGroupCollapse(value: unknown): void;
+    /** Collapse every group on the current page. No-op when `groupBy` is unset. */
+    collapseAllGroups(): void;
+    /** Expand every group. */
+    expandAllGroups(): void;
+    /** Memoized selection as a Set — O(1) membership for row + group + select-all checks. */
+    private readonly selectionSet;
+    protected groupChecked(rows: readonly Record<string, unknown>[]): boolean;
+    protected groupIndeterminate(rows: readonly Record<string, unknown>[]): boolean;
+    protected toggleGroupSelection(rows: readonly Record<string, unknown>[], checked: boolean): void;
+    private readonly doc;
+    /**
+     * Build the table as an RFC-4180 CSV string — a header row from the column
+     * titles, then one row per item in the current column order. Values are taken
+     * from the row data, not from custom `[wrTableCell]` templates.
+     *
+     * Covers the current `items`, so in server-side mode (`totalItems` set) it
+     * exports the current page, while client-side pagination exports every page.
+     *
+     * @example
+     * ```html
+     * <wr-table #table [columns]="columns" [items]="rows" />
+     * <wr-btn (click)="table.exportCsv({ filename: 'users.csv' })">Export</wr-btn>
+     * ```
+     */
+    toCsv(options?: WrTableCsvOptions): string;
+    /** Download the table as a CSV file. No-op on the server. */
+    exportCsv(options?: WrTableCsvOptions): void;
+    private selectedRows;
+    private computeSummary;
     protected directionFor(key: string): WrTableSortDirection;
     protected cycleSort(key: string): void;
     protected onFilter(key: string, items: readonly WrTableFilterItem[]): void;
@@ -180,7 +535,7 @@ declare class WrTable {
     protected getValue(item: Record<string, unknown>, key: unknown): unknown;
     protected templateFor(key: unknown): TemplateRef<WrTableCellContext> | undefined;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<WrTable, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<WrTable, "wr-table", never, { "columns": { "alias": "columns"; "required": true; "isSignal": true; }; "items": { "alias": "items"; "required": false; "isSignal": true; }; "loading": { "alias": "loading"; "required": false; "isSignal": true; }; "responsive": { "alias": "responsive"; "required": false; "isSignal": true; }; "sort": { "alias": "sort"; "required": false; "isSignal": true; }; "pageSize": { "alias": "pageSize"; "required": false; "isSignal": true; }; "page": { "alias": "page"; "required": false; "isSignal": true; }; "totalItems": { "alias": "totalItems"; "required": false; "isSignal": true; }; }, { "sort": "sortChange"; "filterChange": "filterChange"; "page": "pageChange"; }, ["cellTemplates"], never, true, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<WrTable, "wr-table", never, { "columns": { "alias": "columns"; "required": true; "isSignal": true; }; "items": { "alias": "items"; "required": false; "isSignal": true; }; "loading": { "alias": "loading"; "required": false; "isSignal": true; }; "responsive": { "alias": "responsive"; "required": false; "isSignal": true; }; "reorderable": { "alias": "reorderable"; "required": false; "isSignal": true; }; "columnOrder": { "alias": "columnOrder"; "required": false; "isSignal": true; }; "rowSelection": { "alias": "rowSelection"; "required": false; "isSignal": true; }; "rowKey": { "alias": "rowKey"; "required": false; "isSignal": true; }; "selection": { "alias": "selection"; "required": false; "isSignal": true; }; "expanded": { "alias": "expanded"; "required": false; "isSignal": true; }; "groupBy": { "alias": "groupBy"; "required": false; "isSignal": true; }; "collapsedGroups": { "alias": "collapsedGroups"; "required": false; "isSignal": true; }; "groupSummary": { "alias": "groupSummary"; "required": false; "isSignal": true; }; "showGroupCount": { "alias": "showGroupCount"; "required": false; "isSignal": true; }; "sort": { "alias": "sort"; "required": false; "isSignal": true; }; "pageSize": { "alias": "pageSize"; "required": false; "isSignal": true; }; "page": { "alias": "page"; "required": false; "isSignal": true; }; "totalItems": { "alias": "totalItems"; "required": false; "isSignal": true; }; "virtualScroll": { "alias": "virtualScroll"; "required": false; "isSignal": true; }; "rowHeight": { "alias": "rowHeight"; "required": false; "isSignal": true; }; "viewportHeight": { "alias": "viewportHeight"; "required": false; "isSignal": true; }; "overscan": { "alias": "overscan"; "required": false; "isSignal": true; }; }, { "columnOrder": "columnOrderChange"; "selection": "selectionChange"; "expanded": "expandedChange"; "collapsedGroups": "collapsedGroupsChange"; "sort": "sortChange"; "filterChange": "filterChange"; "page": "pageChange"; }, ["cellTemplates", "expandTpl", "groupTpl"], never, true, never>;
 }
 
 /**
@@ -203,6 +558,62 @@ declare class WrTableCell {
     static ɵdir: _angular_core.ɵɵDirectiveDeclaration<WrTableCell, "[wrTableCell]", never, { "columnKey": { "alias": "wrTableCell"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 
+/**
+ * @license
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://github.com/thekhegay/ngwr/blob/main/LICENSE
+ */
+
+/**
+ * Provide the detail template revealed when a row is expanded. Adding it turns
+ * on the leading expand column; the row object is the template's implicit
+ * context.
+ *
+ * @example
+ * ```html
+ * <wr-table [columns]="columns" [items]="items" [(expanded)]="expanded" rowKey="id">
+ *   <ng-template wrTableExpand let-row>
+ *     <p>{{ row.bio }}</p>
+ *   </ng-template>
+ * </wr-table>
+ * ```
+ */
+declare class WrTableExpand {
+    readonly template: TemplateRef<WrTableExpandContext>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<WrTableExpand, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<WrTableExpand, "ng-template[wrTableExpand]", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * @license
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://github.com/thekhegay/ngwr/blob/main/LICENSE
+ */
+
+/**
+ * Provide a custom template for a group band's label area. The collapse chevron
+ * and the optional group checkbox are still rendered by the table around it, so
+ * the template may safely contain its own interactive content. Projecting it
+ * does NOT enable grouping — set `[groupBy]` for that.
+ *
+ * @example
+ * ```html
+ * <wr-table [columns]="columns" [items]="rows" groupBy="department">
+ *   <ng-template wrTableGroupHeader let-value let-count="count" let-toggle="toggle">
+ *     <wr-tag color="primary" (click)="toggle()">{{ value }}</wr-tag>
+ *     <small>{{ count }} people</small>
+ *   </ng-template>
+ * </wr-table>
+ * ```
+ */
+declare class WrTableGroupHeader {
+    readonly template: TemplateRef<WrTableGroupContext>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<WrTableGroupHeader, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<WrTableGroupHeader, "ng-template[wrTableGroupHeader]", never, {}, {}, never, never, true, never>;
+}
+
 /**
  * Sort indicator rendered in a sortable column's header.
  *
@@ -239,5 +650,5 @@ declare class WrTableFilter {
     static ɵcmp: _angular_core.ɵɵComponentDeclaration<WrTableFilter, "wr-table-filter", never, { "items": { "alias": "items"; "required": true; "isSignal": true; }; }, { "selectionChange": "selectionChange"; }, never, never, true, never>;
 }
 
-export { WrTable, WrTableCell, WrTableFilter, WrTableSort };
-export type { WrTableCellContext, WrTableColumn, WrTableColumns, WrTableFilterChange, WrTableFilterItem, WrTableSortDirection, WrTableSortState };
+export { WrTable, WrTableCell, WrTableExpand, WrTableFilter, WrTableGroupHeader, WrTableSort };
+export type { WrTableCellContext, WrTableColumn, WrTableColumns, WrTableCsvOptions, WrTableExpandContext, WrTableFilterChange, WrTableFilterItem, WrTableGroupContext, WrTableSortDirection, WrTableSortState, WrTableSummary };

package/types/ngwr-tabs.d.ts

@@ -91,7 +91,7 @@ declare const WR_TABS: InjectionToken<WrTabsContext>;
  * <router-outlet />
  * ```
  *
- * @see https://ngwr.dev/components/tabs
+ * @see https://ngwr.dev/reference/components/tabs
  */
 declare class WrTabs implements WrTabsContext {
     /** Two-way bindable active tab key (content mode). */