simple-table-core 2.6.2 → 3.0.0-beta.5

package/dist/src/utils/bodyCell/types.d.ts

@@ -0,0 +1,103 @@
+import HeaderObject, { Accessor } from "../../types/HeaderObject";
+import CellValue from "../../types/CellValue";
+import { IconsConfig } from "../../types/IconsConfig";
+import OnRowGroupExpandProps from "../../types/OnRowGroupExpandProps";
+import type Row from "../../types/Row";
+import type TableRow from "../../types/TableRow";
+import type RowState from "../../types/RowState";
+import type { RowButton } from "../../types/RowButton";
+import type { CustomTheme } from "../../types/CustomTheme";
+import type { HeightOffsets } from "../infiniteScrollUtils";
+import type { VanillaEmptyStateRenderer, VanillaErrorStateRenderer, VanillaLoadingStateRenderer } from "../../types/RowStateRendererProps";
+type SetStateAction<T> = T | ((prevState: T) => T);
+type Dispatch<A> = (value: A) => void;
+export interface AbsoluteBodyCell {
+    header: HeaderObject;
+    row: Row;
+    rowIndex: number;
+    colIndex: number;
+    rowId: string;
+    displayRowNumber: number;
+    depth: number;
+    isOdd: boolean;
+    tableRow: TableRow;
+    left: number;
+    top: number;
+    width: number;
+    height: number;
+}
+export interface CellData {
+    rowIndex: number;
+    colIndex: number;
+    rowId: string;
+}
+export interface CellEditParams {
+    accessor: Accessor;
+    newValue: CellValue;
+    row: Row;
+    rowIndex: number;
+}
+export interface CellClickParams {
+    accessor: Accessor;
+    colIndex: number;
+    row: Row;
+    rowIndex: number;
+    value: CellValue;
+}
+export interface CellRegistryEntry {
+    updateContent: (newValue: CellValue) => void;
+}
+export interface CellRenderContext {
+    collapsedHeaders: Set<Accessor>;
+    collapsedRows: Map<string, number>;
+    expandedRows: Map<string, number>;
+    expandedDepths: number[];
+    selectedColumns: Set<number>;
+    rowsWithSelectedCells: Set<string>;
+    columnBorders: boolean;
+    enableRowSelection?: boolean;
+    /** Used for context cache invalidation when row selection changes */
+    selectedRowCount?: number;
+    cellUpdateFlash?: boolean;
+    useOddColumnBackground?: boolean;
+    useHoverRowBackground?: boolean;
+    useOddEvenRowBackground?: boolean;
+    rowGrouping?: string[];
+    headers: HeaderObject[];
+    rowHeight: number;
+    /** Number of header rows (for aria-rowindex: position + maxHeaderDepth + 1) */
+    maxHeaderDepth?: number;
+    heightOffsets?: HeightOffsets;
+    customTheme?: CustomTheme;
+    containerWidth?: number;
+    /** Main section viewport width (avoids clientWidth read when set); use for getVisibleBodyCells when !pinned */
+    mainSectionContainerWidth?: number;
+    onCellEdit?: (params: CellEditParams) => void;
+    onCellClick?: (params: CellClickParams) => void;
+    onRowGroupExpand?: (props: OnRowGroupExpandProps) => void | Promise<void>;
+    handleRowSelect?: (rowId: string, checked: boolean) => void;
+    handleMouseDown: (cell: CellData) => void;
+    handleMouseOver: (cell: CellData) => void;
+    cellRegistry?: Map<string, CellRegistryEntry>;
+    setCollapsedRows: Dispatch<SetStateAction<Map<string, number>>>;
+    setExpandedRows: Dispatch<SetStateAction<Map<string, number>>>;
+    setRowStateMap: Dispatch<SetStateAction<Map<string | number, RowState>>>;
+    getCollapsedRows?: () => Map<string, number>;
+    getExpandedRows?: () => Map<string, number>;
+    icons: IconsConfig;
+    theme: string;
+    rowButtons?: RowButton[];
+    loadingStateRenderer?: VanillaLoadingStateRenderer;
+    errorStateRenderer?: VanillaErrorStateRenderer;
+    emptyStateRenderer?: VanillaEmptyStateRenderer;
+    getBorderClass: (cell: CellData) => string;
+    isSelected: (cell: CellData) => boolean;
+    isInitialFocusedCell: (cell: CellData) => boolean;
+    isCopyFlashing: (cell: CellData) => boolean;
+    isWarningFlashing: (cell: CellData) => boolean;
+    isRowSelected?: (rowId: string) => boolean;
+    canExpandRowGroup?: (row: Row) => boolean;
+    isLoading?: boolean;
+    pinned?: "left" | "right";
+}
+export {};

