infi-grid 1.0.0

package/lib/models/events.types.d.ts

@@ -0,0 +1,98 @@
+import type { GridApi, GridEditState, VirtualizationState } from './api.types';
+import type { GridRowKey } from './data.types';
+import type { ResolvedColumn } from './column.types';
+import type { FilterModel } from './filter.types';
+import type { SortModelItem } from './sort.types';
+/** Cell events: `cellClick`, `cellDoubleClick`, `cellContextMenu`, `cellMouseEnter`, `cellMouseLeave`. */
+export interface GridCellEvent<TRow = any> {
+    row: TRow;
+    /** The row's primary-key value (the row itself without a primary key). */
+    key: GridRowKey;
+    /** Position in the current (sorted and filtered) view. */
+    rowIndex: number;
+    /** Position in the data array (-1 for rows that aren't in the data yet). */
+    dataIndex: number;
+    field: string;
+    column: ResolvedColumn<TRow>;
+    value: unknown;
+    formattedValue: string;
+    /** The original DOM event. */
+    event: Event;
+    /**
+     * Set to `true` to stop the grid's built-in reaction to a click (selecting the row or, with `cellSelection`, the cell;
+     * starting an edit). Ignored by `cellMouseEnter`/`cellMouseLeave`, and in `events.clickMode: 'waitForDoubleClick'`.
+     */
+    cancel: boolean;
+}
+/** Row events: `rowClick`, `rowDoubleClick`. */
+export interface GridRowEvent<TRow = any> {
+    row: TRow;
+    key: GridRowKey;
+    rowIndex: number;
+    dataIndex: number;
+    /** The field of the clicked cell, or null when the click was outside the cells. */
+    field: string | null;
+    event: Event;
+    /** Set to `true` to stop the grid's built-in reaction (selecting the row or, with `cellSelection`, the cell; starting an edit). */
+    cancel: boolean;
+}
+/** `(headerClick)`: a click on a header's label (sorting) or filter button. */
+export interface GridHeaderClickEvent<TRow = any> {
+    column: ResolvedColumn<TRow>;
+    field: string;
+    columnIndex: number;
+    /** `'label'`: the part that sorts; `'filterButton'`: the funnel. */
+    area: 'label' | 'filterButton';
+    event: MouseEvent;
+    /** Set to `true` to stop the built-in reaction (sorting, opening the filter). */
+    cancel: boolean;
+}
+export interface GridCellValueChangeEvent<TRow = any> {
+    row: TRow;
+    rowIndex: number;
+    field: string;
+    column: ResolvedColumn<TRow>;
+    oldValue: unknown;
+    newValue: unknown;
+    /** `'edit'` for user edits, `'api'` for `updateCell()`. */
+    source: 'edit' | 'api';
+}
+export interface GridEditEvent<TRow = any> {
+    state: GridEditState<TRow>;
+}
+export interface GridSortChangeEvent {
+    sortModel: readonly SortModelItem[];
+}
+export interface GridFilterChangeEvent {
+    filterModel: FilterModel;
+    /** Rows left after filtering. */
+    displayedRowCount: number;
+}
+export interface GridColumnResizeEvent<TRow = any> {
+    field: string;
+    column: ResolvedColumn<TRow>;
+    /** Width before the change (for a drag: the width when the drag started). */
+    oldWidth: number;
+    newWidth: number;
+    /** Same as `newWidth` (1.0 name). */
+    width: number;
+    /** False while dragging, true when the drag ends (always true for API calls). */
+    finished: boolean;
+    /** `'user'`: dragged in the header; `'api'`: `setColumnWidth()`; `'reset'`: `resetColumnWidth()`. */
+    source: 'user' | 'api' | 'reset';
+}
+export interface GridViewportChangeEvent {
+    state: VirtualizationState;
+}
+/**
+ * Errors the grid caught (for example a custom summary function that threw).
+ * The grid never writes to the console; listen to `(gridError)` instead.
+ */
+export interface GridErrorEvent {
+    source: 'summary' | 'filter' | 'sort' | 'edit' | 'format' | 'config' | 'data';
+    field?: string;
+    error: unknown;
+}
+export interface GridReadyEvent<TRow = any> {
+    api: GridApi<TRow>;
+}

