@simple-table/solid 3.0.0-beta.10

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

@@ -0,0 +1,50 @@
+export type SectionId = "pinned-left" | "main" | "pinned-right";
+export type SectionPaneRole = "sticky" | "scrollbar" | "header" | "body";
+export interface SectionScrollControllerConfig {
+    onMainSectionScrollLeft?: (scrollLeft: number) => void;
+}
+/**
+ * Single controller for horizontal scroll sync across all four panes per section:
+ * sticky parent, horizontal scrollbar segment, header, and body.
+ * Scrolling any one pane updates the other three in that section.
+ * All four panes must have the same scroll width (enforced by renderers).
+ */
+export declare class SectionScrollController {
+    private scrollLeftBySection;
+    private panesBySection;
+    private scrollHandlers;
+    private config;
+    /** Guard to avoid re-entrancy when we programmatically set scrollLeft on other panes */
+    private isSyncing;
+    /** Last scrollLeft at which we ran main-section virtualization; used to run heavy ops only every N px. */
+    private lastMainVirtualizationScrollLeft;
+    constructor(config?: SectionScrollControllerConfig);
+    updateConfig(config: Partial<SectionScrollControllerConfig>): void;
+    /**
+     * Register a pane (sticky, scrollbar, header, or body) for a section.
+     * When any registered pane scrolls, the others in the same section are updated.
+     * If a pane with the same role was already registered (e.g. after re-render), it is replaced.
+     */
+    registerPane(sectionId: SectionId, element: HTMLElement, role: SectionPaneRole): void;
+    /**
+     * Unregister a pane (e.g. when section is removed or re-created).
+     */
+    unregisterPane(sectionId: SectionId, element: HTMLElement): void;
+    /**
+     * Unregister all panes for a section (e.g. on cleanup).
+     */
+    unregisterSection(sectionId: SectionId): void;
+    /**
+     * Set scroll position for a section. Updates state and all registered panes.
+     * Used when a pane fires scroll and when restoring after render.
+     */
+    setSectionScrollLeft(sectionId: SectionId, value: number): void;
+    getSectionScrollLeft(sectionId: SectionId): number;
+    /**
+     * Restore scroll position to all registered panes from stored state (e.g. after render).
+     */
+    restoreAll(): void;
+    private addScrollListener;
+    private removeScrollListener;
+    destroy(): void;
+}

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

