@humanspeak/svelte-headless-table 5.0.0

package/dist/plugins/addExpandedRows.d.ts

@@ -0,0 +1,17 @@
+import type { BodyRow } from '../bodyRows.js';
+import type { NewTablePropSet, TablePlugin } from '../types/TablePlugin.js';
+import { type RecordSetStore } from '../utils/store.js';
+import { type Readable, type Writable } from 'svelte/store';
+export interface ExpandedRowsConfig<Item> {
+    initialExpandedIds?: Record<string, boolean>;
+}
+export interface ExpandedRowsState<Item> {
+    expandedIds: RecordSetStore<string>;
+    getRowState: (row: BodyRow<Item>) => ExpandedRowsRowState;
+}
+export interface ExpandedRowsRowState {
+    isExpanded: Writable<boolean>;
+    canExpand: Readable<boolean>;
+    isAllSubRowsExpanded: Readable<boolean>;
+}
+export declare const addExpandedRows: <Item>({ initialExpandedIds }?: ExpandedRowsConfig<Item>) => TablePlugin<Item, ExpandedRowsState<Item>, Record<string, never>, NewTablePropSet<never>>;

package/dist/plugins/addExpandedRows.js

@@ -0,0 +1,51 @@
+import { recordSetStore } from '../utils/store.js';
+import { keyed } from '@humanspeak/svelte-keyed';
+import { derived, readable } from 'svelte/store';
+const withExpandedRows = (row, expandedIds) => {
+    if (row.subRows === undefined) {
+        return [row];
+    }
+    if (expandedIds[row.id] !== true) {
+        return [row];
+    }
+    const expandedSubRows = row.subRows.flatMap((subRow) => withExpandedRows(subRow, expandedIds));
+    return [row, ...expandedSubRows];
+};
+export const addExpandedRows = ({ initialExpandedIds = {} } = {}) => () => {
+    const expandedIds = recordSetStore(initialExpandedIds);
+    const getRowState = (row) => {
+        const isExpanded = keyed(expandedIds, row.id);
+        const canExpand = readable((row.subRows?.length ?? 0) > 0);
+        const subRowExpandedIds = derived(expandedIds, ($expandedIds) => {
+            // Check prefix with '>' to match child ids while ignoring this row's id.
+            return Object.entries($expandedIds).filter(([id, expanded]) => id.startsWith(`${row.id}>`) && expanded);
+        });
+        // If the number of expanded subRows is equal to the number of subRows
+        // that can expand, then all subRows are expanded.
+        const isAllSubRowsExpanded = derived(subRowExpandedIds, ($subRowExpandedIds) => {
+            if (row.subRows === undefined) {
+                return true;
+            }
+            // canExpand is derived from the presence of the `subRows` property.
+            const expandableSubRows = row.subRows.filter((subRow) => subRow.subRows !== undefined);
+            return $subRowExpandedIds.length === expandableSubRows.length;
+        });
+        return {
+            isExpanded,
+            canExpand,
+            isAllSubRowsExpanded
+        };
+    };
+    const pluginState = { expandedIds, getRowState };
+    const deriveRows = (rows) => {
+        return derived([rows, expandedIds], ([$rows, $expandedIds]) => {
+            return $rows.flatMap((row) => {
+                return withExpandedRows(row, $expandedIds);
+            });
+        });
+    };
+    return {
+        pluginState,
+        deriveRows
+    };
+};

package/dist/plugins/addFlatten.d.ts

@@ -0,0 +1,19 @@
+import type { BodyRow } from '../bodyRows.js';
+import type { NewTablePropSet, TablePlugin } from '../types/TablePlugin.js';
+import { type Writable } from 'svelte/store';
+export interface FlattenConfig {
+    initialDepth?: number;
+}
+export interface FlattenState {
+    depth: Writable<number>;
+}
+export interface FlattenColumnOptions<Item> {
+}
+export type FlattenPropSet = NewTablePropSet<{
+    'tbody.tr.td': {
+        flatten: (depth: number) => void;
+        unflatten: () => void;
+    };
+}>;
+export declare const getFlattenedRows: <Item, Row extends BodyRow<Item>>(rows: Row[], depth: number) => Row[];
+export declare const addFlatten: <Item>({ initialDepth }?: FlattenConfig) => TablePlugin<Item, FlattenState, FlattenColumnOptions<Item>, FlattenPropSet>;

