[graph] better logic for neighbour nodes (sorted by edge weight)

src/Gargantext/Components/GraphExplorer/Sidebar.purs

@@ -513,17 +513,11 @@ neighborhoodCpt = R.memo' $ here.component "neighborhood" cpt
       flip T.listen expandNeighborhood onExpandNeighborhoodChange
 
     R.useEffect1' selectedNodeIds' do
-      let refreshed = neighbourBadges graph' selectedNodeIds'
-      let count = Seq.length refreshed
-      -- let ordered = A.sortWith (\n -> -n.size) $ Seq.toUnfoldable refreshed
-
-      let neighbours' = neighbourBadges graph' selectedNodeIds'
-      let edges' = SigmaxT.neighboringEdges graph' selectedNodeIds'
-      let edgesSorted = A.sortWith (\e -> -e.weight) $ A.fromFoldable edges'
-      let neighboursSorted = (\e -> if Set.member e.source selectedNodeIds' then e.targetNode else e.sourceNode) <$> edgesSorted
+      let neighbours' = SigmaxT.neighborsSortedByEdgeWeight graph' selectedNodeIds'
+      let count = A.length neighbours'
 
       T.write_ (count - 1) termCountBox
-      T.write_ neighboursSorted termListBox
+      T.write_ neighbours' termListBox
       T.write_ false showMoreBox
 
     -- | Render
@@ -690,11 +684,6 @@ badgeSize minSize maxSize size =
 badges :: SigmaxT.SGraph -> SigmaxT.NodeIds -> Seq.Seq (Record SigmaxT.Node)
 badges graph selectedNodeIds = SigmaxT.graphNodes $ SigmaxT.nodesById graph selectedNodeIds
 
-neighbourBadges :: SigmaxT.SGraph -> SigmaxT.NodeIds -> Seq.Seq (Record SigmaxT.Node)
-neighbourBadges graph selectedNodeIds = SigmaxT.neighbors graph selectedNodes'
-  where
-  selectedNodes' = SigmaxT.graphNodes $ SigmaxT.nodesById graph selectedNodeIds
-
 ---------------------------------------------------------
 
 type SendPatches =

src/Gargantext/Hooks/Sigmax/Types.purs

@@ -18,7 +18,7 @@ import Gargantext.Data.Louvain as Louvain
 import Gargantext.Types as GT
 import Gargantext.Utils.Range as Range
 import Partial.Unsafe (unsafePartial)
-import Prelude (class Eq, class Show, ($), (&&), (==), (||), (<$>), mod, not, (<=))
+import Prelude (class Eq, class Show, ($), (&&), (==), (||), (<$>), mod, not, (<=), negate)
 import Record.Unsafe (unsafeGet, unsafeSet)
 
 newtype Graph n e = Graph { edges :: Seq.Seq { | e }, nodes :: Seq.Seq { | n } }
@@ -214,11 +214,13 @@ sub graph (Graph { nodes, edges }) = newGraph
   filteredEdges = edgesFilter edgeFilterFunc graph
   newGraph = nodesFilter (\n -> not (Set.member n.id nodeIds)) filteredEdges
 
-neighbors :: SGraph -> Seq.Seq (Record Node) -> Seq.Seq (Record Node)
-neighbors g nodes = Seq.fromFoldable $ Set.unions [ if Set.size sources <= 1 then targets else sources ]
+-- | NOTE: The logic of this function is a bit iffy. See
+-- https://gitlab.iscpif.fr/gargantext/purescript-gargantext/issues/749
+neighbors :: SGraph -> NodeIds -> Set.Set (Record Node)
+neighbors g nodeIds = Set.unions [ if Set.size sources <= 1 then targets else sources ]
   where
-  nodeIds = Set.fromFoldable $ Seq.map _.id nodes
-  selectedEdges = neighboringEdges g nodeIds
+  nodeIds' = Set.fromFoldable nodeIds
+  selectedEdges = neighboringEdges g nodeIds'
   sources = Set.fromFoldable $ graphNodes $ nodesById g $ Set.fromFoldable $ Seq.map _.source selectedEdges
   targets = Set.fromFoldable $ graphNodes $ nodesById g $ Set.fromFoldable $ Seq.map _.target selectedEdges
 
@@ -227,6 +229,12 @@ neighboringEdges g nodeIds = Seq.filter condition $ graphEdges g
   where
   condition { source, target } = (Set.member source nodeIds) || (Set.member target nodeIds)
 
+neighborsSortedByEdgeWeight :: SGraph -> NodeIds -> Array (Record Node)
+neighborsSortedByEdgeWeight g nodeIds = A.nubByEq (\n1 n2 -> n1.id == n2.id) neighbourNodes
+  where
+  neighbourNodes = (\e -> if Set.member e.source nodeIds then e.targetNode else e.sourceNode) <$> edgesSorted
+  edgesSorted = A.sortWith (\e -> -e.weight) $ A.fromFoldable (neighboringEdges g nodeIds)
+
 eqGraph :: SGraph -> SGraph -> Boolean
 eqGraph (Graph { nodes: n1, edges: e1 }) (Graph { nodes: n2, edges: e2 }) = (n1 == n2) && (e1 == e2)