@@ -0,0 +1,246 @@
+import type Cell from "../../types/Cell";
+import { type SelectionManagerConfig } from "./types";
+export type { SelectionManagerConfig } from "./types";
+export { createSetString } from "./types";
+export declare class SelectionManager {
+    private config;
+    private selectedCells;
+    private selectedColumns;
+    private lastSelectedColumnIndex;
+    private initialFocusedCell;
+    private copyFlashCells;
+    private warningFlashCells;
+    private isSelecting;
+    private startCell;
+    private keydownHandler;
+    private currentMouseX;
+    private currentMouseY;
+    private scrollAnimationFrame;
+    private lastSelectionUpdate;
+    private selectionThrottleMs;
+    private globalMouseMoveHandler;
+    private globalMouseUpHandler;
+    private columnsWithSelectedCells;
+    private rowsWithSelectedCells;
+    private leafHeaders;
+    /** rowId -> table row index; avoids O(tableRows) findIndex per cell in getBorderClass */
+    private rowIdToTableIndex;
+    /** Set of "rowId\tcolIndex" for O(1) selected membership in syncAllCellClasses */
+    private selectedByRowIdColIndex;
+    /** When true, all cells are selected without storing R×C cell IDs (fast path for Cmd+A). */
+    private fullTableSelected;
+    constructor(config: SelectionManagerConfig);
+    /**
+     * Update configuration when props change.
+     * When options.positionOnlyBody is true (e.g. scroll-only render), only updates rowIdToTableIndex and
+     * selectedByRowIdColIndex so lookups work for new cells; skips columnsWithSelectedCells/rowsWithSelectedCells.
+     */
+    updateConfig(config: Partial<SelectionManagerConfig>, options?: {
+        positionOnlyBody?: boolean;
+    }): void;
+    /**
+     * Update derived state based on current selections.
+     * When fullTableSelected, derives columns/rows from table shape (O(R+C)) instead of iterating selectedCells (O(R×C)).
+     * Otherwise, single pass over selectedCells to build selectedByRowIdColIndex, columnsWithSelectedCells, rowsWithSelectedCells.
+     */
+    private updateDerivedState;
+    /**
+     * Minimal update for scroll-only renders: only rowIdToTableIndex and selectedByRowIdColIndex
+     * so isSelected/getBorderClass work for new cells; skips columnsWithSelectedCells and rowsWithSelectedCells.
+     * When fullTableSelected, selectedByRowIdColIndex is left empty (isSelected uses the flag).
+     */
+    private updateRowIdAndSelectionLookupOnly;
+    /**
+     * Setup keyboard navigation event listener
+     */
+    private setupKeyboardNavigation;
+    /**
+     * Clean up event listeners and resources
+     */
+    destroy(): void;
+    /**
+     * Handle keyboard events for navigation and clipboard operations
+     */
+    private handleKeyDown;
+    /**
+     * Handle navigation keys (arrows, home, end, page up/down)
+     */
+    private handleNavigationKeys;
+    /**
+     * Helper function to find the edge of data in a direction
+     */
+    private findEdgeInDirection;
+    /**
+     * Handle arrow up key
+     */
+    private handleArrowUp;
+    /**
+     * Handle arrow down key
+     */
+    private handleArrowDown;
+    /**
+     * Handle arrow left key
+     */
+    private handleArrowLeft;
+    /**
+     * Handle arrow right key
+     */
+    private handleArrowRight;
+    /**
+     * Handle home key
+     */
+    private handleHome;
+    /**
+     * Handle end key
+     */
+    private handleEnd;
+    /**
+     * Handle page up key
+     */
+    private handlePageUp;
+    /**
+     * Handle page down key
+     */
+    private handlePageDown;
+    /**
+     * Copy selected cells to clipboard
+     */
+    private copyToClipboard;
+    /**
+     * Paste from clipboard to cells
+     */
+    private pasteFromClipboard;
+    /**
+     * Delete content from selected cells
+     */
+    private deleteSelectedCells;
+    /**
+     * Select all cells in the table. Uses fullTableSelected flag instead of storing R×C cell IDs for O(1) update.
+     */
+    private selectAll;
+    /**
+     * Build the full set of cell IDs when fullTableSelected. Used for copy/delete/getSelectedCells.
+     */
+    private buildFullTableSelectedSet;
+    /**
+     * Clear all selections
+     */
+    clearSelection(): void;
+    /**
+     * Set selected cells (for external control)
+     */
+    setSelectedCells(cells: Set<string>): void;
+    /**
+     * Set selected columns (for external control)
+     */
+    setSelectedColumns(columns: Set<number>): void;
+    /**
+     * Update flash classes on cells (copy/warning animations)
+     */
+    private updateCellFlashClasses;
+    private static readonly SELECTION_CLASSES;
+    /**
+     * Apply selection classes to all currently rendered cells. Used after drag ends
+     * so that the DOM (which may have been replaced during scroll) reflects selection.
+     * Only adds/removes classes that changed to reduce DOM writes.
+     * Fast path when there is no selection: one pass to clear all selection classes.
+     */
+    private syncAllCellClasses;
+    /**
+     * Update all cell classes based on current selection state
+     * Directly manipulates the DOM without triggering React re-renders.
+     * When isSelecting (drag) or fullTableSelected (Cmd+A), run synchronously so classes are applied
+     * before any scroll-triggered render or next frame.
+     */
+    private updateAllCellClasses;
+    /**
+     * Check if a cell is selected. Uses selectedByRowIdColIndex for O(1) membership.
+     * When fullTableSelected, returns true for any cell without lookup.
+     */
+    isSelected({ colIndex, rowIndex, rowId }: Cell): boolean;
+    /**
+     * Get border class for a cell based on its selection state. Uses rowIdToTableIndex for O(1) lookups.
+     * When fullTableSelected, short-circuits with border classes for the full grid (no neighbor lookups).
+     */
+    getBorderClass({ colIndex, rowIndex, rowId }: Cell): string;
+    /**
+     * Check if a cell is the initial focused cell
+     */
+    isInitialFocusedCell({ rowIndex, colIndex, rowId }: Cell): boolean;
+    /**
+     * Check if a cell is currently showing copy flash animation
+     */
+    isCopyFlashing({ colIndex, rowIndex, rowId }: Cell): boolean;
+    /**
+     * Check if a cell is currently showing warning flash animation
+     */
+    isWarningFlashing({ colIndex, rowIndex, rowId }: Cell): boolean;
+    /**
+     * Get columns that have selected cells
+     */
+    getColumnsWithSelectedCells(): Set<number>;
+    /**
+     * Get rows that have selected cells
+     */
+    getRowsWithSelectedCells(): Set<string>;
+    /**
+     * Get selected cells. When fullTableSelected, builds and returns the full set on demand.
+     */
+    getSelectedCells(): Set<string>;
+    /**
+     * Get selected columns
+     */
+    getSelectedColumns(): Set<number>;
+    /**
+     * Get last selected column index
+     */
+    getLastSelectedColumnIndex(): number | null;
+    /**
+     * Get start cell for range selection
+     */
+    getStartCell(): Cell | null;
+    /**
+     * Set the initial focused cell (e.g. when clearing selection from header drag).
+     */
+    setInitialFocusedCell(cell: Cell | null): void;
+    /**
+     * Select a single cell
+     */
+    selectSingleCell(cell: Cell): void;
+    /**
+     * Select a range of cells from startCell to endCell
+     */
+    selectCellRange(startCell: Cell, endCell: Cell): void;
+    /**
+     * Select one or more columns
+     */
+    selectColumns(columnIndices: number[], isShiftKey?: boolean): void;
+    /**
+     * Update selection range during mouse drag. Skips derived state and class sync when selection unchanged.
+     */
+    private updateSelectionRange;
+    /**
+     * Calculate the nearest cell to a given mouse position
+     */
+    private calculateNearestCell;
+    /**
+     * Get cell from mouse position
+     */
+    private getCellFromMousePosition;
+    /**
+     * Handle auto-scrolling when dragging near edges
+     */
+    private handleAutoScroll;
+    /**
+     * Continuous scroll loop during mouse drag
+     */
+    private continuousScroll;
+    /**
+     * Handle mouse down on a cell to start selection
+     */
+    handleMouseDown({ colIndex, rowIndex, rowId }: Cell): void;
+    /**
+     * Handle mouse over a cell during selection drag
+     */
+    handleMouseOver({ colIndex, rowIndex, rowId }: Cell): void;
+}

