@diagrammo/dgmo 0.46.0 → 0.48.0

package/dist/chunk-U6EQI3U6.js

@@ -0,0 +1,130 @@
+import {
+  TITLE_FONT_SIZE,
+  TITLE_FONT_WEIGHT,
+  TITLE_Y
+} from "./chunk-A4GOY3PE.js";
+import {
+  FONT_FAMILY
+} from "./chunk-6KFWC4CO.js";
+import {
+  getSeriesColors
+} from "./chunk-P6T66CCZ.js";
+
+// src/utils/d3-helpers.ts
+import * as d3Selection from "d3-selection";
+function renderChartTitle(svg, title, titleLineNumber, width, textColor, onClickItem) {
+  if (!title) return;
+  const titleEl = svg.append("text").attr("class", "chart-title").attr("x", width / 2).attr("y", TITLE_Y).attr("text-anchor", "middle").attr("fill", textColor).attr("font-size", TITLE_FONT_SIZE).attr("font-weight", TITLE_FONT_WEIGHT).style("cursor", onClickItem && titleLineNumber ? "pointer" : "default").text(title);
+  if (titleLineNumber) {
+    titleEl.attr("data-line-number", titleLineNumber);
+    if (onClickItem) {
+      titleEl.on("click", () => onClickItem(titleLineNumber)).on("mouseenter", function() {
+        d3Selection.select(this).attr("opacity", 0.7);
+      }).on("mouseleave", function() {
+        d3Selection.select(this).attr("opacity", 1);
+      });
+    }
+  }
+}
+function initD3Chart(container, palette, exportDims) {
+  d3Selection.select(container).selectAll(":not([data-d3-tooltip])").remove();
+  const width = exportDims?.width ?? container.clientWidth;
+  const height = exportDims?.height ?? container.clientHeight;
+  if (width <= 0 || height <= 0) return null;
+  const textColor = palette.text;
+  const mutedColor = palette.border;
+  const bgColor = palette.bg;
+  const colors = getSeriesColors(palette);
+  const svg = d3Selection.select(container).append("svg").attr("width", width).attr("height", height).attr("viewBox", `0 0 ${width} ${height}`).style("background", bgColor);
+  return { svg, width, height, textColor, mutedColor, bgColor, colors };
+}
+function createTooltip(container, palette, isDark) {
+  container.style.position = "relative";
+  const existing = container.querySelector("[data-d3-tooltip]");
+  if (existing) {
+    existing.style.display = "none";
+    existing.style.background = palette.surface;
+    existing.style.color = palette.text;
+    existing.style.boxShadow = isDark ? "0 2px 6px rgba(0,0,0,0.3)" : "0 2px 6px rgba(0,0,0,0.12)";
+    return existing;
+  }
+  const tip = document.createElement("div");
+  tip.setAttribute("data-d3-tooltip", "");
+  tip.style.position = "absolute";
+  tip.style.display = "none";
+  tip.style.pointerEvents = "none";
+  tip.style.background = palette.surface;
+  tip.style.color = palette.text;
+  tip.style.padding = "6px 10px";
+  tip.style.borderRadius = "4px";
+  tip.style.fontSize = "12px";
+  tip.style.lineHeight = "1.4";
+  tip.style.whiteSpace = "nowrap";
+  tip.style.zIndex = "10";
+  tip.style.boxShadow = isDark ? "0 2px 6px rgba(0,0,0,0.3)" : "0 2px 6px rgba(0,0,0,0.12)";
+  container.appendChild(tip);
+  return tip;
+}
+function showTooltip(tooltip, html, event) {
+  tooltip.innerHTML = html;
+  tooltip.style.display = "block";
+  const container = tooltip.parentElement;
+  const rect = container.getBoundingClientRect();
+  let left = event.clientX - rect.left + 12;
+  let top = event.clientY - rect.top - 28;
+  const tipW = tooltip.offsetWidth;
+  const tipH = tooltip.offsetHeight;
+  if (left + tipW > rect.width) left = rect.width - tipW - 4;
+  if (top < 0) top = event.clientY - rect.top + 16;
+  if (top + tipH > rect.height) top = rect.height - tipH - 4;
+  tooltip.style.left = `${left}px`;
+  tooltip.style.top = `${top}px`;
+}
+function hideTooltip(tooltip) {
+  tooltip.style.display = "none";
+}
+var EXPORT_WIDTH = 1200;
+var EXPORT_HEIGHT = 800;
+async function resolveExportPalette(theme, palette) {
+  if (palette) return palette;
+  const { getPalette } = await import("./palettes-PRJ2RI6D.js");
+  return theme === "dark" ? getPalette("nord").dark : getPalette("nord").light;
+}
+function createExportContainer(width, height) {
+  const container = document.createElement("div");
+  container.style.width = `${width}px`;
+  container.style.height = `${height}px`;
+  container.style.position = "absolute";
+  container.style.left = "-9999px";
+  document.body.appendChild(container);
+  return container;
+}
+function finalizeSvgExport(container, theme, palette) {
+  const svgEl = container.querySelector("svg");
+  if (!svgEl) return "";
+  if (theme === "transparent") {
+    svgEl.style.background = "none";
+  } else if (!svgEl.style.background) {
+    svgEl.style.background = palette.bg;
+  }
+  svgEl.setAttribute("xmlns", "http://www.w3.org/2000/svg");
+  svgEl.style.fontFamily = FONT_FAMILY;
+  svgEl.querySelectorAll("[data-export-ignore]").forEach((el) => el.remove());
+  const svgHtml = svgEl.outerHTML;
+  document.body.removeChild(container);
+  return svgHtml;
+}
+
+export {
+  renderChartTitle,
+  initD3Chart,
+  createTooltip,
+  showTooltip,
+  hideTooltip,
+  EXPORT_WIDTH,
+  EXPORT_HEIGHT,
+  resolveExportPalette,
+  createExportContainer,
+  finalizeSvgExport
+};
+//# sourceMappingURL=chunk-U6EQI3U6.js.map

