@simple-table/vue 3.0.0-beta.10

package/dist/cjs/core/src/consts/column-constraints.d.ts

@@ -0,0 +1,58 @@
+/**
+ * Column width constraints for the table
+ * These values control minimum and maximum widths for columns and sections
+ */
+/**
+ * MIN_COLUMN_WIDTH
+ * The minimum width in pixels that any column can have.
+ * This is used as:
+ * - The default minimum width when header.minWidth is undefined
+ * - The absolute minimum in autoExpandColumns mode to prevent columns from becoming too narrow
+ */
+export declare const MIN_COLUMN_WIDTH = 40;
+/**
+ * MAX_SINGLE_PINNED_SECTION_PERCENT
+ * Maximum percentage of container width that a single pinned section can occupy.
+ * When only one section (left OR right) is pinned, it can take up to 60% of the width.
+ * This ensures the main section always has at least 40% of the space.
+ */
+export declare const MAX_SINGLE_PINNED_SECTION_PERCENT = 0.6;
+/**
+ * MAX_DUAL_PINNED_SECTION_PERCENT
+ * Maximum percentage of container width that each pinned section can occupy
+ * when BOTH left and right sections are pinned.
+ * With both sections at 40%, the main section is guaranteed at least 20% of the space.
+ */
+export declare const MAX_DUAL_PINNED_SECTION_PERCENT = 0.4;
+/**
+ * Mobile breakpoints for responsive pinned section constraints
+ */
+export declare const MOBILE_BREAKPOINT_SMALL = 480;
+export declare const MOBILE_BREAKPOINT_MEDIUM = 768;
+/**
+ * Get the maximum allowed width percentage for a single pinned section based on container width.
+ * This is used when only ONE section (left OR right) is pinned.
+ *
+ * @param containerWidth - The table container width in pixels (st-body-container)
+ * @returns The maximum percentage (0-1) of container width that the pinned section can occupy
+ */
+export declare const getMaxSinglePinnedPercent: (containerWidth: number) => number;
+/**
+ * Get the maximum allowed width percentage for pinned sections based on container width
+ * and the number of pinned sections.
+ *
+ * @param containerWidth - The table container width in pixels (st-body-container)
+ * @param hasPinnedLeft - Whether there is a pinned left section
+ * @param hasPinnedRight - Whether there is a pinned right section
+ * @returns The maximum percentage (0-1) of container width that each pinned section can occupy
+ */
+export declare const getMaxPinnedSectionPercent: (containerWidth: number, hasPinnedLeft: boolean, hasPinnedRight: boolean) => number;
+/**
+ * Calculate the maximum width in pixels for a pinned section
+ *
+ * @param containerWidth - The table container width in pixels (st-body-container)
+ * @param hasPinnedLeft - Whether there is a pinned left section
+ * @param hasPinnedRight - Whether there is a pinned right section
+ * @returns The maximum width in pixels for a pinned section
+ */
+export declare const getMaxPinnedSectionWidth: (containerWidth: number, hasPinnedLeft: boolean, hasPinnedRight: boolean) => number;

package/dist/cjs/core/src/consts/general-consts.d.ts

@@ -0,0 +1,13 @@
+export declare const DRAG_THROTTLE_LIMIT = 50;
+export declare const ROW_SEPARATOR_WIDTH = 1;
+export declare const PAGE_SIZE = 20;
+export declare const CSS_VAR_BORDER_WIDTH = "--st-border-width";
+export declare const DEFAULT_BORDER_WIDTH = 1;
+export declare const VIRTUALIZATION_THRESHOLD = 20;
+export declare const OVERSCAN_PIXELS = 800;
+export declare const calculateBufferRowCount: (rowHeight: number) => number;
+export declare const COLUMN_EDIT_WIDTH = 29.5;
+export declare const TABLE_HEADER_CELL_WIDTH_DEFAULT = 150;
+export declare const PINNED_BORDER_WIDTH = 1;
+export declare const CHART_COLUMN_TYPES: string[];
+export declare const OPTIMAL_CHART_COLUMN_WIDTH = 150;

package/dist/cjs/core/src/core/SimpleTableVanilla.d.ts

