@simple-table/angular 3.0.0-beta.8

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

@@ -0,0 +1,61 @@
+import HeaderObject, { Accessor } from "../../types/HeaderObject";
+import { HeaderRenderContext } from "../../utils/headerCellRenderer";
+import { CellRenderContext } from "../../utils/bodyCellRenderer";
+import TableRow from "../../types/TableRow";
+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;
+}
+export declare class SectionRenderer {
+    private headerSections;
+    private bodySections;
+    private bodyCellsCache;
+    private headerCellsCache;
+    private contextCache;
+    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;
+    invalidateCache(type?: "body" | "header" | "context" | "all"): void;
+    /**
+     * Get the next colIndex after rendering a section
+     */
+    getNextColIndex(sectionKey: string): number;
+    cleanup(): void;
+}

package/dist/core/src/core/rendering/TableRenderer.d.ts

@@ -0,0 +1,89 @@
+import HeaderObject, { Accessor } from "../../types/HeaderObject";
+import { SimpleTableConfig } from "../../types/SimpleTableConfig";
+import { CustomTheme } from "../../types/CustomTheme";
+import { DimensionManager } from "../../managers/DimensionManager";
+import type { SectionScrollController } from "../../managers/SectionScrollController";
+import { SortManager } from "../../managers/SortManager";
+import { FilterManager } from "../../managers/FilterManager";
+import { SelectionManager } from "../../managers/SelectionManager";
+import { RowSelectionManager } from "../../managers/RowSelectionManager";
+export interface TableRendererDeps {
+    cellRegistry: Map<string, any>;
+    collapsedHeaders: Set<Accessor>;
+    collapsedRows: Map<string, number>;
+    config: SimpleTableConfig;
+    customTheme: CustomTheme;
+    dimensionManager: DimensionManager | null;
+    draggedHeaderRef: {
+        current: HeaderObject | null;
+    };
+    effectiveHeaders: HeaderObject[];
+    essentialAccessors: Set<string>;
+    expandedDepths: Set<number>;
+    expandedRows: Map<string, number>;
+    filterManager: FilterManager | null;
+    getCollapsedHeaders?: () => Set<Accessor>;
+    getCollapsedRows: () => Map<string, number>;
+    getExpandedRows: () => Map<string, number>;
+    getRowStateMap: () => Map<string | number, any>;
+    headerRegistry: Map<string, any>;
+    headers: HeaderObject[];
+    hoveredHeaderRef: {
+        current: HeaderObject | null;
+    };
+    internalIsLoading: boolean;
+    isResizing: boolean;
+    localRows: any[];
+    mainBodyRef: {
+        current: HTMLDivElement | null;
+    };
+    mainHeaderRef: {
+        current: HTMLDivElement | null;
+    };
+    onRender: () => void;
+    pinnedLeftHeaderRef: {
+        current: HTMLDivElement | null;
+    };
+    pinnedLeftRef: {
+        current: HTMLDivElement | null;
+    };
+    pinnedRightHeaderRef: {
+        current: HTMLDivElement | null;
+    };
+    pinnedRightRef: {
+        current: HTMLDivElement | null;
+    };
+    positionOnlyBody?: boolean; /** When true, body sections use position-only updates for existing cells (scroll performance). */
+    resolvedIcons: any;
+    rowSelectionManager: RowSelectionManager | null;
+    rowStateMap: Map<string | number, any>;
+    sectionScrollController: SectionScrollController | null;
+    selectionManager: SelectionManager | null;
+    setCollapsedHeaders: (headers: Set<Accessor>) => void;
+    setCollapsedRows: (rows: Map<string, number>) => void;
+    setExpandedRows: (rows: Map<string, number>) => void;
+    setHeaders: (headers: HeaderObject[]) => void;
+    setIsResizing: (value: boolean) => void;
+    setRowStateMap: (map: Map<string | number, any>) => void;
+    sortManager: SortManager | null;
+}
+export declare class TableRenderer {
+    private sectionRenderer;
+    private footerInstance;
+    private columnEditorInstance;
+    private horizontalScrollbarRef;
+    private scrollbarTimeoutId;
+    private stickyParentsContainer;
+    private sectionScrollController;
+    private renderScheduled;
+    private pendingRenderCallback;
+    constructor();
+    private scheduleRender;
+    invalidateCache(type?: "body" | "header" | "context" | "all"): void;
+    renderHeader(container: HTMLElement, calculatedHeaderHeight: number, maxHeaderDepth: number, deps: TableRendererDeps): void;
+    renderBody(container: HTMLElement, processedResult: any, deps: TableRendererDeps): void;
+    renderFooter(container: HTMLElement, totalRows: number, currentPage: number, onPageChange: (page: number) => void, deps: TableRendererDeps): void;
+    renderColumnEditor(contentWrapper: HTMLElement, columnEditorOpen: boolean, setColumnEditorOpen: (open: boolean) => void, mergedColumnEditorConfig: any, deps: TableRendererDeps): void;
+    renderHorizontalScrollbar(wrapperContainer: HTMLElement, mainBodyWidth: number, pinnedLeftWidth: number, pinnedRightWidth: number, pinnedLeftContentWidth: number, pinnedRightContentWidth: number, tableBodyContainerRef: HTMLDivElement, deps: TableRendererDeps): void;
+    cleanup(): void;
+}

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

