@simple-table/react 3.0.0-beta.10

package/dist/core/src/hooks/handleOutsideClick.d.ts

@@ -0,0 +1,50 @@
+import HeaderObject from "../types/HeaderObject";
+import Cell from "../types/Cell";
+export interface HandleOutsideClickConfig {
+    selectableColumns: boolean;
+    selectedCells: Set<string>;
+    selectedColumns: Set<number>;
+    setSelectedCells: (cells: Set<string>) => void;
+    setSelectedColumns: (columns: Set<number>) => void;
+    activeHeaderDropdown?: HeaderObject | null;
+    setActiveHeaderDropdown?: (header: HeaderObject | null) => void;
+    startCell?: {
+        current: Cell | null;
+    };
+    /** When provided, used to read current selection (avoids stale refs). */
+    getSelectedCells?: () => Set<string>;
+    getSelectedColumns?: () => Set<number>;
+    /** When provided, called to clear both cell/column selection and startCell in one go. */
+    onClearSelection?: () => void;
+}
+/**
+ * Manages outside click detection for cells, columns, and header dropdowns.
+ * This is a vanilla JS alternative to the useHandleOutsideClick hook.
+ */
+export declare class HandleOutsideClickManager {
+    private config;
+    private isListening;
+    constructor(config: HandleOutsideClickConfig);
+    /**
+     * Updates the configuration
+     * @param config - New configuration
+     */
+    updateConfig(config: Partial<HandleOutsideClickConfig>): void;
+    /**
+     * Handles the mousedown event
+     */
+    private handleClickOutside;
+    /**
+     * Starts listening to mousedown events
+     */
+    startListening(): void;
+    /**
+     * Stops listening to mousedown events
+     */
+    stopListening(): void;
+    /**
+     * Cleans up the manager and removes all event listeners
+     */
+    destroy(): void;
+}
+export default HandleOutsideClickManager;

package/dist/core/src/hooks/previousValue.d.ts

@@ -0,0 +1,30 @@
+/**
+ * A class to track previous values of a variable.
+ * This replaces the usePrevious hook for non-React code.
+ *
+ * @example
+ * const tracker = new PreviousValueTracker(initialValue);
+ * const previous = tracker.get();
+ * tracker.update(newValue);
+ */
+export declare class PreviousValueTracker<T> {
+    private previousValue;
+    constructor(initialValue: T);
+    /**
+     * Updates the tracked value and returns the previous value
+     * @param newValue - The new value to track
+     * @returns The previous value before update
+     */
+    update(newValue: T): T;
+    /**
+     * Gets the current previous value without updating
+     * @returns The currently stored previous value
+     */
+    get(): T;
+    /**
+     * Sets the previous value directly (useful for initialization)
+     * @param value - The value to set
+     */
+    set(value: T): void;
+}
+export default PreviousValueTracker;

package/dist/core/src/hooks/scrollbarVisibility.d.ts

@@ -0,0 +1,65 @@
+/**
+ * Manages scrollbar visibility detection and header padding adjustments.
+ * This is a vanilla JS alternative to the useScrollbarVisibility hook.
+ */
+export declare class ScrollbarVisibilityManager {
+    private isMainSectionScrollable;
+    private headerContainer;
+    private mainSection;
+    private scrollbarWidth;
+    private resizeObserver;
+    private observers;
+    private rafId;
+    constructor(config: {
+        headerContainer?: HTMLElement | null;
+        mainSection?: HTMLElement | null;
+        scrollbarWidth: number;
+    });
+    /**
+     * Initializes the scrollbar visibility detection
+     */
+    private initialize;
+    /**
+     * Checks if the main section is scrollable
+     */
+    private checkScrollability;
+    /**
+     * Updates the header padding based on scrollbar visibility
+     */
+    private updateHeaderPadding;
+    /**
+     * Updates the scrollbar width and refreshes padding
+     * @param width - New scrollbar width in pixels
+     */
+    setScrollbarWidth(width: number): void;
+    /**
+     * Updates the header container element
+     * @param container - New header container element
+     */
+    setHeaderContainer(container: HTMLElement | null): void;
+    /**
+     * Updates the main section element
+     * @param section - New main section element
+     */
+    setMainSection(section: HTMLElement | null): void;
+    /**
+     * Gets whether the main section is currently scrollable
+     * @returns True if the main section has vertical scroll
+     */
+    getIsMainSectionScrollable(): boolean;
+    /**
+     * Subscribes to scrollability changes
+     * @param callback - Function to call when scrollability changes
+     * @returns Unsubscribe function
+     */
+    subscribe(callback: (isScrollable: boolean) => void): () => void;
+    /**
+     * Notifies all observers of scrollability changes
+     */
+    private notifyObservers;
+    /**
+     * Cleans up the manager and removes all observers
+     */
+    destroy(): void;
+}
+export default ScrollbarVisibilityManager;