@@ -0,0 +1,71 @@
+import { SimpleTableConfig } from "../types/SimpleTableConfig";
+import { TableAPI } from "../types/TableAPI";
+import "../styles/all-themes.css";
+export declare class SimpleTableVanilla {
+    private container;
+    private config;
+    private customTheme;
+    private mergedColumnEditorConfig;
+    private resolvedIcons;
+    private domManager;
+    private renderOrchestrator;
+    private draggedHeaderRef;
+    private hoveredHeaderRef;
+    private localRows;
+    private headers;
+    private essentialAccessors;
+    private currentPage;
+    private scrollTop;
+    private scrollDirection;
+    private isResizing;
+    private isScrolling;
+    /** True when this render is scroll-driven so body can use position-only updates for existing cells. */
+    private _positionOnlyBody;
+    private firstRenderDone;
+    private internalIsLoading;
+    private scrollbarWidth;
+    private isMainSectionScrollable;
+    private columnEditorOpen;
+    private collapsedHeaders;
+    private expandedDepths;
+    private expandedRows;
+    private collapsedRows;
+    private rowStateMap;
+    private announcement;
+    private cellRegistry;
+    private headerRegistry;
+    private rowIndexMap;
+    private autoScaleManager;
+    private dimensionManager;
+    private scrollManager;
+    private sectionScrollController;
+    private sortManager;
+    private filterManager;
+    private selectionManager;
+    private rowSelectionManager;
+    private windowResizeManager;
+    private handleOutsideClickManager;
+    private scrollbarVisibilityManager;
+    private expandedDepthsManager;
+    private ariaAnnouncementManager;
+    private mounted;
+    private scrollRafId;
+    private scrollEndTimeoutId;
+    private lastScrollTop;
+    private isUpdating;
+    constructor(container: HTMLElement, config: SimpleTableConfig);
+    private rebuildRowIndexMap;
+    private initializeManagers;
+    mount(): void;
+    private setupManagers;
+    private setupEventListeners;
+    private handleScroll;
+    private clearHoveredRows;
+    private updateAriaLiveRegion;
+    private getRenderContext;
+    private getRenderState;
+    private render;
+    update(config: Partial<SimpleTableConfig>): void;
+    destroy(): void;
+    getAPI(): TableAPI;
+}

package/dist/cjs/core/src/core/api/TableAPIImpl.d.ts

@@ -0,0 +1,44 @@
+import { TableAPI } from "../../types/TableAPI";
+import { SimpleTableConfig } from "../../types/SimpleTableConfig";
+import HeaderObject from "../../types/HeaderObject";
+import Row from "../../types/Row";
+import { CustomTheme } from "../../types/CustomTheme";
+import RowState from "../../types/RowState";
+import { SelectionManager } from "../../managers/SelectionManager";
+import { SortManager } from "../../managers/SortManager";
+import { FilterManager } from "../../managers/FilterManager";
+import { FlattenRowsResult } from "../../utils/rowFlattening";
+import { ProcessRowsResult } from "../../utils/rowProcessing";
+export interface TableAPIContext {
+    config: SimpleTableConfig;
+    localRows: Row[];
+    effectiveHeaders: HeaderObject[];
+    headers: HeaderObject[];
+    essentialAccessors: Set<string>;
+    customTheme: CustomTheme;
+    currentPage: number;
+    /** Returns current page from live state (use this in API getCurrentPage so it stays correct after setPage). */
+    getCurrentPage: () => number;
+    expandedRows: Map<string, number>;
+    collapsedRows: Map<string, number>;
+    expandedDepths: Set<number>;
+    rowStateMap: Map<string | number, RowState>;
+    headerRegistry: Map<string, any>;
+    cellRegistry?: Map<string, {
+        updateContent: (value: any) => void;
+    }>;
+    columnEditorOpen: boolean;
+    expandedDepthsManager: any;
+    selectionManager: SelectionManager | null;
+    sortManager: SortManager | null;
+    filterManager: FilterManager | null;
+    getCachedFlattenResult?: () => FlattenRowsResult | null;
+    getCachedProcessedResult?: () => ProcessRowsResult | null;
+    onRender: () => void;
+    setHeaders: (headers: HeaderObject[]) => void;
+    setCurrentPage: (page: number) => void;
+    setColumnEditorOpen: (open: boolean) => void;
+}
+export declare class TableAPIImpl {
+    static createAPI(context: TableAPIContext): TableAPI;
+}

