@simple-table/solid 3.0.0-beta.12 → 3.0.0-beta.14

package/dist/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/core/src/utils/nestedGridRowRenderer.d.ts

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

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

package/dist/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/core/src/utils/resizeUtils/autoExpandResize.d.ts

@@ -1,21 +0,0 @@
-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[] | 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;
-    startWidth: number;
-}) => void;

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

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

package/dist/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/core/src/utils/resizeUtils/index.d.ts

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

@@ -1,16 +0,0 @@
-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 | undefined;
-    collapsedHeaders?: Set<string> | undefined;
-}) => {
-    leftWidth: number;
-    rightWidth: number;
-    mainWidth: number;
-    leftContentWidth: number;
-    rightContentWidth: number;
-};

package/dist/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/core/src/utils/rowProcessing.d.ts

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

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

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

@@ -1,12 +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;
-}
-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;

package/dist/core/src/utils/rowUtils.d.ts

@@ -1,136 +0,0 @@
-import TableRow from "../types/TableRow";
-import Row from "../types/Row";
-import HeaderObject, { Accessor } from "../types/HeaderObject";
-import CellValue from "../types/CellValue";
-import RowState from "../types/RowState";
-import { CustomTheme } from "../types/CustomTheme";
-import { GetRowId } from "../types/GetRowId";
-import { GenerateRowIdParams } from "../types/GenerateRowIdParams";
-/**
- * Calculate the height of a nested grid based on the number of child rows
- * @param childRowCount - Number of rows in the nested grid
- * @param rowHeight - Height of each row
- * @param headerHeight - Height of the header
- * @param customTheme - Custom theme configuration
- * @returns Calculated height in pixels (includes padding, borders, row separators, and header border)
- */
-export declare const calculateNestedGridHeight: ({ childRowCount, rowHeight, headerHeight, customTheme, }: {
-    childRowCount: number;
-    rowHeight: number;
-    headerHeight: number;
-    customTheme: CustomTheme;
-}) => number;
-/**
- * Calculate the final wrapper height for a nested grid, accounting for custom heights
- *
- * @param calculatedHeight - The default calculated height based on child rows
- * @param customHeight - Optional custom height from nestedTable config (e.g., "200px" or 200)
- * @param customTheme - Custom theme configuration for padding
- * @returns Final height in pixels for the wrapper (includes padding)
- */
-export declare const calculateFinalNestedGridHeight: ({ calculatedHeight, customHeight, customTheme, }: {
-    calculatedHeight: number;
-    customHeight?: string | number | undefined;
-    customTheme: CustomTheme;
-}) => number;
-/**
- * Calculate the inner height for a nested SimpleTable component
- * This accounts for the padding that's applied to the wrapper
- *
- * @param calculatedHeight - The total height of the nested grid row (from calculateNestedGridHeight)
- * @param customHeight - Optional custom height from nestedTable config (e.g., "200px")
- * @param customTheme - Custom theme configuration for padding
- * @returns Height value to pass to the nested SimpleTable (string with units)
- */
-export declare const calculateNestedTableHeight: ({ calculatedHeight, customHeight, customTheme, }: {
-    calculatedHeight: number;
-    customHeight?: string | number | undefined;
-    customTheme: CustomTheme;
-}) => string;
-/**
- * Get a nested property value from an object using dot notation and array bracket notation
- * Examples:
- *   getNestedValue(row, "latest.rank") returns row.latest.rank
- *   getNestedValue(row, "albums[0].title") returns row.albums[0].title
- *   getNestedValue(row, "releaseDate[0]") returns row.releaseDate[0]
- */
-export declare const getNestedValue: (obj: Row, path: Accessor) => CellValue;
-/**
- * Set a nested property value in an object using dot notation and array bracket notation
- * Examples:
- *   setNestedValue(row, "latest.rank", 5) sets row.latest.rank = 5
- *   setNestedValue(row, "albums[0].title", "New Album") sets row.albums[0].title = "New Album"
- *   setNestedValue(row, "releaseDate[0]", "2024") sets row.releaseDate[0] = "2024"
- */
-export declare const setNestedValue: (obj: Row, path: Accessor, value: CellValue) => void;
-/**
- * Check if an array contains Row objects (vs primitive arrays like string[] or number[])
- */
-export declare const isRowArray: (data: any) => data is Row[];
-/**
- * Generate the row ID array from index path and optional custom identifier.
- *
- * The row ID is always an array that includes:
- * - The index at each level of nesting
- * - The grouping key between levels (for readability)
- * - An optional custom identifier from getRowId (appended at the end)
- *
- * Examples:
- * - Root row (index 1): [1]
- * - Nested store (parent index 1, store index 5): [1, "stores", 5]
- * - With custom ID: [1, "stores", 5, "STORE-101"]
- * - Deep nesting: [1, "stores", 5, "products", 2, "PROD-24"]
- *
- * @param params - Object containing row data, getRowId function, and metadata
- * @returns An array representing the unique row ID path
- */
-export declare const generateRowId: (params: GenerateRowIdParams) => (string | number)[];
-/**
- * Convert a row ID array to a string for use as Map keys, Set members, etc.
- *
- * @param rowId - Array of strings/numbers representing the row ID path
- * @returns A string representation of the row ID
- */
-export declare const rowIdToString: (rowId: (string | number)[]) => string;
-/**
- * Get nested rows from a row based on the grouping path
- */
-export declare const getNestedRows: (row: Row, groupingKey: string) => Row[];
-/**
- * Check if a row has nested rows for a given grouping key
- */
-export declare const hasNestedRows: (row: Row, groupingKey?: string) => boolean;
-/**
- * Determine if a row is expanded based on expandedDepths and manual row overrides
- * @param rowId - The ID of the row to check
- * @param depth - The depth level of the row (0-indexed)
- * @param expandedDepths - Set of depth levels that are expanded
- * @param expandedRows - Map of row IDs to their depths for rows that user wants expanded
- * @param collapsedRows - Map of row IDs to their depths for rows that user wants collapsed
- * @returns true if the row is expanded, false otherwise
- */
-export declare const isRowExpanded: (rowId: string | number, depth: number, expandedDepths: Set<number>, expandedRows: Map<string, number>, collapsedRows: Map<string, number>) => boolean;
-/**
- * Flatten rows recursively based on row grouping configuration
- * Now calculates ALL properties including position and isLastGroupRow
- * Also injects special state rows for loading/error/empty states (only if renderers are available)
- * Also injects nested grid rows when a header has nestedTable configuration
- */
-export declare const flattenRowsWithGrouping: ({ depth, expandedDepths, expandedRows, collapsedRows, rowGrouping, getRowId, rows, displayPositionOffset, rowStateMap, hasLoadingRenderer, hasErrorRenderer, hasEmptyRenderer, headers, rowHeight, headerHeight, customTheme, }: {
-    depth?: number | undefined;
-    expandedDepths: Set<number>;
-    expandedRows: Map<string, number>;
-    collapsedRows: Map<string, number>;
-    rowGrouping?: string[] | undefined;
-    getRowId?: GetRowId | undefined;
-    rows: Row[];
-    displayPositionOffset?: number | undefined;
-    rowStateMap?: Map<string | number, RowState> | undefined;
-    hasLoadingRenderer?: boolean | undefined;
-    hasErrorRenderer?: boolean | undefined;
-    hasEmptyRenderer?: boolean | undefined;
-    headers?: HeaderObject[] | undefined;
-    rowHeight: number;
-    headerHeight: number;
-    customTheme: CustomTheme;
-}) => TableRow[];