package/dist/chunk-UJ4FJLBF.js

@@ -0,0 +1,86 @@
+import {
+  collapseTree
+} from "./chunk-BS7SV7C3.js";
+
+// src/org/collapse.ts
+function cloneNode(node) {
+  return {
+    id: node.id,
+    label: node.label,
+    metadata: { ...node.metadata },
+    children: node.children.map(cloneNode),
+    parentId: node.parentId,
+    isContainer: node.isContainer,
+    lineNumber: node.lineNumber,
+    ...node.color !== void 0 && { color: node.color }
+  };
+}
+var ORG_SHAPE = {
+  getId: (node) => node.id,
+  getChildren: (node) => node.children,
+  clone: cloneNode,
+  setChildren: (node, children) => {
+    node.children = children;
+  },
+  countsAsHidden: (node) => !node.isContainer
+};
+function collapseOrgTree(original, collapsedIds) {
+  if (collapsedIds.size === 0) {
+    return { parsed: original, hiddenCounts: /* @__PURE__ */ new Map() };
+  }
+  const { roots, hiddenCounts } = collapseTree(
+    original.roots,
+    collapsedIds,
+    ORG_SHAPE
+  );
+  return { parsed: { ...original, roots }, hiddenCounts };
+}
+function findNodeWithPath(nodes, targetId, path) {
+  for (const node of nodes) {
+    if (node.id === targetId) {
+      return { node, path };
+    }
+    const result = findNodeWithPath(node.children, targetId, [
+      ...path,
+      {
+        id: node.id,
+        label: node.label,
+        lineNumber: node.lineNumber,
+        ...node.color !== void 0 && { color: node.color },
+        metadata: { ...node.metadata },
+        isContainer: node.isContainer
+      }
+    ]);
+    if (result) return result;
+  }
+  return null;
+}
+function focusOrgTree(original, focusNodeId) {
+  const found = findNodeWithPath(original.roots, focusNodeId, []);
+  if (!found) return null;
+  const isRoot = original.roots.some((r) => r.id === focusNodeId);
+  if (isRoot) {
+    return {
+      parsed: {
+        ...original,
+        roots: [cloneNode(found.node)]
+      },
+      ancestorPath: []
+    };
+  }
+  const cloned = cloneNode(found.node);
+  cloned.parentId = null;
+  return {
+    parsed: {
+      ...original,
+      roots: [cloned]
+    },
+    ancestorPath: found.path
+  };
+}
+
+export {
+  collapseOrgTree,
+  focusOrgTree
+};
+//# sourceMappingURL=chunk-UJ4FJLBF.js.map

