simple-table-core 4.0.1 → 4.0.3

package/dist/cjs/src/core/api/TableAPIImpl.d.ts

@@ -1,78 +0,0 @@
-import { TableAPI } from "../../types/TableAPI";
-import { SimpleTableConfig } from "../../types/SimpleTableConfig";
-import HeaderObject, { Accessor } from "../../types/HeaderObject";
-import Row from "../../types/Row";
-import { CustomTheme } from "../../types/CustomTheme";
-import RowState from "../../types/RowState";
-import { SelectionManager } from "../../managers/SelectionManager";
-import { RowSelectionManager } from "../../managers/RowSelectionManager";
-import { SortManager } from "../../managers/SortManager";
-import { FilterManager } from "../../managers/FilterManager";
-import { FlattenRowsResult } from "../../utils/rowFlattening";
-import { ProcessRowsResult } from "../../utils/rowProcessing";
-import type { PivotConfig } from "../../types/PivotTypes";
-export interface TableAPIContext {
-    config: SimpleTableConfig;
-    localRows: Row[];
-    effectiveHeaders: HeaderObject[];
-    headers: HeaderObject[];
-    /** Pristine snapshot of the configured column definitions (see SimpleTableVanilla.pristineDefaultHeaders). */
-    getPristineDefaultHeaders: () => HeaderObject[];
-    essentialAccessors: Set<string>;
-    customTheme: CustomTheme;
-    currentPage: number;
-    /** Returns current page from live state (use this in API getCurrentPage so it stays correct after setPage). */
-    getCurrentPage: () => number;
-    expandedRows: Map<string, number>;
-    collapsedRows: Map<string, number>;
-    expandedDepths: Set<number>;
-    clearExpandedRows: () => void;
-    clearCollapsedRows: () => void;
-    rowStateMap: Map<string | number, RowState>;
-    headerRegistry: Map<string, any>;
-    cellRegistry?: Map<string, {
-        updateContent: (value: any) => void;
-    }>;
-    /**
-     * Whether a cell (by its `getCellId` key) is currently mid-FLIP-animation.
-     * Live `updateData` content writes are skipped for animating cells so a
-     * data tick doesn't re-render / mutate a cell that is sliding to a new
-     * position (which causes visible jank). The underlying row data is still
-     * updated; only the in-place DOM refresh is deferred to the next tick or
-     * re-render once the animation settles.
-     */
-    isCellAnimating?: (cellId: string) => boolean;
-    /** True while any FLIP cell transition is in flight (blocks live re-sort/re-filter). */
-    hasAnimatingCells?: () => boolean;
-    columnEditorOpen: boolean;
-    expandedDepthsManager: any;
-    selectionManager: SelectionManager | null;
-    rowSelectionManager: RowSelectionManager | null;
-    sortManager: SortManager | null;
-    filterManager: FilterManager | null;
-    getCachedFlattenResult?: () => FlattenRowsResult | null;
-    getCachedProcessedResult?: () => ProcessRowsResult | null;
-    onRender: () => void;
-    /**
-     * Bust the flatten / body row caches so the next render re-runs quick filter
-     * (and related processing) against in-place mutated row values.
-     */
-    invalidateRowsCache?: () => void;
-    /**
-     * Run `fn` without capturing a FLIP snapshot when sort/filter subscribers
-     * fire. Used for live-update-driven reorder/visibility changes so high-
-     * frequency ticks don't spam sort animations.
-     */
-    runWithoutAnimationSnapshot?: (fn: () => void) => void;
-    setHeaders: (headers: HeaderObject[]) => void;
-    setCurrentPage: (page: number) => void;
-    setColumnEditorOpen: (open: boolean) => void;
-    getEffectiveRowGrouping: () => Accessor[] | undefined;
-    setPivot: (config: PivotConfig | null) => void;
-    getPivot: () => PivotConfig | null;
-    getPivotHeaders: () => HeaderObject[];
-    getPivotedRows: () => Row[];
-}
-export declare class TableAPIImpl {
-    static createAPI(context: TableAPIContext): TableAPI;
-}

package/dist/cjs/src/core/rendering/SectionRenderer.d.ts

