@simple-table/angular 3.0.0-beta.8

package/dist/cjs/core/src/utils/headerCell/types.d.ts

@@ -0,0 +1,75 @@
+import HeaderObject, { Accessor } from "../../types/HeaderObject";
+import SortColumn from "../../types/SortColumn";
+import { TableFilterState, FilterCondition } from "../../types/FilterTypes";
+import { IconsConfig } from "../../types/IconsConfig";
+import Row from "../../types/Row";
+type SetStateAction<T> = T | ((prevState: T) => T);
+type Dispatch<A> = (value: A) => void;
+type MutableRefObject<T> = {
+    current: T;
+};
+type RefObject<T> = {
+    readonly current: T | null;
+};
+export interface AbsoluteCell {
+    header: HeaderObject;
+    left: number;
+    top: number;
+    width: number;
+    height: number;
+    colIndex: number;
+    parentHeader?: HeaderObject;
+}
+export interface HeaderRenderContext {
+    areAllRowsSelected?: () => boolean;
+    autoExpandColumns: boolean;
+    collapsedHeaders: Set<Accessor>;
+    essentialAccessors?: ReadonlySet<string>;
+    columnBorders: boolean;
+    columnReordering: boolean;
+    columnResizing: boolean;
+    columnsWithSelectedCells: Set<number>;
+    containerWidth: number;
+    draggedHeaderRef: MutableRefObject<HeaderObject | null>;
+    enableHeaderEditing?: boolean;
+    enableRowSelection?: boolean;
+    filters: TableFilterState;
+    forceUpdate: () => void;
+    getCollapsedHeaders?: () => Set<Accessor>; /** Get current collapsed headers (avoids stale closure in toggle handler). */
+    handleApplyFilter: (filter: FilterCondition) => void;
+    handleClearFilter: (accessor: Accessor) => void;
+    handleSelectAll?: (checked: boolean) => void;
+    headerHeight: number;
+    headerRegistry?: Map<string, {
+        setEditing: (editing: boolean) => void;
+    }>;
+    headers: HeaderObject[];
+    hoveredHeaderRef: MutableRefObject<HeaderObject | null>;
+    icons: IconsConfig;
+    lastHeaderIndex: number;
+    mainBodyRef: RefObject<HTMLDivElement>;
+    mainSectionContainerWidth?: number; /** Main section viewport width (avoids clientWidth read when set); use for getVisibleCells when !pinned */
+    onColumnOrderChange?: (headers: HeaderObject[]) => void;
+    onColumnSelect?: (header: HeaderObject) => void;
+    onColumnWidthChange?: (headers: HeaderObject[]) => void;
+    onHeaderEdit?: (header: HeaderObject, newLabel: string) => void;
+    onSort: (accessor: Accessor) => void;
+    onTableHeaderDragEnd: (headers: HeaderObject[]) => void;
+    pinned?: "left" | "right";
+    pinnedLeftRef: RefObject<HTMLDivElement>;
+    pinnedRightRef: RefObject<HTMLDivElement>;
+    reverse: boolean;
+    rows: Row[];
+    selectColumns?: (columnIndices: number[]) => void;
+    selectableColumns?: boolean;
+    selectedColumns: Set<number>;
+    selectedRowCount?: number; /** Used for context cache invalidation when row selection changes */
+    setCollapsedHeaders: Dispatch<SetStateAction<Set<Accessor>>>;
+    setHeaders: Dispatch<SetStateAction<HeaderObject[]>>;
+    setInitialFocusedCell: (cell: any) => void;
+    setIsResizing: Dispatch<SetStateAction<boolean>>;
+    setSelectedCells: Dispatch<SetStateAction<Set<string>>>;
+    setSelectedColumns: Dispatch<SetStateAction<Set<number>>>;
+    sort: SortColumn | null;
+}
+export {};

package/dist/cjs/core/src/utils/headerCellRenderer.d.ts

@@ -0,0 +1,4 @@
+import { AbsoluteCell, HeaderRenderContext } from "./headerCell/types";
+export type { AbsoluteCell, HeaderRenderContext } from "./headerCell/types";
+export { cleanupHeaderCellRendering } from "./headerCell/eventTracking";
+export declare const renderHeaderCells: (container: HTMLElement, absoluteCells: AbsoluteCell[], context: HeaderRenderContext, scrollLeft?: number) => void;

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

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

