simple-table-core 4.0.1 → 4.0.3

package/dist/src/managers/AnimationCoordinator.d.ts

@@ -1,356 +0,0 @@
-export interface AnimationCoordinatorOptions {
-    duration?: number;
-    easing?: string;
-}
-export interface CellPosition {
-    left: number;
-    top: number;
-    width: number;
-    height: number;
-}
-/**
- * FLIP-style animation coordinator for body cells with virtualization awareness.
- *
- * Triggered explicitly via {@link captureSnapshot} (before a layout-affecting
- * change) and {@link play} (after the renderer has placed cells at their new
- * positions).
- *
- * Three classes of cells participate in an animation:
- *   - Persistent cells (visible before AND after): the same DOM node moves to
- *     a new `top`/`left`; FLIP slides it from the old visual spot.
- *   - Incoming cells (off-screen before, in DOM after): the renderer creates
- *     them at their new position; if the snapshot has their pre-change
- *     position (computed for ALL rows, not just the band), FLIP slides them
- *     in from there. The portion that's outside the body's overflow clip is
- *     never painted, so cells appear to slide in from the viewport edge.
- *   - Outgoing cells (in DOM before, off-screen after): the renderer hands
- *     them to {@link retainCell} along with their post-change off-screen
- *     position; FLIP slides them out to that position, then removes them.
- */
-export declare class AnimationCoordinator {
-    private enabled;
-    private duration;
-    private easing;
-    /** Pre-change positions for any cell we want to consider for animation. */
-    private snapshot;
-    /**
-     * One-shot synthetic origins for incoming cells that have no entry in the
-     * captured snapshot (e.g. rows/columns that did not exist in the pre-render
-     * state because they were inside a collapsed group). Used by accordion
-     * animations so a newly-visible cell unfolds from its parent's position
-     * rather than appearing in place. Cleared at the end of {@link play}.
-     */
-    private incomingOrigins;
-    /**
-     * Accessors that were already renderable (visible leaf/group columns) in the
-     * pre-change layout for an in-flight accordion-horizontal toggle. Set once
-     * per collapse/expand render and consumed by the renderers' grow-from-zero
-     * gate so a column that merely re-enters the virtualization band (because the
-     * collapsed group shrank the content width and clamped scrollLeft) is NOT
-     * mistaken for a freshly-expanded column and animated from width 0.
-     *
-     * Header cells have no full pre-change conceptual layout the way body cells do
-     * (see SectionRenderer.getCurrentBodyLayouts), so `hasSnapshotEntry` alone
-     * can't tell "newly visible" apart from "scrolled back into view". This set
-     * supplies the missing pre-change visibility signal. Cleared at the end of
-     * {@link play}.
-     */
-    private accordionPreVisibleAccessors;
-    private inFlight;
-    /** Outgoing cells the renderer handed off; keyed per container so play() finds them. */
-    private retainedCells;
-    private prefersReducedMotion;
-    /**
-     * Per-render cache of scroller layout metrics. Reading
-     * `scrollHeight`/`clientHeight`/etc. after a style mutation forces a sync
-     * layout flush; without this cache, scaleFlipDistance() forces a fresh
-     * flush for every cell in the retain/play loops, turning a single sort
-     * into hundreds of layout passes (observed: 513ms in `msRemove` for ~287
-     * cells, growing across consecutive sorts as DOM size grows). The cache
-     * is cleared at the boundaries of a render cycle (captureSnapshot start
-     * and play end / cancel) since column count and section heights are
-     * stable within a single sort.
-     */
-    private scrollerMetricsCache;
-    /**
-     * Vertical scroller metrics override for external/page-scroll mode. When the
-     * table has no internal vertical overflow (it grows to its natural height and
-     * a parent element / the window scrolls), the body container's own
-     * clientHeight/scrollHeight no longer describe the visible viewport, so
-     * {@link scaleFlipDistance} can't bound the FLIP journey and sort cells slide
-     * the full conceptual distance. The vanilla table pushes the real visible
-     * viewport here (from the same `getExternalScrollMetrics` the virtualizer
-     * uses) so the y-axis FLIP scaling matches the on-screen viewport. `null`
-     * when external scroll is inactive — internal scroller metrics are used as-is.
-     */
-    private externalVerticalScroll;
-    /**
-     * The currently-scheduled (not-yet-started) FLIP frame. play() defers the
-     * transition start by two animation frames so the inverted "First" frame
-     * gets painted before the transition fires. Spam-clicking sort triggers a
-     * full re-render + play() inside that two-frame window: without coalescing,
-     * the stale chain's startTransition zeroes the transforms the newer cycle
-     * just inverted (a frame early), so the final transition animates
-     * identity→identity and nothing visibly moves — and many captured nodes are
-     * detached by the intervening render before they ever transition. Tracking
-     *     the pending frame lets a new play() cancel the prior cycle and reset the
-     * transforms it left behind, so only the latest sort animates.
-     */
-    private scheduledFlip;
-    /**
-     * Invoked immediately BEFORE a retained/ghost element is permanently removed
-     * from the DOM (FLIP/shrink/cancel/destroy teardown). Lets framework adapters
-     * tear down renderer subtrees (React portals, etc.) mounted into the element
-     * before it's discarded. NOT called on reuse/reparent paths
-     * ({@link claimRetainedForReuse} success), so a reclaimed ghost keeps its
-     * content.
-     */
-    private onHostDiscard?;
-    constructor(opts?: AnimationCoordinatorOptions);
-    /**
-     * Register the callback fired before a ghost/retained element is permanently
-     * removed (see {@link onHostDiscard}). Additive: passing `undefined` disables it.
-     */
-    setOnHostDiscard(cb: ((host: HTMLElement) => void) | undefined): void;
-    setEnabled(enabled: boolean): void;
-    setDuration(duration: number): void;
-    setEasing(easing: string): void;
-    isEnabled(): boolean;
-    isInFlight(cellId: string): boolean;
-    /** True while any FLIP / retained-cell transition is still running. */
-    hasInFlight(): boolean;
-    getDuration(): number;
-    getEasing(): string;
-    /**
-     * Register synthetic pre-change origins for incoming cells that did not
-     * exist in the captured snapshot. {@link play} consults this map before
-     * giving up on a cell that has no `before` snapshot entry; matching cells
-     * FLIP from the override origin to their final position.
-     *
-     * The map is consumed by the next `play()` call and cleared, so callers
-     * must set it after `captureSnapshot` and before the render that creates
-     * the corresponding cells.
-     */
-    setIncomingOrigins(origins: Map<string, CellPosition> | null): void;
-    /**
-     * Register the set of accessors that were renderable in the pre-change layout
-     * of an accordion-horizontal toggle. Must be set after `captureSnapshot` and
-     * before the render that creates cells. Consumed and cleared by the next
-     * {@link play}. Pass `null` (e.g. for vertical/row accordions) to disable the
-     * re-entry guard so behavior is unchanged.
-     */
-    setAccordionPreVisibleAccessors(accessors: Set<string> | null): void;
-    /**
-     * True when `accessor` was already a renderable column before the current
-     * accordion-horizontal toggle. Renderers use this to skip the grow-from-zero
-     * animation for columns that only re-entered the virtualization band rather
-     * than genuinely becoming visible from an expand.
-     */
-    wasRenderableBeforeAccordion(accessor: string): boolean;
-    /**
-     * Read scroller layout metrics for `container`, caching the result for the
-     * remainder of the current render cycle. Subsequent calls in the same
-     * cycle (e.g. for every cell in a retain or play loop) skip the DOM read,
-     * which would otherwise force a synchronous layout flush after each style
-     * mutation in the loop.
-     */
-    private getScrollerMetrics;
-    /**
-     * Supply (or clear) the vertical scroller metrics override used by
-     * {@link scaleFlipDistance} in external/page-scroll mode. Must be set before
-     * `captureSnapshot`/`retainCell`/`play` so the whole FLIP cycle scales
-     * against the real visible viewport. Pass `null` to fall back to the body
-     * container's own metrics (internal scroll).
-     */
-    setExternalVerticalScroll(metrics: {
-        clientHeight: number;
-        scrollHeight: number;
-        scrollTop: number;
-    } | null): void;
-    private clearScrollerMetricsCache;
-    /**
-     * Capture pre-change positions for cells we may want to animate.
-     *
-     * @param args.containers Body containers; rendered cells are read from the DOM.
-     * @param args.preLayouts Optional per-container conceptual layout. Should
-     *   include positions for ALL rows in the dataset (not just the visible
-     *   band) so cells that newly enter the band can FLIP in from their actual
-     *   pre-change location and cells that leave the band can FLIP out to it.
-     */
-    captureSnapshot(args: {
-        containers: Array<HTMLElement | null | undefined>;
-        preLayouts?: Map<HTMLElement, Map<string, CellPosition>>;
-    }): void;
-    /**
-     * The renderer asks before removing a cell whether the coordinator wants to
-     * keep it for an out-animation.
-     */
-    shouldRetain(cellId: string): boolean;
-    /**
-     * Whether the captured snapshot has an entry for the given cellId. The
-     * accordion expand path uses this to detect "newly visible" cells (no
-     * pre-change layout) so it can initialize them at zero size and let the
-     * CSS transition grow them to full size.
-     */
-    hasSnapshotEntry(cellId: string): boolean;
-    /**
-     * True when the snapshot has an entry for `cellId` AND the cell was
-     * rendered in `currentContainer` at snapshot time. Returns false when the
-     * cell came from a different container (cross-section pin/unpin) — its
-     * snapshot position is in another container's coordinate frame, so a
-     * FLIP applied locally would slide from a wrong visual origin and the
-     * destination renderer should treat the cell as fresh (accordion grow
-     * from 0 instead).
-     *
-     * Snapshot entries with `sourceContainer === null` (preLayouts /
-     * conceptual positions) are treated as same-container so the existing
-     * sort/reorder FLIP-from-off-screen behavior is preserved.
-     */
-    hasSnapshotEntryInContainer(cellId: string, currentContainer: HTMLElement): boolean;
-    /**
-     * Whether a vertical position transition should be animated. Rows that live
-     * only in the virtualization padding band (above/below the visible viewport)
-     * should teleport rather than FLIP — otherwise a mid-scroll sort animates
-     * hundreds of off-screen rows through the viewport at once.
-     */
-    shouldAnimateVerticalTransition(args: {
-        beforeTop: number;
-        afterTop: number;
-        cellHeight: number;
-        container: HTMLElement;
-    }): boolean;
-    /**
-     * Whether a horizontal position transition should be animated. Same viewport
-     * gate as {@link shouldAnimateVerticalTransition} but for column slides.
-     */
-    shouldAnimateHorizontalTransition(args: {
-        beforeLeft: number;
-        afterLeft: number;
-        cellWidth: number;
-        container: HTMLElement;
-    }): boolean;
-    /**
-     * Whether a cell's position change should participate in FLIP animation.
-     * Only axes that actually moved are checked against the viewport gate —
-     * a vertical sort must not inherit "visible" from an unchanged horizontal
-     * position (which would retain/mount every column in every padding-band row).
-     */
-    shouldAnimateTransition(args: {
-        beforeTop: number;
-        afterTop: number;
-        beforeLeft: number;
-        afterLeft: number;
-        cellHeight: number;
-        cellWidth: number;
-        container: HTMLElement;
-    }): boolean;
-    /**
-     * Whether an incoming cell (in the snapshot but not previously in the DOM)
-     * should be mounted for this sort/reorder render. Padding-band rows that
-     * never intersect the visible viewport are deferred to the next scroll
-     * render so they do not pop into existence at animation start.
-     */
-    shouldMountIncomingCell(args: {
-        cellId: string;
-        afterTop: number;
-        afterLeft: number;
-        cellHeight: number;
-        cellWidth: number;
-        container: HTMLElement;
-    }): boolean;
-    /**
-     * Whether the cell currently paints inside the body scrollers' clip rects.
-     * Outgoing retain decisions use this as a fallback when {@link shouldAnimateTransition}
-     * rejects a cell based on `style.top`/`style.left` alone: virtualization padding
-     * rows can sit with their leading edge outside the scroll band while still being
-     * partially visible on screen (common at the bottom when scrolled to the end).
-     */
-    isCellRenderedInScrollerViewport(element: HTMLElement, container: HTMLElement): boolean;
-    /**
-     * Whether an outgoing DOM cell at a vertical scroll extreme (top or bottom of
-     * the dataset) should be retained even when {@link shouldAnimateTransition}
-     * rejects it on leading-edge grounds. Virtualization keeps a few overscan
-     * rows mounted above/below the strict viewport at max scroll; those rows
-     * must still slide out as ghosts when a sort evicts them.
-     */
-    shouldRetainDomCellAtScrollExtrema(cellId: string, container: HTMLElement): boolean;
-    /**
-     * Hand a cell that the renderer would otherwise remove to the coordinator.
-     * The coordinator updates its absolute positioning to the post-change layout
-     * and will animate it from the snapshotted pre-change visual position to
-     * that new position during {@link play}, then remove it from the DOM.
-     *
-     * The new position can be off-screen (e.g. the row sorted to a position
-     * outside the visible band) — the body container's `overflow: hidden`
-     * naturally clips the cell as it slides past the viewport edge.
-     */
-    retainCell(args: {
-        cellId: string;
-        element: HTMLElement;
-        container: HTMLElement;
-        newPosition: CellPosition;
-    }): void;
-    /**
-     * Take ownership of a retained (outgoing) ghost element so the renderer can
-     * promote it back to a live cell — rather than tearing it down and creating
-     * a fresh node — when its row becomes visible again. Returns the element
-     * with its retained-only attributes/state stripped, or `null` if no ghost
-     * is currently retained for this id in the container.
-     *
-     * Reusing the ghost preserves DOM continuity: the next play() step reads
-     * the cell's mid-flight visual position from the snapshot (captured before
-     * the render) and FLIPs it from there to its new live destination, so the
-     * row glides instead of disappearing and a freshly created replacement
-     * doesn't pop into existence at a clipped FLIP entry point.
-     */
-    claimRetainedForReuse(cellId: string, container: HTMLElement): HTMLElement | null;
-    /**
-     * Hand off a cell that the renderer would otherwise remove for an accordion
-     * shrink-out (column hide / pin-out from this section): the cell stays in
-     * place and its size in the named axis is animated to zero by the
-     * `.st-accordion-animating` CSS transition (width/height). Removed from the
-     * DOM after the transition completes.
-     *
-     * Used when there is no destination position for the cell in the current
-     * section's post-render layout — either because the column was hidden or
-     * because it moved to a different pinned section. In the moved-section
-     * case, the destination section creates a fresh cell that grows from zero
-     * width via the existing accordion incoming-cell path, so the visual
-     * effect is a synchronized shrink-here / grow-there pair rather than a
-     * cross-container slide (which would require translating coordinates
-     * between two different container coordinate frames).
-     */
-    shrinkOutCell(args: {
-        cellId: string;
-        element: HTMLElement;
-        container: HTMLElement;
-        axis: "horizontal" | "vertical";
-    }): void;
-    /**
-     * Discard any retained cell with this id in the given container. Called by
-     * the renderer when it's about to create a fresh cell with the same id, so
-     * we don't have two DOM nodes claiming the same logical slot.
-     */
-    discardRetainedIfPresent(cellId: string, container: HTMLElement): void;
-    /**
-     * Apply the FLIP invert + play step to every cell present in the snapshot
-     * that is now in the DOM (either as an actively rendered cell or as a
-     * retained cell). Clears the snapshot.
-     */
-    play(args: {
-        containers: Array<HTMLElement | null | undefined>;
-    }): void;
-    /**
-     * Cancel every in-flight transition and clear any armed snapshot. Active
-     * cells snap to their final positions; retained cells are removed from the
-     * DOM so we don't leak nodes.
-     */
-    cancel(): void;
-    destroy(): void;
-    private readPosition;
-    private startTransition;
-    private cancelInFlight;
-    private finalizeCell;
-    private finishElement;
-    private isCellRetained;
-}

