infi-grid 1.0.0

package/lib/components/tooltip-controller.d.ts

@@ -0,0 +1,43 @@
+import type { GridRowKey } from '../models/data.types';
+import type { GridStore } from '../state/grid-store';
+import type { GridTooltipService } from '../state/tooltip.service';
+/**
+ * What a tooltip points at. Body cells are identified by row key and field, not by element: elements are
+ * recycled while scrolling, so a recycled element can never keep a stale tooltip.
+ */
+export interface TooltipTarget {
+    readonly kind: 'cell' | 'header' | 'summary';
+    readonly field: string;
+    /** The element the tooltip is placed against. */
+    readonly element: HTMLElement;
+    readonly key?: GridRowKey;
+    readonly row?: unknown;
+    readonly rowIndex?: number;
+}
+/**
+ * Decides when the grid's tooltip shows and with what: the target under the pointer or the keyboard focus,
+ * whether its text is cut off (measured once per target, never per frame), the show and hide delays, and the
+ * content (a column's `tooltip` function, a tooltip template, or the text).
+ */
+export declare class GridTooltipController<TRow> {
+    private readonly store;
+    private readonly tooltip;
+    private target;
+    private timer;
+    constructor(store: GridStore<TRow>, tooltip: GridTooltipService);
+    /** The pointer (or the keyboard focus) is now on `next`, or on nothing. */
+    point(next: TooltipTarget | null): void;
+    /** Hides it and forgets the target (scrolling, re-rendering): the next pointer move finds the new target. */
+    reset(): void;
+    /** Hides it but keeps the target, so it only comes back on another target (pointer down, key press). */
+    dismiss(): void;
+    destroy(): void;
+    private schedule;
+    private clearTimer;
+    /** What a target shows, or null (tooltip off, text not cut off, nothing to say). */
+    private content;
+    private cellContent;
+    private headerContent;
+    /** Summary cells show their label and value when they are cut off. */
+    private summaryContent;
+}

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

