@truedat/dd 8.14.0 → 8.14.1

package/src/utils/__tests__/fixtures/lineageInternalDependencies.json

@@ -0,0 +1,375 @@
+{
+  "capturedAt": "2026-10-06",
+  "sourcePath": "/graphs/30148",
+  "groupLabel": "Manufacturing Business MySQL > db_man_bl_dtmep",
+  "counts": {
+    "visibleNodes": 362,
+    "visibleEdges": 410,
+    "children": 19,
+    "internalEdges": 38,
+    "externalEdges": 20
+  },
+  "nodes": [
+    {
+      "id": "sappm_activity_class",
+      "label": "sappm_activity_class",
+      "parentId": "dtmep",
+      "width": 360,
+      "height": 36,
+      "variant": "lineage-field"
+    },
+    {
+      "id": "sappm_activity_notification",
+      "label": "sappm_activity_notification",
+      "parentId": "dtmep",
+      "width": 360,
+      "height": 36,
+      "variant": "lineage-field"
+    },
+    {
+      "id": "sappm_costtype",
+      "label": "sappm_costtype",
+      "parentId": "dtmep",
+      "width": 360,
+      "height": 36,
+      "variant": "lineage-field"
+    },
+    {
+      "id": "sappm_equipment",
+      "label": "sappm_equipment",
+      "parentId": "dtmep",
+      "width": 360,
+      "height": 36,
+      "variant": "lineage-field"
+    },
+    {
+      "id": "sappm_equipment_object_class",
+      "label": "sappm_equipment_object_class",
+      "parentId": "dtmep",
+      "width": 360,
+      "height": 36,
+      "variant": "lineage-field"
+    },
+    {
+      "id": "sappm_gpa",
+      "label": "sappm_gpa",
+      "parentId": "dtmep",
+      "width": 360,
+      "height": 36,
+      "variant": "lineage-field"
+    },
+    {
+      "id": "sappm_kpi_objective",
+      "label": "sappm_kpi_objective",
+      "parentId": "dtmep",
+      "width": 360,
+      "height": 36,
+      "variant": "lineage-field"
+    },
+    {
+      "id": "sappm_manufacturing_calendar",
+      "label": "sappm_manufacturing_calendar",
+      "parentId": "dtmep",
+      "width": 360,
+      "height": 36,
+      "variant": "lineage-field"
+    },
+    {
+      "id": "sappm_md_functional_location",
+      "label": "sappm_md_functional_location",
+      "parentId": "dtmep",
+      "width": 360,
+      "height": 36,
+      "variant": "lineage-field"
+    },
+    {
+      "id": "sappm_md_pep",
+      "label": "sappm_md_pep",
+      "parentId": "dtmep",
+      "width": 360,
+      "height": 36,
+      "variant": "lineage-field"
+    },
+    {
+      "id": "sappm_md_work_center",
+      "label": "sappm_md_work_center",
+      "parentId": "dtmep",
+      "width": 360,
+      "height": 36,
+      "variant": "lineage-field"
+    },
+    {
+      "id": "sappm_notification",
+      "label": "sappm_notification",
+      "parentId": "dtmep",
+      "width": 360,
+      "height": 36,
+      "variant": "lineage-field"
+    },
+    {
+      "id": "sappm_notification_object_class",
+      "label": "sappm_notification_object_class",
+      "parentId": "dtmep",
+      "width": 360,
+      "height": 36,
+      "variant": "lineage-field"
+    },
+    {
+      "id": "sappm_operation",
+      "label": "sappm_operation",
+      "parentId": "dtmep",
+      "width": 360,
+      "height": 36,
+      "variant": "lineage-field"
+    },
+    {
+      "id": "sappm_order",
+      "label": "sappm_order",
+      "parentId": "dtmep",
+      "width": 360,
+      "height": 36,
+      "variant": "lineage-field"
+    },
+    {
+      "id": "sappm_order_notification",
+      "label": "sappm_order_notification",
+      "parentId": "dtmep",
+      "width": 360,
+      "height": 36,
+      "variant": "lineage-field"
+    },
+    {
+      "id": "sappm_order_pep_costtype",
+      "label": "sappm_order_pep_costtype",
+      "parentId": "dtmep",
+      "width": 360,
+      "height": 36,
+      "variant": "lineage-field"
+    },
+    {
+      "id": "sappm_work_center",
+      "label": "sappm_work_center",
+      "parentId": "dtmep",
+      "width": 360,
+      "height": 36,
+      "variant": "lineage-field"
+    },
+    {
+      "id": "sappm_workstation_calendar",
+      "label": "sappm_workstation_calendar",
+      "parentId": "dtmep",
+      "width": 360,
+      "height": 36,
+      "variant": "lineage-field"
+    }
+  ],
+  "edges": [
+    {
+      "id": "legacy-path-106-0",
+      "source": "sappm_activity_class",
+      "target": "sappm_order_notification"
+    },
+    {
+      "id": "legacy-path-593-0",
+      "source": "sappm_activity_notification",
+      "target": "sappm_notification"
+    },
+    {
+      "id": "legacy-path-409-0",
+      "source": "sappm_costtype",
+      "target": "sappm_order"
+    },
+    {
+      "id": "legacy-path-428-0",
+      "source": "sappm_costtype",
+      "target": "sappm_order_pep_costtype"
+    },
+    {
+      "id": "legacy-path-794-0",
+      "source": "sappm_equipment",
+      "target": "sappm_order"
+    },
+    {
+      "id": "legacy-path-335-0",
+      "source": "sappm_equipment_object_class",
+      "target": "sappm_equipment"
+    },
+    {
+      "id": "legacy-path-121-0",
+      "source": "sappm_equipment_object_class",
+      "target": "sappm_notification"
+    },
+    {
+      "id": "legacy-path-712-0",
+      "source": "sappm_equipment_object_class",
+      "target": "sappm_order"
+    },
+    {
+      "id": "legacy-path-384-0",
+      "source": "sappm_gpa",
+      "target": "sappm_kpi_objective"
+    },
+    {
+      "id": "legacy-path-765-0",
+      "source": "sappm_gpa",
+      "target": "sappm_md_functional_location"
+    },
+    {
+      "id": "legacy-path-141-0",
+      "source": "sappm_kpi_objective",
+      "target": "sappm_operation"
+    },
+    {
+      "id": "legacy-path-73-0",
+      "source": "sappm_manufacturing_calendar",
+      "target": "sappm_equipment"
+    },
+    {
+      "id": "legacy-path-761-0",
+      "source": "sappm_manufacturing_calendar",
+      "target": "sappm_kpi_objective"
+    },
+    {
+      "id": "legacy-path-764-0",
+      "source": "sappm_manufacturing_calendar",
+      "target": "sappm_notification"
+    },
+    {
+      "id": "legacy-path-48-0",
+      "source": "sappm_manufacturing_calendar",
+      "target": "sappm_operation"
+    },
+    {
+      "id": "legacy-path-350-0",
+      "source": "sappm_manufacturing_calendar",
+      "target": "sappm_order"
+    },
+    {
+      "id": "legacy-path-814-0",
+      "source": "sappm_manufacturing_calendar",
+      "target": "sappm_order_notification"
+    },
+    {
+      "id": "legacy-path-678-0",
+      "source": "sappm_manufacturing_calendar",
+      "target": "sappm_order_pep_costtype"
+    },
+    {
+      "id": "legacy-path-309-0",
+      "source": "sappm_md_functional_location",
+      "target": "sappm_equipment"
+    },
+    {
+      "id": "legacy-path-467-0",
+      "source": "sappm_md_functional_location",
+      "target": "sappm_notification"
+    },
+    {
+      "id": "legacy-path-576-0",
+      "source": "sappm_md_functional_location",
+      "target": "sappm_order"
+    },
+    {
+      "id": "legacy-path-233-0",
+      "source": "sappm_md_functional_location",
+      "target": "sappm_order_pep_costtype"
+    },
+    {
+      "id": "legacy-path-455-0",
+      "source": "sappm_md_pep",
+      "target": "sappm_order_pep_costtype"
+    },
+    {
+      "id": "legacy-path-685-0",
+      "source": "sappm_md_work_center",
+      "target": "sappm_operation"
+    },
+    {
+      "id": "legacy-path-444-0",
+      "source": "sappm_md_work_center",
+      "target": "sappm_order"
+    },
+    {
+      "id": "legacy-path-372-0",
+      "source": "sappm_notification",
+      "target": "sappm_equipment"
+    },
+    {
+      "id": "legacy-path-404-0",
+      "source": "sappm_notification",
+      "target": "sappm_operation"
+    },
+    {
+      "id": "legacy-path-294-0",
+      "source": "sappm_notification",
+      "target": "sappm_order"
+    },
+    {
+      "id": "legacy-path-390-0",
+      "source": "sappm_notification",
+      "target": "sappm_order_pep_costtype"
+    },
+    {
+      "id": "legacy-path-705-0",
+      "source": "sappm_notification_object_class",
+      "target": "sappm_notification"
+    },
+    {
+      "id": "legacy-path-667-0",
+      "source": "sappm_operation",
+      "target": "sappm_order"
+    },
+    {
+      "id": "legacy-path-686-0",
+      "source": "sappm_order",
+      "target": "sappm_order_pep_costtype"
+    },
+    {
+      "id": "legacy-path-214-0",
+      "source": "sappm_order_notification",
+      "target": "sappm_operation"
+    },
+    {
+      "id": "legacy-path-682-0",
+      "source": "sappm_order_notification",
+      "target": "sappm_order"
+    },
+    {
+      "id": "legacy-path-327-0",
+      "source": "sappm_work_center",
+      "target": "sappm_notification"
+    },
+    {
+      "id": "legacy-path-27-0",
+      "source": "sappm_work_center",
+      "target": "sappm_operation"
+    },
+    {
+      "id": "legacy-path-574-0",
+      "source": "sappm_work_center",
+      "target": "sappm_order"
+    },
+    {
+      "id": "legacy-path-807-0",
+      "source": "sappm_workstation_calendar",
+      "target": "sappm_order_notification"
+    }
+  ],
+  "baseline": {
+    "groupWidth": 392,
+    "groupHeight": 826,
+    "columns": 1
+  },
+  "rankOnlySimulation": {
+    "columns": 6,
+    "columnCounts": [11, 3, 1, 2, 1, 1],
+    "groupWidth": 2952,
+    "groupHeight": 906,
+    "columnX": [16, 528, 1040, 1552, 2064, 2576]
+  },
+  "notes": [
+    "IDs de recursos sustituidos por nombres; sin hosts, credenciales ni payload completo.",
+    "Las 20 conexiones externas solo se registran como conteo; no forman parte del fixture de rutas.",
+    "La simulación cambia solo el ranking: no incluye reservas de canales ni validación visual final."
+  ]
+}

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