package/dist/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/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/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/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/src/managers/SelectionManager/mouseUtils.d.ts

@@ -1,16 +0,0 @@
-import type Cell from "../../types/Cell";
-/**
- * Calculate the nearest cell to a given mouse position.
- * Uses row buckets: one getBoundingClientRect per row to find the row, then only
- * measures cells in that row (O(rows + cols) instead of O(rows * cols)).
- */
-export declare function calculateNearestCell(clientX: number, clientY: number, root?: Document | HTMLElement): Cell | null;
-/**
- * Get cell from mouse position (element under point, or nearest cell).
- */
-export declare function getCellFromMousePosition(clientX: number, clientY: number, root?: Document | HTMLElement): Cell | null;
-/**
- * Handle auto-scrolling when dragging near table edges.
- * @param root - Table root (e.g. `.simple-table-root`); limits queries to this instance.
- */
-export declare function handleAutoScroll(clientX: number, clientY: number, root?: Document | HTMLElement): void;

package/dist/src/managers/TableManager.d.ts

@@ -1,72 +0,0 @@
-import HeaderObject, { Accessor } from "../types/HeaderObject";
-import Row from "../types/Row";
-import SortColumn, { SortDirection } from "../types/SortColumn";
-import { TableFilterState } from "../types/FilterTypes";
-import { ColumnVisibilityState } from "../types/ColumnVisibilityTypes";
-import { CustomTheme } from "../types/CustomTheme";
-import { GetRowId } from "../types/GetRowId";
-import { SortManager } from "./SortManager";
-import { FilterManager } from "./FilterManager";
-import { RowManager } from "./RowManager";
-import { ColumnManager } from "./ColumnManager";
-import { DimensionManager } from "./DimensionManager";
-import { ScrollManager } from "./ScrollManager";
-import { SelectionManager } from "./SelectionManager";
-export interface TableManagerConfig {
-    headers: HeaderObject[];
-    rows: Row[];
-    rowHeight: number;
-    headerHeight?: number;
-    customTheme: CustomTheme;
-    externalSortHandling?: boolean;
-    externalFilterHandling?: boolean;
-    rowGrouping?: Accessor[];
-    getRowId?: GetRowId;
-    selectableCells?: boolean;
-    selectableColumns?: boolean;
-    enableRowSelection?: boolean;
-    copyHeadersToClipboard?: boolean;
-    height?: string | number;
-    maxHeight?: string | number;
-    initialSortColumn?: string;
-    initialSortDirection?: SortDirection;
-    onSortChange?: (sort: SortColumn | null) => void;
-    onFilterChange?: (filters: TableFilterState) => void;
-    onColumnOrderChange?: (newHeaders: HeaderObject[]) => void;
-    onColumnVisibilityChange?: (visibilityState: ColumnVisibilityState) => void;
-    onColumnWidthChange?: (headers: HeaderObject[]) => void;
-    onLoadMore?: () => void;
-    onCellEdit?: (props: any) => void;
-    announce?: (message: string) => void;
-    containerElement?: HTMLElement;
-    cellRegistry?: Map<string, any>;
-    collapsedHeaders?: Set<Accessor>;
-}
-export interface TableManagerState {
-    isReady: boolean;
-}
-type StateChangeCallback = () => void;
-export declare class TableManager {
-    private config;
-    private state;
-    private subscribers;
-    sortManager: SortManager;
-    filterManager: FilterManager;
-    rowManager: RowManager;
-    columnManager: ColumnManager;
-    dimensionManager: DimensionManager;
-    scrollManager: ScrollManager;
-    selectionManager: SelectionManager;
-    constructor(config: TableManagerConfig);
-    private setupManagerSubscriptions;
-    private applyFiltersAndSort;
-    private handleSortChange;
-    private handleFilterChange;
-    updateConfig(config: Partial<TableManagerConfig>): void;
-    subscribe(callback: StateChangeCallback): () => void;
-    private notifySubscribers;
-    getState(): TableManagerState;
-    isReady(): boolean;
-    destroy(): void;
-}
-export {};

package/dist/src/types/AnimationsConfig.d.ts

@@ -1,16 +0,0 @@
-/**
- * Configuration for cell animations on sort and programmatic column reorder.
- *
- * The animation coordinator runs FLIP-style transitions when cells move between
- * positions. All fields are optional; omit the prop entirely to use defaults.
- *
- * Row group expand/collapse never animates when `rowGrouping` is configured.
- */
-export interface AnimationsConfig {
-    /** Master toggle. Defaults to `true`. When `false`, no other field has effect. */
-    enabled?: boolean;
-    /** Animation duration in milliseconds. Defaults to `240`. */
-    duration?: number;
-    /** CSS easing function. Defaults to `cubic-bezier(0.2, 0.8, 0.2, 1)`. */
-    easing?: string;
-}