simple-table-core 2.6.3 → 3.0.0-beta.6

package/dist/cjs/src/utils/headerCell/filtering.d.ts

@@ -0,0 +1,3 @@
+import HeaderObject from "../../types/HeaderObject";
+import { HeaderRenderContext } from "./types";
+export declare const createFilterIcon: (header: HeaderObject, context: HeaderRenderContext) => HTMLElement | null;

package/dist/cjs/src/utils/headerCell/resizing.d.ts

@@ -0,0 +1,3 @@
+import HeaderObject from "../../types/HeaderObject";
+import { HeaderRenderContext } from "./types";
+export declare const createResizeHandle: (header: HeaderObject, context: HeaderRenderContext, isLastHeader: boolean) => HTMLElement | null;

package/dist/cjs/src/utils/headerCell/selection.d.ts

@@ -0,0 +1,10 @@
+import { HeaderRenderContext } from "./types";
+/**
+ * Updates an existing header select-all checkbox to match the current checked state.
+ * Use when selection changes but the header cell DOM is reused (e.g. from cache).
+ */
+export declare const updateHeaderSelectionCheckbox: (cellElement: HTMLElement, checked: boolean) => void;
+/**
+ * Creates the header select-all checkbox using the shared createCheckbox (same as column editor popout).
+ */
+export declare const createSelectionCheckbox: (context: HeaderRenderContext) => HTMLElement;

package/dist/cjs/src/utils/headerCell/sorting.d.ts

@@ -0,0 +1,3 @@
+import HeaderObject from "../../types/HeaderObject";
+import { HeaderRenderContext } from "./types";
+export declare const createSortIcon: (header: HeaderObject, context: HeaderRenderContext) => HTMLElement | null;

package/dist/cjs/src/utils/headerCell/styling.d.ts

@@ -0,0 +1,5 @@
+import { AbsoluteCell, HeaderRenderContext } from "./types";
+export declare const calculateHeaderCellClasses: (cell: AbsoluteCell, context: HeaderRenderContext, isLastHeader: boolean) => string;
+export declare const createHeaderCellElement: (cell: AbsoluteCell, context: HeaderRenderContext, isLastHeader: boolean) => HTMLElement;
+export declare const getLastHeaderIndex: (absoluteCells: AbsoluteCell[]) => number;
+export declare const updateHeaderCellElement: (cellElement: HTMLElement, cell: AbsoluteCell, context: HeaderRenderContext, isLastHeader: boolean) => void;

package/dist/cjs/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/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/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/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/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/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/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[] | 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/cjs/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/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/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/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> | undefined;
+}) => number;

package/dist/cjs/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/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 | undefined;
+    collapsedHeaders?: Set<string> | undefined;
+}) => {
+    leftWidth: number;
+    rightWidth: number;
+    mainWidth: number;
+    leftContentWidth: number;
+    rightContentWidth: number;
+};

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

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

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

@@ -0,0 +1,30 @@
+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/cjs/stories/SimpleTable.stories.d.ts

@@ -0,0 +1,62 @@
+/**
+ * Docs & Examples – vanilla ports of React Storybook examples.
+ * Each story uses SimpleTableVanilla; example logic lives in stories/examples/.
+ */
+import type { Meta, StoryObj } from "@storybook/html";
+declare const meta: Meta;
+export default meta;
+export declare const AdvancedSorting: StoryObj;
+export declare const AggregateExample: StoryObj;
+export declare const Alignment: StoryObj;
+export declare const AutoExpandColumns: StoryObj;
+export declare const BasicExample: StoryObj;
+export declare const BasicRowGrouping: StoryObj;
+export declare const BillingExample: StoryObj;
+export declare const CSVExportFormatting: StoryObj;
+export declare const CSVExportSingleRowChildren: StoryObj;
+export declare const CellHighlighting: StoryObj;
+export declare const CellRenderer: StoryObj;
+export declare const Charts: StoryObj;
+export declare const ClayExample: StoryObj;
+export declare const ClipboardFormatting: StoryObj;
+export declare const CollapsibleColumns: StoryObj;
+export declare const ColumnVisibilityAPI: StoryObj;
+export declare const ColumnWidthChange: StoryObj;
+export declare const CustomHeaderRendering: StoryObj;
+export declare const CustomTheme: StoryObj;
+export declare const DynamicHeaders: StoryObj;
+export declare const DynamicNestedTableLoading: StoryObj;
+export declare const DynamicRowLoading: StoryObj;
+export declare const DynamicRowLoadingWithExternalSort: StoryObj;
+export declare const EditableCells: StoryObj;
+export declare const ExpansionControl: StoryObj;
+export declare const ExternalFilter: StoryObj;
+export declare const ExternalSort: StoryObj;
+export declare const FilterExample: StoryObj;
+export declare const FinanceExample: StoryObj;
+export declare const HeaderInclusion: StoryObj;
+export declare const HiddenColumns: StoryObj;
+export declare const InfiniteScroll: StoryObj;
+export declare const InfrastructureExample: StoryObj;
+export declare const LeadsExample: StoryObj;
+export declare const LiveUpdates: StoryObj;
+export declare const LoadingState: StoryObj;
+export declare const ManufacturingExample: StoryObj;
+export declare const MusicExample: StoryObj;
+export declare const NestedGrid: StoryObj;
+export declare const NestedAccessor: StoryObj;
+export declare const Pagination: StoryObj;
+export declare const PaginationAPI: StoryObj;
+export declare const PinnedColumns: StoryObj;
+export declare const ProgrammaticFilter: StoryObj;
+export declare const ProgrammaticSort: StoryObj;
+export declare const QuickFilter: StoryObj;
+export declare const RowButtons: StoryObj;
+export declare const RowGrouping: StoryObj;
+export declare const RowHeight: StoryObj;
+export declare const RowSelection: StoryObj;
+export declare const SalesExample: StoryObj;
+export declare const SelectableCells: StoryObj;
+export declare const ServerSidePagination: StoryObj;
+export declare const Theming: StoryObj;
+export declare const Tooltip: StoryObj;

