Open source website builder and Webflow alternative. Webstudio is an advanced visual builder that connects to any headless CMS, supports all CSS properties, and can be hosted anywhere, including with us.
TypeScript accessibilityalternativecloudflarecloudflare-workersdesignfreefrontendopen-sourceradix-uireactremixweb-developmentwebflowwebsite-builderwebsite-developmentwebsiteswebstudio
import { useMemo, useState } from "react";
import { EllipsesIcon, DotIcon } from "@webstudio-is/icons";
import { SmallIconButton } from "./small-icon-button";
import { Box } from "./box";
import {
TreeRoot,
TreeNode,
TreeNodeLabel,
TreeSortableItem,
type TreeDropTarget,
} from "./tree";
import { StorySection } from "./storybook";
export default {
title: "Tree",
};
type Node = {
name: string;
children: Node[];
};
type FlatNode = {
name: string;
selector: string[];
level: number;
isExpanded?: boolean;
isLastChild: boolean;
dropTarget?: TreeDropTarget;
};
const findNode = (data: Node, name?: string) => {
let matched: undefined | Node;
const traverse = (node: Node) => {
if (node.name === name) {
matched = node;
return;
}
for (const child of node.children) {
traverse(child);
}
};
traverse(data);
return matched;
};
const move = ({
data,
sourceParentName,
sourceName,
dropTarget,
}: {
data: Node;
sourceParentName: string;
sourceName: string;
dropTarget: DropTarget;
}) => {
const newData = structuredClone(data);
const sourceParentNode = findNode(newData, sourceParentName);
const sourceNode = findNode(newData, sourceName);
const targetParentNode = findNode(newData, dropTarget.parentName);
const targetBeforeNode = findNode(newData, dropTarget.beforeName);
const targetAfterNode = findNode(newData, dropTarget.afterName);
if (sourceParentNode && sourceNode) {
const index = sourceParentNode.children.indexOf(sourceNode);
sourceParentNode.children.splice(index, 1);
}
if (targetParentNode && sourceNode) {
if (targetBeforeNode) {
const index = targetParentNode.children.indexOf(targetBeforeNode);
targetParentNode.children.splice(index, 0, sourceNode);
} else if (targetAfterNode) {
const index = targetParentNode.children.indexOf(targetAfterNode) + 1;
targetParentNode.children.splice(index, 0, sourceNode);
} else {
targetParentNode.children.push(sourceNode);
}
}
return newData;
};
const initialData: Node = {
name: "Root",
children: Array.from(Array(10)).map((_, index) => ({
name: `Parent ${index + 1}`,
children: [
{
name: `Box ${index + 1}.1`,
children: [
{ name: `Box ${index + 1}.2`, children: [] },
{ name: `Container ${index + 1}.1`, children: [] },
{ name: `Wrapper ${index + 1}.1`, children: [] },
],
},
{
name: `Container ${index + 1}.2`,
children: [
{ name: `Box ${index + 1}.3`, children: [] },
{ name: `Container ${index + 1}.3`, children: [] },
{ name: `Wrapper ${index + 1}.2`, children: [] },
],
},
{
name: `Wrapper ${index + 1}.3`,
children: [
{ name: `Box ${index + 1}.4`, children: [] },
{ name: `Container ${index + 1}.4`, children: [] },
{ name: `Wrapper ${index + 1}.4`, children: [] },
],
},
],
})),
};
type DropTarget = {
parentName: string;
beforeName?: string;
afterName?: string;
};
const getStoriesDropTarget = (
node: FlatNode,
dropTarget: undefined | TreeDropTarget
): undefined | DropTarget => {
if (dropTarget === undefined) {
return;
}
const parentName = node.selector.at(-dropTarget.parentLevel - 1);
const beforeName =
dropTarget.beforeLevel === undefined
? undefined
: node.selector.at(-dropTarget.beforeLevel - 1);
const afterName =
dropTarget.afterLevel === undefined
? undefined
: node.selector.at(-dropTarget.afterLevel - 1);
if (parentName) {
return { parentName, beforeName, afterName };
}
};
export const Tree = () => {
const [selectedItemId, setSelectedItemId] = useState("");
const [expandedItems, setExpandedItems] = useState(new Set<string>());
const [data, setData] = useState(initialData);
const [dropTarget, setDropTarget] = useState<undefined | DropTarget>();
const flatTree = useMemo(() => {
const flatTree: FlatNode[] = [];
const traverse = (
node: Node,
selector: string[],
isLastChild = false,
level = 0
) => {
let isExpanded;
if (level > 0 && node.children.length > 0) {
isExpanded = expandedItems.has(node.name);
}
// hide root folder
const flatNode: FlatNode = {
name: node.name,
selector,
level,
isExpanded,
isLastChild,
};
flatTree.push(flatNode);
let lastFlatNode = flatNode;
if (level === 0 || isExpanded) {
for (const child of node.children) {
const isLastChild = node.children.at(-1) === child;
lastFlatNode = traverse(
child,
[child.name, ...selector],
isLastChild,
level + 1
);
}
}
if (dropTarget?.beforeName === node.name) {
flatNode.dropTarget = {
parentLevel: level - 1,
beforeLevel: level,
};
}
if (dropTarget?.afterName === node.name) {
lastFlatNode.dropTarget = {
parentLevel: level - 1,
afterLevel: level,
};
}
return lastFlatNode;
};
traverse(data, [data.name], false);
return flatTree;
}, [data, expandedItems, dropTarget]);
return (
<>
<StorySection title="Interactive">
<Box css={{ maxWidth: 300 }}>
<TreeRoot>
{flatTree.map((node) => {
const handleExpand = (isExpanded: boolean) => {
setExpandedItems((prevExpandedItems) => {
const newExpandedItems = new Set(prevExpandedItems);
if (isExpanded) {
newExpandedItems.add(node.name);
} else {
newExpandedItems.delete(node.name);
}
return newExpandedItems;
});
};
return (
<TreeSortableItem
key={node.name}
level={node.level}
isExpanded={node.isExpanded}
isLastChild={node.isLastChild}
data={node}
// prevent dragging root
canDrag={() => node.level > 0}
onExpand={handleExpand}
dropTarget={node.dropTarget}
onDropTargetChange={(dropTarget) => {
// prevent dropping into toplevel
if (dropTarget && dropTarget.parentLevel > 0) {
setDropTarget(getStoriesDropTarget(node, dropTarget));
} else {
setDropTarget(undefined);
}
}}
onDrop={(sourceNode) => {
if (dropTarget) {
setData((data) =>
move({
data,
sourceParentName: sourceNode.selector[1],
sourceName: sourceNode.selector[0],
dropTarget,
})
);
}
setDropTarget(undefined);
}}
>
<TreeNode
level={node.level}
isSelected={node.name === selectedItemId}
isHighlighted={dropTarget?.parentName === node.name}
isExpanded={node.isExpanded}
onExpand={handleExpand}
buttonProps={{
onFocus: () => {
setSelectedItemId(node.name);
},
onClick: () => {
setSelectedItemId(node.name);
},
}}
action={
<SmallIconButton tabIndex={-1} icon={<EllipsesIcon />} />
}
>
<TreeNodeLabel>{node.name}</TreeNodeLabel>
</TreeNode>
</TreeSortableItem>
);
})}
</TreeRoot>
</Box>
</StorySection>
<StorySection title="Static nodes">
<div style={{ maxWidth: 300 }}>
<TreeRoot>
<TreeNode
level={0}
isSelected={false}
isExpanded={true}
onExpand={() => {}}
buttonProps={{}}
action={<SmallIconButton tabIndex={-1} icon={<EllipsesIcon />} />}
>
<TreeNodeLabel>Root node</TreeNodeLabel>
</TreeNode>
<TreeNode
level={1}
isSelected={true}
isExpanded={undefined}
isActionVisible
buttonProps={{}}
action={<SmallIconButton tabIndex={-1} icon={<EllipsesIcon />} />}
>
<TreeNodeLabel prefix={<DotIcon />}>
With prefix and action visible
</TreeNodeLabel>
</TreeNode>
<TreeNode
level={2}
isSelected={false}
isSelectedDescendant
isExpanded={undefined}
buttonProps={{}}
action={<SmallIconButton tabIndex={-1} icon={<EllipsesIcon />} />}
>
<TreeNodeLabel>Selected descendant node</TreeNodeLabel>
</TreeNode>
<TreeNode
level={1}
tabbable
isSelected={false}
isExpanded={false}
onExpand={() => {}}
buttonProps={{}}
action={<SmallIconButton tabIndex={-1} icon={<EllipsesIcon />} />}
>
<TreeNodeLabel>Tabbable collapsed node</TreeNodeLabel>
</TreeNode>
<TreeNode
level={1}
isSelected={false}
isHighlighted
isExpanded={undefined}
buttonProps={{}}
action={<SmallIconButton tabIndex={-1} icon={<EllipsesIcon />} />}
>
<TreeNodeLabel>Highlighted node</TreeNodeLabel>
</TreeNode>
</TreeRoot>
</div>
</StorySection>
</>
);
};