simple-table-core 4.0.0 → 4.0.2

package/dist/{src/utils → utils}/headerWidthUtils.d.ts

@@ -1,121 +1,121 @@
-import HeaderObject, { Accessor } from "../types/HeaderObject";
-/**
- * Build the set of row indices to sample for auto-size measurement.
- * Hybrid strategy: the first `headSize` rows (always include the top / initial
- * viewport) plus `stridedSize` rows spread at an even stride across the rest of
- * the dataset, so wide values deeper in the data are caught without scanning
- * every row. Strided (not random) keeps the result deterministic across renders.
- */
-export declare const buildHybridSampleIndices: (rowCount: number, headSize: number, stridedSize: number) => number[];
-/** Linear-interpolated percentile (0-100) of a numeric array. */
-export declare const percentileOf: (values: number[], percentile: number) => number;
-/**
- * Choose a representative "content width" from sampled cell widths, clipping
- * outliers only when they clearly stand apart from the bulk of the data.
- *
- * - Uses the true max when the column is uniform (max close to the percentile),
- *   so nothing legitimate gets truncated.
- * - Falls back to the percentile width only when `max > p * (1 + threshold)` and
- *   there are enough samples to trust the percentile, so a single rogue 2000px
- *   row can't define the whole column.
- */
-export declare const selectContentWidthWithOutlierClip: (widths: number[], options?: {
-    percentile?: number;
-    threshold?: number;
-    minSampleForClip?: number;
-}) => number;
-/**
- * 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;
-/** True when a header's width requests content-based auto-sizing (`width: "auto"`). */
-export declare const isAutoWidth: (header: HeaderObject) => boolean;
-/**
- * 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, all fr/% columns are resolved against the full container width,
- * so pinned and non-pinned fr columns share the same proportional pool.
- */
-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[];
-/**
- * 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 Measured width plus whether the result is final (`settled`). When a
- *   custom `cellRenderer` / `headerRenderer` exists but its real DOM is not
- *   measurable yet (async portal / loading skeleton), `settled` is false and
- *   the width is provisional (header / minWidth only — never `valueFormatter`
- *   or plain `label` as a stand-in for renderer output). Callers should apply
- *   that provisional width once and re-measure later via an explicit refit
- *   (rows / isLoading / `refitAutoSizeColumns`) — not by leaving the column
- *   pending across every render.
- */
-export declare const calculateHeaderContentWidth: (accessor: Accessor, options?: {
-    rows?: any[] | undefined;
-    header?: HeaderObject | undefined;
-    maxWidth?: number | undefined;
-    /** Leading rows always measured (default AUTO_SIZE_HEAD_SAMPLE_SIZE) */
-    headSampleSize?: number | undefined;
-    /** Rows sampled at an even stride across the rest (default AUTO_SIZE_STRIDED_SAMPLE_SIZE) */
-    stridedSampleSize?: number | undefined;
-    /** Back-compat: when set, used as the head sample size (strided defaults to 0) */
-    sampleSize?: number | undefined;
-    /** Outlier clip percentile (default AUTO_SIZE_OUTLIER_PERCENTILE) */
-    outlierPercentile?: number | undefined;
-    /** Outlier clip threshold fraction (default AUTO_SIZE_OUTLIER_THRESHOLD) */
-    outlierThreshold?: number | undefined;
-    /** When "header", ignore cell content and fit the header label only */
-    autoSizeMode?: "content" | "header" | undefined;
-    /** Theme passed to a custom cellRenderer during measurement */
-    theme?: any;
-    /** Scope `.st-cell-content` font/padding sampling to this table instance */
-    styleRoot?: ParentNode | null | undefined;
-    /**
-     * The table's resolved sort icon. Used to reserve space on sortable columns
-     * that are not currently sorted (the icon only exists on the active sort
-     * column), so sorting later does not push the label into ellipsis.
-     */
-    sortIcon?: string | HTMLElement | SVGSVGElement | undefined;
-    /**
-     * The table's resolved expand/collapse icon. Used to reserve space on
-     * collapsible headers when the header cell is virtualized out of the
-     * horizontal band (so the icon is not in the DOM to measure directly).
-     */
-    expandIcon?: string | HTMLElement | SVGSVGElement | undefined;
-    /**
-     * Called before a temporary measure host from `cellRenderer` is discarded.
-     * Framework adapters (React portals, Vue/Solid mounts) register on render;
-     * without this, autofit sampling leaks those registrations.
-     */
-    onRendererHostDiscard?: ((host: HTMLElement) => void) | undefined;
-} | undefined) => {
-    width: number;
-    settled: boolean;
-};
+import HeaderObject, { Accessor } from "../types/HeaderObject";
+/**
+ * Build the set of row indices to sample for auto-size measurement.
+ * Hybrid strategy: the first `headSize` rows (always include the top / initial
+ * viewport) plus `stridedSize` rows spread at an even stride across the rest of
+ * the dataset, so wide values deeper in the data are caught without scanning
+ * every row. Strided (not random) keeps the result deterministic across renders.
+ */
+export declare const buildHybridSampleIndices: (rowCount: number, headSize: number, stridedSize: number) => number[];
+/** Linear-interpolated percentile (0-100) of a numeric array. */
+export declare const percentileOf: (values: number[], percentile: number) => number;
+/**
+ * Choose a representative "content width" from sampled cell widths, clipping
+ * outliers only when they clearly stand apart from the bulk of the data.
+ *
+ * - Uses the true max when the column is uniform (max close to the percentile),
+ *   so nothing legitimate gets truncated.
+ * - Falls back to the percentile width only when `max > p * (1 + threshold)` and
+ *   there are enough samples to trust the percentile, so a single rogue 2000px
+ *   row can't define the whole column.
+ */
+export declare const selectContentWidthWithOutlierClip: (widths: number[], options?: {
+    percentile?: number;
+    threshold?: number;
+    minSampleForClip?: number;
+}) => number;
+/**
+ * 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;
+/** True when a header's width requests content-based auto-sizing (`width: "auto"`). */
+export declare const isAutoWidth: (header: HeaderObject) => boolean;
+/**
+ * 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, all fr/% columns are resolved against the full container width,
+ * so pinned and non-pinned fr columns share the same proportional pool.
+ */
+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[];
+/**
+ * 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 Measured width plus whether the result is final (`settled`). When a
+ *   custom `cellRenderer` / `headerRenderer` exists but its real DOM is not
+ *   measurable yet (async portal / loading skeleton), `settled` is false and
+ *   the width is provisional (header / minWidth only — never `valueFormatter`
+ *   or plain `label` as a stand-in for renderer output). Callers should apply
+ *   that provisional width once and re-measure later via an explicit refit
+ *   (rows / isLoading / `refitAutoSizeColumns`) — not by leaving the column
+ *   pending across every render.
+ */
+export declare const calculateHeaderContentWidth: (accessor: Accessor, options?: {
+    rows?: any[];
+    header?: HeaderObject;
+    maxWidth?: number;
+    /** Leading rows always measured (default AUTO_SIZE_HEAD_SAMPLE_SIZE) */
+    headSampleSize?: number;
+    /** Rows sampled at an even stride across the rest (default AUTO_SIZE_STRIDED_SAMPLE_SIZE) */
+    stridedSampleSize?: number;
+    /** Back-compat: when set, used as the head sample size (strided defaults to 0) */
+    sampleSize?: number;
+    /** Outlier clip percentile (default AUTO_SIZE_OUTLIER_PERCENTILE) */
+    outlierPercentile?: number;
+    /** Outlier clip threshold fraction (default AUTO_SIZE_OUTLIER_THRESHOLD) */
+    outlierThreshold?: number;
+    /** When "header", ignore cell content and fit the header label only */
+    autoSizeMode?: "content" | "header";
+    /** Theme passed to a custom cellRenderer during measurement */
+    theme?: any;
+    /** Scope `.st-cell-content` font/padding sampling to this table instance */
+    styleRoot?: ParentNode | null;
+    /**
+     * The table's resolved sort icon. Used to reserve space on sortable columns
+     * that are not currently sorted (the icon only exists on the active sort
+     * column), so sorting later does not push the label into ellipsis.
+     */
+    sortIcon?: string | HTMLElement | SVGSVGElement;
+    /**
+     * The table's resolved expand/collapse icon. Used to reserve space on
+     * collapsible headers when the header cell is virtualized out of the
+     * horizontal band (so the icon is not in the DOM to measure directly).
+     */
+    expandIcon?: string | HTMLElement | SVGSVGElement;
+    /**
+     * Called before a temporary measure host from `cellRenderer` is discarded.
+     * Framework adapters (React portals, Vue/Solid mounts) register on render;
+     * without this, autofit sampling leaks those registrations.
+     */
+    onRendererHostDiscard?: (host: HTMLElement) => void;
+}) => {
+    width: number;
+    settled: boolean;
+};