@@ -0,0 +1,217 @@
+import { OnDestroy } from '@angular/core';
+import type { VirtualizationState } from '../models/api.types';
+import type { FilterModel } from '../models/filter.types';
+import type { SortModelItem } from '../models/sort.types';
+import type { GridCellSelectionSource } from '../models/selection.types';
+import type { GridSummaryResult } from '../models/summary.types';
+import { type IndexRange, type VerticalMetrics } from '../core/virtual-math';
+import { type ColumnLayout, type EditSession, type LayoutColumn, type ViewportHandle } from '../state/grid-store';
+import * as i0 from "@angular/core";
+/**
+ * A reusable row slot. Slot `k` renders the row whose index ≡ k (mod pool size).
+ * Slots are never destroyed while scrolling: an unused slot keeps its last row and is hidden,
+ * because creating or destroying views makes Angular check the whole application.
+ */
+interface RowSlot<TRow> {
+    readonly key: number;
+    row: TRow | null;
+    hidden: boolean;
+    columns: readonly LayoutColumn<TRow>[];
+    rowIndex: number;
+    dataIndex: number;
+    top: number;
+    transform: string;
+    version: number;
+    edit: EditSession<TRow> | null;
+    focusField: string | null;
+    selected: boolean;
+    selectable: boolean;
+    /** The row of the selected cell, with `cellSelection.activeRow`. */
+    active: boolean;
+    stamp: number;
+}
+interface RenderWindow<TRow> {
+    slots: RowSlot<TRow>[];
+    columns: readonly LayoutColumn<TRow>[];
+    /** Number of plain-cell slots per row (never shrinks while scrolling). */
+    columnPool: number;
+    /** Number of template-cell slots per row (never shrinks while scrolling). */
+    templatePool: number;
+    layout: ColumnLayout<TRow>;
+    rowRange: IndexRange;
+    colRange: IndexRange;
+    metrics: VerticalMetrics;
+    rowCount: number;
+    /** Displayed data columns. */
+    columnCount: number;
+    /** `aria-colcount`: data columns plus the checkbox and action columns. */
+    ariaColCount: number;
+    rowHeight: number;
+    headerHeight: number;
+    /** Height of the filter row (0 without one). */
+    filterRowHeight: number;
+    /** Rows above the data rows for `aria-rowindex`: the header, and the filter row. */
+    headerRows: number;
+    summaryHeight: number;
+    summaryVisible: boolean;
+    summarySticky: boolean;
+    summaries: Readonly<Record<string, GridSummaryResult>>;
+    sortModel: readonly SortModelItem[];
+    filterModel: FilterModel;
+    openFilterField: string | null;
+    gridEditMode: boolean;
+    renderNonce: number;
+    canvasWidth: number;
+    canvasRowsHeight: number;
+    rowsViewportHeight: number;
+    /** `virtualization.syncScroll`: the content is positioned by `applyScroll()`. */
+    syncScroll: boolean;
+    /** Width of the stage with syncScroll: the viewport without its scrollbar. */
+    stageWidth: number;
+    /** Top of the rows area in the canvas: the header block and the top add row. */
+    rowsTop: number;
+    /** Height of the rows area (at least the viewport's rows height with a sticky summary row). */
+    rowsBoxHeight: number;
+    ariaLabel: string;
+    selectionOn: boolean;
+    multiselect: boolean;
+    leadingWidth: number;
+    trailingWidth: number;
+    selectAllVisible: boolean;
+    headerSelectionState: 'none' | 'some' | 'all';
+    /** The inline add row's session, and where its band is pinned. */
+    addSession: EditSession<TRow> | null;
+    addTop: boolean;
+    addBottom: boolean;
+    /** Bottom offset of the bottom add band (above a sticky summary row). */
+    addBottomOffset: number;
+}
+/**
+ * The scroll container: header (sticky), virtualized rows, summary row (sticky or inline).
+ *
+ * Performance design:
+ * - scroll, resize, click and key listeners run outside Angular's zone;
+ * - on scroll, only this component is checked (`detectChanges()`), and only when the rendered
+ *   row/column window actually changed — the rest of the application is never checked;
+ * - rows live in a fixed pool of slots that are reused, so fast scrolling rebinds existing DOM
+ *   instead of creating and destroying it;
+ * - with `virtualization.syncScroll` (default), the drawn content stays in view while the browser scrolls on its own
+ *   thread, and moves in the same frame as the rows and columns drawn for the new position: fast scrolling never
+ *   shows areas that aren't drawn yet (see applyScroll()).
+ */
+export declare class GridViewportComponent<TRow = any> implements ViewportHandle, OnDestroy {
+    private scrollerRef;
+    private rowsRef;
+    private innerRef?;
+    private trackRef?;
+    private readonly store;
+    private readonly cdr;
+    private readonly zone;
+    private readonly tips;
+    private scrollTop;
+    private scrollLeft;
+    private viewportWidth;
+    private viewportHeight;
+    private focusRow;
+    private focusField;
+    /** Offsets written by applyScroll(). */
+    private appliedLeft;
+    private appliedTop;
+    private win;
+    private memo;
+    private slots;
+    private columnPool;
+    private templatePool;
+    private poolLayout;
+    private poolWidth;
+    private stamp;
+    private resizeObserver;
+    private readonly cleanup;
+    private destroyed;
+    constructor();
+    ngOnDestroy(): void;
+    /** Called from the template. Returns the cached window unless an input of the window changed. */
+    renderWindow(): RenderWindow<TRow>;
+    /**
+     * syncScroll: moves the content to the current scroll position. The stage is sticky, so while the browser scrolls
+     * on its own thread it stays in view with the content drawn for the last position (the rows track sticks under the
+     * header the same way). The content only moves here: from the scroll handler, in the same task that draws the rows
+     * and columns for the new position, so a frame never shows the new position without them. Not template bindings:
+     * the offsets change on every scroll frame, also when the drawn window doesn't (no change detection then).
+     *
+     * The offsets are the ones the browser gives the sticky elements: the stage moves right by `scrollLeft` (the inner
+     * block moves back by the same amount), the track moves down by `scrollTop`, up to the end of the rows area.
+     */
+    private applyScroll;
+    /**
+     * syncScroll: places the pinned regions (checkbox and action columns of the rows, header, filter and summary rows)
+     * at the viewport edges. Without syncScroll they are sticky, but a sticky element in every row makes the browser
+     * give every row its own layer: dozens of layers to update while scrolling. With syncScroll the grid moves the
+     * content itself, so it places them too (`is-placed`, absolutely positioned): rows place theirs when they are drawn
+     * (`GridStore.pinPlacement`), and this moves the ones already drawn, in the frame the content moves.
+     */
+    private placePins;
+    /**
+     * Sizes the cell pools for the widest window the layout can produce, once per layout/viewport
+     * width, so scrolling sideways never grows them (growing creates views, which makes Angular check
+     * the whole application). Pools only grow; they are capped at the number of displayed columns.
+     */
+    private sizeColumnPools;
+    scrollToRow(rowIndex: number, position: 'auto' | 'start' | 'center' | 'end'): void;
+    scrollToColumn(columnIndex: number, position: 'auto' | 'start' | 'center' | 'end'): void;
+    /** Horizontal scroll position that shows a column next to (not under) the pinned regions. */
+    private alignColumn;
+    getVirtualizationState(): VirtualizationState;
+    focus(): void;
+    focusCell(rowIndex: number, field: string, source?: GridCellSelectionSource): void;
+    private attach;
+    private measure;
+    /** Scroll handler (outside the zone). Checks only this component, and only if the window changed. */
+    private onScroll;
+    /** True when the new scroll position needs different rows/columns (or scaled positions). */
+    private windowChanged;
+    /** The row (and cell) under a pointer event, from the DOM attributes the viewport renders. */
+    private hitRow;
+    private dataIndexAt;
+    private cellEvent;
+    /**
+     * Emits the click (or double-click) events of a row. They always fire; a handler that sets `cancel`
+     * stops the grid's built-in reaction. Returns true when a handler cancelled.
+     */
+    private emitClickEvents;
+    /** Click events waiting for a possible double click (`events.clickMode: 'waitForDoubleClick'`). */
+    private pendingClick;
+    private clearPendingClick;
+    private onClick;
+    /** Makes a row's checkbox show that row's selection state. */
+    private syncSelectorBox;
+    private onRowClick;
+    /** Buttons of the action column: edit, delete, save and cancel on rows (and the add row), add in the header. */
+    private onActionClick;
+    private onContextMenu;
+    /** The hovered cell, identified by row key and field (not by element: elements are recycled). */
+    private hover;
+    private hoverFrame;
+    private hoverEvent;
+    private listensToHover;
+    /** At most one hit test per animation frame, however fast the pointer moves. */
+    private onPointerMove;
+    /** The cell, header or summary cell under the pointer that can have a tooltip. */
+    private tooltipTarget;
+    /** Keyboard focus on a header's filter button shows the header tooltip. */
+    private onFocusIn;
+    /** Keyboard focus moved to a cell: its tooltip shows after the delay, as on hover. */
+    private focusTooltip;
+    /** Changes the hovered cell, emitting leave for the old one and enter for the new one. */
+    private setHover;
+    private onDoubleClick;
+    private onKeydown;
+    private focusEditorAt;
+    /** The focused cell. With cell selection it is the selected cell (by key, so it is right also before a re-render). */
+    private focusPosition;
+    /** Moves the focus to a cell; with cell selection, that cell becomes the selected cell (`source` and `event` say why). */
+    private setFocus;
+    static ɵfac: i0.ɵɵFactoryDeclaration<GridViewportComponent<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<GridViewportComponent<any>, "infi-grid-viewport", never, {}, {}, never, never, true, never>;
+}
+export {};

