simple-table-core 4.1.5 → 4.1.7

package/dist/managers/ColumnManager.d.ts

@@ -1,42 +0,0 @@
-import ColumnDef, { Accessor } from "../types/ColumnDef";
-import { ColumnVisibilityState } from "../types/ColumnVisibilityTypes";
-export interface ColumnManagerConfig {
-    headers: ColumnDef[];
-    collapsedHeaders: Set<Accessor>;
-    onColumnOrderChange?: (newHeaders: ColumnDef[]) => void;
-    onColumnVisibilityChange?: (visibilityState: ColumnVisibilityState) => void;
-    onColumnWidthChange?: (headers: ColumnDef[]) => void;
-}
-export interface ColumnManagerState {
-    headers: ColumnDef[];
-    collapsedHeaders: Set<Accessor>;
-    columnVisibility: ColumnVisibilityState;
-    draggedHeader: ColumnDef | null;
-    hoveredHeader: ColumnDef | null;
-}
-type StateChangeCallback = (state: ColumnManagerState) => void;
-export declare class ColumnManager {
-    private config;
-    private state;
-    private subscribers;
-    constructor(config: ColumnManagerConfig);
-    private buildColumnVisibilityState;
-    updateConfig(config: Partial<ColumnManagerConfig>): void;
-    subscribe(callback: StateChangeCallback): () => void;
-    private notifySubscribers;
-    setHeaders(headers: ColumnDef[]): void;
-    setCollapsedHeaders(collapsedHeaders: Set<Accessor>): void;
-    toggleColumnCollapse(accessor: Accessor): void;
-    setColumnVisibility(accessor: Accessor, visible: boolean): void;
-    updateColumnWidth(accessor: Accessor, width: number | string): void;
-    reorderColumns(newHeaders: ColumnDef[]): void;
-    setDraggedHeader(header: ColumnDef | null): void;
-    setHoveredHeader(header: ColumnDef | null): void;
-    getState(): ColumnManagerState;
-    getHeaders(): ColumnDef[];
-    getCollapsedHeaders(): Set<Accessor>;
-    getColumnVisibility(): ColumnVisibilityState;
-    isColumnVisible(accessor: Accessor): boolean;
-    destroy(): void;
-}
-export {};

package/dist/managers/RowManager.d.ts

@@ -1,56 +0,0 @@
-import ColumnDef, { Accessor } from "../types/ColumnDef";
-import Row from "../types/Row";
-import RowState from "../types/RowState";
-import TableRow from "../types/TableRow";
-import { HeightOffsets } from "../utils/infiniteScrollUtils";
-import { CustomTheme } from "../types/CustomTheme";
-import { GetRowId } from "../types/GetRowId";
-export interface RowManagerConfig {
-    rows: Row[];
-    headers: ColumnDef[];
-    rowGrouping?: Accessor[];
-    getRowId?: GetRowId;
-    rowHeight: number;
-    headerHeight: number;
-    customTheme: CustomTheme;
-    hasLoadingRenderer: boolean;
-    hasErrorRenderer: boolean;
-    hasEmptyRenderer: boolean;
-}
-export interface RowManagerState {
-    expandedRows: Map<string, number>;
-    collapsedRows: Map<string, number>;
-    expandedDepths: Set<number>;
-    rowStateMap: Map<string | number, RowState>;
-    aggregatedRows: Row[];
-    flattenedRows: TableRow[];
-    heightOffsets: HeightOffsets;
-    paginatableRows: TableRow[];
-    parentEndPositions: number[];
-}
-type StateChangeCallback = (state: RowManagerState) => void;
-export declare class RowManager {
-    private config;
-    private state;
-    private subscribers;
-    constructor(config: RowManagerConfig);
-    private getAllAggregationHeaders;
-    private calculateAggregation;
-    private computeAggregatedRows;
-    private computeFlattenedRows;
-    updateConfig(config: Partial<RowManagerConfig>): void;
-    subscribe(callback: StateChangeCallback): () => void;
-    private notifySubscribers;
-    setExpandedRows(expandedRows: Map<string, number>): void;
-    setCollapsedRows(collapsedRows: Map<string, number>): void;
-    setExpandedDepths(expandedDepths: Set<number>): void;
-    setRowStateMap(rowStateMap: Map<string | number, RowState>): void;
-    getState(): RowManagerState;
-    getAggregatedRows(): Row[];
-    getFlattenedRows(): TableRow[];
-    getHeightOffsets(): HeightOffsets;
-    getPaginatableRows(): TableRow[];
-    getParentEndPositions(): number[];
-    destroy(): void;
-}
-export {};

