@simple-table/react 3.0.0-beta.8

package/dist/core/src/utils/filters/createCustomSelect.d.ts

@@ -0,0 +1,20 @@
+export interface CustomSelectOption {
+    value: string;
+    label: string;
+}
+export interface CreateCustomSelectOptions {
+    value: string;
+    onChange: (value: string) => void;
+    options: CustomSelectOption[];
+    placeholder?: string;
+    className?: string;
+    disabled?: boolean;
+    containerRef?: HTMLElement;
+    mainBodyRef?: HTMLElement;
+}
+export declare const createCustomSelect: (options: CreateCustomSelectOptions) => {
+    element: HTMLDivElement;
+    update: (newOptions: Partial<CreateCustomSelectOptions>) => void;
+    destroy: () => void;
+    setOpen: (newOpen: boolean) => void;
+};

package/dist/core/src/utils/filters/createDateFilter.d.ts

@@ -0,0 +1,15 @@
+import HeaderObject from "../../types/HeaderObject";
+import { FilterCondition } from "../../types/FilterTypes";
+export interface CreateDateFilterOptions {
+    header: HeaderObject;
+    currentFilter?: FilterCondition;
+    onApplyFilter: (filter: FilterCondition) => void;
+    onClearFilter: () => void;
+    containerRef?: HTMLElement;
+    mainBodyRef?: HTMLElement;
+}
+export declare const createDateFilter: (options: CreateDateFilterOptions) => {
+    element: HTMLDivElement;
+    update: (newOptions: Partial<CreateDateFilterOptions>) => void;
+    destroy: () => void;
+};

package/dist/core/src/utils/filters/createDatePicker.d.ts

@@ -0,0 +1,10 @@
+export interface CreateDatePickerOptions {
+    onChange: (date: Date) => void;
+    onClose?: () => void;
+    value: Date;
+}
+export declare const createDatePicker: (options: CreateDatePickerOptions) => {
+    element: HTMLDivElement;
+    update: (newOptions: Partial<CreateDatePickerOptions>) => void;
+    destroy: () => void;
+};

package/dist/core/src/utils/filters/createDropdown.d.ts

@@ -0,0 +1,16 @@
+export interface CreateDropdownOptions {
+    children: HTMLElement;
+    containerRef?: HTMLElement;
+    mainBodyRef?: HTMLElement;
+    onClose: () => void;
+    open: boolean;
+    overflow?: "auto" | "visible" | "hidden";
+    width?: number;
+    positioning?: "fixed" | "absolute";
+}
+export declare const createDropdown: (options: CreateDropdownOptions) => {
+    element: HTMLDivElement;
+    update: (newOptions: Partial<CreateDropdownOptions>) => void;
+    destroy: () => void;
+    setOpen: (newOpen: boolean) => void;
+};

package/dist/core/src/utils/filters/createEnumFilter.d.ts

@@ -0,0 +1,15 @@
+import HeaderObject from "../../types/HeaderObject";
+import { FilterCondition } from "../../types/FilterTypes";
+export interface CreateEnumFilterOptions {
+    header: HeaderObject;
+    currentFilter?: FilterCondition;
+    onApplyFilter: (filter: FilterCondition) => void;
+    onClearFilter: () => void;
+    containerRef?: HTMLElement;
+    mainBodyRef?: HTMLElement;
+}
+export declare const createEnumFilter: (options: CreateEnumFilterOptions) => {
+    element: HTMLDivElement;
+    update: (newOptions: Partial<CreateEnumFilterOptions>) => void;
+    destroy: () => void;
+};

package/dist/core/src/utils/filters/createFilterActions.d.ts

@@ -0,0 +1,11 @@
+export interface CreateFilterActionsOptions {
+    onApply: () => void;
+    onClear?: () => void;
+    canApply: boolean;
+    showClear: boolean;
+}
+export declare const createFilterActions: (options: CreateFilterActionsOptions) => {
+    element: HTMLDivElement;
+    update: (newOptions: Partial<CreateFilterActionsOptions>) => void;
+    destroy: () => void;
+};

package/dist/core/src/utils/filters/createFilterDropdown.d.ts