@@ -0,0 +1,202 @@
+import { layoutVisibleLineageGraph } from "../lineageLayout";
+import {
+  applyInternalEdgeRoutes,
+  applyInternalNodeLayers,
+} from "../lineageInternalRoutes";
+import fixture from "./fixtures/lineageInternalDependencies.json";
+
+const input = () => [
+  {
+    id: "dtmep",
+    type: "lineageGroup",
+    position: { x: 0, y: 0 },
+    data: { label: "dtmep", resourceContainer: true },
+  },
+  ...fixture.nodes.map(({ variant, label, ...node }) => ({
+    ...node,
+    position: { x: 0, y: 0 },
+    data: { label, variant },
+  })),
+];
+const snapshot = (nodes) =>
+  Object.fromEntries(nodes.map((n) => [n.id, n.data.absoluteGeometry]));
+
+it.each([
+  ["compact", [19]],
+  ["expanded", [11, 3, 1, 2, 1, 1]],
+])("keeps all resources and routes in %s mode", (dependencyLayout, counts) => {
+  const nodes = layoutVisibleLineageGraph({
+    nodes: input(),
+    edges: fixture.edges,
+    dependencyLayout,
+  });
+  const children = nodes.filter((n) => n.parentId === "dtmep");
+  const xs = [...new Set(children.map((n) => n.position.x))].sort(
+    (a, b) => a - b,
+  );
+  expect(
+    xs.map((x) => children.filter((n) => n.position.x === x).length),
+  ).toEqual(counts);
+  const parent = nodes.find((n) => n.id === "dtmep");
+  expect(Object.keys(parent.data.internalEdgeGuides)).toHaveLength(38);
+  expect(parent.data.internalColumns).toHaveLength(
+    dependencyLayout === "compact" ? 3 : xs.length,
+  );
+  parent.data.internalColumns.forEach((column) => {
+    if (dependencyLayout === "expanded") expect(column.y).toBe(66);
+    if (dependencyLayout === "compact") {
+      children.forEach((node) => {
+        const above = node.position.y + node.height <= column.y - 12;
+        const below = node.position.y >= column.y + 24 + 8;
+        expect(above || below).toBe(true);
+      });
+    }
+    expect(column.count).toBeGreaterThan(0);
+    if (dependencyLayout === "expanded") {
+      expect(column.roles.length).toBeGreaterThan(0);
+      expect(column.roles).not.toContain(undefined);
+    }
+  });
+  if (dependencyLayout === "expanded") {
+    xs.forEach((x) => {
+      const column = children
+        .filter((n) => n.position.x === x)
+        .sort((a, b) => a.position.y - b.position.y);
+      column.slice(1).forEach((node, index) => {
+        expect(
+          node.position.y - column[index].position.y - column[index].height,
+        ).toBe(8);
+      });
+    });
+  }
+  children.forEach((n) => {
+    expect(n.position.x).toBeGreaterThanOrEqual(16);
+    expect(n.position.y).toBeGreaterThanOrEqual(58);
+    expect(n.position.x + n.width).toBeLessThanOrEqual(parent.width);
+    expect(n.position.y + n.height).toBeLessThanOrEqual(parent.height);
+  });
+  const reversed = layoutVisibleLineageGraph({
+    nodes: input().reverse(),
+    edges: [...fixture.edges].reverse(),
+    dependencyLayout,
+  });
+  expect(snapshot(reversed)).toEqual(snapshot(nodes));
+  const layered = applyInternalNodeLayers(nodes);
+  const result = applyInternalEdgeRoutes(fixture.edges, layered);
+  expect(result.map((e) => e.id)).toEqual(fixture.edges.map((e) => e.id));
+  const owner = layered.find((n) => n.id === "dtmep");
+  result.forEach((e) => {
+    expect(e.data.edgePath).toBe("guided-bezier");
+    expect(e.zIndex).toBe(150);
+    expect(e.zIndex).toBeGreaterThan(owner.zIndex);
+    expect(e.data.selectionBaseZIndex).toBe(owner.zIndex + 2);
+    expect(e.zIndex).toBeLessThan(
+      layered.find((n) => n.id === e.source).zIndex,
+    );
+  });
+});
+
+it("keeps plain lists compact and removes obsolete guides", () => {
+  const related = layoutVisibleLineageGraph({
+    nodes: input(),
+    edges: fixture.edges,
+  });
+  const plain = layoutVisibleLineageGraph({ nodes: related, edges: [] });
+  const children = plain
+    .filter((n) => n.parentId === "dtmep")
+    .sort((a, b) => a.position.y - b.position.y);
+  expect(new Set(children.map((n) => n.position.x)).size).toBe(1);
+  expect(children[1].position.y - children[0].position.y).toBe(40);
+  expect(
+    plain.find((n) => n.id === "dtmep").data.internalEdgeGuides,
+  ).toBeUndefined();
+});
+
+it.each(["compact", "expanded"])(
+  "keeps cyclic, isolated and differently sized children inside nested %s groups",
+  (dependencyLayout) => {
+    const nodes = [
+      { id: "outer", type: "lineageGroup", data: {} },
+      {
+        id: "inner",
+        parentId: "outer",
+        type: "lineageGroup",
+        data: { resourceContainer: true },
+      },
+      ...["a", "b", "c", "isolated"].map((id, index) => ({
+        id,
+        parentId: "inner",
+        width: 240 + index * 80,
+        height: 36,
+        data: { label: id, variant: "lineage-field" },
+      })),
+    ].map((node) => ({ position: { x: 0, y: 0 }, ...node }));
+    const edges = [
+      ["a", "b"],
+      ["b", "c"],
+      ["c", "a"],
+    ].map(([source, target]) => ({
+      id: `${source}-${target}`,
+      source,
+      target,
+    }));
+    const result = applyInternalNodeLayers(
+      layoutVisibleLineageGraph({ nodes, edges, dependencyLayout }),
+    );
+    const owner = result.find((node) => node.id === "inner");
+    expect(Object.keys(owner.data.internalEdgeGuides)).toHaveLength(3);
+    result
+      .filter((node) => node.parentId === "inner")
+      .forEach((node) => {
+        expect(node.position.x + node.width).toBeLessThanOrEqual(owner.width);
+        expect(node.position.y + node.height).toBeLessThanOrEqual(owner.height);
+      });
+    const routed = applyInternalEdgeRoutes(edges, result);
+    routed.forEach((edge) => {
+      expect(edge.targetHandle).toBe("target-right-node");
+      expect(edge.zIndex).toBe(150);
+      expect(edge.zIndex).toBeGreaterThan(owner.zIndex);
+      expect(edge.data.selectionBaseZIndex).toBe(owner.zIndex + 2);
+      expect(edge.zIndex).toBeLessThan(
+        result.find((node) => node.id === edge.source).zIndex,
+      );
+      expect(Number.isFinite(edge.data.routeGuide.laneX)).toBe(true);
+    });
+  },
+);
+
+it("drops an obsolete internal layer when its owner has no route guide", () => {
+  const [edge] = applyInternalEdgeRoutes(
+    [
+      {
+        id: "obsolete",
+        zIndex: 9,
+        data: { internalOwnerId: "group", selectionBaseZIndex: 206 },
+      },
+    ],
+    [],
+  );
+  expect(edge.zIndex).toBe(150);
+  expect(edge.data.selectionBaseZIndex).toBe(100);
+  expect(edge.data.internalOwnerId).toBeUndefined();
+});
+
+it("keeps compact routing within a narrow right gutter", () => {
+  const nodes = layoutVisibleLineageGraph({
+    nodes: input(),
+    edges: fixture.edges,
+    dependencyLayout: "compact",
+  });
+  const parent = nodes.find((node) => node.id === "dtmep");
+  const right = Math.max(
+    ...nodes
+      .filter((node) => node.parentId === "dtmep")
+      .map((node) => node.position.x + node.width),
+  );
+  const guides = Object.values(parent.data.internalEdgeGuides);
+  expect(parent.width - right).toBeLessThanOrEqual(48 + guides.length * 4);
+  guides.forEach((guide) => {
+    expect(guide.laneX).toBeGreaterThan(right);
+    expect(guide.laneX).toBeLessThan(parent.width);
+  });
+});

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