package/dist/src/utils/bodyCellRenderer.d.ts

@@ -0,0 +1,5 @@
+import { AbsoluteBodyCell, CellRenderContext } from "./bodyCell/types";
+import type TableRow from "../types/TableRow";
+export type { AbsoluteBodyCell, CellData, CellEditParams, CellClickParams, CellRegistryEntry, CellRenderContext, } from "./bodyCell/types";
+export { cleanupBodyCellRendering } from "./bodyCell/eventTracking";
+export declare const renderBodyCells: (container: HTMLElement, cells: AbsoluteBodyCell[], context: CellRenderContext, scrollLeft?: number, allRows?: TableRow[], positionOnly?: boolean) => void;

package/dist/src/utils/charts/createBarChart.d.ts

@@ -0,0 +1,15 @@
+export interface BarChartProps {
+    data: number[];
+    width?: number | string;
+    height?: number;
+    color?: string;
+    gap?: number;
+    className?: string;
+    min?: number;
+    max?: number;
+}
+export declare const createBarChart: (options: BarChartProps) => {
+    element: SVGSVGElement;
+    update: (newOptions: Partial<BarChartProps>) => void;
+    destroy: () => void;
+} | null;

package/dist/src/utils/charts/createLineAreaChart.d.ts

@@ -0,0 +1,17 @@
+export interface LineAreaChartProps {
+    data: number[];
+    width?: number | string;
+    height?: number;
+    color?: string;
+    fillColor?: string;
+    fillOpacity?: number;
+    strokeWidth?: number;
+    className?: string;
+    min?: number;
+    max?: number;
+}
+export declare const createLineAreaChart: (options: LineAreaChartProps) => {
+    element: SVGSVGElement;
+    update: (newOptions: Partial<LineAreaChartProps>) => void;
+    destroy: () => void;
+} | null;

package/dist/src/utils/columnEditor/columnEditorUtils.d.ts

@@ -0,0 +1,14 @@
+import HeaderObject, { Accessor } from "../../types/HeaderObject";
+import { ColumnVisibilityState } from "../../types/ColumnVisibilityTypes";
+import { FlattenedHeader } from "../../types/FlattenedHeader";
+export type { FlattenedHeader };
+export declare const findAndMarkParentsVisible: (headers: HeaderObject[], childAccessor: Accessor, visited?: Set<string>) => void;
+export declare const areAllChildrenHidden: (children: HeaderObject[]) => boolean;
+export declare const updateParentHeaders: (headers: HeaderObject[]) => void;
+export declare const buildColumnVisibilityState: (headers: HeaderObject[]) => ColumnVisibilityState;
+export declare const findClosestValidSeparatorIndex: ({ flattenedHeaders, draggingRow, hoveredRowIndex, isTopHalfOfRow, }: {
+    flattenedHeaders: FlattenedHeader[];
+    draggingRow: FlattenedHeader;
+    hoveredRowIndex: number;
+    isTopHalfOfRow: boolean;
+}) => number | null;

