@alaarab/ogrid-angular 2.0.2 → 2.0.4

package/dist/esm/utils/dataGridViewModel.js

@@ -0,0 +1,163 @@
+/**
+ * View model helpers for Angular DataGridTable. Core owns the logic; UI packages only render.
+ * Ported from React's dataGridViewModel.ts to eliminate duplication in Angular Material and PrimeNG packages.
+ */
+import { getCellValue, isInSelectionRange } from '@alaarab/ogrid-core';
+/**
+ * Returns ColumnHeaderFilter props from column def and grid filter/sort state.
+ * Use in Angular Material and PrimeNG DataGridTableComponent instead of inline logic.
+ */
+export function getHeaderFilterConfig(col, input) {
+    const filterable = col.filterable && typeof col.filterable === 'object' ? col.filterable : null;
+    const filterType = (filterable?.type ?? 'none');
+    const filterField = filterable?.filterField ?? col.columnId;
+    const sortable = col.sortable !== false;
+    const filterValue = input.filters[filterField];
+    const base = {
+        columnKey: col.columnId,
+        columnName: col.name,
+        filterType,
+        isSorted: input.sortBy === col.columnId,
+        isSortedDescending: input.sortBy === col.columnId && input.sortDirection === 'desc',
+        onSort: sortable ? () => input.onColumnSort(col.columnId) : undefined,
+    };
+    if (filterType === 'text') {
+        return {
+            ...base,
+            textValue: filterValue?.type === 'text' ? filterValue.value : '',
+            onTextChange: (v) => input.onFilterChange(filterField, v.trim() ? { type: 'text', value: v } : undefined),
+        };
+    }
+    if (filterType === 'people') {
+        return {
+            ...base,
+            selectedUser: filterValue?.type === 'people' ? filterValue.value : undefined,
+            onUserChange: (u) => input.onFilterChange(filterField, u ? { type: 'people', value: u } : undefined),
+            peopleSearch: input.peopleSearch,
+        };
+    }
+    if (filterType === 'multiSelect') {
+        return {
+            ...base,
+            options: input.filterOptions[filterField] ?? [],
+            isLoadingOptions: input.loadingFilterOptions[filterField] ?? false,
+            selectedValues: filterValue?.type === 'multiSelect' ? filterValue.value : [],
+            onFilterChange: (values) => input.onFilterChange(filterField, values.length ? { type: 'multiSelect', value: values } : undefined),
+        };
+    }
+    if (filterType === 'date') {
+        return {
+            ...base,
+            dateValue: filterValue?.type === 'date' ? filterValue.value : undefined,
+            onDateChange: (v) => input.onFilterChange(filterField, v ? { type: 'date', value: v } : undefined),
+        };
+    }
+    return base;
+}
+/**
+ * Returns a descriptor for rendering a cell. UI uses this to decide editing-inline vs editing-popover vs display
+ * and to apply isActive, isInRange, etc. without duplicating the boolean logic.
+ */
+export function getCellRenderDescriptor(item, col, rowIndex, colIdx, input) {
+    const rowId = input.getRowId(item);
+    const globalColIndex = colIdx + input.colOffset;
+    const colEditable = col.editable === true ||
+        (typeof col.editable === 'function' && col.editable(item));
+    const canEditInline = input.editable !== false &&
+        !!colEditable &&
+        !!input.onCellValueChanged &&
+        typeof col.cellEditor !== 'function';
+    const canEditPopup = input.editable !== false &&
+        !!colEditable &&
+        !!input.onCellValueChanged &&
+        typeof col.cellEditor === 'function';
+    const canEditAny = canEditInline || canEditPopup;
+    const isEditing = input.editingCell?.rowId === rowId &&
+        input.editingCell?.columnId === col.columnId;
+    const isActive = input.activeCell?.rowIndex === rowIndex &&
+        input.activeCell?.columnIndex === globalColIndex;
+    const isInRange = input.selectionRange != null &&
+        isInSelectionRange(input.selectionRange, rowIndex, colIdx);
+    const isInCutRange = input.cutRange != null &&
+        isInSelectionRange(input.cutRange, rowIndex, colIdx);
+    const isInCopyRange = input.copyRange != null &&
+        isInSelectionRange(input.copyRange, rowIndex, colIdx);
+    const isSelectionEndCell = !input.isDragging &&
+        input.copyRange == null &&
+        input.cutRange == null &&
+        input.selectionRange != null &&
+        rowIndex === input.selectionRange.endRow &&
+        colIdx === input.selectionRange.endCol;
+    let mode = 'display';
+    let editorType;
+    const value = getCellValue(item, col);
+    if (isEditing && canEditInline) {
+        mode = 'editing-inline';
+        if (col.cellEditor === 'text' ||
+            col.cellEditor === 'select' ||
+            col.cellEditor === 'checkbox' ||
+            col.cellEditor === 'richSelect' ||
+            col.cellEditor === 'date') {
+            editorType = col.cellEditor;
+        }
+        else if (col.type === 'date') {
+            editorType = 'date';
+        }
+        else if (col.type === 'boolean') {
+            editorType = 'checkbox';
+        }
+        else {
+            editorType = 'text';
+        }
+    }
+    else if (isEditing && canEditPopup) {
+        mode = 'editing-popover';
+    }
+    return {
+        mode,
+        editorType,
+        value,
+        isActive,
+        isInRange,
+        isInCutRange,
+        isInCopyRange,
+        isSelectionEndCell,
+        canEditAny,
+        globalColIndex,
+        rowId,
+        rowIndex,
+        displayValue: value,
+    };
+}
+// --- Cell rendering helpers (reduce DataGridTable view-layer duplication) ---
+/**
+ * Resolves display content for a cell in display mode.
+ * Handles the renderCell → valueFormatter → String() fallback chain.
+ */
+export function resolveCellDisplayContent(col, item, displayValue) {
+    if (col.renderCell && typeof col.renderCell === 'function') {
+        const result = col.renderCell(item);
+        return result != null ? String(result) : '';
+    }
+    if (col.valueFormatter)
+        return String(col.valueFormatter(displayValue, item) ?? '');
+    if (displayValue == null)
+        return '';
+    if (col.type === 'date') {
+        const d = new Date(String(displayValue));
+        if (!Number.isNaN(d.getTime()))
+            return d.toLocaleDateString();
+    }
+    if (col.type === 'boolean') {
+        return displayValue ? 'True' : 'False';
+    }
+    return String(displayValue);
+}
+/**
+ * Resolves the cellStyle from a column def, handling both function and static values.
+ */
+export function resolveCellStyle(col, item) {
+    if (!col.cellStyle)
+        return undefined;
+    return typeof col.cellStyle === 'function' ? col.cellStyle(item) : col.cellStyle;
+}