package/dist/cjs/core/src/core/dom/DOMManager.d.ts

@@ -0,0 +1,50 @@
+import { SimpleTableConfig } from "../../types/SimpleTableConfig";
+export interface DOMElements {
+    rootElement: HTMLElement;
+    wrapperContainer: HTMLElement;
+    contentWrapper: HTMLElement;
+    content: HTMLElement;
+    headerContainer: HTMLElement;
+    bodyContainer: HTMLElement;
+    footerContainer: HTMLElement;
+    ariaLiveRegion: HTMLElement;
+}
+export interface DOMRefs {
+    mainBodyRef: {
+        current: HTMLDivElement | null;
+    };
+    pinnedLeftRef: {
+        current: HTMLDivElement | null;
+    };
+    pinnedRightRef: {
+        current: HTMLDivElement | null;
+    };
+    mainHeaderRef: {
+        current: HTMLDivElement | null;
+    };
+    pinnedLeftHeaderRef: {
+        current: HTMLDivElement | null;
+    };
+    pinnedRightHeaderRef: {
+        current: HTMLDivElement | null;
+    };
+    headerContainerRef: {
+        current: HTMLDivElement | null;
+    };
+    tableBodyContainerRef: {
+        current: HTMLDivElement | null;
+    };
+    horizontalScrollbarRef: {
+        current: HTMLElement | null;
+    };
+}
+export declare class DOMManager {
+    private elements;
+    private refs;
+    constructor();
+    createDOMStructure(container: HTMLElement, config: SimpleTableConfig): DOMElements;
+    updateTheme(theme: string): void;
+    getElements(): DOMElements | null;
+    getRefs(): DOMRefs;
+    destroy(container: HTMLElement): void;
+}

package/dist/cjs/core/src/core/initialization/TableInitializer.d.ts

@@ -0,0 +1,30 @@
+import { SimpleTableConfig } from "../../types/SimpleTableConfig";
+import { CustomTheme } from "../../types/CustomTheme";
+import HeaderObject, { Accessor } from "../../types/HeaderObject";
+export interface ResolvedIcons {
+    drag: string | HTMLElement | SVGSVGElement;
+    expand: string | HTMLElement | SVGSVGElement;
+    filter: string | HTMLElement | SVGSVGElement;
+    headerCollapse: string | HTMLElement | SVGSVGElement;
+    headerExpand: string | HTMLElement | SVGSVGElement;
+    next: string | HTMLElement | SVGSVGElement;
+    prev: string | HTMLElement | SVGSVGElement;
+    sortDown: string | HTMLElement | SVGSVGElement;
+    sortUp: string | HTMLElement | SVGSVGElement;
+}
+export interface MergedColumnEditorConfig {
+    text: string;
+    searchEnabled: boolean;
+    searchPlaceholder: string;
+    allowColumnPinning: boolean;
+    searchFunction?: (header: HeaderObject, searchText: string) => boolean;
+    rowRenderer?: any;
+}
+export declare class TableInitializer {
+    static resolveIcons(config: SimpleTableConfig): ResolvedIcons;
+    static mergeCustomTheme(config: SimpleTableConfig): CustomTheme;
+    static mergeColumnEditorConfig(config: SimpleTableConfig): MergedColumnEditorConfig;
+    static buildEssentialAccessors(headers: HeaderObject[]): Set<string>;
+    static getInitialCollapsedHeaders(headers: HeaderObject[]): Set<Accessor>;
+    static getInitialExpandedDepths(config: SimpleTableConfig): Set<number>;
+}

package/dist/cjs/core/src/core/rendering/RenderOrchestrator.d.ts