@@ -0,0 +1,15 @@
+import HeaderObject from "../../types/HeaderObject";
+import { FilterCondition } from "../../types/FilterTypes";
+export interface CreateFilterDropdownOptions {
+    header: HeaderObject;
+    currentFilter?: FilterCondition;
+    onApplyFilter: (filter: FilterCondition) => void;
+    onClearFilter: () => void;
+    containerRef?: HTMLElement;
+    mainBodyRef?: HTMLElement;
+}
+export declare const createFilterDropdown: (options: CreateFilterDropdownOptions) => {
+    element: HTMLDivElement;
+    update: (newOptions: Partial<import("./createStringFilter").CreateStringFilterOptions>) => void;
+    destroy: () => void;
+};

package/dist/core/src/utils/filters/createFilterInput.d.ts

@@ -0,0 +1,16 @@
+export interface CreateFilterInputOptions {
+    type?: "text" | "number" | "date";
+    value: string;
+    onChange: (value: string) => void;
+    onEnter?: () => void;
+    placeholder?: string;
+    autoFocus?: boolean;
+    min?: string;
+    max?: string;
+    step?: string;
+}
+export declare const createFilterInput: (options: CreateFilterInputOptions) => {
+    element: HTMLInputElement;
+    update: (newOptions: Partial<CreateFilterInputOptions>) => void;
+    destroy: () => void;
+};

package/dist/core/src/utils/filters/createNumberFilter.d.ts

@@ -0,0 +1,15 @@
+import HeaderObject from "../../types/HeaderObject";
+import { FilterCondition } from "../../types/FilterTypes";
+export interface CreateNumberFilterOptions {
+    header: HeaderObject;
+    currentFilter?: FilterCondition;
+    onApplyFilter: (filter: FilterCondition) => void;
+    onClearFilter: () => void;
+    containerRef?: HTMLElement;
+    mainBodyRef?: HTMLElement;
+}
+export declare const createNumberFilter: (options: CreateNumberFilterOptions) => {
+    element: HTMLDivElement;
+    update: (newOptions: Partial<CreateNumberFilterOptions>) => void;
+    destroy: () => void;
+};

package/dist/core/src/utils/filters/createStringFilter.d.ts

@@ -0,0 +1,15 @@
+import HeaderObject from "../../types/HeaderObject";
+import { FilterCondition } from "../../types/FilterTypes";
+export interface CreateStringFilterOptions {
+    header: HeaderObject;
+    currentFilter?: FilterCondition;
+    onApplyFilter: (filter: FilterCondition) => void;
+    onClearFilter: () => void;
+    containerRef?: HTMLElement;
+    mainBodyRef?: HTMLElement;
+}
+export declare const createStringFilter: (options: CreateStringFilterOptions) => {
+    element: HTMLDivElement;
+    update: (newOptions: Partial<CreateStringFilterOptions>) => void;
+    destroy: () => void;
+};

package/dist/core/src/utils/footer/createTableFooter.d.ts

@@ -0,0 +1,21 @@
+import OnNextPage from "../../types/OnNextPage";
+export interface CreateTableFooterOptions {
+    currentPage: number;
+    hideFooter?: boolean;
+    onPageChange: (page: number) => void;
+    onNextPage?: OnNextPage;
+    onUserPageChange?: (page: number) => void | Promise<void>;
+    rowsPerPage: number;
+    shouldPaginate?: boolean;
+    totalPages: number;
+    totalRows: number;
+    /** Custom icon for previous page button (string = HTML, HTMLElement = node to clone/append). */
+    prevIcon?: string | HTMLElement | SVGSVGElement;
+    /** Custom icon for next page button. */
+    nextIcon?: string | HTMLElement | SVGSVGElement;
+}
+export declare const createTableFooter: (options: CreateTableFooterOptions) => {
+    element: HTMLDivElement;
+    update: (newOptions: Partial<CreateTableFooterOptions>) => void;
+    destroy: () => void;
+};

package/dist/core/src/utils/formatters.d.ts

@@ -0,0 +1,3 @@
+export declare const formatDate: (dateString: string | number | Date) => string;
+export declare const formatCurrency: (value: number) => string;
+export declare const formatLargeNumber: (value: number) => string;

package/dist/core/src/utils/generalUtils.d.ts

@@ -0,0 +1,4 @@
+import HeaderObject from "../types/HeaderObject";
+import { Pinned } from "../types/Pinned";
+export declare const deepClone: <T>(obj: T) => T;
+export declare const canDisplaySection: (headers: HeaderObject[], pinned?: Pinned) => boolean;

package/dist/core/src/utils/headerCell/collapsing.d.ts