package/lib/models/filter.types.d.ts

@@ -0,0 +1,78 @@
+import type { GridDataType } from './column.types';
+export type TextFilterOperator = 'contains' | 'notContains' | 'equals' | 'notEquals' | 'startsWith' | 'endsWith' | 'empty' | 'notEmpty';
+export type NumberFilterOperator = 'equals' | 'notEquals' | 'greaterThan' | 'greaterThanOrEqual' | 'lessThan' | 'lessThanOrEqual' | 'between' | 'empty' | 'notEmpty';
+export type DateFilterOperator = 'equals' | 'notEquals' | 'before' | 'after' | 'onOrBefore' | 'onOrAfter' | 'between' | 'empty' | 'notEmpty';
+export type BooleanFilterOperator = 'isTrue' | 'isFalse' | 'empty' | 'notEmpty';
+/** Built-in operators, or the `key` of a custom operator. */
+export type FilterOperator = TextFilterOperator | NumberFilterOperator | DateFilterOperator | BooleanFilterOperator | (string & {});
+/**
+ * One condition, e.g. `{ operator: 'greaterThan', value: 100 }`.
+ * Dates are given as `Date`, timestamp or `'YYYY-MM-DD'`. `between` uses `value` and `valueTo` (inclusive).
+ */
+export interface FilterCondition {
+    operator: FilterOperator;
+    value?: unknown;
+    valueTo?: unknown;
+}
+/**
+ * Filter for one column. A row passes when it matches the conditions (combined with `logic`)
+ * AND its value is in `values` (the Excel-style checkbox list). Leave a part out to skip it.
+ */
+export interface ColumnFilterModel {
+    conditions?: FilterCondition[];
+    /** How `conditions` are combined. Default `'and'`. */
+    logic?: 'and' | 'or';
+    /**
+     * Selected values from the checkbox list. `null`/`undefined` means "all values".
+     * Blanks are represented by `null`; dates by `'YYYY-MM-DD'` strings.
+     */
+    values?: readonly unknown[] | null;
+}
+/** Filter state of the whole grid, keyed by column field. */
+export type FilterModel = Readonly<Record<string, ColumnFilterModel>>;
+/** A developer-defined filter operator shown in the filter popup. */
+export interface CustomFilterOperator<TRow = any> {
+    /** Unique key stored in the filter model. */
+    key: string;
+    /** Label shown in the operator dropdown. */
+    label: string;
+    /** How many value inputs the operator needs. Default 1. */
+    inputs?: 0 | 1 | 2;
+    predicate: (cellValue: unknown, value: unknown, valueTo: unknown, row: TRow) => boolean;
+}
+/** Filter icon visibility: always shown, or only while hovering the header (always shown when a filter is active). */
+export type FilterIconVisibility = 'always' | 'hover';
+/** Column-level filter configuration. Every property overrides the global `filtering` value. */
+export interface ColumnFilterConfig<TRow = any> {
+    showIcon?: boolean;
+    iconVisibility?: FilterIconVisibility;
+    /** Operators offered in the popup, in order. Defaults to all operators of the column type. */
+    operators?: readonly FilterOperator[];
+    /** Operator selected when the popup opens with no condition. */
+    defaultOperator?: FilterOperator;
+    customOperators?: readonly CustomFilterOperator<TRow>[];
+    /** Show the Excel-style checkbox list of values. */
+    valueList?: boolean;
+    /** Show the condition section (operator + value). */
+    conditions?: boolean;
+    /** Maximum conditions in the popup (1 to 5). */
+    maxConditions?: 1 | 2 | 3 | 4 | 5;
+    caseSensitive?: boolean;
+    /** Replace the built-in matching logic for this column. */
+    predicate?: (row: TRow, model: ColumnFilterModel, cellValue: unknown) => boolean;
+}
+/** Column filter configuration after merging with the global configuration. */
+export interface ResolvedColumnFilter<TRow = any> {
+    readonly operators: readonly FilterOperator[];
+    readonly defaultOperator: FilterOperator;
+    readonly customOperators: readonly CustomFilterOperator<TRow>[];
+    readonly valueList: boolean;
+    readonly conditions: boolean;
+    readonly maxConditions: number;
+    readonly caseSensitive: boolean;
+    readonly predicate: ((row: TRow, model: ColumnFilterModel, cellValue: unknown) => boolean) | null;
+}
+/** Operators offered for each data type (in popup order). */
+export declare const FILTER_OPERATORS_BY_TYPE: Readonly<Record<GridDataType, readonly FilterOperator[]>>;
+/** Number of value inputs each built-in operator needs. */
+export declare const FILTER_OPERATOR_INPUTS: Readonly<Record<string, 0 | 1 | 2>>;