@@ -0,0 +1,123 @@
+import { SimpleTableConfig } from "../../types/SimpleTableConfig";
+import { CustomTheme } from "../../types/CustomTheme";
+import HeaderObject, { Accessor } from "../../types/HeaderObject";
+import Row from "../../types/Row";
+import RowState from "../../types/RowState";
+import { DimensionManager } from "../../managers/DimensionManager";
+import { ScrollManager } from "../../managers/ScrollManager";
+import type { SectionScrollController } from "../../managers/SectionScrollController";
+import { SortManager } from "../../managers/SortManager";
+import { FilterManager } from "../../managers/FilterManager";
+import { SelectionManager } from "../../managers/SelectionManager";
+import { RowSelectionManager } from "../../managers/RowSelectionManager";
+import { FlattenRowsResult } from "../../utils/rowFlattening";
+import { ProcessRowsResult } from "../../utils/rowProcessing";
+import { MergedColumnEditorConfig, ResolvedIcons } from "../initialization/TableInitializer";
+export interface RenderContext {
+    cellRegistry: Map<string, any>;
+    collapsedHeaders: Set<Accessor>;
+    collapsedRows: Map<string, number>;
+    config: SimpleTableConfig;
+    customTheme: CustomTheme;
+    dimensionManager: DimensionManager | null;
+    draggedHeaderRef: {
+        current: HeaderObject | null;
+    };
+    effectiveHeaders: HeaderObject[];
+    essentialAccessors: Set<string>;
+    expandedDepths: Set<number>;
+    expandedRows: Map<string, number>;
+    filterManager: FilterManager | null;
+    getCollapsedRows: () => Map<string, number>;
+    getCollapsedHeaders?: () => Set<Accessor>;
+    getExpandedRows: () => Map<string, number>;
+    getRowStateMap: () => Map<string | number, RowState>;
+    headerRegistry: Map<string, any>;
+    headers: HeaderObject[];
+    hoveredHeaderRef: {
+        current: HeaderObject | null;
+    };
+    internalIsLoading: boolean;
+    isResizing: boolean;
+    localRows: Row[];
+    mainBodyRef: {
+        current: HTMLDivElement | null;
+    };
+    mainHeaderRef: {
+        current: HTMLDivElement | null;
+    };
+    onRender: () => void;
+    pinnedLeftHeaderRef: {
+        current: HTMLDivElement | null;
+    };
+    pinnedLeftRef: {
+        current: HTMLDivElement | null;
+    };
+    pinnedRightHeaderRef: {
+        current: HTMLDivElement | null;
+    };
+    pinnedRightRef: {
+        current: HTMLDivElement | null;
+    };
+    resolvedIcons: ResolvedIcons;
+    rowSelectionManager: RowSelectionManager | null;
+    rowStateMap: Map<string | number, RowState>;
+    scrollManager: ScrollManager | null;
+    sectionScrollController: SectionScrollController | null;
+    selectionManager: SelectionManager | null;
+    setCollapsedHeaders: (headers: Set<Accessor>) => void;
+    setCollapsedRows: (rows: Map<string, number>) => void;
+    setColumnEditorOpen: (open: boolean) => void;
+    setCurrentPage: (page: number) => void;
+    setExpandedRows: (rows: Map<string, number>) => void;
+    setHeaders: (headers: HeaderObject[]) => void;
+    setIsResizing: (value: boolean) => void;
+    setRowStateMap: (map: Map<string | number, any>) => void;
+    sortManager: SortManager | null;
+    /** When true, body cells that stay visible get only position updates (no content/selection recalc). Used during vertical scroll for performance. */
+    positionOnlyBody?: boolean;
+}
+export interface RenderState {
+    currentPage: number;
+    scrollTop: number;
+    scrollDirection: "up" | "down" | "none";
+    scrollbarWidth: number;
+    isMainSectionScrollable: boolean;
+    columnEditorOpen: boolean;
+}
+export declare class RenderOrchestrator {
+    private tableRenderer;
+    private lastHeadersRef;
+    private lastRowsRef;
+    private flattenedRowsCache;
+    private lastProcessedResult;
+    constructor();
+    getCachedFlattenResult(): FlattenRowsResult | null;
+    getLastProcessedResult(): ProcessRowsResult | null;
+    invalidateCache(type?: "body" | "header" | "context" | "all"): void;
+    computeEffectiveHeaders(headers: HeaderObject[], config: SimpleTableConfig, customTheme: CustomTheme, containerWidth?: number): HeaderObject[];
+    render(elements: {
+        bodyContainer: HTMLElement;
+        content: HTMLElement;
+        contentWrapper: HTMLElement;
+        footerContainer: HTMLElement;
+        headerContainer: HTMLElement;
+        rootElement: HTMLElement;
+        wrapperContainer: HTMLElement;
+    }, refs: {
+        mainBodyRef: {
+            current: HTMLDivElement | null;
+        };
+        tableBodyContainerRef: {
+            current: HTMLDivElement | null;
+        };
+    }, context: RenderContext, state: RenderState, mergedColumnEditorConfig: MergedColumnEditorConfig): void;
+    private renderHeader;
+    private renderBody;
+    private renderFooter;
+    private renderColumnEditor;
+    private renderHorizontalScrollbar;
+    private registerSectionPanes;
+    private buildRendererDeps;
+    cleanup(): void;
+}