package/dist/core/src/hooks/scrollbarWidth.d.ts

@@ -0,0 +1,52 @@
+/**
+ * Calculates the scrollbar width of an element.
+ * This is a pure function that replaces the useScrollbarWidth hook.
+ *
+ * @param element - The HTML element to measure
+ * @returns The width of the scrollbar in pixels, or 0 if element is null
+ */
+export declare function calculateScrollbarWidth(element: HTMLElement | null): number;
+/**
+ * A class to manage scrollbar width state and updates.
+ * This provides a stateful alternative to the useScrollbarWidth hook.
+ */
+export declare class ScrollbarWidthManager {
+    private width;
+    private element;
+    private observers;
+    constructor(element?: HTMLElement | null);
+    /**
+     * Sets the element to measure and calculates its scrollbar width
+     * @param element - The HTML element to measure
+     */
+    setElement(element: HTMLElement | null): void;
+    /**
+     * Updates the scrollbar width measurement
+     */
+    update(): void;
+    /**
+     * Gets the current scrollbar width
+     * @returns The current scrollbar width in pixels
+     */
+    getWidth(): number;
+    /**
+     * Manually sets the scrollbar width
+     * @param width - The width to set
+     */
+    setWidth(width: number): void;
+    /**
+     * Subscribes to scrollbar width changes
+     * @param callback - Function to call when width changes
+     * @returns Unsubscribe function
+     */
+    subscribe(callback: (width: number) => void): () => void;
+    /**
+     * Notifies all observers of width changes
+     */
+    private notifyObservers;
+    /**
+     * Cleans up the manager
+     */
+    destroy(): void;
+}
+export default calculateScrollbarWidth;

package/dist/core/src/hooks/useAggregatedRows.d.ts

@@ -0,0 +1,14 @@
+import HeaderObject from "../types/HeaderObject";
+import Row from "../types/Row";
+import { RowManager } from "../managers/RowManager";
+interface CalculateAggregatedRowsProps {
+    rows?: Row[];
+    headers?: HeaderObject[];
+    rowGrouping?: string[];
+    rowManager?: RowManager;
+}
+/**
+ * Pure function to calculate aggregated rows based on row grouping and aggregation configuration
+ */
+export declare const calculateAggregatedRows: (props: CalculateAggregatedRowsProps) => Row[];
+export default calculateAggregatedRows;

package/dist/core/src/hooks/useQuickFilter.d.ts

@@ -0,0 +1,14 @@
+import { QuickFilterConfig } from "../types/QuickFilterTypes";
+import Row from "../types/Row";
+import HeaderObject from "../types/HeaderObject";
+interface FilterRowsWithQuickFilterProps {
+    rows: Row[];
+    headers: HeaderObject[];
+    quickFilter?: QuickFilterConfig;
+}
+/**
+ * Pure function to filter rows based on quick filter configuration
+ * Supports both simple (contains) and smart (multi-word, phrases, negation, column-specific) modes
+ */
+export declare const filterRowsWithQuickFilter: ({ rows, headers, quickFilter }: FilterRowsWithQuickFilterProps) => Row[];
+export default filterRowsWithQuickFilter;