package/dist/{src/utils → utils}/horizontalScrollbarRenderer.d.ts

@@ -1,27 +1,27 @@
-import type { SectionScrollController } from "../managers/SectionScrollController";
-export interface HorizontalScrollbarProps {
-    mainBodyRef: HTMLDivElement;
-    mainBodyWidth: number;
-    pinnedLeftWidth: number;
-    pinnedRightWidth: number;
-    pinnedLeftContentWidth: number;
-    pinnedRightContentWidth: number;
-    tableBodyContainerRef: HTMLDivElement;
-    /** True when the column-editor toggle strip is visible and reserves horizontal space. */
-    editColumns: boolean;
-    sectionScrollController?: SectionScrollController | null;
-    /**
-     * When true, skip the DOM scrollWidth check and always build the scrollbar.
-     * Used after the caller has already verified content overflow (e.g. empty
-     * tables where the header scrollport is sized to content and reports no
-     * DOM overflow even though columns exceed the viewport).
-     */
-    forceScrollable?: boolean;
-}
-export declare const createHorizontalScrollbar: (props: HorizontalScrollbarProps) => HTMLElement | null;
-/**
- * Apply width props to an existing scrollbar from {@link createHorizontalScrollbar}.
- * Used when layout is recreated without tearing down the DOM node (e.g. pinned resize).
- */
-export declare const syncHorizontalScrollbarLayout: (container: HTMLElement, props: HorizontalScrollbarProps) => void;
-export declare const cleanupHorizontalScrollbar: (container: HTMLElement, sectionScrollController?: SectionScrollController | null) => void;
+import type { SectionScrollController } from "../managers/SectionScrollController";
+export interface HorizontalScrollbarProps {
+    mainBodyRef: HTMLDivElement;
+    mainBodyWidth: number;
+    pinnedLeftWidth: number;
+    pinnedRightWidth: number;
+    pinnedLeftContentWidth: number;
+    pinnedRightContentWidth: number;
+    tableBodyContainerRef: HTMLDivElement;
+    /** True when the column-editor toggle strip is visible and reserves horizontal space. */
+    editColumns: boolean;
+    sectionScrollController?: SectionScrollController | null;
+    /**
+     * When true, skip the DOM scrollWidth check and always build the scrollbar.
+     * Used after the caller has already verified content overflow (e.g. empty
+     * tables where the header scrollport is sized to content and reports no
+     * DOM overflow even though columns exceed the viewport).
+     */
+    forceScrollable?: boolean;
+}
+export declare const createHorizontalScrollbar: (props: HorizontalScrollbarProps) => HTMLElement | null;
+/**
+ * Apply width props to an existing scrollbar from {@link createHorizontalScrollbar}.
+ * Used when layout is recreated without tearing down the DOM node (e.g. pinned resize).
+ */
+export declare const syncHorizontalScrollbarLayout: (container: HTMLElement, props: HorizontalScrollbarProps) => void;
+export declare const cleanupHorizontalScrollbar: (container: HTMLElement, sectionScrollController?: SectionScrollController | null) => void;