package/dist/core/src/utils/sortUtils.d.ts

@@ -1,8 +0,0 @@
-import HeaderObject from "../types/HeaderObject";
-import Row from "../types/Row";
-import SortColumn from "../types/SortColumn";
-export declare const handleSort: ({ headers, rows, sortColumn, }: {
-    headers: HeaderObject[];
-    rows: Row[];
-    sortColumn: SortColumn;
-}) => Row[];

package/dist/core/src/utils/stateRowRenderer.d.ts

@@ -1,15 +0,0 @@
-import type TableRowType from "../types/TableRow";
-import { HeightOffsets } from "./infiniteScrollUtils";
-import { CustomTheme } from "../types/CustomTheme";
-import { LoadingStateRenderer, ErrorStateRenderer, EmptyStateRenderer } from "../types/RowStateRendererProps";
-export interface StateRowRenderContext {
-    index: number;
-    rowHeight: number;
-    heightOffsets: HeightOffsets | undefined;
-    customTheme: CustomTheme;
-    loadingStateRenderer?: LoadingStateRenderer;
-    errorStateRenderer?: ErrorStateRenderer;
-    emptyStateRenderer?: EmptyStateRenderer;
-}
-export declare const createStateRow: (tableRow: TableRowType, context: StateRowRenderContext) => HTMLElement;
-export declare const cleanupStateRow: (rowElement: HTMLElement) => void;

package/dist/core/src/utils/stickyParentsRenderer.d.ts

@@ -1,30 +0,0 @@
-import TableRow from "../types/TableRow";
-import HeaderObject from "../types/HeaderObject";
-import { CumulativeHeightMap, HeightOffsets } from "./infiniteScrollUtils";
-import type { SectionScrollController } from "../managers/SectionScrollController";
-import { CustomTheme } from "../types/CustomTheme";
-import { CellRenderContext } from "./bodyCell/types";
-export interface StickyParentsContainerProps {
-    calculatedHeaderHeight: number;
-    heightMap?: CumulativeHeightMap;
-    partiallyVisibleRows: TableRow[];
-    pinnedLeftColumns: HeaderObject[];
-    pinnedLeftWidth: number;
-    pinnedRightColumns: HeaderObject[];
-    pinnedRightWidth: number;
-    scrollTop: number;
-    scrollbarWidth: number;
-    stickyParents: TableRow[];
-}
-export interface StickyParentsRenderContext {
-    collapsedHeaders: Set<string>;
-    customTheme: CustomTheme;
-    editColumns: boolean;
-    headers: HeaderObject[];
-    rowHeight: number;
-    heightOffsets: HeightOffsets | undefined;
-    cellRenderContext: CellRenderContext;
-    sectionScrollController?: SectionScrollController | null;
-}
-export declare const createStickyParentsContainer: (props: StickyParentsContainerProps, context: StickyParentsRenderContext) => HTMLElement | null;
-export declare const cleanupStickyParentsContainer: (container: HTMLElement, sectionScrollController?: SectionScrollController | null) => void;

package/dist/solid/src/SimpleTable.d.ts

@@ -1,19 +0,0 @@
-import type { SimpleTableSolidProps } from "./types";
-/**
- * SimpleTable — Solid.js adapter for simple-table-core.
- *
- * Accepts the same props as SimpleTableProps (the vanilla user-facing API) but
- * with Solid component types for all renderer props.
- *
- * Pass a callback `ref` prop to receive the full TableAPI imperative interface:
- *
- * @example
- * let tableApi: TableAPI | undefined;
- *
- * <SimpleTable
- *   ref={(api) => (tableApi = api)}
- *   rows={rows()}
- *   defaultHeaders={headers}
- * />
- */
-export declare function SimpleTable(props: SimpleTableSolidProps): import("solid-js").JSX.Element;