simple-table-core 4.0.0 → 4.0.2

package/dist/{cjs/src/managers → managers}/AutoScaleManager.d.ts

@@ -1,33 +1,33 @@
-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 {};
+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 → managers}/ColumnManager.d.ts

@@ -1,42 +1,42 @@
-import HeaderObject, { Accessor } from "../types/HeaderObject";
-import { ColumnVisibilityState } from "../types/ColumnVisibilityTypes";
-export interface ColumnManagerConfig {
-    headers: HeaderObject[];
-    collapsedHeaders: Set<Accessor>;
-    onColumnOrderChange?: (newHeaders: HeaderObject[]) => void;
-    onColumnVisibilityChange?: (visibilityState: ColumnVisibilityState) => void;
-    onColumnWidthChange?: (headers: HeaderObject[]) => void;
-}
-export interface ColumnManagerState {
-    headers: HeaderObject[];
-    collapsedHeaders: Set<Accessor>;
-    columnVisibility: ColumnVisibilityState;
-    draggedHeader: HeaderObject | null;
-    hoveredHeader: HeaderObject | null;
-}
-type StateChangeCallback = (state: ColumnManagerState) => void;
-export declare class ColumnManager {
-    private config;
-    private state;
-    private subscribers;
-    constructor(config: ColumnManagerConfig);
-    private buildColumnVisibilityState;
-    updateConfig(config: Partial<ColumnManagerConfig>): void;
-    subscribe(callback: StateChangeCallback): () => void;
-    private notifySubscribers;
-    setHeaders(headers: HeaderObject[]): void;
-    setCollapsedHeaders(collapsedHeaders: Set<Accessor>): void;
-    toggleColumnCollapse(accessor: Accessor): void;
-    setColumnVisibility(accessor: Accessor, visible: boolean): void;
-    updateColumnWidth(accessor: Accessor, width: number | string): void;
-    reorderColumns(newHeaders: HeaderObject[]): void;
-    setDraggedHeader(header: HeaderObject | null): void;
-    setHoveredHeader(header: HeaderObject | null): void;
-    getState(): ColumnManagerState;
-    getHeaders(): HeaderObject[];
-    getCollapsedHeaders(): Set<Accessor>;
-    getColumnVisibility(): ColumnVisibilityState;
-    isColumnVisible(accessor: Accessor): boolean;
-    destroy(): void;
-}
-export {};
+import HeaderObject, { Accessor } from "../types/HeaderObject";
+import { ColumnVisibilityState } from "../types/ColumnVisibilityTypes";
+export interface ColumnManagerConfig {
+    headers: HeaderObject[];
+    collapsedHeaders: Set<Accessor>;
+    onColumnOrderChange?: (newHeaders: HeaderObject[]) => void;
+    onColumnVisibilityChange?: (visibilityState: ColumnVisibilityState) => void;
+    onColumnWidthChange?: (headers: HeaderObject[]) => void;
+}
+export interface ColumnManagerState {
+    headers: HeaderObject[];
+    collapsedHeaders: Set<Accessor>;
+    columnVisibility: ColumnVisibilityState;
+    draggedHeader: HeaderObject | null;
+    hoveredHeader: HeaderObject | null;
+}
+type StateChangeCallback = (state: ColumnManagerState) => void;
+export declare class ColumnManager {
+    private config;
+    private state;
+    private subscribers;
+    constructor(config: ColumnManagerConfig);
+    private buildColumnVisibilityState;
+    updateConfig(config: Partial<ColumnManagerConfig>): void;
+    subscribe(callback: StateChangeCallback): () => void;
+    private notifySubscribers;
+    setHeaders(headers: HeaderObject[]): void;
+    setCollapsedHeaders(collapsedHeaders: Set<Accessor>): void;
+    toggleColumnCollapse(accessor: Accessor): void;
+    setColumnVisibility(accessor: Accessor, visible: boolean): void;
+    updateColumnWidth(accessor: Accessor, width: number | string): void;
+    reorderColumns(newHeaders: HeaderObject[]): void;
+    setDraggedHeader(header: HeaderObject | null): void;
+    setHoveredHeader(header: HeaderObject | null): void;
+    getState(): ColumnManagerState;
+    getHeaders(): HeaderObject[];
+    getCollapsedHeaders(): Set<Accessor>;
+    getColumnVisibility(): ColumnVisibilityState;
+    isColumnVisible(accessor: Accessor): boolean;
+    destroy(): void;
+}
+export {};

package/dist/{cjs/src/managers → managers}/DimensionManager.d.ts

@@ -1,84 +1,84 @@
-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 {};
+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 → managers}/DragHandlerManager.d.ts

@@ -1,44 +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, 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;
-}
+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/{src/managers → managers}/FilterManager.d.ts

@@ -1,36 +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 {};
+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/{src/managers → managers}/PivotManager.d.ts

@@ -1,35 +1,35 @@
-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 {};
+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 {};