package/dist/src/utils/columnEditor/createCheckbox.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Creates a vanilla JS checkbox element
+ */
+export interface CreateCheckboxOptions {
+    checked: boolean;
+    onChange: (checked: boolean) => void;
+    ariaLabel?: string;
+}
+/** Shared checkmark SVG for checkbox custom visual (used by createCheckbox and update helpers). */
+export declare const createCheckmarkSVG: () => SVGSVGElement;
+/**
+ * Updates an existing checkbox DOM (created by createCheckbox) to match the given checked state.
+ * Use when the checkbox element is reused (e.g. from cache) and selection state changed.
+ * @param container - Element that contains .st-checkbox-input and .st-checkbox-custom (the label or a parent)
+ */
+export declare const updateCheckboxElement: (container: HTMLElement, checked: boolean) => void;
+export declare const createCheckbox: ({ checked, onChange, ariaLabel }: CreateCheckboxOptions) => {
+    element: HTMLLabelElement;
+    update: (newChecked: boolean) => void;
+    destroy: () => void;
+};

package/dist/src/utils/columnEditor/createColumnEditor.d.ts

@@ -0,0 +1,25 @@
+import HeaderObject from "../../types/HeaderObject";
+import { ColumnEditorSearchFunction, ColumnEditorConfig } from "../../types/ColumnEditorConfig";
+import { ColumnVisibilityState } from "../../types/ColumnVisibilityTypes";
+export interface CreateColumnEditorOptions {
+    columnEditorText: string;
+    editColumns: boolean;
+    headers: HeaderObject[];
+    open: boolean;
+    searchEnabled: boolean;
+    searchPlaceholder: string;
+    searchFunction?: ColumnEditorSearchFunction;
+    columnEditorConfig: ColumnEditorConfig;
+    contextHeaders: HeaderObject[];
+    essentialAccessors?: ReadonlySet<string>;
+    resetColumns?: () => void;
+    setHeaders: (headers: HeaderObject[]) => void;
+    onColumnVisibilityChange?: (state: ColumnVisibilityState) => void;
+    onColumnOrderChange?: (headers: HeaderObject[]) => void;
+    setOpen: (open: boolean) => void;
+}
+export declare const createColumnEditor: (options: CreateColumnEditorOptions) => {
+    update: (newOptions: Partial<CreateColumnEditorOptions>) => void;
+    destroy: () => void;
+    element: HTMLDivElement;
+};

package/dist/src/utils/columnEditor/createColumnEditorPopout.d.ts

@@ -0,0 +1,22 @@
+import HeaderObject from "../../types/HeaderObject";
+import { ColumnEditorSearchFunction, ColumnEditorConfig } from "../../types/ColumnEditorConfig";
+import { ColumnVisibilityState } from "../../types/ColumnVisibilityTypes";
+export interface CreateColumnEditorPopoutOptions {
+    headers: HeaderObject[];
+    open: boolean;
+    searchEnabled: boolean;
+    searchPlaceholder: string;
+    searchFunction?: ColumnEditorSearchFunction;
+    columnEditorConfig: ColumnEditorConfig;
+    contextHeaders: HeaderObject[];
+    essentialAccessors?: ReadonlySet<string>;
+    setHeaders: (headers: HeaderObject[]) => void;
+    onColumnVisibilityChange?: (state: ColumnVisibilityState) => void;
+    onColumnOrderChange?: (headers: HeaderObject[]) => void;
+    resetColumns?: () => void;
+}
+export declare const createColumnEditorPopout: (initialOptions: CreateColumnEditorPopoutOptions) => {
+    element: HTMLDivElement;
+    update: (newOptions: Partial<CreateColumnEditorPopoutOptions>) => void;
+    destroy: () => void;
+};

package/dist/src/utils/columnEditor/createColumnEditorRow.d.ts