package/dist/cjs/core/src/core/rendering/SectionRenderer.d.ts

@@ -0,0 +1,61 @@
+import HeaderObject, { Accessor } from "../../types/HeaderObject";
+import { HeaderRenderContext } from "../../utils/headerCellRenderer";
+import { CellRenderContext } from "../../utils/bodyCellRenderer";
+import TableRow from "../../types/TableRow";
+export interface HeaderSectionParams {
+    headers: HeaderObject[];
+    collapsedHeaders: Set<Accessor>;
+    pinned?: "left" | "right";
+    maxHeaderDepth: number;
+    headerHeight: number;
+    context: HeaderRenderContext;
+    sectionWidth?: number;
+    startColIndex?: number;
+}
+export interface BodySectionParams {
+    headers: HeaderObject[];
+    rows: TableRow[];
+    collapsedHeaders: Set<Accessor>;
+    pinned?: "left" | "right";
+    context: CellRenderContext;
+    sectionWidth?: number;
+    rowHeight: number;
+    heightOffsets?: Array<[number, number]>;
+    totalRowCount?: number;
+    startColIndex?: number;
+    /** When true, only update cell positions for existing cells (scroll performance). */
+    positionOnly?: boolean;
+    /** Full table rows ref + range for range-based body cell cache (avoids cache miss on every scroll). */
+    fullTableRows?: TableRow[];
+    renderedStartIndex?: number;
+    renderedEndIndex?: number;
+}
+export declare class SectionRenderer {
+    private headerSections;
+    private bodySections;
+    private bodyCellsCache;
+    private headerCellsCache;
+    private contextCache;
+    private nextColIndexMap;
+    private stateRowsMap;
+    private nestedGridRowsMap;
+    renderHeaderSection(params: HeaderSectionParams): HTMLElement;
+    renderBodySection(params: BodySectionParams): HTMLElement;
+    private renderNestedGridRows;
+    private renderStateRows;
+    private calculateAbsoluteHeaderCells;
+    private calculateAbsoluteBodyCells;
+    private getLeafHeaders;
+    private createHeadersHash;
+    private createHeightOffsetsHash;
+    private createContextHash;
+    private getCachedBodyCells;
+    private getCachedHeaderCells;
+    private getCachedContext;
+    invalidateCache(type?: "body" | "header" | "context" | "all"): void;
+    /**
+     * Get the next colIndex after rendering a section
+     */
+    getNextColIndex(sectionKey: string): number;
+    cleanup(): void;
+}

package/dist/cjs/core/src/core/rendering/TableRenderer.d.ts