@@ -1,119 +0,0 @@
-import HeaderObject, { Accessor } from "../../types/HeaderObject";
-import { HeaderRenderContext } from "../../utils/headerCellRenderer";
-import { CellRenderContext } from "../../utils/bodyCellRenderer";
-import TableRow from "../../types/TableRow";
-import type { AnimationCoordinator, CellPosition } from "../../managers/AnimationCoordinator";
-export interface HeaderSectionParams {
-    headers: HeaderObject[];
-    collapsedHeaders: Set<Accessor>;
-    pinned?: "left" | "right";
-    maxHeaderDepth: number;
-    headerHeight: number;
-    context: HeaderRenderContext;
-    sectionWidth?: number;
-    startColIndex?: number;
-}
-export interface BodySectionParams {
-    headers: HeaderObject[];
-    rows: TableRow[];
-    collapsedHeaders: Set<Accessor>;
-    pinned?: "left" | "right";
-    context: CellRenderContext;
-    sectionWidth?: number;
-    rowHeight: number;
-    heightOffsets?: Array<[number, number]>;
-    totalRowCount?: number;
-    startColIndex?: number;
-    /** When true, only update cell positions for existing cells (scroll performance). */
-    positionOnly?: boolean;
-    /** Full table rows ref + range for range-based body cell cache (avoids cache miss on every scroll). */
-    fullTableRows?: TableRow[];
-    renderedStartIndex?: number;
-    renderedEndIndex?: number;
-    /** Full pre-pagination flattened rows (used by animation snapshot to include
-     * off-page rows so cross-page sort can FLIP cells in/out from off-screen). */
-    allFlattenedRows?: TableRow[];
-    /** Global flattened-list index where the current page starts. Used to offset
-     * absolute positions in {@link allFlattenedRows} so on-page rows align with
-     * the page-relative DOM positions while off-page rows fall above/below. */
-    pageStartIndex?: number;
-    /** When provided, body cell renderer hands outgoing cells to the coordinator
-     * for FLIP-style out-animation instead of removing them immediately. */
-    animationCoordinator?: AnimationCoordinator;
-}
-export declare class SectionRenderer {
-    private headerSections;
-    private bodySections;
-    /**
-     * Callback fired before a body cell host element is permanently removed in
-     * the {@link invalidateCache} "all" path (which wipes every rendered cell).
-     * Threaded down from the table config so framework adapters can tear down
-     * renderer subtrees (React portals, etc.) before the nodes are discarded.
-     */
-    private onRendererHostDiscard?;
-    private bodyCellsCache;
-    private headerCellsCache;
-    private contextCache;
-    private bodySectionSnapshots;
-    private nextColIndexMap;
-    private stateRowsMap;
-    private nestedGridRowsMap;
-    renderHeaderSection(params: HeaderSectionParams): HTMLElement;
-    renderBodySection(params: BodySectionParams): HTMLElement;
-    private renderNestedGridRows;
-    private renderStateRows;
-    private calculateAbsoluteHeaderCells;
-    private calculateAbsoluteBodyCells;
-    private getLeafHeaders;
-    private createHeadersHash;
-    private createHeightOffsetsHash;
-    private createContextHash;
-    private getCachedBodyCells;
-    private getCachedHeaderCells;
-    private getCachedContext;
-    setOnRendererHostDiscard(cb: ((host: HTMLElement) => void) | undefined): void;
-    invalidateCache(type?: "body" | "header" | "context" | "all"): void;
-    /**
-     * Get the next colIndex after rendering a section
-     */
-    getNextColIndex(sectionKey: string): number;
-    /**
-     * Build a per-section layout map covering every cell in the dataset (every
-     * row × every leaf header), not just the cells in the current virtualization
-     * band. Used by the animation coordinator: it needs positions for off-screen
-     * rows so that:
-     *
-     *   - Cells that newly enter the visible band (e.g. row sorted from bottom
-     *     to top) can FLIP in from their actual pre-change off-screen `top`.
-     *   - Cells that leave the visible band (e.g. row sorted from top to
-     *     bottom) can be retained and slid to their actual post-change
-     *     off-screen `top` before being removed.
-     *
-     * The body container clips overflow so cells whose interpolated position
-     * falls outside the viewport simply aren't painted — the animation looks
-     * like a slide in from / out to the viewport edge.
-     */
-    getCurrentBodyLayouts(): Map<HTMLElement, Map<string, CellPosition>>;
-    /**
-     * Compute every cell position the section currently knows about (every row
-     * × every leaf header), including positions for off-screen rows, by using
-     * the most recent snapshot config for `sectionKey`. Returns null if no
-     * snapshot has been captured for this section yet.
-     */
-    getFullSectionLayout(sectionKey: string): Map<string, CellPosition> | null;
-    /**
-     * Refresh the per-section snapshot config so getCurrentBodyLayouts can
-     * recompute positions for any row × column combination the section
-     * currently knows about.
-     */
-    private captureSnapshotConfig;
-    /**
-     * Tear down all body sections and forget them so a subsequent
-     * `renderBodySection` creates fresh nodes. Used when the empty-state path
-     * takes over the body container: clearing `innerHTML` alone leaves
-     * `renderedCells` pointing at detached nodes, so rows never remount when
-     * data returns (e.g. typing `-E` mid-filter briefly matches every row).
-     */
-    releaseBodySections(): void;
-    cleanup(): void;
-}

