infi-grid 1.0.0

package/index.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Generated bundle index. Do not edit.
+ */
+/// <amd-module name="infi-grid" />
+export * from './public-api';

package/lib/components/cell-editor.component.d.ts

@@ -0,0 +1,42 @@
+import { AfterViewInit, OnChanges, SimpleChanges } from '@angular/core';
+import type { GridEditorOptions, GridSelectOption } from '../models/column.types';
+import type { GridEditContext } from '../models/template.types';
+import * as i0 from "@angular/core";
+/**
+ * Built-in editors: text, number, dropdown (select), checkbox and date picker.
+ * In a normal edit session values are drafts until committed; in grid edit mode (`live`)
+ * each change is saved immediately.
+ */
+export declare class GridCellEditorComponent implements OnChanges, AfterViewInit {
+    context: GridEditContext;
+    /** Grid edit mode: save on every change instead of keeping a draft. */
+    live: boolean;
+    /** The data row (`context.row` can be a copy showing pending values in batch mode). */
+    source: unknown;
+    private inputRef?;
+    private readonly store;
+    private readonly zone;
+    private readonly host;
+    opts: GridEditorOptions;
+    options: readonly GridSelectOption[];
+    error: string | null;
+    private boundRow;
+    private boundField;
+    ngOnChanges(changes: SimpleChanges): void;
+    ngAfterViewInit(): void;
+    /** Puts the current value into the native control (not bound, so typing never loses the caret). */
+    private writeValue;
+    onText(event: Event): void;
+    onChange(event: Event): void;
+    onCheckbox(event: Event): void;
+    onSelect(event: Event): void;
+    onKeydown(event: KeyboardEvent): void;
+    onBlur(): void;
+    private syncDraftFromInput;
+    private setDraft;
+    private save;
+    /** Tab / Shift+Tab: save and edit the next editable cell (wrapping to the next row). */
+    private moveToNextEditable;
+    static ɵfac: i0.ɵɵFactoryDeclaration<GridCellEditorComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<GridCellEditorComponent, "infi-grid-cell-editor", never, { "context": { "alias": "context"; "required": true; }; "live": { "alias": "live"; "required": false; }; "source": { "alias": "source"; "required": false; }; }, {}, never, never, true, never>;
+}

package/lib/components/filter-popup.component.d.ts

