@simple-table/react 4.0.0 → 4.0.2

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

@@ -1,145 +0,0 @@
-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[];
-};

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

@@ -1,50 +0,0 @@
-/**
- * Vanilla equivalent of React NestedGridRow: renders a full-width row that contains
- * a nested SimpleTable when a row has nestedTable config (expandable + nestedTable headers).
- */
-import type TableRow from "../types/TableRow";
-import type { CustomTheme } from "../types/CustomTheme";
-import type { SimpleTableConfig } from "../types/SimpleTableConfig";
-import { type HeightOffsets } from "./infiniteScrollUtils";
-/**
- * Minimal surface of a table instance this renderer drives. Declared
- * structurally so this module never has to statically import the concrete
- * `SimpleTableVanilla` class — that import would close a cycle
- * (SimpleTableVanilla → RenderOrchestrator → TableRenderer → SectionRenderer →
- * nestedGridRowRenderer → SimpleTableVanilla). The class is injected at render
- * time via {@link NestedTableFactory} instead.
- */
-export interface NestedTableInstance {
-    mount: () => void;
-    destroy: () => void;
-}
-/** Factory injected by the host table to instantiate a nested table. */
-export type NestedTableFactory = (container: HTMLElement, config: SimpleTableConfig) => NestedTableInstance;
-export interface NestedGridRowRenderContext {
-    rowHeight: number;
-    heightOffsets: HeightOffsets | undefined;
-    customTheme: CustomTheme;
-    theme?: string;
-    rowGrouping?: (string | number)[];
-    depth: number;
-    loadingStateRenderer?: SimpleTableConfig["loadingStateRenderer"];
-    errorStateRenderer?: SimpleTableConfig["errorStateRenderer"];
-    emptyStateRenderer?: SimpleTableConfig["emptyStateRenderer"];
-    icons?: SimpleTableConfig["icons"];
-    /** Injected constructor for nested tables (breaks the import cycle). */
-    createNestedTable?: NestedTableFactory;
-}
-/**
- * Creates a nested grid row element: a div with class "st-row st-nested-grid-row"
- * that contains a nested SimpleTableVanilla instance.
- * Returns the row element and a cleanup function to destroy the nested table.
- */
-export declare function createNestedGridRow(tableRow: TableRow, context: NestedGridRowRenderContext): {
-    element: HTMLElement;
-    cleanup: () => void;
-};
-/**
- * Creates a spacer row for pinned sections: same position/height as a nested grid row
- * but no inner table (keeps scroll height in sync).
- */
-export declare function createNestedGridSpacer(tableRow: TableRow, context: Pick<NestedGridRowRenderContext, "rowHeight" | "heightOffsets" | "customTheme">): HTMLElement;

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

@@ -1,29 +0,0 @@
-import HeaderObject, { Accessor } from "../types/HeaderObject";
-import { PinnedSectionsState } from "../types/PinnedSectionsState";
-import { PanelSection } from "../types/PanelSection";
-export type { PinnedSectionsState, PanelSection };
-/** Root-level columns only, preserving order within each pin group. */
-export declare function partitionRootHeadersByPin(headers: HeaderObject[]): {
-    pinnedLeft: HeaderObject[];
-    unpinned: HeaderObject[];
-    pinnedRight: HeaderObject[];
-};
-export declare function isHeaderEssential(header: HeaderObject, essentialAccessors: ReadonlySet<string>): boolean;
-/** Accessors for every header with `isEssential` in the tree (including nested). */
-export declare function collectEssentialAccessors(headers: HeaderObject[]): Set<string>;
-/** Within one sibling list: all essential columns must form a left prefix. */
-export declare function hasEssentialPrefixOrder(siblings: HeaderObject[], essentialAccessors: ReadonlySet<string>): boolean;
-/** Root array mixes pin sections; validate each pin group separately, then recurse into children. */
-export declare function validateFullHeaderTreeEssentialOrder(headers: HeaderObject[], essentialAccessors: ReadonlySet<string>): boolean;
-export declare function getPinnedSectionsState(headers: HeaderObject[]): PinnedSectionsState;
-/**
- * Rebuilds root `headers` order and `pinned` flags from section accessor lists.
- * Clamps essential columns to the left within each section. Returns null if accessors don't match roots.
- */
-export declare function rebuildHeadersFromPinnedState(headers: HeaderObject[], state: PinnedSectionsState, essentialAccessors: ReadonlySet<string>): HeaderObject[] | null;
-/**
- * Move a root column to another pin section.
- * Appends within left/right targets. For `main`, left-pinned columns are inserted at the
- * start of main; right-pinned (and other) columns are inserted at the end of main.
- */
-export declare function moveRootColumnPinSide(headers: HeaderObject[], accessor: Accessor, target: Exclude<PanelSection, "main"> | "main", essentialAccessors: ReadonlySet<string>): HeaderObject[] | null;