@@ -0,0 +1,6 @@
+import HeaderObject from "../../types/HeaderObject";
+import { HeaderRenderContext } from "./types";
+/** Use same icon and animation as body row expand/collapse (icons.expand + st-expand-icon-container). */
+export declare const createCollapseIcon: (header: HeaderObject, context: HeaderRenderContext) => HTMLElement | null;
+/** Update header collapse icon direction on an existing cell (same pattern as body updateExpandIconState). */
+export declare const updateHeaderCollapseIconState: (cellElement: HTMLElement, isCollapsed: boolean, label?: string) => void;

package/dist/core/src/utils/headerCell/dragging.d.ts

@@ -0,0 +1,5 @@
+import HeaderObject from "../../types/HeaderObject";
+import { HeaderRenderContext } from "./types";
+export declare const handleColumnHeaderClick: (event: MouseEvent, header: HeaderObject, colIndex: number, context: HeaderRenderContext) => void;
+export declare const handleColumnHeaderDoubleClick: (event: MouseEvent, header: HeaderObject, context: HeaderRenderContext) => void;
+export declare const attachDragHandlers: (labelElement: HTMLElement, cellElement: HTMLElement, header: HeaderObject, context: HeaderRenderContext) => void;

package/dist/core/src/utils/headerCell/editing.d.ts

@@ -0,0 +1,4 @@
+import HeaderObject from "../../types/HeaderObject";
+import { HeaderRenderContext } from "./types";
+export declare const createEditableInput: (header: HeaderObject, context: HeaderRenderContext, labelContainer: HTMLElement) => HTMLInputElement;
+export declare const createLabelContent: (header: HeaderObject, context: HeaderRenderContext, labelOverride?: string) => HTMLElement;

package/dist/core/src/utils/headerCell/eventTracking.d.ts

@@ -0,0 +1,25 @@
+import HeaderObject from "../../types/HeaderObject";
+export declare let prevUpdateTime: number;
+export declare let prevDraggingPosition: {
+    screenX: number;
+    screenY: number;
+};
+export declare let prevHeaders: HeaderObject[] | null;
+export declare const setPrevUpdateTime: (time: number) => void;
+export declare const setPrevDraggingPosition: (position: {
+    screenX: number;
+    screenY: number;
+}) => void;
+export declare const setPrevHeaders: (headers: HeaderObject[] | null) => void;
+export declare const getRenderedCells: (container: HTMLElement) => Map<string, HTMLElement>;
+export interface CachedHeaderPosition {
+    left: number;
+    top: number;
+    width: number;
+    height: number;
+}
+export declare const getHeaderPositionCache: (container: HTMLElement) => Map<string, CachedHeaderPosition>;
+export declare const REVERT_TO_PREVIOUS_HEADERS_DELAY = 1500;
+export declare const throttle: (callback: () => void, limit: number) => void;
+export declare const addTrackedEventListener: (element: HTMLElement, event: string, handler: EventListener, options?: AddEventListenerOptions) => void;
+export declare const cleanupHeaderCellRendering: (container?: HTMLElement) => void;

package/dist/core/src/utils/headerCell/filtering.d.ts

@@ -0,0 +1,3 @@
+import HeaderObject from "../../types/HeaderObject";
+import { HeaderRenderContext } from "./types";
+export declare const createFilterIcon: (header: HeaderObject, context: HeaderRenderContext) => HTMLElement | null;

package/dist/core/src/utils/headerCell/resizing.d.ts

@@ -0,0 +1,3 @@
+import HeaderObject from "../../types/HeaderObject";
+import { HeaderRenderContext } from "./types";
+export declare const createResizeHandle: (header: HeaderObject, context: HeaderRenderContext, isLastHeader: boolean) => HTMLElement | null;

package/dist/core/src/utils/headerCell/selection.d.ts

@@ -0,0 +1,10 @@
+import { HeaderRenderContext } from "./types";
+/**
+ * Updates an existing header select-all checkbox to match the current checked state.
+ * Use when selection changes but the header cell DOM is reused (e.g. from cache).
+ */
+export declare const updateHeaderSelectionCheckbox: (cellElement: HTMLElement, checked: boolean) => void;
+/**
+ * Creates the header select-all checkbox using the shared createCheckbox (same as column editor popout).
+ */
+export declare const createSelectionCheckbox: (context: HeaderRenderContext) => HTMLElement;

