@truedat/dd 8.12.10 → 8.12.11

package/src/utils/__tests__/lineageLayout.spec.js

@@ -233,6 +233,74 @@ describe("compound root columns", () => {
   });
 });
 
+describe("relations within one lineage group", () => {
+  const group = { ...node("group"), data: { label: "group", topology: true } };
+  const child = (id) => ({ ...node(id), parentId: "group" });
+
+  it("places related siblings from left to right and keeps an unrelated sibling separate", () => {
+    const nodes = [group, child("source"), child("target"), child("unrelated")];
+    const edges = [{ source: "source", target: "target" }];
+    const positions = geometry(freshLayout()({ nodes, edges }));
+
+    expect(positions.source.x + positions.source.w).toBeLessThan(
+      positions.target.x,
+    );
+    expect(positions.unrelated.x).toBe(positions.source.x);
+    expect(positions.unrelated.y).toBeGreaterThan(positions.source.y);
+    expect(positions.target.x + positions.target.w).toBeLessThanOrEqual(
+      positions.group.x + positions.group.w,
+    );
+  });
+
+  it("projects relations between nested nodes onto their sibling groups", () => {
+    const nodes = [
+      group,
+      child("left"),
+      child("right"),
+      { ...node("left/leaf"), parentId: "left" },
+      { ...node("right/leaf"), parentId: "right" },
+    ];
+    const edges = [{ source: "left/leaf", target: "right/leaf" }];
+    const positions = geometry(freshLayout()({ nodes, edges }));
+
+    expect(positions.left.x + positions.left.w).toBeLessThan(positions.right.x);
+    expect(positions["left/leaf"].x).toBeGreaterThanOrEqual(positions.left.x);
+    expect(positions["right/leaf"].x).toBeGreaterThanOrEqual(positions.right.x);
+  });
+
+  it("reflows the whole graph when an internal dependency widens a group", () => {
+    const nodes = [group, child("source"), child("target"), node("other")];
+    const layout = freshLayout();
+    const before = geometry(layout({ nodes, edges: [] }));
+    const after = geometry(
+      layout({
+        nodes,
+        edges: [{ source: "source", target: "target" }],
+      }),
+    );
+
+    expect(after.group.w).toBeGreaterThan(before.group.w);
+    expect(after.group.h).toBeLessThan(before.group.h);
+    expect(after.other.y).toBeLessThan(before.other.y);
+  });
+
+  it("keeps cyclic siblings in one column without overlapping", () => {
+    const nodes = [group, child("a"), child("b")];
+    const positions = geometry(
+      freshLayout()({
+        nodes,
+        edges: [
+          { source: "a", target: "b" },
+          { source: "b", target: "a" },
+        ],
+      }),
+    );
+
+    expect(positions.a.x).toBe(positions.b.x);
+    expect(positions.b.y).toBeGreaterThanOrEqual(positions.a.y + positions.a.h);
+  });
+});
+
 it.each([undefined, "lineage-field"])(
   "leaves only bottom padding after the last child (%s)",
   (variant) => {

package/src/utils/lineageGraph.js

@@ -3108,8 +3108,8 @@ export const planLineageEdgeRoutes = (edges = [], nodes = []) => {
     data: {
       ...edge.data,
       ...routePortPositions[index],
-      edgeOffset: routeGuides[index]?.edgeOffset ?? edge.data?.edgeOffset,
-      routeGuide: routeGuides[index] || edge.data?.routeGuide,
+      edgeOffset: routeGuides[index]?.edgeOffset,
+      routeGuide: routeGuides[index],
     },
   }));
 };
@@ -3139,6 +3139,7 @@ export const focusLineageNodes = (
   focusedNodeIds,
   focusActive,
   selectedNodeId,
+  pinnedNodeId,
 ) =>
   focusActive
     ? nodes.map((node) => {
@@ -3147,7 +3148,8 @@ export const focusLineageNodes = (
           node.data?.lineageNode?.lineageKind === "group";
         const selected = node.id === selectedNodeId;
         const direct = !selected && focusedNodeIds.has(node.id);
-        const dimmed = !selected && !focusedNodeIds.has(node.id);
+        const dimmed =
+          !selected && node.id !== pinnedNodeId && !focusedNodeIds.has(node.id);
 
         return {
           ...node,