@@ -0,0 +1,31 @@
+import HeaderObject from "../../types/HeaderObject";
+import { ColumnEditorConfig } from "../../types/ColumnEditorConfig";
+import { FlattenedHeader } from "./columnEditorUtils";
+import { ColumnVisibilityState } from "../../types/ColumnVisibilityTypes";
+import { PanelSection } from "../pinnedColumnUtils";
+export interface CreateColumnEditorRowOptions {
+    allHeaders: HeaderObject[];
+    clearHoverSeparator?: () => void;
+    depth: number;
+    doesAnyHeaderHaveChildren: boolean;
+    draggingRow: FlattenedHeader | null;
+    getDraggingRow?: () => FlattenedHeader | null;
+    getHoveredSeparatorIndex?: () => number | null;
+    expandedHeaders: Set<string>;
+    flattenedHeaders: FlattenedHeader[];
+    forceExpanded: boolean;
+    header: HeaderObject;
+    hoveredSeparatorIndex: number | null;
+    panelSection?: PanelSection;
+    rowIndex: number;
+    setDraggingRow: (row: FlattenedHeader | null) => void;
+    setExpandedHeaders: (headers: Set<string>) => void;
+    setHoveredSeparatorIndex: (index: number | null) => void;
+    columnEditorConfig: ColumnEditorConfig;
+    essentialAccessors?: ReadonlySet<string>;
+    headers: HeaderObject[];
+    setHeaders: (headers: HeaderObject[]) => void;
+    onColumnVisibilityChange?: (state: ColumnVisibilityState) => void;
+    onColumnOrderChange?: (headers: HeaderObject[]) => void;
+}
+export declare const createColumnEditorRow: (options: CreateColumnEditorRowOptions) => DocumentFragment;

package/dist/src/utils/columnVirtualizationUtils.d.ts

