infi-grid 1.0.0

package/lib/state/grid-api.d.ts

@@ -0,0 +1,4 @@
+import type { GridApi } from '../models/api.types';
+import type { GridStore } from './grid-store';
+/** Builds the public API object on top of the store. */
+export declare function createGridApi<TRow>(store: GridStore<TRow>): GridApi<TRow>;

package/lib/state/grid-store.d.ts

@@ -0,0 +1,584 @@
+import { type OnDestroy, type Signal } from '@angular/core';
+import type { GridApi, GridEditState, VirtualizationState } from '../models/api.types';
+import type { ColumnConfig, ResolvedColumn } from '../models/column.types';
+import type { GridConfig, ResolvedGridConfig } from '../models/config.types';
+import type { GridAddPosition, GridAddRowOptions, GridBeginAddRowOptions, GridChangeSet, GridCrudResult, GridPendingChangeEvent, GridSaveFailedEvent, GridSaveResult, GridRowAddedEvent, GridRowAddingEvent, GridRowDeletedEvent, GridRowDeletingEvent, GridRowUpdatedEvent, GridRowUpdatingEvent } from '../models/crud.types';
+import type { GridCellEvent, GridCellValueChangeEvent, GridRowEvent, GridViewportChangeEvent, GridColumnResizeEvent, GridEditEvent, GridErrorEvent, GridFilterChangeEvent, GridHeaderClickEvent, GridSortChangeEvent } from '../models/events.types';
+import type { ColumnFilterModel, FilterModel } from '../models/filter.types';
+import type { SortDirection, SortModelItem } from '../models/sort.types';
+import type { GridSummaryResult } from '../models/summary.types';
+import type { GridRowKey, GridDataRefreshEvent, GridDataRefreshReason, GridLoadingChangeEvent, GridRefreshOptions, GridRefreshResult } from '../models/data.types';
+import type { GridCellSelectionChangeEvent, GridCellSelectionSource, GridRowSelectionEvent, GridSelectedCell, GridSelectionChangeEvent, GridSelectionClearedEvent, GridSelectionClickEvent, GridSelectionSource } from '../models/selection.types';
+import { type KeyIndex } from '../core/keys';
+import { type TemplateRegistry } from '../core/template-registry';
+import * as i0 from "@angular/core";
+/** One displayed column with its current position. */
+export interface LayoutColumn<TRow = any> {
+    readonly key: string;
+    readonly col: ResolvedColumn<TRow>;
+    /** Position among displayed columns. */
+    readonly index: number;
+    /** Position among displayed columns that have a display template, or -1 (see the row component). */
+    readonly templateIndex: number;
+    /** Position among displayed columns that have a header template, or -1. */
+    readonly headerTemplateIndex: number;
+    /** Position among displayed columns that have a summary template, or -1. */
+    readonly summaryTemplateIndex: number;
+    readonly left: number;
+    readonly width: number;
+}
+export interface ColumnLayout<TRow = any> {
+    readonly columns: readonly LayoutColumn<TRow>[];
+    readonly offsets: readonly number[];
+    /** Width of every column plus the pinned regions. */
+    readonly totalWidth: number;
+    readonly byField: ReadonlyMap<string, LayoutColumn<TRow>>;
+    /** Pinned region at the left (the selection checkboxes); data columns start after it. */
+    readonly leadingWidth: number;
+    /** Pinned region at the right (the action column). */
+    readonly trailingWidth: number;
+    /** Added to a column's position for `aria-colindex` (the checkbox column is column 1). */
+    readonly ariaColOffset: number;
+}
+/** Mutable edit session (drafts are stored here, not in the DOM, so they survive row recycling). */
+export interface EditSession<TRow = any> {
+    row: TRow;
+    /** View index of the row (-1 for the inline add row). */
+    rowIndex: number;
+    mode: 'cell' | 'row';
+    fields: string[];
+    focusField: string;
+    values: Record<string, unknown>;
+    original: Record<string, unknown>;
+    errors: Record<string, string | null>;
+    /** The inline add row: `row` is a draft that isn't in the data yet. */
+    isNew: boolean;
+    /** Where the add row is shown and the row is added (add row only). */
+    position: 'top' | 'bottom';
+}
+/** An open delete confirmation (built-in dialog or `infiGridDeleteConfirm` template). */
+export interface DeleteRequest<TRow = any> {
+    readonly rows: readonly TRow[];
+    readonly keys: readonly GridRowKey[];
+    readonly source: 'ui' | 'api' | 'keyboard';
+    confirm(): void;
+    cancel(): void;
+}
+/** Implemented by the viewport; lets the API scroll and read what is rendered. */
+export interface ViewportHandle {
+    scrollToRow(rowIndex: number, position: 'auto' | 'start' | 'center' | 'end'): void;
+    scrollToColumn(columnIndex: number, position: 'auto' | 'start' | 'center' | 'end'): void;
+    getVirtualizationState(): VirtualizationState;
+    focus(): void;
+    /** Moves the focus to a cell (with `cellSelection`, also the selected cell; `source` defaults to `'api'`). */
+    focusCell(rowIndex: number, field: string, source?: GridCellSelectionSource): void;
+}
+/** Implemented by the filter popup service. */
+export interface FilterPopupHandle {
+    open(field: string, anchor: HTMLElement | null): void;
+    close(): void;
+    isOpen(): boolean;
+}
+export type GridListenedEvent = 'cellClick' | 'cellDoubleClick' | 'rowClick' | 'rowDoubleClick' | 'viewportChange' | 'selectionClick' | 'headerClick' | 'cellContextMenu' | 'cellMouseEnter' | 'cellMouseLeave' | 'cellSelectionChange';
+/** Callbacks wired to the component outputs. */
+export interface GridEventSink<TRow> {
+    /** Whether the host listens to a frequent event (avoids entering the zone for nothing). */
+    listens?(name: GridListenedEvent): boolean;
+    cellClick?(e: GridCellEvent<TRow>): void;
+    cellDoubleClick?(e: GridCellEvent<TRow>): void;
+    rowClick?(e: GridRowEvent<TRow>): void;
+    rowDoubleClick?(e: GridRowEvent<TRow>): void;
+    headerClick?(e: GridHeaderClickEvent<TRow>): void;
+    cellContextMenu?(e: GridCellEvent<TRow>): void;
+    cellMouseEnter?(e: GridCellEvent<TRow>): void;
+    cellMouseLeave?(e: GridCellEvent<TRow>): void;
+    viewportChange?(e: GridViewportChangeEvent): void;
+    sortChange?(e: GridSortChangeEvent): void;
+    filterChange?(e: GridFilterChangeEvent): void;
+    cellValueChange?(e: GridCellValueChangeEvent<TRow>): void;
+    editStart?(e: GridEditEvent<TRow>): void;
+    editCommit?(e: GridEditEvent<TRow>): void;
+    editCancel?(e: GridEditEvent<TRow>): void;
+    columnResize?(e: GridColumnResizeEvent<TRow>): void;
+    gridError?(e: GridErrorEvent): void;
+    dataRefresh?(e: GridDataRefreshEvent): void;
+    loadingChange?(e: GridLoadingChangeEvent): void;
+    selectionChange?(e: GridSelectionChangeEvent<TRow>): void;
+    rowSelected?(e: GridRowSelectionEvent<TRow>): void;
+    rowDeselected?(e: GridRowSelectionEvent<TRow>): void;
+    selectionCleared?(e: GridSelectionClearedEvent<TRow>): void;
+    selectionClick?(e: GridSelectionClickEvent<TRow>): void;
+    cellSelectionChange?(e: GridCellSelectionChangeEvent<TRow>): void;
+    rowAdding?(e: GridRowAddingEvent<TRow>): void;
+    rowAdded?(e: GridRowAddedEvent<TRow>): void;
+    rowUpdating?(e: GridRowUpdatingEvent<TRow>): void;
+    rowUpdated?(e: GridRowUpdatedEvent<TRow>): void;
+    rowDeleting?(e: GridRowDeletingEvent<TRow>): void;
+    rowDeleted?(e: GridRowDeletedEvent<TRow>): void;
+    /** The data array after an add or delete (for `[(data)]`). */
+    dataChange?(data: readonly TRow[]): void;
+    changesSaved?(e: GridChangeSet<TRow>): void;
+    changesCancelled?(e: GridChangeSet<TRow>): void;
+    changesSaveFailed?(e: GridSaveFailedEvent<TRow>): void;
+    pendingChange?(e: GridPendingChangeEvent): void;
+}
+export interface GridInputs<TRow> {
+    data: Signal<readonly TRow[] | null | undefined>;
+    columns: Signal<readonly ColumnConfig<TRow>[] | null | undefined>;
+    config: Signal<GridConfig<TRow> | null | undefined>;
+    loading: Signal<boolean>;
+    error: Signal<unknown>;
+    registry: Signal<TemplateRegistry>;
+}
+/** A row added in batch mode, not in the data until saved. */
+interface PendingAdd<TRow> {
+    readonly row: TRow;
+    readonly key: GridRowKey;
+    /** Where it goes when saved; `'bottom'` rows are shown last, the others first. */
+    readonly position: GridAddPosition;
+}
+/** The rendering state of a row in batch mode. */
+export interface RowChangeState {
+    readonly kind: 'added' | 'modified' | 'deleted';
+    /** Changed fields (modified rows). */
+    readonly fields: ReadonlyMap<string, unknown> | null;
+}
+/** A selection gesture (click, checkbox, key) worked out before it is applied, so `selectionClick` can cancel it. */
+export interface SelectionPlan<TRow> {
+    row: TRow;
+    key: GridRowKey;
+    selecting: boolean;
+    apply(): void;
+}
+/**
+ * Per-grid state. Configuration, data, sort and filter state are signals; the row pipeline is
+ * `data → sort (indexes) → filter (keeps sort order) → view rows`. Changing a filter never re-sorts,
+ * and editing a cell never re-sorts or re-filters (call `refresh()` for that).
+ */
+export declare class GridStore<TRow = any> implements OnDestroy {
+    readonly api: GridApi<TRow>;
+    events: GridEventSink<TRow>;
+    viewport: ViewportHandle | null;
+    filterPopup: FilterPopupHandle | null;
+    /**
+     * `virtualization.syncScroll`: where the pinned regions (checkbox and action columns) are placed inside their row,
+     * header, filter or summary row (`left` of the start and end regions), or null without syncScroll (they are sticky).
+     * A plain object, not a signal: the viewport updates it and the regions already drawn on every sideways scroll frame
+     * (without change detection); rows read it when they are drawn.
+     */
+    pinPlacement: {
+        start: number;
+        end: number;
+    } | null;
+    private inputs;
+    private readonly bound;
+    private readonly dataState;
+    private readonly columnState;
+    private readonly loadingState;
+    private readonly errorState;
+    readonly data: Signal<readonly TRow[]>;
+    readonly loading: Signal<boolean>;
+    readonly error: Signal<unknown>;
+    readonly config: Signal<ResolvedGridConfig<TRow>>;
+    private readonly registry;
+    readonly columns: Signal<readonly ResolvedColumn<TRow>[]>;
+    readonly columnsByField: Signal<Map<string, ResolvedColumn<TRow>>>;
+    /** The configured primary key (compared by value, so a new config object doesn't rebuild the index). */
+    private readonly primaryKey;
+    /** Key of a row: the primary key value, or the row object itself without a primary key. */
+    readonly keyOf: Signal<import("../core/keys").KeyAccessor<TRow>>;
+    readonly hasPrimaryKey: Signal<boolean>;
+    private readonly widthOverrides;
+    private readonly visibilityOverrides;
+    /** Width of the pinned checkbox column (0 without one). A number, so other config changes keep the layout. */
+    private readonly leadingWidth;
+    /** Width of the pinned action column (0 without one). */
+    private readonly trailingWidth;
+    readonly layout: Signal<ColumnLayout<TRow>>;
+    /**
+     * Height of the filter row (`filtering.mode` `'row'` or `'both'`): `filtering.rowHeight` while a displayed column
+     * is filterable, else 0. With filtering off there is no empty row under the header.
+     */
+    readonly filterRowHeight: Signal<number>;
+    readonly sortModel: import("@angular/core").WritableSignal<readonly SortModelItem[]>;
+    readonly filterModel: import("@angular/core").WritableSignal<Readonly<Record<string, ColumnFilterModel>>>;
+    /** Bumped by `refresh()` to re-run sorting and filtering on mutated data. */
+    private readonly structureVersion;
+    /** Key → data position. Lazy: built the first time something needs a key lookup. */
+    readonly keyIndex: Signal<KeyIndex>;
+    private keyReportFor;
+    /** Bumped on every edit; drives summary recalculation and row re-rendering. */
+    readonly editVersion: import("@angular/core").WritableSignal<number>;
+    /** Bumped when every rendered row must rebuild (refresh, template changes). */
+    readonly renderNonce: import("@angular/core").WritableSignal<number>;
+    private readonly rowVersions;
+    private readonly fieldVersions;
+    private summaryForceAll;
+    private readonly summaryForce;
+    private readonly summaryNonce;
+    private readonly summaryEngine;
+    /** Data indexes in sorted order, or null for the natural order. */
+    readonly sortedIndices: Signal<readonly number[] | null>;
+    /** Data indexes of the sorted and filtered data rows, or null when nothing is sorted or filtered. */
+    private readonly dataViewIndices;
+    /**
+     * Data index of every displayed row in display order (-1 for pending adds of batch mode, which are shown
+     * first or last), or null when the view is the data itself.
+     */
+    readonly viewIndices: Signal<readonly number[] | null>;
+    readonly viewRows: Signal<readonly TRow[]>;
+    readonly rowCount: Signal<number>;
+    readonly dataLength: Signal<number>;
+    readonly summaryColumns: Signal<ResolvedColumn<TRow>[]>;
+    /** Rows the summaries use: the displayed rows, without the pending deletes of batch mode. */
+    private readonly summaryRows;
+    /** Rows of `scope: 'all'` summaries: the data with the pending adds and without the pending deletes. */
+    private readonly summaryData;
+    readonly summaryVisible: Signal<boolean>;
+    /** The last summaries, returned again when every result came from the cache (the summary row doesn't re-render). */
+    private lastSummaries;
+    readonly summaries: Signal<Readonly<Record<string, GridSummaryResult>>>;
+    readonly editSession: import("@angular/core").WritableSignal<EditSession<TRow> | null>;
+    readonly gridEditMode: import("@angular/core").WritableSignal<boolean>;
+    /** Field whose filter popup is open. */
+    readonly openFilterField: import("@angular/core").WritableSignal<string | null>;
+    /** Wires the component inputs. Called once by the grid component. */
+    bind(inputs: GridInputs<TRow>): void;
+    /** Applies `initialSort`, `initialFilter` and `gridEditMode` from the configuration. */
+    applyInitialState(): void;
+    reportError(event: GridErrorEvent): void;
+    rowVersion(row: TRow): number;
+    private bumpRow;
+    private bumpField;
+    /**
+     * Marks what a changed field affects for summaries: the field, columns above or below it in a dot path
+     * (`customer` / `customer.name`), and computed columns (their inputs are unknown).
+     */
+    private bumpChangedField;
+    /** Replaces the data (the API counterpart of a new `[data]` array). */
+    setData(data: readonly TRow[], options?: GridRefreshOptions): GridRefreshResult;
+    /** Re-reads the current data after it was changed in place (push, splice, edited objects). */
+    refreshData(options?: GridRefreshOptions): GridRefreshResult;
+    /**
+     * Called by the component when the `[data]` or `[loading]` input changed. Runs during change
+     * detection, so the resulting events are emitted right after it (in a microtask).
+     */
+    inputsChanged(dataChanged: boolean, dataFirstChange: boolean, loadingChanged: boolean): void;
+    /** Applies the refresh policy and reconciles grid state with the new data. */
+    afterDataChange(reason: GridDataRefreshReason, options: GridRefreshOptions | undefined, defer: boolean): GridRefreshResult;
+    /** Keeps an open edit session on the same row (found again by key), or cancels it if the row is gone. */
+    private retargetEdit;
+    /**
+     * After a data change: drops selected keys whose rows are gone (and, with `onFilter: 'deselectHidden'`, rows the
+     * filter now hides), or everything with `reset`. Rows that still exist keep their selection, even as new objects.
+     */
+    private reconcileSelection;
+    /** The row with this key, if it is in the data (or a pending add of batch mode). */
+    rowByKey(key: GridRowKey): TRow | undefined;
+    /** View index of the row with this key, or -1 when it isn't displayed. O(1) without sort/filter, else O(n). */
+    viewIndexOfKey(key: GridRowKey): number;
+    private reportKeyProblems;
+    private deferred;
+    private held;
+    /**
+     * Runs `fn` now, or right after the current change detection when the change came from an input.
+     * Inside `withHeldEvents()`, synchronous events wait until the operation has updated all state.
+     */
+    private emit;
+    /** Runs an operation, then emits its events in order, so every handler sees the final state. */
+    private withHeldEvents;
+    setColumns(columns: readonly ColumnConfig<TRow>[]): void;
+    /** Called when the `[columns]` input changed (during change detection: events follow in a microtask). */
+    columnsChanged(): void;
+    refresh(): void;
+    refreshRows(rows: readonly TRow[]): void;
+    /** Writes a value into a row; re-renders only that row and recalculates only affected summaries. */
+    setCellValue(row: TRow, rowIndex: number, field: string, value: unknown, source: 'edit' | 'api'): boolean;
+    updateCell(rowIndex: number, field: string, value: unknown): void;
+    setSortModel(model: readonly SortModelItem[]): void;
+    /** Header click: cycles the column's direction. `multi` adds it to the existing sort. */
+    toggleSort(field: string, multi: boolean): void;
+    applySort(field: string, direction?: SortDirection, multi?: boolean): void;
+    clearSort(field?: string): void;
+    setFilterModel(model: FilterModel): void;
+    setColumnFilter(field: string, model: ColumnFilterModel | null): void;
+    clearFilter(field?: string): void;
+    private emitFilterChange;
+    openFilterPopup(field: string, anchor: HTMLElement | null): void;
+    closeFilterPopup(): void;
+    /** Selected rows by key, in selection order. Copy-on-write: every change creates a new map. */
+    readonly selection: import("@angular/core").WritableSignal<ReadonlyMap<GridRowKey, TRow>>;
+    /** Row of the last click (or Space): where Shift ranges start. */
+    private selectionAnchor;
+    /**
+     * The selection a Shift range is added to: the selection right after the click that set the anchor. Repeated Shift
+     * gestures recompute the range on top of it, so the range can grow and shrink. Any other change resets it.
+     */
+    private rangeBase;
+    /** 1 for each data position that is displayed; null when every row is displayed. Cached per view. */
+    readonly displayedMask: Signal<Uint8Array<ArrayBufferLike> | null>;
+    /** Every row: the data and, in batch mode, the pending adds. */
+    private readonly allRows;
+    /** State of the header checkbox over the rows in `selectAllScope`. */
+    readonly headerSelectionState: Signal<"all" | "none" | "some">;
+    private countSelectable;
+    isRowSelectable(row: TRow): boolean;
+    isRowSelected(row: TRow): boolean;
+    /** Selects rows by key. `replace` replaces the selection; in single mode only the last key is kept. */
+    selectKeys(keys: readonly GridRowKey[], source: GridSelectionSource, replace?: boolean): number;
+    /** Selects the given rows (known key and object). Returns the number of rows newly selected. */
+    selectEntries(entries: readonly [GridRowKey, TRow][], source: GridSelectionSource, replace: boolean, acted: [GridRowKey, TRow] | null): number;
+    /** Deselects rows by key. Returns the number of rows deselected. */
+    deselectKeys(keys: Iterable<GridRowKey>, source: GridSelectionSource, acted?: [GridRowKey, TRow] | null): number;
+    /** Selects every row in scope (the filtered rows by default). Returns the number of rows newly selected. */
+    selectAll(source: GridSelectionSource, scope?: "filtered" | "all"): number;
+    /** Deselects the rows in scope (every selected row by default). Returns the number of rows deselected. */
+    deselectAll(source: GridSelectionSource, scope?: 'filtered' | 'all'): number;
+    /**
+     * Works out what a click, checkbox or key on the row at `rowIndex` does to the selection, without applying it.
+     * Returns null when the gesture changes nothing (selection off, row not selectable).
+     *
+     * Every gesture toggles the row: multiple mode keeps the other rows, single mode replaces the selected row (and
+     * deselects it when it is the clicked one). Ctrl/Cmd doesn't change that. In multiple mode, Shift selects the rows
+     * from the anchor (the last clicked row) to this one, on top of the selection the anchor click left.
+     */
+    planSelection(rowIndex: number, gesture: 'click' | 'checkbox' | 'toggle', modifiers: {
+        ctrl: boolean;
+        shift: boolean;
+    }, source: GridSelectionSource): SelectionPlan<TRow> | null;
+    /** Multiple mode: the selection becomes `base` plus the selectable rows of `range` (both in that order). */
+    private selectRange;
+    /**
+     * After a `selection.mode` change: `'none'` deselects every row and `'single'` keeps only the last selected row
+     * (`selectionChange` with source `'api'`, after the change detection that applied the config).
+     */
+    private reconcileSelectionMode;
+    /** Applies a plan after `(selectionClick)` had the chance to cancel it. Returns false when cancelled. */
+    runSelectionPlan(plan: SelectionPlan<TRow>, source: GridSelectionClickEvent['source'], rowIndex: number, event: Event): boolean;
+    /** Header checkbox: selects every row in scope, or deselects them when all are selected. */
+    toggleSelectAll(event: Event): void;
+    /** Selects the rows between the anchor and `rowIndex` (Shift+arrow keys). */
+    extendSelectionTo(rowIndex: number, fromIndex: number): void;
+    /** With `onFilter` set, deselects the rows a new filter hides (or everything with `'clear'`). */
+    private syncSelectionWithFilter;
+    /** Stores a new selection and emits the selection events. Returns false when nothing changed. */
+    private commitSelection;
+    /**
+     * The selected cell, by row key and field, so it follows its row through sort, filter, scrolling and refresh. `hint`
+     * is the view index where it was selected: finding the row again right after a click costs nothing.
+     */
+    readonly selectedCell: import("@angular/core").WritableSignal<{
+        readonly key: GridRowKey;
+        readonly field: string;
+        readonly hint: number;
+    } | null>;
+    /** View index of the selected cell's row: -1 without one, or while a filter hides it. Cached per view. */
+    readonly selectedCellIndex: Signal<number>;
+    /** `getSelectedCell()`: null without a selected cell, and while cell selection is off. */
+    getSelectedCell(): GridSelectedCell<TRow> | null;
+    /**
+     * Selects a cell (`rowIndex`: its view index, or -1 when unknown) or, with `null`, clears the selected cell. Emits
+     * `cellSelectionChange` when the selected cell changed. Never changes the row selection.
+     */
+    setSelectedCell(next: {
+        key: GridRowKey;
+        field: string;
+        rowIndex: number;
+    } | null, source: GridCellSelectionSource, event: Event | null, defer?: boolean): boolean;
+    /** `selectCell()`: selects a displayed cell (row not filtered out, column not hidden). */
+    selectCellByKey(key: GridRowKey, field: string, scroll: boolean): boolean;
+    /** `clearCellSelection()`. */
+    clearCellSelection(): void;
+    private cellSelectionEvent;
+    /** Clears the selected cell when its row left the data or its column was removed (filters and hidden columns keep it). */
+    private reconcileSelectedCell;
+    /** Rows added while a filter is active, kept visible until the filter changes or the data is replaced. */
+    private readonly keptRows;
+    /** The array made by the last add or delete, so its echo through `[(data)]` isn't treated as new data. */
+    private crudData;
+    /** The open delete confirmation, if any. */
+    readonly deleteRequest: import("@angular/core").WritableSignal<DeleteRequest<TRow> | null>;
+    private readonly pathGetters;
+    private readonly pathSetters;
+    /** The primary-key field, when the primary key is a field rather than a function. */
+    readonly primaryKeyField: Signal<string | null>;
+    ngOnDestroy(): void;
+    /** `addRow()`: the object becomes the row (see the API documentation), then it is validated and added. */
+    addRow(values: Partial<TRow> | null | undefined, options: GridAddRowOptions | undefined, source: 'ui' | 'api'): GridCrudResult<TRow>;
+    /** Opens the inline add row: a draft row in row edit mode, added when the edit is committed. */
+    beginAddRow(options?: GridBeginAddRowOptions<TRow>): boolean;
+    /** `updateRow()`. */
+    updateRow(key: GridRowKey, changes: Readonly<Record<string, unknown>> | null | undefined): GridCrudResult<TRow>;
+    /** Deletes rows now, without confirmation. */
+    deleteRows(keys: readonly GridRowKey[], source: 'ui' | 'api' | 'keyboard'): GridCrudResult<TRow>;
+    /** Deletes rows after the configured confirmation (the built-in dialog or the `infiGridDeleteConfirm` template). */
+    requestDelete(keys: readonly GridRowKey[], source: 'ui' | 'api' | 'keyboard'): Promise<GridCrudResult<TRow>>;
+    /** Whether a cell gets an editor. Keys are read-only once a row is added; the add row uses `editableOnAdd`. */
+    isCellEditable(column: ResolvedColumn<TRow>, row: TRow, isNew?: boolean): boolean;
+    private isEditableOnAdd;
+    /**
+     * The object of a new row: the `editing.newRow` object with `values` applied, or `values` itself
+     * (a copy with `copy`); then column defaults fill the fields that are still undefined.
+     */
+    private createRow;
+    /** Validates a new row and inserts it (copy-on-write). `session` is the add row being committed. */
+    private insertNewRow;
+    /**
+     * Validates and writes changes into a row, in place: `required` and column validators, the key must not
+     * change, `rowValidator` on a preview copy; then `rowUpdating` (cancelable), the writes, `cellValueChange`
+     * per field and `rowUpdated`. `session` is the edit session that produced the changes (closed before writing).
+     */
+    private applyUpdate;
+    /** `required`, column validators and `editing.rowValidator` for a new row. */
+    private validateNewRow;
+    /** `required` and the column validator for a value (already converted to the column type). */
+    private checkValue;
+    private runRowValidator;
+    /** A new row needs a key that no row uses yet (with a primary key; without one, the row object is the key). */
+    private checkNewKey;
+    /** Rows of the given keys in the data or the pending adds (each key once), with their data positions (-1: pending). */
+    private findRows;
+    /** Stores the array made by an add or delete. The bound array is never changed. */
+    private commitData;
+    private emitCrudRefresh;
+    /** Scrolls a row into view; with `focus`, its first cell also gets the focus. */
+    private revealRow;
+    /** Errors of a refused commit, on the editors (messages for other fields go on the focused editor). */
+    private showEditErrors;
+    private readPath;
+    private pathSetter;
+    /** Pending adds, in the order they were made. */
+    readonly pendingAdds: import("@angular/core").WritableSignal<ReadonlyMap<GridRowKey, PendingAdd<TRow>>>;
+    /** Rows marked for deletion (shown struck through until saved). */
+    readonly pendingDeletes: import("@angular/core").WritableSignal<ReadonlyMap<GridRowKey, TRow>>;
+    /** Pending values of data rows, by key. Mutable: rows re-render through their version. */
+    private readonly pendingUpdates;
+    /** Data row → its copy with the pending values: what the grid shows, sorts, filters and sums. */
+    private readonly mergedRows;
+    /** Bumped once per change of the pending state (toolbar, `canUndo()`). */
+    readonly pendingVersion: import("@angular/core").WritableSignal<number>;
+    /** A save handler is running: changes are refused until it settles. */
+    readonly saving: import("@angular/core").WritableSignal<boolean>;
+    /** The last save failed (until the next change). */
+    readonly saveFailed: import("@angular/core").WritableSignal<boolean>;
+    private undoStack;
+    private redoStack;
+    /** Pending adds shown first (newest first, as if each was inserted at the top). */
+    private readonly pendingTop;
+    /** Pending adds shown last, in order. */
+    private readonly pendingBottom;
+    /** The row as displayed: in batch mode, a copy with its pending values. */
+    displayRow(row: TRow): TRow;
+    /** The batch state of a row, for rendering (null without changes). */
+    rowChange(row: TRow): RowChangeState | null;
+    private isPendingDelete;
+    hasPendingChanges(): boolean;
+    canUndo(): boolean;
+    canRedo(): boolean;
+    /** Undoes the last pending change. An open edit of a data row is discarded first. */
+    undo(): boolean;
+    redo(): boolean;
+    getPendingChanges(): GridChangeSet<TRow>;
+    /**
+     * Commits an open edit, runs the save handler (default `editing.saveHandler`) and applies the changes to the
+     * data when it succeeds. A handler that throws or rejects keeps everything pending. Never rejects.
+     */
+    saveChanges(handler?: (changes: GridChangeSet<TRow>) => unknown): Promise<GridSaveResult<TRow>>;
+    /** Discards every pending change (and an open edit). Returns what was discarded. */
+    cancelChanges(): GridChangeSet<TRow>;
+    /** Batch mode: takes rows off the pending deletes (the action column's restore button). */
+    restoreRows(keys: readonly GridRowKey[]): boolean;
+    /**
+     * Called when the `[config]` input changed: a selection the new `selection.mode` can't hold is reduced, turning cell
+     * selection off forgets the selected cell (no event: the feature is off), and turning batch mode off discards the
+     * pending changes.
+     */
+    configChanged(): void;
+    /** Records a validated new row as a pending add. */
+    private addPending;
+    /**
+     * Records validated changes: a pending add is changed in place (it is the grid's own object); a data row
+     * gets pending values and a display copy.
+     */
+    private updatePending;
+    /** Marks rows as deleted; pending adds are dropped instead. */
+    private deletePending;
+    private setPendingAdds;
+    private setPendingDeletes;
+    /**
+     * Rows that were removed or marked deleted: their edit is cancelled and they are deselected. The selected cell only
+     * goes with rows that left the grid (a row marked deleted is still shown until the save).
+     */
+    private forgetRows;
+    /** Stores pending values of a data row. A value equal to the data's drops that change. */
+    private setPendingValues;
+    /** Rebuilds the display copy of a row with pending values (or forgets the row when none are left). */
+    private rebuildMerged;
+    private pendingSnapshot;
+    /** Undo/redo of an update: puts back the pending values a row had. */
+    private restorePending;
+    private afterPendingWrite;
+    /** Writes the saved changes into the data: values in place, deletes and adds as a new array. */
+    private applyChanges;
+    /** Forgets every pending change and the undo history; every rendered row is drawn again. */
+    private clearPending;
+    /** After the data was replaced or refreshed, pending changes follow their rows by key (or go with them). */
+    private rebasePending;
+    /** Records an undoable step; a new change clears the redo history. */
+    private recordStep;
+    /** Undo/redo discard an open edit of a data row (an open add row stays). */
+    private discardRowEdit;
+    private emitPendingChange;
+    /** The data row with this key (never a pending add). */
+    private dataRowByKey;
+    /**
+     * Sets a column's width (clamped to min/max). `startWidth` is the width when a drag started, so every
+     * event of one drag reports the same `oldWidth`.
+     */
+    setColumnWidth(field: string, width: number, finished?: boolean, source?: 'user' | 'api', startWidth?: number): void;
+    /** Restores the configured width of one column, or of every resized column. */
+    resetColumnWidth(field?: string): void;
+    setColumnVisible(field: string, visible: boolean): void;
+    columnWidth(field: string): number | undefined;
+    recalculateSummary(fields?: string | readonly string[]): void;
+    setLoading(loading: boolean): void;
+    private lastLoading;
+    /** Emits `loadingChange` once per real change of the effective loading state. */
+    private syncLoading;
+    setError(error: unknown): void;
+    /** Editable fields of a row, in display order (never the primary-key field). */
+    editableFields(row: TRow): string[];
+    /**
+     * Starts editing a cell (field given) or a whole row. In row mode (`editing.mode: 'row'`),
+     * starting on a cell edits the whole row with that cell focused.
+     */
+    startEdit(rowIndex: number, field?: string): boolean;
+    /** Stores a draft value and re-validates it. */
+    setDraft(field: string, value: unknown): string | null;
+    /**
+     * Saves the current session: updates the row (`rowUpdating`/`rowUpdated`, source `'edit'`), or adds the
+     * inline add row. Returns false and keeps editing when validation fails or a handler cancels.
+     */
+    commitEdit(): boolean;
+    /** Writes the add row's values into its draft and adds it. */
+    private commitNewRow;
+    cancelEdit(emit?: boolean): void;
+    /**
+     * Grid edit mode: every change is validated and saved immediately (as an update with source `'edit'`).
+     * `saved` is false when the value was refused or a `rowUpdating` handler cancelled.
+     */
+    commitGridCell(row: TRow, rowIndex: number, field: string, value: unknown): {
+        error: string | null;
+        saved: boolean;
+    };
+    setGridEditMode(enabled: boolean): void;
+    getEditState(): GridEditState<TRow> | null;
+    private publicEditState;
+    /** Validates an editor value: a number for number columns, then `required` and the column validator. */
+    private validate;
+    /** Converts editor output back to the column type, keeping the shape of the original value. */
+    parseEditedValue(column: ResolvedColumn<TRow>, value: unknown, original: unknown): unknown;
+    static ɵfac: i0.ɵɵFactoryDeclaration<GridStore<any>, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<GridStore<any>>;
+}
+export {};