package/dist/types/core/src/utils/pivot/pivotRows.d.ts

@@ -1,16 +0,0 @@
-import type HeaderObject from "../../types/HeaderObject";
-import type { Accessor } from "../../types/HeaderObject";
-import type Row from "../../types/Row";
-import type { PivotConfig, PivotResult } from "../../types/PivotTypes";
-export type PivotRowsProps = {
-    rows: Row[];
-    pivot: PivotConfig;
-    /** Field catalog (`defaultHeaders`) for labels, types, widths, formatters. */
-    fieldHeaders: HeaderObject[];
-};
-export declare const buildPivotAccessor: (colKey: string, valueAccessor: Accessor) => string;
-export declare const buildPivotRowTotalAccessor: (valueAccessor: Accessor) => string;
-/**
- * Pure transform: flat source rows + pivot config → pivoted rows and generated headers.
- */
-export declare const pivotRows: ({ rows, pivot, fieldHeaders }: PivotRowsProps) => PivotResult;

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

@@ -1,60 +0,0 @@
-/**
- * Shared prop-sync helpers for framework adapters.
- * Used to skip no-op `defaultHeaders` / `rows` updates when consumers rebuild
- * column configs or shallow-clone rows every render.
- */
-import type { GetRowIdParams } from "../types/GetRowId";
-/** Minimal header shape for structural comparison (renderers ignored). */
-export type HeaderStructureLike = {
-    accessor: string | number | symbol;
-    width?: number | string;
-    minWidth?: number | string;
-    maxWidth?: number | string;
-    label?: string;
-    type?: string;
-    pinned?: string | boolean | null;
-    hide?: boolean;
-    isSortable?: boolean;
-    filterable?: boolean;
-    align?: string;
-    collapsible?: boolean;
-    collapseDefault?: boolean;
-    showWhen?: string;
-    isEditable?: boolean;
-    isEssential?: boolean;
-    disableReorder?: boolean;
-    expandable?: boolean;
-    excludeFromRender?: boolean;
-    autoSizeMode?: string;
-    tooltip?: string;
-    quickFilterable?: boolean;
-    filterOperators?: ReadonlyArray<string>;
-    children?: ReadonlyArray<HeaderStructureLike>;
-};
-/**
- * True when two header trees describe the same columns (accessors, widths,
- * flags, nesting). Ignores renderer identity.
- */
-export declare function headersStructurallyEqual(a: ReadonlyArray<HeaderStructureLike> | undefined, b: ReadonlyArray<HeaderStructureLike> | undefined): boolean;
-/** Collect every accessor in a header tree (for renderer-cache pruning). */
-export declare function collectHeaderAccessors(headers: ReadonlyArray<HeaderStructureLike>, into?: Set<string>): Set<string>;
-/**
- * Shallow equality of a single row object (own enumerable keys, `===` values).
- * Identical references are equal. In-place mutation on a shared object is
- * invisible — callers must pass new object identities when data changes.
- */
-export declare function shallowEqualRow(a: object, b: object): boolean;
-/** Compatible with `GetRowId`; return may be undefined for sync helpers. */
-export type GetRowIdLike = (params: GetRowIdParams) => string | number | undefined;
-/**
- * Above this length, skip per-field shallow compares when row object identity
- * differs. Same-array-ref and same-row-object cases stay O(1) / O(n) pointer
- * checks. Protects huge client datasets from O(n × fields) scans.
- */
-export declare const SHALLOW_ROW_COMPARE_MAX = 50000;
-/**
- * True when `next` is a no-op relative to `prev` for table sync:
- * same length, matching `getRowId` sequence (when provided), and each row
- * either the same object or shallow-equal (for modest list sizes).
- */
-export declare function rowsShallowUnchanged(prev: ReadonlyArray<object> | undefined, next: ReadonlyArray<object> | undefined, getRowId?: GetRowIdLike): boolean;

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

