@rebasepro/ui 0.24.0 → 0.24.1-canary.gcb918fc

package/dist/components/VirtualTable/VirtualTable.es.js

@@ -0,0 +1,516 @@
+import { cls } from "../../util/cls.es.js";
+import { useDebounceCallback } from "../../hooks/useDebounceCallback.es.js";
+import { CenteredView } from "../CenteredView.es.js";
+import { CircularProgress } from "../CircularProgress.es.js";
+import { Typography } from "../Typography.es.js";
+import { useUiLabels } from "../../hooks/UiLabelsContext.es.js";
+import { VirtualTableHeaderRow } from "./VirtualTableHeaderRow.es.js";
+import { VirtualTableRow } from "./VirtualTableRow.es.js";
+import { VirtualTableCell } from "./VirtualTableCell.es.js";
+import React, { createContext, forwardRef, useCallback, useEffect, useMemo, useRef, useState } from "react";
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+import { deepEqual, shallowEqual } from "fast-equals";
+import { FixedSizeList } from "react-window";
+import useMeasure from "react-use-measure";
+import { SortableContext, arrayMove, horizontalListSortingStrategy, useSortable } from "@dnd-kit/sortable";
+import { DndContext, PointerSensor, closestCenter, useSensor, useSensors } from "@dnd-kit/core";
+//#region src/components/VirtualTable/VirtualTable.tsx
+var VirtualListContext = createContext(null);
+VirtualListContext.displayName = "VirtualListContext";
+var innerElementType = forwardRef(({ children, ...rest }, ref) => {
+	return /* @__PURE__ */ jsx(VirtualListContext.Consumer, { children: (virtualTableProps) => {
+		const customView = virtualTableProps.customView;
+		const headerHeight = virtualTableProps.headerHeight ?? 48;
+		return /* @__PURE__ */ jsxs(Fragment, { children: [/* @__PURE__ */ jsx("div", {
+			id: "virtual-table",
+			style: {
+				position: "relative",
+				height: "100%",
+				zIndex: 0
+			},
+			children: /* @__PURE__ */ jsxs("div", {
+				ref,
+				...rest,
+				style: {
+					...rest?.style,
+					height: (typeof rest?.style?.height === "number" ? rest.style.height : parseFloat(rest?.style?.height || "0")) + headerHeight,
+					minHeight: "100%",
+					position: "relative"
+				},
+				children: [/* @__PURE__ */ jsx("div", {
+					style: {
+						position: "sticky",
+						top: 0,
+						zIndex: 20
+					},
+					children: /* @__PURE__ */ jsx(VirtualTableHeaderRow, { ...virtualTableProps })
+				}), !customView && children]
+			})
+		}), customView && /* @__PURE__ */ jsx("div", {
+			style: {
+				position: "sticky",
+				top: virtualTableProps.headerHeight ?? 48,
+				flexGrow: 1,
+				height: `calc(100% - ${virtualTableProps.headerHeight ?? 48}px)`,
+				marginTop: `calc(${virtualTableProps.headerHeight ?? 48}px - 100vh)`,
+				left: 0
+			},
+			children: customView
+		})] });
+	} });
+});
+/**
+* This is a Table component that allows displaying arbitrary data, not
+* necessarily related to entities or properties. It is the component
+* that powers the entity collections but has a generic API, so it
+* can be reused.
+*
+* @group Components
+*/
+var VirtualTableInner = React.memo(function VirtualTable({ data, onResetPagination, onEndReached, endOffset = 600, rowHeight = 54, headerHeight = 40, columns: columnsProp, onRowClick, onColumnResize, onColumnResizeEnd, filter: filterInput, checkFilterCombination, onFilterUpdate, sortBy, error, emptyComponent, onSortByUpdate, onScroll: onScrollProp, loading, cellRenderer, hoverRow, createFilterField, rowClassName, style, className, endAdornment, AddColumnComponent, initialScroll = 0, onColumnsOrderChange, extraData, onRowsRendered }) {
+	const sortIndex = useMemo(() => {
+		const index = /* @__PURE__ */ new Map();
+		(sortBy ?? []).forEach(([key, direction], position) => {
+			if (!index.has(key)) index.set(key, {
+				direction,
+				position
+			});
+		});
+		return index;
+	}, [sortBy]);
+	const columnsPropRef = useRef(columnsProp);
+	if (columnsPropRef.current !== columnsProp && !deepEqual(columnsPropRef.current, columnsProp)) columnsPropRef.current = columnsProp;
+	const stableColumnsProp = columnsPropRef.current;
+	const [columns, setColumns] = useState(stableColumnsProp);
+	const [adoptedColumnsProp, setAdoptedColumnsProp] = useState(stableColumnsProp);
+	if (adoptedColumnsProp !== stableColumnsProp) {
+		setAdoptedColumnsProp(stableColumnsProp);
+		setColumns(stableColumnsProp);
+	}
+	const tableRef = useRef(null);
+	const endReachCallbackThreshold = useRef(0);
+	const debouncedScroll = useDebounceCallback(onScrollProp, 200);
+	const [draggingColumnId, setDraggingColumnId] = useState(null);
+	const sensors = useSensors(useSensor(PointerSensor, { activationConstraint: { distance: 5 } }));
+	const handleDragStart = useCallback((event) => {
+		setDraggingColumnId(event.active.id);
+	}, []);
+	const handleDragEnd = useCallback((event) => {
+		const { active, over } = event;
+		setDraggingColumnId(null);
+		if (over && active.id !== over.id && onColumnsOrderChange) {
+			const oldIndex = columns.findIndex((col) => col.key === active.id);
+			const newIndex = columns.findIndex((col) => col.key === over.id);
+			if (oldIndex !== -1 && newIndex !== -1) {
+				const newColumns = arrayMove(columns, oldIndex, newIndex);
+				setColumns(newColumns);
+				onColumnsOrderChange(newColumns);
+			}
+		}
+	}, [columns, onColumnsOrderChange]);
+	const handleDragCancel = useCallback(() => {
+		setDraggingColumnId(null);
+	}, []);
+	const pendingInitialScroll = useRef(initialScroll > 0 ? initialScroll : void 0);
+	useEffect(() => {
+		if (tableRef.current && initialScroll) {
+			const { scrollLeft } = tableRef.current;
+			tableRef.current.scrollTo(scrollLeft, initialScroll);
+		}
+	}, [tableRef, initialScroll]);
+	const [measureRef, bounds] = useMeasure({
+		polyfill: ResizeObserver,
+		scroll: true,
+		offsetSize: true
+	});
+	const onColumnResizeInternal = useCallback((params) => {
+		setColumns((prevColumns) => prevColumns.map((column) => column.key === params.column.key ? params.column : column));
+	}, []);
+	const onColumnResizeEndInternal = useCallback((params) => {
+		setColumns(columns.map((column) => column.key === params.column.key ? params.column : column));
+		if (onColumnResize) onColumnResize(params);
+		if (onColumnResizeEnd) onColumnResizeEnd(params);
+	}, [
+		columns,
+		onColumnResize,
+		onColumnResizeEnd
+	]);
+	const filterRef = useRef(void 0);
+	useEffect(() => {
+		filterRef.current = filterInput;
+	}, [filterInput]);
+	const scrollToTop = useCallback(() => {
+		endReachCallbackThreshold.current = 0;
+		if (tableRef.current) tableRef.current.scrollTo(tableRef.current?.scrollLeft, 0);
+	}, []);
+	/**
+	* Click a header to sort by that column: ascending, descending, then
+	* off. Shift-click to keep the sort you already have and add this
+	* column under it — the same idiom spreadsheets use, and the only way
+	* to build "by role, newest first" out of two clicks.
+	*
+	* Shift cycles the column it lands on through the same three states, so
+	* a key added by mistake is removed by shift-clicking it twice more,
+	* without disturbing the keys around it.
+	*/
+	const onColumnSort = useCallback((key, additive = false) => {
+		const current = sortIndex.get(key);
+		const next = current === void 0 ? "asc" : current.direction === "asc" ? "desc" : void 0;
+		const existing = sortBy ?? [];
+		let newSortBy;
+		if (!additive) newSortBy = next ? [[key, next]] : void 0;
+		else if (next === void 0) newSortBy = existing.filter(([existingKey]) => existingKey !== key);
+		else if (current === void 0) newSortBy = [...existing, [key, next]];
+		else newSortBy = existing.map((entry) => entry[0] === key ? [key, next] : entry);
+		if (newSortBy?.length === 0) newSortBy = void 0;
+		const filter = filterRef.current;
+		if (filter) {
+			if (checkFilterCombination && !checkFilterCombination(filter, newSortBy)) {
+				if (onFilterUpdate) onFilterUpdate(void 0);
+			}
+		}
+		if (onResetPagination) onResetPagination();
+		if (onSortByUpdate) onSortByUpdate(newSortBy);
+		scrollToTop();
+	}, [
+		checkFilterCombination,
+		onFilterUpdate,
+		onResetPagination,
+		onSortByUpdate,
+		scrollToTop,
+		sortBy,
+		sortIndex
+	]);
+	const maxScroll = Math.max((data?.length ?? 0) * rowHeight - bounds.height, 0);
+	const onEndReachedInternal = useCallback((scrollOffset) => {
+		if (onEndReached && (data?.length ?? 0) > 0 && scrollOffset > endReachCallbackThreshold.current + endOffset) {
+			endReachCallbackThreshold.current = scrollOffset;
+			onEndReached();
+		}
+	}, [data?.length, onEndReached]);
+	const onScroll = useCallback(({ scrollDirection, scrollOffset, scrollUpdateWasRequested }) => {
+		if (scrollOffset > 0) pendingInitialScroll.current = void 0;
+		if (onScrollProp) debouncedScroll({
+			scrollDirection,
+			scrollOffset,
+			scrollUpdateWasRequested
+		});
+		if (!scrollUpdateWasRequested && scrollOffset >= maxScroll - endOffset) onEndReachedInternal(scrollOffset);
+	}, [maxScroll, onEndReachedInternal]);
+	const lastReportedRange = useRef(void 0);
+	const onItemsRendered = useCallback(({ visibleStartIndex, visibleStopIndex }) => {
+		if (!onRowsRendered) return;
+		const rows = data?.length ?? 0;
+		let start = visibleStartIndex;
+		let end = visibleStopIndex + 1;
+		const restoring = pendingInitialScroll.current;
+		if (restoring !== void 0 && visibleStartIndex === 0) {
+			start = Math.floor(restoring / rowHeight);
+			end = start + Math.max(1, Math.ceil(bounds.height / rowHeight));
+		}
+		start = Math.min(start, rows);
+		end = Math.min(end, rows);
+		const last = lastReportedRange.current;
+		if (last && last.start === start && last.end === end) return;
+		lastReportedRange.current = {
+			start,
+			end
+		};
+		onRowsRendered({
+			start,
+			end
+		});
+	}, [
+		onRowsRendered,
+		data?.length,
+		rowHeight,
+		bounds.height
+	]);
+	const onFilterUpdateInternal = useCallback((column, filterForProperty) => {
+		endReachCallbackThreshold.current = 0;
+		const filter = filterRef.current;
+		let newFilterValue = filter ? { ...filter } : {};
+		if (!filterForProperty) delete newFilterValue[column.key];
+		else newFilterValue[column.key] = filterForProperty;
+		if (!(!checkFilterCombination || checkFilterCombination(newFilterValue, sortBy))) newFilterValue = filterForProperty ? { [column.key]: filterForProperty } : {};
+		if (onFilterUpdate) onFilterUpdate(newFilterValue);
+	}, [
+		checkFilterCombination,
+		onFilterUpdate,
+		sortBy
+	]);
+	const labels = useUiLabels();
+	const empty = !loading && (data?.length ?? 0) === 0;
+	const customView = error && (data?.length ?? 0) === 0 ? /* @__PURE__ */ jsxs(CenteredView, {
+		maxWidth: "2xl",
+		className: "flex flex-col gap-2",
+		children: [/* @__PURE__ */ jsx(Typography, {
+			variant: "h6",
+			children: labels.error
+		}), error?.message && /* @__PURE__ */ jsx(SafeLinkRenderer, { text: error.message })]
+	}) : empty ? loading ? /* @__PURE__ */ jsx("div", {
+		className: "flex items-center justify-center py-12 px-8",
+		children: /* @__PURE__ */ jsx(CircularProgress, { size: "small" })
+	}) : /* @__PURE__ */ jsx("div", {
+		className: "flex flex-col overflow-auto items-center justify-center py-12 px-8",
+		children: emptyComponent
+	}) : void 0;
+	const virtualListController = useMemo(() => ({
+		data,
+		rowHeight,
+		headerHeight,
+		cellRenderer,
+		columns,
+		onRowClick,
+		customView,
+		onColumnResize: onColumnResizeInternal,
+		onColumnResizeEnd: onColumnResizeEndInternal,
+		filter: filterInput,
+		onColumnSort,
+		onFilterUpdate: onFilterUpdateInternal,
+		sortIndex,
+		hoverRow: hoverRow ?? false,
+		createFilterField,
+		rowClassName,
+		endAdornment,
+		AddColumnComponent,
+		onColumnsOrderChange: onColumnsOrderChange ? (newColumns) => {
+			setColumns(newColumns);
+			onColumnsOrderChange(newColumns);
+		} : void 0,
+		draggingColumnId,
+		extraData
+	}), [
+		data,
+		rowHeight,
+		cellRenderer,
+		columns,
+		onRowClick,
+		customView,
+		onColumnResizeInternal,
+		onColumnResizeEndInternal,
+		filterInput,
+		onColumnSort,
+		onFilterUpdateInternal,
+		sortIndex,
+		hoverRow,
+		createFilterField,
+		rowClassName,
+		endAdornment,
+		AddColumnComponent,
+		onColumnsOrderChange,
+		draggingColumnId,
+		extraData
+	]);
+	const sortableColumnKeys = columns.filter((col) => !col.frozen).map((col) => col.key);
+	const tableContent = /* @__PURE__ */ jsx("div", {
+		ref: measureRef,
+		style,
+		className: cls("h-full w-full", className, draggingColumnId && "overflow-hidden"),
+		children: /* @__PURE__ */ jsx(VirtualListContext.Provider, {
+			value: virtualListController,
+			children: /* @__PURE__ */ jsx(MemoizedList, {
+				outerRef: tableRef,
+				width: bounds.width,
+				height: bounds.height,
+				itemCount: (data?.length ?? 0) + (endAdornment ? 1 : 0),
+				onScroll: draggingColumnId ? void 0 : onScroll,
+				onItemsRendered: onRowsRendered ? onItemsRendered : void 0,
+				itemSize: rowHeight
+			}, rowHeight)
+		})
+	});
+	if (onColumnsOrderChange) return /* @__PURE__ */ jsx(DndContext, {
+		sensors,
+		collisionDetection: closestCenter,
+		onDragStart: handleDragStart,
+		onDragEnd: handleDragEnd,
+		onDragCancel: handleDragCancel,
+		children: /* @__PURE__ */ jsx(SortableContext, {
+			items: sortableColumnKeys,
+			strategy: horizontalListSortingStrategy,
+			children: tableContent
+		})
+	});
+	return tableContent;
+}, areVirtualTablePropsEqual);
+/**
+* Every prop by value except `data`, which is compared by reference.
+*
+* A realtime frame decodes into new row objects whether or not anything in
+* them changed, so a deep compare of `data` walked every row the table held —
+* 10,000 rows scrolled through cost ~22 ms per frame — to decide what only
+* the rows on screen can show. A new array now re-renders the table, and each
+* row on screen compares its own row by value (`areRowRendererPropsEqual`):
+* the work is bounded by the window, not by how far the user scrolled.
+*/
+function areVirtualTablePropsEqual(a, b) {
+	if (a.data !== b.data) return false;
+	return deepEqual({
+		...a,
+		data: void 0
+	}, {
+		...b,
+		data: void 0
+	});
+}
+/**
+* `React.memo` is not generic-preserving: it takes the props type as its own
+* type argument, so annotating the call with
+* `VirtualTableProps<Record<string, unknown>>` pinned `T` at the boundary and
+* discarded the `<T>` the inner function declares. The exported component was
+* therefore not generic at all — every consumer got `Record<string, unknown>`,
+* `columns` and `cellRenderer` were unrelated to `data`, and a caller writing
+* `<VirtualTable<Post> …>` was told the component expects no type arguments.
+*
+* Re-asserting the call signature is the standard way to carry a type parameter
+* across `memo`; it is the only cast here, and it restores the generic the
+* implementation always had. Runtime behaviour is unchanged — this is the same
+* memoized component under a type that describes it.
+*/
+var VirtualTable = VirtualTableInner;
+var SortableCellWrapper = ({ columnKey, width, isDragging, isDraggable, frozen, children }) => {
+	const { attributes, listeners, setNodeRef, transform, transition } = useSortable({
+		id: columnKey,
+		disabled: !isDraggable || frozen
+	});
+	const { tabIndex: _tabIndex, ...attrsWithoutTabIndex } = attributes;
+	return /* @__PURE__ */ jsx("div", {
+		ref: setNodeRef,
+		style: {
+			transform: transform ? `translateX(${transform.x}px)` : void 0,
+			transition: isDragging ? void 0 : transition,
+			minWidth: width,
+			maxWidth: width,
+			width
+		},
+		className: cls("flex-shrink-0", frozen && "sticky left-0 z-10 bg-surface-card"),
+		...attrsWithoutTabIndex,
+		children
+	});
+};
+/**
+* One row and its cells, drawn again only when something it is drawn from
+* changed.
+*
+* Every input is a prop and every prop is compared, so nothing a row shows can
+* go stale behind its memo. The comparisons are by reference except for the
+* row itself and `extraData`, which are compared by value: a realtime frame
+* decodes into new, equal objects, and comparing only the rows on screen is
+* what lets the table skip a deep compare of everything it holds.
+*
+* This replaced a deep compare of the row's `children` — every cell element,
+* each carrying the full `columns` array — which cost ~400 column-object
+* compares per row on every parent render.
+*/
+var VirtualTableRowRenderer = React.memo(function VirtualTableRowRenderer({ rowData, index, style, onRowClick, columns, hoverRow, rowClassName, rowHeight, headerHeight, cellRenderer, draggingColumnId, columnsReorderable, includeAddColumn, extraData }) {
+	return /* @__PURE__ */ jsxs(VirtualTableRow, {
+		rowData,
+		rowIndex: index,
+		onRowClick,
+		columns,
+		hoverRow,
+		rowClassName,
+		style: {
+			...style,
+			top: `calc(${style.top}px + ${headerHeight ?? 48}px)`
+		},
+		rowHeight,
+		children: [columns.map((column, columnIndex) => {
+			const cellData = rowData && rowData[column.key];
+			const isDragging = draggingColumnId === column.key;
+			const isDraggable = !column.frozen && columnsReorderable;
+			const cell = /* @__PURE__ */ jsx(VirtualTableCell, {
+				dataKey: column.key,
+				cellRenderer,
+				column,
+				columns,
+				rowData,
+				cellData,
+				rowIndex: index,
+				columnIndex,
+				extraData
+			});
+			return columnsReorderable ? /* @__PURE__ */ jsx(SortableCellWrapper, {
+				columnKey: column.key,
+				width: column.width,
+				isDragging,
+				isDraggable,
+				frozen: column.frozen,
+				children: cell
+			}, `cell_wrapper_${column.key}`) : /* @__PURE__ */ jsx("div", {
+				className: cls("flex-shrink-0 relative", column.frozen && "sticky left-0 z-10 bg-surface-card"),
+				style: {
+					minWidth: column.width,
+					maxWidth: column.width,
+					width: column.width
+				},
+				children: cell
+			}, `cell_wrapper_${column.key}`);
+		}), includeAddColumn && /* @__PURE__ */ jsx("div", { className: "w-20" })]
+	});
+}, areRowRendererPropsEqual);
+function areRowRendererPropsEqual(a, b) {
+	return a.index === b.index && a.columns === b.columns && a.cellRenderer === b.cellRenderer && a.onRowClick === b.onRowClick && a.rowClassName === b.rowClassName && a.hoverRow === b.hoverRow && a.rowHeight === b.rowHeight && a.headerHeight === b.headerHeight && a.draggingColumnId === b.draggingColumnId && a.columnsReorderable === b.columnsReorderable && a.includeAddColumn === b.includeAddColumn && shallowEqual(a.style, b.style) && deepEqual(a.extraData, b.extraData) && deepEqual(a.rowData, b.rowData);
+}
+function MemoizedList({ outerRef, width, height, itemCount, onScroll, onItemsRendered, itemSize }) {
+	return /* @__PURE__ */ jsx(FixedSizeList, {
+		outerRef,
+		innerElementType,
+		width,
+		height,
+		overscanCount: 4,
+		itemCount,
+		onScroll,
+		onItemsRendered,
+		itemSize,
+		children: useCallback(({ index, style }) => {
+			return /* @__PURE__ */ jsx(VirtualListContext.Consumer, { children: ({ onRowClick, data, columns, rowHeight = 54, headerHeight = 40, cellRenderer, hoverRow, rowClassName, endAdornment, draggingColumnId, onColumnsOrderChange, AddColumnComponent, extraData }) => {
+				if (endAdornment && index === (data ?? []).length) return /* @__PURE__ */ jsx("div", {
+					style: {
+						...style,
+						height: "auto",
+						position: "sticky",
+						bottom: 0,
+						zIndex: 1
+					},
+					children: endAdornment
+				});
+				return /* @__PURE__ */ jsx(VirtualTableRowRenderer, {
+					rowData: data ? data[index] : void 0,
+					index,
+					style,
+					onRowClick,
+					columns,
+					hoverRow,
+					rowClassName,
+					rowHeight,
+					headerHeight,
+					cellRenderer,
+					draggingColumnId,
+					columnsReorderable: Boolean(onColumnsOrderChange),
+					includeAddColumn: Boolean(AddColumnComponent),
+					extraData
+				});
+			} });
+		}, [])
+	});
+}
+var SafeLinkRenderer = ({ text }) => {
+	const urlRegex = /https?:\/\/[^\s]+/g;
+	const urls = text.match(urlRegex) || [];
+	return /* @__PURE__ */ jsx("div", {
+		className: "break-all",
+		children: text.split(urlRegex).map((part, i) => /* @__PURE__ */ jsxs(React.Fragment, { children: [part, urls[i] && /* @__PURE__ */ jsxs(Fragment, { children: [/* @__PURE__ */ jsx("a", {
+			href: urls[i],
+			className: "underline",
+			target: "_blank",
+			rel: "noopener noreferrer",
+			children: "Link"
+		}), /* @__PURE__ */ jsx("br", {})] })] }, i))
+	});
+};
+//#endregion
+export { VirtualTable };
+
+//# sourceMappingURL=VirtualTable.es.js.map