package/dist/core/src/managers/SelectionManager/index.d.ts

@@ -0,0 +1,2 @@
+export { SelectionManager, createSetString, } from "./SelectionManager";
+export type { SelectionManagerConfig } from "./SelectionManager";

package/dist/core/src/managers/SelectionManager/keyboardUtils.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Find the edge of data in a direction (pure helper for keyboard navigation).
+ */
+export declare function findEdgeInDirection(tableRowsLength: number, leafHeadersLength: number, enableRowSelection: boolean, startRow: number, startCol: number, direction: "up" | "down" | "left" | "right"): {
+    rowIndex: number;
+    colIndex: number;
+};

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

@@ -0,0 +1,15 @@
+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): Cell | null;
+/**
+ * Get cell from mouse position (element under point, or nearest cell).
+ */
+export declare function getCellFromMousePosition(clientX: number, clientY: number): Cell | null;
+/**
+ * Handle auto-scrolling when dragging near table edges.
+ */
+export declare function handleAutoScroll(clientX: number, clientY: number): void;

package/dist/core/src/managers/SelectionManager/selectionRangeUtils.d.ts

@@ -0,0 +1,7 @@
+import type Cell from "../../types/Cell";
+import type TableRowType from "../../types/TableRow";
+/**
+ * Compute the set of cell IDs for a selection range.
+ * Resolves rowId to current row index (for virtualized/sorted tables) then fills the rectangle.
+ */
+export declare function computeSelectionRange(startCell: Cell, endCell: Cell, tableRows: TableRowType[], enableRowSelection: boolean): Set<string>;

package/dist/core/src/managers/SelectionManager/types.d.ts

@@ -0,0 +1,22 @@
+import type HeaderObject from "../../types/HeaderObject";
+import type { Accessor } from "../../types/HeaderObject";
+import type TableRowType from "../../types/TableRow";
+import type Cell from "../../types/Cell";
+import type { CustomTheme } from "../../types/CustomTheme";
+export declare const createSetString: ({ rowIndex, colIndex, rowId }: Cell) => string;
+export interface SelectionManagerConfig {
+    selectableCells: boolean;
+    headers: HeaderObject[];
+    tableRows: TableRowType[];
+    onCellEdit?: (props: any) => void;
+    cellRegistry?: Map<string, any>;
+    collapsedHeaders?: Set<Accessor>;
+    rowHeight: number;
+    enableRowSelection?: boolean;
+    copyHeadersToClipboard?: boolean;
+    customTheme: CustomTheme;
+    /** Called when a selection drag ends so the table can re-render and apply selection classes. */
+    onSelectionDragEnd?: () => void;
+    /** Root element of the table; sync scopes cell queries to this so only this table's cells are updated. */
+    tableRoot?: HTMLElement;
+}

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