package/dist/managers/TableManager.d.ts

@@ -1,72 +0,0 @@
-import ColumnDef, { Accessor } from "../types/ColumnDef";
-import Row from "../types/Row";
-import SortColumn, { SortDirection } from "../types/SortColumn";
-import { TableFilterState } from "../types/FilterTypes";
-import { ColumnVisibilityState } from "../types/ColumnVisibilityTypes";
-import { CustomTheme } from "../types/CustomTheme";
-import { GetRowId } from "../types/GetRowId";
-import { SortManager } from "./SortManager";
-import { FilterManager } from "./FilterManager";
-import { RowManager } from "./RowManager";
-import { ColumnManager } from "./ColumnManager";
-import { DimensionManager } from "./DimensionManager";
-import { ScrollManager } from "./ScrollManager";
-import { SelectionManager } from "./SelectionManager";
-export interface TableManagerConfig {
-    headers: ColumnDef[];
-    rows: Row[];
-    rowHeight: number;
-    headerHeight?: number;
-    customTheme: CustomTheme;
-    externalSortHandling?: boolean;
-    externalFilterHandling?: boolean;
-    rowGrouping?: Accessor[];
-    getRowId?: GetRowId;
-    selectableCells?: boolean;
-    selectableColumns?: boolean;
-    enableRowSelection?: boolean;
-    copyHeadersToClipboard?: boolean;
-    height?: string | number;
-    maxHeight?: string | number;
-    initialSortColumn?: string;
-    initialSortDirection?: SortDirection;
-    onSortChange?: (sort: SortColumn | null) => void;
-    onFilterChange?: (filters: TableFilterState) => void;
-    onColumnOrderChange?: (newHeaders: ColumnDef[]) => void;
-    onColumnVisibilityChange?: (visibilityState: ColumnVisibilityState) => void;
-    onColumnWidthChange?: (headers: ColumnDef[]) => void;
-    onLoadMore?: () => void;
-    onCellEdit?: (props: any) => void;
-    announce?: (message: string) => void;
-    containerElement?: HTMLElement;
-    cellRegistry?: Map<string, any>;
-    collapsedHeaders?: Set<Accessor>;
-}
-export interface TableManagerState {
-    isReady: boolean;
-}
-type StateChangeCallback = () => void;
-export declare class TableManager {
-    private config;
-    private state;
-    private subscribers;
-    sortManager: SortManager;
-    filterManager: FilterManager;
-    rowManager: RowManager;
-    columnManager: ColumnManager;
-    dimensionManager: DimensionManager;
-    scrollManager: ScrollManager;
-    selectionManager: SelectionManager;
-    constructor(config: TableManagerConfig);
-    private setupManagerSubscriptions;
-    private applyFiltersAndSort;
-    private handleSortChange;
-    private handleFilterChange;
-    updateConfig(config: Partial<TableManagerConfig>): void;
-    subscribe(callback: StateChangeCallback): () => void;
-    private notifySubscribers;
-    getState(): TableManagerState;
-    isReady(): boolean;
-    destroy(): void;
-}
-export {};

package/dist/types/BoundingBox.d.ts

@@ -1,11 +0,0 @@
-type BoundingBox = {
-    bottom: number;
-    height: number;
-    left: number;
-    right: number;
-    top: number;
-    width: number;
-    x: number;
-    y: number;
-};
-export default BoundingBox;

package/dist/types/DragHandlerProps.d.ts