package/lib/core/accessor.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Compiled field accessors. `'price'` reads `row.price`; `'customer.name'` reads `row.customer?.name`.
+ * Compiling once per column keeps the per-cell cost to a property read.
+ */
+export declare function compileGetter(field: string): (row: any) => any;
+export declare function compileSetter(field: string): ((row: any, value: any) => void) | null;

package/lib/core/config-resolver.d.ts

@@ -0,0 +1,16 @@
+import type { ColumnConfig, ResolvedColumn } from '../models/column.types';
+import type { GridConfig, ResolvedGridConfig } from '../models/config.types';
+import type { GridErrorEvent } from '../models/events.types';
+import type { TemplateRegistry } from './template-registry';
+/** Copies an object without its `undefined` properties, so they don't override defaults when spread. */
+export declare function stripUndefined<T extends object>(value: T): Partial<T>;
+/** Fills every default of the grid configuration. */
+export declare function resolveConfig<TRow>(config: GridConfig<TRow> | null | undefined): ResolvedGridConfig<TRow>;
+/**
+ * Merges each column with `defaultColumn` and the global flags (column settings win),
+ * compiles accessors/formatters, and resolves templates (most specific first):
+ * column property → field directive → type template (config, then directive) → default column → built-in.
+ */
+export declare function resolveColumns<TRow>(columns: readonly ColumnConfig<TRow>[] | null | undefined, config: ResolvedGridConfig<TRow>, registry: TemplateRegistry, onError?: (event: GridErrorEvent) => void): ResolvedColumn<TRow>[];
+/** Whether a column is editable for a given row (it must also be writable). */
+export declare function isColumnEditable<TRow>(column: ResolvedColumn<TRow>, row: TRow): boolean;