package/dist/core/src/hooks/windowResize.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Manages window resize event listeners.
+ * This is a vanilla JS alternative to the useWindowResize hook.
+ */
+export declare class WindowResizeManager {
+    private callbacks;
+    private isListening;
+    /**
+     * Handles the window resize event
+     */
+    private handleResize;
+    /**
+     * Adds a callback to be called on window resize
+     * @param callback - Function to call when window resizes
+     * @returns Unsubscribe function
+     */
+    addCallback(callback: () => void): () => void;
+    /**
+     * Starts listening to window resize events
+     */
+    startListening(): void;
+    /**
+     * Stops listening to window resize events
+     */
+    stopListening(): void;
+    /**
+     * Cleans up the manager and removes all event listeners
+     */
+    destroy(): void;
+}
+export default WindowResizeManager;

package/dist/core/src/icons/AngleDownIcon.d.ts

@@ -0,0 +1 @@
+export declare const createAngleDownIcon: (className?: string) => SVGSVGElement;

package/dist/core/src/icons/AngleLeftIcon.d.ts

@@ -0,0 +1 @@
+export declare const createAngleLeftIcon: (className?: string) => SVGSVGElement;

package/dist/core/src/icons/AngleRightIcon.d.ts

@@ -0,0 +1 @@
+export declare const createAngleRightIcon: (className?: string) => SVGSVGElement;

package/dist/core/src/icons/AngleUpIcon.d.ts

@@ -0,0 +1 @@
+export declare const createAngleUpIcon: (className?: string) => SVGSVGElement;

package/dist/core/src/icons/AscIcon.d.ts

@@ -0,0 +1 @@
+export declare const createAscIcon: (className?: string) => SVGSVGElement;

package/dist/core/src/icons/CheckIcon.d.ts

@@ -0,0 +1 @@
+export declare const createCheckIcon: (className?: string) => SVGSVGElement;

package/dist/core/src/icons/DescIcon.d.ts

@@ -0,0 +1 @@
+export declare const createDescIcon: (className?: string) => SVGSVGElement;

package/dist/core/src/icons/DragIcon.d.ts

@@ -0,0 +1 @@
+export declare const createDragIcon: (className?: string) => SVGSVGElement;

package/dist/core/src/icons/FilterIcon.d.ts

@@ -0,0 +1 @@
+export declare const createFilterIcon: (className?: string) => SVGSVGElement;

package/dist/core/src/icons/SelectIcon.d.ts

@@ -0,0 +1 @@
+export declare const createSelectIcon: () => SVGSVGElement;

package/dist/core/src/icons/index.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Internal icon factory functions
+ * These create vanilla JS SVG elements for use within the table component
+ */
+export { createAngleDownIcon } from "./AngleDownIcon";
+export { createAngleLeftIcon } from "./AngleLeftIcon";
+export { createAngleRightIcon } from "./AngleRightIcon";
+export { createAngleUpIcon } from "./AngleUpIcon";
+export { createAscIcon } from "./AscIcon";
+export { createCheckIcon } from "./CheckIcon";
+export { createDescIcon } from "./DescIcon";
+export { createDragIcon } from "./DragIcon";
+export { createFilterIcon } from "./FilterIcon";
+export { createSelectIcon } from "./SelectIcon";

package/dist/core/src/index.d.ts