@@ -0,0 +1,128 @@
+import HeaderObject, { Accessor } from "../types/HeaderObject";
+import { Pinned } from "../types/Pinned";
+/**
+ * Precomputed cumulative width data structure for O(1) column position lookups
+ * and O(log n) viewport calculations (analogous to CumulativeHeightMap for rows)
+ */
+export interface CumulativeWidthMap {
+    /** Array where index i contains the left pixel position of leaf column i */
+    columnLeftPositions: number[];
+    /** Total width of all columns combined */
+    totalWidth: number;
+    /** Ordered array of leaf headers (actual columns that render) */
+    leafHeaders: HeaderObject[];
+}
+/**
+ * Get all leaf headers (actual columns that render) from a header tree
+ * Handles nested headers, collapsed state, showWhen logic, and pinned sections
+ *
+ * Uses the existing displayCell utility to respect all visibility rules
+ *
+ * @param headers - Array of header objects (can be nested)
+ * @param pinned - The pinned state for this section
+ * @param allHeaders - All headers in the table (for displayCell context)
+ * @param collapsedHeaders - Set of collapsed header accessors
+ * @returns Flat array of leaf headers in order
+ */
+export declare const getLeafHeaders: (headers: HeaderObject[], pinned: Pinned | undefined, allHeaders: HeaderObject[], collapsedHeaders?: Set<Accessor>) => HeaderObject[];
+/**
+ * Build a cumulative width map for efficient viewport calculations
+ * This precomputes the left position of every column, enabling:
+ * - O(1) lookup of column left position
+ * - O(log n) binary search to find columns in viewport
+ *
+ * Similar to buildCumulativeHeightMap for rows
+ *
+ * @param headers - Array of header objects for a section
+ * @param pinned - The pinned state for this section
+ * @param allHeaders - All headers in the table (for displayCell context)
+ * @param collapsedHeaders - Set of collapsed header accessors
+ * @returns Cumulative width map with column positions
+ */
+export declare const buildCumulativeWidthMap: (headers: HeaderObject[], pinned: Pinned | undefined, allHeaders: HeaderObject[], collapsedHeaders?: Set<Accessor>) => CumulativeWidthMap;
+/**
+ * Find the column index at a given scroll position using binary search
+ * Returns the index of the column that contains or is closest to the scroll position
+ *
+ * Similar to findRowAtScrollPosition for rows
+ *
+ * @param scrollLeft - The horizontal scroll position in pixels
+ * @param widthMap - Precomputed cumulative width map
+ * @returns Column index at the scroll position
+ */
+export declare const findColumnAtScrollPosition: (scrollLeft: number, widthMap: CumulativeWidthMap) => number;
+/**
+ * Calculate visible columns for viewport with overscan buffer
+ * Returns column indices and the actual leaf header objects to render
+ *
+ * Similar to getViewportCalculations for rows
+ *
+ * @param scrollLeft - Current horizontal scroll position
+ * @param viewportWidth - Width of the visible viewport
+ * @param bufferColumnCount - Number of columns to render outside viewport (overscan)
+ * @param scrollDirection - Direction of scroll for asymmetric overscan
+ * @param widthMap - Precomputed cumulative width map
+ * @returns Object with startIndex, endIndex, and columns array (leaf columns only)
+ */
+export declare const getVisibleColumns: ({ scrollLeft, viewportWidth, bufferColumnCount, scrollDirection, widthMap, }: {
+    scrollLeft: number;
+    viewportWidth: number;
+    bufferColumnCount: number;
+    scrollDirection?: "left" | "right" | "none" | undefined;
+    widthMap: CumulativeWidthMap;
+}) => {
+    startIndex: number;
+    endIndex: number;
+    columns: HeaderObject[];
+};
+/**
+ * Build parent-child relationship maps for the header hierarchy
+ * This enables efficient lookup of ancestors for visible leaf columns
+ *
+ * @param headers - Array of top-level header objects
+ * @param pinned - The pinned state for this section
+ * @param allHeaders - All headers in the table (for displayCell context)
+ * @param collapsedHeaders - Set of collapsed header accessors
+ * @returns Maps for leaf-to-parents and parent-to-leaves relationships
+ */
+export declare const buildColumnHierarchy: (headers: HeaderObject[], pinned: Pinned | undefined, allHeaders: HeaderObject[], collapsedHeaders?: Set<Accessor>) => {
+    leafToParents: Map<Accessor, Accessor[]>;
+    parentToLeaves: Map<Accessor, Accessor[]>;
+};
+/**
+ * Get all headers to render (visible leaves + their ancestors)
+ *
+ * Strategy: Include a parent header if ANY of its children are visible
+ *
+ * @param visibleLeafColumns - Array of visible leaf header objects
+ * @param leafToParents - Map from leaf accessor to parent accessor chain
+ * @returns Set of all header accessors to render (leaves + ancestors)
+ */
+export declare const getHeadersToRender: (visibleLeafColumns: HeaderObject[], leafToParents: Map<Accessor, Accessor[]>) => Set<Accessor>;
+/**
+ * GridCell type (matches TableHeaderSection.tsx)
+ * Represents a single header cell in the grid with its positioning
+ */
+export type GridCell = {
+    header: HeaderObject;
+    gridColumnStart: number;
+    gridColumnEnd: number;
+    gridRowStart: number;
+    gridRowEnd: number;
+    colIndex: number;
+    parentHeader?: HeaderObject;
+};
+/**
+ * Recalculate grid column positions for visible headers
+ * Adjusts gridColumnStart/End to account for hidden columns before the viewport
+ *
+ * This is the key function that makes virtualization work - it offsets the grid
+ * positions so that the visible subset appears correctly positioned
+ *
+ * @param originalGridCells - All grid cells from the full header tree
+ * @param headersToRender - Set of header accessors that should be rendered
+ * @param visibleLeafColumns - Array of visible leaf columns (for determining offset)
+ * @param startColumnIndex - Index of first visible leaf column in the full leaf array
+ * @returns Filtered and repositioned grid cells
+ */
+export declare const recalculateGridPositions: (originalGridCells: GridCell[], headersToRender: Set<Accessor>, visibleLeafColumns: HeaderObject[], startColumnIndex: number) => GridCell[];

package/dist/src/utils/deprecatedPropsWarnings.d.ts

@@ -0,0 +1,10 @@
+import { SimpleTableConfig } from "../types/SimpleTableConfig";
+/**
+ * Checks for deprecated props and logs console errors with helpful migration messages
+ * @param props - The SimpleTable props to check
+ */
+export declare const checkDeprecatedProps: (props: SimpleTableConfig) => void;
+/**
+ * Export the list of deprecated props for testing or documentation purposes
+ */
+export declare const getDeprecatedPropNames: () => string[];