package/dist/plugins/addFlatten.js

@@ -0,0 +1,38 @@
+import { derived, writable } from 'svelte/store';
+export const getFlattenedRows = (rows, depth) => {
+    if (depth === 0)
+        return rows;
+    const flattenedRows = [];
+    for (const row of rows) {
+        if (row.subRows === undefined)
+            continue;
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        flattenedRows.push(...getFlattenedRows(row.subRows, depth - 1));
+    }
+    return flattenedRows;
+};
+export const addFlatten = ({ initialDepth = 0 } = {}) => () => {
+    const depth = writable(initialDepth);
+    const pluginState = { depth };
+    const deriveRows = (rows) => {
+        return derived([rows, depth], ([$rows, $depth]) => {
+            return getFlattenedRows($rows, $depth);
+        });
+    };
+    return {
+        pluginState,
+        deriveRows,
+        hooks: {
+            'tbody.tr.td': () => {
+                const props = derived([], () => {
+                    const flatten = ($depth) => {
+                        depth.set($depth);
+                    };
+                    const unflatten = () => flatten(0);
+                    return { flatten, unflatten };
+                });
+                return { props };
+            }
+        }
+    };
+};

package/dist/plugins/addGridLayout.d.ts

@@ -0,0 +1,2 @@
+import type { NewTablePropSet, TablePlugin } from '../types/TablePlugin.js';
+export declare const addGridLayout: <Item>() => TablePlugin<Item, Record<string, never>, Record<string, never>, NewTablePropSet<never>>;

package/dist/plugins/addGridLayout.js

@@ -0,0 +1,73 @@
+import { derived } from 'svelte/store';
+export const addGridLayout = () => ({ tableState }) => {
+    const pluginState = {};
+    const deriveTableAttrs = (attrs) => {
+        return derived([attrs, tableState.visibleColumns], ([$attrs, $visibleColumns]) => {
+            return {
+                ...$attrs,
+                style: {
+                    display: 'grid',
+                    'grid-template-columns': `repeat(${$visibleColumns.length}, auto)`
+                }
+            };
+        });
+    };
+    const deriveTableHeadAttrs = (attrs) => {
+        return derived(attrs, ($attrs) => {
+            return {
+                ...$attrs,
+                style: {
+                    display: 'contents'
+                }
+            };
+        });
+    };
+    const deriveTableBodyAttrs = (attrs) => {
+        return derived(attrs, ($attrs) => {
+            return {
+                ...$attrs,
+                style: {
+                    display: 'contents'
+                }
+            };
+        });
+    };
+    return {
+        pluginState,
+        deriveTableAttrs,
+        deriveTableHeadAttrs,
+        deriveTableBodyAttrs,
+        hooks: {
+            'thead.tr': () => {
+                const attrs = derived([], () => {
+                    return {
+                        style: {
+                            display: 'contents'
+                        }
+                    };
+                });
+                return { attrs };
+            },
+            'thead.tr.th': (cell) => {
+                const attrs = derived([], () => {
+                    return {
+                        style: {
+                            'grid-column': `${cell.colstart + 1} / span ${cell.colspan}`
+                        }
+                    };
+                });
+                return { attrs };
+            },
+            'tbody.tr': () => {
+                const attrs = derived([], () => {
+                    return {
+                        style: {
+                            display: 'contents'
+                        }
+                    };
+                });
+                return { attrs };
+            }
+        }
+    };
+};

package/dist/plugins/addGroupBy.d.ts

