simple-table-core 4.1.6 → 4.1.7

package/dist/managers/AccordionController.d.ts

@@ -0,0 +1,39 @@
+import ColumnDef, { Accessor } from "../types/ColumnDef";
+import type { AnimationCoordinator, CellPosition } from "./AnimationCoordinator";
+import { type AccordionAxis } from "../utils/accordionAnimation";
+export interface AccordionHost {
+    animationCoordinator: AnimationCoordinator;
+    getRoot(): HTMLElement;
+    getAnimatableContainers(): HTMLElement[];
+    getHeaders(): ColumnDef[];
+    getCollapsedHeaders(): Set<Accessor>;
+    getEffectiveRowGrouping(): Accessor[] | undefined;
+    getCurrentBodyLayouts(): Map<HTMLElement, Map<string, CellPosition>>;
+    getExternalVerticalScroll(): {
+        clientHeight: number;
+        scrollHeight: number;
+        scrollTop: number;
+    } | null;
+}
+/**
+ * Owns accordion CSS class timing and when to capture a FLIP snapshot.
+ * Delegates the actual FLIP work to {@link AnimationCoordinator}.
+ */
+export declare class AccordionController {
+    private host;
+    private pendingAccordionAxis;
+    private accordionCleanupTimerId;
+    /** Leaf accessor + pin key from the last committed paint. */
+    private lastRenderedVisibilityKey;
+    constructor(host: AccordionHost);
+    getPendingAxis(): AccordionAxis;
+    clearPendingAxis(): void;
+    didColumnVisibilityChange(nextHeaders: ColumnDef[]): boolean;
+    /** Record the leaf/pin set that the last render actually painted. */
+    rememberRenderedHeaders(headers: ColumnDef[]): void;
+    captureSnapshot(): void;
+    begin(axis: AccordionAxis): void;
+    play(): void;
+    destroy(): void;
+    private updateAnimationVerticalScroll;
+}

package/dist/managers/AnimationCoordinator.d.ts