package/lib/models/index.d.ts

@@ -0,0 +1,12 @@
+export * from './api.types';
+export * from './column.types';
+export * from './config.types';
+export * from './crud.types';
+export * from './data.types';
+export * from './events.types';
+export * from './filter.types';
+export * from './selection.types';
+export * from './sort.types';
+export * from './summary.types';
+export * from './template.types';
+export * from './tooltip.types';

package/lib/models/selection.types.d.ts

@@ -0,0 +1,173 @@
+import type { ResolvedColumn } from './column.types';
+import type { GridRowKey } from './data.types';
+/**
+ * What a click (on the checkbox, or on a cell or row with `selectOnClick`) or Space does to a row:
+ * - `'multiple'`: toggles that row and keeps the other selected rows. Shift+click and Shift+↑/↓ select the rows
+ *   between the last clicked row and this one, keeping the rows that were selected before.
+ * - `'single'`: selects that row instead of the selected one; on the selected row, deselects it.
+ * - `'none'`: row selection is off.
+ *
+ * Changing the mode at runtime: `'none'` deselects every row, and `'single'` keeps only the last selected row
+ * (`selectionChange` with source `'api'`).
+ */
+export type GridSelectionMode = 'none' | 'single' | 'multiple';
+/** Row selection settings. */
+export interface SelectionConfig<TRow = any> {
+    /** Default `'none'`. See `GridSelectionMode` for what a click does in each mode. */
+    mode?: GridSelectionMode;
+    /** Show a checkbox column (pinned at the left). Default: `true` in `'multiple'` mode. */
+    checkbox?: boolean;
+    /** Width of the checkbox column in px. Default 40. */
+    checkboxWidth?: number;
+    /** Select-all checkbox in the header (`'multiple'` mode). Default `true`. */
+    headerCheckbox?: boolean;
+    /**
+     * A click on a cell or row selects it (as described for the mode). With `false`, only the checkboxes, the keyboard
+     * and the API select. Ignored while `cellSelection.enabled` is on: cell clicks then select cells, never rows.
+     * Default `true`.
+     */
+    selectOnClick?: boolean;
+    /** Rows the header checkbox and `selectAll()` select: only the filtered rows, or every row. Default `'filtered'`. */
+    selectAllScope?: 'filtered' | 'all';
+    /**
+     * When a filter changes: deselect the rows it hides (`'deselectHidden'`), clear the whole selection
+     * (`'clear'`), or leave the selection alone (`'keep'`). Default `'deselectHidden'`.
+     */
+    onFilter?: 'deselectHidden' | 'clear' | 'keep';
+    /** API selection scrolls the row into view. Default `false`. */
+    scrollToSelection?: boolean;
+    /** Space toggles the focused row, Shift+↑/↓ extends, Ctrl/Cmd+A selects all. Default `true`. */
+    keyboard?: boolean;
+    /** Rows that can't be selected (their checkbox is disabled). */
+    rowSelectable?: (row: TRow) => boolean;
+}
+/** What caused a selection change. */
+export type GridSelectionSource = 'cell' | 'row' | 'checkbox' | 'selectAll' | 'keyboard' | 'api' | 'filter' | 'dataRefresh' | 'delete';
+/** `(selectionChange)`: emitted once per operation that changed the selection. */
+export interface GridSelectionChangeEvent<TRow = any> {
+    source: GridSelectionSource;
+    /** `'change'` when rows were selected and deselected (e.g. moving the selection to another row). */
+    action: 'select' | 'deselect' | 'change';
+    /** The row the user or the API acted on (click, checkbox, single-row call), or null for bulk operations. */
+    row: TRow | null;
+    key: GridRowKey | null;
+    readonly added: readonly TRow[];
+    readonly addedKeys: readonly GridRowKey[];
+    readonly removed: readonly TRow[];
+    readonly removedKeys: readonly GridRowKey[];
+    /** `'single'` mode: the row selected before the change, or null when there was none. Null in `'multiple'` mode. */
+    oldRow: TRow | null;
+    /** `'single'` mode: the row selected after the change, or null when the selection was cleared. Null in `'multiple'` mode. */
+    newRow: TRow | null;
+    oldKey: GridRowKey | null;
+    newKey: GridRowKey | null;
+    /** The selection before the operation, in selection order. */
+    readonly previousSelection: readonly TRow[];
+    readonly previousKeys: readonly GridRowKey[];
+    /** The selection after the operation, in selection order. */
+    readonly currentSelection: readonly TRow[];
+    readonly currentKeys: readonly GridRowKey[];
+}
+/** `(rowSelected)` / `(rowDeselected)`: emitted once per operation, listing every affected row. */
+export interface GridRowSelectionEvent<TRow = any> {
+    source: GridSelectionSource;
+    /** The first affected row (the only one for single-row gestures). */
+    row: TRow;
+    key: GridRowKey;
+    readonly rows: readonly TRow[];
+    readonly keys: readonly GridRowKey[];
+    readonly currentSelection: readonly TRow[];
+    readonly currentKeys: readonly GridRowKey[];
+}
+/** `(selectionCleared)`: the selection became empty. */
+export interface GridSelectionClearedEvent<TRow = any> {
+    source: GridSelectionSource;
+    readonly previousSelection: readonly TRow[];
+    readonly previousKeys: readonly GridRowKey[];
+}
+/** `(selectionClick)`: a click (or key) is about to change the selection. Set `cancel` to prevent it. */
+export interface GridSelectionClickEvent<TRow = any> {
+    source: 'cell' | 'row' | 'checkbox' | 'selectAll' | 'keyboard';
+    /** The row clicked, or null for the header checkbox. */
+    row: TRow | null;
+    key: GridRowKey | null;
+    rowIndex: number;
+    /** True when the gesture selects, false when it deselects. */
+    selecting: boolean;
+    event: Event;
+    cancel: boolean;
+}
+/** Options of the selection API. */
+export interface GridSelectOptions {
+    /** Scroll the (first) row into view. Default: `selection.scrollToSelection`. */
+    scroll?: boolean;
+}
+/** Scope of `selectAll()` / `deselectAll()`. */
+export interface GridSelectAllOptions {
+    scope?: 'filtered' | 'all';
+}
+/**
+ * Cell selection: one selected cell, chosen with a click or the arrow keys. It is independent of row selection: it never
+ * selects or deselects rows, and no `selection` setting applies to it.
+ */
+export interface CellSelectionConfig {
+    /**
+     * A click on a cell selects that cell; the arrow keys, Home/End and Page Up/Down move it. While this is on, clicks
+     * never change the row selection (`selection.selectOnClick` is ignored): rows are selected with the checkbox column,
+     * the keyboard (Space, Shift+↑/↓, Ctrl/Cmd+A) and the API. Default `false`.
+     */
+    enabled?: boolean;
+    /**
+     * Mark the row of the selected cell as the active row (class `infi-grid__row--active`, color `--infi-grid-active-row-bg`).
+     * Visual only: the active row isn't selected and has no checkbox. A selected row keeps the selected color.
+     * Needs `enabled`. Default `false`.
+     */
+    activeRow?: boolean;
+}
+/**
+ * What changed the selected cell:
+ * - `'click'`: a click on a cell;
+ * - `'keyboard'`: the arrow keys, Home/End, Page Up/Down, or Tab/Shift+Tab between editors;
+ * - `'api'`: `selectCell()`, `clearCellSelection()`, or the grid itself (`enterEditMode()` in grid edit mode, the row
+ *   added with the add row gets its first cell selected);
+ * - `'dataRefresh'`: new data without the selected cell's row;
+ * - `'delete'`: the selected cell's row was deleted (or its pending add undone or discarded, in batch mode);
+ * - `'columns'`: the selected cell's column was removed.
+ */
+export type GridCellSelectionSource = 'click' | 'keyboard' | 'api' | 'dataRefresh' | 'delete' | 'columns';
+/** `(cellSelectionChange)`: the selected cell changed (`cellSelection.enabled`). Row selection is not involved. */
+export interface GridCellSelectionChangeEvent<TRow = any> {
+    source: GridCellSelectionSource;
+    /** The selected cell's row, or null when no cell is selected any more. */
+    row: TRow | null;
+    key: GridRowKey | null;
+    /** Position in the current (sorted and filtered) view, or -1 when no cell is selected. */
+    rowIndex: number;
+    /** Position in the data array, or -1 (no cell selected, or a row that isn't in the data yet). */
+    dataIndex: number;
+    field: string | null;
+    column: ResolvedColumn<TRow> | null;
+    value: unknown;
+    /** The value as displayed, or `''` when no cell is selected. */
+    formattedValue: string;
+    /** The cell selected before, or null when there was none. */
+    previous: {
+        readonly key: GridRowKey;
+        readonly field: string;
+    } | null;
+    /** The click or key event, or null for the API and data changes. */
+    event: Event | null;
+}
+/** `getSelectedCell()`: the selected cell, identified by row key and field. */
+export interface GridSelectedCell<TRow = any> {
+    row: TRow;
+    key: GridRowKey;
+    field: string;
+    /** Position in the current view, or -1 while a filter hides the row. */
+    rowIndex: number;
+}
+/** Options of `selectCell()`. */
+export interface GridSelectCellOptions {
+    /** Scroll the cell into view. Default `false`. */
+    scroll?: boolean;
+}