package/dist/core/src/utils/headerCell/sorting.d.ts

@@ -0,0 +1,3 @@
+import HeaderObject from "../../types/HeaderObject";
+import { HeaderRenderContext } from "./types";
+export declare const createSortIcon: (header: HeaderObject, context: HeaderRenderContext) => HTMLElement | null;

package/dist/core/src/utils/headerCell/styling.d.ts

@@ -0,0 +1,5 @@
+import { AbsoluteCell, HeaderRenderContext } from "./types";
+export declare const calculateHeaderCellClasses: (cell: AbsoluteCell, context: HeaderRenderContext, isLastHeader: boolean) => string;
+export declare const createHeaderCellElement: (cell: AbsoluteCell, context: HeaderRenderContext, isLastHeader: boolean) => HTMLElement;
+export declare const getLastHeaderIndex: (absoluteCells: AbsoluteCell[]) => number;
+export declare const updateHeaderCellElement: (cellElement: HTMLElement, cell: AbsoluteCell, context: HeaderRenderContext, isLastHeader: boolean) => void;

package/dist/core/src/utils/headerCell/types.d.ts

@@ -0,0 +1,75 @@
+import HeaderObject, { Accessor } from "../../types/HeaderObject";
+import SortColumn from "../../types/SortColumn";
+import { TableFilterState, FilterCondition } from "../../types/FilterTypes";
+import { IconsConfig } from "../../types/IconsConfig";
+import Row from "../../types/Row";
+type SetStateAction<T> = T | ((prevState: T) => T);
+type Dispatch<A> = (value: A) => void;
+type MutableRefObject<T> = {
+    current: T;
+};
+type RefObject<T> = {
+    readonly current: T | null;
+};
+export interface AbsoluteCell {
+    header: HeaderObject;
+    left: number;
+    top: number;
+    width: number;
+    height: number;
+    colIndex: number;
+    parentHeader?: HeaderObject;
+}
+export interface HeaderRenderContext {
+    areAllRowsSelected?: () => boolean;
+    autoExpandColumns: boolean;
+    collapsedHeaders: Set<Accessor>;
+    essentialAccessors?: ReadonlySet<string>;
+    columnBorders: boolean;
+    columnReordering: boolean;
+    columnResizing: boolean;
+    columnsWithSelectedCells: Set<number>;
+    containerWidth: number;
+    draggedHeaderRef: MutableRefObject<HeaderObject | null>;
+    enableHeaderEditing?: boolean;
+    enableRowSelection?: boolean;
+    filters: TableFilterState;
+    forceUpdate: () => void;
+    getCollapsedHeaders?: () => Set<Accessor>; /** Get current collapsed headers (avoids stale closure in toggle handler). */
+    handleApplyFilter: (filter: FilterCondition) => void;
+    handleClearFilter: (accessor: Accessor) => void;
+    handleSelectAll?: (checked: boolean) => void;
+    headerHeight: number;
+    headerRegistry?: Map<string, {
+        setEditing: (editing: boolean) => void;
+    }>;
+    headers: HeaderObject[];
+    hoveredHeaderRef: MutableRefObject<HeaderObject | null>;
+    icons: IconsConfig;
+    lastHeaderIndex: number;
+    mainBodyRef: RefObject<HTMLDivElement>;
+    mainSectionContainerWidth?: number; /** Main section viewport width (avoids clientWidth read when set); use for getVisibleCells when !pinned */
+    onColumnOrderChange?: (headers: HeaderObject[]) => void;
+    onColumnSelect?: (header: HeaderObject) => void;
+    onColumnWidthChange?: (headers: HeaderObject[]) => void;
+    onHeaderEdit?: (header: HeaderObject, newLabel: string) => void;
+    onSort: (accessor: Accessor) => void;
+    onTableHeaderDragEnd: (headers: HeaderObject[]) => void;
+    pinned?: "left" | "right";
+    pinnedLeftRef: RefObject<HTMLDivElement>;
+    pinnedRightRef: RefObject<HTMLDivElement>;
+    reverse: boolean;
+    rows: Row[];
+    selectColumns?: (columnIndices: number[]) => void;
+    selectableColumns?: boolean;
+    selectedColumns: Set<number>;
+    selectedRowCount?: number; /** Used for context cache invalidation when row selection changes */
+    setCollapsedHeaders: Dispatch<SetStateAction<Set<Accessor>>>;
+    setHeaders: Dispatch<SetStateAction<HeaderObject[]>>;
+    setInitialFocusedCell: (cell: any) => void;
+    setIsResizing: Dispatch<SetStateAction<boolean>>;
+    setSelectedCells: Dispatch<SetStateAction<Set<string>>>;
+    setSelectedColumns: Dispatch<SetStateAction<Set<number>>>;
+    sort: SortColumn | null;
+}
+export {};