@@ -1,14 +0,0 @@
-import { SmartFilterToken } from "../types/QuickFilterTypes";
-/**
- * Parses a smart filter query into tokens
- * Supports:
- * - Multi-word: "john engineer" → matches rows containing both "john" AND "engineer"
- * - Phrase: "john doe" → matches exact phrase
- * - Negation: -inactive → excludes rows containing "inactive"
- * - Column-specific: name:john → searches only in name column
- */
-export declare const parseSmartFilter: (query: string) => SmartFilterToken[];
-/**
- * Checks if a value matches a simple filter (case-insensitive contains)
- */
-export declare const matchesSimpleFilter: (value: string, filterText: string, caseSensitive: boolean) => boolean;

package/dist/types/core/src/utils/resizeUtils/autoExpandResize.d.ts

@@ -1,32 +0,0 @@
-import type HeaderObject from "../../types/HeaderObject";
-import type { Pinned } from "../../types/Pinned";
-/**
- * Handle resize with autoExpandColumns enabled.
- *
- * Neighbors compensate a growing column only down to their shrink floor (their
- * natural width — declared, content-measured, or user-set). Once all
- * neighbors are at their floor, the main section keeps growing past the
- * container width and overflows into horizontal scroll instead of blocking
- * the drag. Pinned sections cannot scroll their own content, so their growth
- * stays capped by the neighbors' available surplus (plus the pinned-width
- * policy cap).
- */
-export declare const handleResizeWithAutoExpand: ({ childrenToResize, collapsedHeaders, containerWidth, delta, headers, initialWidthsMap, isParentResize, resizedHeader, reverse, rootPinned, sectionHeaders, sectionWidth, sectionViewportWidth, shrinkFloors, startWidth, }: {
-    childrenToResize?: HeaderObject[] | undefined;
-    collapsedHeaders?: Set<string> | undefined;
-    containerWidth: number;
-    delta: number;
-    headers: HeaderObject[];
-    initialWidthsMap: Map<string, number>;
-    isParentResize?: boolean | undefined;
-    resizedHeader: HeaderObject;
-    reverse: boolean;
-    rootPinned: Pinned | undefined;
-    sectionHeaders: HeaderObject[];
-    sectionWidth: number;
-    /** Visible viewport width of the section (main: container minus pinned). 0 when unknown. */
-    sectionViewportWidth?: number | undefined;
-    /** Accessor -> natural width; the shrink floor for compensating neighbors. */
-    shrinkFloors?: Map<string, number> | undefined;
-    startWidth: number;
-}) => void;

package/dist/types/core/src/utils/resizeUtils/compensation.d.ts

@@ -1,17 +0,0 @@
-import type HeaderObject from "../../types/HeaderObject";
-/**
- * Distribute compensation among columns proportionally based on available headroom
- * Used in autoExpandColumns mode
- * Positive compensation = shrink columns, Negative compensation = grow columns
- *
- * `shrinkFloors` (accessor -> px) sets each column's shrink floor — its natural
- * width (declared, content-measured, or user-set). Columns give up only their
- * surplus (expanded) space and are never squeezed below their natural width.
- * Falls back to MIN_COLUMN_WIDTH when a column has no known floor.
- */
-export declare const distributeCompensationProportionally: ({ columnsToShrink, totalCompensation, initialWidthsMap, shrinkFloors, }: {
-    columnsToShrink: HeaderObject[];
-    totalCompensation: number;
-    initialWidthsMap: Map<string, number>;
-    shrinkFloors?: Map<string, number> | undefined;
-}) => void;

package/dist/types/core/src/utils/resizeUtils/domUpdates.d.ts

@@ -1,15 +0,0 @@
-import type HeaderObject from "../../types/HeaderObject";
-import type { Pinned } from "../../types/Pinned";
-/**
- * Get the pinned value from the root header (for nested headers, children inherit from parent)
- */
-export declare const getRootPinned: (header: HeaderObject, headers: HeaderObject[]) => Pinned | undefined;
-/**
- * Update column widths and positions directly in the DOM without triggering React re-renders
- * This is used during resize drag for better performance
- *
- * IMPORTANT: Positions are calculated per pinned section (left/main/right each start at 0)
- * @param collapsedHeaders - Set of collapsed header accessors; only visible children are laid out (matches findLeafHeaders / SectionRenderer).
- * @param overrideWidths - Optional map of accessor -> width to use for position calculation (e.g. after resize so DOM reflects just-set value)
- */
-export declare const updateColumnWidthsInDOM: (headers: HeaderObject[], collapsedHeaders?: Set<string>, overrideWidths?: Map<string, number>) => void;