package/dist/esm/utils/debounce.js

@@ -0,0 +1,105 @@
+/**
+ * Debounce utilities for Angular using signals.
+ * Provides functional parity with React's useDebounce and useDebouncedCallback.
+ */
+import { signal, effect } from '@angular/core';
+/**
+ * Creates a debounced signal that updates after the specified delay when the source value changes.
+ *
+ * @param source - The signal to debounce
+ * @param delayMs - Delay in milliseconds
+ * @returns A signal containing the debounced value
+ *
+ * @example
+ * ```typescript
+ * const searchQuery = signal('');
+ * const debouncedQuery = createDebouncedSignal(searchQuery, 300);
+ *
+ * effect(() => {
+ *   console.log('Debounced search:', debouncedQuery());
+ * });
+ * ```
+ */
+export function createDebouncedSignal(source, delayMs) {
+    const debouncedValue = signal(source());
+    effect((onCleanup) => {
+        const currentValue = source();
+        const timeoutId = setTimeout(() => {
+            debouncedValue.set(currentValue);
+        }, delayMs);
+        onCleanup(() => clearTimeout(timeoutId));
+    });
+    return debouncedValue;
+}
+/**
+ * Creates a debounced function that delays invoking the provided function
+ * until after `delayMs` milliseconds have elapsed since the last time it was invoked.
+ *
+ * @param fn - The function to debounce
+ * @param delayMs - Delay in milliseconds
+ * @returns A debounced version of the function
+ *
+ * @example
+ * ```typescript
+ * const saveData = (value: string) => {
+ *   console.log('Saving:', value);
+ * };
+ *
+ * const debouncedSave = createDebouncedCallback(saveData, 500);
+ *
+ * // Multiple rapid calls will only trigger once after 500ms
+ * debouncedSave('hello');
+ * debouncedSave('world');  // Only this will execute after 500ms
+ * ```
+ */
+export function createDebouncedCallback(fn, delayMs) {
+    let timeoutId = null;
+    return ((...args) => {
+        if (timeoutId !== null) {
+            clearTimeout(timeoutId);
+        }
+        timeoutId = setTimeout(() => {
+            fn(...args);
+            timeoutId = null;
+        }, delayMs);
+    });
+}
+/**
+ * Simple debounce function (non-Angular-specific, can be used anywhere).
+ * Returns a debounced version of the provided function.
+ *
+ * @param fn - The function to debounce
+ * @param delayMs - Delay in milliseconds
+ * @returns A debounced version of the function with a `cancel()` method
+ *
+ * @example
+ * ```typescript
+ * const handleResize = debounce(() => {
+ *   console.log('Window resized');
+ * }, 200);
+ *
+ * window.addEventListener('resize', handleResize);
+ *
+ * // Later, cancel pending execution
+ * handleResize.cancel();
+ * ```
+ */
+export function debounce(fn, delayMs) {
+    let timeoutId = null;
+    const debounced = ((...args) => {
+        if (timeoutId !== null) {
+            clearTimeout(timeoutId);
+        }
+        timeoutId = setTimeout(() => {
+            fn(...args);
+            timeoutId = null;
+        }, delayMs);
+    });
+    debounced.cancel = () => {
+        if (timeoutId !== null) {
+            clearTimeout(timeoutId);
+            timeoutId = null;
+        }
+    };
+    return debounced;
+}

