@diagrammo/dgmo 0.46.0 → 0.47.0

package/dist/chunk-J5FIXQRT.js

@@ -0,0 +1,813 @@
+import {
+  LEGEND_CAPSULE_PAD,
+  LEGEND_DOT_R,
+  LEGEND_ENTRY_DOT_GAP,
+  LEGEND_ENTRY_FONT_SIZE,
+  LEGEND_ENTRY_TRAIL,
+  LEGEND_EYE_GAP,
+  LEGEND_EYE_SIZE,
+  LEGEND_GROUP_GAP,
+  LEGEND_HEIGHT,
+  LEGEND_PILL_FONT_SIZE,
+  LEGEND_PILL_PAD,
+  measureLegendText
+} from "./chunk-QOOUC2J5.js";
+import {
+  measureText
+} from "./chunk-WCT3NYCV.js";
+import {
+  injectDefaultTagMetadata,
+  resolveTagColor,
+  tagAttrKey
+} from "./chunk-QLCCJEJI.js";
+
+// src/org/layout.ts
+import { hierarchy, tree } from "d3-hierarchy";
+var LABEL_FONT_SIZE = 13;
+var META_FONT_SIZE = 11;
+var META_LINE_HEIGHT = 16;
+var HEADER_HEIGHT = 28;
+var SEPARATOR_GAP = 6;
+var CARD_H_PAD = 20;
+var CARD_V_PAD = 10;
+var MIN_CARD_WIDTH = 140;
+var H_GAP = 30;
+var V_GAP = 50;
+var MARGIN = 40;
+var CONTAINER_PAD_X = 24;
+var CONTAINER_PAD_BOTTOM = 24;
+var CONTAINER_LABEL_HEIGHT = 28;
+var CONTAINER_META_LINE_HEIGHT = 16;
+var STACK_V_GAP = 20;
+function countDescendantNodes(node, hiddenCounts) {
+  let count = 0;
+  for (const child of node.children) {
+    count += (child.isContainer ? 0 : 1) + countDescendantNodes(child, hiddenCounts);
+    const hc = hiddenCounts?.get(child.id);
+    if (hc) count += hc;
+  }
+  return count;
+}
+function filterMetadata(metadata, hiddenAttributes) {
+  if (!hiddenAttributes || hiddenAttributes.size === 0) return metadata;
+  const filtered = {};
+  for (const [key, value] of Object.entries(metadata)) {
+    if (!hiddenAttributes.has(key)) {
+      filtered[key] = value;
+    }
+  }
+  return filtered;
+}
+function computeCardWidth(label, meta) {
+  let maxTextWidth = measureText(label, LABEL_FONT_SIZE);
+  for (const [key, value] of Object.entries(meta)) {
+    const lineWidth = measureText(`${key}: ${value}`, META_FONT_SIZE);
+    if (lineWidth > maxTextWidth) maxTextWidth = lineWidth;
+  }
+  return Math.max(MIN_CARD_WIDTH, Math.ceil(maxTextWidth) + CARD_H_PAD * 2);
+}
+function computeCardHeight(meta) {
+  const metaCount = Object.keys(meta).length;
+  if (metaCount === 0) return HEADER_HEIGHT + CARD_V_PAD;
+  return HEADER_HEIGHT + SEPARATOR_GAP + metaCount * META_LINE_HEIGHT + CARD_V_PAD;
+}
+function resolveNodeColor(node, tagGroups, activeGroupName) {
+  if (node.color) return node.color;
+  return resolveTagColor(
+    node.metadata,
+    [...tagGroups],
+    activeGroupName,
+    node.isContainer
+  );
+}
+function buildTreeNodes(nodes, hiddenCounts, hiddenAttributes, subNodeLabel, showSubNodeCount) {
+  return nodes.map((orgNode) => {
+    const meta = filterMetadata(orgNode.metadata, hiddenAttributes);
+    const hc = hiddenCounts?.get(orgNode.id);
+    if (!orgNode.isContainer && showSubNodeCount && !(hc != null && hc > 0)) {
+      const count = countDescendantNodes(orgNode, hiddenCounts);
+      if (count > 0) {
+        meta[subNodeLabel ?? "Sub-node Count"] = String(count);
+      }
+    }
+    return {
+      orgNode,
+      children: buildTreeNodes(
+        orgNode.children,
+        hiddenCounts,
+        hiddenAttributes,
+        subNodeLabel,
+        showSubNodeCount
+      ),
+      width: computeCardWidth(orgNode.label, meta),
+      height: computeCardHeight(meta)
+    };
+  });
+}
+function countDescendants(node) {
+  let count = 0;
+  for (const child of node.children) {
+    count += 1 + countDescendants(child);
+  }
+  return count;
+}
+function centerHeavyChildren(node) {
+  for (const child of node.children) {
+    centerHeavyChildren(child);
+  }
+  if (node.children.length <= 2) return;
+  const weighted = node.children.map((child) => ({ child, weight: countDescendants(child) })).sort((a, b) => b.weight - a.weight);
+  const result = new Array(weighted.length);
+  const mid = Math.floor((weighted.length - 1) / 2);
+  let left = mid;
+  let right = mid;
+  for (let i = 0; i < weighted.length; i++) {
+    const w = weighted[i];
+    if (i === 0) {
+      result[mid] = w.child;
+    } else if (i % 2 === 1) {
+      right++;
+      result[right] = w.child;
+    } else {
+      left--;
+      result[left] = w.child;
+    }
+  }
+  node.children = result;
+}
+function computeLegendGroups(tagGroups, showEyeIcons, usedValuesByGroup) {
+  const groups = [];
+  for (const group of tagGroups) {
+    if (group.entries.length === 0) continue;
+    const usedValues = usedValuesByGroup?.get(tagAttrKey(group.name));
+    const visibleEntries = usedValues ? group.entries.filter((e) => usedValues.has(e.value.toLowerCase())) : group.entries;
+    if (visibleEntries.length === 0) continue;
+    const pillWidth = measureLegendText(group.name, LEGEND_PILL_FONT_SIZE) + LEGEND_PILL_PAD;
+    const minPillWidth = pillWidth;
+    let entriesWidth = 0;
+    for (const entry of visibleEntries) {
+      entriesWidth += LEGEND_DOT_R * 2 + LEGEND_ENTRY_DOT_GAP + measureLegendText(entry.value, LEGEND_ENTRY_FONT_SIZE) + LEGEND_ENTRY_TRAIL;
+    }
+    const eyeSpace = showEyeIcons ? LEGEND_EYE_SIZE + LEGEND_EYE_GAP : 0;
+    const capsuleWidth = LEGEND_CAPSULE_PAD * 2 + pillWidth + 4 + eyeSpace + entriesWidth;
+    groups.push({
+      name: group.name,
+      ...group.alias !== void 0 && { alias: group.alias },
+      entries: visibleEntries.map((e) => ({
+        value: e.value,
+        color: e.color
+      })),
+      x: 0,
+      y: 0,
+      width: capsuleWidth,
+      height: LEGEND_HEIGHT,
+      minifiedWidth: minPillWidth,
+      minifiedHeight: LEGEND_HEIGHT
+    });
+  }
+  return groups;
+}
+function injectDefaultMetadata(roots, tagGroups) {
+  const allNodes = [];
+  const collect = (node) => {
+    allNodes.push(node);
+    for (const child of node.children) collect(child);
+  };
+  for (const root of roots) collect(root);
+  injectDefaultTagMetadata(
+    allNodes,
+    tagGroups,
+    (entity) => entity.isContainer
+  );
+}
+function layoutOrg(parsed, hiddenCounts, activeTagGroup, hiddenAttributes, expandAllLegend) {
+  if (parsed.roots.length === 0) {
+    const showEyeIcons2 = hiddenAttributes !== void 0;
+    const legendGroups2 = computeLegendGroups(parsed.tagGroups, showEyeIcons2);
+    if (legendGroups2.length === 0) {
+      return {
+        nodes: [],
+        edges: [],
+        containers: [],
+        legend: [],
+        width: 0,
+        height: 0
+      };
+    }
+    let cy = MARGIN;
+    let maxWidth2 = 0;
+    for (const g of legendGroups2) {
+      g.x = MARGIN;
+      g.y = cy;
+      cy += LEGEND_HEIGHT + LEGEND_GROUP_GAP;
+      if (g.width > maxWidth2) maxWidth2 = g.width;
+    }
+    return {
+      nodes: [],
+      edges: [],
+      containers: [],
+      legend: legendGroups2,
+      width: maxWidth2 + MARGIN * 2,
+      height: cy - LEGEND_GROUP_GAP + MARGIN
+    };
+  }
+  injectDefaultMetadata(parsed.roots, parsed.tagGroups);
+  const subNodeLabel = parsed.options["sub-node-label"] ?? void 0;
+  const showSubNodeCount = ["yes", "on"].includes(
+    parsed.options["show-sub-node-count"]?.toLowerCase() ?? ""
+  );
+  const treeNodes = buildTreeNodes(
+    parsed.roots,
+    hiddenCounts,
+    hiddenAttributes,
+    subNodeLabel,
+    showSubNodeCount
+  );
+  let root;
+  if (treeNodes.length === 1) {
+    root = treeNodes[0];
+  } else {
+    root = {
+      orgNode: {
+        id: "__virtual_root__",
+        label: "",
+        metadata: {},
+        children: parsed.roots,
+        parentId: null,
+        isContainer: false,
+        lineNumber: 0
+      },
+      children: treeNodes,
+      width: 0,
+      height: 0
+    };
+  }
+  let maxWidth = 0;
+  let maxHeight = 0;
+  const allTreeNodes = [];
+  const collectNodes = (tn) => {
+    if (tn.orgNode.id !== "__virtual_root__") {
+      allTreeNodes.push(tn);
+      if (tn.width > maxWidth) maxWidth = tn.width;
+      if (tn.height > maxHeight) maxHeight = tn.height;
+    }
+    for (const child of tn.children) collectNodes(child);
+  };
+  collectNodes(root);
+  for (const tn of allTreeNodes) {
+    tn.width = maxWidth;
+  }
+  const leafStacks = /* @__PURE__ */ new Map();
+  const collapseLeafContainers = (tn) => {
+    for (const child of tn.children) collapseLeafContainers(child);
+    if (tn.orgNode.isContainer && tn.children.length > 0 && tn.children.every((c) => c.children.length === 0)) {
+      const placeholderId = `__stack_${tn.orgNode.id}`;
+      leafStacks.set(tn.orgNode.id, {
+        children: [...tn.children],
+        placeholderId
+      });
+      const maxW = Math.max(...tn.children.map((c) => c.width));
+      for (const child of tn.children) {
+        child.width = maxW;
+      }
+      const totalH = tn.children.reduce((s, c) => s + c.height, 0) + (tn.children.length - 1) * STACK_V_GAP;
+      tn.children = [
+        {
+          orgNode: {
+            id: placeholderId,
+            label: "",
+            metadata: {},
+            children: [],
+            parentId: tn.orgNode.id,
+            isContainer: false,
+            lineNumber: 0
+          },
+          children: [],
+          width: maxW,
+          height: totalH
+        }
+      ];
+    }
+  };
+  collapseLeafContainers(root);
+  centerHeavyChildren(root);
+  const h = hierarchy(root, (d) => d.children);
+  const treeLayout = tree().nodeSize([
+    maxWidth + H_GAP,
+    maxHeight + V_GAP
+  ]);
+  treeLayout(h);
+  {
+    const descendants = h.descendants().filter((d) => d.data.orgNode.id !== "__virtual_root__");
+    const levelMaxHeight = /* @__PURE__ */ new Map();
+    for (const d of descendants) {
+      if (d.data.orgNode.id.startsWith("__stack_")) continue;
+      const cur = levelMaxHeight.get(d.depth) ?? 0;
+      if (d.data.height > cur) levelMaxHeight.set(d.depth, d.data.height);
+    }
+    const maxDepth = Math.max(...levelMaxHeight.keys(), 0);
+    const compactedY = /* @__PURE__ */ new Map();
+    const rootDepth = treeNodes.length === 1 ? 0 : 1;
+    compactedY.set(rootDepth, 0);
+    for (let d = rootDepth + 1; d <= maxDepth; d++) {
+      const parentH = levelMaxHeight.get(d - 1) ?? maxHeight;
+      const prevY = compactedY.get(d - 1) ?? 0;
+      compactedY.set(d, prevY + parentH + V_GAP);
+    }
+    for (const d of h.descendants()) {
+      if (d.data.orgNode.id === "__virtual_root__") continue;
+      d.y = compactedY.get(d.depth) ?? d.y;
+    }
+  }
+  for (const d of h.descendants()) {
+    if (d.data.orgNode.id === "__virtual_root__") continue;
+    if (!d.data.orgNode.isContainer) continue;
+    if (!d.children || d.children.length === 0) continue;
+    const childY = d.children[0].y;
+    const actualLevelGap = childY - d.y;
+    const metaCount = Object.keys(d.data.orgNode.metadata).length;
+    const headerHeight = CONTAINER_LABEL_HEIGHT + metaCount * CONTAINER_META_LINE_HEIGHT;
+    const desiredGap = headerHeight + 15;
+    const shiftUp = actualLevelGap - desiredGap;
+    if (shiftUp <= 0) continue;
+    const shift = (node) => {
+      if (node.children) {
+        for (const child of node.children) {
+          child.y -= shiftUp;
+          shift(child);
+        }
+      }
+    };
+    shift(d);
+  }
+  for (const d of h.descendants()) {
+    if (d.data.orgNode.id === "__virtual_root__") continue;
+    if (d.data.orgNode.isContainer) continue;
+    if (!d.children || d.children.length === 0) continue;
+    if (!d.children.every((c) => c.data.orgNode.isContainer)) continue;
+    const parentBottomY = d.y + d.data.height;
+    const firstChildY = Math.min(...d.children.map((c) => c.y));
+    const currentGap = firstChildY - parentBottomY;
+    const desiredGap = V_GAP * 0.6;
+    const shiftUp = currentGap - desiredGap;
+    if (shiftUp <= 0) continue;
+    const shiftDown = (node) => {
+      node.y -= shiftUp;
+      if (node.children) {
+        for (const child of node.children) {
+          shiftDown(child);
+        }
+      }
+    };
+    for (const child of d.children) {
+      shiftDown(child);
+    }
+  }
+  {
+    const subtreeExtent = (node) => {
+      let min = node.x - node.data.width / 2;
+      let max = node.x + node.data.width / 2;
+      if (node.children) {
+        for (const child of node.children) {
+          const childExt = subtreeExtent(child);
+          if (childExt.minX < min) min = childExt.minX;
+          if (childExt.maxX > max) max = childExt.maxX;
+        }
+      }
+      if (node.data.orgNode.isContainer) {
+        min -= CONTAINER_PAD_X;
+        max += CONTAINER_PAD_X;
+      }
+      return { minX: min, maxX: max };
+    };
+    const shiftX = (node, dx) => {
+      node.x += dx;
+      if (node.children) node.children.forEach((c) => shiftX(c, dx));
+    };
+    const internalNodes = h.descendants().filter((d) => d.children && d.children.length >= 2).sort((a, b) => b.depth - a.depth);
+    for (const parent of internalNodes) {
+      const children = parent.children;
+      const extents = children.map((child) => {
+        const ext = subtreeExtent(child);
+        return {
+          relLeft: ext.minX - child.x,
+          relRight: ext.maxX - child.x
+        };
+      });
+      const currentCenter = (children[0].x + children[children.length - 1].x) / 2;
+      const positions = [0];
+      for (let i = 1; i < children.length; i++) {
+        const prevRight = positions[i - 1] + extents[i - 1].relRight;
+        positions[i] = prevRight + H_GAP - extents[i].relLeft;
+      }
+      const newCenter = (positions[0] + positions[positions.length - 1]) / 2;
+      const centerShift = currentCenter - newCenter;
+      for (let i = 0; i < children.length; i++) {
+        const newX = positions[i] + centerShift;
+        const dx = newX - children[i].x;
+        if (Math.abs(dx) > 1e-3) {
+          shiftX(children[i], dx);
+        }
+      }
+    }
+  }
+  {
+    const parentNodes = h.descendants().filter(
+      (d) => d.children && d.children.length >= 1 && d.data.orgNode.id !== "__virtual_root__"
+    ).sort((a, b) => b.depth - a.depth);
+    for (const parent of parentNodes) {
+      const childXs = parent.children.map((c) => c.x);
+      const desiredX = (Math.min(...childXs) + Math.max(...childXs)) / 2;
+      parent.x = desiredX;
+    }
+  }
+  const layoutNodes = [];
+  const layoutEdges = [];
+  let minX = Infinity;
+  let maxX = -Infinity;
+  let minY = Infinity;
+  let maxY = -Infinity;
+  const expandedChildren = [];
+  for (const d of h.descendants()) {
+    if (d.data.orgNode.id === "__virtual_root__") continue;
+    if (!d.data.orgNode.id.startsWith("__stack_")) continue;
+    const containerId = d.data.orgNode.id.replace("__stack_", "");
+    const stack = leafStacks.get(containerId);
+    if (!stack) continue;
+    let currentY = d.y;
+    for (const child of stack.children) {
+      expandedChildren.push({
+        orgNode: child.orgNode,
+        width: child.width,
+        height: child.height,
+        cx: d.x,
+        cy: currentY
+      });
+      currentY += child.height + STACK_V_GAP;
+    }
+  }
+  for (const d of h.descendants()) {
+    if (d.data.orgNode.id === "__virtual_root__") continue;
+    if (d.data.orgNode.id.startsWith("__stack_")) continue;
+    const w = d.data.width;
+    const ht = d.data.height;
+    const cx = d.x;
+    const cy = d.y;
+    if (cx - w / 2 < minX) minX = cx - w / 2;
+    if (cx + w / 2 > maxX) maxX = cx + w / 2;
+    if (cy < minY) minY = cy;
+    if (cy + ht > maxY) maxY = cy + ht;
+  }
+  for (const ec of expandedChildren) {
+    if (ec.cx - ec.width / 2 < minX) minX = ec.cx - ec.width / 2;
+    if (ec.cx + ec.width / 2 > maxX) maxX = ec.cx + ec.width / 2;
+    if (ec.cy < minY) minY = ec.cy;
+    if (ec.cy + ec.height > maxY) maxY = ec.cy + ec.height;
+  }
+  const offsetX = -minX + MARGIN;
+  const offsetY = -minY + MARGIN;
+  const subNodeKey = subNodeLabel ?? "Sub-node Count";
+  for (const ec of expandedChildren) {
+    const hc = hiddenCounts?.get(ec.orgNode.id);
+    const meta = filterMetadata(ec.orgNode.metadata, hiddenAttributes);
+    if (!ec.orgNode.isContainer && showSubNodeCount && !(hc != null && hc > 0)) {
+      const count = countDescendantNodes(ec.orgNode, hiddenCounts);
+      if (count > 0) meta[subNodeKey] = String(count);
+    }
+    const ecColor = resolveNodeColor(
+      ec.orgNode,
+      parsed.tagGroups,
+      activeTagGroup ?? null
+    );
+    const ecHasChildren = ec.orgNode.children.length > 0 || hc != null && hc > 0 || void 0;
+    layoutNodes.push({
+      id: ec.orgNode.id,
+      label: ec.orgNode.label,
+      metadata: meta,
+      tagMetadata: { ...ec.orgNode.metadata },
+      isContainer: ec.orgNode.isContainer,
+      lineNumber: ec.orgNode.lineNumber,
+      ...ecColor !== void 0 && { color: ecColor },
+      x: ec.cx + offsetX,
+      y: ec.cy + offsetY,
+      width: ec.width,
+      height: ec.height,
+      ...hc !== void 0 && { hiddenCount: hc },
+      ...ecHasChildren !== void 0 && { hasChildren: ecHasChildren }
+    });
+  }
+  const busGroups = /* @__PURE__ */ new Map();
+  for (const d of h.descendants()) {
+    if (d.data.orgNode.id === "__virtual_root__") continue;
+    if (d.data.orgNode.id.startsWith("__stack_")) continue;
+    const orgNode = d.data.orgNode;
+    const w = d.data.width;
+    const ht = d.data.height;
+    const x = d.x + offsetX;
+    const y = d.y + offsetY;
+    const hc = hiddenCounts?.get(orgNode.id);
+    const nodeMeta = filterMetadata(orgNode.metadata, hiddenAttributes);
+    if (!orgNode.isContainer && showSubNodeCount && !(hc != null && hc > 0)) {
+      const count = countDescendantNodes(orgNode, hiddenCounts);
+      if (count > 0) nodeMeta[subNodeKey] = String(count);
+    }
+    const nodeColor = resolveNodeColor(
+      orgNode,
+      parsed.tagGroups,
+      activeTagGroup ?? null
+    );
+    const nodeHasChildren = d.children != null && d.children.length > 0 || hc != null && hc > 0 || void 0;
+    layoutNodes.push({
+      id: orgNode.id,
+      label: orgNode.label,
+      metadata: nodeMeta,
+      tagMetadata: { ...orgNode.metadata },
+      isContainer: orgNode.isContainer,
+      lineNumber: orgNode.lineNumber,
+      ...nodeColor !== void 0 && { color: nodeColor },
+      x,
+      y,
+      width: w,
+      height: ht,
+      ...hc !== void 0 && { hiddenCount: hc },
+      ...nodeHasChildren !== void 0 && { hasChildren: nodeHasChildren }
+    });
+    const parentIsContainerBox = d.parent?.data.orgNode.isContainer && d.parent.children && d.parent.children.length > 0;
+    if (d.parent && d.parent.data.orgNode.id !== "__virtual_root__" && !parentIsContainerBox) {
+      const parentId = d.parent.data.orgNode.id;
+      if (!busGroups.has(parentId)) {
+        const px = d.parent.x + offsetX;
+        const py = d.parent.y + offsetY;
+        const parentH = d.parent.data.height;
+        busGroups.set(parentId, {
+          parentX: px,
+          parentBottomY: py + parentH,
+          children: []
+        });
+      }
+      busGroups.get(parentId).children.push({
+        id: orgNode.id,
+        x,
+        topY: y
+      });
+    }
+  }
+  for (const [parentId, group] of busGroups) {
+    const { parentX, parentBottomY, children } = group;
+    if (children.length === 1) {
+      const child = children[0];
+      const midY = (parentBottomY + child.topY) / 2;
+      layoutEdges.push({
+        sourceId: parentId,
+        targetId: child.id,
+        points: [
+          { x: parentX, y: parentBottomY },
+          { x: parentX, y: midY },
+          { x: child.x, y: midY },
+          { x: child.x, y: child.topY }
+        ]
+      });
+    } else {
+      const midY = (parentBottomY + children[0].topY) / 2;
+      const childXs = children.map((c) => c.x);
+      const leftX = Math.min(...childXs);
+      const rightX = Math.max(...childXs);
+      layoutEdges.push({
+        sourceId: parentId,
+        targetId: parentId,
+        points: [
+          { x: parentX, y: parentBottomY },
+          { x: parentX, y: midY }
+        ]
+      });
+      layoutEdges.push({
+        sourceId: parentId,
+        targetId: parentId,
+        points: [
+          { x: leftX, y: midY },
+          { x: rightX, y: midY }
+        ]
+      });
+      for (const child of children) {
+        layoutEdges.push({
+          sourceId: parentId,
+          targetId: child.id,
+          points: [
+            { x: child.x, y: midY },
+            { x: child.x, y: child.topY }
+          ]
+        });
+      }
+    }
+  }
+  const allContainerNodes = h.descendants().filter(
+    (d) => d.data.orgNode.id !== "__virtual_root__" && d.data.orgNode.isContainer
+  );
+  const containerBoundsMap = /* @__PURE__ */ new Map();
+  const containers = [];
+  const EMPTY_CONTAINER_MIN_HEIGHT = 60;
+  for (const d of allContainerNodes) {
+    if (d.children && d.children.length > 0) continue;
+    const cx = d.x + offsetX;
+    const cy = d.y + offsetY;
+    const metaCount = Object.keys(d.data.orgNode.metadata).length;
+    const labelHeight = CONTAINER_LABEL_HEIGHT + metaCount * CONTAINER_META_LINE_HEIGHT;
+    const boxWidth = d.data.width;
+    const boxHeight = Math.max(
+      labelHeight + CONTAINER_PAD_BOTTOM,
+      EMPTY_CONTAINER_MIN_HEIGHT
+    );
+    const boxX = cx - boxWidth / 2;
+    const boxY = cy;
+    containerBoundsMap.set(d.data.orgNode.id, {
+      minX: boxX,
+      maxX: boxX + boxWidth,
+      minY: boxY,
+      maxY: boxY + boxHeight
+    });
+    const chc = hiddenCounts?.get(d.data.orgNode.id);
+    const cMeta = filterMetadata(d.data.orgNode.metadata, hiddenAttributes);
+    const cColor = resolveNodeColor(
+      d.data.orgNode,
+      parsed.tagGroups,
+      activeTagGroup ?? null
+    );
+    const cHasChildren = chc != null && chc > 0 || void 0;
+    containers.push({
+      nodeId: d.data.orgNode.id,
+      label: d.data.orgNode.label,
+      lineNumber: d.data.orgNode.lineNumber,
+      ...cColor !== void 0 && { color: cColor },
+      metadata: cMeta,
+      tagMetadata: { ...d.data.orgNode.metadata },
+      x: boxX,
+      y: boxY,
+      width: boxWidth,
+      height: boxHeight,
+      labelHeight,
+      ...chc !== void 0 && { hiddenCount: chc },
+      ...cHasChildren !== void 0 && { hasChildren: cHasChildren }
+    });
+  }
+  const containerCandidates = allContainerNodes.filter(
+    (d) => d.children && d.children.length > 0
+  );
+  containerCandidates.sort((a, b) => b.depth - a.depth);
+  for (const d of containerCandidates) {
+    const allDesc = [];
+    const collectDesc = (node) => {
+      if (node.children) {
+        for (const child of node.children) {
+          allDesc.push(child);
+          collectDesc(child);
+        }
+      }
+    };
+    collectDesc(d);
+    if (allDesc.length === 0) continue;
+    let descMinX = Infinity;
+    let descMaxX = -Infinity;
+    let descMaxY = -Infinity;
+    for (const desc of allDesc) {
+      const innerBounds = containerBoundsMap.get(desc.data.orgNode.id);
+      if (innerBounds) {
+        if (innerBounds.minX < descMinX) descMinX = innerBounds.minX;
+        if (innerBounds.maxX > descMaxX) descMaxX = innerBounds.maxX;
+        if (innerBounds.maxY > descMaxY) descMaxY = innerBounds.maxY;
+      } else if (desc.data.orgNode.id.startsWith("__stack_")) {
+        const cid = desc.data.orgNode.id.replace("__stack_", "");
+        const stack = leafStacks.get(cid);
+        if (stack) {
+          for (const ec of expandedChildren) {
+            if (ec.orgNode.parentId !== cid) continue;
+            const ex = ec.cx + offsetX;
+            const ey = ec.cy + offsetY;
+            if (ex - ec.width / 2 < descMinX) descMinX = ex - ec.width / 2;
+            if (ex + ec.width / 2 > descMaxX) descMaxX = ex + ec.width / 2;
+            if (ey + ec.height > descMaxY) descMaxY = ey + ec.height;
+          }
+        }
+      } else {
+        const dw = desc.data.width;
+        const dh = desc.data.height;
+        const dx = desc.x + offsetX;
+        const dy = desc.y + offsetY;
+        if (dx - dw / 2 < descMinX) descMinX = dx - dw / 2;
+        if (dx + dw / 2 > descMaxX) descMaxX = dx + dw / 2;
+        if (dy + dh > descMaxY) descMaxY = dy + dh;
+      }
+    }
+    const containerX = d.x + offsetX;
+    const containerY = d.y + offsetY;
+    const metaCount = Object.keys(d.data.orgNode.metadata).length;
+    const labelHeight = CONTAINER_LABEL_HEIGHT + metaCount * CONTAINER_META_LINE_HEIGHT;
+    const boxY = containerY;
+    const boxHeight = descMaxY - containerY + CONTAINER_PAD_BOTTOM;
+    const boxX = descMinX - CONTAINER_PAD_X;
+    const contentWidth = descMaxX - descMinX + CONTAINER_PAD_X * 2;
+    const finalBoxWidth = Math.max(contentWidth, d.data.width);
+    const centeredBoxX = finalBoxWidth > contentWidth ? containerX - finalBoxWidth / 2 : boxX;
+    containerBoundsMap.set(d.data.orgNode.id, {
+      minX: centeredBoxX,
+      maxX: centeredBoxX + finalBoxWidth,
+      minY: boxY,
+      maxY: boxY + boxHeight
+    });
+    const chc2 = hiddenCounts?.get(d.data.orgNode.id);
+    const cMeta2 = filterMetadata(d.data.orgNode.metadata, hiddenAttributes);
+    const c2Color = resolveNodeColor(
+      d.data.orgNode,
+      parsed.tagGroups,
+      activeTagGroup ?? null
+    );
+    containers.push({
+      nodeId: d.data.orgNode.id,
+      label: d.data.orgNode.label,
+      lineNumber: d.data.orgNode.lineNumber,
+      ...c2Color !== void 0 && { color: c2Color },
+      metadata: cMeta2,
+      tagMetadata: { ...d.data.orgNode.metadata },
+      x: centeredBoxX,
+      y: boxY,
+      width: finalBoxWidth,
+      height: boxHeight,
+      labelHeight,
+      ...chc2 !== void 0 && { hiddenCount: chc2 },
+      hasChildren: true
+    });
+  }
+  containers.reverse();
+  let finalMinX = minX;
+  let finalMaxX = maxX;
+  let finalMaxY = maxY;
+  for (const c of containers) {
+    const cLeft = c.x - offsetX;
+    const cRight = cLeft + c.width;
+    const cBottom = c.y - offsetY + c.height;
+    if (cLeft < finalMinX) finalMinX = cLeft;
+    if (cRight > finalMaxX) finalMaxX = cRight;
+    if (cBottom > finalMaxY) finalMaxY = cBottom;
+  }
+  const totalWidth = finalMaxX - finalMinX + MARGIN * 2;
+  const totalHeight = finalMaxY - minY + MARGIN * 2;
+  const usedValuesByGroup = /* @__PURE__ */ new Map();
+  for (const group of parsed.tagGroups) {
+    const key = tagAttrKey(group.name);
+    const used = /* @__PURE__ */ new Set();
+    const walk = (node) => {
+      if (!node.isContainer && node.metadata[key]) {
+        used.add(node.metadata[key].toLowerCase());
+      }
+      for (const child of node.children) walk(child);
+    };
+    for (const root2 of parsed.roots) walk(root2);
+    usedValuesByGroup.set(key, used);
+  }
+  const showEyeIcons = hiddenAttributes !== void 0;
+  const legendGroups = computeLegendGroups(
+    parsed.tagGroups,
+    showEyeIcons,
+    usedValuesByGroup
+  );
+  let finalWidth = totalWidth;
+  let finalHeight = totalHeight;
+  const visibleGroups = activeTagGroup != null ? legendGroups.filter(
+    (g) => g.name.toLowerCase() === activeTagGroup.toLowerCase()
+  ) : legendGroups;
+  const allExpanded = expandAllLegend && activeTagGroup == null;
+  const effectiveW = (g) => activeTagGroup != null || allExpanded ? g.width : g.minifiedWidth;
+  if (visibleGroups.length > 0) {
+    const legendShift = LEGEND_HEIGHT + LEGEND_GROUP_GAP;
+    for (const n of layoutNodes) n.y += legendShift;
+    for (const c of containers) c.y += legendShift;
+    for (const e of layoutEdges) {
+      for (const p of e.points)
+        p.y += legendShift;
+    }
+    const totalGroupsWidth = visibleGroups.reduce((s, g) => s + effectiveW(g), 0) + (visibleGroups.length - 1) * LEGEND_GROUP_GAP;
+    let cx = MARGIN;
+    for (const g of visibleGroups) {
+      g.x = cx;
+      g.y = MARGIN;
+      cx += effectiveW(g) + LEGEND_GROUP_GAP;
+    }
+    finalHeight += legendShift;
+    const neededWidth = totalGroupsWidth + MARGIN * 2;
+    if (neededWidth > finalWidth) {
+      finalWidth = neededWidth;
+    }
+  }
+  return {
+    nodes: layoutNodes,
+    edges: layoutEdges,
+    containers,
+    legend: legendGroups,
+    width: finalWidth,
+    height: finalHeight
+  };
+}
+
+export {
+  layoutOrg
+};
+//# sourceMappingURL=chunk-J5FIXQRT.js.map