package/dist/types/core/src/utils/resizeUtils/index.d.ts

@@ -1,26 +0,0 @@
-import type HeaderObject from "../../types/HeaderObject";
-import type { Accessor } from "../../types/HeaderObject";
-import type { HandleResizeStartProps } from "../../types/HandleResizeStartProps";
-/**
- * Handler for when resize dragging starts
- */
-export declare const handleResizeStart: ({ autoExpandColumns, collapsedHeaders, containerWidth, event, header, headers, mainBodyRef, onColumnWidthChange, onAutoExpandNaturalWidths, reverse, setHeaders, setIsResizing, shrinkFloors, startWidth, }: HandleResizeStartProps) => void;
-export type ApplyColumnAutoFitWithAutoExpandParams = {
-    collapsedHeaders: Set<Accessor>;
-    containerWidth: number;
-    getTargetLeafWidth: (leafHeader: HeaderObject) => number;
-    header: HeaderObject;
-    headerCellElement: HTMLElement | null;
-    headers: HeaderObject[];
-    mainBodyRef: HandleResizeStartProps["mainBodyRef"];
-    /** Persist the auto-fitted column(s)' widths as their natural widths. */
-    onAutoExpandNaturalWidths?: (widths: Map<string, number>) => void;
-    reverse: boolean;
-    /** Natural-width shrink floors (accessor -> px) for compensating neighbors. */
-    shrinkFloors?: Map<string, number>;
-};
-/**
- * Apply a one-shot "fit to content" width for a column while preserving autoExpand
- * compensation (same redistribution rules as dragging the resize handle).
- */
-export declare const applyColumnAutoFitWithAutoExpand: ({ header, headers, collapsedHeaders, containerWidth, mainBodyRef, reverse, headerCellElement, getTargetLeafWidth, onAutoExpandNaturalWidths, shrinkFloors, }: ApplyColumnAutoFitWithAutoExpandParams) => void;

package/dist/types/core/src/utils/resizeUtils/maxWidth.d.ts

@@ -1,9 +0,0 @@
-import type HeaderObject from "../../types/HeaderObject";
-/**
- * Calculate the maximum allowable width for a header based on container constraints
- */
-export declare const calculateMaxHeaderWidth: ({ header, headers, collapsedHeaders, }: {
-    header: HeaderObject;
-    headers: HeaderObject[];
-    collapsedHeaders?: Set<string> | undefined;
-}) => number;

package/dist/types/core/src/utils/resizeUtils/parentHeaderResize.d.ts

@@ -1,11 +0,0 @@
-import type HeaderObject from "../../types/HeaderObject";
-/**
- * Handle resizing of parent headers with multiple children
- */
-export declare const handleParentHeaderResize: ({ delta, leafHeaders, minWidth, startWidth, maxWidth, }: {
-    delta: number;
-    leafHeaders: HeaderObject[];
-    minWidth: number;
-    startWidth: number;
-    maxWidth: number;
-}) => void;

package/dist/types/core/src/utils/resizeUtils/sectionWidths.d.ts

@@ -1,36 +0,0 @@
-import type HeaderObject from "../../types/HeaderObject";
-/**
- * Width of the *visible* portion of the main (non-pinned) section: the container
- * width minus the pinned section widths.
- *
- * This is the viewport used for column virtualization (getVisibleBodyCells /
- * getVisibleCells) — NOT `mainWidth` from {@link recalculateAllSectionWidths},
- * which is the full *content* width (sum of all main column widths). Passing the
- * content width here makes every column count as "in viewport", disabling column
- * virtualization (all columns render). See the column-virtualization regression
- * tests.
- *
- * Returns `undefined` when the container has not been measured yet
- * (`containerWidth` 0) so callers fall back to a live `clientWidth` read instead
- * of virtualizing against a 0px viewport.
- */
-export declare const getMainSectionViewportWidth: ({ containerWidth, leftWidth, rightWidth, }: {
-    containerWidth: number;
-    leftWidth: number;
-    rightWidth: number;
-}) => number | undefined;
-/**
- * Recalculate widths for all sections (left, right, main)
- * Returns both constrained widths (for display) and raw content widths (for scrolling)
- */
-export declare const recalculateAllSectionWidths: ({ headers, containerWidth, collapsedHeaders, }: {
-    headers: HeaderObject[];
-    containerWidth?: number | undefined;
-    collapsedHeaders?: Set<string> | undefined;
-}) => {
-    leftWidth: number;
-    rightWidth: number;
-    mainWidth: number;
-    leftContentWidth: number;
-    rightContentWidth: number;
-};

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