@@ -1,14 +0,0 @@
-import ColumnDef, { Accessor } from "./ColumnDef";
-type useDragHandlerProps = {
-    draggedHeaderRef: {
-        current: ColumnDef | null;
-    };
-    essentialAccessors?: ReadonlySet<Accessor | string>;
-    headers: ColumnDef[];
-    hoveredHeaderRef: {
-        current: ColumnDef | null;
-    };
-    onColumnOrderChange?: (newHeaders: ColumnDef[]) => void;
-    onTableHeaderDragEnd: (newHeaders: ColumnDef[]) => void;
-};
-export default useDragHandlerProps;

package/dist/types/OnSortProps.d.ts

@@ -1,3 +0,0 @@
-import { Accessor } from "./ColumnDef";
-type OnSortProps = (accessor: Accessor) => void;
-export default OnSortProps;

package/dist/types/SharedTableProps.d.ts

@@ -1,24 +0,0 @@
-import ColumnDef from "./ColumnDef";
-export interface RefObject<T> {
-    current: T | null;
-}
-interface SharedTableProps {
-    centerHeaderRef: RefObject<HTMLDivElement | null>;
-    draggedHeaderRef: {
-        current: ColumnDef | null;
-    };
-    headerContainerRef: RefObject<HTMLDivElement | null>;
-    headers: ColumnDef[];
-    hoveredHeaderRef: {
-        current: ColumnDef | null;
-    };
-    mainBodyRef: RefObject<HTMLDivElement | null>;
-    onTableHeaderDragEnd: (newHeaders: ColumnDef[]) => void;
-    pinnedLeftColumns: ColumnDef[];
-    pinnedLeftHeaderRef: RefObject<HTMLDivElement | null>;
-    pinnedRightColumns: ColumnDef[];
-    pinnedRightHeaderRef: RefObject<HTMLDivElement | null>;
-    rowHeight: number;
-    tableBodyContainerRef: RefObject<HTMLDivElement | null>;
-}
-export default SharedTableProps;

package/dist/types/TableBodyProps.d.ts

@@ -1,20 +0,0 @@
-import { ColumnDef } from "..";
-import TableRow from "./TableRow";
-import { CumulativeHeightMap } from "../utils/infiniteScrollUtils";
-interface TableBodyProps {
-    calculatedHeaderHeight: number;
-    heightMap?: CumulativeHeightMap;
-    partiallyVisibleRows: TableRow[];
-    pinnedLeftColumns: ColumnDef[];
-    pinnedLeftWidth: number;
-    pinnedRightColumns: ColumnDef[];
-    pinnedRightWidth: number;
-    regularRows: TableRow[];
-    rowsToRender: TableRow[];
-    setScrollDirection: (direction: "up" | "down" | "none") => void;
-    setScrollTop: (scrollTop: number) => void;
-    shouldShowEmptyState: boolean;
-    stickyParents: TableRow[];
-    tableRows: TableRow[];
-}
-export default TableBodyProps;

package/dist/types/TableHeaderProps.d.ts

@@ -1,17 +0,0 @@
-import SortColumn from "./SortColumn";
-import ColumnDef from "./ColumnDef";
-export interface RefObject<T> {
-    current: T | null;
-}
-type TableHeaderProps = {
-    calculatedHeaderHeight: number;
-    centerHeaderRef: RefObject<HTMLDivElement | null>;
-    headers: ColumnDef[];
-    mainBodyWidth: number;
-    pinnedLeftColumns: ColumnDef[];
-    pinnedLeftWidth: number;
-    pinnedRightColumns: ColumnDef[];
-    pinnedRightWidth: number;
-    sort: SortColumn | null;
-};
-export default TableHeaderProps;

package/dist/types/TableHeaderSectionProps.d.ts

@@ -1,19 +0,0 @@
-import { Pinned } from "./Pinned";
-import SortColumn from "./SortColumn";
-import { ColumnDef } from "..";
-import { ColumnIndices } from "../utils/columnIndicesUtils";
-interface TableHeaderSectionProps {
-    calculatedHeaderHeight: number;
-    columnIndices: ColumnIndices;
-    handleScroll?: (event: UIEvent) => void;
-    headers: ColumnDef[];
-    leftOffset?: number;
-    maxDepth: number;
-    pinned?: Pinned;
-    sectionRef: {
-        current: HTMLDivElement | null;
-    };
-    sort: SortColumn | null;
-    width?: number;
-}
-export default TableHeaderSectionProps;

