simple-table-core 2.6.3 → 2.6.6

package/dist/cjs/utils/columnVirtualizationUtils.d.ts

@@ -0,0 +1,86 @@
+import HeaderObject, { Accessor } from "../types/HeaderObject";
+import { Pinned } from "../types/Pinned";
+/**
+ * Column virtualization for the horizontally-scrollable (main) section.
+ *
+ * This mirrors the row virtualization approach (cumulative position map + binary
+ * search + asymmetric overscan) but for columns. The algorithm is ported from the
+ * `main` branch's `columnVirtualizationUtils.ts`; the integration differs: instead of
+ * recomputing CSS grid offsets, v2 keeps the full `grid-template-columns` track list
+ * and places each rendered cell into its real track via `grid-column`, so the leaf
+ * order here must match the grid produced by `createGridTemplateColumns`. That is
+ * guaranteed by deriving the leaf list from the shared `flattenColumnsForGrid`.
+ */
+/**
+ * Precomputed cumulative width data for O(1) column position lookups and
+ * O(log n) viewport calculations (analogous to CumulativeHeightMap for rows).
+ */
+export interface CumulativeWidthMap {
+    /** Left pixel position of each leaf column (index i -> left of column i) */
+    columnLeftPositions: number[];
+    /** Total nominal width of all leaf columns combined */
+    totalWidth: number;
+    /** Ordered leaf headers, 1:1 with the section's grid tracks */
+    leafHeaders: HeaderObject[];
+}
+/**
+ * Resolve a header's column width to pixels for position math.
+ *
+ * Only fixed widths (number or "Npx") are exact. fr/%/minmax/auto layouts can't be
+ * resolved without measuring the DOM, so we fall back to the column's numeric
+ * minWidth or a sensible default. This only affects which columns are *selected* for
+ * the window (mitigated by overscan); placement stays correct because cells are
+ * positioned by their real grid track via `grid-column`.
+ */
+export declare const getColumnWidthInPixels: (header: HeaderObject) => number;
+/**
+ * Build a cumulative width map for a section's headers. The leaf order matches the
+ * grid tracks created by `createGridTemplateColumns` (both use `flattenColumnsForGrid`).
+ */
+export declare const buildCumulativeWidthMap: ({ headers, collapsedHeaders, }: {
+    headers: HeaderObject[];
+    collapsedHeaders?: Set<string> | undefined;
+}) => CumulativeWidthMap;
+/**
+ * Find the leaf column index at a given horizontal scroll position using binary
+ * search. Returns the index of the column that contains (or is closest to) the
+ * position. Analogous to `findRowAtScrollPosition` for rows.
+ */
+export declare const findColumnAtScrollPosition: (scrollLeft: number, widthMap: CumulativeWidthMap) => number;
+/**
+ * Calculate the visible leaf columns for the viewport, with an overscan buffer.
+ * Returns the [startIndex, endIndex) range into the section's leaf array plus the
+ * leaf header objects in that range. Analogous to `getViewportCalculations` for rows.
+ */
+export declare const getVisibleColumns: ({ scrollLeft, viewportWidth, bufferColumnCount, scrollDirection, widthMap, }: {
+    scrollLeft: number;
+    viewportWidth: number;
+    bufferColumnCount: number;
+    scrollDirection?: "left" | "right" | "none" | undefined;
+    widthMap: CumulativeWidthMap;
+}) => {
+    startIndex: number;
+    endIndex: number;
+    columns: HeaderObject[];
+};
+/**
+ * Build the set of leaf accessors that should render for the current horizontal
+ * viewport, plus a map from accessor to its grid track index (0-based) so cells can
+ * be placed with `grid-column: <index + 1>`. Pinned sections never virtualize, so
+ * callers pass `null` to disable windowing.
+ */
+export interface ColumnWindow {
+    /** Leaf accessors currently within the viewport (+overscan) */
+    visibleAccessors: Set<Accessor>;
+    /** Leaf accessor -> 0-based grid track index within the section */
+    trackIndexByAccessor: Map<Accessor, number>;
+}
+export declare const buildColumnWindow: ({ headers, collapsedHeaders, scrollLeft, viewportWidth, bufferColumnCount, scrollDirection, pinned, }: {
+    headers: HeaderObject[];
+    collapsedHeaders?: Set<string> | undefined;
+    scrollLeft: number;
+    viewportWidth: number;
+    bufferColumnCount: number;
+    scrollDirection?: "left" | "right" | "none" | undefined;
+    pinned?: Pinned | undefined;
+}) => ColumnWindow | null;