package/dist/components/VirtualTable/VirtualTable.es.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"VirtualTable.es.js","names":[],"sources":["../../../src/components/VirtualTable/VirtualTable.tsx"],"sourcesContent":["\n\nimport React, { createContext, forwardRef, RefObject, useCallback, useEffect, useMemo, useRef, useState } from \"react\";\n\nimport { deepEqual as equal, shallowEqual } from \"fast-equals\"\n\nimport { FixedSizeList as List } from \"react-window\";\nimport useMeasure from \"react-use-measure\";\n\nimport { CircularProgress } from \"../CircularProgress\";\nimport {\n    OnVirtualTableColumnResizeParams,\n    VirtualTableColumn,\n    VirtualTableFilterValues,\n    VirtualTableProps,\n    VirtualTableSortKey,\n    VirtualTableWhereFilterOp\n} from \"./VirtualTableProps\";\n\nimport { VirtualTableContextProps } from \"./types\";\nimport { VirtualTableHeaderRow } from \"./VirtualTableHeaderRow\";\nimport { VirtualTableRow } from \"./VirtualTableRow\";\nimport { VirtualTableCell } from \"./VirtualTableCell\";\nimport { CenteredView } from \"../CenteredView\";\nimport { Typography } from \"../Typography\";\nimport { cls } from \"../../util/cls\";\nimport { useDebounceCallback } from \"../../hooks/useDebounceCallback\";\nimport { useUiLabels } from \"../../hooks/UiLabelsContext\";\nimport {\n    closestCenter,\n    DndContext,\n    DragEndEvent,\n    DragStartEvent,\n    PointerSensor,\n    useSensor,\n    useSensors\n} from \"@dnd-kit/core\";\nimport { arrayMove, horizontalListSortingStrategy, SortableContext, useSortable } from \"@dnd-kit/sortable\";\n\n\nconst VirtualListContext = createContext<VirtualTableContextProps<Record<string, unknown>>>(null! as VirtualTableContextProps<Record<string, unknown>>);\nVirtualListContext.displayName = \"VirtualListContext\";\n\ntype InnerElementProps = {\n    children: React.ReactNode,\n    style: React.CSSProperties\n};\n\n// eslint-disable-next-line react/display-name\nconst innerElementType = forwardRef<HTMLDivElement, InnerElementProps>(({\n    children,\n    ...rest\n}: InnerElementProps, ref) => {\n\n    return (\n        <VirtualListContext.Consumer>\n            {(virtualTableProps) => {\n                const customView = virtualTableProps.customView;\n                const headerHeight = virtualTableProps.headerHeight ?? 48;\n                return (\n                    <>\n                        <div\n                            id={\"virtual-table\"}\n                            style={{\n                                position: \"relative\",\n                                height: \"100%\",\n                                zIndex: 0\n                            }}>\n                            <div\n                                ref={ref}\n                                {...rest}\n                                style={{\n                                    ...rest?.style,\n                                    height: (typeof rest?.style?.height === \"number\" ? rest.style.height : parseFloat((rest?.style?.height as string) || \"0\")) + headerHeight,\n                                    minHeight: \"100%\",\n                                    position: \"relative\"\n                                }}>\n                                <div style={{ position: \"sticky\",\ntop: 0,\nzIndex: 20 }}>\n                                    <VirtualTableHeaderRow {...virtualTableProps}/>\n                                </div>\n                                {!customView && children}\n                            </div>\n\n                        </div>\n\n                        {customView && <div style={{\n                            position: \"sticky\",\n                            top: virtualTableProps.headerHeight ?? 48,\n                            flexGrow: 1,\n                            height: `calc(100% - ${virtualTableProps.headerHeight ?? 48}px)`,\n                            marginTop: `calc(${(virtualTableProps.headerHeight ?? 48)}px - 100vh)`,\n                            left: 0\n                        }}>{customView}</div>}\n\n                    </>\n                );\n            }}\n        </VirtualListContext.Consumer>\n    );\n})\n    ;\n\n/**\n * This is a Table component that allows displaying arbitrary data, not\n * necessarily related to entities or properties. It is the component\n * that powers the entity collections but has a generic API, so it\n * can be reused.\n *\n * @group Components\n */\nconst VirtualTableInner = React.memo<VirtualTableProps<Record<string, unknown>>>(\n    function VirtualTable<T extends object>({\n        data,\n        onResetPagination,\n        onEndReached,\n        endOffset = 600,\n        rowHeight = 54,\n        headerHeight = 40,\n        columns: columnsProp,\n        onRowClick,\n        onColumnResize,\n        onColumnResizeEnd,\n        filter: filterInput,\n        checkFilterCombination,\n        onFilterUpdate,\n        sortBy,\n        error,\n        emptyComponent,\n        onSortByUpdate,\n        onScroll: onScrollProp,\n        loading,\n        cellRenderer,\n        hoverRow,\n        createFilterField,\n        rowClassName,\n        style,\n        className,\n        endAdornment,\n        AddColumnComponent,\n        initialScroll = 0,\n        onColumnsOrderChange,\n        extraData,\n        onRowsRendered\n    }: VirtualTableProps<T>) {\n\n        // Where each sorted column sits in the order, so a header can show both\n        // which way it runs and how much it counts: `roles ↑1, created_at ↓2`\n        // reads as \"by role, newest first within each role\". Without the rank a\n        // multi-key sort shows two arrows and no way to tell which one wins.\n        const sortIndex = useMemo(() => {\n            const index = new Map<string, { direction: \"asc\" | \"desc\"; position: number }>();\n            (sortBy ?? []).forEach(([key, direction], position) => {\n                if (!index.has(key)) index.set(key, { direction,\nposition });\n            });\n            return index;\n        }, [sortBy]);\n\n        // Held by value: a caller that rebuilds equal column objects on each\n        // render must not hand every cell a new `columns` array, which is one\n        // of the things a cell is drawn from (see `areCellPropsEqual`).\n        const columnsPropRef = useRef(columnsProp);\n        if (columnsPropRef.current !== columnsProp && !equal(columnsPropRef.current, columnsProp)) {\n            columnsPropRef.current = columnsProp;\n        }\n        const stableColumnsProp = columnsPropRef.current;\n\n        // The columns as drawn: the prop, or what a resize or a drag has made\n        // of it since. Adopted during render when the prop changes rather than\n        // in an effect, which drew every changed column a second time — first\n        // with the old columns, then again, a commit later, with the new ones.\n        const [columns, setColumns] = useState(stableColumnsProp);\n        const [adoptedColumnsProp, setAdoptedColumnsProp] = useState(stableColumnsProp);\n        if (adoptedColumnsProp !== stableColumnsProp) {\n            setAdoptedColumnsProp(stableColumnsProp);\n            setColumns(stableColumnsProp);\n        }\n\n        const tableRef = useRef<HTMLDivElement>(null);\n        const endReachCallbackThreshold = useRef<number>(0);\n\n        const debouncedScroll = useDebounceCallback(onScrollProp, 200);\n\n        // Drag and drop state\n        const [draggingColumnId, setDraggingColumnId] = useState<string | null>(null);\n\n        const sensors = useSensors(\n            useSensor(PointerSensor, {\n                activationConstraint: {\n                    distance: 5\n                }\n            })\n        );\n\n        const handleDragStart = useCallback((event: DragStartEvent) => {\n            setDraggingColumnId(event.active.id as string);\n        }, []);\n\n        const handleDragEnd = useCallback((event: DragEndEvent) => {\n            const {\n                active,\n                over\n            } = event;\n            setDraggingColumnId(null);\n\n            if (over && active.id !== over.id && onColumnsOrderChange) {\n                const oldIndex = columns.findIndex((col) => col.key === active.id);\n                const newIndex = columns.findIndex((col) => col.key === over.id);\n\n                if (oldIndex !== -1 && newIndex !== -1) {\n                    const newColumns = arrayMove(columns, oldIndex, newIndex);\n                    setColumns(newColumns);\n                    onColumnsOrderChange(newColumns);\n                }\n            }\n        }, [columns, onColumnsOrderChange]);\n\n        const handleDragCancel = useCallback(() => {\n            setDraggingColumnId(null);\n        }, []);\n\n        // The offset this table opened at, until it has scrolled there: the\n        // list first draws its top rows, and reporting them would have the\n        // rows above a restored position read for nothing.\n        const pendingInitialScroll = useRef(initialScroll > 0 ? initialScroll : undefined);\n\n        // Set initial scroll position\n        useEffect(() => {\n            if (tableRef.current && initialScroll) {\n                const { scrollLeft } = tableRef.current;\n                tableRef.current.scrollTo(scrollLeft, initialScroll);\n            }\n        }, [tableRef, initialScroll]);\n\n    // Removed redundant ResizeObserver to prevent performance issues and UI flickering.\n\n        const [measureRef, bounds] = useMeasure({\n            polyfill: ResizeObserver,\n            scroll: true,\n            // This is important for handling zooming in react-flow\n            offsetSize: true\n        });\n\n        const onColumnResizeInternal = useCallback((params: OnVirtualTableColumnResizeParams) => {\n            setColumns(prevColumns =>\n                prevColumns.map((column) =>\n                    column.key === params.column.key ? params.column : column\n                )\n            );\n        }, []);\n\n        const onColumnResizeEndInternal = useCallback((params: OnVirtualTableColumnResizeParams) => {\n            setColumns(columns.map((column) => column.key === params.column.key ? params.column : column));\n            if (onColumnResize) {\n                onColumnResize(params);\n            }\n            if (onColumnResizeEnd) {\n                onColumnResizeEnd(params);\n            }\n        }, [columns, onColumnResize, onColumnResizeEnd]);\n\n        // saving the current filter as a ref as a workaround for header closure\n        const filterRef = useRef<VirtualTableFilterValues<string> | undefined>(undefined);\n\n        useEffect(() => {\n            filterRef.current = filterInput;\n        }, [filterInput]);\n\n        const scrollToTop = useCallback(() => {\n            endReachCallbackThreshold.current = 0;\n            if (tableRef.current) {\n                tableRef.current.scrollTo(tableRef.current?.scrollLeft, 0);\n            }\n        }, []);\n\n        /**\n         * Click a header to sort by that column: ascending, descending, then\n         * off. Shift-click to keep the sort you already have and add this\n         * column under it — the same idiom spreadsheets use, and the only way\n         * to build \"by role, newest first\" out of two clicks.\n         *\n         * Shift cycles the column it lands on through the same three states, so\n         * a key added by mistake is removed by shift-clicking it twice more,\n         * without disturbing the keys around it.\n         */\n        const onColumnSort = useCallback((key: string, additive = false) => {\n\n            const current = sortIndex.get(key);\n            const next: \"asc\" | \"desc\" | undefined = current === undefined\n                ? \"asc\"\n                : current.direction === \"asc\" ? \"desc\" : undefined;\n\n            const existing = sortBy ?? [];\n            let newSortBy: VirtualTableSortKey[] | undefined;\n            if (!additive) {\n                newSortBy = next ? [[key, next]] : undefined;\n            } else if (next === undefined) {\n                newSortBy = existing.filter(([existingKey]) => existingKey !== key);\n            } else if (current === undefined) {\n                newSortBy = [...existing, [key, next]];\n            } else {\n                newSortBy = existing.map((entry) => entry[0] === key ? [key, next] as VirtualTableSortKey : entry);\n            }\n            if (newSortBy?.length === 0) newSortBy = undefined;\n\n            const filter = filterRef.current;\n            if (filter) {\n                if (checkFilterCombination && !checkFilterCombination(filter, newSortBy)) {\n                    if (onFilterUpdate)\n                        onFilterUpdate(undefined);\n                }\n            }\n\n            if (onResetPagination) {\n                onResetPagination();\n            }\n\n            if (onSortByUpdate) {\n                onSortByUpdate(newSortBy);\n            }\n\n            scrollToTop();\n        }, [checkFilterCombination, onFilterUpdate, onResetPagination, onSortByUpdate, scrollToTop, sortBy, sortIndex]);\n\n        const maxScroll = Math.max((data?.length ?? 0) * rowHeight - bounds.height, 0);\n\n        const onEndReachedInternal = useCallback((scrollOffset: number) => {\n            if (onEndReached && (data?.length ?? 0) > 0 && scrollOffset > endReachCallbackThreshold.current + endOffset) {\n                endReachCallbackThreshold.current = scrollOffset;\n                onEndReached();\n            }\n        }, [data?.length, onEndReached]);\n\n        const onScroll = useCallback(({\n            scrollDirection,\n            scrollOffset,\n            scrollUpdateWasRequested\n        }: {\n            scrollDirection: \"forward\" | \"backward\",\n            scrollOffset: number,\n            scrollUpdateWasRequested: boolean;\n        }) => {\n            if (scrollOffset > 0) pendingInitialScroll.current = undefined;\n            if (onScrollProp) {\n                debouncedScroll({\n                    scrollDirection,\n                    scrollOffset,\n                    scrollUpdateWasRequested\n                })\n            }\n            if (!scrollUpdateWasRequested && (scrollOffset >= maxScroll - endOffset))\n                onEndReachedInternal(scrollOffset);\n        }, [maxScroll, onEndReachedInternal]);\n\n        const lastReportedRange = useRef<{ start: number; end: number } | undefined>(undefined);\n        const onItemsRendered = useCallback(({\n            visibleStartIndex,\n            visibleStopIndex\n        }: { visibleStartIndex: number; visibleStopIndex: number }) => {\n            if (!onRowsRendered) return;\n            const rows = data?.length ?? 0;\n            let start = visibleStartIndex;\n            let end = visibleStopIndex + 1;\n            const restoring = pendingInitialScroll.current;\n            if (restoring !== undefined && visibleStartIndex === 0) {\n                start = Math.floor(restoring / rowHeight);\n                end = start + Math.max(1, Math.ceil(bounds.height / rowHeight));\n            }\n            // The end adornment's slot is not a row.\n            start = Math.min(start, rows);\n            end = Math.min(end, rows);\n            const last = lastReportedRange.current;\n            if (last && last.start === start && last.end === end) return;\n            lastReportedRange.current = { start, end };\n            onRowsRendered({ start, end });\n        }, [onRowsRendered, data?.length, rowHeight, bounds.height]);\n\n        const onFilterUpdateInternal = useCallback((column: VirtualTableColumn, filterForProperty?: [VirtualTableWhereFilterOp, unknown]) => {\n\n            endReachCallbackThreshold.current = 0;\n            const filter = filterRef.current;\n            let newFilterValue: VirtualTableFilterValues<string> = filter ? { ...filter } : {};\n\n            if (!filterForProperty) {\n                delete newFilterValue[column.key];\n            } else {\n                newFilterValue[column.key] = filterForProperty;\n            }\n            const isNewFilterCombinationValid = !checkFilterCombination || checkFilterCombination(newFilterValue, sortBy);\n            if (!isNewFilterCombinationValid) {\n                newFilterValue = filterForProperty ? { [column.key]: filterForProperty } as VirtualTableFilterValues<Extract<keyof T, string>> : {};\n            }\n\n            if (onFilterUpdate) onFilterUpdate(newFilterValue);\n        }, [checkFilterCombination, onFilterUpdate, sortBy]);\n\n        const labels = useUiLabels();\n        const empty = !loading && (data?.length ?? 0) === 0;\n        const customView = (error && (data?.length ?? 0) === 0)\n            ? <CenteredView maxWidth={\"2xl\"}\n                className=\"flex flex-col gap-2\">\n\n                <Typography variant={\"h6\"}>\n                    {labels.error}\n                </Typography>\n\n                {error?.message && <SafeLinkRenderer text={error.message}/>}\n\n            </CenteredView>\n            : (empty\n                ? (loading\n                    ? <div className=\"flex items-center justify-center py-12 px-8\">\n                        <CircularProgress size=\"small\"/>\n                    </div>\n                    : <div\n                        className=\"flex flex-col overflow-auto items-center justify-center py-12 px-8\">\n                        {emptyComponent}\n                    </div>)\n                : undefined);\n\n        const virtualListController = useMemo(() => ({\n            data,\n            rowHeight: rowHeight,\n            headerHeight: headerHeight,\n            cellRenderer,\n            columns,\n            onRowClick,\n            customView,\n            onColumnResize: onColumnResizeInternal,\n            onColumnResizeEnd: onColumnResizeEndInternal,\n            // The prop, not `filterRef`: the ref is brought up to date by an\n            // effect, after this render has read it, so the header showed the\n            // filter from before — until something else redrew it.\n            filter: filterInput,\n            onColumnSort,\n            onFilterUpdate: onFilterUpdateInternal,\n            sortIndex,\n            hoverRow: hoverRow ?? false,\n            createFilterField,\n            rowClassName,\n            endAdornment,\n            AddColumnComponent,\n            onColumnsOrderChange: onColumnsOrderChange ? (newColumns: VirtualTableColumn[]) => {\n                setColumns(newColumns);\n                onColumnsOrderChange(newColumns);\n            } : undefined,\n            draggingColumnId,\n            extraData\n        }), [data, rowHeight, cellRenderer, columns, onRowClick, customView, onColumnResizeInternal, onColumnResizeEndInternal, filterInput, onColumnSort, onFilterUpdateInternal, sortIndex, hoverRow, createFilterField, rowClassName, endAdornment, AddColumnComponent, onColumnsOrderChange, draggingColumnId, extraData]);\n\n        // Get sortable column keys (excluding frozen columns)\n        const sortableColumnKeys = columns\n            .filter(col => !col.frozen)\n            .map(col => col.key);\n\n        const tableContent = (\n            <div\n                ref={measureRef}\n                style={style}\n                className={cls(\n                    \"h-full w-full\",\n                    className,\n                    draggingColumnId && \"overflow-hidden\"\n                )}>\n                {/* SAFETY: T extends Record<string, any> is structurally assignable to Record<string, unknown> */}\n                <VirtualListContext.Provider\n                    value={virtualListController as VirtualTableContextProps<Record<string, unknown>>}>\n\n                    <MemoizedList\n                        outerRef={tableRef}\n                        key={rowHeight}\n                        width={bounds.width}\n                        height={bounds.height}\n                        itemCount={(data?.length ?? 0) + (endAdornment ? 1 : 0)}\n                        onScroll={draggingColumnId ? undefined : onScroll}\n                        onItemsRendered={onRowsRendered ? onItemsRendered : undefined}\n                        itemSize={rowHeight}/>\n\n                </VirtualListContext.Provider>\n            </div>\n        );\n\n        // Wrap with DndContext if column reorder is enabled\n        if (onColumnsOrderChange) {\n            return (\n                <DndContext\n                    sensors={sensors}\n                    collisionDetection={closestCenter}\n                    onDragStart={handleDragStart}\n                    onDragEnd={handleDragEnd}\n                    onDragCancel={handleDragCancel}\n                >\n                    <SortableContext\n                        items={sortableColumnKeys}\n                        strategy={horizontalListSortingStrategy}\n                    >\n                        {tableContent}\n                    </SortableContext>\n                </DndContext>\n            );\n        }\n\n        return tableContent;\n    },\n    areVirtualTablePropsEqual\n);\n\n/**\n * Every prop by value except `data`, which is compared by reference.\n *\n * A realtime frame decodes into new row objects whether or not anything in\n * them changed, so a deep compare of `data` walked every row the table held —\n * 10,000 rows scrolled through cost ~22 ms per frame — to decide what only\n * the rows on screen can show. A new array now re-renders the table, and each\n * row on screen compares its own row by value (`areRowRendererPropsEqual`):\n * the work is bounded by the window, not by how far the user scrolled.\n */\nfunction areVirtualTablePropsEqual(\n    a: VirtualTableProps<Record<string, unknown>>,\n    b: VirtualTableProps<Record<string, unknown>>\n): boolean {\n    if (a.data !== b.data) return false;\n    return equal({ ...a, data: undefined }, { ...b, data: undefined });\n}\n\n/**\n * `React.memo` is not generic-preserving: it takes the props type as its own\n * type argument, so annotating the call with\n * `VirtualTableProps<Record<string, unknown>>` pinned `T` at the boundary and\n * discarded the `<T>` the inner function declares. The exported component was\n * therefore not generic at all — every consumer got `Record<string, unknown>`,\n * `columns` and `cellRenderer` were unrelated to `data`, and a caller writing\n * `<VirtualTable<Post> …>` was told the component expects no type arguments.\n *\n * Re-asserting the call signature is the standard way to carry a type parameter\n * across `memo`; it is the only cast here, and it restores the generic the\n * implementation always had. Runtime behaviour is unchanged — this is the same\n * memoized component under a type that describes it.\n */\nexport const VirtualTable = VirtualTableInner as <T extends object>(\n    props: VirtualTableProps<T>\n) => React.ReactElement | null;\n// Wrapper that applies sortable transforms to cells\nconst SortableCellWrapper = ({\n    columnKey,\n    width,\n    isDragging,\n    isDraggable,\n    frozen,\n    children\n}: {\n    columnKey: string;\n    width: number;\n    isDragging: boolean;\n    isDraggable: boolean;\n    frozen?: boolean;\n    children: React.ReactNode;\n}) => {\n    const {\n        attributes,\n        listeners,\n        setNodeRef,\n        transform,\n        transition\n    } = useSortable({\n        id: columnKey,\n        disabled: !isDraggable || frozen\n    });\n\n    // Remove tabIndex from attributes to avoid capturing focus before cell content\n    const { tabIndex: _tabIndex, ...attrsWithoutTabIndex } = attributes;\n\n    const style = {\n        // Only use translate, ignore any scale transforms\n        transform: transform ? `translateX(${transform.x}px)` : undefined,\n        // Don't transition the dragged item - only other items should animate\n        transition: isDragging ? undefined : transition,\n        minWidth: width,\n        maxWidth: width,\n        width: width\n    };\n\n    return (\n        <div\n            ref={setNodeRef}\n            style={style}\n            className={cls(\n                \"flex-shrink-0\",\n                frozen && \"sticky left-0 z-10 bg-surface-card\"\n            )}\n            {...attrsWithoutTabIndex}\n        >\n            {children}\n        </div>\n    );\n};\n\ntype VirtualTableRowRendererProps = {\n    rowData: Record<string, unknown> | undefined;\n    index: number;\n    style: React.CSSProperties;\n    onRowClick?: VirtualTableContextProps<Record<string, unknown>>[\"onRowClick\"];\n    columns: VirtualTableColumn[];\n    hoverRow: boolean;\n    rowClassName?: (rowData: Record<string, unknown>) => string | undefined;\n    rowHeight: number;\n    headerHeight: number;\n    cellRenderer: VirtualTableContextProps<Record<string, unknown>>[\"cellRenderer\"];\n    draggingColumnId?: string | null;\n    columnsReorderable: boolean;\n    includeAddColumn: boolean;\n    extraData?: unknown;\n};\n\n/**\n * One row and its cells, drawn again only when something it is drawn from\n * changed.\n *\n * Every input is a prop and every prop is compared, so nothing a row shows can\n * go stale behind its memo. The comparisons are by reference except for the\n * row itself and `extraData`, which are compared by value: a realtime frame\n * decodes into new, equal objects, and comparing only the rows on screen is\n * what lets the table skip a deep compare of everything it holds.\n *\n * This replaced a deep compare of the row's `children` — every cell element,\n * each carrying the full `columns` array — which cost ~400 column-object\n * compares per row on every parent render.\n */\nconst VirtualTableRowRenderer = React.memo(function VirtualTableRowRenderer({\n    rowData,\n    index,\n    style,\n    onRowClick,\n    columns,\n    hoverRow,\n    rowClassName,\n    rowHeight,\n    headerHeight,\n    cellRenderer,\n    draggingColumnId,\n    columnsReorderable,\n    includeAddColumn,\n    extraData\n}: VirtualTableRowRendererProps) {\n    return (\n        <VirtualTableRow\n            rowData={rowData}\n            rowIndex={index}\n            onRowClick={onRowClick}\n            columns={columns}\n            hoverRow={hoverRow}\n            rowClassName={rowClassName}\n            style={{\n                ...style,\n                top: `calc(${style.top}px + ${headerHeight ?? 48}px)`\n            }}\n            rowHeight={rowHeight}>\n\n            {columns.map((column: VirtualTableColumn, columnIndex: number) => {\n                // The one place the row is read by key, and the one\n                // cast for it. `T` is constrained to `object`\n                // rather than `Record<string, unknown>` because an\n                // `interface` — `Entity`, every consumer's row type\n                // — has no implicit index signature and so does not\n                // satisfy the latter. Constraining it there did not\n                // make this read safe; it pushed an\n                // `as unknown as Record<string, unknown>` onto every\n                // caller, on the data going in AND on each callback\n                // coming back out, which is four of them in\n                // `SelectableTable` alone.\n                const cellData = rowData && (rowData as Record<string, unknown>)[column.key];\n                const isDragging = draggingColumnId === column.key;\n                const isDraggable = !column.frozen && columnsReorderable;\n\n                const cell = <VirtualTableCell\n                    dataKey={column.key}\n                    // @ts-expect-error -- React.memo<VirtualTableProps<any>> erases the generic T, so cellRenderer's parameter type widens to `any` losing structural compatibility with VirtualTableCell<T>. The types are structurally correct at runtime.\n                    cellRenderer={cellRenderer}\n                    column={column}\n                    columns={columns}\n                    rowData={rowData}\n                    cellData={cellData}\n                    rowIndex={index}\n                    columnIndex={columnIndex}\n                    extraData={extraData}/>;\n\n                return columnsReorderable ? (\n                    <SortableCellWrapper\n                        key={`cell_wrapper_${column.key}`}\n                        columnKey={column.key}\n                        width={column.width}\n                        isDragging={isDragging}\n                        isDraggable={isDraggable}\n                        frozen={column.frozen}\n                    >\n                        {cell}\n                    </SortableCellWrapper>\n                ) : (\n                    <div\n                        key={`cell_wrapper_${column.key}`}\n                        className={cls(\n                            \"flex-shrink-0 relative\",\n                            column.frozen && \"sticky left-0 z-10 bg-surface-card\"\n                        )}\n                        style={{\n                            minWidth: column.width,\n                            maxWidth: column.width,\n                            width: column.width\n                        }}\n                    >\n                        {cell}\n                    </div>\n                );\n            })}\n\n            {includeAddColumn && <div className={\"w-20\"}/>}\n\n        </VirtualTableRow>\n    );\n}, areRowRendererPropsEqual);\n\nfunction areRowRendererPropsEqual(a: VirtualTableRowRendererProps, b: VirtualTableRowRendererProps): boolean {\n    return a.index === b.index &&\n        a.columns === b.columns &&\n        a.cellRenderer === b.cellRenderer &&\n        a.onRowClick === b.onRowClick &&\n        a.rowClassName === b.rowClassName &&\n        a.hoverRow === b.hoverRow &&\n        a.rowHeight === b.rowHeight &&\n        a.headerHeight === b.headerHeight &&\n        a.draggingColumnId === b.draggingColumnId &&\n        a.columnsReorderable === b.columnsReorderable &&\n        a.includeAddColumn === b.includeAddColumn &&\n        shallowEqual(a.style, b.style) &&\n        equal(a.extraData, b.extraData) &&\n        equal(a.rowData, b.rowData);\n}\n\nfunction MemoizedList({\n    outerRef,\n    width,\n    height,\n    itemCount,\n    onScroll,\n    onItemsRendered,\n    itemSize\n}: {\n    outerRef: RefObject<HTMLDivElement | null>;\n    width: number;\n    height: number;\n    itemCount: number;\n    onScroll?: (params: {\n        scrollDirection: \"forward\" | \"backward\",\n        scrollOffset: number,\n        scrollUpdateWasRequested: boolean;\n    }) => void;\n    onItemsRendered?: (params: { visibleStartIndex: number; visibleStopIndex: number }) => void;\n    itemSize: number;\n}) {\n\n    const Row = useCallback(({\n        index,\n        style\n    }: { index: number; style: React.CSSProperties }) => {\n        return <VirtualListContext.Consumer>\n            {({\n                onRowClick,\n                data,\n                columns,\n                rowHeight = 54,\n                headerHeight = 40,\n                cellRenderer,\n                hoverRow,\n                rowClassName,\n                endAdornment,\n                draggingColumnId,\n                onColumnsOrderChange,\n                AddColumnComponent,\n                extraData\n            }) => {\n\n                if (endAdornment && index === (data ?? []).length) {\n                    return <div style={{\n                        ...style,\n                        height: \"auto\",\n                        position: \"sticky\",\n                        bottom: 0,\n                        zIndex: 1\n                    }}>\n                        {endAdornment}\n                    </div>;\n                }\n\n                return <VirtualTableRowRenderer\n                    rowData={data ? data[index] : undefined}\n                    index={index}\n                    style={style}\n                    onRowClick={onRowClick}\n                    columns={columns}\n                    hoverRow={hoverRow}\n                    rowClassName={rowClassName}\n                    rowHeight={rowHeight}\n                    headerHeight={headerHeight}\n                    cellRenderer={cellRenderer}\n                    draggingColumnId={draggingColumnId}\n                    columnsReorderable={Boolean(onColumnsOrderChange)}\n                    // Read here rather than from this function's closure: the\n                    // component is created once, and a closure would keep the\n                    // first value for the life of the list.\n                    includeAddColumn={Boolean(AddColumnComponent)}\n                    extraData={extraData}/>;\n            }}\n        </VirtualListContext.Consumer>;\n    }, []);\n\n    return <List\n        outerRef={outerRef}\n        innerElementType={innerElementType}\n        width={width}\n        height={height}\n        overscanCount={4}\n        itemCount={itemCount}\n        onScroll={onScroll}\n        onItemsRendered={onItemsRendered}\n        itemSize={itemSize}>\n        {Row}\n    </List>;\n}\n\nconst SafeLinkRenderer: React.FC<{\n    text: string;\n}> = ({ text }) => {\n    const urlRegex = /https?:\\/\\/[^\\s]+/g;\n    const urls = text.match(urlRegex) || [];\n    const parts = text.split(urlRegex);\n\n    return (\n        <div className={\"break-all\"}>\n            {parts.map((part, i) => (\n                <React.Fragment key={i}>\n                    {part}\n                    {urls[i] && (\n                        <>\n                            <a href={urls[i]} className=\"underline\" target=\"_blank\" rel=\"noopener noreferrer\">Link</a>\n                            <br/>\n                        </>\n                    )}\n                </React.Fragment>\n            ))}\n        </div>\n    );\n};\n"],"mappings":"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"}