package/dist/cjs/stories/data/aggregate-data.d.ts

@@ -0,0 +1,5 @@
+import { Row } from "../../src";
+/**
+ * Aggregate example data – same as React AggregateExample (streaming platforms with categories and creators).
+ */
+export declare const AGGREGATE_ROWS: Row[];

package/dist/cjs/stories/data/athlete-data.d.ts

@@ -0,0 +1,3 @@
+import type { Row, HeaderObject } from "../../src/index";
+export declare const generateAthletesData: () => Row[];
+export declare const ATHLETES_HEADERS: HeaderObject[];

package/dist/cjs/stories/data/retail-data.d.ts

@@ -0,0 +1,3 @@
+import type { Row, HeaderObject } from "../../src/index";
+export declare const generateRetailSalesData: () => Row[];
+export declare const RETAIL_SALES_HEADERS: HeaderObject[];

package/dist/cjs/stories/data/saas-data.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Vanilla-friendly SaaS data (no JSX). Use this from Storybook examples.
+ */
+import type { Row, HeaderObject } from "../../src/index";
+export declare const generateSaaSData: () => Row[];
+export declare const SAAS_HEADERS: HeaderObject[];

package/dist/cjs/stories/data/space-data.d.ts

@@ -0,0 +1,3 @@
+import type { Row, HeaderObject } from "../../src/index";
+export declare const generateSpaceData: () => Row[];
+export declare const SPACE_HEADERS: HeaderObject[];

package/dist/cjs/stories/examples/AdvancedSortingExample.d.ts

@@ -0,0 +1,6 @@
+import { type UniversalVanillaArgs } from "../vanillaStoryConfig";
+export declare const advancedSortingExampleDefaults: {
+    height: string;
+    maxHeight: string;
+};
+export declare function renderAdvancedSortingExample(args?: Partial<UniversalVanillaArgs>): HTMLElement;

package/dist/cjs/stories/examples/AggregateExample.d.ts

@@ -0,0 +1,7 @@
+import { type UniversalVanillaArgs } from "../vanillaStoryConfig";
+export declare const aggregateExampleDefaults: {
+    columnResizing: boolean;
+    height: string;
+    rowGrouping: readonly ["categories", "creators"];
+};
+export declare function renderAggregateExample(args?: Partial<UniversalVanillaArgs>): HTMLElement;

package/dist/cjs/stories/examples/AlignmentExample.d.ts

@@ -0,0 +1,10 @@
+import { type UniversalVanillaArgs } from "../vanillaStoryConfig";
+export declare const alignmentExampleDefaults: {
+    columnResizing: boolean;
+    columnReordering: boolean;
+    selectableCells: boolean;
+    selectableColumns: boolean;
+    editColumns: boolean;
+    height: string;
+};
+export declare function renderAlignmentExample(args?: Partial<UniversalVanillaArgs>): HTMLElement;

package/dist/cjs/stories/examples/AutoExpandColumnsExample.d.ts

@@ -0,0 +1,7 @@
+import { type UniversalVanillaArgs } from "../vanillaStoryConfig";
+export declare const autoExpandColumnsExampleDefaults: {
+    autoExpandColumns: boolean;
+    columnResizing: boolean;
+    height: string;
+};
+export declare function renderAutoExpandColumnsExample(args?: Partial<UniversalVanillaArgs>): HTMLElement;

package/dist/cjs/stories/examples/BasicExample.d.ts

@@ -0,0 +1,11 @@
+import { type UniversalVanillaArgs } from "../vanillaStoryConfig";
+import type { Row } from "../../src/index";
+export declare const basicExampleDefaults: {
+    columnResizing: boolean;
+    editColumns: boolean;
+    selectableCells: boolean;
+    columnReordering: boolean;
+    height: string;
+};
+export declare function createBasicData(rowLength: number): Row[];
+export declare function renderBasicExample(args?: Partial<UniversalVanillaArgs>): HTMLElement;

package/dist/cjs/stories/examples/BasicRowGrouping.d.ts

@@ -0,0 +1,7 @@
+import { type UniversalVanillaArgs } from "../vanillaStoryConfig";
+export declare const basicRowGroupingExampleDefaults: {
+    rowGrouping: readonly ["divisions", "departments"];
+    enableStickyParents: boolean;
+    height: string;
+};
+export declare function renderBasicRowGroupingExample(args?: Partial<UniversalVanillaArgs>): HTMLElement;