export function toElk()

in visual/react/lib/util_elk.tsx [49:98]
50 lines of code
10 McCabe index (conditional complexity)

export function toElk({ nodes, edges }: { nodes: Node[], edges: Edge[] }): ElkNode {
    let rootElkNode: ElkNode = { id: rootID, children: [], edges: [] }
    let allElkNodes: Map<string, ElkNode> = new Map();
    let whoIsParent: Map<string, string> = new Map();
    allElkNodes.set(rootID, rootElkNode)
    nodes.forEach((node) => {
        let elkNode = allElkNodes.get(node.id)
        if (!elkNode) {
            elkNode = {
                id: node.id,
                x: node.position.x,
                y: node.position.y,
                width: node.width === null ? undefined : node.width,
                height: node.height === null ? undefined : node.height,
                labels: [{text: node.data.label }],
                children: [],
                edges: [],
            }
            allElkNodes.set(node.id, elkNode)
        }
        let parentElkNode: ElkNode | undefined
        let parentId = node.parentId || rootID
        whoIsParent.set(node.id, parentId)
        parentElkNode = allElkNodes.get(parentId)
        if (!parentElkNode) {
            parentElkNode = { id: parentId, children: [] }
            allElkNodes.set(parentId, parentElkNode)
        }
        parentElkNode?.children?.push(elkNode)
    })
    edges.forEach((edge) => {
        let sourceNode = allElkNodes.get(edge.source)
        let targetNode = allElkNodes.get(edge.target)
        if (sourceNode && targetNode) {
            let elkEdge: ElkExtendedEdge = {
                id: edge.id,
                sources: [sourceNode.id],
                targets: [targetNode.id],
            }
            let parent = whoIsParent.get(edge.source)
            if (parent) {
                let parentNode = allElkNodes.get(parent)
                if (parentNode) {
                    parentNode.edges?.push(elkEdge)
                }
            }
        }
    })
    return rootElkNode
}