Merge branch 'master' of git.curoverse.com:arvados-workbench2 into 14528_advance_tab_...
[arvados.git] / src / models / tree.ts
1 // Copyright (C) The Arvados Authors. All rights reserved.
2 //
3 // SPDX-License-Identifier: AGPL-3.0
4
5 import { pipe, map, reduce } from 'lodash/fp';
6 export type Tree<T> = Record<string, TreeNode<T>>;
7
8 export const TREE_ROOT_ID = '';
9
10 export interface TreeNode<T = any> {
11     children: string[];
12     value: T;
13     id: string;
14     parent: string;
15     active: boolean;
16     selected: boolean;
17     expanded: boolean;
18     status: TreeNodeStatus;
19 }
20
21 export enum TreeNodeStatus {
22     INITIAL = 'INITIAL',
23     PENDING = 'PENDING',
24     LOADED = 'LOADED',
25 }
26
27 export enum TreePickerId {
28     PROJECTS = 'Projects',
29     SHARED_WITH_ME = 'Shared with me',
30     FAVORITES = 'Favorites'
31 }
32
33 export const createTree = <T>(): Tree<T> => ({});
34
35 export const getNode = (id: string) => <T>(tree: Tree<T>): TreeNode<T> | undefined => tree[id];
36
37 export const appendSubtree = <T>(id: string, subtree: Tree<T>) => (tree: Tree<T>) =>
38     pipe(
39         getNodeDescendants(''),
40         map(node => node.parent === '' ? { ...node, parent: id } : node),
41         reduce((newTree, node) => setNode(node)(newTree), tree)
42     )(subtree) as Tree<T>;
43
44 export const setNode = <T>(node: TreeNode<T>) => (tree: Tree<T>): Tree<T> => {
45     return pipe(
46         (tree: Tree<T>) => getNode(node.id)(tree) === node
47             ? tree
48             : { ...tree, [node.id]: node },
49         addChild(node.parent, node.id)
50     )(tree);
51 };
52
53 export const getNodeValue = (id: string) => <T>(tree: Tree<T>) => {
54     const node = getNode(id)(tree);
55     return node ? node.value : undefined;
56 };
57
58 export const setNodeValue = (id: string) => <T>(value: T) => (tree: Tree<T>) => {
59     const node = getNode(id)(tree);
60     return node
61         ? setNode(mapNodeValue(() => value)(node))(tree)
62         : tree;
63 };
64
65 export const setNodeValueWith = <T>(mapFn: (value: T) => T) => (id: string) => (tree: Tree<T>) => {
66     const node = getNode(id)(tree);
67     return node
68         ? setNode(mapNodeValue(mapFn)(node))(tree)
69         : tree;
70 };
71
72 export const mapTreeValues = <T, R>(mapFn: (value: T) => R) => (tree: Tree<T>): Tree<R> =>
73     getNodeDescendantsIds('')(tree)
74         .map(id => getNode(id)(tree))
75         .map(mapNodeValue(mapFn))
76         .reduce((newTree, node) => setNode(node)(newTree), createTree<R>());
77
78 export const mapTree = <T, R = T>(mapFn: (node: TreeNode<T>) => TreeNode<R>) => (tree: Tree<T>): Tree<R> =>
79     getNodeDescendantsIds('')(tree)
80         .map(id => getNode(id)(tree))
81         .map(mapFn)
82         .reduce((newTree, node) => setNode(node)(newTree), createTree<R>());
83
84 export const getNodeAncestors = (id: string) => <T>(tree: Tree<T>) =>
85     mapIdsToNodes(getNodeAncestorsIds(id)(tree))(tree);
86
87
88 export const getNodeAncestorsIds = (id: string) => <T>(tree: Tree<T>): string[] => {
89     const node = getNode(id)(tree);
90     return node && node.parent
91         ? [...getNodeAncestorsIds(node.parent)(tree), node.parent]
92         : [];
93 };
94
95 export const getNodeDescendants = (id: string, limit = Infinity) => <T>(tree: Tree<T>) =>
96     mapIdsToNodes(getNodeDescendantsIds(id, limit)(tree))(tree);
97
98 export const countNodes = <T>(tree: Tree<T>) =>
99     getNodeDescendantsIds('')(tree).length;
100
101 export const countChildren = (id: string) => <T>(tree: Tree<T>) =>
102     getNodeChildren('')(tree).length;
103
104 export const getNodeDescendantsIds = (id: string, limit = Infinity) => <T>(tree: Tree<T>): string[] => {
105     const node = getNode(id)(tree);
106     const children = node ? node.children :
107         id === TREE_ROOT_ID
108             ? getRootNodeChildrenIds(tree)
109             : [];
110
111     return children
112         .concat(limit < 1
113             ? []
114             : children
115                 .map(id => getNodeDescendantsIds(id, limit - 1)(tree))
116                 .reduce((nodes, nodeChildren) => [...nodes, ...nodeChildren], []));
117 };
118
119 export const getNodeChildren = (id: string) => <T>(tree: Tree<T>) =>
120     mapIdsToNodes(getNodeChildrenIds(id)(tree))(tree);
121
122 export const getNodeChildrenIds = (id: string) => <T>(tree: Tree<T>): string[] =>
123     getNodeDescendantsIds(id, 0)(tree);
124
125 export const mapIdsToNodes = (ids: string[]) => <T>(tree: Tree<T>) =>
126     ids.map(id => getNode(id)(tree)).filter((node): node is TreeNode<T> => node !== undefined);
127
128 export const activateNode = (id: string) => <T>(tree: Tree<T>) =>
129     mapTree((node: TreeNode<T>) => node.id === id ? { ...node, active: true } : { ...node, active: false })(tree);
130
131 export const deactivateNode = <T>(tree: Tree<T>) =>
132     mapTree((node: TreeNode<T>) => node.active ? { ...node, active: false } : node)(tree);
133
134 export const expandNode = (...ids: string[]) => <T>(tree: Tree<T>) =>
135     mapTree((node: TreeNode<T>) => ids.some(id => id === node.id) ? { ...node, expanded: true } : node)(tree);
136
137 export const collapseNode = (...ids: string[]) => <T>(tree: Tree<T>) =>
138     mapTree((node: TreeNode<T>) => ids.some(id => id === node.id) ? { ...node, expanded: false } : node)(tree);
139
140 export const toggleNodeCollapse = (...ids: string[]) => <T>(tree: Tree<T>) =>
141     mapTree((node: TreeNode<T>) => ids.some(id => id === node.id) ? { ...node, expanded: !node.expanded } : node)(tree);
142
143 export const setNodeStatus = (id: string) => (status: TreeNodeStatus) => <T>(tree: Tree<T>) => {
144     const node = getNode(id)(tree);
145     return node
146         ? setNode({ ...node, status })(tree)
147         : tree;
148 };
149
150 export const toggleNodeSelection = (id: string) => <T>(tree: Tree<T>) => {
151     const node = getNode(id)(tree);
152     return node
153         ? pipe(
154             setNode({ ...node, selected: !node.selected }),
155             toggleAncestorsSelection(id),
156             toggleDescendantsSelection(id))(tree)
157         : tree;
158
159 };
160
161 export const selectNode = (id: string) => <T>(tree: Tree<T>) => {
162     const node = getNode(id)(tree);
163     return node && node.selected
164         ? tree
165         : toggleNodeSelection(id)(tree);
166 };
167
168 export const selectNodes = (id: string | string[]) => <T>(tree: Tree<T>) => {
169     const ids = typeof id === 'string' ? [id] : id;
170     return ids.reduce((tree, id) => selectNode(id)(tree), tree);
171 };
172 export const deselectNode = (id: string) => <T>(tree: Tree<T>) => {
173     const node = getNode(id)(tree);
174     return node && node.selected
175         ? toggleNodeSelection(id)(tree)
176         : tree;
177 };
178
179 export const deselectNodes = (id: string | string[]) => <T>(tree: Tree<T>) => {
180     const ids = typeof id === 'string' ? [id] : id;
181     return ids.reduce((tree, id) => deselectNode(id)(tree), tree);
182 };
183
184 export const getSelectedNodes = <T>(tree: Tree<T>) =>
185     getNodeDescendants('')(tree)
186         .filter(node => node.selected);
187
188 export const initTreeNode = <T>(data: Pick<TreeNode<T>, 'id' | 'value'> & { parent?: string }): TreeNode<T> => ({
189     children: [],
190     active: false,
191     selected: false,
192     expanded: false,
193     status: TreeNodeStatus.INITIAL,
194     parent: '',
195     ...data,
196 });
197
198 const toggleDescendantsSelection = (id: string) => <T>(tree: Tree<T>) => {
199     const node = getNode(id)(tree);
200     if (node) {
201         return getNodeDescendants(id)(tree)
202             .reduce((newTree, subNode) =>
203                 setNode({ ...subNode, selected: node.selected })(newTree),
204                 tree);
205     }
206     return tree;
207 };
208
209 const toggleAncestorsSelection = (id: string) => <T>(tree: Tree<T>) => {
210     const ancestors = getNodeAncestorsIds(id)(tree).reverse();
211     return ancestors.reduce((newTree, parent) => parent ? toggleParentNodeSelection(parent)(newTree) : newTree, tree);
212 };
213
214 const toggleParentNodeSelection = (id: string) => <T>(tree: Tree<T>) => {
215     const node = getNode(id)(tree);
216     if (node) {
217         const parentNode = getNode(node.id)(tree);
218         if (parentNode) {
219             const selected = parentNode.children
220                 .map(id => getNode(id)(tree))
221                 .every(node => node !== undefined && node.selected);
222             return setNode({ ...parentNode, selected })(tree);
223         }
224         return setNode(node)(tree);
225     }
226     return tree;
227 };
228
229
230 const mapNodeValue = <T, R>(mapFn: (value: T) => R) => (node: TreeNode<T>): TreeNode<R> =>
231     ({ ...node, value: mapFn(node.value) });
232
233 const getRootNodeChildrenIds = <T>(tree: Tree<T>) =>
234     Object
235         .keys(tree)
236         .filter(id => getNode(id)(tree)!.parent === TREE_ROOT_ID);
237
238
239 const addChild = (parentId: string, childId: string) => <T>(tree: Tree<T>): Tree<T> => {
240     const node = getNode(parentId)(tree);
241     if (node) {
242         const children = node.children.some(id => id === childId)
243             ? node.children
244             : [...node.children, childId];
245
246         const newNode = children === node.children
247             ? node
248             : { ...node, children };
249
250         return setNode(newNode)(tree);
251     }
252     return tree;
253 };