@@ -0,0 +1,56 @@
+import HeaderObject, { Accessor } from "../types/HeaderObject";
+/**
+ * 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;
+/**
+ * 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, the main section's fr columns are given the remaining space
+ * (container width minus pinned left/right), so the flexible column fills available space.
+ */
+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[];
+/**
+ * Convert pixel-based widths to proportional fr units
+ * This is used when autoExpandColumns is enabled
+ */
+export declare const convertPixelWidthsToFr: (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 The optimal width in pixels
+ */
+export declare const calculateHeaderContentWidth: (accessor: Accessor, options?: {
+    rows?: any[];
+    header?: HeaderObject;
+    maxWidth?: number;
+    sampleSize?: number;
+}) => number;

package/dist/cjs/core/src/utils/horizontalScrollbarRenderer.d.ts

@@ -0,0 +1,14 @@
+import type { SectionScrollController } from "../managers/SectionScrollController";
+export interface HorizontalScrollbarProps {
+    mainBodyRef: HTMLDivElement;
+    mainBodyWidth: number;
+    pinnedLeftWidth: number;
+    pinnedRightWidth: number;
+    pinnedLeftContentWidth: number;
+    pinnedRightContentWidth: number;
+    tableBodyContainerRef: HTMLDivElement;
+    editColumns: boolean;
+    sectionScrollController?: SectionScrollController | null;
+}
+export declare const createHorizontalScrollbar: (props: HorizontalScrollbarProps) => HTMLElement | null;
+export declare const cleanupHorizontalScrollbar: (container: HTMLElement, sectionScrollController?: SectionScrollController | null) => void;

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

@@ -0,0 +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";
+    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/cjs/core/src/utils/nestedGridRowRenderer.d.ts

@@ -0,0 +1,34 @@
+/**
+ * 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";
+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"];
+}
+/**
+ * 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/cjs/core/src/utils/pinnedColumnUtils.d.ts

@@ -0,0 +1,25 @@
+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 (append within target section). */
+export declare function moveRootColumnPinSide(headers: HeaderObject[], accessor: Accessor, target: Exclude<PanelSection, "main"> | "main", essentialAccessors: ReadonlySet<string>): HeaderObject[] | null;

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

@@ -0,0 +1,14 @@
+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/cjs/core/src/utils/resizeUtils/autoExpandResize.d.ts

@@ -0,0 +1,21 @@
+import type HeaderObject from "../../types/HeaderObject";
+import type { Pinned } from "../../types/Pinned";
+/**
+ * Handle resize with autoExpandColumns enabled
+ * Columns to the right (or left for right-pinned) shrink proportionally
+ */
+export declare const handleResizeWithAutoExpand: ({ childrenToResize, collapsedHeaders, containerWidth, delta, headers, initialWidthsMap, isParentResize, resizedHeader, reverse, rootPinned, sectionHeaders, sectionWidth, startWidth, }: {
+    childrenToResize?: HeaderObject[];
+    collapsedHeaders?: Set<string>;
+    containerWidth: number;
+    delta: number;
+    headers: HeaderObject[];
+    initialWidthsMap: Map<string, number>;
+    isParentResize?: boolean;
+    resizedHeader: HeaderObject;
+    reverse: boolean;
+    rootPinned: Pinned | undefined;
+    sectionHeaders: HeaderObject[];
+    sectionWidth: number;
+    startWidth: number;
+}) => void;

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

@@ -0,0 +1,11 @@
+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
+ */
+export declare const distributeCompensationProportionally: ({ columnsToShrink, totalCompensation, initialWidthsMap, }: {
+    columnsToShrink: HeaderObject[];
+    totalCompensation: number;
+    initialWidthsMap: Map<string, number>;
+}) => void;

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

@@ -0,0 +1,15 @@
+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/cjs/core/src/utils/resizeUtils/index.d.ts

@@ -0,0 +1,5 @@
+import type { HandleResizeStartProps } from "../../types/HandleResizeStartProps";
+/**
+ * Handler for when resize dragging starts
+ */
+export declare const handleResizeStart: ({ autoExpandColumns, collapsedHeaders, containerWidth, event, header, headers, onColumnWidthChange, reverse, setHeaders, setIsResizing, startWidth, }: HandleResizeStartProps) => void;

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

@@ -0,0 +1,9 @@
+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>;
+}) => number;

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

@@ -0,0 +1,11 @@
+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/cjs/core/src/utils/resizeUtils/sectionWidths.d.ts

@@ -0,0 +1,16 @@
+import type HeaderObject from "../../types/HeaderObject";
+/**
+ * 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;
+    collapsedHeaders?: Set<string>;
+}) => {
+    leftWidth: number;
+    rightWidth: number;
+    mainWidth: number;
+    leftContentWidth: number;
+    rightContentWidth: number;
+};

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

@@ -0,0 +1,30 @@
+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/cjs/core/src/utils/rowProcessing.d.ts

@@ -0,0 +1,36 @@
+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;
+}
+export declare function processRows(config: ProcessRowsConfig): ProcessRowsResult;

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

@@ -0,0 +1,39 @@
+import Row from "../types/Row";
+import TableRow from "../types/TableRow";
+import HeaderObject from "../types/HeaderObject";
+/**
+ * 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
+ */
+export declare const toggleRowSelection: (rowId: string, selectedRows: 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[];
+/**
+ * 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/cjs/core/src/utils/rowSeparatorRenderer.d.ts

@@ -0,0 +1,12 @@
+import { HeightOffsets } from "./infiniteScrollUtils";
+import { CustomTheme } from "../types/CustomTheme";
+export interface CreateRowSeparatorOptions {
+    position: number;
+    rowHeight: number;
+    displayStrongBorder: boolean;
+    heightOffsets?: HeightOffsets;
+    customTheme?: CustomTheme;
+    isSticky?: boolean;
+}
+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;