package/dist/core/src/utils/headerCellRenderer.d.ts

@@ -0,0 +1,4 @@
+import { AbsoluteCell, HeaderRenderContext } from "./headerCell/types";
+export type { AbsoluteCell, HeaderRenderContext } from "./headerCell/types";
+export { cleanupHeaderCellRendering } from "./headerCell/eventTracking";
+export declare const renderHeaderCells: (container: HTMLElement, absoluteCells: AbsoluteCell[], context: HeaderRenderContext, scrollLeft?: number) => void;

package/dist/core/src/utils/headerUtils.d.ts

@@ -0,0 +1,41 @@
+import HeaderObject from "../types/HeaderObject";
+/**
+ * Gets all leaf column indices (bottom-level columns) for a given header and its descendants
+ * @param header The header to get indices for
+ * @param colIndex The column index of the header in the current context
+ * @returns Array of column indices that belong to this header branch
+ */
+export declare const getHeaderLeafIndices: (header: HeaderObject, colIndex: number) => number[];
+/**
+ * Flattens a nested header structure to get all leaf headers
+ * @param headers The headers array to flatten
+ * @returns Flattened array of all leaf headers
+ */
+export declare const flattenHeaders: (headers: HeaderObject[]) => HeaderObject[];
+/**
+ * Flattens a nested header structure to get all headers (including parent headers)
+ * @param headers The headers array to flatten
+ * @returns Flattened array of all headers in the hierarchy
+ */
+export declare const flattenAllHeaders: (headers: HeaderObject[]) => HeaderObject[];
+/**
+ * Gets the range of column indices between two column indices
+ * @param startColIndex Starting column index
+ * @param endColIndex Ending column index
+ * @returns Array of column indices in the range (inclusive)
+ */
+export declare const getColumnRange: (startColIndex: number, endColIndex: number) => number[];
+export declare const calculatePinnedWidth: (width?: number) => number;
+/**
+ * Generates a unique ID for header description element
+ * @param accessor The header accessor
+ * @returns Unique ID string for aria-describedby
+ */
+export declare const getHeaderDescriptionId: (accessor: string | number) => string;
+/**
+ * Builds a descriptive string for screen readers about a column header
+ * @param header The header object
+ * @param filterable Whether the column is filterable
+ * @returns Description string for aria-describedby, or empty string if no description
+ */
+export declare const getHeaderDescription: (header: HeaderObject, filterable: boolean) => string;

package/dist/core/src/utils/headerWidthUtils.d.ts

@@ -0,0 +1,56 @@
+import HeaderObject, { Accessor } from "../types/HeaderObject";
+/**
+ * Find all leaf headers (headers without children) in a header tree
+ * Takes collapsed state into account - when a header is collapsed, only returns
+ * children that are visible when parent is collapsed (showWhen is 'parentCollapsed' or 'always')
+ */
+export declare const findLeafHeaders: (header: HeaderObject, collapsedHeaders?: Set<Accessor>) => HeaderObject[];
+/** Default pixel width for 1fr when converting before container width is known */
+export declare const DEFAULT_FR_PX = 150;
+/** Default total table width used when normalizing fr/% if container width unknown */
+export declare const DEFAULT_TABLE_WIDTH = 800;
+/**
+ * Normalize header widths so that fr and % are converted to pixels.
+ * Call this as soon as headers are received so the rest of the code can assume numeric widths.
+ * If totalWidth is not provided, a reasonable total is computed from fixed widths + default for fr columns.
+ * If options.containerWidth is provided, the main section's fr columns are given the remaining space
+ * (container width minus pinned left/right), so the flexible column fills available space.
+ */
+export declare function normalizeHeaderWidths(headers: HeaderObject[], totalWidthOrOptions?: number | {
+    containerWidth: number;
+}): HeaderObject[];
+/**
+ * Get actual width of a header in pixels
+ */
+export declare const getHeaderWidthInPixels: (header: HeaderObject) => number;
+/**
+ * Convert fractional widths to pixel values
+ */
+export declare const removeAllFractionalWidths: (header: HeaderObject) => void;
+/**
+ * Calculate the minimum width for a header
+ */
+export declare const getHeaderMinWidth: (header: HeaderObject) => number;
+/**
+ * Get all visible leaf headers from an array of headers
+ */
+export declare const getAllVisibleLeafHeaders: (headers: HeaderObject[], collapsedHeaders?: Set<Accessor>) => HeaderObject[];
+/**
+ * Convert pixel-based widths to proportional fr units
+ * This is used when autoExpandColumns is enabled
+ */
+export declare const convertPixelWidthsToFr: (headers: HeaderObject[], collapsedHeaders?: Set<Accessor>) => HeaderObject[];
+/**
+ * Calculate the optimal width for a column by measuring both header and cell content
+ * This is used for auto-sizing columns to fit their content (like Excel/Google Sheets)
+ *
+ * @param accessor - The accessor of the header to measure
+ * @param options - Configuration options
+ * @returns The optimal width in pixels
+ */
+export declare const calculateHeaderContentWidth: (accessor: Accessor, options?: {
+    rows?: any[];
+    header?: HeaderObject;
+    maxWidth?: number;
+    sampleSize?: number;
+}) => number;

