Assign ownership to many libs files (#6928)

Assign ownership to many of the remaining libs/common files.

Criteria for ownership:
* Files used by a single team, is now owned by that team.
* Files related to a domain owned by a team is now owned by that team.
* Where ownership is unclear the "lowest level" service takes ownership.

libs/common/src/vault/service-utils.ts

@@ -0,0 +1,117 @@
+import { ITreeNodeObject, TreeNode } from "./models/domain/tree-node";
+
+export class ServiceUtils {
+  /**
+   * Recursively adds a node to nodeTree
+   * @param {TreeNode<ITreeNodeObject>[]} nodeTree - An array of TreeNodes that the node will be added to
+   * @param {number} partIndex - Index of the `parts` array that is being processed
+   * @param {string[]} parts - Array of strings that represent the path to the `obj` node
+   * @param {ITreeNodeObject} obj - The node to be added to the tree
+   * @param {ITreeNodeObject} parent - The parent node of the `obj` node
+   * @param {string} delimiter - The delimiter used to split the path string, will be used to combine the path for missing nodes
+   */
+  static nestedTraverse(
+    nodeTree: TreeNode<ITreeNodeObject>[],
+    partIndex: number,
+    parts: string[],
+    obj: ITreeNodeObject,
+    parent: TreeNode<ITreeNodeObject> | undefined,
+    delimiter: string
+  ) {
+    if (parts.length <= partIndex) {
+      return;
+    }
+
+    const end: boolean = partIndex === parts.length - 1;
+    const partName: string = parts[partIndex];
+
+    for (let i = 0; i < nodeTree.length; i++) {
+      if (nodeTree[i].node.name !== partName) {
+        continue;
+      }
+      if (end && nodeTree[i].node.id !== obj.id) {
+        // Another node exists with the same name as the node being added
+        nodeTree.push(new TreeNode(obj, parent, partName));
+        return;
+      }
+      // Move down the tree to the next level
+      ServiceUtils.nestedTraverse(
+        nodeTree[i].children,
+        partIndex + 1,
+        parts,
+        obj,
+        nodeTree[i],
+        delimiter
+      );
+      return;
+    }
+
+    // If there's no node here with the same name...
+    if (nodeTree.filter((n) => n.node.name === partName).length === 0) {
+      // And we're at the end of the path given, add the node
+      if (end) {
+        nodeTree.push(new TreeNode(obj, parent, partName));
+        return;
+      }
+      // And we're not at the end of the path, combine the current name with the next name
+      // 1, *1.2, 1.2.1 becomes
+      // 1, *1.2/1.2.1
+      const newPartName = partName + delimiter + parts[partIndex + 1];
+      ServiceUtils.nestedTraverse(
+        nodeTree,
+        0,
+        [newPartName, ...parts.slice(partIndex + 2)],
+        obj,
+        parent,
+        delimiter
+      );
+    }
+  }
+
+  /**
+   * Searches a tree for a node with a matching `id`
+   * @param {TreeNode<T>} nodeTree - A single TreeNode branch that will be searched
+   * @param {string} id - The id of the node to be found
+   * @returns {TreeNode<T>} The node with a matching `id`
+   */
+  static getTreeNodeObject<T extends ITreeNodeObject>(
+    nodeTree: TreeNode<T>,
+    id: string
+  ): TreeNode<T> {
+    if (nodeTree.node.id === id) {
+      return nodeTree;
+    }
+    for (let i = 0; i < nodeTree.children.length; i++) {
+      if (nodeTree.children[i].children != null) {
+        const node = ServiceUtils.getTreeNodeObject(nodeTree.children[i], id);
+        if (node !== null) {
+          return node;
+        }
+      }
+    }
+    return null;
+  }
+
+  /**
+   * Searches an array of tree nodes for a node with a matching `id`
+   * @param {TreeNode<T>} nodeTree - An array of TreeNode branches that will be searched
+   * @param {string} id - The id of the node to be found
+   * @returns {TreeNode<T>} The node with a matching `id`
+   */
+  static getTreeNodeObjectFromList<T extends ITreeNodeObject>(
+    nodeTree: TreeNode<T>[],
+    id: string
+  ): TreeNode<T> {
+    for (let i = 0; i < nodeTree.length; i++) {
+      if (nodeTree[i].node.id === id) {
+        return nodeTree[i];
+      } else if (nodeTree[i].children != null) {
+        const node = ServiceUtils.getTreeNodeObjectFromList(nodeTree[i].children, id);
+        if (node !== null) {
+          return node;
+        }
+      }
+    }
+    return null;
+  }
+}