refactor(node/internals): cleanup

packages/react/src/store/index.ts

@@ -19,7 +19,6 @@ import type {
   Edge,
   EdgeSelectionChange,
   NodeSelectionChange,
-  NodePositionChange,
   UnselectNodesAndEdgesParams,
   FitViewOptions,
   InternalNode,
@@ -99,7 +98,7 @@ const createRFStore = ({
           return;
         }
 
-        updateAbsolutePositions(nodeLookup, nodeOrigin);
+        updateAbsolutePositions(nodeLookup, { nodeOrigin });
 
         // we call fitView once initially after all dimensions are set
         let nextFitViewDone = fitViewDone;

packages/system/src/utils/store.ts

@@ -19,46 +19,45 @@ import { getDimensions, getHandleBounds } from './dom';
 import { getBoundsOfRects, getNodeDimensions, isNumeric, nodeToRect } from './general';
 import { getNodePositionWithOrigin } from './graph';
 
-type ParentNodes = Set<string>;
-
 export function updateAbsolutePositions<NodeType extends NodeBase>(
   nodeLookup: Map<string, InternalNodeBase<NodeType>>,
-  nodeOrigin: NodeOrigin = [0, 0],
+  options: UpdateNodesOptions<NodeType> = {
-  parentNodes?: ParentNodes
+    nodeOrigin: [0, 0] as NodeOrigin,
+    elevateNodesOnSelect: true,
+    defaults: {},
+  },
+  parentNodeIds?: Set<string>
 ) {
-  for (const [, node] of nodeLookup) {
+  const selectedNodeZ: number = options?.elevateNodesOnSelect ? 1000 : 0;
-    if (node.parentNode && !nodeLookup.has(node.parentNode)) {
+
-      throw new Error(`Parent node ${node.parentNode} not found`);
+  for (const [id, node] of nodeLookup) {
+    const parentId = node.parentNode;
+
+    if (parentId && !nodeLookup.has(parentId)) {
+      throw new Error(`Parent node ${parentId} not found`);
     }
 
-    if (node.parentNode || parentNodes?.has(node.id)) {
+    if (node.parentNode || node.internals.isParent || parentNodeIds?.has(id)) {
-      const parentNode = node.parentNode ? nodeLookup.get(node.parentNode) : null;
+      const parentNode = parentId ? nodeLookup.get(parentId) : null;
       const { x, y, z } = calculateXYZPosition(
         node,
         nodeLookup,
         {
           ...node.position,
-          z: node.internals.z ?? 0,
+          z: (isNumeric(node.zIndex) ? node.zIndex : 0) + (node.selected ? selectedNodeZ : 0),
         },
-        parentNode?.origin || nodeOrigin
+        parentNode?.origin || options.nodeOrigin
       );
 
-      const positionChanged = x !== node.internals.positionAbsolute?.x || y !== node.internals.positionAbsolute?.y;
+      const currPosition = node.internals.positionAbsolute;
-      node.internals.positionAbsolute = positionChanged
+      const positionChanged = x !== currPosition.x || y !== currPosition.y;
-        ? {
-            x,
-            y,
-          }
-        : node.internals.positionAbsolute;
 
+      node.internals.positionAbsolute = positionChanged ? { x, y } : currPosition;
       node.internals.z = z;
+      node.internals.isParent = !!parentNodeIds?.has(id);
 
-      if (parentNodes?.has(node.id)) {
+      nodeLookup.set(id, node);
-        node.internals.isParent = true;
-      }
     }
-
-    nodeLookup.set(node.id, node);
   }
 }
 
@@ -79,14 +78,16 @@ export function adoptUserProvidedNodes<NodeType extends NodeBase>(
 ) {
   const tmpLookup = new Map(nodeLookup);
   nodeLookup.clear();
-  const parentNodes: ParentNodes = new Set();
   const selectedNodeZ: number = options?.elevateNodesOnSelect ? 1000 : 0;
+  const parentNodeIds = new Set<string>();
 
   nodes.forEach((n) => {
     const currentStoreNode = tmpLookup.get(n.id);
+
     if (n.parentNode) {
-      parentNodes.add(n.parentNode);
+      parentNodeIds.add(n.parentNode);
     }
+
     if (n === currentStoreNode?.internals?.userProvidedNode) {
       nodeLookup.set(n.id, currentStoreNode);
       return currentStoreNode;
@@ -111,8 +112,8 @@ export function adoptUserProvidedNodes<NodeType extends NodeBase>(
     nodeLookup.set(node.id, node);
   });
 
-  if (parentNodes.size > 0) {
+  if (parentNodeIds.size > 0) {
-    updateAbsolutePositions(nodeLookup, options.nodeOrigin, parentNodes);
+    updateAbsolutePositions(nodeLookup, options, parentNodeIds);
   }
 }
 
@@ -120,7 +121,7 @@ function calculateXYZPosition<NodeType extends NodeBase>(
   node: NodeType,
   nodeLookup: Map<string, InternalNodeBase<NodeType>>,
   result: XYZPosition,
-  nodeOrigin: NodeOrigin
+  nodeOrigin: NodeOrigin = [0, 0]
 ): XYZPosition {
   if (!node.parentNode) {
     return result;