@@ -1,30 +0,0 @@
-import HeaderObject, { Accessor } from "../types/HeaderObject";
-import Row from "../types/Row";
-import RowState from "../types/RowState";
-import TableRow from "../types/TableRow";
-import { HeightOffsets } from "./infiniteScrollUtils";
-import { CustomTheme } from "../types/CustomTheme";
-import { GetRowId } from "../types/GetRowId";
-export interface FlattenRowsConfig {
-    rows: Row[];
-    rowGrouping?: Accessor[];
-    getRowId?: GetRowId;
-    expandedRows?: Map<string, number>;
-    collapsedRows?: Map<string, number>;
-    expandedDepths?: Set<number>;
-    rowStateMap?: Map<string | number, RowState>;
-    hasLoadingRenderer?: boolean;
-    hasErrorRenderer?: boolean;
-    hasEmptyRenderer?: boolean;
-    headers?: HeaderObject[];
-    rowHeight?: number;
-    headerHeight?: number;
-    customTheme?: CustomTheme;
-}
-export interface FlattenRowsResult {
-    flattenedRows: TableRow[];
-    heightOffsets: HeightOffsets;
-    paginatableRows: TableRow[];
-    parentEndPositions: number[];
-}
-export declare function flattenRows(config: FlattenRowsConfig): FlattenRowsResult;

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

@@ -1,65 +0,0 @@
-import { CumulativeHeightMap } from "./infiniteScrollUtils";
-import { Accessor } from "../types/HeaderObject";
-import TableRow from "../types/TableRow";
-import { HeightOffsets } from "./infiniteScrollUtils";
-import { CustomTheme } from "../types/CustomTheme";
-export interface ProcessRowsConfig {
-    flattenedRows: TableRow[];
-    paginatableRows: TableRow[];
-    parentEndPositions: number[];
-    currentPage: number;
-    rowsPerPage: number;
-    shouldPaginate: boolean;
-    serverSidePagination: boolean;
-    contentHeight: number | undefined;
-    rowHeight: number;
-    scrollTop: number;
-    scrollDirection?: "up" | "down" | "none";
-    heightOffsets?: HeightOffsets;
-    customTheme: CustomTheme;
-    enableStickyParents: boolean;
-    rowGrouping?: Accessor[];
-}
-export interface ProcessRowsResult {
-    currentTableRows: TableRow[];
-    rowsToRender: TableRow[];
-    /** Visible range start index into currentTableRows (when virtualized). */
-    renderedStartIndex: number;
-    /** Visible range end index into currentTableRows (when virtualized). */
-    renderedEndIndex: number;
-    stickyParents: TableRow[];
-    regularRows: TableRow[];
-    partiallyVisibleRows: TableRow[];
-    paginatedHeightOffsets: HeightOffsets | undefined;
-    heightMap: CumulativeHeightMap | undefined;
-    /** Pre-pagination flattened rows (each row's `position` is its global index).
-     * Used by animation snapshot to include off-page rows so cross-page sort can
-     * FLIP cells in/out from off-screen. */
-    allFlattenedRows: TableRow[];
-    /** Global flattened-list index where the current page starts. 0 when no
-     * pagination is active. Used by animation snapshot to convert global
-     * positions into page-relative `top` values. */
-    pageStartIndex: number;
-}
-export declare function processRows(config: ProcessRowsConfig): ProcessRowsResult;
-/** Layout inputs that do not depend on scroll position (reuse across scroll-raf frames). */
-export interface ProcessRowsScrollReuseBase {
-    currentTableRows: TableRow[];
-    paginatedHeightOffsets: HeightOffsets | undefined;
-    heightMap: CumulativeHeightMap | undefined;
-    allFlattenedRows: TableRow[];
-    pageStartIndex: number;
-}
-/**
- * Recomputes only viewport-dependent fields when pagination, height map, and row list
- * are unchanged (vertical scroll only). Avoids re-running applyPagination and
- * buildCumulativeHeightMap on every scroll frame.
- */
-export declare function recomputeProcessRowsViewport(base: ProcessRowsScrollReuseBase, config: {
-    contentHeight: number | undefined;
-    rowHeight: number;
-    scrollTop: number;
-    scrollDirection?: "up" | "down" | "none";
-    enableStickyParents: boolean;
-    rowGrouping?: Accessor[];
-}): ProcessRowsResult;

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

