@truedat/dd 8.11.6 → 8.11.7

package/src/utils/lineageLayout.js

@@ -0,0 +1,1047 @@
+const DEFAULT_NODE_WIDTH = 288;
+const DEFAULT_NODE_HEIGHT = 82;
+const COLUMN_GAP = 152;
+const NODE_GAP = 44;
+const FIELD_GAP = 4;
+const ROOT_BRANCH_GAP = 40;
+const GROUP_PADDING_X = 16;
+const GROUP_PADDING_BOTTOM = 34;
+const GROUP_HEADER_HEIGHT = 58;
+const MIN_GROUP_WIDTH = 240;
+const MIN_GROUP_HEIGHT = 82;
+const MAX_SWEEPS = 6;
+const MAX_CACHED_TOPOLOGIES = 4;
+
+const topologyCache = new Map();
+
+const finiteNumber = (value) => {
+  const number = Number(value);
+
+  return Number.isFinite(number) ? number : undefined;
+};
+
+const firstFiniteNumber = (values = [], fallback = 0) =>
+  values.map(finiteNumber).find((value) => value !== undefined) ?? fallback;
+
+const nodeGeometry = (node = {}) => {
+  const geometry = node.data?.absoluteGeometry;
+
+  return {
+    x: firstFiniteNumber([geometry?.x, node.position?.x, node.x], 0),
+    y: firstFiniteNumber([geometry?.y, node.position?.y, node.y], 0),
+    w: firstFiniteNumber(
+      [geometry?.w, node.width, node.measured?.width],
+      DEFAULT_NODE_WIDTH,
+    ),
+    h: firstFiniteNumber(
+      [geometry?.h, node.height, node.measured?.height],
+      DEFAULT_NODE_HEIGHT,
+    ),
+  };
+};
+
+const nodeLabel = (node = {}) => `${node.data?.label || node.id || ""}`;
+
+const nodeDepth = (node = {}) =>
+  firstFiniteNumber([node.data?.z, node.z], undefined);
+
+const median = (values = []) => {
+  if (!values.length) return undefined;
+
+  const ordered = [...values].sort((valueA, valueB) => valueA - valueB);
+  const middle = Math.floor(ordered.length / 2);
+
+  return ordered.length % 2
+    ? ordered[middle]
+    : (ordered[middle - 1] + ordered[middle]) / 2;
+};
+
+const appendMapSet = (map, key, value) => {
+  const values = map.get(key) || new Set();
+
+  values.add(value);
+  map.set(key, values);
+};
+
+const appendWeightedNeighbour = (map, key, value, weight = 1) => {
+  const values = map.get(key) || [];
+
+  values.push(...Array.from({ length: weight }, () => value));
+  map.set(key, values);
+};
+
+const sortedIds = (ids = []) =>
+  [...ids].sort((idA, idB) => idA.localeCompare(idB));
+
+const buildHierarchy = (nodes = []) => {
+  const nodeById = new Map(
+    nodes.filter(Boolean).map((node) => [node.id, node]),
+  );
+  const parentById = new Map();
+  const childIdsByParentId = new Map();
+
+  nodeById.forEach((node) => {
+    if (!node.parentId || !nodeById.has(node.parentId)) return;
+
+    parentById.set(node.id, node.parentId);
+    appendMapSet(childIdsByParentId, node.parentId, node.id);
+  });
+
+  const vertexIds = new Set(
+    [...nodeById.keys()].filter(
+      (id) => !(childIdsByParentId.get(id)?.size > 0),
+    ),
+  );
+
+  return { childIdsByParentId, nodeById, parentById, vertexIds };
+};
+
+const descendantVertexIds = (id, childIdsByParentId, vertexIds, cache) => {
+  if (cache.has(id)) return cache.get(id);
+  if (vertexIds.has(id)) {
+    const result = [id];
+
+    cache.set(id, result);
+    return result;
+  }
+
+  const result = sortedIds(childIdsByParentId.get(id) || []).flatMap(
+    (childId) =>
+      descendantVertexIds(childId, childIdsByParentId, vertexIds, cache),
+  );
+
+  cache.set(id, result);
+  return result;
+};
+
+const endpointVertexId = (id, hierarchy, descendantsCache) => {
+  if (hierarchy.vertexIds.has(id)) return id;
+
+  return descendantVertexIds(
+    id,
+    hierarchy.childIdsByParentId,
+    hierarchy.vertexIds,
+    descendantsCache,
+  )[0];
+};
+
+const normalizedRelationEdges = (edges = [], graphType, hierarchy) => {
+  const descendantsCache = new Map();
+  const relationByKey = new Map();
+
+  edges.forEach((edge) => {
+    if (!edge || edge.data?.containment) return;
+
+    const renderedSource = endpointVertexId(
+      edge.source,
+      hierarchy,
+      descendantsCache,
+    );
+    const renderedTarget = endpointVertexId(
+      edge.target,
+      hierarchy,
+      descendantsCache,
+    );
+
+    if (
+      !renderedSource ||
+      !renderedTarget ||
+      renderedSource === renderedTarget
+    ) {
+      return;
+    }
+
+    const source = renderedSource;
+    const target = renderedTarget;
+    const key = `${source}::${target}`;
+    const relation = relationByKey.get(key);
+    const weight = Math.max(
+      1,
+      Math.min(
+        12,
+        Math.round(
+          firstFiniteNumber(
+            [edge.data?.aggregatedCount, edge.data?.count, edge.count],
+            1,
+          ),
+        ),
+      ),
+    );
+
+    if (relation) {
+      relationByKey.set(key, {
+        ...relation,
+        weight: Math.min(12, relation.weight + weight),
+      });
+      return;
+    }
+
+    relationByKey.set(key, { source, target, weight });
+  });
+
+  return [...relationByKey.values()].sort(
+    (relationA, relationB) =>
+      relationA.source.localeCompare(relationB.source) ||
+      relationA.target.localeCompare(relationB.target),
+  );
+};
+
+const stronglyConnectedComponents = (vertexIds, outgoing) => {
+  const nextIndex = { current: 0 };
+  const indexes = new Map();
+  const lowLinks = new Map();
+  const stack = [];
+  const onStack = new Set();
+  const components = [];
+
+  const visit = (id) => {
+    indexes.set(id, nextIndex.current);
+    lowLinks.set(id, nextIndex.current);
+    nextIndex.current += 1;
+    stack.push(id);
+    onStack.add(id);
+
+    sortedIds(outgoing.get(id) || []).forEach((targetId) => {
+      if (!indexes.has(targetId)) {
+        visit(targetId);
+        lowLinks.set(id, Math.min(lowLinks.get(id), lowLinks.get(targetId)));
+      } else if (onStack.has(targetId)) {
+        lowLinks.set(id, Math.min(lowLinks.get(id), indexes.get(targetId)));
+      }
+    });
+
+    if (lowLinks.get(id) !== indexes.get(id)) return;
+
+    const component = [];
+    const popUntilRoot = () => {
+      const memberId = stack.pop();
+      onStack.delete(memberId);
+      component.push(memberId);
+      if (memberId !== id) popUntilRoot();
+    };
+    popUntilRoot();
+
+    components.push(component.sort((idA, idB) => idA.localeCompare(idB)));
+  };
+
+  sortedIds(vertexIds).forEach((id) => {
+    if (!indexes.has(id)) visit(id);
+  });
+
+  return components;
+};
+
+const depthForVertex = (id, hierarchy) => {
+  if (!id) return undefined;
+  const depth = nodeDepth(hierarchy.nodeById.get(id));
+  return depth !== undefined
+    ? depth
+    : depthForVertex(hierarchy.parentById.get(id), hierarchy);
+};
+
+const componentRanks = (hierarchy, relations) => {
+  const outgoing = new Map(
+    [...hierarchy.vertexIds].map((id) => [id, new Set()]),
+  );
+
+  relations.forEach(({ source, target }) =>
+    appendMapSet(outgoing, source, target),
+  );
+
+  const components = stronglyConnectedComponents(hierarchy.vertexIds, outgoing);
+  const componentByVertexId = new Map();
+
+  components.forEach((component, componentIndex) => {
+    component.forEach((id) => componentByVertexId.set(id, componentIndex));
+  });
+
+  const componentOutgoing = new Map(
+    components.map((_, componentIndex) => [componentIndex, new Set()]),
+  );
+  const componentIncomingCount = new Map(
+    components.map((_, componentIndex) => [componentIndex, 0]),
+  );
+
+  relations.forEach(({ source, target }) => {
+    const sourceComponent = componentByVertexId.get(source);
+    const targetComponent = componentByVertexId.get(target);
+
+    if (
+      sourceComponent === targetComponent ||
+      componentOutgoing.get(sourceComponent).has(targetComponent)
+    ) {
+      return;
+    }
+
+    componentOutgoing.get(sourceComponent).add(targetComponent);
+    componentIncomingCount.set(
+      targetComponent,
+      componentIncomingCount.get(targetComponent) + 1,
+    );
+  });
+  const connectedComponentIds = new Set(
+    relations.flatMap(({ source, target }) => [
+      componentByVertexId.get(source),
+      componentByVertexId.get(target),
+    ]),
+  );
+
+  const componentLabel = (componentIndex) =>
+    components[componentIndex][0] || "";
+  const queue = [...componentIncomingCount]
+    .filter(([, count]) => count === 0)
+    .map(([componentIndex]) => componentIndex)
+    .sort((indexA, indexB) =>
+      componentLabel(indexA).localeCompare(componentLabel(indexB)),
+    );
+  const rankByComponent = new Map(
+    queue.map((componentIndex) => [componentIndex, 0]),
+  );
+
+  while (queue.length) {
+    const componentIndex = queue.shift();
+    const rank = rankByComponent.get(componentIndex) || 0;
+
+    [...(componentOutgoing.get(componentIndex) || [])]
+      .sort((indexA, indexB) => indexA - indexB)
+      .forEach((targetComponent) => {
+        rankByComponent.set(
+          targetComponent,
+          Math.max(rankByComponent.get(targetComponent) || 0, rank + 1),
+        );
+        componentIncomingCount.set(
+          targetComponent,
+          componentIncomingCount.get(targetComponent) - 1,
+        );
+
+        if (componentIncomingCount.get(targetComponent) === 0) {
+          queue.push(targetComponent);
+          queue.sort((indexA, indexB) =>
+            componentLabel(indexA).localeCompare(componentLabel(indexB)),
+          );
+        }
+      });
+  }
+
+  const isolatedComponents = components
+    .map((component, componentIndex) => ({
+      component,
+      componentIndex,
+      isolated: !connectedComponentIds.has(componentIndex),
+      depth: median(
+        component
+          .map((id) => depthForVertex(id, hierarchy))
+          .filter((value) => value !== undefined),
+      ),
+    }))
+    .filter(({ isolated }) => isolated);
+  const depthOrder = new Map(
+    [
+      ...new Set(
+        isolatedComponents
+          .map(({ depth }) => depth)
+          .filter((depth) => depth !== undefined),
+      ),
+    ]
+      .sort((depthA, depthB) => depthA - depthB)
+      .map((depth, index) => [depth, index]),
+  );
+
+  isolatedComponents.forEach(({ componentIndex, depth }) => {
+    if (depth !== undefined)
+      rankByComponent.set(componentIndex, depthOrder.get(depth));
+  });
+
+  return new Map(
+    [...hierarchy.vertexIds].map((id) => [
+      id,
+      rankByComponent.get(componentByVertexId.get(id)) || 0,
+    ]),
+  );
+};
+
+const stableVertexCompare = (hierarchy) => (idA, idB) => {
+  const nodeA = hierarchy.nodeById.get(idA);
+  const nodeB = hierarchy.nodeById.get(idB);
+  const yDiff = nodeGeometry(nodeA).y - nodeGeometry(nodeB).y;
+
+  if (yDiff !== 0) return yDiff;
+
+  const labelDiff = nodeLabel(nodeA).localeCompare(nodeLabel(nodeB));
+
+  return labelDiff || idA.localeCompare(idB);
+};
+
+const crossingMinimizedOrder = (hierarchy, relations, rankById) => {
+  const layerIds = new Map();
+  const previousIds = new Map();
+  const nextIds = new Map();
+  const incomingSegmentsById = new Map();
+  const outgoingSegmentsById = new Map();
+  const stableCompare = stableVertexCompare(hierarchy);
+
+  const appendLayerId = (rank, id) => {
+    const ids = layerIds.get(rank) || [];
+
+    ids.push(id);
+    layerIds.set(rank, ids);
+  };
+
+  [...hierarchy.vertexIds]
+    .sort(stableCompare)
+    .forEach((id) => appendLayerId(rankById.get(id) || 0, id));
+
+  const appendSegment = (source, target, weight) => {
+    const segment = { source, target, weight };
+    const incoming = incomingSegmentsById.get(target) || [];
+    const outgoing = outgoingSegmentsById.get(source) || [];
+
+    incoming.push(segment);
+    outgoing.push(segment);
+    incomingSegmentsById.set(target, incoming);
+    outgoingSegmentsById.set(source, outgoing);
+    appendWeightedNeighbour(previousIds, target, source, weight);
+    appendWeightedNeighbour(nextIds, source, target, weight);
+  };
+
+  relations.forEach(({ source, target, weight }, relationIndex) => {
+    const sourceRank = rankById.get(source) || 0;
+    const targetRank = rankById.get(target) || 0;
+
+    if (targetRank <= sourceRank) return;
+
+    const lastId = Array.from(
+      { length: targetRank - sourceRank - 1 },
+      (_, i) => sourceRank + 1 + i,
+    ).reduce((prevId, rank) => {
+      const virtualId = `@@lineage-layout:${relationIndex}:${rank}`;
+      appendLayerId(rank, virtualId);
+      appendSegment(prevId, virtualId, weight);
+      return virtualId;
+    }, source);
+
+    appendSegment(lastId, target, weight);
+  });
+
+  const ranks = [...layerIds.keys()].sort((rankA, rankB) => rankA - rankB);
+  const stableOrder = new Map();
+
+  ranks.forEach((rank) => {
+    layerIds.get(rank).forEach((id, index) => stableOrder.set(id, index));
+  });
+
+  const positions = () => {
+    const result = new Map();
+
+    ranks.forEach((rank) => {
+      layerIds.get(rank).forEach((id, index) => result.set(id, index));
+    });
+    return result;
+  };
+
+  const sweep = (orderedRanks, neighbourIds) => {
+    const orderById = positions();
+
+    orderedRanks.forEach((rank) => {
+      const ids = layerIds.get(rank);
+      const scoreById = new Map(
+        ids.map((id) => [
+          id,
+          median(
+            (neighbourIds.get(id) || [])
+              .map((neighbourId) => orderById.get(neighbourId))
+              .filter((value) => value !== undefined),
+          ),
+        ]),
+      );
+
+      ids.sort((idA, idB) => {
+        const scoreA = scoreById.get(idA);
+        const scoreB = scoreById.get(idB);
+
+        if (scoreA !== undefined && scoreB !== undefined) {
+          if (scoreA !== scoreB) return scoreA - scoreB;
+        } else {
+          if (scoreA !== undefined) return -1;
+          if (scoreB !== undefined) return 1;
+        }
+
+        return (
+          (stableOrder.get(idA) || 0) - (stableOrder.get(idB) || 0) ||
+          idA.localeCompare(idB)
+        );
+      });
+      ids.forEach((id, index) => orderById.set(id, index));
+    });
+  };
+
+  Array.from({ length: MAX_SWEEPS }).forEach((_, pass) => {
+    if (pass % 2 === 0) sweep(ranks.slice(1), previousIds);
+    else sweep([...ranks].reverse().slice(1), nextIds);
+  });
+
+  const swapDelta = (idA, idB, orderById) => {
+    const computeCrossings = (segmentsA, segmentsB, oppositeId) =>
+      segmentsA.reduce(
+        (outer, segA) =>
+          outer +
+          segmentsB.reduce((inner, segB) => {
+            const posA = orderById.get(segA[oppositeId]);
+            const posB = orderById.get(segB[oppositeId]);
+            if (posA === undefined || posB === undefined) return inner;
+            const w = segA.weight * segB.weight;
+            return inner + (posA > posB ? -w : posA < posB ? w : 0);
+          }, 0),
+        0,
+      );
+
+    return (
+      computeCrossings(
+        incomingSegmentsById.get(idA) || [],
+        incomingSegmentsById.get(idB) || [],
+        "source",
+      ) +
+      computeCrossings(
+        outgoingSegmentsById.get(idA) || [],
+        outgoingSegmentsById.get(idB) || [],
+        "target",
+      )
+    );
+  };
+
+  ranks.forEach((rank) => {
+    const ids = layerIds.get(rank);
+    const directions = [1, -1];
+
+    directions.forEach((direction) => {
+      const orderById = positions();
+      const start = direction > 0 ? 0 : ids.length - 2;
+      const end = direction > 0 ? ids.length - 1 : -1;
+
+      const bubble = (index) => {
+        if (direction > 0 ? index >= end : index <= end) return;
+        const idA = ids[index];
+        const idB = ids[index + 1];
+        if (swapDelta(idA, idB, orderById) < 0) {
+          ids.splice(index, 2, idB, idA);
+          orderById.set(idA, index + 1);
+          orderById.set(idB, index);
+        }
+        bubble(index + direction);
+      };
+      bubble(start);
+    });
+  });
+
+  const orderById = new Map();
+
+  ranks.forEach((rank) => {
+    layerIds.get(rank).forEach((id, index) => {
+      if (hierarchy.vertexIds.has(id)) orderById.set(id, index);
+    });
+  });
+
+  return orderById;
+};
+
+const stringHash = (value) => {
+  const hash = [...value].reduce(
+    (h, ch) => Math.imul(h ^ ch.charCodeAt(0), 16777619) >>> 0,
+    2166136261,
+  );
+  return hash >>> 0;
+};
+
+const unorderedSignature = (items, partFor) => {
+  const { count, sum, squaredSum, xor } = items.reduce(
+    (acc, item) => {
+      const part = partFor(item);
+      if (part === undefined) return acc;
+      const hash = stringHash(part);
+      return {
+        count: acc.count + 1,
+        sum: (acc.sum + hash) >>> 0,
+        squaredSum: (acc.squaredSum + Math.imul(hash, hash)) >>> 0,
+        xor: (acc.xor ^ hash) >>> 0,
+      };
+    },
+    { count: 0, sum: 0, squaredSum: 0, xor: 0 },
+  );
+  return `${count}:${sum.toString(36)}:${squaredSum.toString(36)}:${xor.toString(36)}`;
+};
+
+const topologySignature = (nodes, edges, graphType) => {
+  const nodeSignature = unorderedSignature(
+    nodes,
+    (node) => `${node.id}:${node.parentId || ""}`,
+  );
+  const edgeSignature = unorderedSignature(edges, (edge) => {
+    if (!edge || edge.data?.containment) return undefined;
+
+    return [
+      edge.source || "",
+      edge.target || "",
+      firstFiniteNumber(
+        [edge.data?.aggregatedCount, edge.data?.count, edge.count],
+        1,
+      ),
+    ].join(":");
+  });
+
+  return `${graphType}::${nodeSignature}::${edgeSignature}`;
+};
+
+const buildTopologyPlan = (hierarchy, edges, graphType) => {
+  const relations = normalizedRelationEdges(edges, graphType, hierarchy);
+  const rankById = componentRanks(hierarchy, relations);
+  const orderById = crossingMinimizedOrder(hierarchy, relations, rankById);
+
+  return { orderById, rankById, relations };
+};
+
+const cachedTopologyPlan = (nodes, edges, graphType) => {
+  const signature = topologySignature(nodes, edges, graphType);
+  const hierarchy = buildHierarchy(nodes);
+
+  if (topologyCache.has(signature)) {
+    return { ...topologyCache.get(signature), hierarchy };
+  }
+
+  const plan = buildTopologyPlan(hierarchy, edges, graphType);
+
+  topologyCache.set(signature, plan);
+  if (topologyCache.size > MAX_CACHED_TOPOLOGIES) {
+    topologyCache.delete(topologyCache.keys().next().value);
+  }
+
+  return { ...plan, hierarchy };
+};
+
+const previousGeometryMap = (nodes = []) =>
+  new Map(nodes.filter(Boolean).map((node) => [node.id, nodeGeometry(node)]));
+
+const translateGeometries = (geometries, deltaX, deltaY) => {
+  const translated = new Map();
+
+  geometries.forEach((geometry, id) => {
+    translated.set(id, {
+      ...geometry,
+      x: geometry.x + deltaX,
+      y: geometry.y + deltaY,
+    });
+  });
+
+  return translated;
+};
+
+const mergeGeometryMaps = (blocks = []) => {
+  const geometries = new Map();
+
+  blocks.forEach((block) => {
+    block.geometries.forEach((geometry, id) => geometries.set(id, geometry));
+  });
+  return geometries;
+};
+
+const shiftedBlock = (block, deltaY) => ({
+  ...block,
+  geometries: translateGeometries(block.geometries, 0, deltaY),
+});
+
+const blocksOverlapX = (blockA, blockB, gap = NODE_GAP) =>
+  blockA.left < blockB.right + gap && blockB.left < blockA.right + gap;
+
+const createContainerBlock = ({
+  childBlocks,
+  id,
+  node,
+  previousById,
+  root = false,
+}) => {
+  const stableYFor = (block) =>
+    previousById.get(block.id)?.y ?? block.stableY ?? 0;
+  const orderedBlocks = [...childBlocks].sort((blockA, blockB) => {
+    const rankDiff = blockA.minRank - blockB.minRank;
+
+    if (rankDiff !== 0) return rankDiff;
+
+    const scoreDiff = blockA.score - blockB.score;
+
+    if (scoreDiff !== 0) return scoreDiff;
+
+    return (
+      stableYFor(blockA) - stableYFor(blockB) ||
+      blockA.id.localeCompare(blockB.id)
+    );
+  });
+  const forceStack = Boolean(node?.data?.resourceContainer);
+  const lanes = [];
+
+  orderedBlocks.forEach((block) => {
+    const lane = forceStack
+      ? undefined
+      : lanes.find(
+          (current) =>
+            block.minRank > current.maxRank &&
+            current.blocks.every(
+              (existing) => !blocksOverlapX(existing, block),
+            ),
+        );
+
+    if (lane) {
+      lane.blocks.push(block);
+      const updatedLane = {
+        ...lane,
+        height: Math.max(lane.height, block.height),
+        maxRank: Math.max(lane.maxRank, block.maxRank),
+      };
+      lanes.splice(lanes.indexOf(lane), 1, updatedLane);
+      return;
+    }
+
+    lanes.push({
+      blocks: [block],
+      height: block.height,
+      maxRank: block.maxRank,
+    });
+  });
+
+  const headerHeight = root ? 0 : GROUP_HEADER_HEIGHT;
+  const laneGap = root
+    ? orderedBlocks.length > 4
+      ? ROOT_BRANCH_GAP * 1.5
+      : ROOT_BRANCH_GAP
+    : NODE_GAP;
+  const { nextLaneY, positionedBlocks } = lanes.reduce(
+    (acc, lane) => ({
+      nextLaneY: acc.nextLaneY + lane.height + laneGap,
+      positionedBlocks: [
+        ...acc.positionedBlocks,
+        ...lane.blocks.map((block) => shiftedBlock(block, acc.nextLaneY)),
+      ],
+    }),
+    { nextLaneY: headerHeight, positionedBlocks: [] },
+  );
+
+  const minChildX = positionedBlocks.length
+    ? Math.min(...positionedBlocks.map((block) => block.left))
+    : 0;
+  const maxChildX = positionedBlocks.length
+    ? Math.max(...positionedBlocks.map((block) => block.right))
+    : MIN_GROUP_WIDTH;
+  const paddingX = root ? 0 : GROUP_PADDING_X;
+  const bottomPadding = root ? 0 : GROUP_PADDING_BOTTOM;
+  const x = minChildX - paddingX;
+  const height = Math.max(
+    root ? 0 : MIN_GROUP_HEIGHT,
+    Math.max(0, nextLaneY - laneGap) + bottomPadding,
+  );
+  const width = Math.max(root ? 0 : MIN_GROUP_WIDTH, maxChildX - x + paddingX);
+  const geometries = mergeGeometryMaps(positionedBlocks);
+
+  if (!root) geometries.set(id, { x, y: 0, w: width, h: height });
+
+  return {
+    geometries,
+    height,
+    left: root ? minChildX : Math.min(minChildX, x),
+    right: root ? maxChildX : Math.max(maxChildX, x + width),
+    id: id || "@@lineage-layout-root",
+    maxRank: orderedBlocks.length
+      ? Math.max(...orderedBlocks.map((block) => block.maxRank))
+      : 0,
+    minRank: orderedBlocks.length
+      ? Math.min(...orderedBlocks.map((block) => block.minRank))
+      : 0,
+    score: median(orderedBlocks.map((block) => block.score)) || 0,
+    stableY: median(orderedBlocks.map(stableYFor)) || 0,
+    width,
+  };
+};
+
+const packedGeometry = (nodes, topologyPlan, previousLayout) => {
+  const { hierarchy, orderById, rankById } = topologyPlan;
+  const previousById = previousGeometryMap(previousLayout);
+  const ranks = [...new Set(rankById.values())].sort(
+    (rankA, rankB) => rankA - rankB,
+  );
+  const compactRank = new Map(ranks.map((rank, index) => [rank, index]));
+  const maxWidthByRank = new Map();
+
+  hierarchy.vertexIds.forEach((id) => {
+    const rank = compactRank.get(rankById.get(id)) || 0;
+    const width = nodeGeometry(hierarchy.nodeById.get(id)).w;
+
+    maxWidthByRank.set(rank, Math.max(maxWidthByRank.get(rank) || 0, width));
+  });
+
+  const xByRank = new Map();
+  [...maxWidthByRank.keys()]
+    .sort((rankA, rankB) => rankA - rankB)
+    .reduce((acc, rank) => {
+      xByRank.set(rank, acc);
+      return (
+        acc + (maxWidthByRank.get(rank) || DEFAULT_NODE_WIDTH) + COLUMN_GAP
+      );
+    }, 0);
+
+  const blockById = new Map();
+  const createBlock = (id) => {
+    if (blockById.has(id)) return blockById.get(id);
+
+    const node = hierarchy.nodeById.get(id);
+    const childIds = sortedIds(hierarchy.childIdsByParentId.get(id) || []);
+
+    if (!childIds.length) {
+      const geometry = nodeGeometry(node);
+      const rank = compactRank.get(rankById.get(id)) || 0;
+      const block = {
+        geometries: new Map([
+          [
+            id,
+            { x: xByRank.get(rank) || 0, y: 0, w: geometry.w, h: geometry.h },
+          ],
+        ]),
+        height: geometry.h,
+        left: xByRank.get(rank) || 0,
+        right: (xByRank.get(rank) || 0) + geometry.w,
+        id,
+        maxRank: rank,
+        minRank: rank,
+        score: orderById.get(id) || 0,
+        stableY: previousById.get(id)?.y ?? geometry.y,
+        width: geometry.w,
+      };
+
+      blockById.set(id, block);
+      return block;
+    }
+
+    const block = createContainerBlock({
+      childBlocks: childIds.map(createBlock),
+      id,
+      node,
+      previousById,
+    });
+
+    blockById.set(id, block);
+    return block;
+  };
+  const rootIds = sortedIds(
+    [...hierarchy.nodeById.keys()].filter(
+      (id) => !hierarchy.parentById.has(id),
+    ),
+  );
+  const rootBlock = createContainerBlock({
+    childBlocks: rootIds.map(createBlock),
+    previousById,
+    root: true,
+  });
+  const geometries = rootBlock.geometries;
+  const allGeometries = [...geometries.values()];
+  const minX = Math.min(...allGeometries.map(({ x }) => x), 0);
+  const minY = Math.min(...allGeometries.map(({ y }) => y), 0);
+
+  return translateGeometries(geometries, -minX, -minY);
+};
+
+const preserveAnchor = (geometries, previousLayout, anchorNodeId) => {
+  if (!anchorNodeId) return geometries;
+
+  const previousGeometry =
+    previousGeometryMap(previousLayout).get(anchorNodeId);
+  const nextGeometry = geometries.get(anchorNodeId);
+
+  if (!previousGeometry || !nextGeometry) return geometries;
+
+  return translateGeometries(
+    geometries,
+    previousGeometry.x - nextGeometry.x,
+    previousGeometry.y - nextGeometry.y,
+  );
+};
+
+const applyGeometries = (nodes, geometries) =>
+  nodes.map((node) => {
+    const geometry = geometries.get(node.id) || nodeGeometry(node);
+    const parentGeometry = node.parentId ? geometries.get(node.parentId) : null;
+    const position = parentGeometry
+      ? {
+          x: geometry.x - parentGeometry.x,
+          y: geometry.y - parentGeometry.y,
+        }
+      : { x: geometry.x, y: geometry.y };
+
+    return {
+      ...node,
+      height: geometry.h,
+      position,
+      width: geometry.w,
+      data: {
+        ...node.data,
+        absoluteGeometry: geometry,
+      },
+      style: {
+        ...node.style,
+        height: geometry.h,
+        width: geometry.w,
+      },
+    };
+  });
+
+const compoundGeometry = (nodes, edges) => {
+  const hierarchy = buildHierarchy(nodes);
+  const { nodeById, parentById, childIdsByParentId } = hierarchy;
+  const ancestorsById = new Map();
+  const projectedByParent = new Map();
+  const ancestors = (id) => {
+    if (ancestorsById.has(id)) return ancestorsById.get(id);
+    const build = (current, visited, result) => {
+      if (!current || visited.has(current)) return result;
+      const nextVisited = new Set([...visited, current]);
+      const nextResult = new Map([
+        ...result,
+        [parentById.get(current), current],
+      ]);
+      return build(parentById.get(current), nextVisited, nextResult);
+    };
+    const result = build(id, new Set(), new Map());
+    ancestorsById.set(id, result);
+    return result;
+  };
+  edges.forEach((edge) => {
+    if (
+      edge.data?.containment ||
+      !nodeById.has(edge.source) ||
+      !nodeById.has(edge.target)
+    )
+      return;
+    const targetAncestors = ancestors(edge.target);
+    ancestors(edge.source).forEach((source, parent) => {
+      const target = targetAncestors.get(parent);
+      if (!target || source === target) return;
+      const relations = projectedByParent.get(parent) || [];
+      relations.push({ ...edge, source, target });
+      projectedByParent.set(parent, relations);
+    });
+  });
+  const rootIds = nodes
+    .filter(({ id }) => !parentById.has(id))
+    .map(({ id }) => id);
+  const blockFor = (id) => {
+    const root = id === undefined;
+    const node = nodeById.get(id);
+    const children = root ? rootIds : [...(childIdsByParentId.get(id) || [])];
+    if (!children.length && !root) {
+      const { w, h } = nodeGeometry(node);
+      return {
+        width: w,
+        height: h,
+        geometries: new Map([[id, { x: 0, y: 0, w, h }]]),
+      };
+    }
+    const fields =
+      !root &&
+      children.every(
+        (child) => nodeById.get(child).data?.variant === "lineage-field",
+      );
+    const childNodes = children.map((child) => nodeById.get(child));
+    const plan = cachedTopologyPlan(
+      childNodes,
+      fields ? [] : projectedByParent.get(id) || [],
+      "compound",
+    );
+    const ordered = [...children].sort((a, b) => {
+      if (fields)
+        return (
+          nodeLabel(nodeById.get(a)).localeCompare(
+            nodeLabel(nodeById.get(b)),
+          ) || a.localeCompare(b)
+        );
+      return (
+        (plan.rankById.get(a) || 0) - (plan.rankById.get(b) || 0) ||
+        (plan.orderById.get(a) || 0) - (plan.orderById.get(b) || 0) ||
+        a.localeCompare(b)
+      );
+    });
+    const columns = new Map();
+    ordered.forEach((child) => {
+      const rank = fields ? 0 : plan.rankById.get(child) || 0;
+      const column = columns.get(rank) || [];
+      column.push(blockFor(child));
+      columns.set(rank, column);
+    });
+    const padding = root ? 0 : GROUP_PADDING_X;
+    const header = root ? 0 : GROUP_HEADER_HEIGHT;
+    const {
+      geometries,
+      x: finalX,
+      height: finalHeight,
+    } = [...columns.keys()]
+      .sort((a, b) => a - b)
+      .reduce(
+        (outerAcc, rank) => {
+          const {
+            rankGeos,
+            y: endY,
+            maxWidth,
+          } = columns.get(rank).reduce(
+            (innerAcc, block) => {
+              translateGeometries(
+                block.geometries,
+                outerAcc.x,
+                innerAcc.y,
+              ).forEach((geometry, child) =>
+                innerAcc.rankGeos.set(child, geometry),
+              );
+              return {
+                rankGeos: innerAcc.rankGeos,
+                y: innerAcc.y + block.height + (fields ? FIELD_GAP : NODE_GAP),
+                maxWidth: Math.max(innerAcc.maxWidth, block.width),
+              };
+            },
+            { rankGeos: new Map(), y: header, maxWidth: 0 },
+          );
+          rankGeos.forEach((geometry, child) =>
+            outerAcc.geometries.set(child, geometry),
+          );
+          return {
+            geometries: outerAcc.geometries,
+            x: outerAcc.x + maxWidth + COLUMN_GAP,
+            height: Math.max(outerAcc.height, endY),
+          };
+        },
+        { geometries: new Map(), x: padding, height: header },
+      );
+    const width = Math.max(MIN_GROUP_WIDTH, finalX - COLUMN_GAP + padding);
+    const totalHeight = finalHeight + (root ? 0 : GROUP_PADDING_BOTTOM);
+    if (!root) geometries.set(id, { x: 0, y: 0, w: width, h: totalHeight });
+    return { width, height: totalHeight, geometries };
+  };
+  return blockFor(undefined).geometries;
+};
+
+export const layoutVisibleLineageGraph = ({
+  anchorNodeId,
+  edges = [],
+  graphType = "impact",
+  nodes = [],
+  previousLayout = [],
+}) => {
+  if (!nodes.length) return [];
+
+  const packed = nodes.some(
+    (node) =>
+      node.data?.topology ||
+      (node.parentId && node.data?.variant === "lineage-field"),
+  )
+    ? compoundGeometry(nodes, edges)
+    : packedGeometry(
+        nodes,
+        cachedTopologyPlan(nodes, edges, graphType),
+        previousLayout,
+      );
+  const anchored = preserveAnchor(packed, previousLayout, anchorNodeId);
+
+  return applyGeometries(nodes, anchored);
+};