Flatten dependency tree

flatten.js

function flattenDependencies(dependencies) {
    let nodeSet = {};
    Object.keys(dependencies).forEach(node => nodeSet[node] = true);
    Object.values(dependencies).forEach(parents => parents.forEach(node => nodeSet[node] = true));
    const nodes = Object.keys(nodeSet);

    // Nodes that the key node depends on, that haven't been resolved yet.
    let unresolvedParentsForNode = {};
    // Nodes that have no dependencies.
    let roots = [];
    // Nodes that depend on the key.
    let childrenForNode = {};

    // Initialize with blanks.
    nodes.forEach(node => {
        unresolvedParentsForNode[node] = {};
        childrenForNode[node] = [];
    })

    nodes.forEach(node => {
        const parents = dependencies[node] || [];
        console.log(node, parents);
        if (parents.length === 0) {
            roots.push(node);
        }
        parents.forEach(parent => {
            unresolvedParentsForNode[node][parent] = true;

            childrenForNode[parent].push(node);
        });
    });

    let sortedNodes = [];
    let processableNodes = roots.concat();
    while (processableNodes.length > 0) {
        const node = processableNodes.pop();
        sortedNodes.push(node);
        childrenForNode[node].forEach(child => {
            delete unresolvedParentsForNode[child][node];
            if (Object.keys(unresolvedParentsForNode[child]).length === 0) {
                processableNodes.push(child);
            }
        });
    }
    return sortedNodes;
}

// dependencies = { 'A': ['C', 'E', 'F'], 'C': ['D', 'E'], 'E': ['G'], };
const dependencies = { 'A': ['C', 'E', 'F'], 'C': ['D', 'E'], 'E': ['G'], 'J': ['C'] };
const safe_order = flattenDependencies(dependencies)
console.log(safe_order);