@@ -1,62 +0,0 @@
-import Row from "../types/Row";
-import TableRow from "../types/TableRow";
-import HeaderObject from "../types/HeaderObject";
-import type { RowSelectionMode } from "../types/RowSelectionMode";
-/**
- * Whether the checkbox / row-buttons column should be injected into headers.
- * Always shown when `rowButtons` is set (buttons need a home).
- */
-export declare const shouldShowRowSelectionColumn: (config: {
-    enableRowSelection?: boolean;
-    showRowSelectionColumn?: boolean;
-    rowButtons?: unknown[];
-}) => boolean;
-/**
- * Get the set of selected row IDs from an array of table rows
- */
-export declare const getSelectedRowIds: (tableRows: TableRow[]) => string[];
-/**
- * Check if a specific row is selected
- */
-export declare const isRowSelected: (rowId: string, selectedRows: Set<string>) => boolean;
-/**
- * Check if all rows are selected
- */
-export declare const areAllRowsSelected: (tableRows: TableRow[], selectedRows: Set<string>) => boolean;
-/**
- * Toggle selection of a single row (multiple mode).
- */
-export declare const toggleRowSelection: (rowId: string, selectedRows: Set<string>) => Set<string>;
-/**
- * Set whether a row is selected, respecting selection mode.
- */
-export declare const setRowSelected: (rowId: string, isSelected: boolean, selectedRows: Set<string>, mode?: RowSelectionMode) => Set<string>;
-/**
- * Select a range of visible rows (inclusive) by index into `tableRows`.
- * Used for Shift+arrow keyboard range selection in multiple mode.
- */
-export declare const selectRowRange: (tableRows: TableRow[], startIndex: number, endIndex: number, baseSelection?: Set<string>) => Set<string>;
-/**
- * Select all rows
- */
-export declare const selectAllRows: (tableRows: TableRow[]) => Set<string>;
-/**
- * Deselect all rows
- */
-export declare const deselectAllRows: () => Set<string>;
-/**
- * Get the selected rows from the table rows array
- */
-export declare const getSelectedRows: (tableRows: TableRow[], selectedRows: Set<string>) => Row[];
-/**
- * Find a row by its string row id in the current table rows.
- */
-export declare const findRowById: (tableRows: TableRow[], rowId: string) => Row | undefined;
-/**
- * Get the count of selected rows
- */
-export declare const getSelectedRowCount: (selectedRows: Set<string>) => number;
-/**
- * Create a selection header for the checkbox column
- */
-export declare const createSelectionHeader: (width: number) => HeaderObject;

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

@@ -1,16 +0,0 @@
-import { HeightOffsets } from "./infiniteScrollUtils";
-import { CustomTheme } from "../types/CustomTheme";
-export interface CreateRowSeparatorOptions {
-    position: number;
-    rowHeight: number;
-    displayStrongBorder: boolean;
-    heightOffsets?: HeightOffsets;
-    customTheme?: CustomTheme;
-    isSticky?: boolean;
-    /** Same px width as the body/sticky section (`SectionRenderer` / sticky pane); omit to use 100%. */
-    sectionWidthPx?: number;
-}
-/** Keep separator width in sync with section layout (resize, pinned width changes). */
-export declare const applyRowSeparatorSectionWidth: (separator: HTMLElement, sectionWidthPx?: number) => void;
-export declare const createRowSeparator: (options: CreateRowSeparatorOptions) => HTMLElement;
-export declare const createSpacerRow: (position: number, rowHeight: number, heightOffsets: HeightOffsets | undefined, customTheme: CustomTheme, className: string, height?: number) => HTMLElement;