From f134df4b0ae94d42854cfcd226a20308cc2fc977 Mon Sep 17 00:00:00 2001
From: NunoSempere <nuno.sempere@protonmail.com>
Date: Wed, 8 Dec 2021 11:30:13 +0100
Subject: [PATCH] tweak: Extracted some buildRow functionality to its own
 function

Note: More difficult than it sounds given the constraint
that I want to preserve functionality.
---
 lib/findPaths.js | 54 +++++++++++++++++++++++++++---------------------
 1 file changed, 30 insertions(+), 24 deletions(-)

diff --git a/lib/findPaths.js b/lib/findPaths.js
index 8467ff8..144f2dd 100644
--- a/lib/findPaths.js
+++ b/lib/findPaths.js
@@ -16,7 +16,7 @@ async function findPathsInner({
     let paths = []
     let minPos = Math.min(sourceElementPosition, targetElementPosition)
     let maxPos = Math.max(sourceElementPosition, targetElementPosition)
-    let linksInner = links.filter(link => 
+    let linksInner = links.filter(link =>
         (minPos <= link.sourceElementPosition && link.sourceElementPosition <= maxPos) &&
         (minPos <= link.targetElementPosition && link.targetElementPosition <= maxPos)
     )
@@ -29,21 +29,22 @@ async function findPathsInner({
             ) {
                 paths.push(pathSoFar.concat(link).flat())
             } else if ((link.source == sourceElementId)) {
-                let newPaths = await findPathsInner({ 
+                let newPaths = await findPathsInner({
                     sourceElementId: link.target, sourceElementPosition: link.sourceElementPosition,
                     targetElementId, targetElementPosition,
-                    pathSoFar: pathSoFar.concat(link).flat(), 
-                    links: linksInner, nodes, maxLengthOfPath: (maxLengthOfPath - 1) 
+                    pathSoFar: pathSoFar.concat(link).flat(),
+                    links: linksInner, nodes, maxLengthOfPath: (maxLengthOfPath - 1)
                 })
                 if (newPaths.length != 0) {
                     paths.push(...newPaths)
                 }
             } else if ((link.target == sourceElementId)) {
-                let newPaths = await findPathsInner({ 
+                let newPaths = await findPathsInner({
                     sourceElementId: link.source, sourceElementPosition: link.sourceElementPosition,
                     targetElementId, targetElementPosition,
-                    pathSoFar: pathSoFar.concat(link).flat(), 
-                    links: linksInner, nodes, maxLengthOfPath: (maxLengthOfPath - 1) })
+                    pathSoFar: pathSoFar.concat(link).flat(),
+                    links: linksInner, nodes, maxLengthOfPath: (maxLengthOfPath - 1)
+                })
                 if (newPaths.length != 0) {
                     paths.push(...newPaths)
                 }
@@ -155,42 +156,46 @@ function abridgeArrayAndDisplay(array) {
     return result
 }
 
-export async function buildRows(isListOrdered, orderedList, listOfElements, links){
+export async function buildRows({ isListOrdered, orderedList, listOfElements, links, rows, setTableRows }) {
     // Not used yet.
-    let rows = []
-    if (isListOrdered && ! (orderedList.length < listOfElements.length) && rows.length == 0) {
+    if (isListOrdered && !(orderedList.length < listOfElements.length) && rows.length == 0) {
         let nodes = []
-        let positionDictionary=({})
+        let positionDictionary = ({})
         orderedList.forEach((id, pos) => {
             nodes.push({ ...listOfElements[id], position: pos })
             positionDictionary[id] = pos
         })
         // let nodes = orderedList.map((id, pos) => ({ ...listOfElements[id], position: pos }))
         /* Pre-process links to talk in terms of distances */
-        links = links.map(link => ({...link, 
-            sourceElementPosition: positionDictionary[link.source], 
+        links = links.map(link => ({
+            ...link,
+            sourceElementPosition: positionDictionary[link.source],
             targetElementPosition: positionDictionary[link.target]
         }))
 
         let distances = await findDistancesForAllElements({ nodes, links })
-        rows = nodes.map((element, i) => ({ 
-            id: numToAlphabeticalString(element.position), 
-            position: element.position, 
-            name: element.name, 
-            distances: distances[i] 
+        rows = nodes.map((element, i) => ({
+            id: numToAlphabeticalString(element.position),
+            position: element.position,
+            name: element.name,
+            distances: distances[i]
         }))
         console.log("rows@CreateTableWithDistances")
         console.log(rows)
-    }else{
-        rows = []
+        setTableRows(rows)
+    } else {
+        // rows = []
+        // Do nothing
     }
-    return rows
+    // return rows
 }
 
 export function CreateTableWithDistances({ isListOrdered, orderedList, listOfElements, links }) {
-    const [rows, setRows] = useState([])
+    const [tableRows, setTableRows] = useState([])
 
     useEffect(async () => {
+        await buildRows({ isListOrdered, orderedList, listOfElements, links, rows: tableRows, setTableRows })
+        /*
         // https://stackoverflow.com/questions/57847626/using-async-await-inside-a-react-functional-component
         // https://stackoverflow.com/questions/54936559/using-async-await-in-react-component
         // https://reactjs.org/docs/hooks-effect.html#tip-optimizing-performance-by-skipping-effects
@@ -202,7 +207,7 @@ export function CreateTableWithDistances({ isListOrdered, orderedList, listOfEle
                 positionDictionary[id] = pos
             })
             // let nodes = orderedList.map((id, pos) => ({ ...listOfElements[id], position: pos }))
-            /* Pre-process links to talk in terms of distances */
+            // Pre-process links to talk in terms of distances
             links = links.map(link => ({...link, 
                 sourceElementPosition: positionDictionary[link.source], 
                 targetElementPosition: positionDictionary[link.target]
@@ -218,6 +223,7 @@ export function CreateTableWithDistances({ isListOrdered, orderedList, listOfEle
             console.log("rows@CreateTableWithDistances")
             console.log(rows)
         }
+        */
     }); // this useEffect should ideally only work when isListOrdered changes, but I haven't bothered to program that.
 
     return (
@@ -237,7 +243,7 @@ export function CreateTableWithDistances({ isListOrdered, orderedList, listOfEle
                     </tr>
                 </thead>
                 <tbody>
-                    {rows.map(row => <tr key={row.id}>
+                    {tableRows.map(row => <tr key={row.id}>
                         <td className="" >{row.id}</td>
                         <td>&nbsp;&nbsp;&nbsp;</td>
                         <td className="" >{row.position}</td>