@@ -0,0 +1,40 @@
+import { BodyRow } from '../bodyRows.js';
+import type { DataLabel } from '../types/Label.js';
+import type { NewTablePropSet, TablePlugin } from '../types/TablePlugin.js';
+import { type ArraySetStore } from '../utils/store.js';
+export interface GroupByConfig {
+    initialGroupByIds?: string[];
+    disableMultiGroup?: boolean;
+    isMultiGroupEvent?: (event: Event) => boolean;
+}
+export interface GroupByState {
+    groupByIds: ArraySetStore<string>;
+}
+export interface GroupByColumnOptions<Item, Value = any, GroupOn extends string | number = any, Aggregate = any> {
+    disable?: boolean;
+    getAggregateValue?: (values: GroupOn[]) => Aggregate;
+    getGroupOn?: (value: Value) => GroupOn;
+    cell?: DataLabel<Item>;
+}
+export type GroupByPropSet = NewTablePropSet<{
+    'thead.tr.th': {
+        grouped: boolean;
+        toggle: (event: Event) => void;
+        clear: () => void;
+        disabled: boolean;
+    };
+    'tbody.tr.td': {
+        repeated: boolean;
+        aggregated: boolean;
+        grouped: boolean;
+    };
+}>;
+interface GetGroupedRowsProps {
+    repeatCellIds: Record<string, boolean>;
+    aggregateCellIds: Record<string, boolean>;
+    groupCellIds: Record<string, boolean>;
+    allGroupByIds: string[];
+}
+export declare const getGroupedRows: <Item, Row extends BodyRow<Item>, GroupOn extends string | number = any>(rows: Row[], groupByIds: string[], columnOptions: Record<string, GroupByColumnOptions<Item>>, { repeatCellIds, aggregateCellIds, groupCellIds, allGroupByIds }: GetGroupedRowsProps) => Row[];
+export declare const addGroupBy: <Item>({ initialGroupByIds, disableMultiGroup, isMultiGroupEvent }?: GroupByConfig) => TablePlugin<Item, GroupByState, GroupByColumnOptions<Item>, GroupByPropSet>;
+export {};

package/dist/plugins/addGroupBy.js