@@ -0,0 +1,37 @@
+/**
+ * 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/core/src/hooks/contentHeight.d.ts

@@ -0,0 +1,23 @@
+export interface ContentHeightConfig {
+    height?: string | number;
+    maxHeight?: string | number;
+    rowHeight: number;
+    shouldPaginate?: boolean;
+    rowsPerPage?: number;
+    totalRowCount: number;
+    headerHeight?: number;
+    footerHeight?: number;
+}
+/**
+ * Converts a height value (string or number) to pixels
+ */
+export declare const convertHeightToPixels: (heightValue: string | number) => 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, }: ContentHeightConfig) => number | undefined;
+export default calculateContentHeight;

package/dist/core/src/hooks/expandedDepths.d.ts

@@ -0,0 +1,65 @@
+import { Accessor } from "../types/HeaderObject";
+/**
+ * Initialize expandedDepths based on expandAll prop and rowGrouping
+ */
+export declare const initializeExpandedDepths: (expandAll: boolean, rowGrouping?: Accessor[]) => Set<number>;
+/**
+ * Manages expanded depths state for row grouping.
+ * This is a vanilla JS alternative to the useExpandedDepths hook.
+ */
+export declare class ExpandedDepthsManager {
+    private expandedDepths;
+    private observers;
+    constructor(expandAll: boolean, rowGrouping?: Accessor[]);
+    /**
+     * Updates the expanded depths when rowGrouping changes
+     * Filters out depths that are now out of range
+     * @param rowGrouping - The current row grouping configuration
+     */
+    updateRowGrouping(rowGrouping?: Accessor[]): void;
+    /**
+     * Gets the current expanded depths
+     * @returns Set of expanded depth numbers
+     */
+    getExpandedDepths(): Set<number>;
+    /**
+     * Sets the expanded depths
+     * @param depths - New set of expanded depths
+     */
+    setExpandedDepths(depths: Set<number>): void;
+    /**
+     * Subscribes to expanded depths changes
+     * @param callback - Function to call when depths change
+     * @returns Unsubscribe function
+     */
+    subscribe(callback: (depths: Set<number>) => void): () => void;
+    /**
+     * Notifies all observers of depth changes
+     */
+    private notifyObservers;
+    /**
+     * Expands all depths
+     */
+    expandAll(): void;
+    /**
+     * Collapses all depths
+     */
+    collapseAll(): void;
+    /**
+     * Expands a specific depth
+     */
+    expandDepth(depth: number): void;
+    /**
+     * Collapses a specific depth
+     */
+    collapseDepth(depth: number): void;
+    /**
+     * Toggles a specific depth
+     */
+    toggleDepth(depth: number): void;
+    /**
+     * Cleans up the manager
+     */
+    destroy(): void;
+}
+export default ExpandedDepthsManager;

package/dist/core/src/hooks/handleOutsideClick.d.ts

@@ -0,0 +1,50 @@
+import HeaderObject from "../types/HeaderObject";
+import Cell from "../types/Cell";
+export interface HandleOutsideClickConfig {
+    selectableColumns: boolean;
+    selectedCells: Set<string>;
+    selectedColumns: Set<number>;
+    setSelectedCells: (cells: Set<string>) => void;
+    setSelectedColumns: (columns: Set<number>) => void;
+    activeHeaderDropdown?: HeaderObject | null;
+    setActiveHeaderDropdown?: (header: HeaderObject | null) => void;
+    startCell?: {
+        current: Cell | null;
+    };
+    /** When provided, used to read current selection (avoids stale refs). */
+    getSelectedCells?: () => Set<string>;
+    getSelectedColumns?: () => Set<number>;
+    /** When provided, called to clear both cell/column selection and startCell in one go. */
+    onClearSelection?: () => void;
+}
+/**
+ * Manages outside click detection for cells, columns, and header dropdowns.
+ * This is a vanilla JS alternative to the useHandleOutsideClick hook.
+ */
+export declare class HandleOutsideClickManager {
+    private config;
+    private isListening;
+    constructor(config: HandleOutsideClickConfig);
+    /**
+     * Updates the configuration
+     * @param config - New configuration
+     */
+    updateConfig(config: Partial<HandleOutsideClickConfig>): void;
+    /**
+     * Handles the mousedown event
+     */
+    private handleClickOutside;
+    /**
+     * Starts listening to mousedown events
+     */
+    startListening(): void;
+    /**
+     * Stops listening to mousedown events
+     */
+    stopListening(): void;
+    /**
+     * Cleans up the manager and removes all event listeners
+     */
+    destroy(): void;
+}
+export default HandleOutsideClickManager;