@@ -0,0 +1,89 @@
+import HeaderObject, { Accessor } from "../../types/HeaderObject";
+import { SimpleTableConfig } from "../../types/SimpleTableConfig";
+import { CustomTheme } from "../../types/CustomTheme";
+import { DimensionManager } from "../../managers/DimensionManager";
+import type { SectionScrollController } from "../../managers/SectionScrollController";
+import { SortManager } from "../../managers/SortManager";
+import { FilterManager } from "../../managers/FilterManager";
+import { SelectionManager } from "../../managers/SelectionManager";
+import { RowSelectionManager } from "../../managers/RowSelectionManager";
+export interface TableRendererDeps {
+    cellRegistry: Map<string, any>;
+    collapsedHeaders: Set<Accessor>;
+    collapsedRows: Map<string, number>;
+    config: SimpleTableConfig;
+    customTheme: CustomTheme;
+    dimensionManager: DimensionManager | null;
+    draggedHeaderRef: {
+        current: HeaderObject | null;
+    };
+    effectiveHeaders: HeaderObject[];
+    essentialAccessors: Set<string>;
+    expandedDepths: Set<number>;
+    expandedRows: Map<string, number>;
+    filterManager: FilterManager | null;
+    getCollapsedHeaders?: () => Set<Accessor>;
+    getCollapsedRows: () => Map<string, number>;
+    getExpandedRows: () => Map<string, number>;
+    getRowStateMap: () => Map<string | number, any>;
+    headerRegistry: Map<string, any>;
+    headers: HeaderObject[];
+    hoveredHeaderRef: {
+        current: HeaderObject | null;
+    };
+    internalIsLoading: boolean;
+    isResizing: boolean;
+    localRows: any[];
+    mainBodyRef: {
+        current: HTMLDivElement | null;
+    };
+    mainHeaderRef: {
+        current: HTMLDivElement | null;
+    };
+    onRender: () => void;
+    pinnedLeftHeaderRef: {
+        current: HTMLDivElement | null;
+    };
+    pinnedLeftRef: {
+        current: HTMLDivElement | null;
+    };
+    pinnedRightHeaderRef: {
+        current: HTMLDivElement | null;
+    };
+    pinnedRightRef: {
+        current: HTMLDivElement | null;
+    };
+    positionOnlyBody?: boolean; /** When true, body sections use position-only updates for existing cells (scroll performance). */
+    resolvedIcons: any;
+    rowSelectionManager: RowSelectionManager | null;
+    rowStateMap: Map<string | number, any>;
+    sectionScrollController: SectionScrollController | null;
+    selectionManager: SelectionManager | null;
+    setCollapsedHeaders: (headers: Set<Accessor>) => void;
+    setCollapsedRows: (rows: Map<string, number>) => void;
+    setExpandedRows: (rows: Map<string, number>) => void;
+    setHeaders: (headers: HeaderObject[]) => void;
+    setIsResizing: (value: boolean) => void;
+    setRowStateMap: (map: Map<string | number, any>) => void;
+    sortManager: SortManager | null;
+}
+export declare class TableRenderer {
+    private sectionRenderer;
+    private footerInstance;
+    private columnEditorInstance;
+    private horizontalScrollbarRef;
+    private scrollbarTimeoutId;
+    private stickyParentsContainer;
+    private sectionScrollController;
+    private renderScheduled;
+    private pendingRenderCallback;
+    constructor();
+    private scheduleRender;
+    invalidateCache(type?: "body" | "header" | "context" | "all"): void;
+    renderHeader(container: HTMLElement, calculatedHeaderHeight: number, maxHeaderDepth: number, deps: TableRendererDeps): void;
+    renderBody(container: HTMLElement, processedResult: any, deps: TableRendererDeps): void;
+    renderFooter(container: HTMLElement, totalRows: number, currentPage: number, onPageChange: (page: number) => void, deps: TableRendererDeps): void;
+    renderColumnEditor(contentWrapper: HTMLElement, columnEditorOpen: boolean, setColumnEditorOpen: (open: boolean) => void, mergedColumnEditorConfig: any, deps: TableRendererDeps): void;
+    renderHorizontalScrollbar(wrapperContainer: HTMLElement, mainBodyWidth: number, pinnedLeftWidth: number, pinnedRightWidth: number, pinnedLeftContentWidth: number, pinnedRightContentWidth: number, tableBodyContainerRef: HTMLDivElement, deps: TableRendererDeps): void;
+    cleanup(): void;
+}