package/dist/src/utils/filters/createBooleanFilter.d.ts

@@ -0,0 +1,15 @@
+import HeaderObject from "../../types/HeaderObject";
+import { FilterCondition } from "../../types/FilterTypes";
+export interface CreateBooleanFilterOptions {
+    header: HeaderObject;
+    currentFilter?: FilterCondition;
+    onApplyFilter: (filter: FilterCondition) => void;
+    onClearFilter: () => void;
+    containerRef?: HTMLElement;
+    mainBodyRef?: HTMLElement;
+}
+export declare const createBooleanFilter: (options: CreateBooleanFilterOptions) => {
+    element: HTMLDivElement;
+    update: (newOptions: Partial<CreateBooleanFilterOptions>) => void;
+    destroy: () => void;
+};

package/dist/src/utils/filters/createCustomSelect.d.ts

@@ -0,0 +1,20 @@
+export interface CustomSelectOption {
+    value: string;
+    label: string;
+}
+export interface CreateCustomSelectOptions {
+    value: string;
+    onChange: (value: string) => void;
+    options: CustomSelectOption[];
+    placeholder?: string;
+    className?: string;
+    disabled?: boolean;
+    containerRef?: HTMLElement;
+    mainBodyRef?: HTMLElement;
+}
+export declare const createCustomSelect: (options: CreateCustomSelectOptions) => {
+    element: HTMLDivElement;
+    update: (newOptions: Partial<CreateCustomSelectOptions>) => void;
+    destroy: () => void;
+    setOpen: (newOpen: boolean) => void;
+};

package/dist/src/utils/filters/createDateFilter.d.ts

@@ -0,0 +1,15 @@
+import HeaderObject from "../../types/HeaderObject";
+import { FilterCondition } from "../../types/FilterTypes";
+export interface CreateDateFilterOptions {
+    header: HeaderObject;
+    currentFilter?: FilterCondition;
+    onApplyFilter: (filter: FilterCondition) => void;
+    onClearFilter: () => void;
+    containerRef?: HTMLElement;
+    mainBodyRef?: HTMLElement;
+}
+export declare const createDateFilter: (options: CreateDateFilterOptions) => {
+    element: HTMLDivElement;
+    update: (newOptions: Partial<CreateDateFilterOptions>) => void;
+    destroy: () => void;
+};

package/dist/src/utils/filters/createDatePicker.d.ts

@@ -0,0 +1,10 @@
+export interface CreateDatePickerOptions {
+    onChange: (date: Date) => void;
+    onClose?: () => void;
+    value: Date;
+}
+export declare const createDatePicker: (options: CreateDatePickerOptions) => {
+    element: HTMLDivElement;
+    update: (newOptions: Partial<CreateDatePickerOptions>) => void;
+    destroy: () => void;
+};

package/dist/src/utils/filters/createDropdown.d.ts

@@ -0,0 +1,16 @@
+export interface CreateDropdownOptions {
+    children: HTMLElement;
+    containerRef?: HTMLElement;
+    mainBodyRef?: HTMLElement;
+    onClose: () => void;
+    open: boolean;
+    overflow?: "auto" | "visible" | "hidden";
+    width?: number;
+    positioning?: "fixed" | "absolute";
+}
+export declare const createDropdown: (options: CreateDropdownOptions) => {
+    element: HTMLDivElement;
+    update: (newOptions: Partial<CreateDropdownOptions>) => void;
+    destroy: () => void;
+    setOpen: (newOpen: boolean) => void;
+};

package/dist/src/utils/filters/createEnumFilter.d.ts