@@ -97,6 +97,10 @@ export declare class AnimationCoordinator {
      * transforms it left behind, so only the latest sort animates.
      */
     private scheduledFlip;
+    /** True while the user is dragging a column header to reorder. */
+    private columnReordering;
+    /** Holds and slides cells during column drag. Sort uses CSS transitions in play(). */
+    private readonly cellSlideAnimator;
     /**
      * Invoked immediately BEFORE a retained/ghost element is permanently removed
      * from the DOM (FLIP/shrink/cancel/destroy teardown). Lets framework adapters
@@ -116,8 +120,18 @@ export declare class AnimationCoordinator {
     setDuration(duration: number): void;
     setEasing(easing: string): void;
     isEnabled(): boolean;
+    /**
+     * Enter or leave column-header drag. Motion is owned by CellSlideAnimator.
+     * Left/top writes stay plain; the animator holds and slides after those writes.
+     */
+    setColumnReordering(active: boolean): void;
+    isColumnReordering(): boolean;
+    /** Snapshot header visuals before mid-drag left writes. */
+    beginColumnReorder(root: ParentNode): void;
+    /** Slide after left writes, same task, before paint. */
+    commitColumnReorder(root: ParentNode): void;
     isInFlight(cellId: string): boolean;
-    /** True while any FLIP / retained-cell transition is still running. */
+    /** True while any sort slide, retained cell, or column-reorder slide is running. */
     hasInFlight(): boolean;
     getDuration(): number;
     getEasing(): string;

package/dist/managers/AutoSizeManager.d.ts

@@ -0,0 +1,64 @@
+import ColumnDef, { Accessor } from "../types/ColumnDef";
+import Row from "../types/Row";
+import type { ResolvedIcons } from "../core/initialization/TableInitializer";
+import type TableRow from "../types/TableRow";
+import type Theme from "../types/Theme";
+export interface AutoSizeMeasureContext {
+    headers: ColumnDef[];
+    collapsedHeaders: Set<Accessor>;
+    styleRoot: ParentNode | null;
+    rows: Row[];
+    theme?: Theme;
+    icons: ResolvedIcons;
+    onRendererHostDiscard?: (host: HTMLElement) => void;
+}
+/**
+ * Content-fit column sizing (`width: "auto"`). Distinct from AutoScaleManager,
+ * which stretches already-measured natural widths to fill surplus container space.
+ */
+export declare class AutoSizeManager {
+    private autoSizeAccessors;
+    private pendingAutoSize;
+    private naturalWidths;
+    private isAutoSizing;
+    getAccessors(): Set<Accessor>;
+    getNaturalWidths(): Map<string, number>;
+    hasPending(): boolean;
+    recomputeAccessors(headers: ColumnDef[], collapsedHeaders: Set<Accessor>): void;
+    queuePendingFromAccessors(): void;
+    clearNaturalWidths(): void;
+    recordNaturalWidths(widths: Map<string, number>): void;
+    /**
+     * Shrink floors for auto-expand column resize, keyed by accessor. Each
+     * visible leaf's floor is its natural width — a user-set / content-measured
+     * override when present, else the pixel width declared in the column
+     * definitions — raised to at least its `minWidth`.
+     */
+    getShrinkFloors(headers: ColumnDef[], collapsedHeaders: Set<Accessor>, pristineDefaultHeaders: ColumnDef[]): Map<string, number>;
+    /**
+     * Measure pending auto columns. Returns updated headers when widths changed;
+     * otherwise null (nothing to apply). Always clears the pending set after a
+     * successful measure pass so we do not retry every render.
+     */
+    maybeMeasure(ctx: AutoSizeMeasureContext): ColumnDef[] | null;
+}
+export declare const getAutoSizeStyleRoot: (refs: {
+    mainBodyRef?: {
+        current: HTMLElement | null;
+    };
+    mainHeaderRef?: {
+        current: HTMLElement | null;
+    };
+    pinnedLeftHeaderRef?: {
+        current: HTMLElement | null;
+    };
+    pinnedRightHeaderRef?: {
+        current: HTMLElement | null;
+    };
+}) => ParentNode | null;
+export declare const getAutoSizeMeasureRows: (args: {
+    enablePagination?: boolean;
+    serverSidePagination?: boolean;
+    currentTableRows?: TableRow[];
+    localRows: Row[];
+}) => Row[];

package/dist/managers/CellSlideAnimator.d.ts

@@ -0,0 +1,54 @@
+/**
+ * Slide cells from a remembered visual position to their new layout slot.
+ *
+ * 1. Snapshot style-space visual (left + top, including live translate)
+ * 2. Render writes plain style.left / style.top
+ * 3. Hold = parkedFrom − written, then animate to parkedTo − written
+ *
+ * Far-off true coordinates are parked just outside the viewport and staggered.
+ * Mid-flight retargets cancel and replace. Column-drag bodies copy the header remain.
+ */
+/** Marks animations owned by this helper so they can be cancelled without touching others. */
+export declare const CELL_SLIDE_ANIM_ID = "st-cell-slide";
+export type CellSlideAnimatorOptions = {
+    duration?: number;
+};
+export type CellSlideKeyframe = {
+    element: HTMLElement;
+    id: string;
+    fromX: number;
+    fromY: number;
+    toX?: number;
+    toY?: number;
+    duration?: number;
+    easing?: string;
+    onFinish?: () => void;
+};
+export declare class CellSlideAnimator {
+    private active;
+    private duration;
+    /** Snapshot taken at beginOrderChange — visual before style.left/top rewrites. */
+    private pendingSnap;
+    private running;
+    constructor(opts?: CellSlideAnimatorOptions);
+    setDuration(duration: number): void;
+    setActive(active: boolean): void;
+    isActive(): boolean;
+    hasInFlight(): boolean;
+    /**
+     * Snapshot header visuals before mid-drag style.left rewrites.
+     */
+    beginOrderChange(root: ParentNode): void;
+    /**
+     * After style.left rewrites: hold from parked origin toward parked dest.
+     * Bodies get the same remain as their header.
+     */
+    commitOrderChange(root: ParentNode): void;
+    /**
+     * Run a hold+tween on one element. Cancels a prior slide on that node first.
+     */
+    animate(slide: CellSlideKeyframe): boolean;
+    destroy(): void;
+}
+/** @deprecated Use {@link CellSlideAnimator}. */
+export declare const ColumnReorderAnimator: typeof CellSlideAnimator;

package/dist/managers/DragHandlerManager.d.ts

@@ -4,6 +4,10 @@ export declare const getSiblingArray: (headers: ColumnDef[], indexPath: number[]
 export declare const setSiblingArray: (headers: ColumnDef[], indexPath: number[], newSiblings: ColumnDef[]) => ColumnDef[];
 export declare const getHeaderSection: (header: ColumnDef, rootHeaders: ColumnDef[]) => "left" | "main" | "right";
 export declare const updateHeaderPinnedProperty: (header: ColumnDef, targetSection: "left" | "main" | "right") => ColumnDef;
+/**
+ * Move the dragged sibling to the hovered index (remove + insert).
+ * Columns between those indices shift by one slot.
+ */
 export declare function swapHeaders(headers: ColumnDef[], draggedPath: number[], hoveredPath: number[]): {
     newHeaders: ColumnDef[];
     emergencyBreak: boolean;
@@ -16,29 +20,3 @@ export declare function insertHeaderAcrossSections({ headers, draggedHeader, hov
     newHeaders: ColumnDef[];
     emergencyBreak: boolean;
 };
-export interface DragHandlerManagerConfig {
-    headers: ColumnDef[];
-    essentialAccessors?: ReadonlySet<string>;
-    onTableHeaderDragEnd: (newHeaders: ColumnDef[]) => void;
-    onColumnOrderChange?: (newHeaders: ColumnDef[]) => void;
-    onHeadersChange?: (newHeaders: ColumnDef[]) => 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(): ColumnDef | null;
-    getHoveredHeader(): ColumnDef | null;
-    handleDragStart(header: ColumnDef): void;
-    handleDragOver({ event, hoveredHeader, }: {
-        event: DragEvent;
-        hoveredHeader: ColumnDef;
-    }): void;
-    handleDragEnd(): void;
-    destroy(): void;
-}

package/dist/managers/ExternalScrollController.d.ts

@@ -0,0 +1,68 @@
+import type { DimensionManager } from "./DimensionManager";
+import { type ExternalScrollMetrics, type ResolvedScrollParent, type ScrollParentValue } from "../utils/externalScroll";
+export interface ExternalScrollHost {
+    getScrollParent(): ScrollParentValue;
+    getHeight(): string | number | undefined | null;
+    getMaxHeight(): string | number | undefined | null;
+    getBodyContainer(): HTMLElement | null;
+    getRootElement(): HTMLElement | null;
+    getFallbackRoot(): HTMLElement;
+    isMounted(): boolean;
+    getDimensionManager(): DimensionManager | null;
+    onInternalScroll(e: Event): void;
+    onExternalScroll(metrics: ExternalScrollMetrics): void;
+    onExternalResize(): void;
+}
+/**
+ * Owns which element is the vertical scroller: the table body (internal) or a
+ * consumer `scrollParent` (external / window). Also tracks the visible
+ * viewport height used for virtualization in external mode.
+ */
+export declare class ExternalScrollController {
+    private host;
+    private resolvedScrollParent;
+    private externalScrollListener;
+    private externalWindowResizeListener;
+    private externalParentResizeObserver;
+    private externalViewportHeight;
+    private externalScrollRetryRaf;
+    private externalScrollRetryCount;
+    private bodyScrollListenerAttached;
+    private bodyContainerScrollListener;
+    /**
+     * When external scroll mode is active we briefly take control of the scroll
+     * parent's `overscroll-behavior-y` to neutralize the browser's rubber-band /
+     * scroll-chaining at the boundaries. Without this, pulling past the top or
+     * bottom of the scroll parent visually translates the entire scroll content
+     * layer (including the CSS-sticky header), causing the header to "disappear"
+     * during overscroll bounces even though its layout position is unchanged.
+     */
+    private overscrollBehaviorTarget;
+    private overscrollBehaviorPrev;
+    constructor(host: ExternalScrollHost);
+    getResolvedParent(): ResolvedScrollParent;
+    getViewportHeight(): number;
+    setViewportHeight(next: number): void;
+    /**
+     * Reconciles which element owns the vertical scroll listener based on the
+     * current `scrollParent` config. Idempotent — safe to call repeatedly.
+     */
+    sync(): void;
+    recomputeViewportHeight(): void;
+    getVerticalScrollMetrics(): {
+        clientHeight: number;
+        scrollHeight: number;
+        scrollTop: number;
+    } | null;
+    destroy(): void;
+    private scheduleParentRetry;
+    private ensureBodyScrollListenerAttached;
+    private ensureBodyScrollListenerDetached;
+    private attachExternalWiring;
+    private detachExternalWiring;
+    private applyOverscrollContainment;
+    private restoreOverscrollBehavior;
+    private recomputePaddingTop;
+    private handleExternalResize;
+    private handleExternalScroll;
+}

package/dist/managers/ScrollRenderCoalescer.d.ts

@@ -0,0 +1,32 @@
+import type { ScrollManager } from "./ScrollManager";
+export type ScrollRenderSource = "scroll-raf" | "scroll-end";
+export interface ScrollRenderCoalescerHost {
+    getScrollManager(): ScrollManager | null;
+    /** When true, pass container/content height into ScrollManager for infinite scroll. */
+    shouldTrackInfiniteScroll(): boolean;
+    onRender(source: ScrollRenderSource): void;
+}
+export interface ScrollFrameInput {
+    scrollTop: number;
+    scrollLeft: number;
+    containerHeight: number;
+    contentHeight: number;
+    /** Runs inside the rAF after scrollTop and direction are stored. */
+    afterApply?: () => void;
+}
+/**
+ * Coalesces vertical scroll into one rAF render, then one full render after
+ * scrolling stops. Shared by the table body scroller and an external scroll parent.
+ */
+export declare class ScrollRenderCoalescer {
+    private host;
+    private scrollRafId;
+    private scrollEndTimeoutId;
+    private lastScrollTop;
+    isScrolling: boolean;
+    scrollTop: number;
+    scrollDirection: "up" | "down" | "none";
+    constructor(host: ScrollRenderCoalescerHost);
+    schedule(frame: ScrollFrameInput): void;
+    destroy(): void;
+}

package/dist/managers/SelectionManager/mouseUtils.d.ts

@@ -4,13 +4,13 @@ import type Cell from "../../types/Cell";
  * 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;
+export declare function calculateNearestCell(clientX: number, clientY: number, root: HTMLElement | null): 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;
+export declare function getCellFromMousePosition(clientX: number, clientY: number, root: HTMLElement | null): 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;
+export declare function handleAutoScroll(clientX: number, clientY: number, root: HTMLElement | null): void;