package/dist/{cjs/src/utils → utils}/infiniteScrollUtils.d.ts

@@ -1,145 +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[];
-};
+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";
+    heightMap?: CumulativeHeightMap;
+}) => {
+    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";
+    heightMap?: CumulativeHeightMap;
+}) => TableRow[];
+export declare const calculateSeparatorTopPosition: ({ position, rowHeight, heightOffsets, customTheme, }: {
+    position: number;
+    rowHeight: number;
+    heightOffsets?: HeightOffsets;
+    customTheme: CustomTheme;
+}) => number;
+export declare const calculateRowTopPosition: ({ position, rowHeight, heightOffsets, customTheme, }: {
+    position: number;
+    rowHeight: number;
+    heightOffsets?: HeightOffsets;
+    customTheme: CustomTheme;
+}) => number;
+export declare const getStickyParents: (allTableRows: TableRow[], renderedRows: TableRow[], fullyVisibleRows: TableRow[], partiallyVisibleRows: TableRow[], rowGrouping: Accessor[]) => {
+    stickyParents: TableRow[];
+    regularRows: TableRow[];
+};

package/dist/utils/loadingPlaceholderUtils.d.ts

@@ -0,0 +1,11 @@
+import type Row from "../types/Row";
+import type { GetRowId } from "../types/GetRowId";
+/** Mark and return a fresh empty row used as an `isLoading` skeleton placeholder. */
+export declare const createLoadingPlaceholderRow: () => Row;
+export declare const isLoadingPlaceholderRow: (row: Row) => boolean;
+/**
+ * Consumer `getRowId` often collapses empty placeholders to the same key.
+ * Skip it for placeholders so WeakMap identity / positional ids stay unique.
+ */
+export declare const wrapGetRowIdForLoadingPlaceholders: (getRowId: GetRowId | undefined) => GetRowId | undefined;
+export declare const createLoadingPlaceholderRows: (count: number) => Row[];