@@ -0,0 +1,48 @@
+import { SimpleTableVanilla } from "./core/SimpleTableVanilla";
+import type BoundingBox from "./types/BoundingBox";
+import type Cell from "./types/Cell";
+import type CellChangeProps from "./types/CellChangeProps";
+import type CellValue from "./types/CellValue";
+import type DragHandlerProps from "./types/DragHandlerProps";
+import type EnumOption from "./types/EnumOption";
+import type HeaderObject from "./types/HeaderObject";
+import type { Accessor, ChartOptions, ColumnType, Comparator, ComparatorProps, ExportValueGetter, ExportValueProps, ShowWhen, ValueFormatter, ValueFormatterProps, ValueGetter, ValueGetterProps } from "./types/HeaderObject";
+import type { AggregationConfig, AggregationType } from "./types/AggregationTypes";
+import type OnSortProps from "./types/OnSortProps";
+import type OnRowGroupExpandProps from "./types/OnRowGroupExpandProps";
+import type Row from "./types/Row";
+import type RowState from "./types/RowState";
+import type SharedTableProps from "./types/SharedTableProps";
+import type SortColumn from "./types/SortColumn";
+import type TableHeaderProps from "./types/TableHeaderProps";
+import type { TableAPI, SetHeaderRenameProps, ExportToCSVProps } from "./types/TableAPI";
+import type TableRefType from "./types/TableRefType";
+import type TableRowProps from "./types/TableRowProps";
+import type Theme from "./types/Theme";
+import type UpdateDataProps from "./types/UpdateCellProps";
+import type { FilterCondition, TableFilterState } from "./types/FilterTypes";
+import type { QuickFilterConfig, QuickFilterGetter, QuickFilterGetterProps, QuickFilterMode } from "./types/QuickFilterTypes";
+import type { ColumnVisibilityState } from "./types/ColumnVisibilityTypes";
+import type RowSelectionChangeProps from "./types/RowSelectionChangeProps";
+import type CellClickProps from "./types/CellClickProps";
+import type CellRendererProps from "./types/CellRendererProps";
+import type { CellRenderer } from "./types/CellRendererProps";
+import type HeaderRendererProps from "./types/HeaderRendererProps";
+import type { HeaderRenderer, HeaderRendererComponents } from "./types/HeaderRendererProps";
+import type ColumnEditorRowRendererProps from "./types/ColumnEditorRowRendererProps";
+import type { ColumnEditorRowRenderer, ColumnEditorRowRendererComponents } from "./types/ColumnEditorRowRendererProps";
+import type HeaderDropdownProps from "./types/HeaderDropdownProps";
+import type { HeaderDropdown } from "./types/HeaderDropdownProps";
+import type { RowButtonProps } from "./types/RowButton";
+import type FooterRendererProps from "./types/FooterRendererProps";
+import type { LoadingStateRenderer, ErrorStateRenderer, EmptyStateRenderer, LoadingStateRendererProps, ErrorStateRendererProps, EmptyStateRendererProps } from "./types/RowStateRendererProps";
+import type { CustomTheme, CustomThemeProps } from "./types/CustomTheme";
+import type { ColumnEditorConfig, ColumnEditorSearchFunction } from "./types/ColumnEditorConfig";
+import type { IconsConfig } from "./types/IconsConfig";
+import type { GetRowId, GetRowIdParams } from "./types/GetRowId";
+import type { SimpleTableConfig } from "./types/SimpleTableConfig";
+import type { SimpleTableProps } from "./types/SimpleTableProps";
+import type { RowId } from "./types/RowId";
+import type { PinnedSectionsState } from "./types/PinnedSectionsState";
+export { SimpleTableVanilla };
+export type { Accessor, AggregationConfig, AggregationType, BoundingBox, Cell, CellChangeProps, CellClickProps, CellRenderer, CellRendererProps, CellValue, ChartOptions, ColumnEditorConfig, ColumnEditorRowRenderer, ColumnEditorRowRendererComponents, ColumnEditorRowRendererProps, ColumnEditorSearchFunction, ColumnType, ColumnVisibilityState, Comparator, ComparatorProps, CustomTheme, CustomThemeProps, DragHandlerProps, EmptyStateRenderer, EmptyStateRendererProps, EnumOption, ErrorStateRenderer, ErrorStateRendererProps, ExportToCSVProps, ExportValueGetter, ExportValueProps, FilterCondition, FooterRendererProps, GetRowId, GetRowIdParams, IconsConfig, LoadingStateRenderer, LoadingStateRendererProps, HeaderDropdown, HeaderDropdownProps, HeaderObject, HeaderRenderer, HeaderRendererProps, HeaderRendererComponents, OnRowGroupExpandProps, OnSortProps, QuickFilterConfig, QuickFilterGetter, QuickFilterGetterProps, QuickFilterMode, Row, RowButtonProps, RowId, RowSelectionChangeProps, RowState, SetHeaderRenameProps, SharedTableProps, ShowWhen, SimpleTableConfig, SimpleTableProps, SortColumn, TableAPI, TableFilterState, TableHeaderProps, TableRefType, TableRowProps, Theme, PinnedSectionsState, UpdateDataProps, ValueFormatter, ValueFormatterProps, ValueGetter, ValueGetterProps, };