package/dist/core/src/hooks/previousValue.d.ts

@@ -0,0 +1,30 @@
+/**
+ * A class to track previous values of a variable.
+ * This replaces the usePrevious hook for non-React code.
+ *
+ * @example
+ * const tracker = new PreviousValueTracker(initialValue);
+ * const previous = tracker.get();
+ * tracker.update(newValue);
+ */
+export declare class PreviousValueTracker<T> {
+    private previousValue;
+    constructor(initialValue: T);
+    /**
+     * Updates the tracked value and returns the previous value
+     * @param newValue - The new value to track
+     * @returns The previous value before update
+     */
+    update(newValue: T): T;
+    /**
+     * Gets the current previous value without updating
+     * @returns The currently stored previous value
+     */
+    get(): T;
+    /**
+     * Sets the previous value directly (useful for initialization)
+     * @param value - The value to set
+     */
+    set(value: T): void;
+}
+export default PreviousValueTracker;

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

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

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

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

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

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

@@ -0,0 +1 @@
+export declare const createAngleDownIcon: (className?: string) => SVGSVGElement;

package/dist/core/src/icons/AngleLeftIcon.d.ts

@@ -0,0 +1 @@
+export declare const createAngleLeftIcon: (className?: string) => SVGSVGElement;

package/dist/core/src/icons/AngleRightIcon.d.ts

@@ -0,0 +1 @@
+export declare const createAngleRightIcon: (className?: string) => SVGSVGElement;

package/dist/core/src/icons/AngleUpIcon.d.ts

@@ -0,0 +1 @@
+export declare const createAngleUpIcon: (className?: string) => SVGSVGElement;

package/dist/core/src/icons/AscIcon.d.ts

@@ -0,0 +1 @@
+export declare const createAscIcon: (className?: string) => SVGSVGElement;

package/dist/core/src/icons/CheckIcon.d.ts

@@ -0,0 +1 @@
+export declare const createCheckIcon: (className?: string) => SVGSVGElement;

package/dist/core/src/icons/DescIcon.d.ts

@@ -0,0 +1 @@
+export declare const createDescIcon: (className?: string) => SVGSVGElement;

package/dist/core/src/icons/DragIcon.d.ts

@@ -0,0 +1 @@
+export declare const createDragIcon: (className?: string) => SVGSVGElement;

package/dist/core/src/icons/FilterIcon.d.ts

@@ -0,0 +1 @@
+export declare const createFilterIcon: (className?: string) => SVGSVGElement;

package/dist/core/src/icons/SelectIcon.d.ts

@@ -0,0 +1 @@
+export declare const createSelectIcon: () => SVGSVGElement;

package/dist/core/src/icons/index.d.ts

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

