@wheelhouse/ui 0.2.3 → 0.2.5

package/dist/components/data-grid/data-grid-table-dnd.js

@@ -0,0 +1,95 @@
+'use client';
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Fragment, useEffect, useId, useRef, useState } from 'react';
+import { useDataGrid } from './data-grid';
+import { DataGridTableBase, DataGridTableBody, DataGridTableBodyRow, DataGridTableBodyRowCell, DataGridTableBodyRowExpandded, DataGridTableBodyRowSkeleton, DataGridTableBodyRowSkeletonCell, DataGridTableEmpty, DataGridTableFoot, DataGridTableHead, DataGridTableHeadRow, DataGridTableHeadRowCell, DataGridTableHeadRowCellResize, DataGridTableRowSpacer, DataGridTableViewport, } from './data-grid-table';
+import { closestCenter, DndContext, KeyboardSensor, MouseSensor, TouchSensor, useSensor, useSensors } from '@dnd-kit/core';
+import { horizontalListSortingStrategy, SortableContext, useSortable } from '@dnd-kit/sortable';
+import { CSS } from '@dnd-kit/utilities';
+import { flexRender } from '@tanstack/react-table';
+import { Button } from '../button';
+import { GripVerticalIcon } from 'lucide-react';
+function DataGridTableDndHeader({ header }) {
+    const { props } = useDataGrid();
+    const { column } = header;
+    // Check if column ordering is enabled for this column
+    const canOrder = column.columnDef.enableColumnOrdering !== false;
+    const { attributes, isDragging, listeners, setNodeRef, transform, transition } = useSortable({
+        id: header.column.id,
+    });
+    const style = {
+        opacity: isDragging ? 0.8 : 1,
+        position: 'relative',
+        transform: CSS.Translate.toString(transform),
+        transition,
+        cursor: isDragging ? 'grabbing' : undefined,
+        whiteSpace: 'nowrap',
+        width: props.tableLayout?.columnsResizable ? `calc(var(--header-${header.id}-size) * 1px)` : header.column.getSize(),
+        zIndex: isDragging ? 1 : 0,
+    };
+    return (_jsx(DataGridTableHeadRowCell, { header: header, dndStyle: style, dndRef: setNodeRef, children: _jsxs("div", { className: "flex items-center justify-start gap-0.5", children: [canOrder && (_jsx(Button, { size: "icon-sm", variant: "ghost", className: `-ms-2 size-6 ${isDragging ? 'cursor-grabbing' : 'cursor-grab active:cursor-grabbing'}`, ...attributes, ...listeners, "aria-label": "Drag to reorder", children: _jsx(GripVerticalIcon, { className: "opacity-60 hover:opacity-100", "aria-hidden": "true" }) })), _jsx("span", { className: "grow truncate", children: header.isPlaceholder ? null : flexRender(header.column.columnDef.header, header.getContext()) }), props.tableLayout?.columnsResizable && column.getCanResize() && _jsx(DataGridTableHeadRowCellResize, { header: header })] }) }));
+}
+function DataGridTableDndCell({ cell }) {
+    const { props } = useDataGrid();
+    const { isDragging, setNodeRef, transform, transition } = useSortable({
+        id: cell.column.id,
+    });
+    const style = {
+        opacity: isDragging ? 0.8 : 1,
+        position: 'relative',
+        transform: CSS.Translate.toString(transform),
+        transition,
+        cursor: isDragging ? 'grabbing' : undefined,
+        width: props.tableLayout?.columnsResizable ? `calc(var(--col-${cell.column.id}-size) * 1px)` : cell.column.getSize(),
+        zIndex: isDragging ? 1 : 0,
+    };
+    return (_jsx(DataGridTableBodyRowCell, { cell: cell, dndStyle: style, dndRef: setNodeRef, children: flexRender(cell.column.columnDef.cell, cell.getContext()) }));
+}
+function DataGridTableDnd({ handleDragEnd, footerContent }) {
+    const { table, isLoading, props } = useDataGrid();
+    const pagination = table.getState().pagination;
+    const containerRef = useRef(null);
+    const [isDraggingColumn, setIsDraggingColumn] = useState(false);
+    const sensors = useSensors(useSensor(MouseSensor, {}), useSensor(TouchSensor, {}), useSensor(KeyboardSensor, {}));
+    useEffect(() => {
+        if (!isDraggingColumn)
+            return;
+        const { body, documentElement } = document;
+        const previousBodyCursor = body.style.cursor;
+        const previousDocumentCursor = documentElement.style.cursor;
+        body.style.cursor = 'grabbing';
+        documentElement.style.cursor = 'grabbing';
+        return () => {
+            body.style.cursor = previousBodyCursor;
+            documentElement.style.cursor = previousDocumentCursor;
+        };
+    }, [isDraggingColumn]);
+    // Custom modifier to restrict dragging within table bounds with edge offset
+    const restrictToTableBounds = ({ draggingNodeRect, transform }) => {
+        if (!draggingNodeRect || !containerRef.current) {
+            return { ...transform, y: 0 };
+        }
+        const containerRect = containerRef.current.getBoundingClientRect();
+        const edgeOffset = 0;
+        const minX = containerRect.left - draggingNodeRect.left - edgeOffset;
+        const maxX = containerRect.right - draggingNodeRect.left - draggingNodeRect.width + edgeOffset;
+        return {
+            ...transform,
+            x: Math.min(Math.max(transform.x, minX), maxX),
+            y: 0, // Lock vertical movement
+        };
+    };
+    return (_jsx(DndContext, { collisionDetection: closestCenter, id: useId(), modifiers: [restrictToTableBounds], onDragCancel: () => setIsDraggingColumn(false), onDragEnd: (event) => {
+            setIsDraggingColumn(false);
+            handleDragEnd(event);
+        }, onDragStart: () => setIsDraggingColumn(true), sensors: sensors, children: _jsx(DataGridTableViewport, { viewportRef: containerRef, className: isDraggingColumn ? 'relative cursor-grabbing [&_*]:cursor-grabbing!' : 'relative', children: _jsxs(DataGridTableBase, { children: [_jsx(DataGridTableHead, { children: table.getHeaderGroups().map((headerGroup, index) => {
+                            return (_jsx(DataGridTableHeadRow, { headerGroup: headerGroup, children: _jsx(SortableContext, { items: table.getState().columnOrder, strategy: horizontalListSortingStrategy, children: headerGroup.headers.map((header) => (_jsx(DataGridTableDndHeader, { header: header }, header.id))) }) }, index));
+                        }) }), (props.tableLayout?.stripped || !props.tableLayout?.rowBorder) && _jsx(DataGridTableRowSpacer, {}), _jsx(DataGridTableBody, { children: props.loadingMode === 'skeleton' && isLoading && pagination?.pageSize ? (Array.from({ length: pagination.pageSize }).map((_, rowIndex) => (_jsx(DataGridTableBodyRowSkeleton, { children: table.getVisibleFlatColumns().map((column, colIndex) => {
+                                return (_jsx(DataGridTableBodyRowSkeletonCell, { column: column, children: column.columnDef.meta?.skeleton }, colIndex));
+                            }) }, rowIndex)))) : table.getRowModel().rows.length ? (table.getRowModel().rows.map((row) => {
+                            return (_jsxs(Fragment, { children: [_jsx(DataGridTableBodyRow, { row: row, children: row.getVisibleCells().map((cell) => {
+                                            return (_jsx(SortableContext, { items: table.getState().columnOrder, strategy: horizontalListSortingStrategy, children: _jsx(DataGridTableDndCell, { cell: cell }) }, cell.id));
+                                        }) }), row.getIsExpanded() && _jsx(DataGridTableBodyRowExpandded, { row: row })] }, row.id));
+                        })) : (_jsx(DataGridTableEmpty, {})) }), footerContent && _jsx(DataGridTableFoot, { children: footerContent })] }) }) }));
+}
+export { DataGridTableDnd };