package/dist/core/src/managers/AutoScaleManager.d.ts

@@ -0,0 +1,26 @@
+import HeaderObject from "../types/HeaderObject";
+interface AutoScaleConfig {
+    autoExpandColumns: boolean;
+    containerWidth: number;
+    pinnedLeftWidth: number;
+    pinnedRightWidth: number;
+    mainBodyRef: {
+        current: HTMLDivElement | null;
+    };
+    isResizing?: boolean;
+}
+type HeaderUpdateCallback = (headers: HeaderObject[]) => void;
+export declare const applyAutoScaleToHeaders: (headers: HeaderObject[], options: AutoScaleConfig) => HeaderObject[];
+export declare class AutoScaleManager {
+    private config;
+    private onHeadersUpdate;
+    private isResizingTracker;
+    private containerWidthTracker;
+    constructor(config: AutoScaleConfig, onHeadersUpdate: HeaderUpdateCallback);
+    updateConfig(config: Partial<AutoScaleConfig>): void;
+    private triggerAutoScale;
+    applyAutoScale(headers: HeaderObject[]): HeaderObject[];
+    setHeaders(headersOrUpdater: HeaderObject[] | ((prev: HeaderObject[]) => HeaderObject[]), currentHeaders: HeaderObject[]): HeaderObject[];
+    destroy(): void;
+}
+export {};

package/dist/core/src/managers/DimensionManager.d.ts

@@ -0,0 +1,42 @@
+import HeaderObject from "../types/HeaderObject";
+export interface DimensionManagerConfig {
+    effectiveHeaders: HeaderObject[];
+    headerHeight?: number;
+    rowHeight: number;
+    height?: string | number;
+    maxHeight?: string | number;
+    totalRowCount: number;
+    footerHeight?: number;
+    containerElement?: HTMLElement;
+}
+export interface DimensionManagerState {
+    containerWidth: number;
+    calculatedHeaderHeight: number;
+    maxHeaderDepth: number;
+    contentHeight: number | undefined;
+}
+type StateChangeCallback = (state: DimensionManagerState) => void;
+export declare class DimensionManager {
+    private config;
+    private state;
+    private subscribers;
+    private resizeObserver;
+    private rafId;
+    constructor(config: DimensionManagerConfig);
+    private getHeaderDepth;
+    private calculateMaxHeaderDepth;
+    private calculateHeaderHeight;
+    private convertHeightToPixels;
+    private calculateContentHeight;
+    private observeContainer;
+    updateConfig(config: Partial<DimensionManagerConfig>): void;
+    subscribe(callback: StateChangeCallback): () => void;
+    private notifySubscribers;
+    getState(): DimensionManagerState;
+    getContainerWidth(): number;
+    getCalculatedHeaderHeight(): number;
+    getMaxHeaderDepth(): number;
+    getContentHeight(): number | undefined;
+    destroy(): void;
+}
+export {};

package/dist/core/src/managers/DragHandlerManager.d.ts