package/lib/state/tooltip.service.d.ts

@@ -0,0 +1,38 @@
+import { OnDestroy } from '@angular/core';
+import type { GridTemplate } from '../models/template.types';
+import type { GridTooltipPlacement } from '../models/tooltip.types';
+import * as i0 from "@angular/core";
+/** Text, or a template (TemplateRef or component) with its context. */
+export type TooltipContent = string | {
+    readonly template: GridTemplate<any>;
+    readonly context: object;
+};
+/**
+ * The grid's single tooltip, in `document.body` so it is never clipped. Created on first use, reused for every
+ * cell and header, and removed with the grid. Templates are rendered on show (checked once: they aren't
+ * attached to the application, which would make showing a tooltip check the whole app) and destroyed on hide.
+ */
+export declare class GridTooltipService implements OnDestroy {
+    private readonly environmentInjector;
+    private readonly injector;
+    private readonly document;
+    /** The `<infi-grid>` element (for the theme); set by the grid component. */
+    host: HTMLElement | null;
+    readonly id: string;
+    private element;
+    private view;
+    private anchor;
+    /** True while the tooltip is shown. */
+    get visible(): boolean;
+    /** Shows `content` next to `anchor` (replacing what was shown). */
+    show(anchor: HTMLElement, content: TooltipContent, placement: GridTooltipPlacement): void;
+    hide(): void;
+    ngOnDestroy(): void;
+    private ensureElement;
+    private render;
+    /** Destroys rendered views and detaches the tooltip from its anchor. */
+    private clear;
+    private applyTheme;
+    static ɵfac: i0.ɵɵFactoryDeclaration<GridTooltipService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<GridTooltipService>;
+}