mirror of
https://github.com/outline/outline.git
synced 2026-11-22 14:01:41 +03:00
160 lines
4.6 KiB
TypeScript
160 lines
4.6 KiB
TypeScript
import { NavigationNodeType, type NavigationNode } from "../types";
|
|
import {
|
|
filterNavigationNodes,
|
|
findNavigationNode,
|
|
insertNavigationNode,
|
|
moveNavigationNode,
|
|
removeNavigationNode,
|
|
updateNavigationNode,
|
|
} from "./collections";
|
|
|
|
const node = (id: string, children: NavigationNode[] = []): NavigationNode => ({
|
|
id,
|
|
title: id,
|
|
url: `/doc/${id}`,
|
|
children,
|
|
});
|
|
|
|
const link = (id: string): NavigationNode => ({
|
|
...node(id),
|
|
type: NavigationNodeType.Link,
|
|
url: "https://example.com",
|
|
});
|
|
|
|
const ids = (nodes: NavigationNode[] | undefined): unknown =>
|
|
nodes?.map((n) => (n.children.length ? [n.id, ids(n.children)] : n.id));
|
|
|
|
describe("moveNavigationNode", () => {
|
|
const tree = [node("a", [node("a1"), link("l2")]), link("l1"), node("b")];
|
|
|
|
it("should move a node down within the same parent", () => {
|
|
expect(ids(moveNavigationNode(tree, "l1", undefined, 3))).toEqual([
|
|
["a", ["a1", "l2"]],
|
|
"b",
|
|
"l1",
|
|
]);
|
|
});
|
|
|
|
it("should move a node up within the same parent", () => {
|
|
expect(ids(moveNavigationNode(tree, "b", undefined, 0))).toEqual([
|
|
"b",
|
|
["a", ["a1", "l2"]],
|
|
"l1",
|
|
]);
|
|
});
|
|
|
|
it("should move a node to another parent", () => {
|
|
expect(ids(moveNavigationNode(tree, "l1", "a", 1))).toEqual([
|
|
["a", ["a1", "l1", "l2"]],
|
|
"b",
|
|
]);
|
|
});
|
|
|
|
it("should move a nested node to the root", () => {
|
|
expect(ids(moveNavigationNode(tree, "l2", undefined, 1))).toEqual([
|
|
["a", ["a1"]],
|
|
"l2",
|
|
"l1",
|
|
"b",
|
|
]);
|
|
});
|
|
|
|
it("should append when no index is given", () => {
|
|
expect(ids(moveNavigationNode(tree, "l1", "b"))).toEqual([
|
|
["a", ["a1", "l2"]],
|
|
["b", ["l1"]],
|
|
]);
|
|
});
|
|
|
|
it("should return undefined when the node or parent is missing", () => {
|
|
expect(moveNavigationNode(tree, "missing", undefined, 0)).toBeUndefined();
|
|
expect(moveNavigationNode(tree, "l1", "missing", 0)).toBeUndefined();
|
|
});
|
|
|
|
it("should not mutate the input", () => {
|
|
moveNavigationNode(tree, "l2", undefined, 0);
|
|
expect(ids(tree)).toEqual([["a", ["a1", "l2"]], "l1", "b"]);
|
|
});
|
|
});
|
|
|
|
describe("insertNavigationNode", () => {
|
|
const tree = [node("a", [node("a1")]), node("b")];
|
|
|
|
it("should insert at the given index", () => {
|
|
expect(ids(insertNavigationNode(tree, link("l"), undefined, 1))).toEqual([
|
|
["a", ["a1"]],
|
|
"l",
|
|
"b",
|
|
]);
|
|
});
|
|
|
|
it("should insert below a parent, at the end by default", () => {
|
|
expect(ids(insertNavigationNode(tree, link("l"), "a"))).toEqual([
|
|
["a", ["a1", "l"]],
|
|
"b",
|
|
]);
|
|
});
|
|
|
|
it("should return undefined when the parent is missing", () => {
|
|
expect(insertNavigationNode(tree, link("l"), "missing")).toBeUndefined();
|
|
});
|
|
});
|
|
|
|
describe("findNavigationNode", () => {
|
|
const tree = [node("a", [node("a1"), link("l2")]), link("l1")];
|
|
|
|
it("should return the node and its parent id", () => {
|
|
expect(findNavigationNode(tree, "l2")?.parentId).toBe("a");
|
|
expect(findNavigationNode(tree, "l1")?.parentId).toBeUndefined();
|
|
expect(findNavigationNode(tree, "missing")).toBeUndefined();
|
|
});
|
|
});
|
|
|
|
describe("updateNavigationNode", () => {
|
|
const tree = [node("a", [node("a1"), link("l2")]), node("b")];
|
|
|
|
it("should replace the node and keep unchanged subtrees", () => {
|
|
const result = updateNavigationNode(tree, "l2", (n) => ({
|
|
...n,
|
|
title: "Updated",
|
|
}));
|
|
expect(result?.[0].children[1].title).toBe("Updated");
|
|
expect(result?.[1]).toBe(tree[1]);
|
|
});
|
|
|
|
it("should return undefined when the node is missing", () => {
|
|
expect(updateNavigationNode(tree, "missing", (n) => n)).toBeUndefined();
|
|
});
|
|
});
|
|
|
|
describe("removeNavigationNode", () => {
|
|
const tree = [node("a", [node("a1"), link("l2")]), node("b")];
|
|
|
|
it("should remove the node and return its position", () => {
|
|
const result = removeNavigationNode(tree, "l2");
|
|
expect(ids(result?.nodes)).toEqual([["a", ["a1"]], "b"]);
|
|
expect(result?.parentId).toBe("a");
|
|
expect(result?.index).toBe(1);
|
|
expect(result?.nodes[1]).toBe(tree[1]);
|
|
});
|
|
});
|
|
|
|
describe("filterNavigationNodes", () => {
|
|
it("should remove links at every depth and keep unchanged nodes", () => {
|
|
const tree = [node("a", [node("a1"), link("l2")]), link("l1"), node("b")];
|
|
const result = filterNavigationNodes(
|
|
tree,
|
|
(n) => n.type !== NavigationNodeType.Link
|
|
);
|
|
expect(ids(result)).toEqual([["a", ["a1"]], "b"]);
|
|
expect(result[1]).toBe(tree[2]);
|
|
});
|
|
|
|
it("should return the same array when nothing is removed", () => {
|
|
const tree = [node("a", [node("a1")])];
|
|
expect(
|
|
filterNavigationNodes(tree, (n) => n.type !== NavigationNodeType.Link)
|
|
).toBe(tree);
|
|
});
|
|
});
|