@diagrammo/dgmo 0.45.0 → 0.47.0

package/dist/chunk-Y2ZE3MSG.js

@@ -0,0 +1,590 @@
+import {
+  CHAR_WIDTH_RATIO,
+  measureText,
+  truncateText
+} from "./chunk-WCT3NYCV.js";
+
+// src/infra/layout.ts
+import dagre from "@dagrejs/dagre";
+var MIN_NODE_WIDTH = 140;
+var NODE_HEADER_HEIGHT = 28;
+var META_LINE_HEIGHT = 14;
+var NODE_SEPARATOR_GAP = 4;
+var NODE_PAD_BOTTOM = 10;
+var ROLE_DOT_ROW = 12;
+var COLLAPSE_BAR_HEIGHT = 6;
+var NODE_FONT_SIZE = 13;
+var META_FONT_SIZE = 10;
+var EDGE_LABEL_FONT_SIZE = 11;
+var PADDING_X = 24;
+var GROUP_PADDING = 20;
+var GROUP_HEADER_HEIGHT = 24;
+var EDGE_MARGIN = 60;
+var DISPLAY_KEYS = /* @__PURE__ */ new Set([
+  "cache-hit",
+  "firewall-block",
+  "ratelimit-rps",
+  "latency-ms",
+  "uptime",
+  "instances",
+  "max-rps",
+  "cb-error-threshold",
+  "cb-latency-threshold-ms",
+  "concurrency",
+  "duration-ms",
+  "cold-start-ms",
+  "buffer",
+  "drain-rate",
+  "retention-hours",
+  "partitions"
+]);
+var DISPLAY_NAMES = {
+  "cache-hit": "cache hit",
+  "firewall-block": "firewall block",
+  "ratelimit-rps": "rate limit RPS",
+  "latency-ms": "latency",
+  uptime: "uptime",
+  instances: "instances",
+  "max-rps": "max RPS",
+  "cb-error-threshold": "CB error threshold",
+  "cb-latency-threshold-ms": "CB latency threshold",
+  concurrency: "concurrency",
+  "duration-ms": "duration",
+  "cold-start-ms": "cold start",
+  buffer: "buffer",
+  "drain-rate": "drain rate",
+  "retention-hours": "retention",
+  partitions: "partitions"
+};
+function countDisplayProps(node, expanded, options) {
+  if (!expanded) return 0;
+  let count = node.properties.filter((p) => DISPLAY_KEYS.has(p.key)).length;
+  if (options) {
+    const hasLatency = node.properties.some((p) => p.key === "latency-ms");
+    const hasUptime = node.properties.some((p) => p.key === "uptime");
+    const isServerless = node.properties.some((p) => p.key === "concurrency");
+    const defaultLatency = parseFloat(options["default-latency-ms"] ?? "") || 0;
+    const defaultUptime = parseFloat(options["default-uptime"] ?? "") || 0;
+    if (!hasLatency && !isServerless && defaultLatency > 0) count++;
+    if (!hasUptime && defaultUptime > 0 && defaultUptime < 100) count++;
+  }
+  return count;
+}
+function countComputedRows(node, expanded) {
+  let count = 0;
+  if (node.computedConcurrentInvocations > 0) count += 1;
+  const p = node.computedLatencyPercentiles;
+  if (p.p50 > 0 || p.p90 > 0 || p.p99 > 0) count += expanded ? 3 : 1;
+  if (node.computedUptime < 1) {
+    const declaredUptime = node.properties.find((p2) => p2.key === "uptime");
+    const declaredVal = declaredUptime ? Number(declaredUptime.value) / 100 : 1;
+    const differs = Math.abs(node.computedUptime - declaredVal) > 1e-6;
+    if (differs || node.isEdge) count += 1;
+  }
+  if (node.computedAvailability < 1) count += 1;
+  if (node.computedCbState === "open") count += 1;
+  if (node.queueMetrics) {
+    if (node.queueMetrics.fillRate > 0) count += 1;
+    if (node.queueMetrics.fillRate > 0 && node.queueMetrics.timeToOverflow < Infinity)
+      count += 1;
+  }
+  return count;
+}
+function hasRoles(node) {
+  if (node.isEdge) return false;
+  return node.properties.some((p) => DISPLAY_KEYS.has(p.key));
+}
+function computeNodeWidth(node, expanded, options) {
+  const badgeVal = node.computedConcurrentInvocations === 0 && node.computedInstances > 1 ? node.computedInstances : 0;
+  const badgeWidth = badgeVal > 0 ? measureText(`${badgeVal}x`, META_FONT_SIZE) + 2 * CHAR_WIDTH_RATIO * NODE_FONT_SIZE : 0;
+  const labelWidth = measureText(node.label, NODE_FONT_SIZE) + badgeWidth + PADDING_X;
+  const allKeys = [];
+  if (node.computedRps > 0) allKeys.push("RPS");
+  if (expanded) {
+    for (const p of node.properties) {
+      const dk = DISPLAY_NAMES[p.key];
+      if (dk) allKeys.push(dk);
+    }
+    if (options) {
+      const hasLatency = node.properties.some((p) => p.key === "latency-ms");
+      const hasUptime = node.properties.some((p) => p.key === "uptime");
+      const isServerless = node.properties.some((p) => p.key === "concurrency");
+      if (!hasLatency && !isServerless && (parseFloat(options["default-latency-ms"] ?? "") || 0) > 0)
+        allKeys.push("latency");
+      if (!hasUptime && (parseFloat(options["default-uptime"] ?? "") || 0) > 0 && parseFloat(options["default-uptime"] ?? "") < 100)
+        allKeys.push("uptime");
+    }
+  }
+  const computedRows = countComputedRows(node, expanded);
+  if (computedRows > 0) {
+    if (node.computedConcurrentInvocations > 0) allKeys.push("instances");
+    const perc = node.computedLatencyPercentiles;
+    if (perc.p50 > 0 || perc.p90 > 0 || perc.p99 > 0) {
+      if (expanded) {
+        allKeys.push("p50", "p90", "p99");
+      } else {
+        allKeys.push("p90");
+      }
+    }
+    if (node.computedUptime < 1) {
+      const declaredUptime = node.properties.find((p) => p.key === "uptime");
+      const declaredVal = declaredUptime ? Number(declaredUptime.value) / 100 : 1;
+      if (Math.abs(node.computedUptime - declaredVal) > 1e-6 || node.isEdge) {
+        allKeys.push("eff. uptime");
+      }
+    }
+    if (node.computedAvailability < 1) allKeys.push("availability");
+    if (node.computedCbState === "open") allKeys.push("CB");
+    if (node.queueMetrics) {
+      if (node.queueMetrics.fillRate > 0) allKeys.push("lag");
+      if (node.queueMetrics.fillRate > 0 && node.queueMetrics.timeToOverflow < Infinity)
+        allKeys.push("overflow");
+    }
+  }
+  if (allKeys.length === 0) return Math.max(MIN_NODE_WIDTH, labelWidth);
+  const keyColWidth = Math.max(
+    ...allKeys.map((k) => measureText(`${k}: `, META_FONT_SIZE))
+  );
+  let maxRowWidth = 0;
+  if (node.computedRps > 0) {
+    const nodeMaxRps = getNumProp(node, "max-rps", 0);
+    const nodeRateLimit = getNumProp(node, "ratelimit-rps", 0);
+    const nodeConcurrency = getNumProp(node, "concurrency", 0);
+    const nodeDurationMs = getNumProp(node, "duration-ms", 100);
+    const serverlessCap = nodeConcurrency > 0 ? nodeConcurrency / (nodeDurationMs / 1e3) : 0;
+    const effectiveCap = serverlessCap > 0 ? serverlessCap : nodeMaxRps > 0 && nodeRateLimit > 0 ? Math.min(nodeMaxRps * node.computedInstances, nodeRateLimit) : nodeMaxRps > 0 ? nodeMaxRps * node.computedInstances : nodeRateLimit > 0 ? nodeRateLimit : 0;
+    const rpsVal = effectiveCap > 0 && !node.isEdge ? `${formatRpsShort(node.computedRps)} / ${formatRpsShort(effectiveCap)}` : formatRps(node.computedRps);
+    maxRowWidth = Math.max(
+      maxRowWidth,
+      keyColWidth + measureText(rpsVal, META_FONT_SIZE)
+    );
+  }
+  if (expanded) {
+    for (const p of node.properties) {
+      const dk = DISPLAY_NAMES[p.key];
+      if (!dk) continue;
+      const numVal = typeof p.value === "number" ? p.value : parseFloat(String(p.value)) || 0;
+      const PCT_KEYS = [
+        "cache-hit",
+        "firewall-block",
+        "uptime",
+        "cb-error-threshold"
+      ];
+      const valStr = p.key === "max-rps" || p.key === "ratelimit-rps" ? formatRpsShort(numVal) : p.key === "latency-ms" || p.key === "cb-latency-threshold-ms" || p.key === "duration-ms" || p.key === "cold-start-ms" ? formatMs(numVal) : PCT_KEYS.includes(p.key) ? `${numVal}%` : String(p.value);
+      maxRowWidth = Math.max(
+        maxRowWidth,
+        keyColWidth + measureText(valStr, META_FONT_SIZE)
+      );
+    }
+  }
+  if (computedRows > 0) {
+    const perc = node.computedLatencyPercentiles;
+    const msValues = expanded ? [perc.p50, perc.p90, perc.p99] : [perc.p90];
+    for (const ms of msValues) {
+      if (ms > 0) {
+        maxRowWidth = Math.max(
+          maxRowWidth,
+          keyColWidth + measureText(formatMs(ms), META_FONT_SIZE)
+        );
+      }
+    }
+    if (perc.p90 > 0) {
+      const rawThreshold = node.properties.find((p) => p.key === "slo-p90-latency-ms")?.value ?? options?.["slo-p90-latency-ms"];
+      const threshold = rawThreshold != null ? parseFloat(String(rawThreshold)) : NaN;
+      if (!isNaN(threshold) && threshold > 0) {
+        const combinedVal = `${formatMs(perc.p90)} / ${formatMs(threshold)}`;
+        maxRowWidth = Math.max(
+          maxRowWidth,
+          keyColWidth + measureText(combinedVal, META_FONT_SIZE)
+        );
+      }
+    }
+    if (node.computedUptime < 1) {
+      maxRowWidth = Math.max(
+        maxRowWidth,
+        keyColWidth + measureText(formatUptime(node.computedUptime), META_FONT_SIZE)
+      );
+    }
+    if (node.computedAvailability < 1) {
+      maxRowWidth = Math.max(
+        maxRowWidth,
+        keyColWidth + measureText(formatUptime(node.computedAvailability), META_FONT_SIZE)
+      );
+    }
+    if (node.computedCbState === "open") {
+      maxRowWidth = Math.max(
+        maxRowWidth,
+        measureText("CB: OPEN", META_FONT_SIZE) + 8
+      );
+    }
+  }
+  const DESC_MAX_WIDTH = 120 * CHAR_WIDTH_RATIO * META_FONT_SIZE;
+  const descLines = expanded && node.description && !node.isEdge ? node.description : [];
+  let descWidth = 0;
+  for (const dl of descLines) {
+    const truncated = truncateText(dl, META_FONT_SIZE, DESC_MAX_WIDTH);
+    descWidth = Math.max(
+      descWidth,
+      measureText(truncated, META_FONT_SIZE) + PADDING_X
+    );
+  }
+  return Math.max(MIN_NODE_WIDTH, labelWidth, maxRowWidth + 20, descWidth);
+}
+function computeNodeHeight(node, expanded, options) {
+  const propCount = countDisplayProps(node, expanded, options);
+  const computedCount = countComputedRows(node, expanded);
+  const hasRps = node.computedRps > 0;
+  const descLineCount = expanded && node.description && !node.isEdge ? node.description.length : 0;
+  const descH = descLineCount * META_LINE_HEIGHT;
+  if (propCount === 0 && computedCount === 0 && !hasRps)
+    return NODE_HEADER_HEIGHT + descH + NODE_PAD_BOTTOM;
+  let h = NODE_HEADER_HEIGHT + descH + NODE_SEPARATOR_GAP;
+  const computedSectionCount = (hasRps ? 1 : 0) + computedCount;
+  h += computedSectionCount * META_LINE_HEIGHT;
+  if (computedSectionCount > 0 && propCount > 0) h += NODE_SEPARATOR_GAP;
+  h += propCount * META_LINE_HEIGHT;
+  if (hasRoles(node)) h += ROLE_DOT_ROW;
+  h += NODE_PAD_BOTTOM;
+  if (node.id.startsWith("[")) h += COLLAPSE_BAR_HEIGHT;
+  return h;
+}
+function formatRps(rps) {
+  if (rps >= 1e3) return `${(rps / 1e3).toFixed(1)}k rps`;
+  return `${Math.round(rps)} rps`;
+}
+function formatRpsShort(rps) {
+  if (rps >= 1e3) return `${(rps / 1e3).toFixed(1)}k`;
+  return `${Math.round(rps)}`;
+}
+function getNumProp(node, key, fallback) {
+  const p = node.properties.find((pr) => pr.key === key);
+  if (!p) return fallback;
+  return typeof p.value === "number" ? p.value : parseFloat(String(p.value)) || fallback;
+}
+function formatMs(ms) {
+  if (ms >= 1e3) return `${(ms / 1e3).toFixed(1)}s`;
+  return `${Math.round(ms)}ms`;
+}
+function formatUptime(fraction) {
+  const pct = fraction * 100;
+  if (pct >= 99.99) return "99.99%";
+  if (pct >= 99.9) return `${pct.toFixed(2)}%`;
+  if (pct >= 99) return `${pct.toFixed(1)}%`;
+  return `${pct.toFixed(1)}%`;
+}
+var GROUP_GAP = GROUP_PADDING * 2 + GROUP_HEADER_HEIGHT;
+function separateGroups(groups, nodes, isLR, maxIterations = 20) {
+  const groupDeltas = /* @__PURE__ */ new Map();
+  let converged = false;
+  for (let iter = 0; iter < maxIterations; iter++) {
+    let anyOverlap = false;
+    for (let i = 0; i < groups.length; i++) {
+      for (let j = i + 1; j < groups.length; j++) {
+        const ga = groups[i];
+        const gb = groups[j];
+        const primaryOverlap = isLR ? Math.min(ga.y + ga.height, gb.y + gb.height) - Math.max(ga.y, gb.y) : Math.min(ga.x + ga.width, gb.x + gb.width) - Math.max(ga.x, gb.x);
+        if (primaryOverlap <= 0) continue;
+        const crossOverlap = isLR ? Math.min(ga.x + ga.width, gb.x + gb.width) - Math.max(ga.x, gb.x) : Math.min(ga.y + ga.height, gb.y + gb.height) - Math.max(ga.y, gb.y);
+        if (crossOverlap <= 0) continue;
+        anyOverlap = true;
+        const shift = primaryOverlap + GROUP_GAP;
+        const aCenter = isLR ? ga.y + ga.height / 2 : ga.x + ga.width / 2;
+        const bCenter = isLR ? gb.y + gb.height / 2 : gb.x + gb.width / 2;
+        const groupToShift = aCenter <= bCenter ? gb : ga;
+        if (isLR) groupToShift.y += shift;
+        else groupToShift.x += shift;
+        const prev = groupDeltas.get(groupToShift.id) ?? { dx: 0, dy: 0 };
+        if (isLR)
+          groupDeltas.set(groupToShift.id, {
+            dx: prev.dx,
+            dy: prev.dy + shift
+          });
+        else
+          groupDeltas.set(groupToShift.id, {
+            dx: prev.dx + shift,
+            dy: prev.dy
+          });
+        for (const node of nodes) {
+          if (node.groupId === groupToShift.id) {
+            if (isLR) node.y += shift;
+            else node.x += shift;
+          }
+        }
+      }
+    }
+    if (!anyOverlap) {
+      converged = true;
+      break;
+    }
+  }
+  if (!converged && maxIterations > 0) {
+    console.warn(
+      `separateGroups: hit maxIterations (${maxIterations}) without fully resolving all group overlaps`
+    );
+  }
+  return groupDeltas;
+}
+function fixEdgeWaypoints(edges, nodes, groupDeltas) {
+  if (groupDeltas.size === 0) return;
+  const nodeToGroup = /* @__PURE__ */ new Map();
+  for (const node of nodes) nodeToGroup.set(node.id, node.groupId);
+  for (const edge of edges) {
+    const srcGroup = nodeToGroup.get(edge.sourceId) ?? null;
+    const tgtGroup = nodeToGroup.get(edge.targetId) ?? null;
+    const srcDelta = srcGroup ? groupDeltas.get(srcGroup) : void 0;
+    const tgtDelta = tgtGroup ? groupDeltas.get(tgtGroup) : void 0;
+    if (!srcDelta && !tgtDelta) continue;
+    if (srcDelta && tgtDelta && srcGroup !== tgtGroup) {
+      edge.points = [];
+      continue;
+    }
+    const delta = srcDelta ?? tgtDelta;
+    for (const pt of edge.points) {
+      pt.x += delta.dx;
+      pt.y += delta.dy;
+    }
+  }
+}
+function layoutInfra(computed, expandedNodeIds, collapsedNodes) {
+  if (computed.nodes.length === 0) {
+    return {
+      nodes: [],
+      edges: [],
+      groups: [],
+      options: {},
+      direction: computed.direction,
+      width: 0,
+      height: 0
+    };
+  }
+  const isLR = computed.direction !== "TB";
+  const g = new dagre.graphlib.Graph();
+  g.setGraph({
+    rankdir: computed.direction === "TB" ? "TB" : "LR",
+    nodesep: isLR ? 70 : 60,
+    ranksep: isLR ? 150 : 120,
+    edgesep: 30
+  });
+  g.setDefaultEdgeLabel(() => ({}));
+  const groupedNodeIds = /* @__PURE__ */ new Set();
+  for (const node of computed.nodes) {
+    if (node.groupId) groupedNodeIds.add(node.id);
+  }
+  const GROUP_INFLATE = GROUP_PADDING * 2 + GROUP_HEADER_HEIGHT;
+  const widthMap = /* @__PURE__ */ new Map();
+  const heightMap = /* @__PURE__ */ new Map();
+  for (const node of computed.nodes) {
+    const isNodeCollapsed = collapsedNodes?.has(node.id) ?? false;
+    const expanded = !isNodeCollapsed && (expandedNodeIds?.has(node.id) ?? false);
+    const width = computeNodeWidth(node, expanded, computed.options);
+    const height = isNodeCollapsed ? NODE_HEADER_HEIGHT + NODE_PAD_BOTTOM : computeNodeHeight(node, expanded, computed.options);
+    widthMap.set(node.id, width);
+    heightMap.set(node.id, height);
+    const inGroup = groupedNodeIds.has(node.id);
+    g.setNode(node.id, {
+      label: node.label,
+      width: inGroup && !isLR ? width + GROUP_INFLATE : width,
+      height: inGroup && isLR ? height + GROUP_INFLATE : height
+    });
+  }
+  const groupChildIds = /* @__PURE__ */ new Set();
+  for (const node of computed.nodes) {
+    if (node.groupId) groupChildIds.add(node.id);
+  }
+  const groupChildren = /* @__PURE__ */ new Map();
+  for (const node of computed.nodes) {
+    if (node.groupId) {
+      const list = groupChildren.get(node.groupId) ?? [];
+      list.push(node.id);
+      groupChildren.set(node.groupId, list);
+    }
+  }
+  for (const edge of computed.edges) {
+    const children = groupChildren.get(edge.targetId);
+    if (children && children.length > 0) {
+      for (const childId of children) {
+        g.setEdge(edge.sourceId, childId, { label: edge.label });
+      }
+    } else {
+      g.setEdge(edge.sourceId, edge.targetId, { label: edge.label });
+    }
+  }
+  dagre.layout(g);
+  const layoutNodes = computed.nodes.map(
+    (node) => {
+      const pos = g.node(node.id);
+      return {
+        id: node.id,
+        label: node.label,
+        x: pos.x,
+        y: pos.y,
+        width: widthMap.get(node.id) ?? MIN_NODE_WIDTH,
+        height: heightMap.get(node.id) ?? NODE_HEADER_HEIGHT + NODE_PAD_BOTTOM,
+        computedRps: node.computedRps,
+        overloaded: node.overloaded,
+        rateLimited: node.rateLimited,
+        isEdge: node.isEdge,
+        groupId: node.groupId,
+        computedLatencyMs: node.computedLatencyMs,
+        computedLatencyPercentiles: node.computedLatencyPercentiles,
+        computedUptime: node.computedUptime,
+        computedAvailability: node.computedAvailability,
+        computedAvailabilityPercentiles: node.computedAvailabilityPercentiles,
+        computedInstances: node.computedInstances,
+        computedConcurrentInvocations: node.computedConcurrentInvocations,
+        computedCbState: node.computedCbState,
+        ...node.childHealthState !== void 0 && {
+          childHealthState: node.childHealthState
+        },
+        ...node.queueMetrics !== void 0 && {
+          queueMetrics: node.queueMetrics
+        },
+        properties: node.properties,
+        tags: node.tags,
+        ...node.description !== void 0 && {
+          description: node.description
+        },
+        lineNumber: node.lineNumber
+      };
+    }
+  );
+  const layoutEdges = [];
+  for (const edge of computed.edges) {
+    const children = groupChildren.get(edge.targetId);
+    if (children && children.length > 0) {
+      const edgeData = g.edge(edge.sourceId, children[0]);
+      layoutEdges.push({
+        sourceId: edge.sourceId,
+        targetId: edge.targetId,
+        label: edge.label,
+        async: edge.async,
+        computedRps: edge.computedRps,
+        split: edge.split,
+        fanout: edge.fanout,
+        points: edgeData?.points ?? [],
+        lineNumber: edge.lineNumber
+      });
+    } else {
+      const edgeData = g.edge(edge.sourceId, edge.targetId);
+      layoutEdges.push({
+        sourceId: edge.sourceId,
+        targetId: edge.targetId,
+        label: edge.label,
+        async: edge.async,
+        computedRps: edge.computedRps,
+        split: edge.split,
+        fanout: edge.fanout,
+        points: edgeData?.points ?? [],
+        lineNumber: edge.lineNumber
+      });
+    }
+  }
+  const layoutGroups = computed.groups.map(
+    (group) => {
+      const childNodes = layoutNodes.filter((n) => n.groupId === group.id);
+      if (childNodes.length === 0) {
+        return {
+          id: group.id,
+          label: group.label,
+          x: 0,
+          y: 0,
+          width: MIN_NODE_WIDTH,
+          height: NODE_HEADER_HEIGHT + NODE_PAD_BOTTOM,
+          ...group.instances !== void 0 && { instances: group.instances },
+          lineNumber: group.lineNumber
+        };
+      }
+      let minX2 = Infinity, minY2 = Infinity, maxX2 = -Infinity, maxY2 = -Infinity;
+      for (const child of childNodes) {
+        const left = child.x - child.width / 2;
+        const right = child.x + child.width / 2;
+        const top = child.y - child.height / 2;
+        const bottom = child.y + child.height / 2;
+        if (left < minX2) minX2 = left;
+        if (right > maxX2) maxX2 = right;
+        if (top < minY2) minY2 = top;
+        if (bottom > maxY2) maxY2 = bottom;
+      }
+      return {
+        id: group.id,
+        label: group.label,
+        x: minX2 - GROUP_PADDING,
+        y: minY2 - GROUP_PADDING - GROUP_HEADER_HEIGHT,
+        width: maxX2 - minX2 + GROUP_PADDING * 2,
+        height: maxY2 - minY2 + GROUP_PADDING * 2 + GROUP_HEADER_HEIGHT,
+        ...group.instances !== void 0 && { instances: group.instances },
+        lineNumber: group.lineNumber
+      };
+    }
+  );
+  const groupDeltas = separateGroups(layoutGroups, layoutNodes, isLR);
+  fixEdgeWaypoints(layoutEdges, layoutNodes, groupDeltas);
+  let minX = Infinity, minY = Infinity, maxX = -Infinity, maxY = -Infinity;
+  for (const node of layoutNodes) {
+    const left = node.x - node.width / 2;
+    const right = node.x + node.width / 2;
+    const top = node.y - node.height / 2;
+    const bottom = node.y + node.height / 2;
+    if (left < minX) minX = left;
+    if (right > maxX) maxX = right;
+    if (top < minY) minY = top;
+    if (bottom > maxY) maxY = bottom;
+  }
+  for (const group of layoutGroups) {
+    if (group.x < minX) minX = group.x;
+    if (group.x + group.width > maxX) maxX = group.x + group.width;
+    if (group.y < minY) minY = group.y;
+    if (group.y + group.height > maxY) maxY = group.y + group.height;
+  }
+  for (const edge of layoutEdges) {
+    for (const pt of edge.points) {
+      if (pt.x < minX) minX = pt.x;
+      if (pt.x > maxX) maxX = pt.x;
+      if (pt.y < minY) minY = pt.y;
+      if (pt.y > maxY) maxY = pt.y;
+    }
+    if (edge.label) {
+      const midIdx = Math.floor(edge.points.length / 2);
+      const midPt = edge.points[midIdx];
+      if (midPt) {
+        const halfWidth = (measureText(edge.label, EDGE_LABEL_FONT_SIZE) + 8) / 2;
+        if (midPt.x - halfWidth < minX) minX = midPt.x - halfWidth;
+        if (midPt.x + halfWidth > maxX) maxX = midPt.x + halfWidth;
+      }
+    }
+  }
+  const shiftX = -minX + EDGE_MARGIN;
+  const shiftY = -minY + EDGE_MARGIN;
+  for (const node of layoutNodes) {
+    node.x += shiftX;
+    node.y += shiftY;
+  }
+  for (const edge of layoutEdges) {
+    for (const pt of edge.points) {
+      pt.x += shiftX;
+      pt.y += shiftY;
+    }
+  }
+  for (const group of layoutGroups) {
+    group.x += shiftX;
+    group.y += shiftY;
+  }
+  const totalWidth = maxX + shiftX + EDGE_MARGIN;
+  const totalHeight = maxY + shiftY + EDGE_MARGIN;
+  return {
+    nodes: layoutNodes,
+    edges: layoutEdges,
+    groups: layoutGroups,
+    options: computed.options,
+    direction: computed.direction,
+    width: totalWidth,
+    height: totalHeight
+  };
+}
+
+export {
+  separateGroups,
+  fixEdgeWaypoints,
+  layoutInfra
+};
+//# sourceMappingURL=chunk-Y2ZE3MSG.js.map