root
                         /      \
                        A        B
                       / \      / \
                      C   D    E   F
                    / \ \
                   G  H  I

getLevel(level = 0) {
    if (this.children.length === 0) {
        return level;
    }
    for (let child of this.children) {
        level = child.getLevel(level + 1);
    }
}

class Node {
    constructor(name, ...children) {
        this.name = name;
        this.children = children;
    }
    getDepth(name) {
        if (this.name == name) return 0;
        for (const child of this.children) {
            const level = child.getDepth(name);
            if (level >= 0) return level + 1;
        }
        return -1; // Not found here
    }
}
// Build the example tree
const root = new Node("root",
    new Node("A",
        new Node("C",
            new Node("G"),
            new Node("H"),
            new Node("I")
        ),
        new Node("D")
    ),
    new Node("B",
        new Node("E"),
        new Node("F")
    )
);
const level = root.getDepth("C");
console.log(level); // 2

class Node {
    constructor(name, ...children) {
        this.name = name;
        this.children = children;
    }
    getDepthWithRespectTo(root) {
        if (this === root) return 0;
        for (const parent of root.children) {
            const level = this.getDepthWithRespectTo(parent);
            if (level >= 0) return level + 1;
        }
        return -1; // Not found here
    }
}
// Build the example tree, and keep a reference to node "C"
let node;
const root = new Node("root",
    new Node("A",
        node = new Node("C",
            new Node("G"),
            new Node("H"),
            new Node("I")
        ),
        new Node("D")
    ),
    new Node("B",
        new Node("E"),
        new Node("F")
    )
);
const level = node.getDepthWithRespectTo(root);
console.log(level); // 2

function setDepth(node, depth) {
    node.depth = depth
    for (let c of node.children)
        setDepth(c, depth + 1)
}
setDepth(root, 0)

    class TreeNode {
      constructor(value) {
        this.value = value;
        this.children = [];
      }
    
      addChild(child) {
        this.children.push(child);
      }
    }
    
    function calculateNodeLevel(root, targetValue) {
      if (root.value === targetValue) {
        return 0; // Found the target node at the root level
      }
    
      for (let child of root.children) {
        const level = calculateNodeLevel(child, targetValue);
        if (level !== -1) {
          return level + 1; // Found the target node in a child subtree
        }
      }
    
      return -1; // Target node not found in the tree
    }
    
    // Example usage:
    const tree = new TreeNode(1);
    const child1 = new TreeNode(2);
    const child2 = new TreeNode(3);
    const grandchild = new TreeNode(4);
    child2.addChild(grandchild);
    tree.addChild(child1);
    tree.addChild(child2);
    
    console.log(calculateNodeLevel(tree, 1)); // Output: 0
    console.log(calculateNodeLevel(tree, 2)); // Output: 1
    console.log(calculateNodeLevel(tree, 3)); // Output: 1
    console.log(calculateNodeLevel(tree, 4)); // Output: 2
    console.log(calculateNodeLevel(tree, 5)); // Output: -1 (Node not found)
In this example, the TreeNode class represents a node in the tree, and it has a value property to store the value of the node and a children array to store its child nodes.
The calculateNodeLevel function takes a root node and a targetValue as input. It recursively traverses the tree starting from the root and checks if the value of each node matches the targetValue. If a match is found, it returns the level of that node (0 for the root level, 1 for its children, and so on). If the targetValue is not found in the tree, it returns -1.
In the example usage section, a simple tree is created, and the calculateNodeLevel function is called with different target values to demonstrate its usage and output.