package/lib/core/defaults.d.ts

@@ -0,0 +1,7 @@
+import type { GridText } from '../models/config.types';
+export declare const DEFAULT_ROW_HEIGHT = 36;
+export declare const DEFAULT_HEADER_HEIGHT = 40;
+export declare const DEFAULT_COLUMN_WIDTH = 150;
+export declare const DEFAULT_MIN_COLUMN_WIDTH = 48;
+export declare const DEFAULT_MAX_COLUMN_WIDTH = 4000;
+export declare const DEFAULT_TEXT: GridText;

package/lib/core/filter-engine.d.ts

@@ -0,0 +1,44 @@
+import type { GridDataType, ResolvedColumn } from '../models/column.types';
+import { type ColumnFilterModel, type FilterCondition, type FilterModel } from '../models/filter.types';
+export type RowPredicate<TRow> = (row: TRow) => boolean;
+type ValuePredicate = (value: unknown, row: any) => boolean;
+/** True when the model would remove rows. */
+export declare function isColumnFilterActive(model: ColumnFilterModel | null | undefined): boolean;
+/** Removes inactive column entries. */
+export declare function normalizeFilterModel(model: FilterModel | null | undefined): FilterModel;
+/**
+ * Key used by the Excel-style value list: text → string, number → number,
+ * date → `'YYYY-MM-DD'`, boolean → true/false. Blanks → `null`.
+ */
+export declare function valueKey(value: unknown, type: GridDataType): string | number | boolean | null;
+/** Compiles one condition; `null` means the condition is incomplete and is ignored. */
+export declare function compileCondition<TRow>(column: ResolvedColumn<TRow>, cond: FilterCondition): ValuePredicate | null;
+/** Compiles the filter of one column into a row predicate, or `null` when it removes nothing. */
+export declare function compileColumnFilter<TRow>(column: ResolvedColumn<TRow>, model: ColumnFilterModel): RowPredicate<TRow> | null;
+/** Compiles the whole filter model (optionally skipping one column, for Excel-style cascading value lists). */
+export declare function compileFilterModel<TRow>(model: FilterModel, columns: ReadonlyMap<string, ResolvedColumn<TRow>>, excludeField?: string): RowPredicate<TRow>[];
+/**
+ * Keeps the rows that pass every predicate, preserving `order` (sorted indexes, or natural order when null).
+ * Rows in `alwaysInclude` pass regardless (rows just added, kept visible until the filter changes).
+ * Returns `null` when nothing is filtered, so callers can reuse `order` without copying.
+ */
+export declare function filterIndices<TRow>(data: readonly TRow[], order: readonly number[] | null, predicates: readonly RowPredicate<TRow>[], alwaysInclude?: ReadonlySet<TRow> | null): number[] | null;
+export interface ValueListItem {
+    key: string | number | boolean | null;
+    label: string;
+    count: number;
+}
+export interface ValueListResult {
+    items: ValueListItem[];
+    truncated: boolean;
+}
+/**
+ * Distinct values of a column for the Excel-style checkbox list, from the rows that pass
+ * the filters of all *other* columns (like Excel). Sorted ascending, blanks last.
+ */
+export declare function distinctValues<TRow>(data: readonly TRow[], column: ResolvedColumn<TRow>, model: FilterModel, columns: ReadonlyMap<string, ResolvedColumn<TRow>>, options: {
+    locale: string | undefined;
+    blanksLabel: string;
+    limit: number;
+}): ValueListResult;
+export {};