package/dist/chunk-ULOEATBZ.js

@@ -0,0 +1,347 @@
+import {
+  buildHeatScale,
+  buildLegend,
+  compactNumber,
+  formatPct,
+  resolveCellColor,
+  resolveColorMode
+} from "./chunk-IZMRON6C.js";
+import {
+  renderIntegratedLegend
+} from "./chunk-PWIHZ6NJ.js";
+import {
+  getMaxLegendReservedHeight
+} from "./chunk-YAA6IID3.js";
+import {
+  FONT_FAMILY
+} from "./chunk-6KFWC4CO.js";
+import {
+  LEGEND_GROUP_GAP
+} from "./chunk-QOOUC2J5.js";
+import {
+  measureText
+} from "./chunk-WCT3NYCV.js";
+import {
+  contrastText,
+  getSeriesColors
+} from "./chunk-P6T66CCZ.js";
+import {
+  tagAttrKey
+} from "./chunk-QLCCJEJI.js";
+
+// src/treemap/renderer-radial.ts
+import * as d3Selection from "d3-selection";
+import { arc as d3arc } from "d3-shape";
+
+// src/treemap/layout-radial.ts
+import {
+  hierarchy,
+  partition
+} from "d3-hierarchy";
+function toDatum(node) {
+  if (node.children.length === 0) {
+    return {
+      ref: node,
+      label: node.label,
+      value: node.value ?? 0,
+      ...node.heat !== void 0 && { heat: node.heat },
+      lineNumber: node.lineNumber
+    };
+  }
+  return {
+    ref: node,
+    label: node.label,
+    ...node.heat !== void 0 && { heat: node.heat },
+    lineNumber: node.lineNumber,
+    children: node.children.map((c) => toDatum(c))
+  };
+}
+function datumHeat(node) {
+  if (node.data.heat !== void 0) return node.data.heat;
+  const xs = [];
+  for (const l of node.leaves()) {
+    if (l.data.heat !== void 0) xs.push(l.data.heat);
+  }
+  if (xs.length === 0) return void 0;
+  return xs.reduce((a, b) => a + b, 0) / xs.length;
+}
+function defaultDiscRadius(radius, treeDepth) {
+  const frac = radius * 0.32;
+  const share = radius / (Math.max(1, treeDepth) + 1);
+  return Math.min(frac, share);
+}
+function layoutTreemapRadial(roots, opts) {
+  const maxDepth = opts.maxDepth ?? Infinity;
+  const radius = Math.max(1, opts.radius);
+  const rootDatum = {
+    label: "__root",
+    children: roots.map((r) => toDatum(r))
+  };
+  const h = hierarchy(rootDatum).sum(
+    (d) => d.children?.length ? 0 : d.value ?? 0
+  );
+  const total = h.value ?? 0;
+  if (total <= 0) {
+    return {
+      cells: [],
+      total: 0,
+      discRadius: opts.discRadius ?? defaultDiscRadius(radius, 1),
+      maxDepthReached: 0,
+      isEmpty: true
+    };
+  }
+  const hroot = partition().size([2 * Math.PI, 1])(h);
+  const treeDepth = hroot.height;
+  const discRadius = Math.min(
+    radius - 1,
+    opts.discRadius ?? defaultDiscRadius(radius, treeDepth)
+  );
+  const ringSpan = Math.max(1, radius - discRadius);
+  const ringWidth = ringSpan / Math.max(1, treeDepth);
+  (hroot.children ?? []).forEach((top, i) => {
+    top.each((d) => {
+      d._topIndex = i;
+    });
+  });
+  const cells = [];
+  let maxDepthReached = 0;
+  for (const d of hroot.descendants()) {
+    if (d.depth === 0) continue;
+    if (d.depth > maxDepth) continue;
+    const hasChildren = !!d.children && d.children.length > 0;
+    if (d.depth > maxDepthReached) maxDepthReached = d.depth;
+    const path = [];
+    let p = d;
+    while (p && p.depth > 0) {
+      path.unshift(p.data.label);
+      p = p.parent;
+    }
+    const innerR = discRadius + (d.depth - 1) * ringWidth;
+    const outerR = discRadius + d.depth * ringWidth;
+    const heatVal = datumHeat(d);
+    cells.push({
+      node: d.data.ref ?? null,
+      label: d.data.label,
+      startAngle: d.x0,
+      endAngle: d.x1,
+      innerR,
+      outerR,
+      depth: d.depth,
+      value: d.value ?? 0,
+      isContainer: hasChildren,
+      isCollapsed: false,
+      topIndex: d._topIndex ?? 0,
+      pctOfRoot: total > 0 ? (d.value ?? 0) / total : 0,
+      pctOfParent: d.parent && (d.parent.value ?? 0) > 0 ? (d.value ?? 0) / (d.parent.value ?? 1) : 1,
+      ...heatVal !== void 0 && { heat: heatVal },
+      path,
+      ...d.data.lineNumber !== void 0 && { lineNumber: d.data.lineNumber }
+    });
+  }
+  return { cells, total, discRadius, maxDepthReached, isEmpty: false };
+}
+
+// src/treemap/renderer-radial.ts
+var PADDING = 12;
+var LEGEND_POSITION = {
+  placement: "top-center",
+  titleRelation: "below-title"
+};
+var MIN_LABEL_SWEEP = 6 * Math.PI / 180;
+var MIN_LABEL_FS = 8;
+function renderTreemapRadialForExport(container, parsed, palette, isDark, exportDims, options) {
+  renderTreemapRadial(container, parsed, palette, isDark, exportDims, {
+    exportMode: true,
+    ...options
+  });
+}
+function renderTreemapRadial(container, parsed, palette, isDark, exportDims, options = {}) {
+  if (parsed.error || parsed.roots.length === 0) return;
+  void isDark;
+  d3Selection.select(container).selectAll(":not([data-d3-tooltip])").remove();
+  const width = exportDims?.width ?? container.clientWidth;
+  const height = exportDims?.height ?? container.clientHeight;
+  if (width <= 0 || height <= 0) return;
+  const mode = resolveColorMode(parsed, options.colorMode);
+  const opts = parsed.options;
+  const exportMode = options.exportMode ?? false;
+  const seriesColors = getSeriesColors(palette);
+  const heat = buildHeatScale(parsed, palette);
+  const legend = !opts.noLegend ? buildLegend(mode, parsed, heat, seriesColors, options.colorOffset ?? 0) : null;
+  const legendReserve = legend ? getMaxLegendReservedHeight(
+    { groups: legend.groups, position: LEGEND_POSITION, mode: "preview" },
+    width
+  ) + LEGEND_GROUP_GAP : 0;
+  const areaY = legendReserve + PADDING;
+  const areaW = Math.max(1, width - PADDING * 2);
+  const areaH = Math.max(1, height - areaY - PADDING);
+  const radius = Math.max(1, Math.min(areaW, areaH) / 2 - PADDING);
+  const cx = width / 2;
+  const cy = areaY + areaH / 2;
+  const layout = layoutTreemapRadial(parsed.roots, {
+    radius,
+    ...options.maxDepth !== void 0 && { maxDepth: options.maxDepth }
+  });
+  const svg = d3Selection.select(container).append("svg").attr("width", width).attr("height", height).attr("viewBox", `0 0 ${width} ${height}`).attr("preserveAspectRatio", "xMidYMin meet").attr("xmlns", "http://www.w3.org/2000/svg").attr("class", "dgmo-treemap dgmo-treemap-radial").style("font-family", FONT_FAMILY);
+  const defs = svg.append("defs");
+  svg.append("rect").attr("width", width).attr("height", height).attr("fill", palette.bg);
+  const plot = svg.append("g").attr("class", "dgmo-treemap-cells").attr("transform", `translate(${cx},${cy})`);
+  const activeGroup = parsed.tagGroups.length > 0 ? parsed.tagGroups[0].name : null;
+  const rootIndexByLabel = new Map(parsed.roots.map((r, i) => [r.label, i]));
+  const colorCtx = {
+    mode,
+    heat,
+    tagGroups: parsed.tagGroups,
+    activeGroup,
+    rootIndexByLabel,
+    seriesColors,
+    colorOffset: options.colorOffset ?? 0,
+    bg: palette.bg
+  };
+  const arcGen = d3arc().startAngle((c) => c.startAngle).endAngle((c) => c.endAngle).innerRadius((c) => c.innerR).outerRadius((c) => c.outerR).padAngle(4e-3).padRadius(radius);
+  let labelSeq = 0;
+  if (!layout.isEmpty) {
+    for (const cell of layout.cells) {
+      const fill = resolveCellColor(cell, colorCtx);
+      const g = plot.append("g").attr("class", "dgmo-treemap-cell").attr("data-node-path", cell.path.join(" / "));
+      if (cell.lineNumber !== void 0) {
+        g.attr("data-line-number", cell.lineNumber);
+      }
+      if (cell.heat !== void 0) g.attr("data-heat", cell.heat);
+      if (cell.node && activeGroup) {
+        const key = tagAttrKey(activeGroup);
+        const tagVal = cell.node.metadata[key];
+        if (tagVal) g.attr(`data-tag-${key}`, tagVal);
+      }
+      g.append("path").attr(
+        "class",
+        cell.isContainer ? "dgmo-treemap-arc branch" : "dgmo-treemap-arc"
+      ).attr("d", arcGen(cell) ?? "").attr("fill", fill).attr("stroke", palette.bg).attr("stroke-width", 1);
+      drawArcLabel(
+        g,
+        defs,
+        `dgmo-arc-lbl-${labelSeq++}`,
+        cell,
+        opts,
+        palette,
+        fill
+      );
+    }
+  }
+  drawCenterDisc(
+    plot,
+    parsed,
+    layout.discRadius,
+    layout.total,
+    layout.isEmpty,
+    palette
+  );
+  if (legend) {
+    const legendG = svg.append("g").attr("class", "dgmo-treemap-legend").attr("transform", "translate(0, 0)");
+    renderIntegratedLegend(legendG, {
+      groups: legend.groups,
+      palette: {
+        bg: palette.bg,
+        surface: palette.surface,
+        text: palette.text,
+        textMuted: palette.textMuted,
+        primary: palette.primary
+      },
+      isDark,
+      width,
+      mode: exportMode ? "export" : "preview",
+      position: LEGEND_POSITION,
+      activeGroup: legend.activeGroup,
+      showInactivePills: !exportMode,
+      showEmptyGroups: !exportMode
+    });
+  }
+}
+function drawCenterDisc(plot, parsed, discRadius, total, isEmpty, palette) {
+  const disc = plot.append("g").attr("class", "dgmo-treemap-disc");
+  disc.append("circle").attr("r", discRadius).attr("fill", palette.surface).attr("stroke", palette.bg).attr("stroke-width", 1);
+  const ink = contrastText(
+    palette.surface,
+    palette.textOnFillLight,
+    palette.textOnFillDark
+  );
+  const maxW = discRadius * 1.7;
+  if (isEmpty) {
+    disc.append("text").attr("class", "dgmo-treemap-empty").attr("text-anchor", "middle").attr("y", 4).attr("fill", ink).attr("font-size", clampFs(13, discRadius)).text(clip("No values to chart", maxW, 13));
+    return;
+  }
+  const title = parsed.title ?? "";
+  const totalStr = compactNumber(total);
+  const titleFs = clampFs(15, discRadius);
+  const totalFs = clampFs(22, discRadius);
+  if (title) {
+    const t = disc.append("text").attr("class", "dgmo-treemap-disc-title").attr("text-anchor", "middle").attr("y", -4).attr("fill", ink).attr("font-size", titleFs).attr("font-weight", 600).text(clip(title, maxW, titleFs));
+    if (parsed.titleLineNumber !== null) {
+      t.attr("data-line-number", parsed.titleLineNumber);
+    }
+  }
+  disc.append("text").attr("class", "dgmo-treemap-disc-total").attr("text-anchor", "middle").attr("y", title ? titleFs : 8).attr("fill", ink).attr("font-size", totalFs).attr("font-weight", 700).text(clip(totalStr, maxW, totalFs));
+}
+function drawArcLabel(g, defs, pathId, cell, opts, palette, fill) {
+  const sweep = cell.endAngle - cell.startAngle;
+  if (sweep < MIN_LABEL_SWEEP) return;
+  const ringThickness = cell.outerR - cell.innerR;
+  if (ringThickness < 10) return;
+  const ink = contrastText(
+    fill,
+    palette.textOnFillLight,
+    palette.textOnFillDark
+  );
+  const rMid = (cell.innerR + cell.outerR) / 2;
+  const maxFs = clampFs(13, ringThickness);
+  const valParts = [
+    opts.noValues ? "" : compactNumber(cell.value),
+    opts.noPercent ? "" : formatPct(cell.pctOfRoot)
+  ].filter(Boolean);
+  const valStr = valParts.join(" \xB7 ");
+  const full = valStr ? `${cell.label} ${valStr}` : cell.label;
+  const availLen = sweep * rMid * 0.94;
+  let fs = maxFs;
+  const wAtMax = measureText(full, maxFs);
+  if (wAtMax > availLen) {
+    fs = Math.max(MIN_LABEL_FS, Math.floor(maxFs * availLen / wAtMax));
+  }
+  const text = clip(full, availLen, fs);
+  if (!text) return;
+  drawCurvedLabel(g, defs, pathId, cell, rMid, fs, text, ink);
+}
+function drawCurvedLabel(g, defs, pathId, cell, rMid, fs, text, ink) {
+  const mid = (cell.startAngle + cell.endAngle) / 2;
+  const bottom = mid > Math.PI / 2 && mid < 3 * Math.PI / 2;
+  const rPath = bottom ? rMid + fs * 0.32 : rMid - fs * 0.32;
+  const [a0, a1] = bottom ? [cell.endAngle, cell.startAngle] : [cell.startAngle, cell.endAngle];
+  const p0x = Math.sin(a0) * rPath;
+  const p0y = -Math.cos(a0) * rPath;
+  const p1x = Math.sin(a1) * rPath;
+  const p1y = -Math.cos(a1) * rPath;
+  const sweepFlag = bottom ? 0 : 1;
+  const d = `M ${p0x.toFixed(2)} ${p0y.toFixed(2)} A ${rPath.toFixed(2)} ${rPath.toFixed(2)} 0 0 ${sweepFlag} ${p1x.toFixed(2)} ${p1y.toFixed(2)}`;
+  defs.append("path").attr("id", pathId).attr("d", d);
+  g.append("text").attr("class", "dgmo-treemap-label").attr("font-size", fs).attr("font-weight", 600).attr("fill", ink).append("textPath").attr("href", `#${pathId}`).attr("startOffset", "50%").attr("text-anchor", "middle").text(text);
+}
+function clampFs(base, thickness) {
+  return Math.max(8, Math.min(base, Math.round(thickness * 0.9)));
+}
+function clip(s, maxWidth, fs) {
+  if (measureText(s, fs) <= maxWidth) return s;
+  let lo = 0;
+  let hi = s.length;
+  while (lo < hi) {
+    const mid = Math.ceil((lo + hi) / 2);
+    if (measureText(s.slice(0, mid) + "\u2026", fs) <= maxWidth) lo = mid;
+    else hi = mid - 1;
+  }
+  return lo <= 0 ? "" : s.slice(0, lo) + "\u2026";
+}
+
+export {
+  layoutTreemapRadial,
+  renderTreemapRadialForExport,
+  renderTreemapRadial
+};
+//# sourceMappingURL=chunk-ULOEATBZ.js.map