package/dist/types/TableRowProps.d.ts

@@ -1,29 +0,0 @@
-import CellChangeProps from "./CellChangeProps";
-import ColumnDef from "./ColumnDef";
-import Row from "./Row";
-import Cell from "./Cell";
-type TableRowProps = {
-    currentRows: Row[];
-    draggedHeaderRef: {
-        current: ColumnDef | null;
-    };
-    getBorderClass: (rowIndex: number, columnIndex: number) => string;
-    handleMouseDown: (props: Cell) => void;
-    handleMouseOver: (rowIndex: number, columnIndex: number) => void;
-    headers: ColumnDef[];
-    hoveredHeaderRef: {
-        current: ColumnDef | null;
-    };
-    isSelected: (rowIndex: number, columnIndex: number) => boolean;
-    isInitialFocusedCell: (rowIndex: number, columnIndex: number) => boolean;
-    onCellEdit?: (props: CellChangeProps) => void;
-    onTableHeaderDragEnd: (newHeaders: ColumnDef[]) => void;
-    onToggleGroup: (rowId: number) => void;
-    row: Row;
-    rowIndex: number;
-    enablePagination: boolean;
-    tableRef: {
-        current: HTMLDivElement | null;
-    };
-};
-export default TableRowProps;

package/dist/utils/columnIndicesUtils.d.ts

@@ -1,15 +0,0 @@
-import ColumnDef, { Accessor } from "../types/ColumnDef";
-export type ColumnIndices = Record<string, number>;
-/**
- * Calculates column indices for all headers to ensure consistent colIndex values
- * This function is used in both TableBody and TableHeader components
- *
- * Note: In hierarchical headers, a parent header and its first child can share
- * the same column index, which is needed for proper alignment in the grid.
- */
-export declare function calculateColumnIndices({ headers, pinnedLeftColumns, pinnedRightColumns, collapsedHeaders, }: {
-    headers: ColumnDef[];
-    pinnedLeftColumns: ColumnDef[];
-    pinnedRightColumns: ColumnDef[];
-    collapsedHeaders?: Set<Accessor>;
-}): ColumnIndices;

package/dist/utils/columnVirtualizationUtils.d.ts