@@ -0,0 +1,48 @@
+import { SimpleTableVanilla } from "./core/SimpleTableVanilla";
+import type BoundingBox from "./types/BoundingBox";
+import type Cell from "./types/Cell";
+import type CellChangeProps from "./types/CellChangeProps";
+import type CellValue from "./types/CellValue";
+import type DragHandlerProps from "./types/DragHandlerProps";
+import type EnumOption from "./types/EnumOption";
+import type HeaderObject from "./types/HeaderObject";
+import type { Accessor, ChartOptions, ColumnType, Comparator, ComparatorProps, ExportValueGetter, ExportValueProps, ShowWhen, ValueFormatter, ValueFormatterProps, ValueGetter, ValueGetterProps } from "./types/HeaderObject";
+import type { AggregationConfig, AggregationType } from "./types/AggregationTypes";
+import type OnSortProps from "./types/OnSortProps";
+import type OnRowGroupExpandProps from "./types/OnRowGroupExpandProps";
+import type Row from "./types/Row";
+import type RowState from "./types/RowState";
+import type SharedTableProps from "./types/SharedTableProps";
+import type SortColumn from "./types/SortColumn";
+import type TableHeaderProps from "./types/TableHeaderProps";
+import type { TableAPI, SetHeaderRenameProps, ExportToCSVProps } from "./types/TableAPI";
+import type TableRefType from "./types/TableRefType";
+import type TableRowProps from "./types/TableRowProps";
+import type Theme from "./types/Theme";
+import type UpdateDataProps from "./types/UpdateCellProps";
+import type { FilterCondition, TableFilterState } from "./types/FilterTypes";
+import type { QuickFilterConfig, QuickFilterGetter, QuickFilterGetterProps, QuickFilterMode } from "./types/QuickFilterTypes";
+import type { ColumnVisibilityState } from "./types/ColumnVisibilityTypes";
+import type RowSelectionChangeProps from "./types/RowSelectionChangeProps";
+import type CellClickProps from "./types/CellClickProps";
+import type CellRendererProps from "./types/CellRendererProps";
+import type { CellRenderer } from "./types/CellRendererProps";
+import type HeaderRendererProps from "./types/HeaderRendererProps";
+import type { HeaderRenderer, HeaderRendererComponents } from "./types/HeaderRendererProps";
+import type ColumnEditorRowRendererProps from "./types/ColumnEditorRowRendererProps";
+import type { ColumnEditorRowRenderer, ColumnEditorRowRendererComponents } from "./types/ColumnEditorRowRendererProps";
+import type HeaderDropdownProps from "./types/HeaderDropdownProps";
+import type { HeaderDropdown } from "./types/HeaderDropdownProps";
+import type { RowButtonProps } from "./types/RowButton";
+import type FooterRendererProps from "./types/FooterRendererProps";
+import type { LoadingStateRenderer, ErrorStateRenderer, EmptyStateRenderer, LoadingStateRendererProps, ErrorStateRendererProps, EmptyStateRendererProps } from "./types/RowStateRendererProps";
+import type { CustomTheme, CustomThemeProps } from "./types/CustomTheme";
+import type { ColumnEditorConfig, ColumnEditorSearchFunction } from "./types/ColumnEditorConfig";
+import type { IconsConfig } from "./types/IconsConfig";
+import type { GetRowId, GetRowIdParams } from "./types/GetRowId";
+import type { SimpleTableConfig } from "./types/SimpleTableConfig";
+import type { SimpleTableProps } from "./types/SimpleTableProps";
+import type { RowId } from "./types/RowId";
+import type { PinnedSectionsState } from "./types/PinnedSectionsState";
+export { SimpleTableVanilla };
+export type { Accessor, AggregationConfig, AggregationType, BoundingBox, Cell, CellChangeProps, CellClickProps, CellRenderer, CellRendererProps, CellValue, ChartOptions, ColumnEditorConfig, ColumnEditorRowRenderer, ColumnEditorRowRendererComponents, ColumnEditorRowRendererProps, ColumnEditorSearchFunction, ColumnType, ColumnVisibilityState, Comparator, ComparatorProps, CustomTheme, CustomThemeProps, DragHandlerProps, EmptyStateRenderer, EmptyStateRendererProps, EnumOption, ErrorStateRenderer, ErrorStateRendererProps, ExportToCSVProps, ExportValueGetter, ExportValueProps, FilterCondition, FooterRendererProps, GetRowId, GetRowIdParams, IconsConfig, LoadingStateRenderer, LoadingStateRendererProps, HeaderDropdown, HeaderDropdownProps, HeaderObject, HeaderRenderer, HeaderRendererProps, HeaderRendererComponents, OnRowGroupExpandProps, OnSortProps, QuickFilterConfig, QuickFilterGetter, QuickFilterGetterProps, QuickFilterMode, Row, RowButtonProps, RowId, RowSelectionChangeProps, RowState, SetHeaderRenameProps, SharedTableProps, ShowWhen, SimpleTableConfig, SimpleTableProps, SortColumn, TableAPI, TableFilterState, TableHeaderProps, TableRefType, TableRowProps, Theme, PinnedSectionsState, UpdateDataProps, ValueFormatter, ValueFormatterProps, ValueGetter, ValueGetterProps, };

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

@@ -0,0 +1,26 @@
+import HeaderObject from "../types/HeaderObject";
+interface AutoScaleConfig {
+    autoExpandColumns: boolean;
+    containerWidth: number;
+    pinnedLeftWidth: number;
+    pinnedRightWidth: number;
+    mainBodyRef: {
+        current: HTMLDivElement | null;
+    };
+    isResizing?: boolean;
+}
+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 {};