mirror of
https://github.com/outline/outline.git
synced 2026-11-20 21:23:06 +03:00
* perf: Virtualize sidebar document trees * fix: Hide empty state while adding a doc and scroll the active row on tree mount * fix: Track scroll margin for sidebar trees that start empty
239 lines
6.0 KiB
TypeScript
239 lines
6.0 KiB
TypeScript
import type { NavigationNode } from "../types";
|
|
import {
|
|
ancestors,
|
|
descendants,
|
|
flattenExpandedTree,
|
|
flattenTree,
|
|
} from "./tree";
|
|
|
|
const buildNode = (
|
|
id: string,
|
|
children: NavigationNode[] = []
|
|
): NavigationNode => ({
|
|
id,
|
|
title: `Title ${id}`,
|
|
url: `/doc/${id}`,
|
|
children,
|
|
});
|
|
|
|
/**
|
|
* Annotates a tree with the `parent` and `depth` fields added at runtime by
|
|
* useCollectionTrees, mirroring how nodes are prepared in the app.
|
|
*/
|
|
const annotate = (
|
|
node: NavigationNode,
|
|
parent: NavigationNode | null = null,
|
|
depth = 0
|
|
): NavigationNode => {
|
|
node.parent = parent;
|
|
node.depth = depth;
|
|
node.children.forEach((child) => annotate(child, node, depth + 1));
|
|
return node;
|
|
};
|
|
|
|
const buildTree = () =>
|
|
buildNode("root", [
|
|
buildNode("a", [buildNode("a1", [buildNode("a1i")]), buildNode("a2")]),
|
|
buildNode("b"),
|
|
]);
|
|
|
|
describe("#flattenTree", () => {
|
|
it("should return all nodes in depth-first order", () => {
|
|
expect(flattenTree(buildTree()).map((node) => node.id)).toEqual([
|
|
"root",
|
|
"a",
|
|
"a1",
|
|
"a1i",
|
|
"a2",
|
|
"b",
|
|
]);
|
|
});
|
|
|
|
it("should return a single node for a leaf", () => {
|
|
expect(flattenTree(buildNode("leaf")).map((node) => node.id)).toEqual([
|
|
"leaf",
|
|
]);
|
|
});
|
|
|
|
it("should tolerate nodes without a children array", () => {
|
|
const node: Partial<NavigationNode> = buildNode("orphan");
|
|
delete node.children;
|
|
|
|
expect(flattenTree(node as NavigationNode).map((n) => n.id)).toEqual([
|
|
"orphan",
|
|
]);
|
|
});
|
|
});
|
|
|
|
describe("#ancestors", () => {
|
|
it("should return ancestors ordered from root to direct parent", () => {
|
|
const root = annotate(buildTree());
|
|
const deepest = root.children[0].children[0].children[0];
|
|
|
|
expect(ancestors(deepest).map((node) => node.id)).toEqual([
|
|
"root",
|
|
"a",
|
|
"a1",
|
|
]);
|
|
});
|
|
|
|
it("should return an empty list for a root node", () => {
|
|
const root = annotate(buildTree());
|
|
expect(ancestors(root)).toEqual([]);
|
|
});
|
|
|
|
it("should return an empty list for a missing node", () => {
|
|
expect(ancestors(null)).toEqual([]);
|
|
});
|
|
|
|
it("should treat nodes without a parent annotation as roots", () => {
|
|
// Nodes straight from the server, e.g. a shared tree, carry no parent.
|
|
expect(ancestors(buildNode("unannotated"))).toEqual([]);
|
|
});
|
|
|
|
it("should not loop forever on a malformed parent cycle", () => {
|
|
const first = buildNode("first");
|
|
const second = buildNode("second");
|
|
first.parent = second;
|
|
second.parent = first;
|
|
|
|
// The node itself is never part of its own ancestors, even when the
|
|
// parent chain cycles back to it.
|
|
expect(ancestors(first).map((node) => node.id)).toEqual(["second"]);
|
|
});
|
|
});
|
|
|
|
describe("#descendants", () => {
|
|
it("should return all descendants by default", () => {
|
|
expect(descendants(buildTree()).map((node) => node.id)).toEqual([
|
|
"a",
|
|
"a1",
|
|
"a1i",
|
|
"a2",
|
|
"b",
|
|
]);
|
|
});
|
|
|
|
it("should limit results to the given depth", () => {
|
|
const root = buildTree();
|
|
|
|
expect(descendants(root, 1).map((node) => node.id)).toEqual(["a", "b"]);
|
|
expect(descendants(root, 2).map((node) => node.id)).toEqual([
|
|
"a",
|
|
"a1",
|
|
"a2",
|
|
"b",
|
|
]);
|
|
});
|
|
|
|
it("should limit by depth relative to the node itself", () => {
|
|
const root = annotate(buildTree());
|
|
const child = root.children[0];
|
|
|
|
expect(descendants(child, 1).map((node) => node.id)).toEqual(["a1", "a2"]);
|
|
});
|
|
|
|
it("should not require depth annotations on nodes", () => {
|
|
// Nodes straight from the server carry no depth annotation.
|
|
expect(descendants(buildTree(), 1).map((node) => node.id)).toEqual([
|
|
"a",
|
|
"b",
|
|
]);
|
|
});
|
|
|
|
it("should return an empty list for a leaf node", () => {
|
|
expect(descendants(buildNode("leaf"))).toEqual([]);
|
|
});
|
|
});
|
|
|
|
describe("#flattenExpandedTree", () => {
|
|
// a
|
|
// ├── b
|
|
// │ ├── c
|
|
// │ └── d
|
|
// └── e
|
|
// f
|
|
const nodes = [
|
|
buildNode("a", [
|
|
buildNode("b", [buildNode("c"), buildNode("d")]),
|
|
buildNode("e"),
|
|
]),
|
|
buildNode("f"),
|
|
];
|
|
|
|
const flatten = (
|
|
expandedIds: string[],
|
|
getChildren?: (node: NavigationNode) => NavigationNode[]
|
|
) =>
|
|
flattenExpandedTree({
|
|
nodes,
|
|
depth: 2,
|
|
parentId: "root",
|
|
isExpanded: (id) => expandedIds.includes(id),
|
|
getChildren,
|
|
});
|
|
|
|
it("should return only the root nodes when nothing is expanded", () => {
|
|
const flattened = flatten([]);
|
|
|
|
expect(flattened.map((item) => item.node.id)).toEqual(["a", "f"]);
|
|
expect(flattened[0]).toMatchObject({
|
|
depth: 2,
|
|
index: 0,
|
|
parentId: "root",
|
|
hasChildren: true,
|
|
});
|
|
expect(flattened[1]).toMatchObject({ index: 1, hasChildren: false });
|
|
});
|
|
|
|
it("should include the children of expanded nodes in display order", () => {
|
|
const flattened = flatten(["a", "b"]);
|
|
|
|
expect(
|
|
flattened.map((item) => [item.node.id, item.depth, item.parentId])
|
|
).toEqual([
|
|
["a", 2, "root"],
|
|
["b", 3, "a"],
|
|
["c", 4, "b"],
|
|
["d", 4, "b"],
|
|
["e", 3, "a"],
|
|
["f", 2, "root"],
|
|
]);
|
|
});
|
|
|
|
it("should skip the children of a collapsed node", () => {
|
|
const flattened = flatten(["b"]);
|
|
|
|
expect(flattened.map((item) => item.node.id)).toEqual(["a", "f"]);
|
|
});
|
|
|
|
it("should give the last child the ancestors that end with it", () => {
|
|
const flattened = flatten(["a", "b"]);
|
|
const trailing = Object.fromEntries(
|
|
flattened.map((item) => [
|
|
item.node.id,
|
|
item.trailingAncestors.map((ancestor) => ancestor.node.id),
|
|
])
|
|
);
|
|
|
|
expect(trailing).toEqual({
|
|
a: [],
|
|
b: [],
|
|
c: [],
|
|
d: ["b"],
|
|
e: ["a"],
|
|
f: [],
|
|
});
|
|
});
|
|
|
|
it("should use the children returned by getChildren", () => {
|
|
const draft = buildNode("draft");
|
|
const flattened = flatten(["f"], (node) =>
|
|
node.id === "f" ? [draft] : node.children
|
|
);
|
|
|
|
expect(flattened.map((item) => item.node.id)).toEqual(["a", "f", "draft"]);
|
|
expect(flattened[1].hasChildren).toBe(true);
|
|
});
|
|
});
|