package/dist/components/VirtualTable/VirtualTableCell.d.ts

@@ -4,7 +4,7 @@ type VirtualTableCellProps<T> = {
     dataKey: string;
     column: VirtualTableColumn;
     columns: VirtualTableColumn[];
-    rowData: T;
+    rowData: T | undefined;
     cellData: unknown;
     rowIndex: number;
     columnIndex: number;

package/dist/components/VirtualTable/VirtualTableCell.es.js

@@ -0,0 +1,40 @@
+import React from "react";
+import { deepEqual } from "fast-equals";
+//#region src/components/VirtualTable/VirtualTableCell.tsx
+var VirtualTableCell = React.memo(function VirtualTableCell(props) {
+	return props.rowData !== null ? props.cellRenderer({
+		cellData: props.cellData,
+		rowData: props.rowData,
+		rowIndex: props.rowIndex,
+		isScrolling: false,
+		column: props.column,
+		columns: props.columns,
+		columnIndex: props.columnIndex,
+		width: props.column.width,
+		sortableNodeRef: props.sortableNodeRef,
+		sortableStyle: props.sortableStyle,
+		sortableAttributes: props.sortableAttributes,
+		isDragging: props.isDragging,
+		isDraggable: props.isDraggable,
+		frozen: props.frozen,
+		extraData: props.extraData
+	}) : null;
+}, areCellPropsEqual);
+/**
+* Every prop the cell hands `cellRenderer` is compared, and so is
+* `cellRenderer` itself: a cell that kept the renderer it was first given kept
+* every value that renderer closed over — inline editing switched off, a
+* permission revoked, a new row-actions builder — until its row changed.
+*
+* Values that a parent rebuilds on each render (the row, its cell value, the
+* column, `extraData`) are compared by value; `deepEqual` returns at once for
+* the same reference. Functions and `columns` are compared by reference —
+* `VirtualTable` holds `columns` by value already.
+*/
+function areCellPropsEqual(a, b) {
+	return a.cellRenderer === b.cellRenderer && a.columns === b.columns && a.dataKey === b.dataKey && a.rowIndex === b.rowIndex && a.columnIndex === b.columnIndex && a.isDragging === b.isDragging && a.isDraggable === b.isDraggable && a.frozen === b.frozen && a.sortableNodeRef === b.sortableNodeRef && a.sortableStyle === b.sortableStyle && a.sortableAttributes === b.sortableAttributes && deepEqual(a.column, b.column) && deepEqual(a.cellData, b.cellData) && deepEqual(a.extraData, b.extraData) && deepEqual(a.rowData, b.rowData);
+}
+//#endregion
+export { VirtualTableCell };
+
+//# sourceMappingURL=VirtualTableCell.es.js.map