@@ -0,0 +1,89 @@
+import type { ResolvedColumn } from '../models/column.types';
+import type { GridText } from '../models/config.types';
+import { type ColumnFilterModel } from '../models/filter.types';
+import type { SortDirection } from '../models/sort.types';
+import { type ValueListItem, type ValueListResult } from '../core/filter-engine';
+import * as i0 from "@angular/core";
+interface ConditionDraft {
+    operator: string;
+    value: string;
+    valueTo: string;
+}
+export interface FilterPopupSetup {
+    column: ResolvedColumn;
+    text: GridText;
+    model: ColumnFilterModel | null;
+    showSortButtons: boolean;
+    sortDirection: SortDirection | null;
+    loadValues: () => ValueListResult;
+    apply: (model: ColumnFilterModel | null) => void;
+    cancel: () => void;
+    sort: (direction: SortDirection) => void;
+    /** Some column is filtered (offers "Clear all filters"). */
+    anyFiltered: boolean;
+    clearAll: () => void;
+}
+/**
+ * Excel-style filter popup: Clear filter, sort buttons, 1 to 5 typed conditions (AND/OR), a searchable checkbox
+ * list of values (virtualized, so 100k distinct values stay fast), and Clear all filters / Cancel / Apply.
+ * Nothing is applied before Apply; Cancel and Escape close without applying.
+ */
+export declare class GridFilterPopupComponent {
+    private readonly host;
+    readonly uid: number;
+    readonly itemHeight = 28;
+    setup: FilterPopupSetup;
+    column: ResolvedColumn;
+    text: GridText;
+    title: string;
+    operators: readonly string[];
+    inputType: string;
+    showConditions: boolean;
+    showValueList: boolean;
+    showSortButtons: boolean;
+    sortDirection: SortDirection | null;
+    private maxConditions;
+    readonly conditions: import("@angular/core").WritableSignal<ConditionDraft[]>;
+    readonly logic: import("@angular/core").WritableSignal<"and" | "or">;
+    readonly search: import("@angular/core").WritableSignal<string>;
+    readonly items: import("@angular/core").WritableSignal<ValueListItem[]>;
+    readonly truncated: import("@angular/core").WritableSignal<boolean>;
+    private readonly selected;
+    private readonly selectionVersion;
+    private readonly listScroll;
+    readonly filteredItems: import("@angular/core").Signal<ValueListItem[]>;
+    readonly listHeight: import("@angular/core").Signal<number>;
+    readonly visibleItems: import("@angular/core").Signal<{
+        item: ValueListItem;
+        index: number;
+    }[]>;
+    readonly allState: import("@angular/core").Signal<"all" | "none" | "some">;
+    readonly canApply: import("@angular/core").Signal<boolean>;
+    /** Another condition can be added: below the maximum, and the last one is complete. */
+    readonly canAddCondition: import("@angular/core").Signal<boolean>;
+    readonly truncatedText: import("@angular/core").Signal<string>;
+    /** Called once by the popup service before the first render. */
+    init(setup: FilterPopupSetup): void;
+    focusFirst(): void;
+    operatorLabel(op: string): string;
+    inputCount(op: string): number;
+    setOperator(index: number, event: Event): void;
+    setConditionValue(index: number, key: 'value' | 'valueTo', event: Event): void;
+    private updateCondition;
+    addCondition(): void;
+    removeCondition(index: number): void;
+    /** A new condition row: the column's default operator, when it takes a value (booleans pick one). */
+    private emptyCondition;
+    private isComplete;
+    onSearch(event: Event): void;
+    onListScroll(event: Event): void;
+    isSelected(item: ValueListItem): boolean;
+    toggle(item: ValueListItem, event: Event): void;
+    toggleAll(event: Event): void;
+    onKeydown(event: KeyboardEvent): void;
+    clear(): void;
+    apply(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<GridFilterPopupComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<GridFilterPopupComponent, "infi-grid-filter-popup", never, {}, {}, never, never, true, never>;
+}
+export {};

package/lib/components/filter-row.component.d.ts

@@ -0,0 +1,104 @@
+import { AfterViewChecked, OnChanges, OnDestroy } from '@angular/core';
+import type { GridText } from '../models/config.types';
+import { type FilterModel } from '../models/filter.types';
+import { type LayoutColumn } from '../state/grid-store';
+import * as i0 from "@angular/core";
+interface FilterCellView {
+    key: string | null;
+    ariaCol: number | null;
+    left: number;
+    width: number;
+    cls: string;
+    /** Booleans use a select instead of the input. */
+    boolean: boolean;
+    inputType: string;
+    text: string;
+    booleanValue: string;
+    /** The applied first condition takes two values (`between`): edited in the popup only. */
+    locked: boolean;
+    /** The operator takes no value (`empty`): the input is disabled. */
+    noInput: boolean;
+    symbol: string;
+    operatorLabel: string;
+    inputLabel: string;
+    active: boolean;
+}
+/**
+ * The filter row (`filtering.mode: 'row' | 'both'`, shown while a displayed column is filterable, see
+ * `GridStore.filterRowHeight`): one cell per column under the header, with an operator button, a typed input
+ * (a select for booleans) and a clear button. It edits the first condition of the column's filter and keeps
+ * the rest (more conditions, the value list), so the popup shows the same filter.
+ *
+ * Cells are pooled like header cells: horizontal scrolling rebinds them. Typed text is kept per field, so a
+ * recycled input never loses it; an input whose column scrolls away is applied and blurred first.
+ */
+export declare class GridFilterRowComponent implements OnChanges, AfterViewChecked, OnDestroy {
+    columns: readonly LayoutColumn[];
+    columnPool: number;
+    filterModel: FilterModel;
+    nonce: number;
+    leading: number;
+    trailing: number;
+    private readonly store;
+    /** Where the pinned regions are placed with syncScroll, or null (sticky): see `GridStore.pinPlacement`. */
+    protected get pins(): {
+        start: number;
+        end: number;
+    } | null;
+    private readonly zone;
+    private readonly cdr;
+    private readonly host;
+    private readonly document;
+    cells: FilterCellView[];
+    text: GridText;
+    /** Typed text not applied yet, by field (survives recycling). */
+    private readonly drafts;
+    /** Operator chosen in the menu, by field (until the filter changes elsewhere). */
+    private readonly operators;
+    private readonly timers;
+    /** Fields this row applied, so their next model change isn't taken as a change from elsewhere. */
+    private readonly ownChanges;
+    private previousModel;
+    /** Field each input slot was last written for (the input values are written by hand, see `ngAfterViewChecked`). */
+    private readonly boundFields;
+    private menu;
+    ngOnChanges(): void;
+    /**
+     * Writes the inputs' values by hand: a value binding only writes when the bound value changes, so a reused
+     * input could keep text typed for another column. An input is written when its slot shows another column,
+     * or when it isn't focused and shows something else (the filter changed elsewhere).
+     */
+    ngAfterViewChecked(): void;
+    ngOnDestroy(): void;
+    /** A filter changed elsewhere (popup, API): the row shows it, unless that column is being typed into. */
+    private syncWithModel;
+    private buildCell;
+    /** The operator of a column's cell: chosen in the menu, else the applied one, else the column default. */
+    private operatorOf;
+    /** Operators offered by the row: the column's, without two-value ones (those are in the popup). */
+    private rowOperators;
+    private inputCount;
+    private operatorLabel;
+    onInput(event: Event, cell: FilterCellView): void;
+    onBoolean(event: Event, cell: FilterCellView): void;
+    onKeydown(event: KeyboardEvent, cell: FilterCellView): void;
+    clear(cell: FilterCellView): void;
+    /** Applies a field's typed text after `filtering.rowDebounce`. */
+    private schedule;
+    private cancelTimer;
+    /** Applies a field's typed text now. */
+    private flush;
+    private parse;
+    /** Sets (or removes) the first condition of a column's filter, keeping its other conditions and value list. */
+    private writeFirst;
+    private refresh;
+    /** Tab / Shift+Tab: the next or previous column's filter, in column order (scrolling it into view). */
+    private moveFocus;
+    openMenu(event: MouseEvent, cell: FilterCellView): void;
+    /** An operator was picked: applied at once when it needs no value or a value is there. */
+    private choose;
+    private applyTheme;
+    static ɵfac: i0.ɵɵFactoryDeclaration<GridFilterRowComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<GridFilterRowComponent, "div[infi-grid-filter-row]", never, { "columns": { "alias": "columns"; "required": false; }; "columnPool": { "alias": "columnPool"; "required": false; }; "filterModel": { "alias": "filterModel"; "required": false; }; "nonce": { "alias": "nonce"; "required": false; }; "leading": { "alias": "leading"; "required": false; }; "trailing": { "alias": "trailing"; "required": false; }; }, {}, never, never, true, never>;
+}
+export {};

package/lib/components/grid.component.d.ts

@@ -0,0 +1,155 @@
+import { EventEmitter, OnChanges, OnInit, SimpleChanges } from '@angular/core';
+import type { GridApi } from '../models/api.types';
+import type { ColumnConfig } from '../models/column.types';
+import type { GridConfig } from '../models/config.types';
+import type { GridChangeSet, GridPendingChangeEvent, GridRowAddedEvent, GridRowAddingEvent, GridRowDeletedEvent, GridRowDeletingEvent, GridRowUpdatedEvent, GridRowUpdatingEvent, GridSaveFailedEvent } from '../models/crud.types';
+import type { GridDataRefreshEvent, GridLoadingChangeEvent } from '../models/data.types';
+import type { GridCellSelectionChangeEvent, GridRowSelectionEvent, GridSelectionChangeEvent, GridSelectionClearedEvent, GridSelectionClickEvent } from '../models/selection.types';
+import type { GridCellEvent, GridCellValueChangeEvent, GridColumnResizeEvent, GridEditEvent, GridErrorEvent, GridFilterChangeEvent, GridHeaderClickEvent, GridReadyEvent, GridRowEvent, GridSortChangeEvent, GridViewportChangeEvent } from '../models/events.types';
+import type { GridDeleteConfirmContext, GridEmptyContext, GridErrorContext, GridLoadingContext, GridTemplate } from '../models/template.types';
+import { GridStore } from '../state/grid-store';
+import * as i0 from "@angular/core";
+interface OverlayState<C> {
+    template: GridTemplate<C> | null;
+    context: C;
+}
+/**
+ * Every Grid API method is also available on the component instance, so a parent can call
+ * `@ViewChild(InfiGridComponent) grid; grid.selectRowByKey(1)` as well as `grid.api.selectRowByKey(1)`.
+ */
+export interface InfiGridComponent<TRow = any> extends GridApi<TRow> {
+}
+/**
+ * `<infi-grid>`: virtualized data grid with Excel-style filtering, multi-sort, editing,
+ * summaries and templates.
+ *
+ * ```html
+ * <infi-grid [data]="rows" [columns]="columns" [config]="config" (gridReady)="api = $event.api" />
+ * ```
+ */
+export declare class InfiGridComponent<TRow = any> implements OnInit, OnChanges {
+    /** The rows to show. */
+    readonly data: import("@angular/core").InputSignal<readonly TRow[] | null | undefined>;
+    /** Column definitions. */
+    readonly columns: import("@angular/core").InputSignal<readonly ColumnConfig<TRow, any>[] | null | undefined>;
+    /** Grid configuration and feature flags. */
+    readonly config: import("@angular/core").InputSignal<GridConfig<TRow> | null | undefined>;
+    /** Shows the loading state. */
+    readonly loading: import("@angular/core").InputSignal<boolean>;
+    /** Shows the error state when set (any value: string, Error, HTTP error…). */
+    readonly error: import("@angular/core").InputSignal<unknown>;
+    readonly gridReady: EventEmitter<GridReadyEvent<TRow>>;
+    readonly sortChange: EventEmitter<GridSortChangeEvent>;
+    readonly filterChange: EventEmitter<GridFilterChangeEvent>;
+    readonly cellValueChange: EventEmitter<GridCellValueChangeEvent<TRow>>;
+    readonly editStart: EventEmitter<GridEditEvent<TRow>>;
+    readonly editCommit: EventEmitter<GridEditEvent<TRow>>;
+    readonly editCancel: EventEmitter<GridEditEvent<TRow>>;
+    readonly cellClick: EventEmitter<GridCellEvent<TRow>>;
+    readonly cellDoubleClick: EventEmitter<GridCellEvent<TRow>>;
+    readonly rowClick: EventEmitter<GridRowEvent<TRow>>;
+    readonly rowDoubleClick: EventEmitter<GridRowEvent<TRow>>;
+    /** A click on a header's label or filter button (before sorting / opening the filter; cancelable). */
+    readonly headerClick: EventEmitter<GridHeaderClickEvent<TRow>>;
+    /** Right click on a cell (`events.preventContextMenu` suppresses the browser menu). */
+    readonly cellContextMenu: EventEmitter<GridCellEvent<TRow>>;
+    /** The pointer entered a cell (identified by row key and field; not fired while scrolling). */
+    readonly cellMouseEnter: EventEmitter<GridCellEvent<TRow>>;
+    /** The pointer left a cell. */
+    readonly cellMouseLeave: EventEmitter<GridCellEvent<TRow>>;
+    readonly columnResize: EventEmitter<GridColumnResizeEvent<TRow>>;
+    /** Emits while scrolling (only computed when you listen to it). */
+    readonly viewportChange: EventEmitter<GridViewportChangeEvent>;
+    /** Errors the grid caught (the grid never logs to the console). */
+    readonly gridError: EventEmitter<GridErrorEvent>;
+    /** The effective loading state changed (from `[loading]` or `setLoading()`). */
+    readonly loadingChange: EventEmitter<GridLoadingChangeEvent>;
+    /** The data was replaced or refreshed and the grid state was reconciled with it. */
+    readonly dataRefresh: EventEmitter<GridDataRefreshEvent>;
+    /** The selection changed (once per operation, with the added/removed rows and the old/new selection). */
+    readonly selectionChange: EventEmitter<GridSelectionChangeEvent<TRow>>;
+    /** Rows were selected by one operation. */
+    readonly rowSelected: EventEmitter<GridRowSelectionEvent<TRow>>;
+    /** Rows were deselected by one operation. */
+    readonly rowDeselected: EventEmitter<GridRowSelectionEvent<TRow>>;
+    /** The selection became empty. */
+    readonly selectionCleared: EventEmitter<GridSelectionClearedEvent<TRow>>;
+    /** A click (or key) is about to change the selection; set `cancel` to prevent it. */
+    readonly selectionClick: EventEmitter<GridSelectionClickEvent<TRow>>;
+    /** The selected cell changed (`cellSelection.enabled`): click, keyboard, API, or its row or column went away. */
+    readonly cellSelectionChange: EventEmitter<GridCellSelectionChangeEvent<TRow>>;
+    /** A row is about to be added (after validation); set `cancel` to prevent it. */
+    readonly rowAdding: EventEmitter<GridRowAddingEvent<TRow>>;
+    /** A row was added (inline add row or `addRow()`). */
+    readonly rowAdded: EventEmitter<GridRowAddedEvent<TRow>>;
+    /** A row is about to change (inline edit or `updateRow()`); set `cancel` to prevent it. */
+    readonly rowUpdating: EventEmitter<GridRowUpdatingEvent<TRow>>;
+    /** A row changed, with its old values, new values and a copy of the old row. */
+    readonly rowUpdated: EventEmitter<GridRowUpdatedEvent<TRow>>;
+    /** Rows are about to be deleted (after the confirmation); set `cancel` to prevent it. */
+    readonly rowDeleting: EventEmitter<GridRowDeletingEvent<TRow>>;
+    /** Rows were deleted (once per operation). */
+    readonly rowDeleted: EventEmitter<GridRowDeletedEvent<TRow>>;
+    /**
+     * The new data array after an add or delete (the bound array is never changed). Bind `[(data)]="rows"`
+     * to keep your array in sync.
+     */
+    readonly dataChange: EventEmitter<readonly TRow[]>;
+    /** Batch mode: the pending changes were saved (and applied to the data). */
+    readonly changesSaved: EventEmitter<GridChangeSet<TRow>>;
+    /** Batch mode: the pending changes were discarded. */
+    readonly changesCancelled: EventEmitter<GridChangeSet<TRow>>;
+    /** Batch mode: the save handler threw or rejected; the changes are still pending. */
+    readonly changesSaveFailed: EventEmitter<GridSaveFailedEvent<TRow>>;
+    /** Batch mode: the pending changes or the undo history changed. */
+    readonly pendingChange: EventEmitter<GridPendingChangeEvent>;
+    private readonly cellTemplates;
+    private readonly editTemplates;
+    private readonly headerTemplates;
+    private readonly summaryTemplates;
+    private readonly loadingTemplates;
+    private readonly emptyTemplates;
+    private readonly errorTemplates;
+    private readonly deleteConfirmTemplates;
+    private readonly cellTooltipTemplates;
+    private readonly headerTooltipTemplates;
+    protected readonly store: GridStore<TRow>;
+    private readonly zone;
+    private readonly popup;
+    /** Grid reference / API. Also emitted by `(gridReady)`. */
+    readonly api: GridApi<TRow>;
+    private readonly registry;
+    protected readonly hostClass: import("@angular/core").Signal<string>;
+    /** The header plus the filter row (when there is one): overlays start below it. */
+    protected readonly headerBlockHeight: import("@angular/core").Signal<number>;
+    protected readonly overlayBottom: import("@angular/core").Signal<number>;
+    protected readonly blockWhileLoading: import("@angular/core").Signal<boolean>;
+    protected readonly errorOverlay: import("@angular/core").Signal<OverlayState<GridErrorContext<TRow>> | null>;
+    protected readonly emptyOverlay: import("@angular/core").Signal<OverlayState<GridEmptyContext<TRow>> | null>;
+    protected readonly loadingOverlay: import("@angular/core").Signal<OverlayState<GridLoadingContext<TRow>> | null>;
+    /** The batch toolbar: shown in batch mode while there are changes, undo steps, a save or a failed save. */
+    protected readonly batchBar: import("@angular/core").Signal<{
+        text: import("infi-grid").GridText;
+        saving: boolean;
+        failed: boolean;
+        hasChanges: boolean;
+        canUndo: boolean;
+        canRedo: boolean;
+        message: string;
+    } | null>;
+    protected readonly deleteConfirm: import("@angular/core").Signal<OverlayState<GridDeleteConfirmContext<TRow>> | null>;
+    /** Focuses the dialog's confirm button (or the template's first control) when it opens. */
+    private set confirmOverlay(value);
+    private closeConfirm;
+    /** Keeps the focus inside the confirmation (Tab cycles); Escape cancels. */
+    protected onConfirmKeydown(event: KeyboardEvent, context: GridDeleteConfirmContext<TRow>): void;
+    private focusable;
+    constructor();
+    ngOnInit(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    /** Forwards store events to the outputs, always inside Angular's zone. */
+    private wireEvents;
+    static ɵfac: i0.ɵɵFactoryDeclaration<InfiGridComponent<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<InfiGridComponent<any>, "infi-grid", never, { "data": { "alias": "data"; "required": false; "isSignal": true; }; "columns": { "alias": "columns"; "required": false; "isSignal": true; }; "config": { "alias": "config"; "required": false; "isSignal": true; }; "loading": { "alias": "loading"; "required": false; "isSignal": true; }; "error": { "alias": "error"; "required": false; "isSignal": true; }; }, { "gridReady": "gridReady"; "sortChange": "sortChange"; "filterChange": "filterChange"; "cellValueChange": "cellValueChange"; "editStart": "editStart"; "editCommit": "editCommit"; "editCancel": "editCancel"; "cellClick": "cellClick"; "cellDoubleClick": "cellDoubleClick"; "rowClick": "rowClick"; "rowDoubleClick": "rowDoubleClick"; "headerClick": "headerClick"; "cellContextMenu": "cellContextMenu"; "cellMouseEnter": "cellMouseEnter"; "cellMouseLeave": "cellMouseLeave"; "columnResize": "columnResize"; "viewportChange": "viewportChange"; "gridError": "gridError"; "loadingChange": "loadingChange"; "dataRefresh": "dataRefresh"; "selectionChange": "selectionChange"; "rowSelected": "rowSelected"; "rowDeselected": "rowDeselected"; "selectionCleared": "selectionCleared"; "selectionClick": "selectionClick"; "cellSelectionChange": "cellSelectionChange"; "rowAdding": "rowAdding"; "rowAdded": "rowAdded"; "rowUpdating": "rowUpdating"; "rowUpdated": "rowUpdated"; "rowDeleting": "rowDeleting"; "rowDeleted": "rowDeleted"; "dataChange": "dataChange"; "changesSaved": "changesSaved"; "changesCancelled": "changesCancelled"; "changesSaveFailed": "changesSaveFailed"; "pendingChange": "pendingChange"; }, ["cellTemplates", "editTemplates", "headerTemplates", "summaryTemplates", "loadingTemplates", "emptyTemplates", "errorTemplates", "deleteConfirmTemplates", "cellTooltipTemplates", "headerTooltipTemplates"], never, true, never>;
+}
+export {};

package/lib/components/header-row.component.d.ts

@@ -0,0 +1,76 @@
+import { OnChanges } from '@angular/core';
+import type { GridStyleValue, ResolvedColumn } from '../models/column.types';
+import type { FilterModel } from '../models/filter.types';
+import type { SortModelItem } from '../models/sort.types';
+import type { GridHeaderContext, GridTemplate } from '../models/template.types';
+import { type LayoutColumn } from '../state/grid-store';
+import * as i0 from "@angular/core";
+interface HeaderView {
+    key: string | null;
+    col: ResolvedColumn | null;
+    header: string;
+    /** Native `title` (only when the grid's tooltips are off). */
+    title: string | null;
+    ariaCol: number | null;
+    left: number;
+    width: number;
+    cls: string;
+    style: GridStyleValue | null;
+    sortable: boolean;
+    ariaSort: 'ascending' | 'descending' | 'none' | null;
+    sortIndexText: string;
+    sortIconCls: string;
+    filterBtnCls: string;
+    filterLabel: string | null;
+    filterActive: boolean;
+    resizeCls: string;
+    template: GridTemplate<GridHeaderContext> | null;
+    context: GridHeaderContext | null;
+}
+/**
+ * The single header row: labels/templates, sort icon with sort order, filter button, resize handle.
+ * Header cells use the same slot pool as body cells and toggle icons with CSS classes,
+ * so horizontal scrolling never creates or destroys views.
+ */
+export declare class GridHeaderRowComponent implements OnChanges {
+    columns: readonly LayoutColumn[];
+    columnPool: number;
+    templatePool: number;
+    sortModel: readonly SortModelItem[];
+    filterModel: FilterModel;
+    openFilterField: string | null;
+    nonce: number;
+    /** Width of the pinned checkbox cell (0: no checkbox column). */
+    leading: number;
+    /** Show the select-all checkbox. */
+    selectAll: boolean;
+    selectionState: 'none' | 'some' | 'all';
+    /** Width of the pinned action column (0: none). */
+    trailing: number;
+    private readonly store;
+    /** Where the pinned regions are placed with syncScroll, or null (sticky): see `GridStore.pinPlacement`. */
+    protected get pins(): {
+        start: number;
+        end: number;
+    } | null;
+    private readonly zone;
+    headers: HeaderView[];
+    templateHeaders: HeaderView[];
+    selectAllLabel: string;
+    text: import("infi-grid").GridText;
+    showAdd: boolean;
+    actionsAriaCol: number;
+    private resizing;
+    private ariaColOffset;
+    ngOnChanges(): void;
+    private buildHeader;
+    /** Emits `(headerClick)`; returns true when a handler cancelled the built-in reaction. */
+    private emitHeaderClick;
+    onHeaderClick(event: MouseEvent, h: HeaderView): void;
+    onSelectAll(event: MouseEvent): void;
+    onFilterClick(event: MouseEvent, h: HeaderView): void;
+    onResizeStart(event: PointerEvent, h: HeaderView): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<GridHeaderRowComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<GridHeaderRowComponent, "div[infi-grid-header-row]", never, { "columns": { "alias": "columns"; "required": false; }; "columnPool": { "alias": "columnPool"; "required": false; }; "templatePool": { "alias": "templatePool"; "required": false; }; "sortModel": { "alias": "sortModel"; "required": false; }; "filterModel": { "alias": "filterModel"; "required": false; }; "openFilterField": { "alias": "openFilterField"; "required": false; }; "nonce": { "alias": "nonce"; "required": false; }; "leading": { "alias": "leading"; "required": false; }; "selectAll": { "alias": "selectAll"; "required": false; }; "selectionState": { "alias": "selectionState"; "required": false; }; "trailing": { "alias": "trailing"; "required": false; }; }, {}, never, never, true, never>;
+}
+export {};

package/lib/components/row.component.d.ts

@@ -0,0 +1,106 @@
+import { OnChanges, SimpleChanges } from '@angular/core';
+import type { GridClassValue, GridStyleValue } from '../models/column.types';
+import type { GridCellContext, GridEditContext, GridTemplate } from '../models/template.types';
+import { type EditSession, type LayoutColumn } from '../state/grid-store';
+import * as i0 from "@angular/core";
+/** `text` cells (also booleans and empty slots) are a single element with `textContent`. */
+type CellKind = 'text' | 'template' | 'editor';
+interface CellView {
+    key: string | null;
+    ariaCol: number | null;
+    /** `aria-selected` with cell selection (`'true'` on the selected cell), else null (no attribute). */
+    ariaSelected: 'true' | 'false' | null;
+    left: number;
+    width: number;
+    cls: string;
+    style: GridStyleValue | null;
+    kind: CellKind;
+    text: string;
+    template: GridTemplate<any> | null;
+    context: GridCellContext | GridEditContext | null;
+}
+export declare function classList(value: GridClassValue): string;
+/**
+ * One grid row. OnPush with plain `@Input`s: it re-renders only when its row, row version,
+ * columns, edit state or focus (with cell selection: the selected cell) change, so updating one cell re-renders one row.
+ *
+ * Cells live in fixed pools of slots: plain cells in `cells` (column `i` → slot `i % columnPool`)
+ * and template cells in `templateCells` (template column `t` → slot `t % templatePool`; with `templateKey`s, a column
+ * takes a slot that last showed a column with the same key, see `assignTemplateSlots`).
+ * Scrolling in any direction therefore rebinds existing elements and template views instead of
+ * creating new ones — creating views would make Angular check the whole application.
+ * Editors (only on rows being edited) are rendered separately in `editorCells`.
+ */
+export declare class GridRowComponent<TRow = any> implements OnChanges {
+    row: TRow | null;
+    rowIndex: number;
+    dataIndex: number;
+    columns: readonly LayoutColumn<TRow>[];
+    /** Number of plain-cell slots (≥ columns.length). */
+    columnPool: number;
+    /** Number of template-cell slots (≥ template columns in `columns`). */
+    templatePool: number;
+    /** Changes when this row's data was edited. */
+    version: number;
+    /** Changes when every row must rebuild. */
+    nonce: number;
+    edit: EditSession<TRow> | null;
+    gridEditMode: boolean;
+    focusField: string | null;
+    /** Selection state (drawn by the checkbox; the row class is set by the viewport). */
+    selected: boolean;
+    selectable: boolean;
+    /** Width of the pinned checkbox cell (0: no checkbox column). */
+    leading: number;
+    /** Width of the pinned action column (0: none). */
+    trailing: number;
+    /** The inline add row (its row is a draft that isn't in the data yet). */
+    addRow: boolean;
+    private readonly store;
+    /** Where the pinned regions are placed with syncScroll, or null (sticky): see `GridStore.pinPlacement`. */
+    protected get pins(): {
+        start: number;
+        end: number;
+    } | null;
+    cells: CellView[];
+    templateCells: CellView[];
+    editorCells: CellView[];
+    hostClass: string;
+    hostStyle: GridStyleValue | null;
+    selectLabel: string;
+    /** Classes of the action buttons (hidden ones get `is-hidden`). */
+    actions: {
+        edit: string;
+        delete: string;
+        save: string;
+        cancel: string;
+        restore: string;
+    };
+    canEdit: boolean;
+    actionsAriaCol: number;
+    text: import("infi-grid").GridText;
+    private errorReported;
+    /** What each template slot last showed (a kept, hidden view still shows it): field, template and `templateKey`. */
+    private slotFields;
+    private slotTemplates;
+    private slotKeys;
+    private ariaColOffset;
+    /** Cell selection: the focused cell is the selected cell. */
+    private cellSelection;
+    ngOnChanges(changes: SimpleChanges): void;
+    /**
+     * Template slots when columns have `templateKey`s: a column keeps the slot it already has; otherwise it takes a
+     * free slot that last showed a column with the same template and key (its view only updates), then a slot never
+     * used, then any free slot (its view re-renders). The viewport sizes the pool for the most columns of each key that
+     * can be in view, so once the slots have met their keys, scrolling sideways only updates cells.
+     */
+    private assignTemplateSlots;
+    /** Which action buttons show: edit/delete normally, save/cancel while editing, restore on deleted rows (batch). */
+    private buildActions;
+    private buildCell;
+    private editContext;
+    private safe;
+    static ɵfac: i0.ɵɵFactoryDeclaration<GridRowComponent<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<GridRowComponent<any>, "div[infi-grid-row]", never, { "row": { "alias": "row"; "required": false; }; "rowIndex": { "alias": "rowIndex"; "required": false; }; "dataIndex": { "alias": "dataIndex"; "required": false; }; "columns": { "alias": "columns"; "required": false; }; "columnPool": { "alias": "columnPool"; "required": false; }; "templatePool": { "alias": "templatePool"; "required": false; }; "version": { "alias": "version"; "required": false; }; "nonce": { "alias": "nonce"; "required": false; }; "edit": { "alias": "edit"; "required": false; }; "gridEditMode": { "alias": "gridEditMode"; "required": false; }; "focusField": { "alias": "focusField"; "required": false; }; "selected": { "alias": "selected"; "required": false; }; "selectable": { "alias": "selectable"; "required": false; }; "leading": { "alias": "leading"; "required": false; }; "trailing": { "alias": "trailing"; "required": false; }; "addRow": { "alias": "addRow"; "required": false; }; }, {}, never, never, true, never>;
+}
+export {};

package/lib/components/summary-row.component.d.ts

@@ -0,0 +1,40 @@
+import { OnChanges } from '@angular/core';
+import type { GridSummaryResult } from '../models/summary.types';
+import type { GridSummaryCellContext, GridTemplate } from '../models/template.types';
+import { type LayoutColumn } from '../state/grid-store';
+import * as i0 from "@angular/core";
+interface SummaryCellView {
+    key: string | null;
+    ariaCol: number | null;
+    left: number;
+    width: number;
+    cls: string;
+    label: string;
+    value: string;
+    title: string | null;
+    template: GridTemplate<GridSummaryCellContext> | null;
+    context: GridSummaryCellContext | null;
+}
+/** Summary row cells (label + value, or a summary template), pooled like body cells. */
+export declare class GridSummaryRowComponent implements OnChanges {
+    columns: readonly LayoutColumn[];
+    columnPool: number;
+    templatePool: number;
+    results: Readonly<Record<string, GridSummaryResult>>;
+    /** Width of the pinned checkbox cell (0: no checkbox column). */
+    leading: number;
+    /** Width of the pinned action column (0: none). */
+    trailing: number;
+    private readonly store;
+    /** Where the pinned regions are placed with syncScroll, or null (sticky): see `GridStore.pinPlacement`. */
+    protected get pins(): {
+        start: number;
+        end: number;
+    } | null;
+    cells: SummaryCellView[];
+    templateCells: SummaryCellView[];
+    ngOnChanges(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<GridSummaryRowComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<GridSummaryRowComponent, "div[infi-grid-summary-row]", never, { "columns": { "alias": "columns"; "required": false; }; "columnPool": { "alias": "columnPool"; "required": false; }; "templatePool": { "alias": "templatePool"; "required": false; }; "results": { "alias": "results"; "required": false; }; "leading": { "alias": "leading"; "required": false; }; "trailing": { "alias": "trailing"; "required": false; }; }, {}, never, never, true, never>;
+}
+export {};