@@ -0,0 +1,42 @@
+import HeaderObject, { Accessor } from "../types/HeaderObject";
+import Row from "../types/Row";
+import SortColumn, { SortDirection } from "../types/SortColumn";
+export interface SortManagerConfig {
+    headers: HeaderObject[];
+    tableRows: Row[];
+    externalSortHandling: boolean;
+    onSortChange?: (sort: SortColumn | null) => void;
+    rowGrouping?: string[];
+    initialSortColumn?: string;
+    initialSortDirection?: SortDirection;
+    announce?: (message: string) => void;
+}
+export interface SortManagerState {
+    sort: SortColumn | null;
+    sortedRows: Row[];
+}
+type StateChangeCallback = (state: SortManagerState) => void;
+export declare class SortManager {
+    private config;
+    private state;
+    private subscribers;
+    private headerLookup;
+    constructor(config: SortManagerConfig);
+    private updateHeaderLookup;
+    private getInitialSort;
+    private sortNestedRows;
+    private computeSortedRows;
+    updateConfig(config: Partial<SortManagerConfig>): void;
+    subscribe(callback: StateChangeCallback): () => void;
+    private notifySubscribers;
+    updateSort(props?: {
+        accessor: Accessor;
+        direction?: SortDirection;
+    }): void;
+    computeSortedRowsPreview(accessor: Accessor): Row[];
+    getState(): SortManagerState;
+    getSortColumn(): SortColumn | null;
+    getSortedRows(): Row[];
+    destroy(): void;
+}
+export {};

package/dist/core/src/types/AggregationTypes.d.ts

@@ -0,0 +1,8 @@
+import type CellValue from "./CellValue";
+export type AggregationType = "sum" | "average" | "count" | "min" | "max" | "custom";
+export type AggregationConfig = {
+    type: AggregationType;
+    parseValue?: (value: CellValue) => number;
+    formatResult?: (value: number) => string;
+    customFn?: (values: CellValue[]) => number;
+};

package/dist/core/src/types/BoundingBox.d.ts

@@ -0,0 +1,11 @@
+type BoundingBox = {
+    bottom: number;
+    height: number;
+    left: number;
+    right: number;
+    top: number;
+    width: number;
+    x: number;
+    y: number;
+};
+export default BoundingBox;

package/dist/core/src/types/Cell.d.ts

@@ -0,0 +1,7 @@
+import { RowId } from "./RowId";
+type Cell = {
+    colIndex: number;
+    rowId: RowId;
+    rowIndex: number;
+};
+export default Cell;

package/dist/core/src/types/CellChangeProps.d.ts

@@ -0,0 +1,9 @@
+import CellValue from "./CellValue";
+import { Accessor } from "./HeaderObject";
+import Row from "./Row";
+type CellChangeProps = {
+    accessor: Accessor;
+    newValue: CellValue;
+    row: Row;
+};
+export default CellChangeProps;

package/dist/core/src/types/CellClickProps.d.ts

@@ -0,0 +1,11 @@
+import CellValue from "./CellValue";
+import { Accessor } from "./HeaderObject";
+import Row from "./Row";
+type CellClickProps = {
+    accessor: Accessor;
+    colIndex: number;
+    row: Row;
+    rowIndex: number;
+    value: CellValue;
+};
+export default CellClickProps;

package/dist/core/src/types/CellRendererProps.d.ts

@@ -0,0 +1,32 @@
+import type { Accessor } from "./HeaderObject";
+import type Row from "./Row";
+import type Theme from "./Theme";
+import type CellValue from "./CellValue";
+interface CellRendererProps {
+    accessor: Accessor;
+    colIndex: number;
+    row: Row;
+    rowIndex: number;
+    rowPath?: (string | number)[];
+    theme: Theme;
+    value: CellValue;
+    formattedValue?: string | number | string[] | number[] | null | undefined | boolean;
+}
+/**
+ * CellRenderer return type:
+ * - string | number | null: rendered as text in the cell
+ * - Node (HTMLElement, DocumentFragment, etc.): appended directly into the cell for full DOM control
+ *
+ * Example (text):
+ *   cellRenderer: ({ value, row }) => `${value} (${row.status})`
+ *
+ * Example (custom HTML):
+ *   cellRenderer: ({ row }) => {
+ *     const span = document.createElement('span');
+ *     span.className = 'badge';
+ *     span.textContent = String(row.status);
+ *     return span;
+ *   }
+ */
+export type CellRenderer = (props: CellRendererProps) => string | number | null | Node;
+export default CellRendererProps;