@@ -162,9 +162,9 @@ describe("compound root columns", () => {
     ];
     const positions = geometry(freshLayout()({ nodes, edges }));
     expect(positions.a.x).toBe(positions.b.x);
-    expect(positions.b.y).toBe(positions.a.y + positions.a.h + 44);
-    expect(positions.c.x).toBe(positions.a.x + positions.a.w + 152);
-    expect(positions.d.x).toBe(positions.c.x + positions.c.w + 152);
+    expect(positions.b.y).toBe(positions.a.y + positions.a.h + 48);
+    expect(positions.c.x).toBe(positions.a.x + positions.a.w + 160);
+    expect(positions.d.x).toBe(positions.c.x + positions.c.w + 160);
     expect(positions.c.y).toBe(positions.a.y);
     expect(
       geometry(
@@ -186,7 +186,7 @@ describe("compound root columns", () => {
     expect(new Set(positions.map(({ x }) => x)).size).toBe(1);
     positions.slice(1).forEach((current, i) => {
       expect(current.y).toBeGreaterThanOrEqual(
-        positions[i].y + positions[i].h + 44,
+        positions[i].y + positions[i].h + 48,
       );
     });
   });
@@ -220,7 +220,7 @@ describe("compound root columns", () => {
     expect(expanded.peer.x).toBe(geometry(collapsed).peer.x);
     expect(expanded.peer.y).toBe(geometry(collapsed).peer.y);
     expect(expanded.peer.y).toBeGreaterThanOrEqual(
-      expanded.global.y + expanded.global.h + 44,
+      expanded.global.y + expanded.global.h + 48,
     );
     expect(new Set(fields.map(({ id }) => expanded[id].x)).size).toBe(1);
     fields.forEach(({ id }) => {
@@ -229,7 +229,7 @@ describe("compound root columns", () => {
         expanded.global.y + expanded.global.h,
       );
     });
-    expect(expanded.sink.x).toBe(expanded.global.x + expanded.global.w + 152);
+    expect(expanded.sink.x).toBe(expanded.global.x + expanded.global.w + 160);
   });
 });
 

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

@@ -0,0 +1,27 @@
+import {
+  readDependencyLayout,
+  writeDependencyLayout,
+} from "../lineageViewPreferences";
+const KEY = "td.lineage.dependencyLayout.v1";
+afterEach(() => {
+  localStorage.clear();
+  jest.restoreAllMocks();
+});
+it("defaults to compact and restores an explicit valid choice", () => {
+  expect(readDependencyLayout()).toBe("compact");
+  expect(writeDependencyLayout("expanded")).toBe(true);
+  expect(localStorage.getItem(KEY)).toBe("expanded");
+  expect(readDependencyLayout()).toBe("expanded");
+  localStorage.setItem(KEY, "invalid");
+  expect(readDependencyLayout()).toBe("compact");
+});
+it("works when browser storage is blocked", () => {
+  jest.spyOn(Storage.prototype, "getItem").mockImplementation(() => {
+    throw new Error("blocked");
+  });
+  jest.spyOn(Storage.prototype, "setItem").mockImplementation(() => {
+    throw new Error("blocked");
+  });
+  expect(readDependencyLayout()).toBe("compact");
+  expect(writeDependencyLayout("expanded")).toBe(false);
+});