package/dist/cjs/src/hooks/ariaAnnouncements.d.ts

@@ -1,37 +0,0 @@
-/**
- * Manages aria-live announcements for screen readers.
- * This is a vanilla JS alternative to the useAriaAnnouncements hook.
- *
- * Provides a way to announce dynamic content changes to assistive technologies.
- */
-export declare class AriaAnnouncementManager {
-    private announcement;
-    private timeoutId;
-    private observers;
-    /**
-     * Announces a message to screen readers
-     * The message will be cleared after 1 second to allow for new announcements
-     * @param message - The message to announce
-     */
-    announce(message: string): void;
-    /**
-     * Gets the current announcement message
-     * @returns The current announcement string
-     */
-    getAnnouncement(): string;
-    /**
-     * Subscribes to announcement changes
-     * @param callback - Function to call when announcement changes
-     * @returns Unsubscribe function
-     */
-    subscribe(callback: (message: string) => void): () => void;
-    /**
-     * Notifies all observers of announcement changes
-     */
-    private notifyObservers;
-    /**
-     * Cleans up the manager and clears any pending timeouts
-     */
-    destroy(): void;
-}
-export default AriaAnnouncementManager;

package/dist/cjs/src/hooks/contentHeight.d.ts

@@ -1,29 +0,0 @@
-export interface ContentHeightConfig {
-    height?: string | number;
-    maxHeight?: string | number;
-    rowHeight: number;
-    shouldPaginate?: boolean;
-    rowsPerPage?: number;
-    totalRowCount: number;
-    headerHeight?: number;
-    footerHeight?: number;
-    /**
-     * Visible portion of the table inside an external scroll parent (in pixels).
-     * Only consulted when neither `height` nor `maxHeight` is set; enables
-     * virtualization driven by a window- or element-level scroller.
-     */
-    externalViewportHeight?: number;
-}
-/**
- * Converts a height value (string or number) to pixels
- */
-export declare const convertHeightToPixels: (heightValue: string | number, container?: Element | null) => number;
-/**
- * Calculates the content height for the table.
- * This is a pure function alternative to the useContentHeight hook.
- *
- * @param config - Configuration for content height calculation
- * @returns The calculated content height in pixels, or undefined to disable virtualization
- */
-export declare const calculateContentHeight: ({ height, maxHeight, rowHeight, shouldPaginate, rowsPerPage, totalRowCount, headerHeight, footerHeight, externalViewportHeight, }: ContentHeightConfig) => number | undefined;
-export default calculateContentHeight;

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

@@ -1,65 +0,0 @@
-/**
- * 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/cjs/src/hooks/scrollbarWidth.d.ts

@@ -1,52 +0,0 @@
-/**
- * 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/cjs/src/hooks/useAggregatedRows.d.ts

@@ -1,14 +0,0 @@
-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/cjs/src/hooks/useQuickFilter.d.ts

@@ -1,14 +0,0 @@
-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/cjs/src/hooks/windowResize.d.ts

@@ -1,31 +0,0 @@
-/**
- * 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/cjs/src/icons/index.d.ts

@@ -1,14 +0,0 @@
-/**
- * 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/cjs/src/managers/ColumnManager.d.ts

@@ -1,42 +0,0 @@
-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/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/cjs/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/cjs/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 {};