@perses-dev/components 0.55.0 → 0.56.0-beta.0

package/dist/Table/VirtualizedTable.js

@@ -1,4 +1,5 @@
 import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { c as _c } from "react-compiler-runtime";
 // Copyright The Perses Authors
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
@@ -13,7 +14,7 @@ import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-run
 // limitations under the License.
 import { Box, TablePagination, TableRow as MuiTableRow } from "@mui/material";
 import { flexRender } from "@tanstack/react-table";
-import { useMemo, useRef } from "react";
+import { useRef } from "react";
 import { TableVirtuoso } from "react-virtuoso";
 import { useVirtualizedTableKeyboardNav } from "./hooks/useVirtualizedTableKeyboardNav.js";
 import { InnerTable } from "./InnerTable.js";
@@ -28,243 +29,410 @@ import { VirtualizedTableContainer } from "./VirtualizedTableContainer.js";
 // Separating out the virtualized table because we may want a paginated table
 // in the future that does not need virtualization, and we'd likely lay them
 // out differently.
-export function VirtualizedTable({ width, height, density, defaultColumnWidth, defaultColumnHeight, onRowClick, onRowMouseOver, onRowMouseOut, rows, columns, headers, cellConfigs, pagination, onPaginationChange, rowCount, toolbarConfig }) {
-    'use no memo'; // TanStack Table row and column getters read mutable state behind stable identities.
+export function VirtualizedTable(t0) {
+    const $ = _c(71);
+    const { width, height, density, defaultColumnWidth, defaultColumnHeight, onRowClick, onRowMouseOver, onRowMouseOut, table, cellConfigs, pagination, onPaginationChange, toolbarConfig } = t0;
+    let t1;
+    if ($[0] !== table) {
+        t1 = table.getRowModel();
+        $[0] = table;
+        $[1] = t1;
+    } else {
+        t1 = $[1];
+    }
+    const rows = t1.rows;
+    let t2;
+    if ($[2] !== table) {
+        t2 = table.getVisibleFlatColumns();
+        $[2] = table;
+        $[3] = t2;
+    } else {
+        t2 = $[3];
+    }
+    const columnCount = t2.length;
     const virtuosoRef = useRef(null);
-    // Use a ref for these values because they are only needed for keyboard
-    // focus interactions and setting them on state will lead to a significant
-    // amount of unnecessary re-renders.
-    const visibleRange = useRef({
-        startIndex: 0,
-        endIndex: 0
-    });
-    const setVisibleRange = (newVisibleRange)=>{
-        visibleRange.current = newVisibleRange;
-    };
-    const keyboardNav = useVirtualizedTableKeyboardNav({
-        visibleRange: visibleRange,
-        virtualTable: virtuosoRef,
-        // We add 1 here for the header.
-        maxRows: rows.length + 1,
-        maxColumns: columns.length
-    });
-    const getFocusState = (cellPosition)=>{
-        if (cellPosition.row === keyboardNav.activeCell.row && cellPosition.column === keyboardNav.activeCell.column) {
-            return keyboardNav.isActive ? 'trigger-focus' : 'focus-next';
-        }
-        return 'none';
-    };
-    const VirtuosoTableComponents = useMemo(()=>{
-        return {
+    let t3;
+    if ($[4] === Symbol.for("react.memo_cache_sentinel")) {
+        t3 = {
+            startIndex: 0,
+            endIndex: 0
+        };
+        $[4] = t3;
+    } else {
+        t3 = $[4];
+    }
+    const visibleRange = useRef(t3);
+    let t4;
+    if ($[5] === Symbol.for("react.memo_cache_sentinel")) {
+        t4 = (newVisibleRange)=>{
+            visibleRange.current = newVisibleRange;
+        };
+        $[5] = t4;
+    } else {
+        t4 = $[5];
+    }
+    const setVisibleRange = t4;
+    const t5 = rows.length + 1;
+    let t6;
+    if ($[6] !== columnCount || $[7] !== t5) {
+        t6 = {
+            visibleRange,
+            virtualTable: virtuosoRef,
+            maxRows: t5,
+            maxColumns: columnCount
+        };
+        $[6] = columnCount;
+        $[7] = t5;
+        $[8] = t6;
+    } else {
+        t6 = $[8];
+    }
+    const keyboardNav = useVirtualizedTableKeyboardNav(t6);
+    let t7;
+    if ($[9] !== keyboardNav.activeCell || $[10] !== keyboardNav.isActive) {
+        t7 = (cellPosition)=>{
+            if (cellPosition.row === keyboardNav.activeCell.row && cellPosition.column === keyboardNav.activeCell.column) {
+                return keyboardNav.isActive ? "trigger-focus" : "focus-next";
+            }
+            return "none";
+        };
+        $[9] = keyboardNav.activeCell;
+        $[10] = keyboardNav.isActive;
+        $[11] = t7;
+    } else {
+        t7 = $[11];
+    }
+    const getFocusState = t7;
+    let t8;
+    if ($[12] !== density || $[13] !== keyboardNav.onTableBlur || $[14] !== keyboardNav.onTableKeyDown || $[15] !== width) {
+        t8 = (props)=>/*#__PURE__*/ _jsx(InnerTable, {
+                ...props,
+                width: width,
+                density: density,
+                onKeyDown: keyboardNav.onTableKeyDown,
+                onBlur: keyboardNav.onTableBlur
+            });
+        $[12] = density;
+        $[13] = keyboardNav.onTableBlur;
+        $[14] = keyboardNav.onTableKeyDown;
+        $[15] = width;
+        $[16] = t8;
+    } else {
+        t8 = $[16];
+    }
+    let t9;
+    if ($[17] !== density || $[18] !== onRowClick || $[19] !== onRowMouseOut || $[20] !== onRowMouseOver || $[21] !== rows) {
+        t9 = (t10)=>{
+            const { item: _item, ...props_0 } = t10;
+            const index = props_0["data-index"];
+            const row = rows[index];
+            if (!row) {
+                return null;
+            }
+            const rowEventOpts = {
+                id: row.id,
+                index: row.index
+            };
+            return /*#__PURE__*/ _jsx(TableRow, {
+                ...props_0,
+                onClick: (e)=>onRowClick(e, row),
+                density: density,
+                onMouseOver: (e_0)=>{
+                    onRowMouseOver?.(e_0, rowEventOpts);
+                },
+                onMouseOut: (e_1)=>{
+                    onRowMouseOut?.(e_1, rowEventOpts);
+                }
+            });
+        };
+        $[17] = density;
+        $[18] = onRowClick;
+        $[19] = onRowMouseOut;
+        $[20] = onRowMouseOver;
+        $[21] = rows;
+        $[22] = t9;
+    } else {
+        t9 = $[22];
+    }
+    let t10;
+    if ($[23] !== t8 || $[24] !== t9) {
+        t10 = {
             Scroller: VirtualizedTableContainer,
-            Table: (props)=>{
-                return /*#__PURE__*/ _jsx(InnerTable, {
-                    ...props,
-                    width: width,
-                    density: density,
-                    onKeyDown: keyboardNav.onTableKeyDown,
-                    onBlur: keyboardNav.onTableBlur
-                });
-            },
+            Table: t8,
             TableHead,
             TableFoot,
-            TableRow: ({ item: _item, ...props })=>{
-                const index = props['data-index'];
-                const row = rows[index];
-                if (!row) {
-                    return null;
-                }
-                const rowEventOpts = {
-                    id: row.id,
-                    index: row.index
-                };
-                return /*#__PURE__*/ _jsx(TableRow, {
-                    ...props,
-                    onClick: (e)=>onRowClick(e, row.id),
-                    density: density,
-                    onMouseOver: (e)=>{
-                        onRowMouseOver?.(e, rowEventOpts);
-                    },
-                    onMouseOut: (e)=>{
-                        onRowMouseOut?.(e, rowEventOpts);
-                    }
-                });
-            },
+            TableRow: t9,
             TableBody
         };
-    }, [
-        density,
-        keyboardNav.onTableKeyDown,
-        keyboardNav.onTableBlur,
-        onRowClick,
-        onRowMouseOut,
-        onRowMouseOver,
-        rows,
-        width
-    ]);
-    const handleChangePage = (_event, newPage)=>{
-        if (!pagination || !onPaginationChange) return;
-        onPaginationChange({
-            ...pagination,
-            pageIndex: newPage
-        });
-    };
-    const handleChangeRowsPerPage = (event)=>{
-        if (!pagination || !onPaginationChange) return;
-        onPaginationChange({
-            pageIndex: 0,
-            pageSize: parseInt(event.target.value, 10)
-        });
-    };
-    /**
-   * Instead of calling `column.getSize()` on every render for every header
-   * and especially every data cell (very expensive),
-   * we calculate all column sizes once per render at the root table level
-   * and pass the column sizes down as CSS variables to the <table> element.
-   */ const columnSizeVars = {};
-    headers.forEach((headerGroup)=>{
-        headerGroup.headers.filter((header)=>header.column.getCanResize()).forEach((header)=>{
-            columnSizeVars[`--header-${header.id}-size`] = header.getSize();
-            columnSizeVars[`--col-${header.column.id}-size`] = header.column.getSize();
+        $[23] = t8;
+        $[24] = t9;
+        $[25] = t10;
+    } else {
+        t10 = $[25];
+    }
+    const VirtuosoTableComponents = t10;
+    let t11;
+    if ($[26] !== onPaginationChange || $[27] !== pagination) {
+        t11 = (_event, newPage)=>{
+            if (!pagination || !onPaginationChange) {
+                return;
+            }
+            onPaginationChange({
+                ...pagination,
+                pageIndex: newPage
+            });
+        };
+        $[26] = onPaginationChange;
+        $[27] = pagination;
+        $[28] = t11;
+    } else {
+        t11 = $[28];
+    }
+    const handleChangePage = t11;
+    let t12;
+    if ($[29] !== onPaginationChange || $[30] !== pagination) {
+        t12 = (event)=>{
+            if (!pagination || !onPaginationChange) {
+                return;
+            }
+            onPaginationChange({
+                pageIndex: 0,
+                pageSize: parseInt(event.target.value, 10)
+            });
+        };
+        $[29] = onPaginationChange;
+        $[30] = pagination;
+        $[31] = t12;
+    } else {
+        t12 = $[31];
+    }
+    const handleChangeRowsPerPage = t12;
+    let columnSizeVars;
+    if ($[32] !== table) {
+        columnSizeVars = {};
+        table.getHeaderGroups().forEach((headerGroup)=>{
+            headerGroup.headers.filter(_temp).forEach((header_0)=>{
+                columnSizeVars[`--header-${header_0.id}-size`] = header_0.getSize();
+                columnSizeVars[`--col-${header_0.column.id}-size`] = header_0.column.getSize();
+            });
         });
-    });
-    return /*#__PURE__*/ _jsxs(Box, {
-        style: {
+        $[32] = table;
+        $[33] = columnSizeVars;
+    } else {
+        columnSizeVars = $[33];
+    }
+    let t13;
+    if ($[34] !== columnSizeVars || $[35] !== height || $[36] !== width) {
+        t13 = {
             width,
             height,
             ...columnSizeVars
-        },
-        children: [
-            /*#__PURE__*/ _jsx(TableToolbar, {
-                ...toolbarConfig,
-                width: width
-            }),
-            /*#__PURE__*/ _jsx(TableVirtuoso, {
-                ref: virtuosoRef,
-                totalCount: rows.length,
-                components: VirtuosoTableComponents,
-                // Note: this value is impacted by overscan. See this issue if overscan
-                // is added.
-                // https://github.com/petyosi/react-virtuoso/issues/118#issuecomment-642156138
-                rangeChanged: setVisibleRange,
-                fixedHeaderContent: ()=>{
-                    return /*#__PURE__*/ _jsx(_Fragment, {
-                        children: headers.map((headerGroup)=>{
-                            return /*#__PURE__*/ _jsx(TableRow, {
-                                density: density,
-                                children: headerGroup.headers.map((header, i, headers)=>{
-                                    const column = header.column;
-                                    const position = {
-                                        row: 0,
-                                        column: i
-                                    };
-                                    const isSorted = column.getIsSorted();
-                                    const nextSorting = column.getNextSortingOrder();
-                                    return /*#__PURE__*/ _jsx(TableHeaderCell, {
-                                        onSort: column.getCanSort() ? column.getToggleSortingHandler() : undefined,
-                                        sortDirection: typeof isSorted === 'string' ? isSorted : undefined,
-                                        nextSortDirection: typeof nextSorting === 'string' ? nextSorting : undefined,
-                                        width: header.column.getCanResize() ? `calc(var(--header-${header?.id}-size) * 1px)` : column.getSize() || defaultColumnWidth,
-                                        defaultColumnHeight: defaultColumnHeight,
-                                        align: column.columnDef.meta?.align,
-                                        variant: "head",
-                                        density: density,
-                                        description: column.columnDef.meta?.headerDescription,
-                                        focusState: getFocusState(position),
-                                        onFocusTrigger: ()=>keyboardNav.onCellFocus(position),
-                                        isFirstColumn: i === 0,
-                                        isLastColumn: i === headers.length - 1,
-                                        resizeConfig: header.column.getCanResize() ? {
-                                            resizeHandler: header.getResizeHandler(),
-                                            resetSizeHandler: header.column.resetSize,
-                                            isResizing: header.column.getIsResizing()
-                                        } : undefined,
-                                        children: flexRender(column.columnDef.header, header.getContext())
-                                    }, header.id);
-                                })
-                            }, headerGroup.id);
-                        })
-                    });
-                },
-                fixedFooterContent: pagination ? ()=>/*#__PURE__*/ _jsx(MuiTableRow, {
-                        sx: {
-                            backgroundColor: (theme)=>theme.palette.background.default
-                        },
-                        children: /*#__PURE__*/ _jsx(TablePagination, {
-                            colSpan: columns.length,
-                            count: rowCount,
-                            page: pagination.pageIndex,
-                            rowsPerPage: pagination.pageSize,
-                            onPageChange: handleChangePage,
-                            onRowsPerPageChange: handleChangeRowsPerPage
-                        })
-                    }) : undefined,
-                itemContent: (index)=>{
-                    const row = rows[index];
-                    if (!row) {
-                        return null;
-                    }
-                    return /*#__PURE__*/ _jsx(_Fragment, {
-                        children: row.getVisibleCells().map((cell, i, cells)=>{
+        };
+        $[34] = columnSizeVars;
+        $[35] = height;
+        $[36] = width;
+        $[37] = t13;
+    } else {
+        t13 = $[37];
+    }
+    let t14;
+    if ($[38] !== toolbarConfig || $[39] !== width) {
+        t14 = /*#__PURE__*/ _jsx(TableToolbar, {
+            ...toolbarConfig,
+            width: width
+        });
+        $[38] = toolbarConfig;
+        $[39] = width;
+        $[40] = t14;
+    } else {
+        t14 = $[40];
+    }
+    let t15;
+    if ($[41] !== defaultColumnHeight || $[42] !== defaultColumnWidth || $[43] !== density || $[44] !== getFocusState || $[45] !== keyboardNav || $[46] !== table) {
+        t15 = ()=>/*#__PURE__*/ _jsx(_Fragment, {
+                children: table.getHeaderGroups().map((headerGroup_0)=>/*#__PURE__*/ _jsx(TableRow, {
+                        density: density,
+                        children: headerGroup_0.headers.map((header_1, i, headers)=>{
+                            const column = header_1.column;
                             const position = {
-                                row: index + 1,
+                                row: 0,
                                 column: i
                             };
-                            const cellContext = cell.getContext();
-                            const cellConfig = cellConfigs?.[cellContext.cell.id];
-                            const cellRenderFn = cell.column.columnDef.cell;
-                            const cellContent = typeof cellRenderFn === 'function' ? cellRenderFn(cellContext) : null;
-                            /*
-                     IMPORTANT:
-                     If Variables exist in the link, they should have been translated by the plugin already. (Being developed at the moment)
-                     Components have no access to any context (Which is intentional and correct)
-                     We may want to add parameters to a link from neighboring cells in the future as well.
-                     If this is the case, the value of the neighboring cells should be read from here and be replaced. (Bing discussed at the moment, not decided yet)
-                  */ const cellDescriptionDef = cell.column.columnDef.meta?.cellDescription;
-                            let description = undefined;
-                            if (typeof cellDescriptionDef === 'function') {
-                                // If the cell description is a function, set the value using
-                                // the function.
-                                description = cellDescriptionDef(cellContext);
-                            } else if (cellDescriptionDef && typeof cellContent === 'string') {
-                                // If the cell description is `true` AND the cell content is
-                                // a string (and thus viable as a `title` attribute), use the
-                                // cell content.
-                                description = cellContent;
-                            }
-                            /* this has been specifically added for the data link,
-                     therefore, non string and numeric values should be excluded
-                  */ const adjacentCellsValuesMap = Object.entries(row.original)?.filter(([_, value])=>[
-                                    'string',
-                                    'number'
-                                ].includes(typeof value)).reduce((acc, [key, value])=>({
-                                    ...acc,
-                                    [key]: String(value)
-                                }), {});
-                            return /*#__PURE__*/ _jsx(TableCell, {
-                                "data-testid": cell.id,
-                                title: description || cellConfig?.text || cellContent,
-                                width: cell.column.getCanResize() ? `calc(var(--col-${cell.column.id}-size) * 1px)` : cell.column.getSize() || defaultColumnWidth,
+                            const isSorted = column.getIsSorted();
+                            const nextSorting = column.getNextSortingOrder();
+                            return /*#__PURE__*/ _jsx(TableHeaderCell, {
+                                onSort: column.getCanSort() ? column.getToggleSortingHandler() : undefined,
+                                sortDirection: typeof isSorted === "string" ? isSorted : undefined,
+                                nextSortDirection: typeof nextSorting === "string" ? nextSorting : undefined,
+                                width: header_1.column.getCanResize() ? `calc(var(--header-${header_1?.id}-size) * 1px)` : column.getSize() || defaultColumnWidth,
                                 defaultColumnHeight: defaultColumnHeight,
-                                align: cell.column.columnDef.meta?.align,
+                                align: column.columnDef.meta?.align,
+                                variant: "head",
                                 density: density,
+                                description: column.columnDef.meta?.headerDescription,
                                 focusState: getFocusState(position),
                                 onFocusTrigger: ()=>keyboardNav.onCellFocus(position),
                                 isFirstColumn: i === 0,
-                                isLastColumn: i === cells.length - 1,
-                                description: description,
-                                color: cellConfig?.textColor ?? undefined,
-                                backgroundColor: cellConfig?.backgroundColor ?? undefined,
-                                dataLink: cell.column.columnDef.meta?.dataLink,
-                                adjacentCellsValuesMap: adjacentCellsValuesMap,
-                                children: cellConfig?.text || cellContent
-                            }, cell.id);
+                                isLastColumn: i === headers.length - 1,
+                                resizeConfig: header_1.column.getCanResize() ? {
+                                    resizeHandler: header_1.getResizeHandler(),
+                                    resetSizeHandler: ()=>header_1.column.resetSize(),
+                                    isResizing: header_1.column.getIsResizing()
+                                } : undefined,
+                                children: flexRender(column.columnDef.header, header_1.getContext())
+                            }, header_1.id);
                         })
-                    });
-                }
-            })
-        ]
-    });
+                    }, headerGroup_0.id))
+            });
+        $[41] = defaultColumnHeight;
+        $[42] = defaultColumnWidth;
+        $[43] = density;
+        $[44] = getFocusState;
+        $[45] = keyboardNav;
+        $[46] = table;
+        $[47] = t15;
+    } else {
+        t15 = $[47];
+    }
+    let t16;
+    if ($[48] !== handleChangePage || $[49] !== handleChangeRowsPerPage || $[50] !== pagination || $[51] !== table) {
+        t16 = pagination ? ()=>/*#__PURE__*/ _jsx(MuiTableRow, {
+                sx: {
+                    backgroundColor: _temp2
+                },
+                children: /*#__PURE__*/ _jsx(TablePagination, {
+                    colSpan: table.getVisibleFlatColumns().length,
+                    count: table.getRowCount(),
+                    page: pagination.pageIndex,
+                    rowsPerPage: pagination.pageSize,
+                    onPageChange: handleChangePage,
+                    onRowsPerPageChange: handleChangeRowsPerPage
+                })
+            }) : undefined;
+        $[48] = handleChangePage;
+        $[49] = handleChangeRowsPerPage;
+        $[50] = pagination;
+        $[51] = table;
+        $[52] = t16;
+    } else {
+        t16 = $[52];
+    }
+    let t17;
+    if ($[53] !== cellConfigs || $[54] !== defaultColumnHeight || $[55] !== defaultColumnWidth || $[56] !== density || $[57] !== getFocusState || $[58] !== keyboardNav || $[59] !== table) {
+        t17 = (index_0)=>{
+            const row_0 = table.getRowModel().rows[index_0];
+            if (!row_0) {
+                return null;
+            }
+            return /*#__PURE__*/ _jsx(_Fragment, {
+                children: row_0.getVisibleCells().map((cell, i_0, cells)=>{
+                    const position_0 = {
+                        row: index_0 + 1,
+                        column: i_0
+                    };
+                    const cellContext = cell.getContext();
+                    const cellConfig = cellConfigs?.[cellContext.cell.id];
+                    const cellRenderFn = cell.column.columnDef.cell;
+                    const cellContent = typeof cellRenderFn === "function" ? cellRenderFn(cellContext) : null;
+                    const cellDescriptionDef = cell.column.columnDef.meta?.cellDescription;
+                    let description = undefined;
+                    if (typeof cellDescriptionDef === "function") {
+                        description = cellDescriptionDef(cellContext);
+                    } else {
+                        if (cellDescriptionDef && typeof cellContent === "string") {
+                            description = cellContent;
+                        }
+                    }
+                    const adjacentCellsValuesMap = Object.entries(row_0.original)?.filter(_temp3).reduce(_temp4, {});
+                    return /*#__PURE__*/ _jsx(TableCell, {
+                        "data-testid": cell.id,
+                        title: description || cellConfig?.text || cellContent,
+                        width: cell.column.getCanResize() ? `calc(var(--col-${cell.column.id}-size) * 1px)` : cell.column.getSize() || defaultColumnWidth,
+                        defaultColumnHeight: defaultColumnHeight,
+                        align: cell.column.columnDef.meta?.align,
+                        density: density,
+                        focusState: getFocusState(position_0),
+                        onFocusTrigger: ()=>keyboardNav.onCellFocus(position_0),
+                        isFirstColumn: i_0 === 0,
+                        isLastColumn: i_0 === cells.length - 1,
+                        description: description,
+                        color: cellConfig?.textColor ?? undefined,
+                        backgroundColor: cellConfig?.backgroundColor ?? undefined,
+                        dataLink: cell.column.columnDef.meta?.dataLink,
+                        adjacentCellsValuesMap: adjacentCellsValuesMap,
+                        children: cellConfig?.text || cellContent
+                    }, cell.id);
+                })
+            });
+        };
+        $[53] = cellConfigs;
+        $[54] = defaultColumnHeight;
+        $[55] = defaultColumnWidth;
+        $[56] = density;
+        $[57] = getFocusState;
+        $[58] = keyboardNav;
+        $[59] = table;
+        $[60] = t17;
+    } else {
+        t17 = $[60];
+    }
+    let t18;
+    if ($[61] !== VirtuosoTableComponents || $[62] !== rows.length || $[63] !== t15 || $[64] !== t16 || $[65] !== t17) {
+        t18 = /*#__PURE__*/ _jsx(TableVirtuoso, {
+            ref: virtuosoRef,
+            totalCount: rows.length,
+            components: VirtuosoTableComponents,
+            rangeChanged: setVisibleRange,
+            fixedHeaderContent: t15,
+            fixedFooterContent: t16,
+            itemContent: t17
+        });
+        $[61] = VirtuosoTableComponents;
+        $[62] = rows.length;
+        $[63] = t15;
+        $[64] = t16;
+        $[65] = t17;
+        $[66] = t18;
+    } else {
+        t18 = $[66];
+    }
+    let t19;
+    if ($[67] !== t13 || $[68] !== t14 || $[69] !== t18) {
+        t19 = /*#__PURE__*/ _jsxs(Box, {
+            style: t13,
+            children: [
+                t14,
+                t18
+            ]
+        });
+        $[67] = t13;
+        $[68] = t14;
+        $[69] = t18;
+        $[70] = t19;
+    } else {
+        t19 = $[70];
+    }
+    return t19;
+}
+function _temp4(acc, t0) {
+    const [key, value_0] = t0;
+    return {
+        ...acc,
+        [key]: String(value_0)
+    };
+}
+function _temp3(t0) {
+    const [, value] = t0;
+    return [
+        "string",
+        "number"
+    ].includes(typeof value);
+}
+function _temp2(theme) {
+    return theme.palette.background.default;
+}
+function _temp(header) {
+    return header.column.getCanResize();
 }
 
 //# sourceMappingURL=VirtualizedTable.js.map