package/dist/components/data-grid/data-grid-table-virtual.d.ts

@@ -0,0 +1,28 @@
+import { type ReactNode } from 'react';
+import { type Row } from '@tanstack/react-table';
+import { type VirtualizerOptions } from '@tanstack/react-virtual';
+type DataGridTableVirtualScrollElements = {
+    containerElement: HTMLDivElement | null;
+    scrollElement: HTMLElement | null;
+};
+type DataGridTableVirtualizerOptions<TData> = Omit<VirtualizerOptions<HTMLElement, HTMLTableRowElement>, 'count' | 'estimateSize' | 'getItemKey' | 'getScrollElement'> & {
+    estimateSize?: (index: number, row: Row<TData>) => number;
+    getItemKey?: (index: number, row: Row<TData>) => string | number;
+    getScrollElement?: (elements: DataGridTableVirtualScrollElements) => HTMLElement | null;
+};
+interface DataGridTableVirtualProps<TData> {
+    height?: number | string;
+    estimateSize?: number;
+    overscan?: number;
+    footerContent?: ReactNode;
+    renderHeader?: boolean;
+    onFetchMore?: () => void;
+    isFetchingMore?: boolean;
+    hasMore?: boolean;
+    fetchMoreOffset?: number;
+    virtualizerOptions?: DataGridTableVirtualizerOptions<TData>;
+}
+declare function DataGridTableVirtual<TData>({ height, estimateSize, overscan, footerContent, renderHeader, onFetchMore, isFetchingMore, hasMore, fetchMoreOffset, virtualizerOptions, }: DataGridTableVirtualProps<TData>): import("react/jsx-runtime").JSX.Element;
+export { DataGridTableVirtual };
+export type { DataGridTableVirtualProps, DataGridTableVirtualScrollElements, DataGridTableVirtualizerOptions };
+//# sourceMappingURL=data-grid-table-virtual.d.ts.map