package/lib/models/sort.types.d.ts

@@ -0,0 +1,22 @@
+export type SortDirection = 'asc' | 'desc';
+/** One entry of the sort model. The array order is the sort priority. */
+export interface SortModelItem {
+    field: string;
+    direction: SortDirection;
+}
+/**
+ * Sort icon visibility:
+ * - `always`: always shown (a neutral icon when the column is not sorted)
+ * - `sorted`: only shown when the column is sorted
+ * - `hover`: shown while hovering the header, and always when the column is sorted
+ */
+export type SortIconVisibility = 'always' | 'sorted' | 'hover';
+/** Column-level sorting configuration. Every property overrides the global `sorting` value. */
+export interface ColumnSortConfig<TRow = any> {
+    /** Custom comparator. Receives raw cell values and rows; return <0, 0 or >0 for ascending order. */
+    comparator?: (a: unknown, b: unknown, rowA: TRow, rowB: TRow) => number;
+    showIcon?: boolean;
+    iconVisibility?: SortIconVisibility;
+    /** Order of states when the header is clicked. Default `['asc', 'desc', null]`. */
+    cycle?: readonly (SortDirection | null)[];
+}

package/lib/models/summary.types.d.ts

@@ -0,0 +1,78 @@
+import type { GridApi } from './api.types';
+import type { ResolvedColumn } from './column.types';
+import type { FilterModel } from './filter.types';
+import type { SortModelItem } from './sort.types';
+/** Built-in summary functions. */
+export type GridSummaryType = 'sum' | 'avg' | 'count' | 'min' | 'max';
+/** Which rows a summary is calculated over: rows left after filtering, or all rows. */
+export type GridSummaryScope = 'filtered' | 'all';
+/** Helpers available to custom summary functions. */
+export interface GridSummaryHelpers {
+    sum(values: readonly unknown[]): number;
+    avg(values: readonly unknown[]): number | null;
+    count(values: readonly unknown[]): number;
+    min(values: readonly unknown[]): unknown;
+    max(values: readonly unknown[]): unknown;
+}
+/** Everything a custom summary function receives. */
+export interface GridSummaryContext<TRow = any> {
+    /** Complete grid data (unfiltered). */
+    data: readonly TRow[];
+    /** Rows the summary is calculated over (filtered rows by default, see `scope`). */
+    rows: readonly TRow[];
+    /** This column's values for `rows` (the "current column data"). */
+    values: readonly unknown[];
+    /** The column object. */
+    column: ResolvedColumn<TRow>;
+    /** The column field. */
+    field: string;
+    /** Grid reference/API. */
+    api: GridApi<TRow>;
+    /** Grid context: the active scope, filter state and sort state. */
+    scope: GridSummaryScope;
+    filterModel: FilterModel;
+    sortModel: readonly SortModelItem[];
+    /** Value of another column's summary, for formulas that combine columns. */
+    getSummary(field: string): unknown;
+    /** Built-in functions to reuse inside formulas. */
+    fn: GridSummaryHelpers;
+}
+export type GridSummaryFunction<TRow = any> = (ctx: GridSummaryContext<TRow>) => unknown;
+/** Column-level summary configuration. */
+export interface ColumnSummaryConfig<TRow = any> {
+    /** Built-in function. Ignored when `fn` is set. */
+    type?: GridSummaryType;
+    /** Custom summary function / formula. */
+    fn?: GridSummaryFunction<TRow>;
+    /** Turn this column's summary off without removing the config. */
+    enabled?: boolean;
+    /** Label shown before the value, e.g. `'Total'`. Defaults to the built-in name. */
+    label?: string;
+    /** Formats the summary value. Defaults to the column's own formatting. */
+    formatter?: (value: unknown, column: ResolvedColumn<TRow>) => string;
+    /** Overrides the global summary scope for this column. */
+    scope?: GridSummaryScope;
+    /**
+     * Fields whose edits should trigger a recalculation of this (custom) summary.
+     * By default a custom summary is recalculated after any edit.
+     */
+    dependsOn?: readonly string[];
+}
+/** Column summary after merging with the global configuration. */
+export interface ResolvedColumnSummary<TRow = any> {
+    readonly type: GridSummaryType | 'custom';
+    readonly fn: GridSummaryFunction<TRow> | null;
+    readonly label: string;
+    readonly formatter: ((value: unknown, column: ResolvedColumn<TRow>) => string) | null;
+    readonly scope: GridSummaryScope;
+    readonly dependsOn: readonly string[] | null;
+}
+/** Calculated summary for one column. */
+export interface GridSummaryResult {
+    field: string;
+    value: unknown;
+    formattedValue: string;
+    label: string;
+    /** Set when a custom summary function threw; the cell shows `#ERROR`. */
+    error: unknown;
+}