@@ -0,0 +1,192 @@
+import { DataBodyCell } from '../bodyCells.js';
+import { BodyRow, DisplayBodyRow } from '../bodyRows.js';
+import { isShiftClick } from '../utils/event.js';
+import { nonUndefined } from '../utils/filter.js';
+import { arraySetStore } from '../utils/store.js';
+import { derived, writable } from 'svelte/store';
+const getIdPrefix = (id) => {
+    const prefixTokens = id.split('>').slice(0, -1);
+    if (prefixTokens.length === 0) {
+        return '';
+    }
+    return `${prefixTokens.join('>')}>`;
+};
+const getIdLeaf = (id) => {
+    const tokens = id.split('>');
+    return tokens[tokens.length - 1] ?? '';
+};
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+const deepenIdAndDepth = (row, parentId) => {
+    row.id = `${parentId}>${row.id}`;
+    row.depth = row.depth + 1;
+    row.subRows?.forEach((subRow) => deepenIdAndDepth(subRow, parentId));
+};
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export const getGroupedRows = (rows, groupByIds, columnOptions, { repeatCellIds, aggregateCellIds, groupCellIds, allGroupByIds }) => {
+    if (groupByIds.length === 0) {
+        return rows;
+    }
+    if (rows.length === 0) {
+        return rows;
+    }
+    const idPrefix = getIdPrefix(rows[0].id);
+    const [groupById, ...restIds] = groupByIds;
+    const subRowsForGroupOnValue = new Map();
+    for (const row of rows) {
+        const cell = row.cellForId[groupById];
+        if (!cell.isData()) {
+            break;
+        }
+        const columnOption = columnOptions[groupById] ?? {};
+        const { getGroupOn } = columnOption;
+        const groupOnValue = getGroupOn?.(cell.value) ?? cell.value;
+        if (typeof groupOnValue === 'function' || typeof groupOnValue === 'object') {
+            console.warn(`Missing \`getGroupOn\` column option to aggregate column "${groupById}" with object values`);
+        }
+        const subRows = subRowsForGroupOnValue.get(groupOnValue) ?? [];
+        subRowsForGroupOnValue.set(groupOnValue, [...subRows, row]);
+    }
+    const groupedRows = [];
+    let groupRowIdx = 0;
+    for (const [groupOnValue, subRows] of subRowsForGroupOnValue.entries()) {
+        // Guaranteed to have at least one subRow.
+        const firstRow = subRows[0];
+        const groupRow = new DisplayBodyRow({
+            id: `${idPrefix}${groupRowIdx++}`,
+            // TODO Differentiate data rows and grouped rows.
+            depth: firstRow.depth,
+            cells: [],
+            cellForId: {}
+        });
+        const groupRowCellForId = Object.fromEntries(Object.entries(firstRow.cellForId).map(([id, cell]) => {
+            if (id === groupById) {
+                const newCell = new DataBodyCell({
+                    column: cell.column,
+                    row: groupRow,
+                    value: groupOnValue
+                });
+                return [id, newCell];
+            }
+            const columnCells = subRows.map((row) => row.cellForId[id]).filter(nonUndefined);
+            if (!columnCells[0].isData()) {
+                const clonedCell = columnCells[0].clone();
+                clonedCell.row = groupRow;
+                return [id, clonedCell];
+            }
+            const { cell: label, getAggregateValue } = columnOptions[id] ?? {};
+            const columnValues = columnCells.map((cell) => cell.value);
+            const value = getAggregateValue === undefined ? '' : getAggregateValue(columnValues);
+            const newCell = new DataBodyCell({
+                column: cell.column,
+                row: groupRow,
+                value,
+                label
+            });
+            return [id, newCell];
+        }));
+        const groupRowCells = firstRow.cells.map((cell) => {
+            return groupRowCellForId[cell.id];
+        });
+        groupRow.cellForId = groupRowCellForId;
+        groupRow.cells = groupRowCells;
+        const groupRowSubRows = subRows.map((subRow) => {
+            const clonedSubRow = subRow.clone({ includeCells: true, includeSubRows: true });
+            deepenIdAndDepth(clonedSubRow, groupRow.id);
+            return clonedSubRow;
+        });
+        groupRow.subRows = getGroupedRows(groupRowSubRows, restIds, columnOptions, {
+            repeatCellIds,
+            aggregateCellIds,
+            groupCellIds,
+            allGroupByIds
+        });
+        groupedRows.push(groupRow);
+        groupRow.cells.forEach((cell) => {
+            if (cell.id === groupById) {
+                groupCellIds[cell.rowColId()] = true;
+            }
+            else {
+                aggregateCellIds[cell.rowColId()] = true;
+            }
+        });
+        groupRow.subRows.forEach((subRow) => {
+            subRow.parentRow = groupRow;
+            subRow.cells.forEach((cell) => {
+                if (allGroupByIds.includes(cell.id) && groupCellIds[cell.rowColId()] !== true) {
+                    repeatCellIds[cell.rowColId()] = true;
+                }
+            });
+        });
+    }
+    return groupedRows;
+};
+export const addGroupBy = ({ initialGroupByIds = [], disableMultiGroup = false, isMultiGroupEvent = isShiftClick } = {}) => ({ columnOptions }) => {
+    const disabledGroupIds = Object.entries(columnOptions)
+        .filter(([, option]) => option.disable === true)
+        .map(([columnId]) => columnId);
+    const groupByIds = arraySetStore(initialGroupByIds);
+    const repeatCellIds = writable({});
+    const aggregateCellIds = writable({});
+    const groupCellIds = writable({});
+    const pluginState = {
+        groupByIds
+    };
+    const deriveRows = (rows) => {
+        return derived([rows, groupByIds], ([$rows, $groupByIds]) => {
+            const $repeatCellIds = {};
+            const $aggregateCellIds = {};
+            const $groupCellIds = {};
+            const $groupedRows = getGroupedRows($rows, $groupByIds, columnOptions, {
+                repeatCellIds: $repeatCellIds,
+                aggregateCellIds: $aggregateCellIds,
+                groupCellIds: $groupCellIds,
+                allGroupByIds: $groupByIds
+            });
+            repeatCellIds.set($repeatCellIds);
+            aggregateCellIds.set($aggregateCellIds);
+            groupCellIds.set($groupCellIds);
+            return $groupedRows;
+        });
+    };
+    return {
+        pluginState,
+        deriveRows,
+        hooks: {
+            'thead.tr.th': (cell) => {
+                const disabled = disabledGroupIds.includes(cell.id) || !cell.isData();
+                const props = derived(groupByIds, ($groupByIds) => {
+                    const grouped = $groupByIds.includes(cell.id);
+                    const toggle = (event) => {
+                        if (!cell.isData())
+                            return;
+                        if (disabled)
+                            return;
+                        groupByIds.toggle(cell.id, {
+                            clearOthers: disableMultiGroup || !isMultiGroupEvent(event)
+                        });
+                    };
+                    const clear = () => {
+                        groupByIds.remove(cell.id);
+                    };
+                    return {
+                        grouped,
+                        toggle,
+                        clear,
+                        disabled
+                    };
+                });
+                return { props };
+            },
+            'tbody.tr.td': (cell) => {
+                const props = derived([repeatCellIds, aggregateCellIds, groupCellIds], ([$repeatCellIds, $aggregateCellIds, $groupCellIds]) => {
+                    return {
+                        repeated: $repeatCellIds[cell.rowColId()] === true,
+                        aggregated: $aggregateCellIds[cell.rowColId()] === true,
+                        grouped: $groupCellIds[cell.rowColId()] === true
+                    };
+                });
+                return { props };
+            }
+        }
+    };
+};

