simple-table-core 4.0.1 → 4.0.3

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

@@ -1,41 +0,0 @@
-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/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/src/utils/loadingPlaceholderUtils.d.ts

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

package/dist/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/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/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/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/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/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/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/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/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;