package/dist/core/src/types/CellValue.d.ts

@@ -0,0 +1,2 @@
+type CellValue = string | number | boolean | undefined | null | string[] | number[] | Record<string, unknown>[];
+export default CellValue;

package/dist/core/src/types/ColumnEditorConfig.d.ts

@@ -0,0 +1,32 @@
+import HeaderObject from "./HeaderObject";
+import { ColumnEditorRowRenderer } from "./ColumnEditorRowRendererProps";
+/**
+ * Custom search function for filtering columns in the column editor
+ * @param header - The header object to check
+ * @param searchTerm - The current search term
+ * @returns true if the header matches the search term, false otherwise
+ */
+export type ColumnEditorSearchFunction = (header: HeaderObject, searchTerm: string) => boolean;
+/**
+ * Configuration options for the column editor/visibility drawer
+ */
+export interface ColumnEditorConfig {
+    /** Text displayed on the column editor button (default: "Columns") */
+    text?: string;
+    /** Enable search functionality in the column editor (default: true) */
+    searchEnabled?: boolean;
+    /** Placeholder text for the search input (default: "Search columns...") */
+    searchPlaceholder?: string;
+    /** Custom search function to override default search behavior. Receives header and searchTerm, returns true if header matches. */
+    searchFunction?: ColumnEditorSearchFunction;
+    /**
+     * When false, hides pin/unpin controls (L/R) in the column editor. Pinned sections still appear if columns are pinned.
+     * Default: true.
+     */
+    allowColumnPinning?: boolean;
+    /** Custom renderer for column editor row layout to reposition icons and labels */
+    rowRenderer?: ColumnEditorRowRenderer;
+}
+export declare const DEFAULT_COLUMN_EDITOR_CONFIG: Required<Omit<ColumnEditorConfig, "searchFunction" | "rowRenderer">>;
+/** Column editor config with defaults applied (text, searchEnabled, searchPlaceholder are required) */
+export type MergedColumnEditorConfig = Required<Pick<ColumnEditorConfig, "text" | "searchEnabled" | "searchPlaceholder" | "allowColumnPinning">> & Pick<ColumnEditorConfig, "searchFunction" | "rowRenderer">;

package/dist/core/src/types/ColumnEditorRowRendererProps.d.ts

@@ -0,0 +1,39 @@
+import type { Accessor } from "./HeaderObject";
+import type HeaderObject from "./HeaderObject";
+import type { IconElement } from "./IconsConfig";
+import type { PanelSection } from "./PanelSection";
+export interface ColumnEditorRowRendererComponents {
+    expandIcon?: IconElement;
+    checkbox?: HTMLElement | string;
+    dragIcon?: IconElement;
+    labelContent?: string | HTMLElement;
+    /** Default pin column (outline / filled); omit when building a fully custom row */
+    pinIcon?: IconElement;
+}
+/** Pin / unpin actions for column editor rows (also use for lock/tooltip UX via HeaderObject.isEssential). */
+export interface ColumnEditorPinControl {
+    pinnedSide: "left" | "right" | null;
+    canPinLeft: boolean;
+    canPinRight: boolean;
+    canUnpin: boolean;
+    pinLeft: () => void;
+    pinRight: () => void;
+    unpin: () => void;
+}
+interface ColumnEditorRowRendererProps {
+    accessor: Accessor;
+    header: HeaderObject;
+    components: ColumnEditorRowRendererComponents;
+    /** Which panel section this row is rendered in */
+    panelSection?: PanelSection;
+    /** Resolved from HeaderObject.isEssential / essentialAccessors */
+    isEssential?: boolean;
+    /** False when visibility cannot be toggled (essential columns) */
+    canToggleVisibility?: boolean;
+    /** Mirrors `columnEditorConfig.allowColumnPinning` (default true) */
+    allowColumnPinning?: boolean;
+    pinControl?: ColumnEditorPinControl;
+}
+export type ColumnEditorRowRenderer = (props: ColumnEditorRowRendererProps) => HTMLElement | string | null;
+export default ColumnEditorRowRendererProps;
+export type { PanelSection };