package/lib/core/format.d.ts

@@ -0,0 +1,11 @@
+import type { ColumnConfig, GridDataType } from '../models/column.types';
+import type { GridText } from '../models/config.types';
+/** `Intl.NumberFormat` instances are expensive to create, so they are cached by locale + options. */
+export declare function getNumberFormat(locale: string | undefined, options?: Intl.NumberFormatOptions): Intl.NumberFormat;
+export declare function getDateFormat(locale: string | undefined, options?: Intl.DateTimeFormatOptions): Intl.DateTimeFormat;
+export type ValueFormatter = (value: any, row?: any) => string;
+/**
+ * Builds the display formatter of a column. A failing custom `valueFormatter`
+ * shows `#ERROR` in the cell and is reported once through `onError`.
+ */
+export declare function createFormatter(column: Pick<ColumnConfig, 'valueFormatter' | 'numberFormat' | 'dateFormat' | 'booleanLabels'>, type: GridDataType, locale: string | undefined, text: GridText, onError?: (error: unknown) => void): ValueFormatter;

package/lib/core/keys.d.ts

@@ -0,0 +1,24 @@
+import type { GridRowKey } from '../models/data.types';
+/** Returns the key of a row. */
+export type KeyAccessor<TRow> = (row: TRow) => GridRowKey;
+/** Compiles `config.primaryKey` (field, dot path or function). Without one, the row object is the key. */
+export declare function compileKeyAccessor<TRow>(primaryKey: string | ((row: TRow) => GridRowKey) | null): KeyAccessor<TRow>;
+/** A key that can't identify a row: `null`, `undefined`, `''` or `NaN`. */
+export declare function isMissingKey(key: unknown): boolean;
+/** Data position of each key, built once per data version. */
+export interface KeyIndex {
+    /** Key → position in the data array (the first row wins when keys repeat). */
+    readonly positions: ReadonlyMap<GridRowKey, number>;
+    /** Distinct keys that occur more than once (at most 10 are listed). */
+    readonly duplicates: readonly GridRowKey[];
+    /** Number of distinct repeated keys (`duplicates` lists at most 10 of them). */
+    readonly distinctDuplicateCount: number;
+    /** Rows sharing a key with an earlier row. */
+    readonly duplicateCount: number;
+    /** Rows without a usable key. */
+    readonly missingCount: number;
+}
+/** Builds the key index of `data` in one pass. `checkMissing` is false when rows are their own keys. */
+export declare function buildKeyIndex<TRow>(data: readonly TRow[], keyOf: KeyAccessor<TRow>, checkMissing: boolean): KeyIndex;
+/** Human-readable description of the problems in a key index, or null when the keys are valid. */
+export declare function describeKeyProblems(index: KeyIndex, primaryKey: string | null): string | null;

package/lib/core/row-ops.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Helpers for adding, updating and deleting rows: emptiness, row copies (for `oldRow` snapshots and
+ * validation previews), positions and validation results.
+ */
+import type { GridAddPosition, GridRowValidationResult } from '../models/crud.types';
+/** Values a `required` field doesn't accept: null, undefined, blank text, NaN and invalid dates. */
+export declare function isEmptyValue(value: unknown): boolean;
+/** Shallow copy that keeps the prototype, so class instances keep their methods and getters. */
+export declare function shallowCopy<T>(value: T): T;
+/**
+ * Copy of a row in which the objects along each dot path are copied too, so that writing those paths on
+ * the copy leaves the row unchanged (and the copy keeps the old values when the row is written).
+ * With `oneLevel`, every object property of the row is copied as well, for custom `valueSetter`s that may
+ * write into nested objects outside their field path.
+ */
+export declare function copyAlongPaths<T>(row: T, paths: Iterable<string>, oneLevel?: boolean): T;
+/** Data index for a new row. */
+export declare function resolveAddPosition(position: GridAddPosition | undefined, fallback: 'top' | 'bottom', length: number): number;
+/** Adds the messages of a `rowValidator` result to `errors` (`'$row'` for a row-level message). Existing messages win. */
+export declare function mergeRowValidation(result: GridRowValidationResult, errors: Record<string, string>): void;

