Virtualized tree select
A virtualized tree select using @tanstack/react-virtual to efficiently render a large tree with 292 nodes. Supports expand/collapse with chevron icons.
treeselect
import { type KeyboardEvent, useMemo, useState } from 'react';
import { useVirtualizer } from '@tanstack/react-virtual';
import { Combobox, Input, InputBase, useVirtualizedCombobox } from '@mantine/core';
import classes from './TreeSelectVirtualized.module.css';
interface TreeNode {
value: string;
label: string;
children?: TreeNode[];
}
const ITEM_HEIGHT = 36;
function ChevronIcon({ size = 16 }: { size?: number }) {
return (
<svg width={size} height={size} viewBox="0 0 15 15" fill="none" style={{ display: 'block' }}>
<path
d="M3.13523 6.15803C3.3241 5.95657 3.64052 5.94637 3.84197 6.13523L7.5 9.56464L11.158 6.13523C11.3595 5.94637 11.6759 5.95657 11.8648 6.15803C12.0536 6.35949 12.0434 6.67591 11.842 6.86477L7.84197 10.6148C7.64964 10.7951 7.35036 10.7951 7.15803 10.6148L3.15803 6.86477C2.95657 6.67591 2.94637 6.35949 3.13523 6.15803Z"
fill="currentColor"
fillRule="evenodd"
clipRule="evenodd"
/>
</svg>
);
}
interface FlatNode {
node: TreeNode;
level: number;
parent: string | null;
hasChildren: boolean;
expanded: boolean;
}
function flattenTree(
nodes: TreeNode[],
expanded: Record<string, boolean>,
level: number = 1,
parent: string | null = null
): FlatNode[] {
const result: FlatNode[] = [];
nodes.forEach((node) => {
const hasChildren = !!node.children?.length;
const isExpanded = !!expanded[node.value];
result.push({ node, level, parent, hasChildren, expanded: isExpanded });
if (hasChildren && isExpanded) {
result.push(...flattenTree(node.children!, expanded, level + 1, node.value));
}
});
return result;
}
function findLabel(nodes: TreeNode[], value: string): string | null {
for (const node of nodes) {
if (node.value === value) {
return node.label;
}
if (node.children) {
const found = findLabel(node.children, value);
if (found) {
return found;
}
}
}
return null;
}
function generateTreeData(): TreeNode[] {
const categories = [
'Design',
'Engineering',
'Marketing',
'Sales',
'Support',
'Product',
'Legal',
'Finance',
'HR',
'Operations',
'Research',
'QA',
'Security',
'Data',
'Infrastructure',
'Mobile',
'Web',
'Platform',
'Analytics',
'AI',
];
return categories.map((cat, i) => ({
value: `cat-${i}`,
label: cat,
children: Array.from({ length: 5 + (((i * 7 + 3) % 6) | 0) }, (_, j) => {
const hasNested = j < 2;
return {
value: `cat-${i}-${j}`,
label: `${cat} Team ${j + 1}`,
children: hasNested
? Array.from({ length: 3 }, (_, k) => ({
value: `cat-${i}-${j}-${k}`,
label: `${cat} ${j + 1}.${k + 1}`,
}))
: undefined,
};
}),
}));
}
const largeData = generateTreeData();
export function TreeSelectVirtualized() {
const [opened, setOpened] = useState(false);
const [selectedValue, setSelectedValue] = useState<string | null>(null);
const [value, setValue] = useState<string | null>(null);
const [expanded, setExpanded] = useState<Record<string, boolean>>({});
const [scrollParent, setScrollParent] = useState<HTMLDivElement | null>(null);
const toggleExpand = (nodeValue: string) => {
setExpanded((prev) => ({ ...prev, [nodeValue]: !prev[nodeValue] }));
};
const flatNodes = useMemo(() => flattenTree(largeData, expanded), [expanded]);
const activeOptionIndex = value ? flatNodes.findIndex((n) => n.node.value === value) : -1;
const selectedOptionIndex = selectedValue
? flatNodes.findIndex((n) => n.node.value === selectedValue)
: -1;
const virtualizer = useVirtualizer({
count: flatNodes.length,
getScrollElement: () => scrollParent,
estimateSize: () => ITEM_HEIGHT,
overscan: 10,
});
const store = useVirtualizedCombobox({
opened,
onOpenedChange: setOpened,
onDropdownClose: () => setSelectedValue(null),
onDropdownOpen: () => {
if (activeOptionIndex !== -1) {
setSelectedValue(value);
requestAnimationFrame(() => {
virtualizer.scrollToIndex(activeOptionIndex, { align: 'auto' });
});
}
},
totalOptionsCount: flatNodes.length,
getOptionId: (index) => (flatNodes[index] ? `tsv-${flatNodes[index].node.value}` : null),
selectedOptionIndex,
activeOptionIndex,
setSelectedOptionIndex: (index) => {
setSelectedValue(index === -1 ? null : (flatNodes[index]?.node.value ?? null));
if (index !== -1) {
virtualizer.scrollToIndex(index, { align: 'auto' });
}
},
onSelectedOptionSubmit: onOptionSubmit,
});
function onOptionSubmit(index: number) {
const node = flatNodes[index]?.node;
if (!node) {
return;
}
setValue(node.value);
store.closeDropdown();
store.resetSelectedOption();
}
const handleKeyDown = (event: KeyboardEvent) => {
if (!store.dropdownOpened) {
return;
}
const index = store.getSelectedOptionIndex();
if (index < 0 || index >= flatNodes.length) {
return;
}
const current = flatNodes[index];
if (event.key === 'ArrowRight' && current.hasChildren && !current.expanded) {
event.preventDefault();
toggleExpand(current.node.value);
}
if (event.key === 'ArrowLeft') {
if (current.hasChildren && current.expanded) {
event.preventDefault();
toggleExpand(current.node.value);
} else if (current.parent) {
event.preventDefault();
const parentIndex = flatNodes.findIndex((n) => n.node.value === current.parent);
if (parentIndex >= 0) {
store.selectOption(parentIndex);
}
}
}
};
return (
<Combobox store={store} withinPortal={false} resetSelectionOnOptionHover={false} keepMounted>
<Combobox.Target targetType="button">
<InputBase
component="button"
type="button"
pointer
rightSection={<Combobox.Chevron />}
onClick={() => store.toggleDropdown()}
onKeyDown={handleKeyDown}
onBlur={() => store.closeDropdown()}
rightSectionPointerEvents="none"
aria-label="Pick a team"
>
{(value && findLabel(largeData, value)) || (
<Input.Placeholder>Pick a team</Input.Placeholder>
)}
</InputBase>
</Combobox.Target>
<Combobox.Dropdown>
<Combobox.ScrollArea
mah={250}
viewportProps={{ tabIndex: -1 }}
viewportRef={setScrollParent}
onMouseDown={(event) => event.preventDefault()}
>
<Combobox.Options>
<div className={classes.list} style={{ height: virtualizer.getTotalSize() }}>
{virtualizer.getVirtualItems().map((virtualItem) => {
const flatNode = flatNodes[virtualItem.index];
return (
<Combobox.Option
key={flatNode.node.value}
id={`tsv-${flatNode.node.value}`}
value={flatNode.node.value}
active={virtualItem.index === activeOptionIndex}
selected={virtualItem.index === selectedOptionIndex}
onClick={() => onOptionSubmit(virtualItem.index)}
className={classes.option}
mod={{ leaf: !flatNode.hasChildren }}
style={{
'--level': flatNode.level,
height: virtualItem.size,
transform: `translateY(${virtualItem.start}px)`,
}}
>
{flatNode.hasChildren && (
<span
aria-hidden
className={classes.chevron}
data-expanded={flatNode.expanded || undefined}
onClick={(event) => {
event.stopPropagation();
event.preventDefault();
toggleExpand(flatNode.node.value);
}}
onMouseDown={(event) => event.preventDefault()}
>
<ChevronIcon size={16} />
</span>
)}
<span className={classes.label}>{flatNode.node.label}</span>
</Combobox.Option>
);
})}
</div>
</Combobox.Options>
</Combobox.ScrollArea>
</Combobox.Dropdown>
</Combobox>
);
}