package/dist/core/src/utils/horizontalScrollbarRenderer.d.ts

@@ -0,0 +1,14 @@
+import type { SectionScrollController } from "../managers/SectionScrollController";
+export interface HorizontalScrollbarProps {
+    mainBodyRef: HTMLDivElement;
+    mainBodyWidth: number;
+    pinnedLeftWidth: number;
+    pinnedRightWidth: number;
+    pinnedLeftContentWidth: number;
+    pinnedRightContentWidth: number;
+    tableBodyContainerRef: HTMLDivElement;
+    editColumns: boolean;
+    sectionScrollController?: SectionScrollController | null;
+}
+export declare const createHorizontalScrollbar: (props: HorizontalScrollbarProps) => HTMLElement | null;
+export declare const cleanupHorizontalScrollbar: (container: HTMLElement, sectionScrollController?: SectionScrollController | null) => void;

package/dist/core/src/utils/infiniteScrollUtils.d.ts

@@ -0,0 +1,145 @@
+import TableRow from "../types/TableRow";
+import { CustomTheme } from "../types/CustomTheme";
+import { Accessor } from "../types/HeaderObject";
+/**
+ * Sorted array of [position, extraHeight] tuples for nested grids
+ * Position: the row index in flattened array
+ * ExtraHeight: additional height beyond standard rowHeight (in pixels)
+ * Array is kept sorted by position for efficient binary search
+ */
+export type HeightOffsets = Array<[number, number]>;
+/**
+ * Precomputed cumulative height data structure for O(1) row position lookups
+ * and O(log n) viewport calculations
+ */
+export interface CumulativeHeightMap {
+    /** Array where index i contains the top pixel position of row i */
+    rowTopPositions: number[];
+    /** Total height of all rows combined */
+    totalHeight: number;
+}
+/**
+ * Build a cumulative height map for efficient viewport calculations
+ * This precomputes the top position of every row, enabling:
+ * - O(1) lookup of row top position
+ * - O(log n) binary search to find rows in viewport
+ *
+ * @param rowCount - Total number of rows
+ * @param rowHeight - Standard height of each row
+ * @param heightOffsets - Array of [position, extraHeight] for variable-height rows
+ * @param customTheme - Theme configuration for separator width
+ * @returns Cumulative height map with row positions
+ */
+export declare const buildCumulativeHeightMap: (rowCount: number, rowHeight: number, heightOffsets: HeightOffsets | undefined, customTheme: CustomTheme) => CumulativeHeightMap;
+/**
+ * Find the row index at a given scroll position using binary search
+ * Returns the index of the row that contains or is closest to the scroll position
+ *
+ * @param scrollTop - The scroll position in pixels
+ * @param heightMap - Precomputed cumulative height map
+ * @returns Row index at the scroll position
+ */
+export declare const findRowAtScrollPosition: (scrollTop: number, heightMap: CumulativeHeightMap) => number;
+/**
+ * Calculate cumulative extra height from nested grids above a given position
+ * Uses binary search for O(log n) performance
+ * @param position - The row position to calculate height for
+ * @param heightOffsets - Sorted array of [position, extraHeight] tuples
+ * @returns Total extra height from all nested grids above this position
+ */
+export declare const getCumulativeExtraHeight: (position: number, heightOffsets?: HeightOffsets) => number;
+export declare const getTotalRowCount: (tableRows: TableRow[]) => number;
+/**
+ * Calculate the total height of all rows including nested grids with extra heights
+ * @param totalRowCount - Total number of rows
+ * @param rowHeight - Standard height of each row
+ * @param heightOffsets - Array of [position, extraHeight] tuples for rows with non-standard heights
+ * @param customTheme - Custom theme configuration for separator width
+ * @returns Total height in pixels
+ */
+export declare const calculateTotalHeight: (totalRowCount: number, rowHeight: number, heightOffsets: HeightOffsets | undefined, customTheme: CustomTheme) => number;
+/**
+ * Viewport range calculation result containing start/end indices and the actual rows
+ */
+export interface ViewportRange {
+    startIndex: number;
+    endIndex: number;
+    rows: TableRow[];
+}
+/**
+ * Complete viewport calculations with multiple strategies
+ * Provides three different ways to calculate visible rows for different use cases
+ */
+export interface ViewportCalculations {
+    /** Rows to render in the DOM (includes overscan buffer for smooth scrolling) */
+    rendered: ViewportRange;
+    /** Rows that are completely visible within the viewport boundaries */
+    fullyVisible: ViewportRange;
+    /** Rows that are at least partially visible in the viewport */
+    partiallyVisible: ViewportRange;
+}
+/**
+ * Calculate all viewport ranges for virtual scrolling with variable-height row support
+ * Returns three different viewport calculations:
+ * - rendered: What should be in the DOM (includes overscan buffer)
+ * - fullyVisible: Rows completely visible (useful for scroll-to-view logic)
+ * - partiallyVisible: Rows at least partially visible (useful for scroll boundaries)
+ *
+ * This function now supports variable-height rows by using a cumulative height map
+ * for O(log n) viewport calculations instead of assuming fixed row heights.
+ */
+export declare const getViewportCalculations: ({ bufferRowCount, contentHeight, rowHeight, scrollTop, tableRows, scrollDirection, heightMap, }: {
+    bufferRowCount: number;
+    contentHeight: number;
+    rowHeight: number;
+    scrollTop: number;
+    tableRows: TableRow[];
+    scrollDirection?: "up" | "down" | "none" | undefined;
+    heightMap?: CumulativeHeightMap | undefined;
+}) => {
+    rendered: {
+        startIndex: number;
+        endIndex: number;
+        rows: TableRow[];
+    };
+    fullyVisible: {
+        startIndex: number;
+        endIndex: number;
+        rows: TableRow[];
+    };
+    partiallyVisible: {
+        startIndex: number;
+        endIndex: number;
+        rows: TableRow[];
+    };
+};
+/**
+ * Get visible rows with pixel-based overscan
+ * Uses the viewport calculations internally and returns the rendered rows
+ * Maintains backward compatibility with existing code
+ */
+export declare const getVisibleRows: ({ bufferRowCount, contentHeight, rowHeight, scrollTop, tableRows, scrollDirection, heightMap, }: {
+    bufferRowCount: number;
+    contentHeight: number;
+    rowHeight: number;
+    scrollTop: number;
+    tableRows: TableRow[];
+    scrollDirection?: "up" | "down" | "none" | undefined;
+    heightMap?: CumulativeHeightMap | undefined;
+}) => TableRow[];
+export declare const calculateSeparatorTopPosition: ({ position, rowHeight, heightOffsets, customTheme, }: {
+    position: number;
+    rowHeight: number;
+    heightOffsets?: HeightOffsets | undefined;
+    customTheme: CustomTheme;
+}) => number;
+export declare const calculateRowTopPosition: ({ position, rowHeight, heightOffsets, customTheme, }: {
+    position: number;
+    rowHeight: number;
+    heightOffsets?: HeightOffsets | undefined;
+    customTheme: CustomTheme;
+}) => number;
+export declare const getStickyParents: (allTableRows: TableRow[], renderedRows: TableRow[], fullyVisibleRows: TableRow[], partiallyVisibleRows: TableRow[], rowGrouping: Accessor[]) => {
+    stickyParents: TableRow[];
+    regularRows: TableRow[];
+};