package/lib/core/sort-engine.d.ts

@@ -0,0 +1,11 @@
+import type { ResolvedColumn } from '../models/column.types';
+import type { SortModelItem } from '../models/sort.types';
+export interface SortOptions {
+    locale: string | undefined;
+    nulls: 'first' | 'last';
+}
+/**
+ * Returns data indexes in sorted order, or `null` when the model has no usable entry
+ * (natural data order). The sort is stable; ties keep their original order.
+ */
+export declare function sortIndices<TRow>(data: readonly TRow[], model: readonly SortModelItem[], columns: ReadonlyMap<string, ResolvedColumn<TRow>>, options: SortOptions): number[] | null;

package/lib/core/summary-engine.d.ts

@@ -0,0 +1,35 @@
+import type { GridApi } from '../models/api.types';
+import type { ResolvedColumn } from '../models/column.types';
+import type { GridErrorEvent } from '../models/events.types';
+import type { FilterModel } from '../models/filter.types';
+import type { SortModelItem } from '../models/sort.types';
+import type { GridSummaryHelpers, GridSummaryResult } from '../models/summary.types';
+export declare const SUMMARY_HELPERS: GridSummaryHelpers;
+export interface SummaryInput<TRow> {
+    data: readonly TRow[];
+    /** Rows after filtering (and sorting). */
+    rows: readonly TRow[];
+    columns: readonly ResolvedColumn<TRow>[];
+    /** Edit counter per field; a summary is recalculated only when its fields changed. */
+    fieldVersion: (field: string) => number;
+    /** Increases on every edit; used for custom summaries without `dependsOn`. */
+    editVersion: number;
+    /** Changes on `recalculateSummary()` for the given field (or all fields). */
+    forceVersion: (field: string) => string;
+    api: GridApi<TRow>;
+    filterModel: FilterModel;
+    sortModel: readonly SortModelItem[];
+    locale: string | undefined;
+    onError?: (event: GridErrorEvent) => void;
+}
+/**
+ * Calculates column summaries with a per-column cache. A column is recalculated only when
+ * its rows, its column definition, or the fields it depends on changed, so editing one cell
+ * recalculates one summary instead of all of them.
+ */
+export declare class SummaryEngine<TRow> {
+    private cache;
+    compute(input: SummaryInput<TRow>): Record<string, GridSummaryResult>;
+    clear(): void;
+    private format;
+}

package/lib/core/template-registry.d.ts

@@ -0,0 +1,27 @@
+import type { GridDataType } from '../models/column.types';
+import type { GridTemplate } from '../models/template.types';
+/** Templates declared with `<ng-template infiGrid…>` directives inside `<infi-grid>`. */
+export interface TemplateRegistry {
+    readonly display: TemplateGroup;
+    readonly edit: TemplateGroup;
+    readonly header: TemplateGroup;
+    readonly summary: TemplateGroup;
+    readonly cellTooltip: TemplateGroup;
+    readonly headerTooltip: TemplateGroup;
+    readonly loading: GridTemplate<any> | null;
+    readonly empty: GridTemplate<any> | null;
+    readonly error: GridTemplate<any> | null;
+}
+export interface TemplateGroup {
+    readonly byField: ReadonlyMap<string, GridTemplate<any>>;
+    readonly byType: ReadonlyMap<GridDataType, GridTemplate<any>>;
+    /** Directive without `field` or `type`: applies to every column. */
+    readonly fallback: GridTemplate<any> | null;
+}
+export declare const EMPTY_TEMPLATE_REGISTRY: TemplateRegistry;
+export interface TemplateDirectiveLike {
+    readonly template: GridTemplate<any>;
+    readonly field: string | undefined;
+    readonly type: GridDataType | undefined;
+}
+export declare function buildTemplateGroup(directives: readonly TemplateDirectiveLike[]): TemplateGroup;