@@ -0,0 +1,44 @@
+import HeaderObject, { Accessor } from "../types/HeaderObject";
+export declare const getHeaderIndexPath: (headers: HeaderObject[], targetAccessor: Accessor, currentPath?: number[]) => number[] | null;
+export declare const getSiblingArray: (headers: HeaderObject[], indexPath: number[]) => HeaderObject[];
+export declare const setSiblingArray: (headers: HeaderObject[], indexPath: number[], newSiblings: HeaderObject[]) => HeaderObject[];
+export declare const getHeaderSection: (header: HeaderObject) => "left" | "main" | "right";
+export declare const updateHeaderPinnedProperty: (header: HeaderObject, targetSection: "left" | "main" | "right") => HeaderObject;
+export declare function swapHeaders(headers: HeaderObject[], draggedPath: number[], hoveredPath: number[]): {
+    newHeaders: HeaderObject[];
+    emergencyBreak: boolean;
+};
+export declare function insertHeaderAcrossSections({ headers, draggedHeader, hoveredHeader, }: {
+    headers: HeaderObject[];
+    draggedHeader: HeaderObject;
+    hoveredHeader: HeaderObject;
+}): {
+    newHeaders: HeaderObject[];
+    emergencyBreak: boolean;
+};
+export interface DragHandlerManagerConfig {
+    headers: HeaderObject[];
+    essentialAccessors?: ReadonlySet<string>;
+    onTableHeaderDragEnd: (newHeaders: HeaderObject[]) => void;
+    onColumnOrderChange?: (newHeaders: HeaderObject[]) => void;
+    onHeadersChange?: (newHeaders: HeaderObject[]) => void;
+}
+export declare class DragHandlerManager {
+    private config;
+    private draggedHeader;
+    private hoveredHeader;
+    private prevUpdateTime;
+    private prevDraggingPosition;
+    private prevHeadersTracker;
+    constructor(config: DragHandlerManagerConfig);
+    updateConfig(config: Partial<DragHandlerManagerConfig>): void;
+    getDraggedHeader(): HeaderObject | null;
+    getHoveredHeader(): HeaderObject | null;
+    handleDragStart(header: HeaderObject): void;
+    handleDragOver({ event, hoveredHeader, }: {
+        event: DragEvent;
+        hoveredHeader: HeaderObject;
+    }): void;
+    handleDragEnd(): void;
+    destroy(): void;
+}

package/dist/core/src/managers/FilterManager.d.ts

@@ -0,0 +1,36 @@
+import { TableFilterState, FilterCondition } from "../types/FilterTypes";
+import Row from "../types/Row";
+import HeaderObject, { Accessor } from "../types/HeaderObject";
+export interface FilterManagerConfig {
+    rows: Row[];
+    headers: HeaderObject[];
+    externalFilterHandling: boolean;
+    onFilterChange?: (filters: TableFilterState) => void;
+    announce?: (message: string) => void;
+}
+export interface FilterManagerState {
+    filters: TableFilterState;
+    filteredRows: Row[];
+}
+type StateChangeCallback = (state: FilterManagerState) => void;
+export declare class FilterManager {
+    private config;
+    private state;
+    private subscribers;
+    private headerLookup;
+    constructor(config: FilterManagerConfig);
+    private updateHeaderLookup;
+    private computeFilteredRows;
+    updateConfig(config: Partial<FilterManagerConfig>): void;
+    subscribe(callback: StateChangeCallback): () => void;
+    private notifySubscribers;
+    updateFilter(filter: FilterCondition): void;
+    clearFilter(accessor: Accessor): void;
+    clearAllFilters(): void;
+    computeFilteredRowsPreview(filter: FilterCondition): Row[];
+    getState(): FilterManagerState;
+    getFilters(): TableFilterState;
+    getFilteredRows(): Row[];
+    destroy(): void;
+}
+export {};

package/dist/core/src/managers/RowManager.d.ts

@@ -0,0 +1,56 @@
+import HeaderObject, { Accessor } from "../types/HeaderObject";
+import Row from "../types/Row";
+import RowState from "../types/RowState";
+import TableRow from "../types/TableRow";
+import { HeightOffsets } from "../utils/infiniteScrollUtils";
+import { CustomTheme } from "../types/CustomTheme";
+import { GetRowId } from "../types/GetRowId";
+export interface RowManagerConfig {
+    rows: Row[];
+    headers: HeaderObject[];
+    rowGrouping?: Accessor[];
+    getRowId?: GetRowId;
+    rowHeight: number;
+    headerHeight: number;
+    customTheme: CustomTheme;
+    hasLoadingRenderer: boolean;
+    hasErrorRenderer: boolean;
+    hasEmptyRenderer: boolean;
+}
+export interface RowManagerState {
+    expandedRows: Map<string, number>;
+    collapsedRows: Map<string, number>;
+    expandedDepths: Set<number>;
+    rowStateMap: Map<string | number, RowState>;
+    aggregatedRows: Row[];
+    flattenedRows: TableRow[];
+    heightOffsets: HeightOffsets;
+    paginatableRows: TableRow[];
+    parentEndPositions: number[];
+}
+type StateChangeCallback = (state: RowManagerState) => void;
+export declare class RowManager {
+    private config;
+    private state;
+    private subscribers;
+    constructor(config: RowManagerConfig);
+    private getAllAggregationHeaders;
+    private calculateAggregation;
+    private computeAggregatedRows;
+    private computeFlattenedRows;
+    updateConfig(config: Partial<RowManagerConfig>): void;
+    subscribe(callback: StateChangeCallback): () => void;
+    private notifySubscribers;
+    setExpandedRows(expandedRows: Map<string, number>): void;
+    setCollapsedRows(collapsedRows: Map<string, number>): void;
+    setExpandedDepths(expandedDepths: Set<number>): void;
+    setRowStateMap(rowStateMap: Map<string | number, RowState>): void;
+    getState(): RowManagerState;
+    getAggregatedRows(): Row[];
+    getFlattenedRows(): TableRow[];
+    getHeightOffsets(): HeightOffsets;
+    getPaginatableRows(): TableRow[];
+    getParentEndPositions(): number[];
+    destroy(): void;
+}
+export {};

