@simple-table/react 4.0.1 → 4.0.2

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

@@ -1,33 +0,0 @@
-import HeaderObject, { Accessor } from "../types/HeaderObject";
-interface AutoScaleConfig {
-    autoExpandColumns: boolean;
-    containerWidth: number;
-    pinnedLeftWidth: number;
-    pinnedRightWidth: number;
-    mainBodyRef: {
-        current: HTMLDivElement | null;
-    };
-    isResizing?: boolean;
-    /**
-     * Currently collapsed header accessors. Auto-scale must only account for the
-     * leaf columns that are actually visible for the current collapsed state —
-     * otherwise it sums the widths of hidden child columns and under-expands,
-     * leaving empty space on the right.
-     */
-    collapsedHeaders?: Set<Accessor>;
-}
-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/types/core/src/managers/DimensionManager.d.ts

@@ -1,84 +0,0 @@
-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;
-    /**
-     * Visible portion of the table inside an external scroll parent (in pixels).
-     * Drives virtualization when neither `height` nor `maxHeight` is set.
-     */
-    externalViewportHeight?: number;
-}
-export interface DimensionManagerState {
-    containerWidth: number;
-    calculatedHeaderHeight: number;
-    maxHeaderDepth: number;
-    contentHeight: number | undefined;
-}
-type StateChangeCallback = (state: DimensionManagerState) => void;
-/**
- * Wait this long after the last container-width ResizeObserver tick before
- * notifying subscribers. Coalesces CSS-transition / animated layout shifts
- * (e.g. a collapsible nav) into a single trailing update instead of one full
- * table render per animation frame.
- *
- * Kept above typical frame-budget jank (~50–80ms) so a hitch mid-transition
- * does not look like "animation ended" and fire an extra full relayout.
- */
-export declare const CONTAINER_RESIZE_NOTIFY_DEBOUNCE_MS = 100;
-/**
- * After a trailing notify, keep the burst open this long. A jank-sized quiet
- * gap mid-animation must not start a fresh burst (which would allow another
- * pair of notifies and thrash subscribers).
- */
-export declare const CONTAINER_RESIZE_BURST_END_MS = 150;
-export declare class DimensionManager {
-    private config;
-    private state;
-    private subscribers;
-    private resizeObserver;
-    private rafId;
-    private resizeNotifyDebounceId;
-    private resizeBurstEndId;
-    /** Notifies emitted in the current continuous resize burst (capped at 2). */
-    private resizeBurstNotifyCount;
-    /** True when a 3rd+ trailing tick was suppressed; flush latest width on burst end. */
-    private resizeBurstNeedsFinalFlush;
-    /** Set when applyContainerWidthSync updates state before any subscriber exists. */
-    private initialNotifyPending;
-    constructor(config: DimensionManagerConfig);
-    private getHeaderDepth;
-    private calculateMaxHeaderDepth;
-    private calculateHeaderHeight;
-    private convertHeightToPixels;
-    private calculateContentHeight;
-    private cancelPendingResizeNotify;
-    private cancelResizeBurstEnd;
-    private scheduleResizeBurstEnd;
-    /**
-     * Trailing debounce for animated / continuous container resizes.
-     *
-     * Per burst (continuous RO ticks separated by less than {@link CONTAINER_RESIZE_BURST_END_MS}):
-     * - 1st quiet gap → notify immediately (sole update, or mid-animation pass)
-     * - later quiet gaps → defer to burst-end so subscribers always see the final
-     *   width without a 3rd+ notify when frame timing is janky
-     */
-    private scheduleResizeNotify;
-    private observeContainer;
-    private applyContainerWidthSync;
-    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/types/core/src/managers/DragHandlerManager.d.ts

@@ -1,44 +0,0 @@
-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, rootHeaders: 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/types/core/src/managers/FilterManager.d.ts

@@ -1,36 +0,0 @@
-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/types/core/src/managers/PivotManager.d.ts

@@ -1,35 +0,0 @@
-import type HeaderObject from "../types/HeaderObject";
-import type { Accessor } from "../types/HeaderObject";
-import type Row from "../types/Row";
-import type { PivotConfig } from "../types/PivotTypes";
-export interface PivotManagerConfig {
-    sourceRows: Row[];
-    fieldHeaders: HeaderObject[];
-    pivot: PivotConfig | null;
-}
-export interface PivotManagerState {
-    active: boolean;
-    pivotedRows: Row[];
-    headers: HeaderObject[];
-    rowGrouping?: Accessor[];
-    pivot: PivotConfig | null;
-}
-type StateChangeCallback = (state: PivotManagerState) => void;
-export declare class PivotManager {
-    private config;
-    private state;
-    private subscribers;
-    private cacheKey;
-    constructor(config: PivotManagerConfig);
-    private buildCacheKey;
-    private computeState;
-    getState(): PivotManagerState;
-    isActive(): boolean;
-    getPivot(): PivotConfig | null;
-    updateConfig(partial: Partial<PivotManagerConfig>): void;
-    setPivot(pivot: PivotConfig | null): void;
-    subscribe(callback: StateChangeCallback): () => void;
-    private notifySubscribers;
-    destroy(): void;
-}
-export {};

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

@@ -1,56 +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 "../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/types/core/src/managers/RowSelectionManager.d.ts

@@ -1,72 +0,0 @@
-import TableRow from "../types/TableRow";
-import Row from "../types/Row";
-import RowSelectionChangeProps from "../types/RowSelectionChangeProps";
-import type { RowSelectionMode } from "../types/RowSelectionMode";
-export interface RowSelectionManagerConfig {
-    tableRows: TableRow[];
-    onRowSelectionChange?: (props: RowSelectionChangeProps) => void;
-    enableRowSelection?: boolean;
-    rowSelectionMode?: RowSelectionMode;
-    selectRowOnClick?: boolean;
-    showRowSelectionColumn?: boolean;
-    /** When true, Arrow/Home/End/Ctrl+A are left to SelectionManager; Space still toggles rows. */
-    selectableCells?: boolean;
-    /** Table root element used to decide whether keyboard events apply. */
-    tableRoot?: HTMLElement | null;
-}
-export interface RowSelectionManagerState {
-    selectedRows: Set<string>;
-    selectedRowCount: number;
-    selectedRowsData: Row[];
-    /** Keyboard focus / navigation target row id */
-    activeRowId: string | null;
-}
-type StateChangeCallback = (state: RowSelectionManagerState) => void;
-export declare class RowSelectionManager {
-    private config;
-    private state;
-    private subscribers;
-    /** Anchor for Shift+range selection */
-    private anchorRowId;
-    private keydownHandler;
-    constructor(config: RowSelectionManagerConfig);
-    updateConfig(config: Partial<RowSelectionManagerConfig>): void;
-    private getMode;
-    private updateDerivedState;
-    subscribe(callback: StateChangeCallback): () => void;
-    private notifySubscribers;
-    private fireChange;
-    private applySelection;
-    isRowSelected(rowId: string): boolean;
-    areAllRowsSelected(): boolean;
-    getSelectedRows(): Set<string>;
-    getSelectedRowCount(): number;
-    getSelectedRowsData(): Row[];
-    getRow(rowId: string): Row | undefined;
-    getActiveRowId(): string | null;
-    setActiveRowId(rowId: string | null): void;
-    setSelectedRows(selectedRows: Set<string>): void;
-    /**
-     * Set a row's selected state (does not toggle). Respects single/multiple mode.
-     */
-    handleRowSelect(rowId: string, isSelected: boolean): void;
-    selectRow(rowId: string): void;
-    deselectRow(rowId: string): void;
-    handleSelectAll(isSelected: boolean): void;
-    handleToggleRow(rowId: string): void;
-    /**
-     * Click-to-select: multiple toggles; single replaces.
-     */
-    handleRowClickSelect(rowId: string): void;
-    clearSelection(): void;
-    getState(): RowSelectionManagerState;
-    private setupKeyboardNavigation;
-    private isEventInsideTable;
-    private isTypingInFormField;
-    private findRowIndex;
-    private resolveActiveRowId;
-    private moveActiveRow;
-    private handleKeyDown;
-    destroy(): void;
-}
-export {};

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

@@ -1,38 +0,0 @@
-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;
-    /** Coalesce scroll-driven subscriber notifications to one rAF (avoids sync storms + reflow). */
-    private notifySubscribersRafId;
-    constructor(config: ScrollManagerConfig);
-    updateConfig(config: Partial<ScrollManagerConfig>): void;
-    subscribe(callback: StateChangeCallback): () => void;
-    private notifySubscribers;
-    private scheduleNotifySubscribersFromScroll;
-    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 {};

package/dist/types/core/src/managers/SectionScrollController.d.ts

@@ -1,74 +0,0 @@
-export type SectionId = "pinned-left" | "main" | "pinned-right";
-export type SectionPaneRole = "sticky" | "scrollbar" | "header" | "body";
-export interface SectionScrollControllerConfig {
-    /** Heavy body virtualization. Throttled to every {@link VIRTUALIZATION_THRESHOLD_PX}px. */
-    onMainSectionScrollLeft?: (scrollLeft: number) => void;
-}
-/**
- * Single controller for horizontal scroll sync across all four panes per section:
- * sticky parent, horizontal scrollbar segment, header, and body.
- * Scrolling any one pane updates the other three in that section.
- * All four panes must have the same scroll width (enforced by renderers).
- */
-export declare class SectionScrollController {
-    private scrollLeftBySection;
-    private panesBySection;
-    private scrollHandlers;
-    /** Non-passive touchmove handlers on header panes that cancel iOS touch scrolling. */
-    private headerTouchMoveHandlers;
-    private config;
-    /** Guard to avoid re-entrancy when we programmatically set scrollLeft on other panes */
-    private isSyncing;
-    /** Last scrollLeft at which we ran main-section virtualization; used to run heavy ops only every N px. */
-    private lastMainVirtualizationScrollLeft;
-    /**
-     * True while a touch-driven scroll (including post-release momentum) is in progress on a body
-     * pane. While true, we must not write scrollLeft to scroll-container followers (the horizontal
-     * scrollbar), because on iOS that cancels the body's inertial momentum. Such followers are
-     * reconciled once scrolling settles.
-     */
-    private isTouchScrolling;
-    /** Scroll-idle timer used to detect the end of a touch-driven scroll (incl. momentum). */
-    private touchSettleTimeoutId;
-    constructor(config?: SectionScrollControllerConfig);
-    updateConfig(config: Partial<SectionScrollControllerConfig>): void;
-    /**
-     * Register a pane (sticky, scrollbar, header, or body) for a section.
-     * When any registered pane scrolls, the others in the same section are updated.
-     * If a pane with the same role was already registered (e.g. after re-render), it is replaced.
-     */
-    registerPane(sectionId: SectionId, element: HTMLElement, role: SectionPaneRole): void;
-    /**
-     * Unregister a pane (e.g. when section is removed or re-created).
-     */
-    unregisterPane(sectionId: SectionId, element: HTMLElement): void;
-    /**
-     * Unregister all panes for a section (e.g. on cleanup).
-     */
-    unregisterSection(sectionId: SectionId): void;
-    /**
-     * Set scroll position for a section. Updates state and all registered panes.
-     * Used when a pane fires scroll and when restoring after render.
-     */
-    setSectionScrollLeft(sectionId: SectionId, value: number): void;
-    getSectionScrollLeft(sectionId: SectionId): number;
-    /**
-     * Restore scroll position to all registered panes from stored state (e.g. after render).
-     */
-    restoreAll(): void;
-    private addScrollListener;
-    /**
-     * Track touch-driven scrolling on a body pane. While a touch (and its post-release momentum) is
-     * active, scroll-container followers (the horizontal scrollbar) are not written, to preserve iOS
-     * momentum; they are reconciled when scrolling settles.
-     */
-    private addTouchTracking;
-    /**
-     * (Re)arm the scroll-idle timer that marks the end of a touch-driven scroll. When it fires (no
-     * scroll for the idle window, i.e. momentum has stopped), reconcile scroll-container followers
-     * (the scrollbar) to the final position, which we deliberately skipped during the touch scroll.
-     */
-    private scheduleTouchSettle;
-    private removeScrollListener;
-    destroy(): void;
-}