@@ -1,128 +0,0 @@
-import ColumnDef, { Accessor } from "../types/ColumnDef";
-import { Pinned } from "../types/Pinned";
-/**
- * Precomputed cumulative width data structure for O(1) column position lookups
- * and O(log n) viewport calculations (analogous to CumulativeHeightMap for rows)
- */
-export interface CumulativeWidthMap {
-    /** Array where index i contains the left pixel position of leaf column i */
-    columnLeftPositions: number[];
-    /** Total width of all columns combined */
-    totalWidth: number;
-    /** Ordered array of leaf headers (actual columns that render) */
-    leafHeaders: ColumnDef[];
-}
-/**
- * Get all leaf headers (actual columns that render) from a header tree
- * Handles nested headers, collapsed state, showWhen logic, and pinned sections
- *
- * Uses the existing displayCell utility to respect all visibility rules
- *
- * @param headers - Array of header objects (can be nested)
- * @param pinned - The pinned state for this section
- * @param allHeaders - All headers in the table (for displayCell context)
- * @param collapsedHeaders - Set of collapsed header accessors
- * @returns Flat array of leaf headers in order
- */
-export declare const getLeafHeaders: (headers: ColumnDef[], pinned: Pinned | undefined, allHeaders: ColumnDef[], collapsedHeaders?: Set<Accessor>) => ColumnDef[];
-/**
- * Build a cumulative width map for efficient viewport calculations
- * This precomputes the left position of every column, enabling:
- * - O(1) lookup of column left position
- * - O(log n) binary search to find columns in viewport
- *
- * Similar to buildCumulativeHeightMap for rows
- *
- * @param headers - Array of header objects for a section
- * @param pinned - The pinned state for this section
- * @param allHeaders - All headers in the table (for displayCell context)
- * @param collapsedHeaders - Set of collapsed header accessors
- * @returns Cumulative width map with column positions
- */
-export declare const buildCumulativeWidthMap: (headers: ColumnDef[], pinned: Pinned | undefined, allHeaders: ColumnDef[], collapsedHeaders?: Set<Accessor>) => CumulativeWidthMap;
-/**
- * Find the column index at a given scroll position using binary search
- * Returns the index of the column that contains or is closest to the scroll position
- *
- * Similar to findRowAtScrollPosition for rows
- *
- * @param scrollLeft - The horizontal scroll position in pixels
- * @param widthMap - Precomputed cumulative width map
- * @returns Column index at the scroll position
- */
-export declare const findColumnAtScrollPosition: (scrollLeft: number, widthMap: CumulativeWidthMap) => number;
-/**
- * Calculate visible columns for viewport with overscan buffer
- * Returns column indices and the actual leaf header objects to render
- *
- * Similar to getViewportCalculations for rows
- *
- * @param scrollLeft - Current horizontal scroll position
- * @param viewportWidth - Width of the visible viewport
- * @param bufferColumnCount - Number of columns to render outside viewport (overscan)
- * @param scrollDirection - Direction of scroll for asymmetric overscan
- * @param widthMap - Precomputed cumulative width map
- * @returns Object with startIndex, endIndex, and columns array (leaf columns only)
- */
-export declare const getVisibleColumns: ({ scrollLeft, viewportWidth, bufferColumnCount, scrollDirection, widthMap, }: {
-    scrollLeft: number;
-    viewportWidth: number;
-    bufferColumnCount: number;
-    scrollDirection?: "left" | "right" | "none";
-    widthMap: CumulativeWidthMap;
-}) => {
-    startIndex: number;
-    endIndex: number;
-    columns: ColumnDef[];
-};
-/**
- * Build parent-child relationship maps for the header hierarchy
- * This enables efficient lookup of ancestors for visible leaf columns
- *
- * @param headers - Array of top-level header objects
- * @param pinned - The pinned state for this section
- * @param allHeaders - All headers in the table (for displayCell context)
- * @param collapsedHeaders - Set of collapsed header accessors
- * @returns Maps for leaf-to-parents and parent-to-leaves relationships
- */
-export declare const buildColumnHierarchy: (headers: ColumnDef[], pinned: Pinned | undefined, allHeaders: ColumnDef[], collapsedHeaders?: Set<Accessor>) => {
-    leafToParents: Map<Accessor, Accessor[]>;
-    parentToLeaves: Map<Accessor, Accessor[]>;
-};
-/**
- * Get all headers to render (visible leaves + their ancestors)
- *
- * Strategy: Include a parent header if ANY of its children are visible
- *
- * @param visibleLeafColumns - Array of visible leaf header objects
- * @param leafToParents - Map from leaf accessor to parent accessor chain
- * @returns Set of all header accessors to render (leaves + ancestors)
- */
-export declare const getHeadersToRender: (visibleLeafColumns: ColumnDef[], leafToParents: Map<Accessor, Accessor[]>) => Set<Accessor>;
-/**
- * GridCell type (matches TableHeaderSection.tsx)
- * Represents a single header cell in the grid with its positioning
- */
-export type GridCell = {
-    header: ColumnDef;
-    gridColumnStart: number;
-    gridColumnEnd: number;
-    gridRowStart: number;
-    gridRowEnd: number;
-    colIndex: number;
-    parentHeader?: ColumnDef;
-};
-/**
- * Recalculate grid column positions for visible headers
- * Adjusts gridColumnStart/End to account for hidden columns before the viewport
- *
- * This is the key function that makes virtualization work - it offsets the grid
- * positions so that the visible subset appears correctly positioned
- *
- * @param originalGridCells - All grid cells from the full header tree
- * @param headersToRender - Set of header accessors that should be rendered
- * @param visibleLeafColumns - Array of visible leaf columns (for determining offset)
- * @param startColumnIndex - Index of first visible leaf column in the full leaf array
- * @returns Filtered and repositioned grid cells
- */
-export declare const recalculateGridPositions: (originalGridCells: GridCell[], headersToRender: Set<Accessor>, visibleLeafColumns: ColumnDef[], startColumnIndex: number) => GridCell[];