package/dist/core/src/managers/RowSelectionManager.d.ts

@@ -0,0 +1,36 @@
+import TableRow from "../types/TableRow";
+import RowSelectionChangeProps from "../types/RowSelectionChangeProps";
+export interface RowSelectionManagerConfig {
+    tableRows: TableRow[];
+    onRowSelectionChange?: (props: RowSelectionChangeProps) => void;
+    enableRowSelection?: boolean;
+}
+export interface RowSelectionManagerState {
+    selectedRows: Set<string>;
+    selectedRowCount: number;
+    selectedRowsData: any[];
+}
+type StateChangeCallback = (state: RowSelectionManagerState) => void;
+export declare class RowSelectionManager {
+    private config;
+    private state;
+    private subscribers;
+    constructor(config: RowSelectionManagerConfig);
+    updateConfig(config: Partial<RowSelectionManagerConfig>): void;
+    private updateDerivedState;
+    subscribe(callback: StateChangeCallback): () => void;
+    private notifySubscribers;
+    isRowSelected(rowId: string): boolean;
+    areAllRowsSelected(): boolean;
+    getSelectedRows(): Set<string>;
+    getSelectedRowCount(): number;
+    getSelectedRowsData(): any[];
+    setSelectedRows(selectedRows: Set<string>): void;
+    handleRowSelect(rowId: string, isSelected: boolean): void;
+    handleSelectAll(isSelected: boolean): void;
+    handleToggleRow(rowId: string): void;
+    clearSelection(): void;
+    getState(): RowSelectionManagerState;
+    destroy(): void;
+}
+export {};

package/dist/core/src/managers/ScrollManager.d.ts

@@ -0,0 +1,35 @@
+export interface ScrollManagerConfig {
+    onLoadMore?: () => void;
+    infiniteScrollThreshold?: number;
+}
+export interface ScrollManagerState {
+    scrollTop: number;
+    scrollLeft: number;
+    scrollDirection: "up" | "down" | "none";
+    isScrolling: boolean;
+}
+type StateChangeCallback = (state: ScrollManagerState) => void;
+/**
+ * Manages vertical scroll state (scrollTop, direction, isScrolling) and infinite scroll.
+ * Horizontal header/body/scrollbar sync is handled by SectionScrollController.
+ */
+export declare class ScrollManager {
+    private config;
+    private state;
+    private subscribers;
+    private lastScrollTop;
+    private scrollTimeoutId;
+    constructor(config: ScrollManagerConfig);
+    updateConfig(config: Partial<ScrollManagerConfig>): void;
+    subscribe(callback: StateChangeCallback): () => void;
+    private notifySubscribers;
+    handleScroll(scrollTop: number, scrollLeft: number, containerHeight: number, contentHeight: number): void;
+    setScrolling(isScrolling: boolean): void;
+    getState(): ScrollManagerState;
+    getScrollTop(): number;
+    getScrollLeft(): number;
+    getScrollDirection(): "up" | "down" | "none";
+    isScrolling(): boolean;
+    destroy(): void;
+}
+export {};