package/dist/components/data-grid/data-grid-table-virtual.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"data-grid-table-virtual.d.ts","sourceRoot":"","sources":["../../../src/components/data-grid/data-grid-table-virtual.tsx"],"names":[],"mappings":"AAEA,OAAO,EAAQ,KAAK,SAAS,EAA6C,MAAM,OAAO,CAAC;AAgBxF,OAAO,EAAgC,KAAK,GAAG,EAAc,MAAM,uBAAuB,CAAC;AAC3F,OAAO,EAAsD,KAAK,kBAAkB,EAAE,MAAM,yBAAyB,CAAC;AAKtH,KAAK,kCAAkC,GAAG;IACtC,gBAAgB,EAAE,cAAc,GAAG,IAAI,CAAC;IACxC,aAAa,EAAE,WAAW,GAAG,IAAI,CAAC;CACrC,CAAC;AAIF,KAAK,+BAA+B,CAAC,KAAK,IAAI,IAAI,CAC9C,kBAAkB,CAAC,WAAW,EAAE,mBAAmB,CAAC,EACpD,OAAO,GAAG,cAAc,GAAG,YAAY,GAAG,kBAAkB,CAC/D,GAAG;IACA,YAAY,CAAC,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,GAAG,CAAC,KAAK,CAAC,KAAK,MAAM,CAAC;IAC1D,UAAU,CAAC,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,GAAG,CAAC,KAAK,CAAC,KAAK,MAAM,GAAG,MAAM,CAAC;IACjE,gBAAgB,CAAC,EAAE,CAAC,QAAQ,EAAE,kCAAkC,KAAK,WAAW,GAAG,IAAI,CAAC;CAC3F,CAAC;AAEF,UAAU,yBAAyB,CAAC,KAAK;IACrC,MAAM,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;IACzB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,aAAa,CAAC,EAAE,SAAS,CAAC;IAC1B,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,WAAW,CAAC,EAAE,MAAM,IAAI,CAAC;IACzB,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,kBAAkB,CAAC,EAAE,+BAA+B,CAAC,KAAK,CAAC,CAAC;CAC/D;AAuID,iBAAS,oBAAoB,CAAC,KAAK,EAAE,EACjC,MAAM,EACN,YAAiB,EACjB,QAAa,EACb,aAAa,EACb,YAAmB,EACnB,WAAW,EACX,cAAsB,EACtB,OAAO,EACP,eAAmB,EACnB,kBAAkB,GACrB,EAAE,yBAAyB,CAAC,KAAK,CAAC,2CA+IlC;AAED,OAAO,EAAE,oBAAoB,EAAE,CAAC;AAChC,YAAY,EAAE,yBAAyB,EAAE,kCAAkC,EAAE,+BAA+B,EAAE,CAAC"}

package/dist/components/data-grid/data-grid-table-virtual.js