package/dist/esm/utils/index.js

@@ -0,0 +1,8 @@
+/**
+ * Shared utilities for Angular DataGridTable view layer.
+ */
+export { getHeaderFilterConfig, getCellRenderDescriptor, resolveCellDisplayContent, resolveCellStyle, } from './dataGridViewModel';
+// Debounce utilities
+export { createDebouncedSignal, createDebouncedCallback, debounce, } from './debounce';
+// Latest ref utilities
+export { createLatestRef, createLatestCallback, } from './latestRef';

package/dist/esm/utils/latestRef.js

@@ -0,0 +1,46 @@
+/**
+ * Latest ref utility for Angular using signals.
+ * Provides functional parity with React's useLatestRef.
+ */
+/**
+ * Creates a stable wrapper function that always calls the latest version of the provided function.
+ * Useful for event handlers and callbacks where you want a stable reference but need to call
+ * the latest implementation.
+ *
+ * @param fn - Signal containing the function to wrap
+ * @returns A stable function that always invokes the latest version
+ *
+ * @example
+ * ```typescript
+ * class MyService {
+ *   readonly onSave = signal<(value: string) => void>((val) => console.log('Default:', val));
+ *   readonly stableOnSave = createLatestCallback(this.onSave);
+ *
+ *   constructor() {
+ *     // Setup event listener with stable reference
+ *     effect((onCleanup) => {
+ *       // stableOnSave never changes, so this effect only runs once
+ *       const callback = () => this.stableOnSave('data');
+ *       window.addEventListener('click', callback);
+ *       onCleanup(() => window.removeEventListener('click', callback));
+ *     });
+ *   }
+ *
+ *   updateHandler(newFn: (value: string) => void) {
+ *     // Even though we change the function, the callback reference stays stable
+ *     this.onSave.set(newFn);
+ *   }
+ * }
+ * ```
+ */
+export function createLatestCallback(fn) {
+    // Return a stable function that always calls the current value of the signal
+    return ((...args) => {
+        return fn()(...args);
+    });
+}
+/**
+ * Alias for createLatestCallback for consistency with React/Vue naming.
+ * @deprecated Use createLatestCallback instead
+ */
+export const createLatestRef = createLatestCallback;