package/lib/models/template.types.d.ts

@@ -0,0 +1,126 @@
+import type { TemplateRef, Type } from '@angular/core';
+import type { GridApi } from './api.types';
+import type { GridEditorOptions, ResolvedColumn } from './column.types';
+import type { GridRowKey } from './data.types';
+import type { SortDirection } from './sort.types';
+import type { GridSummaryResult } from './summary.types';
+/**
+ * A template can be an Angular `TemplateRef` or a component class.
+ * Components receive the context through an input named `context`
+ * (extend `GridTemplateComponent` to get it declared for you).
+ */
+export type GridTemplate<C> = TemplateRef<C> | Type<unknown>;
+/** Context of display-mode cell templates. */
+export interface GridCellContext<TRow = any, TValue = any> {
+    /** The cell value (`let-value`). */
+    $implicit: TValue;
+    value: TValue;
+    /** The value formatted by the column's formatter. */
+    formattedValue: string;
+    /** The row data object. */
+    row: TRow;
+    /** Row position in the current (sorted and filtered) view. */
+    rowIndex: number;
+    /** Row position in the original `data` array. */
+    dataIndex: number;
+    /** The column object. */
+    column: ResolvedColumn<TRow>;
+    /** Column position among displayed columns. */
+    columnIndex: number;
+    field: string;
+    /** True when this cell is in edit mode. */
+    editing: boolean;
+    /** True when any cell of this row is in edit mode. */
+    rowEditing: boolean;
+    /** Grid reference/API. */
+    api: GridApi<TRow>;
+}
+/** Context of edit-mode templates. `value` holds the value being edited. */
+export interface GridEditContext<TRow = any, TValue = any> extends GridCellContext<TRow, TValue> {
+    /** Value before editing started. */
+    originalValue: TValue;
+    /** Validation message from the column `validator`, or null. */
+    error: string | null;
+    editorOptions: GridEditorOptions<TRow>;
+    /** True for the cell that should take focus when editing starts. */
+    autoFocus: boolean;
+    /** Update the edited value. */
+    setValue(value: TValue): void;
+    /** Save the edited value(s) and leave edit mode. */
+    commit(): void;
+    /** Discard the edited value(s) and leave edit mode. */
+    cancel(): void;
+}
+/** Context of header templates. */
+export interface GridHeaderContext<TRow = any> {
+    $implicit: ResolvedColumn<TRow>;
+    column: ResolvedColumn<TRow>;
+    columnIndex: number;
+    header: string;
+    sortDirection: SortDirection | null;
+    /** 1-based position in a multi-column sort, or null. */
+    sortIndex: number | null;
+    filterActive: boolean;
+    api: GridApi<TRow>;
+    /** Cycle the sort of this column. Pass `true` to add it to a multi-column sort. */
+    toggleSort(multi?: boolean): void;
+    /** Open the filter popup for this column. */
+    openFilter(anchor?: HTMLElement): void;
+}
+/** Context of summary cell templates. */
+export interface GridSummaryCellContext<TRow = any> {
+    /** The summary value. */
+    $implicit: unknown;
+    value: unknown;
+    formattedValue: string;
+    label: string;
+    result: GridSummaryResult;
+    column: ResolvedColumn<TRow>;
+    field: string;
+    api: GridApi<TRow>;
+}
+/** Context of loading templates. */
+export interface GridLoadingContext<TRow = any> {
+    $implicit: boolean;
+    loading: boolean;
+    message: string;
+    api: GridApi<TRow>;
+}
+/** Why the empty state is shown. */
+export type GridEmptyReason = 'noData' | 'noResults';
+/** Context of empty-data ("No Data Found") templates. */
+export interface GridEmptyContext<TRow = any> {
+    /** `'noData'` when the data array is empty, `'noResults'` when filters removed every row. */
+    $implicit: GridEmptyReason;
+    reason: GridEmptyReason;
+    message: string;
+    api: GridApi<TRow>;
+    clearFilters(): void;
+}
+/** Context of error templates. */
+export interface GridErrorContext<TRow = any> {
+    /** The error passed to the grid. */
+    $implicit: unknown;
+    error: unknown;
+    message: string;
+    api: GridApi<TRow>;
+    /** Clears the error state. */
+    dismiss(): void;
+}
+/** Context of the delete confirmation template (`<ng-template infiGridDeleteConfirm>`). */
+export interface GridDeleteConfirmContext<TRow = any> {
+    /** The rows to delete. */
+    $implicit: readonly TRow[];
+    rows: readonly TRow[];
+    keys: readonly GridRowKey[];
+    count: number;
+    /** The built-in message ("Delete 3 rows?"). */
+    message: string;
+    /** `'ui'`, `'keyboard'` or `'api'`: what asked for the deletion. */
+    source: 'ui' | 'api' | 'keyboard';
+    api: GridApi<TRow>;
+    /** Delete the rows. */
+    confirm(): void;
+    /** Keep the rows. */
+    cancel(): void;
+}