@@ -0,0 +1,133 @@
+'use client';
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { memo, useCallback, useEffect, useMemo, useState } from 'react';
+import { useDataGrid } from './data-grid';
+import { DataGridTableBase, DataGridTableBody, DataGridTableEmpty, DataGridTableFoot, DataGridTableHead, DataGridTableHeadRow, DataGridTableHeadRowCell, DataGridTableHeadRowCellResize, DataGridTableRenderedRow, DataGridTableRowSpacer, DataGridTableViewport, getDataGridTableRowSections, } from './data-grid-table';
+import { flexRender } from '@tanstack/react-table';
+import { useVirtualizer } from '@tanstack/react-virtual';
+import { Spinner } from '../spinner';
+import { cn } from '../../lib/utils';
+function DataGridTableVirtualSpacer({ columnCount, height }) {
+    if (height <= 0)
+        return null;
+    return (_jsx("tr", { "aria-hidden": "true", children: _jsx("td", { colSpan: columnCount, style: { height, padding: 0 } }) }));
+}
+function DataGridTableVirtualStatusRow({ children, className, columnCount }) {
+    return (_jsx("tr", { children: _jsx("td", { colSpan: columnCount, className: cn('py-4 text-center text-sm text-muted-foreground', className), children: children }) }));
+}
+function DataGridTableVirtualBody({ table: _table, columnCount, topRows, centerRows, bottomRows, virtualItems, totalSize, isVirtualizationEnabled, isInfiniteMode, isFetchingMore, hasMore, loadingMoreMessage, allRowsLoadedMessage, measureRowRef, }) {
+    const totalRows = topRows.length + centerRows.length + bottomRows.length;
+    if (!totalRows)
+        return _jsx(DataGridTableEmpty, {});
+    const hasCenterRows = centerRows.length > 0;
+    const showFetchingRow = isInfiniteMode && isFetchingMore;
+    const showCompleteRow = isInfiniteMode && hasMore === false && totalRows > 0;
+    const hasMiddleSection = hasCenterRows || showFetchingRow || showCompleteRow;
+    const leadingSpacerHeight = isVirtualizationEnabled && hasCenterRows && virtualItems.length > 0 ? (virtualItems[0]?.start ?? 0) : 0;
+    const trailingSpacerHeight = isVirtualizationEnabled && hasCenterRows && virtualItems.length > 0 ? Math.max(0, totalSize - (virtualItems[virtualItems.length - 1]?.end ?? 0)) : 0;
+    const renderedRows = [];
+    topRows.forEach((row, index) => {
+        renderedRows.push(_jsx(DataGridTableRenderedRow, { row: row, pinnedBoundary: index === topRows.length - 1 && hasMiddleSection ? 'top' : undefined }, row.id));
+    });
+    if (isVirtualizationEnabled) {
+        if (leadingSpacerHeight > 0) {
+            renderedRows.push(_jsx(DataGridTableVirtualSpacer, { columnCount: columnCount, height: leadingSpacerHeight }, "virtual-spacer-start"));
+        }
+        virtualItems.forEach((virtualRow) => {
+            const row = centerRows[virtualRow.index];
+            if (!row)
+                return;
+            renderedRows.push(_jsx(DataGridTableRenderedRow, { row: row, rowRef: measureRowRef }, row.id));
+        });
+        if (trailingSpacerHeight > 0) {
+            renderedRows.push(_jsx(DataGridTableVirtualSpacer, { columnCount: columnCount, height: trailingSpacerHeight }, "virtual-spacer-end"));
+        }
+    }
+    else {
+        centerRows.forEach((row) => {
+            renderedRows.push(_jsx(DataGridTableRenderedRow, { row: row }, row.id));
+        });
+    }
+    if (showFetchingRow) {
+        renderedRows.push(_jsx(DataGridTableVirtualStatusRow, { columnCount: columnCount, children: _jsxs("div", { className: "flex items-center justify-center gap-2", children: [_jsx(Spinner, { className: "size-4 opacity-60" }), loadingMoreMessage] }) }, "virtual-status-loading"));
+    }
+    if (showCompleteRow) {
+        renderedRows.push(_jsx(DataGridTableVirtualStatusRow, { columnCount: columnCount, className: "py-3 text-xs", children: allRowsLoadedMessage }, "virtual-status-complete"));
+    }
+    bottomRows.forEach((row, index) => {
+        renderedRows.push(_jsx(DataGridTableRenderedRow, { row: row, pinnedBoundary: index === 0 && (topRows.length > 0 || hasMiddleSection) ? 'bottom' : undefined }, row.id));
+    });
+    return _jsx(_Fragment, { children: renderedRows });
+}
+/**
+ * Memoized virtual body: skip re-renders during active column resize.
+ * Column widths update via CSS variables on the <table> element,
+ * so the browser handles width changes without React re-renders.
+ */
+const MemoizedVirtualBody = memo(DataGridTableVirtualBody, (_prev, next) => !!next.table.getState().columnSizingInfo.isResizingColumn);
+function DataGridTableVirtual({ height, estimateSize = 48, overscan = 10, footerContent, renderHeader = true, onFetchMore, isFetchingMore = false, hasMore, fetchMoreOffset = 0, virtualizerOptions, }) {
+    const { table, props } = useDataGrid();
+    const { topRows, centerRows, bottomRows } = getDataGridTableRowSections(table, props.tableLayout?.rowsPinnable);
+    const columnCount = table.getVisibleFlatColumns().length + (props.tableLayout?.columnsResizable ? 1 : 0);
+    const isInfiniteMode = typeof onFetchMore === 'function';
+    const [viewportElements, setViewportElements] = useState({
+        containerElement: null,
+        scrollElement: null,
+    });
+    const { estimateSize: customEstimateSize, getItemKey: customGetItemKey, getScrollElement: customGetScrollElement, measureElement: customMeasureElement, overscan: customOverscan, ...virtualizerOptionsRest } = virtualizerOptions ?? {};
+    const isVirtualizationEnabled = virtualizerOptions?.enabled !== false;
+    const loadingMoreMessage = props.fetchingMoreMessage || props.loadingMessage || 'Loading...';
+    const allRowsLoadedMessage = props.allRowsLoadedMessage || 'All records loaded';
+    const handleViewportRef = useCallback((node) => {
+        setViewportElements({
+            containerElement: node,
+            scrollElement: node?.closest('[data-slot="scroll-area-viewport"]') ?? node,
+        });
+    }, []);
+    const usesExternalScrollArea = viewportElements.scrollElement !== null && viewportElements.scrollElement !== viewportElements.containerElement;
+    const resolveScrollElement = useCallback(() => {
+        if (customGetScrollElement) {
+            return customGetScrollElement(viewportElements);
+        }
+        return viewportElements.scrollElement;
+    }, [customGetScrollElement, viewportElements]);
+    const resolveItemKey = useCallback((index) => {
+        const row = centerRows[index];
+        if (!row)
+            return index;
+        return customGetItemKey?.(index, row) ?? row.id ?? index;
+    }, [centerRows, customGetItemKey]);
+    const resolveEstimateSize = useCallback((index) => {
+        const row = centerRows[index];
+        return row ? (customEstimateSize?.(index, row) ?? estimateSize) : estimateSize;
+    }, [centerRows, customEstimateSize, estimateSize]);
+    const virtualizer = useVirtualizer({
+        count: centerRows.length,
+        getScrollElement: resolveScrollElement,
+        getItemKey: resolveItemKey,
+        estimateSize: resolveEstimateSize,
+        overscan: customOverscan ?? overscan,
+        measureElement: customMeasureElement,
+        ...virtualizerOptionsRest,
+    });
+    const virtualItems = isVirtualizationEnabled ? virtualizer.getVirtualItems() : [];
+    const totalSize = isVirtualizationEnabled ? virtualizer.getTotalSize() : 0;
+    const measureRowRef = isVirtualizationEnabled && customMeasureElement ? virtualizer.measureElement : undefined;
+    const resolvedFetchMoreOffset = useMemo(() => Math.max(0, fetchMoreOffset), [fetchMoreOffset]);
+    useEffect(() => {
+        if (!isVirtualizationEnabled || !isInfiniteMode || hasMore === false || isFetchingMore) {
+            return;
+        }
+        const lastItem = virtualItems[virtualItems.length - 1];
+        if (!lastItem)
+            return;
+        if (lastItem.index >= centerRows.length - 1 - resolvedFetchMoreOffset) {
+            onFetchMore?.();
+        }
+    }, [centerRows.length, hasMore, isFetchingMore, isInfiniteMode, isVirtualizationEnabled, onFetchMore, resolvedFetchMoreOffset, virtualItems]);
+    return (_jsx(DataGridTableViewport, { viewportRef: handleViewportRef, className: !usesExternalScrollArea ? 'block' : undefined, style: usesExternalScrollArea ? undefined : { height, overflow: 'auto', position: 'relative' }, children: _jsxs(DataGridTableBase, { children: [renderHeader && (_jsx(DataGridTableHead, { children: table.getHeaderGroups().map((headerGroup, index) => (_jsx(DataGridTableHeadRow, { headerGroup: headerGroup, children: headerGroup.headers.map((header, hIndex) => {
+                            const { column } = header;
+                            return (_jsxs(DataGridTableHeadRowCell, { header: header, children: [header.isPlaceholder ? null : props.tableLayout?.columnsResizable && column.getCanResize() ? (_jsx("div", { className: "truncate", children: flexRender(header.column.columnDef.header, header.getContext()) })) : (flexRender(header.column.columnDef.header, header.getContext())), props.tableLayout?.columnsResizable && column.getCanResize() && _jsx(DataGridTableHeadRowCellResize, { header: header })] }, hIndex));
+                        }) }, index))) })), renderHeader && (props.tableLayout?.stripped || !props.tableLayout?.rowBorder) && _jsx(DataGridTableRowSpacer, {}), _jsx(DataGridTableBody, { children: _jsx(MemoizedVirtualBody, { table: table, columnCount: columnCount, topRows: topRows, centerRows: centerRows, bottomRows: bottomRows, virtualItems: virtualItems, totalSize: totalSize, isVirtualizationEnabled: isVirtualizationEnabled, isInfiniteMode: isInfiniteMode, isFetchingMore: isFetchingMore, hasMore: hasMore, loadingMoreMessage: loadingMoreMessage, allRowsLoadedMessage: allRowsLoadedMessage, measureRowRef: measureRowRef }) }), footerContent && _jsx(DataGridTableFoot, { children: footerContent })] }) }));
+}
+export { DataGridTableVirtual };