package/dist/types/components/marching-ants-overlay.component.d.ts

@@ -12,6 +12,7 @@ export declare class MarchingAntsOverlayComponent {
     readonly copyRange: import("@angular/core").InputSignal<ISelectionRange | null>;
     readonly cutRange: import("@angular/core").InputSignal<ISelectionRange | null>;
     readonly colOffset: import("@angular/core").InputSignal<number>;
+    readonly columnSizingVersion: import("@angular/core").InputSignal<number>;
     readonly selRect: import("@angular/core").WritableSignal<OverlayRect | null>;
     readonly clipRect: import("@angular/core").WritableSignal<OverlayRect | null>;
     private rafId;

package/dist/types/index.d.ts

@@ -7,6 +7,9 @@ export { OGridService } from './services/ogrid.service';
 export type { ColumnChooserPlacement, OGridPagination, OGridColumnChooser, OGridFilters, OGridSideBarState, } from './services/ogrid.service';
 export { DataGridStateService } from './services/datagrid-state.service';
 export type { DataGridLayoutState, DataGridRowSelectionState, DataGridEditingState, DataGridCellInteractionState, DataGridContextMenuState, DataGridViewModelState, DataGridStateResult, } from './services/datagrid-state.service';
+export { ColumnReorderService } from './services/column-reorder.service';
+export { VirtualScrollService } from './services/virtual-scroll.service';
+export type { IVirtualScrollConfig } from './services/virtual-scroll.service';
 export { OGridLayoutComponent } from './components/ogrid-layout.component';
 export { StatusBarComponent } from './components/status-bar.component';
 export { GridContextMenuComponent } from './components/grid-context-menu.component';
@@ -14,3 +17,5 @@ export { SideBarComponent } from './components/sidebar.component';
 export type { SideBarProps, SideBarFilterColumn } from './components/sidebar.component';
 export { MarchingAntsOverlayComponent } from './components/marching-ants-overlay.component';
 export { EmptyStateComponent } from './components/empty-state.component';
+export type { HeaderFilterConfigInput, HeaderFilterConfig, CellRenderDescriptorInput, CellRenderDescriptor, CellRenderMode, } from './utils';
+export { getHeaderFilterConfig, getCellRenderDescriptor, resolveCellDisplayContent, resolveCellStyle, createDebouncedSignal, createDebouncedCallback, debounce, createLatestRef, createLatestCallback, } from './utils';

package/dist/types/services/column-reorder.service.d.ts

@@ -0,0 +1,30 @@
+import type { IColumnDef } from '../types';
+/**
+ * Manages column reorder drag interactions with RAF-throttled updates.
+ * Angular signals-based port of React's useColumnReorder hook.
+ */
+export declare class ColumnReorderService<T> {
+    private destroyRef;
+    readonly columns: import("@angular/core").WritableSignal<IColumnDef<T>[]>;
+    readonly columnOrder: import("@angular/core").WritableSignal<string[] | undefined>;
+    readonly onColumnOrderChange: import("@angular/core").WritableSignal<((order: string[]) => void) | undefined>;
+    readonly enabled: import("@angular/core").WritableSignal<boolean>;
+    readonly wrapperEl: import("@angular/core").WritableSignal<HTMLElement | null>;
+    readonly isDragging: import("@angular/core").WritableSignal<boolean>;
+    readonly dropIndicatorX: import("@angular/core").WritableSignal<number | null>;
+    private rafId;
+    private cleanupFn;
+    private latestDropTargetIndex;
+    constructor();
+    /**
+     * Call this from the header cell's mousedown handler.
+     * @param columnId - The column being dragged
+     * @param event - The native MouseEvent
+     */
+    handleHeaderMouseDown(columnId: string, event: MouseEvent): void;
+    /**
+     * Calculate drop target from mouse position and header cell rects.
+     * Same logic as React's useColumnReorder inline calculation.
+     */
+    private calculateDrop;
+}

package/dist/types/services/datagrid-state.service.d.ts

@@ -9,6 +9,7 @@ export interface DataGridLayoutState<T> {
     totalColCount: number;
     colOffset: number;
     hasCheckboxCol: boolean;
+    hasRowNumbersCol: boolean;
     rowIndexByRowId: Map<RowId, number>;
     containerWidth: number;
     minTableWidth: number;
@@ -159,7 +160,6 @@ export declare class DataGridStateService<T> {
     private rafId;
     private lastMousePos;
     private autoScrollInterval;
-    private windowCleanups;
     private resizeObserver;
     private readonly propsResolved;
     readonly cellSelection: import("@angular/core").Signal<boolean>;
@@ -169,8 +169,10 @@ export declare class DataGridStateService<T> {
     readonly visibleCols: import("@angular/core").Signal<IColumnDef<T>[]>;
     readonly visibleColumnCount: import("@angular/core").Signal<number>;
     readonly hasCheckboxCol: import("@angular/core").Signal<boolean>;
+    readonly hasRowNumbersCol: import("@angular/core").Signal<boolean>;
+    readonly specialColsCount: import("@angular/core").Signal<number>;
     readonly totalColCount: import("@angular/core").Signal<number>;
-    readonly colOffset: import("@angular/core").Signal<0 | 1>;
+    readonly colOffset: import("@angular/core").Signal<number>;
     readonly rowIndexByRowId: import("@angular/core").Signal<Map<RowId, number>>;
     readonly selectedRowIds: import("@angular/core").Signal<Set<RowId>>;
     readonly allSelected: import("@angular/core").Signal<boolean>;

package/dist/types/services/ogrid.service.d.ts

@@ -105,10 +105,10 @@ export declare class OGridService<T> {
     private readonly internalData;
     private readonly internalLoading;
     private readonly internalPage;
-    private readonly internalPageSize;
-    private readonly internalSort;
+    private readonly internalPageSizeOverride;
+    private readonly internalSortOverride;
     private readonly internalFilters;
-    private readonly internalVisibleColumns;
+    private readonly internalVisibleColumnsOverride;
     private readonly internalSelectedRows;
     private readonly columnWidthOverrides;
     private readonly pinnedOverrides;
@@ -121,9 +121,6 @@ export declare class OGridService<T> {
     private readonly sideBarActivePanel;
     private readonly serverFilterOptions;
     private readonly loadingFilterOptions;
-    private sortInitialized;
-    private visibleColumnsInitialized;
-    private pageSizeInitialized;
     readonly columns: import("@angular/core").Signal<IColumnDef<T>[]>;
     readonly isServerSide: import("@angular/core").Signal<boolean>;
     readonly isClientSide: import("@angular/core").Signal<boolean>;
@@ -187,5 +184,31 @@ export declare class OGridService<T> {
     handleColumnResized(columnId: string, width: number): void;
     handleColumnPinned(columnId: string, pinned: 'left' | 'right' | null): void;
     configure(props: IOGridProps<T>): void;
+    /**
+     * Pin a column to the left or right edge.
+     */
+    pinColumn(columnId: string, side: 'left' | 'right'): void;
+    /**
+     * Unpin a column (remove sticky positioning).
+     */
+    unpinColumn(columnId: string): void;
+    /**
+     * Check if a column is pinned and which side.
+     */
+    isPinned(columnId: string): 'left' | 'right' | undefined;
+    /**
+     * Compute sticky left offsets for left-pinned columns.
+     * Returns a map of columnId -> left offset in pixels.
+     */
+    computeLeftOffsets(visibleCols: {
+        columnId: string;
+    }[], columnWidths: Record<string, number>, defaultWidth: number, hasCheckboxColumn: boolean, checkboxColumnWidth: number): Record<string, number>;
+    /**
+     * Compute sticky right offsets for right-pinned columns.
+     * Returns a map of columnId -> right offset in pixels.
+     */
+    computeRightOffsets(visibleCols: {
+        columnId: string;
+    }[], columnWidths: Record<string, number>, defaultWidth: number): Record<string, number>;
     getApi(): IOGridApi<T>;
 }

package/dist/types/services/virtual-scroll.service.d.ts

@@ -0,0 +1,54 @@
+import type { IVisibleRange } from '@alaarab/ogrid-core';
+export interface IVirtualScrollConfig {
+    /** Enable virtual scrolling. Default: true when provided. */
+    enabled?: boolean;
+    /** Row height in pixels (required for virtualization). */
+    rowHeight: number;
+    /** Number of rows to render outside the visible area. Default: 5. */
+    overscan?: number;
+}
+/**
+ * Manages virtual scrolling state using Angular signals.
+ * Port of React's useVirtualScroll hook.
+ *
+ * Uses core's pure-TS `computeVisibleRange` and `getScrollTopForRow` utilities.
+ * The UI layer (Angular Material / PrimeNG) provides the scrollable container
+ * and calls `onScroll()` / sets `containerHeight`.
+ */
+export declare class VirtualScrollService {
+    private destroyRef;
+    readonly totalRows: import("@angular/core").WritableSignal<number>;
+    readonly config: import("@angular/core").WritableSignal<IVirtualScrollConfig>;
+    readonly containerHeight: import("@angular/core").WritableSignal<number>;
+    readonly scrollTop: import("@angular/core").WritableSignal<number>;
+    private containerEl;
+    readonly rowHeight: import("@angular/core").Signal<number>;
+    readonly overscan: import("@angular/core").Signal<number>;
+    readonly enabled: import("@angular/core").Signal<boolean>;
+    /** Whether virtual scrolling is actually active (enabled + enough rows). */
+    readonly isActive: import("@angular/core").Signal<boolean>;
+    /** The visible range of rows with spacer offsets. */
+    readonly visibleRange: import("@angular/core").Signal<IVisibleRange>;
+    /** Total scrollable height in pixels. */
+    readonly totalHeight: import("@angular/core").Signal<number>;
+    constructor();
+    /**
+     * Set the scrollable container element.
+     * Used for programmatic scrolling (scrollToRow).
+     */
+    setContainer(el: HTMLElement | null): void;
+    /**
+     * Call this from the container's scroll event handler.
+     */
+    onScroll(event: Event): void;
+    /**
+     * Scroll to a specific row index.
+     * @param index - The row index to scroll to.
+     * @param align - Where to position the row: 'start' (top), 'center', or 'end' (bottom). Default: 'start'.
+     */
+    scrollToRow(index: number, align?: 'start' | 'center' | 'end'): void;
+    /**
+     * Update the virtual scroll configuration.
+     */
+    updateConfig(updates: Partial<IVirtualScrollConfig>): void;
+}

package/dist/types/types/dataGridTypes.d.ts

@@ -107,6 +107,9 @@ export interface IOGridDataGridProps<T> {
     rowSelection?: RowSelectionMode;
     selectedRows?: Set<RowId>;
     onSelectionChange?: (event: IRowSelectionChangeEvent<T>) => void;
+    showRowNumbers?: boolean;
+    currentPage?: number;
+    pageSize?: number;
     statusBar?: IStatusBarProps;
     filters: IFilters;
     onFilterChange: (key: string, value: FilterValue | undefined) => void;

package/dist/types/utils/dataGridViewModel.d.ts

@@ -0,0 +1,107 @@
+/**
+ * View model helpers for Angular DataGridTable. Core owns the logic; UI packages only render.
+ * Ported from React's dataGridViewModel.ts to eliminate duplication in Angular Material and PrimeNG packages.
+ */
+import type { ColumnFilterType, IDateFilterValue } from '../types/columnTypes';
+import type { IColumnDef } from '../types/columnTypes';
+import type { RowId, UserLike, IFilters, FilterValue } from '../types/dataGridTypes';
+export interface HeaderFilterConfigInput {
+    sortBy?: string;
+    sortDirection: 'asc' | 'desc';
+    onColumnSort: (columnKey: string) => void;
+    filters: IFilters;
+    onFilterChange: (key: string, value: FilterValue | undefined) => void;
+    filterOptions: Record<string, string[]>;
+    loadingFilterOptions: Record<string, boolean>;
+    peopleSearch?: (query: string) => Promise<UserLike[]>;
+}
+/** Props to pass to ColumnHeaderFilter. */
+export interface HeaderFilterConfig {
+    columnKey: string;
+    columnName: string;
+    filterType: ColumnFilterType;
+    isSorted?: boolean;
+    isSortedDescending?: boolean;
+    onSort?: () => void;
+    selectedValues?: string[];
+    onFilterChange?: (values: string[]) => void;
+    options?: string[];
+    isLoadingOptions?: boolean;
+    textValue?: string;
+    onTextChange?: (value: string) => void;
+    selectedUser?: UserLike;
+    onUserChange?: (user: UserLike | undefined) => void;
+    peopleSearch?: (query: string) => Promise<UserLike[]>;
+    dateValue?: IDateFilterValue;
+    onDateChange?: (value: IDateFilterValue | undefined) => void;
+}
+/**
+ * Returns ColumnHeaderFilter props from column def and grid filter/sort state.
+ * Use in Angular Material and PrimeNG DataGridTableComponent instead of inline logic.
+ */
+export declare function getHeaderFilterConfig<T>(col: IColumnDef<T>, input: HeaderFilterConfigInput): HeaderFilterConfig;
+export type CellRenderMode = 'editing-inline' | 'editing-popover' | 'display';
+export interface CellRenderDescriptorInput<T> {
+    editingCell: {
+        rowId: RowId;
+        columnId: string;
+    } | null;
+    activeCell: {
+        rowIndex: number;
+        columnIndex: number;
+    } | null;
+    selectionRange: {
+        startRow: number;
+        startCol: number;
+        endRow: number;
+        endCol: number;
+    } | null;
+    cutRange: {
+        startRow: number;
+        startCol: number;
+        endRow: number;
+        endCol: number;
+    } | null;
+    copyRange: {
+        startRow: number;
+        startCol: number;
+        endRow: number;
+        endCol: number;
+    } | null;
+    colOffset: number;
+    getRowId: (item: T) => RowId;
+    editable?: boolean;
+    onCellValueChanged?: unknown;
+    /** True while user is drag-selecting cells — hides fill handle during drag. */
+    isDragging?: boolean;
+}
+export interface CellRenderDescriptor {
+    mode: CellRenderMode;
+    editorType?: 'text' | 'select' | 'checkbox' | 'richSelect' | 'date';
+    value?: unknown;
+    isActive: boolean;
+    isInRange: boolean;
+    isInCutRange: boolean;
+    isInCopyRange: boolean;
+    isSelectionEndCell: boolean;
+    canEditAny: boolean;
+    globalColIndex: number;
+    rowId: RowId;
+    rowIndex: number;
+    /** Raw value for display (when mode === 'display'). */
+    displayValue?: unknown;
+}
+/**
+ * Returns a descriptor for rendering a cell. UI uses this to decide editing-inline vs editing-popover vs display
+ * and to apply isActive, isInRange, etc. without duplicating the boolean logic.
+ */
+export declare function getCellRenderDescriptor<T>(item: T, col: IColumnDef<T>, rowIndex: number, colIdx: number, input: CellRenderDescriptorInput<T>): CellRenderDescriptor;
+/**
+ * Resolves display content for a cell in display mode.
+ * Handles the renderCell → valueFormatter → String() fallback chain.
+ */
+export declare function resolveCellDisplayContent<T>(col: IColumnDef<T>, item: T, displayValue: unknown): string;
+/**
+ * Resolves the cellStyle from a column def, handling both function and static values.
+ */
+export declare function resolveCellStyle<T>(col: IColumnDef<T>, item: T): Record<string, string> | undefined;