package/dist/cjs/core/src/hooks/ariaAnnouncements.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Manages aria-live announcements for screen readers.
+ * This is a vanilla JS alternative to the useAriaAnnouncements hook.
+ *
+ * Provides a way to announce dynamic content changes to assistive technologies.
+ */
+export declare class AriaAnnouncementManager {
+    private announcement;
+    private timeoutId;
+    private observers;
+    /**
+     * Announces a message to screen readers
+     * The message will be cleared after 1 second to allow for new announcements
+     * @param message - The message to announce
+     */
+    announce(message: string): void;
+    /**
+     * Gets the current announcement message
+     * @returns The current announcement string
+     */
+    getAnnouncement(): string;
+    /**
+     * Subscribes to announcement changes
+     * @param callback - Function to call when announcement changes
+     * @returns Unsubscribe function
+     */
+    subscribe(callback: (message: string) => void): () => void;
+    /**
+     * Notifies all observers of announcement changes
+     */
+    private notifyObservers;
+    /**
+     * Cleans up the manager and clears any pending timeouts
+     */
+    destroy(): void;
+}
+export default AriaAnnouncementManager;

package/dist/cjs/core/src/hooks/contentHeight.d.ts

@@ -0,0 +1,23 @@
+export interface ContentHeightConfig {
+    height?: string | number;
+    maxHeight?: string | number;
+    rowHeight: number;
+    shouldPaginate?: boolean;
+    rowsPerPage?: number;
+    totalRowCount: number;
+    headerHeight?: number;
+    footerHeight?: number;
+}
+/**
+ * Converts a height value (string or number) to pixels
+ */
+export declare const convertHeightToPixels: (heightValue: string | number) => number;
+/**
+ * Calculates the content height for the table.
+ * This is a pure function alternative to the useContentHeight hook.
+ *
+ * @param config - Configuration for content height calculation
+ * @returns The calculated content height in pixels, or undefined to disable virtualization
+ */
+export declare const calculateContentHeight: ({ height, maxHeight, rowHeight, shouldPaginate, rowsPerPage, totalRowCount, headerHeight, footerHeight, }: ContentHeightConfig) => number | undefined;
+export default calculateContentHeight;

package/dist/cjs/core/src/hooks/expandedDepths.d.ts

@@ -0,0 +1,65 @@
+import { Accessor } from "../types/HeaderObject";
+/**
+ * Initialize expandedDepths based on expandAll prop and rowGrouping
+ */
+export declare const initializeExpandedDepths: (expandAll: boolean, rowGrouping?: Accessor[]) => Set<number>;
+/**
+ * Manages expanded depths state for row grouping.
+ * This is a vanilla JS alternative to the useExpandedDepths hook.
+ */
+export declare class ExpandedDepthsManager {
+    private expandedDepths;
+    private observers;
+    constructor(expandAll: boolean, rowGrouping?: Accessor[]);
+    /**
+     * Updates the expanded depths when rowGrouping changes
+     * Filters out depths that are now out of range
+     * @param rowGrouping - The current row grouping configuration
+     */
+    updateRowGrouping(rowGrouping?: Accessor[]): void;
+    /**
+     * Gets the current expanded depths
+     * @returns Set of expanded depth numbers
+     */
+    getExpandedDepths(): Set<number>;
+    /**
+     * Sets the expanded depths
+     * @param depths - New set of expanded depths
+     */
+    setExpandedDepths(depths: Set<number>): void;
+    /**
+     * Subscribes to expanded depths changes
+     * @param callback - Function to call when depths change
+     * @returns Unsubscribe function
+     */
+    subscribe(callback: (depths: Set<number>) => void): () => void;
+    /**
+     * Notifies all observers of depth changes
+     */
+    private notifyObservers;
+    /**
+     * Expands all depths
+     */
+    expandAll(): void;
+    /**
+     * Collapses all depths
+     */
+    collapseAll(): void;
+    /**
+     * Expands a specific depth
+     */
+    expandDepth(depth: number): void;
+    /**
+     * Collapses a specific depth
+     */
+    collapseDepth(depth: number): void;
+    /**
+     * Toggles a specific depth
+     */
+    toggleDepth(depth: number): void;
+    /**
+     * Cleans up the manager
+     */
+    destroy(): void;
+}
+export default ExpandedDepthsManager;