@@ -0,0 +1,15 @@
+import HeaderObject from "../../types/HeaderObject";
+import { FilterCondition } from "../../types/FilterTypes";
+export interface CreateEnumFilterOptions {
+    header: HeaderObject;
+    currentFilter?: FilterCondition;
+    onApplyFilter: (filter: FilterCondition) => void;
+    onClearFilter: () => void;
+    containerRef?: HTMLElement;
+    mainBodyRef?: HTMLElement;
+}
+export declare const createEnumFilter: (options: CreateEnumFilterOptions) => {
+    element: HTMLDivElement;
+    update: (newOptions: Partial<CreateEnumFilterOptions>) => void;
+    destroy: () => void;
+};

package/dist/src/utils/filters/createFilterActions.d.ts

@@ -0,0 +1,11 @@
+export interface CreateFilterActionsOptions {
+    onApply: () => void;
+    onClear?: () => void;
+    canApply: boolean;
+    showClear: boolean;
+}
+export declare const createFilterActions: (options: CreateFilterActionsOptions) => {
+    element: HTMLDivElement;
+    update: (newOptions: Partial<CreateFilterActionsOptions>) => void;
+    destroy: () => void;
+};

package/dist/src/utils/filters/createFilterDropdown.d.ts

@@ -0,0 +1,15 @@
+import HeaderObject from "../../types/HeaderObject";
+import { FilterCondition } from "../../types/FilterTypes";
+export interface CreateFilterDropdownOptions {
+    header: HeaderObject;
+    currentFilter?: FilterCondition;
+    onApplyFilter: (filter: FilterCondition) => void;
+    onClearFilter: () => void;
+    containerRef?: HTMLElement;
+    mainBodyRef?: HTMLElement;
+}
+export declare const createFilterDropdown: (options: CreateFilterDropdownOptions) => {
+    element: HTMLDivElement;
+    update: (newOptions: Partial<import("./createStringFilter").CreateStringFilterOptions>) => void;
+    destroy: () => void;
+};

package/dist/src/utils/filters/createFilterInput.d.ts

@@ -0,0 +1,16 @@
+export interface CreateFilterInputOptions {
+    type?: "text" | "number" | "date";
+    value: string;
+    onChange: (value: string) => void;
+    onEnter?: () => void;
+    placeholder?: string;
+    autoFocus?: boolean;
+    min?: string;
+    max?: string;
+    step?: string;
+}
+export declare const createFilterInput: (options: CreateFilterInputOptions) => {
+    element: HTMLInputElement;
+    update: (newOptions: Partial<CreateFilterInputOptions>) => void;
+    destroy: () => void;
+};

package/dist/src/utils/filters/createNumberFilter.d.ts

@@ -0,0 +1,15 @@
+import HeaderObject from "../../types/HeaderObject";
+import { FilterCondition } from "../../types/FilterTypes";
+export interface CreateNumberFilterOptions {
+    header: HeaderObject;
+    currentFilter?: FilterCondition;
+    onApplyFilter: (filter: FilterCondition) => void;
+    onClearFilter: () => void;
+    containerRef?: HTMLElement;
+    mainBodyRef?: HTMLElement;
+}
+export declare const createNumberFilter: (options: CreateNumberFilterOptions) => {
+    element: HTMLDivElement;
+    update: (newOptions: Partial<CreateNumberFilterOptions>) => void;
+    destroy: () => void;
+};

package/dist/src/utils/filters/createStringFilter.d.ts

@@ -0,0 +1,15 @@
+import HeaderObject from "../../types/HeaderObject";
+import { FilterCondition } from "../../types/FilterTypes";
+export interface CreateStringFilterOptions {
+    header: HeaderObject;
+    currentFilter?: FilterCondition;
+    onApplyFilter: (filter: FilterCondition) => void;
+    onClearFilter: () => void;
+    containerRef?: HTMLElement;
+    mainBodyRef?: HTMLElement;
+}
+export declare const createStringFilter: (options: CreateStringFilterOptions) => {
+    element: HTMLDivElement;
+    update: (newOptions: Partial<CreateStringFilterOptions>) => void;
+    destroy: () => void;
+};

package/dist/src/utils/footer/createTableFooter.d.ts

