Fix: Js Recursive Function to Get the Nested (Multilevel) Child Objects as Array of Objects

function getParts(array) {    var result = [];    array.forEach(function iter(group) {        return function ({ id, name, children }, i, { length }) {            if (!group && children.length) {                result.push({ header: name });            }            if (group || !children.length) {                result.push({ name, group: group || name, id });            }            children.forEach(iter(name));            if (!group && i + 1 !== length) {                result.push({ divider: true });            }        };    }(''));    return result;}
var data = [{ id: 1, name: "Electronics", path: "Electronics", children: [{ id: 2, name: "Laptops & PC", path: "Electronics > Laptops & PC", children: [] }, { id: 7, name: "Phones & Accessories", path: "Electronics > Phones & Accessories", children: [{ id: 8, name: "Smartphones", path: "Electronics > Phones & Accessories > Smartphones", children: [{ id: 9, name: "Android", path: "Electronics > Phones & Accessories > Smartphones > Android", children: [] }, { id: 10, name: "iOS", path: "Electronics > Phones & Accessories > Smartphones > iOS", children: [] }] }] }] }, { id: 11, name: "Software", path: "Software", children: [] }, { id: 11, name: "Software", path: "Software", children: [] }, { id: 11, name: "Software", path: "Software", children: [] }],    result = getParts(data);
console.log(result);

.as-console-wrapper { max-height: 100% !important; top: 0; }

Flatten a deeply nested data structure of arrays, objects + strings into a list of data items while mapping the former parent-child relationship too

First of all, I would not be answering if there was not already a good answer. Please, on StackOverflow, always show your own attempts and explain where you got stuck. But since there is already an answer, I think this version might be a bit simpler.

Second, I'm assuming this output format is some sort of directed graph, that the first half is your list of vertices and the second half a list of edges. If so I don't know if your output format is constrained here. But if you had the option, I would think a better structure would be an object with vertices and edges properties, each containing an array. You might then not need the edges' ids. And the code could also be simplified.

This version first converts to an intermediate structure like this:

[
    {id: "1", data: {label: {author: "John Doe", age: 26}}, children: [
        {id: "2", data: {label: "books"}, children: [
            {id: "3", data: {label: {title: "Book 1"}}, children: []}, 
            {id: "4", data: {label: {title: "Book 2"}}, children: [
                {id: "5", data: {label: "chapters"}, children: [
                    {id: "6", data: {label: {title: "No Way Home"}}, children: []}
                ]}
            ]}
        ]}
    ]}
]

Then we flatten that structure into the first section of the output and use it to calculate the relationships (edges?) between nested nodes to go in the second section.

The code looks like this:

const transform = (input) => {
  const extract = (os, nextId = ((id) => () => String (++ id)) (0)) => os .map ((o) => ({
    id: nextId(), 
    data: {label: Object .fromEntries (Object .entries (o) .filter (([k, v]) => !Array .isArray (v)))},
    children: Object .entries (o) .filter (([k, v]) => Array .isArray (v)) .flatMap (([k, v]) => [
      {id: nextId(), data: {label: k}, children: extract (v, nextId)},
    ])
  }))
  
  const relationships = (xs) =>
    xs .flatMap (({id: target, children = []}) => [
      ... children .map (({id: source}) => ({id: `e${source}-${target}`, source, target})),
      ... relationships (children),
    ])
  
  const flatten = (xs) => 
    xs .flatMap (({children, ...rest}) => [rest, ... flatten (children)])
    
  const res = extract (input)
  
  return [...flatten (res), ... relationships (res)] 
}

const input = [{author: "John Doe", age : 26, books: [{title: "Book 1"}, {title: "Book 2", chapters: [{title: "No Way Home", page: 256}]}]}]

console .log (transform (input))

.as-console-wrapper {max-height: 100% !important; top: 0}

var matches = [];
var needle = 100; // what to look for

arr.forEach(function(e) {
    matches = matches.concat(e.Categories.filter(function(c) {
        return (c.Id === needle);
    }));
});

console.log(matches[0] || "Not found");

let input = [ { "PRODUCT_CATEGORY_ID": "1", "NAME": "OTOMOBİL PARÇALARI", "DESCRIPTION": "Araba Parçaları", "ACTIVE": "True", "PARENT_PRODUCT_CATEGORY_ID": "", "children": [ { "PRODUCT_CATEGORY_ID": "3", "NAME": "HONDA PARÇALARI", "DESCRIPTION": "Honda Parçaları", "ACTIVE": "True", "PARENT_PRODUCT_CATEGORY_ID": "1" }, { "PRODUCT_CATEGORY_ID": "4", "NAME": "RENAULT PARÇALARI", "DESCRIPTION": "Renault Parçaları", "ACTIVE": "True", "PARENT_PRODUCT_CATEGORY_ID": "1", "children": [ { "PRODUCT_CATEGORY_ID": "5", "NAME": "MINIMAL RENAULT PARÇALARI", "DESCRIPTION": "", "ACTIVE": "True", "PARENT_PRODUCT_CATEGORY_ID": "4" } ] } ] } ]

function getPaths(obj, property, path = '') {
    const paths = [];
    for(let k in obj) {
        if (typeof(obj[k]) === 'object') {
            paths.push(...getPaths(obj[k], property, path));
        } else if (k === property) {
            path += (path ? ' > ' : '') + obj[k];
            paths.push(path)
        }
    }
    return paths;
}

console.log('Paths:', getPaths(input, 'NAME'))

function ListItem({ item }) {
  let children = null;
  if (item.values) {
    children = (
      <ul>
        {item.values.map(i => <ListItem item={i} key={i.id} />)}
      </ul>
    );
  }

  return (
    <li>
      {item.name}
      {children}
    </li>
  );
}