package/dist/components/data-grid/data-grid-table.d.ts

@@ -0,0 +1,98 @@
+import { type CSSProperties, type ReactNode, type Ref } from 'react';
+import { type Cell, type Column, type Header, type HeaderGroup, type Row, type Table } from '@tanstack/react-table';
+type DataGridTablePinnedBoundary = 'top' | 'bottom';
+declare function getDataGridTableRowSections<TData>(table: Table<TData>, rowsPinnable?: boolean): {
+    topRows: Row<TData>[];
+    centerRows: Row<TData>[];
+    bottomRows: Row<TData>[];
+};
+declare function getDataGridTableResolvedRows<TData>(table: Table<TData>, rowsPinnable?: boolean): {
+    row: Row<TData>;
+    pinnedBoundary?: DataGridTablePinnedBoundary;
+}[];
+declare function DataGridTableBase({ children }: {
+    children: ReactNode;
+}): import("react/jsx-runtime").JSX.Element;
+declare function DataGridTableViewport({ children, className, viewportRef, style, }: {
+    children: ReactNode;
+    className?: string;
+    viewportRef?: Ref<HTMLDivElement>;
+    style?: CSSProperties;
+}): import("react/jsx-runtime").JSX.Element;
+declare function DataGridTableHead({ children }: {
+    children: ReactNode;
+}): import("react/jsx-runtime").JSX.Element;
+declare function DataGridTableHeadRow<TData>({ children, headerGroup }: {
+    children: ReactNode;
+    headerGroup: HeaderGroup<TData>;
+}): import("react/jsx-runtime").JSX.Element;
+declare function DataGridTableHeadRowCell<TData>({ children, header, dndRef, dndStyle, }: {
+    children: ReactNode;
+    header: Header<TData, unknown>;
+    dndRef?: React.Ref<HTMLTableCellElement>;
+    dndStyle?: CSSProperties;
+}): import("react/jsx-runtime").JSX.Element;
+declare function DataGridTableHeadRowCellResize<TData>({ header }: {
+    header: Header<TData, unknown>;
+}): import("react/jsx-runtime").JSX.Element;
+declare function DataGridTableRowSpacer(): import("react/jsx-runtime").JSX.Element;
+declare function DataGridTableBody({ children }: {
+    children: ReactNode;
+}): import("react/jsx-runtime").JSX.Element;
+declare function DataGridTableFoot({ children }: {
+    children: ReactNode;
+}): import("react/jsx-runtime").JSX.Element;
+declare function DataGridTableFootRow({ children }: {
+    children: ReactNode;
+}): import("react/jsx-runtime").JSX.Element;
+declare function DataGridTableFootRowCell({ children, colSpan, className }: {
+    children?: ReactNode;
+    colSpan?: number;
+    className?: string;
+}): import("react/jsx-runtime").JSX.Element;
+declare function DataGridTableBodyRowSkeleton({ children }: {
+    children: ReactNode;
+}): import("react/jsx-runtime").JSX.Element;
+declare function DataGridTableBodyRowSkeletonCell<TData>({ children, column }: {
+    children: ReactNode;
+    column: Column<TData>;
+}): import("react/jsx-runtime").JSX.Element;
+declare function DataGridTableBodyRow<TData>({ children, row, pinnedBoundary, rowRef, dndRef, dndStyle, }: {
+    children: ReactNode;
+    row: Row<TData>;
+    pinnedBoundary?: DataGridTablePinnedBoundary;
+    rowRef?: React.Ref<HTMLTableRowElement>;
+    dndRef?: React.Ref<HTMLTableRowElement>;
+    dndStyle?: CSSProperties;
+}): import("react/jsx-runtime").JSX.Element;
+declare function DataGridTableBodyRowExpandded<TData>({ row }: {
+    row: Row<TData>;
+}): import("react/jsx-runtime").JSX.Element;
+declare function DataGridTableBodyRowCell<TData>({ children, cell, dndRef, dndStyle, }: {
+    children: ReactNode;
+    cell: Cell<TData, unknown>;
+    dndRef?: React.Ref<HTMLTableCellElement>;
+    dndStyle?: CSSProperties;
+}): import("react/jsx-runtime").JSX.Element;
+declare function DataGridTableRenderedRow<TData>({ row, pinnedBoundary, rowRef, }: {
+    row: Row<TData>;
+    pinnedBoundary?: DataGridTablePinnedBoundary;
+    rowRef?: React.Ref<HTMLTableRowElement>;
+}): import("react/jsx-runtime").JSX.Element;
+declare function DataGridTableEmpty(): import("react/jsx-runtime").JSX.Element;
+declare function DataGridTableLoader(): import("react/jsx-runtime").JSX.Element;
+declare function DataGridTableRowPin<TData>({ row }: {
+    row: Row<TData>;
+}): import("react/jsx-runtime").JSX.Element;
+declare function DataGridTableRowSelect<TData>({ row }: {
+    row: Row<TData>;
+}): import("react/jsx-runtime").JSX.Element;
+declare function DataGridTableRowSelectAll(): import("react/jsx-runtime").JSX.Element;
+declare function DataGridTableHeader<TData>(): import("react/jsx-runtime").JSX.Element;
+declare function DataGridTable<TData>({ footerContent, renderHeader }: {
+    footerContent?: ReactNode;
+    renderHeader?: boolean;
+}): import("react/jsx-runtime").JSX.Element;
+export { DataGridTable, DataGridTableBase, DataGridTableBody, DataGridTableBodyRow, DataGridTableBodyRowCell, DataGridTableBodyRowExpandded, DataGridTableRenderedRow, DataGridTableBodyRowSkeleton, DataGridTableBodyRowSkeletonCell, DataGridTableEmpty, DataGridTableFoot, DataGridTableFootRow, DataGridTableFootRowCell, DataGridTableHeader, DataGridTableHead, DataGridTableHeadRow, DataGridTableHeadRowCell, DataGridTableHeadRowCellResize, DataGridTableLoader, DataGridTableRowPin, DataGridTableRowSelect, DataGridTableRowSelectAll, DataGridTableRowSpacer, DataGridTableViewport, getDataGridTableResolvedRows, getDataGridTableRowSections, };
+export type { DataGridTablePinnedBoundary };
+//# sourceMappingURL=data-grid-table.d.ts.map

package/dist/components/data-grid/data-grid-table.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"data-grid-table.d.ts","sourceRoot":"","sources":["../../../src/components/data-grid/data-grid-table.tsx"],"names":[],"mappings":"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"}