package/dist/core/src/types/ColumnVisibilityTypes.d.ts

@@ -0,0 +1,4 @@
+import { Accessor } from "./HeaderObject";
+export interface ColumnVisibilityState {
+    [accessor: Accessor]: boolean;
+}

package/dist/core/src/types/CustomTheme.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Custom theme configuration for SimpleTable
+ * Contains all customizable dimensions and spacing values used in calculations and styling
+ * All properties are optional - missing values will be filled with defaults
+ */
+export interface CustomThemeProps {
+    rowHeight?: number;
+    headerHeight?: number;
+    footerHeight?: number;
+    rowSeparatorWidth?: number;
+    borderWidth?: number;
+    pinnedBorderWidth?: number;
+    nestedGridBorderWidth?: number;
+    nestedGridPaddingTop?: number;
+    nestedGridPaddingBottom?: number;
+    nestedGridPaddingLeft?: number;
+    nestedGridPaddingRight?: number;
+    nestedGridMaxHeight?: number;
+    selectionColumnWidth?: number;
+}
+export type CustomTheme = Required<CustomThemeProps>;
+/**
+ * Default theme values
+ * These match the original hardcoded constants throughout the codebase
+ */
+export declare const DEFAULT_CUSTOM_THEME: CustomTheme;

package/dist/core/src/types/DragHandlerProps.d.ts

@@ -0,0 +1,14 @@
+import HeaderObject, { Accessor } from "./HeaderObject";
+type useDragHandlerProps = {
+    draggedHeaderRef: {
+        current: HeaderObject | null;
+    };
+    essentialAccessors?: ReadonlySet<Accessor | string>;
+    headers: HeaderObject[];
+    hoveredHeaderRef: {
+        current: HeaderObject | null;
+    };
+    onColumnOrderChange?: (newHeaders: HeaderObject[]) => void;
+    onTableHeaderDragEnd: (newHeaders: HeaderObject[]) => void;
+};
+export default useDragHandlerProps;

package/dist/core/src/types/EnumOption.d.ts

@@ -0,0 +1,5 @@
+type EnumOption = {
+    label: string;
+    value: string;
+};
+export default EnumOption;

package/dist/core/src/types/FilterTypes.d.ts

@@ -0,0 +1,22 @@
+import CellValue from "./CellValue";
+import { Accessor } from "./HeaderObject";
+export type StringFilterOperator = "equals" | "notEquals" | "contains" | "notContains" | "startsWith" | "endsWith" | "isEmpty" | "isNotEmpty";
+export type NumberFilterOperator = "equals" | "notEquals" | "greaterThan" | "lessThan" | "greaterThanOrEqual" | "lessThanOrEqual" | "between" | "notBetween" | "isEmpty" | "isNotEmpty";
+export type BooleanFilterOperator = "equals" | "isEmpty" | "isNotEmpty";
+export type DateFilterOperator = "equals" | "notEquals" | "before" | "after" | "between" | "notBetween" | "isEmpty" | "isNotEmpty";
+export type EnumFilterOperator = "in" | "notIn" | "isEmpty" | "isNotEmpty";
+export type FilterOperator = StringFilterOperator | NumberFilterOperator | BooleanFilterOperator | DateFilterOperator | EnumFilterOperator;
+export interface FilterCondition {
+    accessor: Accessor;
+    operator: FilterOperator;
+    value?: CellValue;
+    values?: CellValue[];
+}
+export interface TableFilterState {
+    [accessor: Accessor]: FilterCondition;
+}
+export declare const FILTER_OPERATOR_LABELS: Record<FilterOperator, string>;
+export declare const getAvailableOperators: (columnType: "string" | "number" | "boolean" | "date" | "enum") => FilterOperator[];
+export declare const requiresSingleValue: (operator: FilterOperator) => boolean;
+export declare const requiresMultipleValues: (operator: FilterOperator) => boolean;
+export declare const requiresNoValue: (operator: FilterOperator) => boolean;

package/dist/core/src/types/FlattenedHeader.d.ts

@@ -0,0 +1,10 @@
+import HeaderObject from "./HeaderObject";
+import type { PanelSection } from "./PanelSection";
+export type FlattenedHeader = {
+    header: HeaderObject;
+    visualIndex: number;
+    depth: number;
+    parent: HeaderObject | null;
+    indexPath: number[];
+    panelSection?: PanelSection;
+};