package/dist/components/simple-table/RenderCells.d.ts

@@ -4,9 +4,11 @@ import type TableRowType from "../../types/TableRow";
 import { Pinned } from "../../types/Pinned";
 import RowIndices from "../../types/RowIndices";
 import ColumnIndices from "../../types/ColumnIndices";
+import { ColumnWindow } from "../../utils/columnVirtualizationUtils";
 interface RenderCellsProps {
     columnIndexStart?: number;
     columnIndices: ColumnIndices;
+    columnWindow?: ColumnWindow | null;
     headers: HeaderObject[];
     pinned?: Pinned;
     rowIndex: number;
@@ -14,5 +16,5 @@ interface RenderCellsProps {
     rowIndices: RowIndices;
     tableRow: TableRowType;
 }
-declare const _default: React.MemoExoticComponent<({ columnIndexStart, columnIndices, headers, pinned, rowIndex, displayRowNumber, rowIndices, tableRow, }: RenderCellsProps) => import("react/jsx-runtime").JSX.Element>;
+declare const _default: React.MemoExoticComponent<({ columnIndexStart, columnIndices, columnWindow, headers, pinned, rowIndex, displayRowNumber, rowIndices, tableRow, }: RenderCellsProps) => import("react/jsx-runtime").JSX.Element>;
 export default _default;

package/dist/components/simple-table/TableCell.d.ts

@@ -1,4 +1,4 @@
 import React from "react";
 import TableCellProps from "../../types/TableCellProps";
-declare const _default: React.MemoExoticComponent<({ borderClass, colIndex, displayRowNumber, header, isHighlighted, isInitialFocused, nestedIndex, parentHeader, rowIndex, tableRow, }: TableCellProps) => import("react/jsx-runtime").JSX.Element>;
+declare const _default: React.MemoExoticComponent<({ borderClass, colIndex, displayRowNumber, gridColumnStart, header, isHighlighted, isInitialFocused, nestedIndex, parentHeader, rowIndex, tableRow, }: TableCellProps) => import("react/jsx-runtime").JSX.Element>;
 export default _default;

package/dist/components/simple-table/TableRow.d.ts

@@ -4,9 +4,11 @@ import { Pinned } from "../../types/Pinned";
 import HeaderObject from "../../types/HeaderObject";
 import ColumnIndices from "../../types/ColumnIndices";
 import RowIndices from "../../types/RowIndices";
+import { ColumnWindow } from "../../utils/columnVirtualizationUtils";
 interface TableRowProps {
     columnIndexStart?: number;
     columnIndices: ColumnIndices;
+    columnWindow?: ColumnWindow | null;
     gridTemplateColumns: string;
     headers: HeaderObject[];
     index: number;
@@ -20,5 +22,5 @@ interface TableRowProps {
     stickyOffset?: number;
     stickyZIndex?: number;
 }
-declare const _default: React.MemoExoticComponent<({ columnIndices, columnIndexStart, gridTemplateColumns, headers, index, pinned, rowHeight, rowIndices, setHoveredIndex, tableRow, isSticky, stickyIndex, stickyOffset, stickyZIndex, }: TableRowProps) => import("react/jsx-runtime").JSX.Element>;
+declare const _default: React.MemoExoticComponent<({ columnIndices, columnIndexStart, columnWindow, gridTemplateColumns, headers, index, pinned, rowHeight, rowIndices, setHoveredIndex, tableRow, isSticky, stickyIndex, stickyOffset, stickyZIndex, }: TableRowProps) => import("react/jsx-runtime").JSX.Element>;
 export default _default;

package/dist/components/simple-table/TableSection.d.ts

@@ -4,9 +4,12 @@ import { Pinned } from "../../types/Pinned";
 import HeaderObject from "../../types/HeaderObject";
 import ColumnIndices from "../../types/ColumnIndices";
 import RowIndices from "../../types/RowIndices";
+import { ColumnWindow } from "../../utils/columnVirtualizationUtils";
 interface TableSectionProps {
     columnIndexStart?: number;
     columnIndices: ColumnIndices;
+    /** Visible-column window for this section, or null/undefined to render all columns (pinned sections). */
+    columnWindow?: ColumnWindow | null;
     headers: HeaderObject[];
     pinned?: Pinned;
     regularRows: TableRowType[];

package/dist/context/TableContext.d.ts

@@ -79,7 +79,6 @@ interface TableContextType {
     isLoading?: boolean;
     isResizing: boolean;
     isRowSelected?: (rowId: string) => boolean;
-    isScrolling: boolean;
     isSelected: (cell: Cell) => boolean;
     isWarningFlashing: (cell: Cell) => boolean;
     mainBodyRef: RefObject<HTMLDivElement | null>;
@@ -115,7 +114,6 @@ interface TableContextType {
     setHeaders: Dispatch<SetStateAction<HeaderObject[]>>;
     setInitialFocusedCell: Dispatch<SetStateAction<Cell | null>>;
     setIsResizing: Dispatch<SetStateAction<boolean>>;
-    setIsScrolling: Dispatch<SetStateAction<boolean>>;
     setSelectedCells: Dispatch<SetStateAction<Set<string>>>;
     setSelectedColumns: Dispatch<SetStateAction<Set<number>>>;
     setSelectedRows?: Dispatch<SetStateAction<Set<string>>>;
@@ -140,4 +138,12 @@ export declare const TableProvider: ({ children, value, }: {
     value: TableContextType;
 }) => import("react/jsx-runtime").JSX.Element;
 export declare const useTableContext: () => TableContextType;
+interface ScrollStateContextType {
+    isScrolling: boolean;
+    setIsScrolling: Dispatch<SetStateAction<boolean>>;
+}
+export declare const ScrollStateProvider: ({ children }: {
+    children: ReactNode;
+}) => import("react/jsx-runtime").JSX.Element;
+export declare const useScrollState: () => ScrollStateContextType;
 export {};

package/dist/hooks/useKeyboardNavigation.d.ts

@@ -4,7 +4,8 @@ import HeaderObject from "../types/HeaderObject";
 import type TableRowType from "../types/TableRow";
 interface UseKeyboardNavigationProps {
     selectableCells: boolean;
-    initialFocusedCell: Cell | null;
+    initialFocusedCellRef: React.MutableRefObject<Cell | null>;
+    selectedCellsRef: React.MutableRefObject<Set<string>>;
     tableRows: TableRowType[];
     leafHeaders: HeaderObject[];
     selectSingleCell: (cell: Cell) => void;
@@ -17,10 +18,9 @@ interface UseKeyboardNavigationProps {
     deleteSelectedCells: () => void;
     startCell: React.MutableRefObject<Cell | null>;
     enableRowSelection?: boolean;
-    selectedCells: Set<string>;
 }
 /**
  * Hook that handles keyboard navigation for cell selection
  */
-export declare const useKeyboardNavigation: ({ copyToClipboard, deleteSelectedCells, enableRowSelection, initialFocusedCell, leafHeaders, pasteFromClipboard, selectCellRange, selectSingleCell, selectableCells, selectedCells, setLastSelectedColumnIndex, setSelectedCells, setSelectedColumns, startCell, tableRows, }: UseKeyboardNavigationProps) => void;
+export declare const useKeyboardNavigation: ({ copyToClipboard, deleteSelectedCells, enableRowSelection, initialFocusedCellRef, leafHeaders, pasteFromClipboard, selectCellRange, selectSingleCell, selectableCells, selectedCellsRef, setLastSelectedColumnIndex, setSelectedCells, setSelectedColumns, startCell, tableRows, }: UseKeyboardNavigationProps) => void;
 export {};