How to modify tree object by property?

Question

I have an object with type:

export interface TreeNode extends ITreeNode {
   name: string,
   children:  TreeNode[],
   show?: boolean;
}

I need to reduce this object by property show and return a new tree where show is true or undefined.

I have tried this:

  function prepareNodes(source: TreeNode) {
        if (source.show!== undefined || source.show == false) delete source;
      if (source.children) {
        source.children.forEach((child: TreeNode) => {
          this.prepareNodes(child);
        });
      }
  }

Also I tried:

function prepareNodes(source: any) {
      if (source.show !== undefined && source.show === false) source = null;
      if (source.children) {
        source.children = source.children.filter((child: any) => child.show== undefined || child.show === true);
        source.children.forEach((child: any) => prepareNodes(child));
      }
  }

Answer 1

Currently my assumption is that you want to produce a new tree containing just those nodes of the original tree where the show property is either true or undefined for that node and all ancestor nodes. So if show is false on any node, the output tree will not contain that node or any subtree of that node.

I also assume that it's possible for the root node to have show of false, in which case the whole tree might end up undefined. You can't set modify an object to become undefined; you can change its contents, but you can't delete it. So I'm not going to present anything that tries to modify the original tree. I won't touch the original tree. Instead I will produce a completely new tree.

Here goes:

const defined = <T,>(x: T | undefined): x is T => typeof x !== "undefined";

function filterTree(source: TreeNode): TreeNode | undefined {
  if (source.show === false) return;
  return {
    name: source.name,
    show: source.show,
    children: source.children.map(filterTree).filter(defined)
  }
}

The filterTree() function will return undefined if the argument node's show property is exactly false (and not undefined). Otherwise, it produces a new node with the same name and show, and whose children property is what you get when you call filterTree() (recursively) on each of the original node's children, and then filter out any undefined nodes.

I'm using a user-defined type guard function called defined to let the compiler know that the filtering takes an array of TreeNode | undefined and produces an array of TreeNode, eliminating any undefined entries.

Hopefully this meets your use cases; please test it out on whatever data you have and check, because the question unfortunately did not include such data.

Playground link to code