package/lib/core/theme.d.ts

@@ -0,0 +1,2 @@
+/** CSS custom properties used for theming (copied onto the filter popup, which lives in `<body>`). */
+export declare const THEME_VARIABLES: readonly string[];

package/lib/core/tooltip-position.d.ts

@@ -0,0 +1,24 @@
+import type { GridTooltipPlacement } from '../models/tooltip.types';
+export interface TooltipRect {
+    readonly left: number;
+    readonly top: number;
+    readonly width: number;
+    readonly height: number;
+}
+export interface TooltipPosition {
+    readonly left: number;
+    readonly top: number;
+    /** The side used: the preferred one, or the opposite side when the preferred one has no room. */
+    readonly placement: GridTooltipPlacement;
+}
+/**
+ * Places a tooltip of `size` next to `anchor` (both in viewport coordinates), centered on it.
+ * Flips to the opposite side when the preferred side has no room, then keeps it inside the viewport.
+ */
+export declare function placeTooltip(anchor: TooltipRect, size: {
+    readonly width: number;
+    readonly height: number;
+}, viewport: {
+    readonly width: number;
+    readonly height: number;
+}, placement: GridTooltipPlacement, gap?: number, margin?: number): TooltipPosition;

package/lib/core/values.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Value normalization shared by sorting, filtering, formatting and summaries.
+ * Everything here is allocation-free on the hot path and never throws.
+ */
+export declare function isBlank(value: unknown): boolean;
+/** Number or null. Booleans become 1/0, dates their timestamp. */
+export declare function toNumber(value: unknown): number | null;
+/** Timestamp (ms) or null. `'YYYY-MM-DD'` strings are read as local dates. */
+export declare function toTimestamp(value: unknown): number | null;
+/** true / false / null. Accepts booleans, 1/0 and 'true'/'false'/'yes'/'no'. */
+export declare function toBoolean(value: unknown): boolean | null;
+/** Local calendar day as a sortable number: 2024-05-01 → 20240501. */
+export declare function dayNumber(timestamp: number): number;
+/** Local calendar day as `'YYYY-MM-DD'`. */
+export declare function dayKey(timestamp: number): string;
+/** Timestamp of local midnight for a `'YYYY-MM-DD'` key. */
+export declare function dayKeyToTimestamp(key: string): number | null;
+/** Relative float comparison so that computed values like 0.1 + 0.2 equal 0.3. */
+export declare function numbersEqual(a: number, b: number): boolean;
+/** Cached, case-insensitive, number-aware collator ("item 2" < "item 10"). */
+export declare function getCollator(locale: string | undefined): Intl.Collator;

package/lib/core/virtual-math.d.ts