package/dist/chunk-UNCCZ3NU.js

@@ -0,0 +1,127 @@
+import {
+  collapseTree,
+  collectTreeIds
+} from "./chunk-BS7SV7C3.js";
+
+// src/utils/collapse-engine/tree-edges.ts
+function buildParentMap(roots, shape) {
+  const map = /* @__PURE__ */ new Map();
+  const walk = (nodes) => {
+    for (const node of nodes) {
+      for (const child of shape.getChildren(node)) {
+        map.set(shape.getId(child), shape.getId(node));
+        walk([child]);
+      }
+    }
+  };
+  walk(roots);
+  return map;
+}
+function findVisibleAncestor(nodeId, parentMap, visibleIds, collapsedIds) {
+  let current = nodeId;
+  while (true) {
+    const parentId = parentMap.get(current);
+    if (!parentId) return null;
+    if (visibleIds.has(parentId) && collapsedIds.has(parentId)) {
+      return parentId;
+    }
+    current = parentId;
+  }
+}
+function reterminateEdges(originalRoots, prunedRoots, edges, collapsedIds, nodeShape, edgeShape) {
+  const visibleIds = collectTreeIds(prunedRoots, nodeShape);
+  const parentMap = buildParentMap(originalRoots, nodeShape);
+  const result = [];
+  for (const edge of edges) {
+    let sourceId = edgeShape.getSource(edge);
+    let targetId = edgeShape.getTarget(edge);
+    const sourceVisible = visibleIds.has(sourceId);
+    const targetVisible = visibleIds.has(targetId);
+    if (sourceVisible && targetVisible) {
+      result.push(edgeShape.withEndpoints(edge, sourceId, targetId));
+      continue;
+    }
+    if (!sourceVisible) {
+      const ancestor = findVisibleAncestor(
+        sourceId,
+        parentMap,
+        visibleIds,
+        collapsedIds
+      );
+      if (!ancestor) continue;
+      sourceId = ancestor;
+    }
+    if (!targetVisible) {
+      const ancestor = findVisibleAncestor(
+        targetId,
+        parentMap,
+        visibleIds,
+        collapsedIds
+      );
+      if (!ancestor) continue;
+      targetId = ancestor;
+    }
+    if (sourceId === targetId) continue;
+    result.push(edgeShape.withEndpoints(edge, sourceId, targetId));
+  }
+  return result;
+}
+
+// src/sitemap/collapse.ts
+function cloneNode(node) {
+  return {
+    id: node.id,
+    label: node.label,
+    metadata: { ...node.metadata },
+    children: node.children.map(cloneNode),
+    parentId: node.parentId,
+    isContainer: node.isContainer,
+    lineNumber: node.lineNumber,
+    ...node.color !== void 0 && { color: node.color }
+  };
+}
+var SITEMAP_SHAPE = {
+  getId: (node) => node.id,
+  getChildren: (node) => node.children,
+  clone: cloneNode,
+  setChildren: (node, children) => {
+    node.children = children;
+  },
+  countsAsHidden: (node) => !node.isContainer
+};
+var SITEMAP_EDGE_SHAPE = {
+  getSource: (edge) => edge.sourceId,
+  getTarget: (edge) => edge.targetId,
+  withEndpoints: (edge, sourceId, targetId) => ({
+    ...edge,
+    sourceId,
+    targetId
+  })
+};
+function collapseSitemapTree(original, collapsedIds) {
+  if (collapsedIds.size === 0) {
+    return { parsed: original, hiddenCounts: /* @__PURE__ */ new Map() };
+  }
+  const { roots, hiddenCounts } = collapseTree(
+    original.roots,
+    collapsedIds,
+    SITEMAP_SHAPE
+  );
+  const edges = reterminateEdges(
+    original.roots,
+    roots,
+    original.edges,
+    collapsedIds,
+    SITEMAP_SHAPE,
+    SITEMAP_EDGE_SHAPE
+  );
+  return {
+    parsed: { ...original, roots, edges },
+    hiddenCounts
+  };
+}
+
+export {
+  collapseSitemapTree
+};
+//# sourceMappingURL=chunk-UNCCZ3NU.js.map