package/dist/plugins/addHiddenColumns.d.ts

@@ -0,0 +1,9 @@
+import type { NewTablePropSet, TablePlugin } from '../types/TablePlugin.js';
+import { type Writable } from 'svelte/store';
+export interface HiddenColumnsConfig {
+    initialHiddenColumnIds?: string[];
+}
+export interface HiddenColumnsState {
+    hiddenColumnIds: Writable<string[]>;
+}
+export declare const addHiddenColumns: <Item>({ initialHiddenColumnIds }?: HiddenColumnsConfig) => TablePlugin<Item, HiddenColumnsState, Record<string, never>, NewTablePropSet<never>>;

package/dist/plugins/addHiddenColumns.js

@@ -0,0 +1,17 @@
+import { derived, writable } from 'svelte/store';
+export const addHiddenColumns = ({ initialHiddenColumnIds = [] } = {}) => () => {
+    const hiddenColumnIds = writable(initialHiddenColumnIds);
+    const pluginState = { hiddenColumnIds };
+    const deriveFlatColumns = (flatColumns) => {
+        return derived([flatColumns, hiddenColumnIds], ([$flatColumns, $hiddenColumnIds]) => {
+            if ($hiddenColumnIds.length === 0) {
+                return $flatColumns;
+            }
+            return $flatColumns.filter((c) => !$hiddenColumnIds.includes(c.id));
+        });
+    };
+    return {
+        pluginState,
+        deriveFlatColumns
+    };
+};

package/dist/plugins/addPagination.d.ts

@@ -0,0 +1,39 @@
+import type { NewTablePropSet, TablePlugin } from '../types/TablePlugin.js';
+import { type Readable, type Updater, type Writable } from 'svelte/store';
+export type PaginationConfig = {
+    initialPageIndex?: number;
+    initialPageSize?: number;
+} & ({
+    serverSide?: false | undefined;
+    serverItemCount?: undefined;
+} | {
+    serverSide: true;
+    serverItemCount: Readable<number>;
+});
+export interface PaginationState {
+    pageSize: Writable<number>;
+    pageIndex: Writable<number>;
+    pageCount: Readable<number>;
+    hasPreviousPage: Readable<boolean>;
+    hasNextPage: Readable<boolean>;
+}
+export declare const createPageStore: ({ items, initialPageSize, initialPageIndex, serverSide, serverItemCount }: PageStoreConfig) => {
+    pageSize: {
+        subscribe: (this: void, run: import("svelte/store").Subscriber<number>, invalidate?: import("svelte/store").Invalidator<number> | undefined) => import("svelte/store").Unsubscriber;
+        update: (fn: Updater<number>) => void;
+        set: (newPageSize: number) => void;
+    };
+    pageIndex: Writable<number>;
+    pageCount: Readable<number>;
+    serverItemCount: Readable<number> | undefined;
+    hasPreviousPage: Readable<boolean>;
+    hasNextPage: Readable<boolean>;
+};
+export interface PageStoreConfig {
+    items: Readable<unknown[]>;
+    initialPageSize?: number;
+    initialPageIndex?: number;
+    serverSide?: boolean;
+    serverItemCount?: Readable<number>;
+}
+export declare const addPagination: <Item>({ initialPageIndex, initialPageSize, serverSide, serverItemCount }?: PaginationConfig) => TablePlugin<Item, PaginationState, Record<string, never>, NewTablePropSet<never>>;

package/dist/plugins/addPagination.js