package/lib/models/tooltip.types.d.ts

@@ -0,0 +1,48 @@
+import type { GridApi } from './api.types';
+import type { GridDataType, ResolvedColumn } from './column.types';
+/** When a tooltip shows: only when the text is cut off (ellipsis), always, or never. */
+export type GridTooltipMode = 'truncated' | 'always' | 'never';
+/** Preferred side of a tooltip; it flips to the other side when there is no room. */
+export type GridTooltipPlacement = 'top' | 'bottom' | 'left' | 'right';
+/** Tooltip settings for cells, headers and summary cells. */
+export interface TooltipConfig {
+    /** Show tooltips. With `false`, headers and summary cells keep the browser's native `title`. Default `true`. */
+    enabled?: boolean;
+    /** When cells show a tooltip. Default `'truncated'`. */
+    cells?: GridTooltipMode;
+    /** When headers show a tooltip (a column `description` always shows). Default `'truncated'`. */
+    headers?: GridTooltipMode;
+    /** Delay before a tooltip shows, in ms. Moving to the next cell while one is shown switches at once. Default 500. */
+    showDelay?: number;
+    /** Delay before a tooltip hides after the pointer leaves, in ms. Default 100. */
+    hideDelay?: number;
+    /** Default `'top'`. */
+    placement?: GridTooltipPlacement;
+    /** Data types whose cells get no tooltip (for example `['boolean']`). A column's own `tooltip` wins. */
+    disabledTypes?: readonly GridDataType[];
+}
+/** Context of cell tooltip templates (`infiGridCellTooltip`) and of a column's `tooltip` function. */
+export interface GridTooltipContext<TRow = any, TValue = any> {
+    /** The cell value (`let-value`). */
+    $implicit: TValue;
+    value: TValue;
+    formattedValue: string;
+    row: TRow;
+    rowIndex: number;
+    column: ResolvedColumn<TRow>;
+    field: string;
+    /** True when the cell text is cut off. */
+    truncated: boolean;
+    api: GridApi<TRow>;
+}
+/** Context of header tooltip templates (`infiGridHeaderTooltip`). */
+export interface GridHeaderTooltipContext<TRow = any> {
+    $implicit: ResolvedColumn<TRow>;
+    column: ResolvedColumn<TRow>;
+    header: string;
+    /** The column's `description`, or null. */
+    description: string | null;
+    /** True when the header text is cut off. */
+    truncated: boolean;
+    api: GridApi<TRow>;
+}

package/lib/state/filter-popup.service.d.ts

@@ -0,0 +1,30 @@
+import { OnDestroy } from '@angular/core';
+import { type FilterPopupHandle } from './grid-store';
+import * as i0 from "@angular/core";
+/**
+ * Opens the Excel-style filter popup in `document.body`, so it is never clipped by the grid
+ * or by transformed/overflow-hidden ancestors. Theme variables are copied from the grid.
+ */
+export declare class GridFilterPopupService implements FilterPopupHandle, OnDestroy {
+    private readonly store;
+    private readonly appRef;
+    private readonly environmentInjector;
+    private readonly injector;
+    private readonly document;
+    private readonly zone;
+    /** The `<infi-grid>` element; set by the grid component. */
+    host: HTMLElement | null;
+    private ref;
+    private anchor;
+    private listeners;
+    constructor();
+    ngOnDestroy(): void;
+    isOpen(): boolean;
+    open(field: string, anchor: HTMLElement | null): void;
+    /** Closes the popup; `restoreFocus` returns focus to the header filter button. */
+    close(restoreFocus?: boolean): void;
+    private position;
+    private applyTheme;
+    static ɵfac: i0.ɵɵFactoryDeclaration<GridFilterPopupService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<GridFilterPopupService>;
+}