@@ -0,0 +1,57 @@
+/**
+ * Pure virtualization math. Row heights are fixed, so every position is O(1);
+ * column positions use prefix sums and binary search.
+ */
+/**
+ * Browsers cap element height (Chrome ~33.5M px, Firefox ~17.9M px). Above this height the
+ * rows canvas stays at this size and scroll positions are scaled to the real row positions.
+ */
+export declare const MAX_CANVAS_HEIGHT = 15000000;
+export interface VerticalMetrics {
+    /** Height of all rows (rowCount × rowHeight). */
+    totalHeight: number;
+    /** Height of the scrollable rows canvas (≤ MAX_CANVAS_HEIGHT). */
+    canvasHeight: number;
+    /** totalHeight / canvasHeight scroll ratio, 1 when no scaling is needed. */
+    scale: number;
+    /** Scroll position in real row coordinates. */
+    virtualTop: number;
+    /** Subtract from `rowIndex × rowHeight` to get the row's position inside the canvas. */
+    offset: number;
+}
+export declare function computeVerticalMetrics(scrollTop: number, viewportHeight: number, rowCount: number, rowHeight: number, maxCanvasHeight?: number): VerticalMetrics;
+export interface IndexRange {
+    /** First rendered index (inclusive). */
+    start: number;
+    /** Last rendered index (exclusive). */
+    end: number;
+    /** First index inside the viewport (inclusive). */
+    visibleStart: number;
+    /** Last index inside the viewport (exclusive). */
+    visibleEnd: number;
+}
+export declare function computeRowRange(metrics: VerticalMetrics, viewportHeight: number, rowCount: number, rowHeight: number, buffer: number, virtualize: boolean): IndexRange;
+/** Pool size needed to cover the viewport plus buffers; rendered rows reuse these slots. */
+export declare function rowPoolSize(viewportHeight: number, rowHeight: number, buffer: number): number;
+export interface ColumnOffsets {
+    offsets: number[];
+    total: number;
+}
+export declare function computeColumnOffsets(widths: readonly number[]): ColumnOffsets;
+/** Index of the column containing x (the last column whose left edge is ≤ x). */
+export declare function columnIndexAt(offsets: readonly number[], x: number): number;
+export declare function computeColumnRange(scrollLeft: number, viewportWidth: number, offsets: readonly number[], buffer: number, virtualize: boolean): IndexRange;
+/**
+ * Largest column window any horizontal scroll position can render (visible columns + buffers),
+ * and the largest number of flagged columns (e.g. columns with templates) in such a window.
+ * Used to size the cell pools once, so they never grow (and create views) while scrolling.
+ */
+export declare function maxColumnWindow(offsets: readonly number[], totalWidth: number, viewportWidth: number, buffer: number, flags: readonly (readonly boolean[])[]): {
+    columns: number;
+    flagged: number[];
+};
+export type ScrollAlign = 'auto' | 'start' | 'center' | 'end';
+/** Target position (in real coordinates) that brings [itemStart, itemStart + itemSize) into view. */
+export declare function alignedScrollTarget(itemStart: number, itemSize: number, viewportSize: number, current: number, contentSize: number, align: ScrollAlign): number;
+/** Converts a real row position to the element's scrollTop (undoes scroll scaling). */
+export declare function virtualToScrollTop(virtualTop: number, metrics: VerticalMetrics): number;

package/lib/directives/grid-template-component.d.ts

@@ -0,0 +1,16 @@
+import * as i0 from "@angular/core";
+/**
+ * Base class for components used as grid templates (cell, edit, header, summary, loading, empty, error).
+ * It declares the `context` input the grid sets.
+ *
+ * ```ts
+ * @Component({ template: `<b>{{ context().value }}</b>` })
+ * export class PriceCell extends GridTemplateComponent<GridCellContext<Order, number>> {}
+ * ```
+ * Components that don't extend it can declare their own `context` input instead.
+ */
+export declare abstract class GridTemplateComponent<C> {
+    readonly context: import("@angular/core").InputSignal<C>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<GridTemplateComponent<any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<GridTemplateComponent<any>, never, never, { "context": { "alias": "context"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}

package/lib/directives/outlet.directive.d.ts

@@ -0,0 +1,25 @@
+import { OnChanges, OnDestroy } from '@angular/core';
+import type { GridTemplate } from '../models/template.types';
+import * as i0 from "@angular/core";
+/**
+ * Renders a `TemplateRef` or a component with a context object.
+ *
+ * The view is created once and reused when rows are recycled during scrolling:
+ * for templates the new context is copied into the existing view context (no re-creation,
+ * no proxy); for components the `context` input is updated.
+ */
+export declare class GridOutletDirective<C extends object = any> implements OnChanges, OnDestroy {
+    template: GridTemplate<C> | null;
+    context: C | null;
+    private readonly vcr;
+    private viewRef;
+    private componentRef;
+    private rendered;
+    ngOnChanges(): void;
+    ngOnDestroy(): void;
+    private create;
+    private update;
+    private clear;
+    static ɵfac: i0.ɵɵFactoryDeclaration<GridOutletDirective<any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<GridOutletDirective<any>, "[infiGridOutlet]", never, { "template": { "alias": "infiGridOutlet"; "required": false; }; "context": { "alias": "infiGridOutletContext"; "required": false; }; }, {}, never, never, true, never>;
+}