@@ -0,0 +1,21 @@
+import OnNextPage from "../../types/OnNextPage";
+export interface CreateTableFooterOptions {
+    currentPage: number;
+    hideFooter?: boolean;
+    onPageChange: (page: number) => void;
+    onNextPage?: OnNextPage;
+    onUserPageChange?: (page: number) => void | Promise<void>;
+    rowsPerPage: number;
+    shouldPaginate?: boolean;
+    totalPages: number;
+    totalRows: number;
+    /** Custom icon for previous page button (string = HTML, HTMLElement = node to clone/append). */
+    prevIcon?: string | HTMLElement | SVGSVGElement;
+    /** Custom icon for next page button. */
+    nextIcon?: string | HTMLElement | SVGSVGElement;
+}
+export declare const createTableFooter: (options: CreateTableFooterOptions) => {
+    element: HTMLDivElement;
+    update: (newOptions: Partial<CreateTableFooterOptions>) => void;
+    destroy: () => void;
+};

package/dist/src/utils/headerCell/collapsing.d.ts

@@ -0,0 +1,6 @@
+import HeaderObject from "../../types/HeaderObject";
+import { HeaderRenderContext } from "./types";
+/** Use same icon and animation as body row expand/collapse (icons.expand + st-expand-icon-container). */
+export declare const createCollapseIcon: (header: HeaderObject, context: HeaderRenderContext) => HTMLElement | null;
+/** Update header collapse icon direction on an existing cell (same pattern as body updateExpandIconState). */
+export declare const updateHeaderCollapseIconState: (cellElement: HTMLElement, isCollapsed: boolean, label?: string) => void;

package/dist/src/utils/headerCell/dragging.d.ts

@@ -0,0 +1,5 @@
+import HeaderObject from "../../types/HeaderObject";
+import { HeaderRenderContext } from "./types";
+export declare const handleColumnHeaderClick: (event: MouseEvent, header: HeaderObject, colIndex: number, context: HeaderRenderContext) => void;
+export declare const handleColumnHeaderDoubleClick: (event: MouseEvent, header: HeaderObject, context: HeaderRenderContext) => void;
+export declare const attachDragHandlers: (labelElement: HTMLElement, cellElement: HTMLElement, header: HeaderObject, context: HeaderRenderContext) => void;

package/dist/src/utils/headerCell/editing.d.ts

@@ -0,0 +1,4 @@
+import HeaderObject from "../../types/HeaderObject";
+import { HeaderRenderContext } from "./types";
+export declare const createEditableInput: (header: HeaderObject, context: HeaderRenderContext, labelContainer: HTMLElement) => HTMLInputElement;
+export declare const createLabelContent: (header: HeaderObject, context: HeaderRenderContext, labelOverride?: string) => HTMLElement;

package/dist/src/utils/headerCell/eventTracking.d.ts

@@ -0,0 +1,25 @@
+import HeaderObject from "../../types/HeaderObject";
+export declare let prevUpdateTime: number;
+export declare let prevDraggingPosition: {
+    screenX: number;
+    screenY: number;
+};
+export declare let prevHeaders: HeaderObject[] | null;
+export declare const setPrevUpdateTime: (time: number) => void;
+export declare const setPrevDraggingPosition: (position: {
+    screenX: number;
+    screenY: number;
+}) => void;
+export declare const setPrevHeaders: (headers: HeaderObject[] | null) => void;
+export declare const getRenderedCells: (container: HTMLElement) => Map<string, HTMLElement>;
+export interface CachedHeaderPosition {
+    left: number;
+    top: number;
+    width: number;
+    height: number;
+}
+export declare const getHeaderPositionCache: (container: HTMLElement) => Map<string, CachedHeaderPosition>;
+export declare const REVERT_TO_PREVIOUS_HEADERS_DELAY = 1500;
+export declare const throttle: (callback: () => void, limit: number) => void;
+export declare const addTrackedEventListener: (element: HTMLElement, event: string, handler: EventListener, options?: AddEventListenerOptions) => void;
+export declare const cleanupHeaderCellRendering: (container?: HTMLElement) => void;