@@ -0,0 +1,84 @@
+import { derived, writable } from 'svelte/store';
+const MIN_PAGE_SIZE = 1;
+export const createPageStore = ({ items, initialPageSize, initialPageIndex, serverSide, serverItemCount }) => {
+    const pageSize = writable(initialPageSize);
+    const updatePageSize = (fn) => {
+        pageSize.update(($pageSize) => {
+            const newPageSize = fn($pageSize);
+            return Math.max(newPageSize, MIN_PAGE_SIZE);
+        });
+    };
+    const setPageSize = (newPageSize) => updatePageSize(() => newPageSize);
+    const pageIndex = writable(initialPageIndex);
+    function calcPageCountAndLimitIndex([$pageSize, $itemCount]) {
+        const $pageCount = Math.ceil($itemCount / $pageSize);
+        pageIndex.update(($pageIndex) => {
+            if ($pageCount > 0 && $pageIndex >= $pageCount) {
+                return $pageCount - 1;
+            }
+            return $pageIndex;
+        });
+        return $pageCount;
+    }
+    let pageCount;
+    if (serverSide && serverItemCount != null) {
+        pageCount = derived([pageSize, serverItemCount], calcPageCountAndLimitIndex);
+    }
+    else {
+        const itemCount = derived(items, ($items) => $items.length);
+        pageCount = derived([pageSize, itemCount], calcPageCountAndLimitIndex);
+    }
+    const hasPreviousPage = derived(pageIndex, ($pageIndex) => {
+        return $pageIndex > 0;
+    });
+    const hasNextPage = derived([pageIndex, pageCount], ([$pageIndex, $pageCount]) => {
+        return $pageIndex < $pageCount - 1;
+    });
+    return {
+        pageSize: {
+            subscribe: pageSize.subscribe,
+            update: updatePageSize,
+            set: setPageSize
+        },
+        pageIndex,
+        pageCount,
+        serverItemCount,
+        hasPreviousPage,
+        hasNextPage
+    };
+};
+export const addPagination = ({ initialPageIndex = 0, initialPageSize = 10, serverSide = false, serverItemCount } = {}) => () => {
+    const prePaginatedRows = writable([]);
+    const paginatedRows = writable([]);
+    const { pageSize, pageIndex, pageCount, hasPreviousPage, hasNextPage } = createPageStore({
+        items: prePaginatedRows,
+        initialPageIndex,
+        initialPageSize,
+        serverSide,
+        serverItemCount
+    });
+    const pluginState = {
+        pageSize,
+        pageIndex,
+        pageCount,
+        hasPreviousPage,
+        hasNextPage
+    };
+    const derivePageRows = (rows) => {
+        return derived([rows, pageSize, pageIndex], ([$rows, $pageSize, $pageIndex]) => {
+            prePaginatedRows.set($rows);
+            if (serverSide) {
+                paginatedRows.set($rows);
+                return $rows;
+            }
+            const startIdx = $pageIndex * $pageSize;
+            const _paginatedRows = $rows.slice(startIdx, startIdx + $pageSize);
+            paginatedRows.set(_paginatedRows);
+            return _paginatedRows;
+        });
+    };
+    return {
+        pluginState,
+        derivePageRows
+    };
+};

package/dist/plugins/addResizedColumns.d.ts

@@ -0,0 +1,41 @@
+import type { NewTableAttributeSet, NewTablePropSet, TablePlugin } from '../types/TablePlugin.js';
+import { type Writable } from 'svelte/store';
+export interface AddResizedColumnsConfig {
+    onResizeEnd?: (ev: Event) => void;
+}
+export type ResizedColumnsState = {
+    columnWidths: Writable<Record<string, number>>;
+};
+export type ResizedColumnsColumnOptions = {
+    initialWidth?: number;
+    minWidth?: number;
+    maxWidth?: number;
+    disable?: boolean;
+};
+export type ResizedColumnsPropSet = NewTablePropSet<{
+    'thead.tr.th': {
+        (node: Element): void;
+        drag: (node: Element) => void;
+        reset: (node: Element) => void;
+        disabled: boolean;
+    };
+}>;
+export type ResizedColumnsAttributeSet = NewTableAttributeSet<{
+    'thead.tr.th': {
+        style?: {
+            width: string;
+            'min-width': string;
+            'max-width': string;
+            'box-sizing': 'border-box';
+        };
+    };
+    'tbody.tr.td': {
+        style?: {
+            width: string;
+            'min-width': string;
+            'max-width': string;
+            'box-sizing': 'border-box';
+        };
+    };
+}>;
+export declare const addResizedColumns: <Item>({ onResizeEnd }?: AddResizedColumnsConfig) => TablePlugin<Item, ResizedColumnsState, ResizedColumnsColumnOptions, ResizedColumnsPropSet, ResizedColumnsAttributeSet>;