@diagrammo/dgmo 0.46.0 → 0.48.0

package/dist/chunk-6SM5NJQH.js

@@ -0,0 +1,620 @@
+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/sitemap/layout.ts
+import dagre from "@dagrejs/dagre";
+var LABEL_FONT_SIZE = 13;
+var META_FONT_SIZE = 11;
+var CONTAINER_LABEL_FONT_SIZE = 13;
+function clipToRectBorder(cx, cy, w, h, tx, ty) {
+  const dx = tx - cx;
+  const dy = ty - cy;
+  if (dx === 0 && dy === 0) return { x: cx, y: cy };
+  const hw = w / 2;
+  const hh = h / 2;
+  const sx = dx !== 0 ? hw / Math.abs(dx) : Infinity;
+  const sy = dy !== 0 ? hh / Math.abs(dy) : Infinity;
+  const s = Math.min(sx, sy);
+  return { x: cx + dx * s, y: cy + dy * s };
+}
+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 MARGIN = 40;
+var CONTAINER_PAD_X = 24;
+var CONTAINER_PAD_TOP = 40;
+var CONTAINER_PAD_BOTTOM = 24;
+var CONTAINER_LABEL_HEIGHT = 28;
+var CONTAINER_META_LINE_HEIGHT = 16;
+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, descLines) {
+  let maxContentWidth = measureText(label, LABEL_FONT_SIZE);
+  for (const [key, value] of Object.entries(meta)) {
+    const lineWidth = measureText(`${key}: ${value}`, META_FONT_SIZE);
+    if (lineWidth > maxContentWidth) maxContentWidth = lineWidth;
+  }
+  if (descLines) {
+    for (const dl of descLines) {
+      const dlWidth = measureText(dl, META_FONT_SIZE);
+      if (dlWidth > maxContentWidth) maxContentWidth = dlWidth;
+    }
+  }
+  return Math.max(MIN_CARD_WIDTH, Math.ceil(maxContentWidth) + CARD_H_PAD * 2);
+}
+function computeCardHeight(meta, descLineCount = 0) {
+  const metaCount = Object.keys(meta).length;
+  const contentCount = metaCount + descLineCount;
+  if (contentCount === 0) return HEADER_HEIGHT + CARD_V_PAD;
+  return HEADER_HEIGHT + SEPARATOR_GAP + contentCount * 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
+  );
+}
+var OVERLAP_GAP = 20;
+function computeLegendGroups(tagGroups, 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 = LEGEND_EYE_SIZE + LEGEND_EYE_GAP;
+    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 flattenNodes(nodes, parentContainerId, parentPageId, hiddenCounts, hiddenAttributes, result) {
+  for (const node of nodes) {
+    const meta = filterMetadata(node.metadata, hiddenAttributes);
+    if (node.isContainer) {
+      const metaCount = Object.keys(meta).length;
+      const labelHeight = CONTAINER_LABEL_HEIGHT + metaCount * CONTAINER_META_LINE_HEIGHT;
+      result.push({
+        sitemapNode: node,
+        parentContainerId,
+        parentPageId,
+        meta,
+        fullMeta: { ...node.metadata },
+        width: Math.max(
+          MIN_CARD_WIDTH,
+          measureText(node.label, CONTAINER_LABEL_FONT_SIZE) + CARD_H_PAD * 2
+        ),
+        height: labelHeight + CONTAINER_PAD_BOTTOM
+      });
+      flattenNodes(
+        node.children,
+        node.id,
+        parentPageId,
+        hiddenCounts,
+        hiddenAttributes,
+        result
+      );
+    } else {
+      result.push({
+        sitemapNode: node,
+        parentContainerId,
+        parentPageId,
+        meta,
+        fullMeta: { ...node.metadata },
+        width: computeCardWidth(node.label, meta, node.description),
+        height: computeCardHeight(meta, node.description?.length ?? 0)
+      });
+      if (node.children.length > 0) {
+        flattenNodes(
+          node.children,
+          parentContainerId,
+          node.id,
+          hiddenCounts,
+          hiddenAttributes,
+          result
+        );
+      }
+    }
+  }
+}
+function layoutSitemap(parsed, hiddenCounts, activeTagGroup, hiddenAttributes, expandAllLegend) {
+  if (parsed.roots.length === 0) {
+    return {
+      nodes: [],
+      edges: [],
+      containers: [],
+      legend: [],
+      width: 0,
+      height: 0
+    };
+  }
+  const allNodes = [];
+  const collect = (node) => {
+    allNodes.push(node);
+    for (const child of node.children) collect(child);
+  };
+  for (const root of parsed.roots) collect(root);
+  injectDefaultTagMetadata(
+    allNodes,
+    parsed.tagGroups,
+    (e) => e.isContainer
+  );
+  const flatNodes = [];
+  flattenNodes(
+    parsed.roots,
+    null,
+    null,
+    hiddenCounts,
+    hiddenAttributes,
+    flatNodes
+  );
+  const nodeMap = /* @__PURE__ */ new Map();
+  for (const flat of flatNodes) {
+    nodeMap.set(flat.sitemapNode.id, flat);
+  }
+  const g = new dagre.graphlib.Graph({ compound: true, multigraph: true });
+  g.setGraph({
+    rankdir: parsed.direction,
+    nodesep: 50,
+    ranksep: 60,
+    edgesep: 30,
+    marginx: MARGIN,
+    marginy: MARGIN
+  });
+  g.setDefaultEdgeLabel(() => ({}));
+  const containerIds = /* @__PURE__ */ new Set();
+  const pageNodeIds = /* @__PURE__ */ new Set();
+  const collapsedContainerIds = /* @__PURE__ */ new Set();
+  for (const flat of flatNodes) {
+    if (flat.sitemapNode.isContainer) {
+      containerIds.add(flat.sitemapNode.id);
+      const hidden = hiddenCounts?.get(flat.sitemapNode.id) ?? 0;
+      if (hidden > 0) {
+        collapsedContainerIds.add(flat.sitemapNode.id);
+      }
+    } else {
+      pageNodeIds.add(flat.sitemapNode.id);
+    }
+  }
+  let pageMaxW = 0;
+  let pageMaxH = 0;
+  for (const f of flatNodes) {
+    if (!f.sitemapNode.isContainer) {
+      if (f.width > pageMaxW) pageMaxW = f.width;
+      if (f.height > pageMaxH) pageMaxH = f.height;
+    }
+  }
+  for (const flat of flatNodes) {
+    const node = flat.sitemapNode;
+    if (node.isContainer) {
+      if (collapsedContainerIds.has(node.id)) {
+        const flooredW = Math.max(flat.width, pageMaxW);
+        const flooredH = Math.max(flat.height, pageMaxH);
+        g.setNode(node.id, {
+          label: node.label,
+          width: flooredW,
+          height: flooredH
+        });
+      } else {
+        g.setNode(node.id, {
+          label: node.label,
+          paddingLeft: CONTAINER_PAD_X,
+          paddingRight: CONTAINER_PAD_X,
+          paddingTop: CONTAINER_PAD_TOP,
+          paddingBottom: CONTAINER_PAD_BOTTOM
+        });
+      }
+    } else {
+      g.setNode(node.id, {
+        label: node.label,
+        width: flat.width,
+        height: flat.height
+      });
+    }
+  }
+  for (const flat of flatNodes) {
+    if (flat.parentContainerId && !collapsedContainerIds.has(flat.parentContainerId)) {
+      g.setParent(flat.sitemapNode.id, flat.parentContainerId);
+    }
+  }
+  const expandedContainerIds = /* @__PURE__ */ new Set();
+  for (const cid of containerIds) {
+    if (!collapsedContainerIds.has(cid)) {
+      expandedContainerIds.add(cid);
+    }
+  }
+  const deferredEdgeIndices = [];
+  for (let i = 0; i < parsed.edges.length; i++) {
+    const edge = parsed.edges[i];
+    if (!g.hasNode(edge.sourceId) || !g.hasNode(edge.targetId)) continue;
+    if (expandedContainerIds.has(edge.sourceId) || expandedContainerIds.has(edge.targetId)) {
+      deferredEdgeIndices.push(i);
+      continue;
+    }
+    g.setEdge(
+      edge.sourceId,
+      edge.targetId,
+      {
+        label: edge.label ?? "",
+        minlen: 1
+      },
+      `e${i}`
+    );
+  }
+  dagre.layout(g);
+  const layoutNodes = [];
+  const layoutContainers = [];
+  for (const flat of flatNodes) {
+    const node = flat.sitemapNode;
+    if (node.isContainer) continue;
+    const pos = g.node(node.id);
+    if (!pos) continue;
+    const hc = hiddenCounts?.get(node.id);
+    const resolvedColor = resolveNodeColor(
+      node,
+      parsed.tagGroups,
+      activeTagGroup ?? null
+    );
+    layoutNodes.push({
+      id: node.id,
+      label: node.label,
+      metadata: flat.meta,
+      tagMetadata: flat.fullMeta,
+      ...node.description !== void 0 && {
+        description: [...node.description]
+      },
+      isContainer: false,
+      lineNumber: node.lineNumber,
+      ...resolvedColor !== void 0 && { color: resolvedColor },
+      x: pos.x,
+      y: pos.y - pos.height / 2,
+      width: pos.width,
+      height: pos.height,
+      ...hc !== void 0 && { hiddenCount: hc },
+      ...(node.children.length > 0 || hc != null && hc > 0) && {
+        hasChildren: true
+      }
+    });
+  }
+  for (const flat of flatNodes) {
+    const node = flat.sitemapNode;
+    if (!node.isContainer) continue;
+    const pos = g.node(node.id);
+    const hc = hiddenCounts?.get(node.id);
+    const metaCount = Object.keys(flat.meta).length;
+    const labelHeight = CONTAINER_LABEL_HEIGHT + metaCount * CONTAINER_META_LINE_HEIGHT;
+    const containerColor = resolveNodeColor(
+      node,
+      parsed.tagGroups,
+      activeTagGroup ?? null
+    );
+    if (pos) {
+      layoutContainers.push({
+        nodeId: node.id,
+        label: node.label,
+        lineNumber: node.lineNumber,
+        ...containerColor !== void 0 && { color: containerColor },
+        metadata: flat.meta,
+        tagMetadata: flat.fullMeta,
+        x: pos.x - pos.width / 2,
+        y: pos.y - pos.height / 2,
+        width: pos.width,
+        height: pos.height,
+        labelHeight,
+        ...hc !== void 0 && { hiddenCount: hc },
+        ...(node.children.length > 0 || hc != null && hc > 0) && {
+          hasChildren: true
+        }
+      });
+    } else {
+      const isCollapsed = collapsedContainerIds.has(node.id);
+      const flooredW = isCollapsed ? Math.max(flat.width, pageMaxW) : flat.width;
+      const fallbackH = isCollapsed ? flat.height : labelHeight + CONTAINER_PAD_BOTTOM;
+      const flooredH = isCollapsed ? Math.max(fallbackH, pageMaxH) : fallbackH;
+      layoutContainers.push({
+        nodeId: node.id,
+        label: node.label,
+        lineNumber: node.lineNumber,
+        ...containerColor !== void 0 && { color: containerColor },
+        metadata: flat.meta,
+        tagMetadata: flat.fullMeta,
+        x: MARGIN,
+        y: MARGIN,
+        width: flooredW,
+        height: flooredH,
+        labelHeight,
+        ...hc !== void 0 && { hiddenCount: hc },
+        ...(node.children.length > 0 || hc != null && hc > 0) && {
+          hasChildren: true
+        }
+      });
+    }
+  }
+  const deferredSet = new Set(deferredEdgeIndices);
+  const layoutEdges = [];
+  for (let i = 0; i < parsed.edges.length; i++) {
+    const edge = parsed.edges[i];
+    if (!g.hasNode(edge.sourceId) || !g.hasNode(edge.targetId)) continue;
+    let points;
+    if (deferredSet.has(i)) {
+      const srcNode = g.node(edge.sourceId);
+      const tgtNode = g.node(edge.targetId);
+      if (!srcNode || !tgtNode) continue;
+      const srcPt = clipToRectBorder(
+        srcNode.x,
+        srcNode.y,
+        srcNode.width,
+        srcNode.height,
+        tgtNode.x,
+        tgtNode.y
+      );
+      const tgtPt = clipToRectBorder(
+        tgtNode.x,
+        tgtNode.y,
+        tgtNode.width,
+        tgtNode.height,
+        srcNode.x,
+        srcNode.y
+      );
+      const midX = (srcPt.x + tgtPt.x) / 2;
+      const midY = (srcPt.y + tgtPt.y) / 2;
+      points = [srcPt, { x: midX, y: midY }, tgtPt];
+    } else {
+      const edgeData = g.edge({
+        v: edge.sourceId,
+        w: edge.targetId,
+        name: `e${i}`
+      });
+      if (!edgeData) continue;
+      points = edgeData.points ?? [];
+    }
+    layoutEdges.push({
+      sourceId: edge.sourceId,
+      targetId: edge.targetId,
+      points,
+      ...edge.label !== void 0 && { label: edge.label },
+      lineNumber: edge.lineNumber,
+      ...deferredSet.has(i) && { deferred: true }
+    });
+  }
+  {
+    const allNodeIds = /* @__PURE__ */ new Set([...pageNodeIds, ...collapsedContainerIds]);
+    const ufParent = /* @__PURE__ */ new Map();
+    for (const id of allNodeIds) ufParent.set(id, id);
+    const ufFind = (x) => {
+      while (ufParent.get(x) !== x) {
+        ufParent.set(x, ufParent.get(ufParent.get(x)));
+        x = ufParent.get(x);
+      }
+      return x;
+    };
+    const ufUnion = (a, b) => {
+      const ra = ufFind(a);
+      const rb = ufFind(b);
+      if (ra !== rb) ufParent.set(ra, rb);
+    };
+    for (const edge of parsed.edges) {
+      if (allNodeIds.has(edge.sourceId) && allNodeIds.has(edge.targetId)) {
+        ufUnion(edge.sourceId, edge.targetId);
+      }
+    }
+    const firstRootPage = flatNodes.find((f) => !f.sitemapNode.isContainer)?.sitemapNode.id;
+    const mainRoot = firstRootPage ? ufFind(firstRootPage) : null;
+    const isolatedNodeIds = /* @__PURE__ */ new Set();
+    for (const id of allNodeIds) {
+      if (mainRoot && ufFind(id) !== mainRoot) {
+        isolatedNodeIds.add(id);
+      }
+    }
+    const isolatedContainerIds = /* @__PURE__ */ new Set();
+    for (const cid of containerIds) {
+      if (collapsedContainerIds.has(cid)) {
+        if (isolatedNodeIds.has(cid)) isolatedContainerIds.add(cid);
+        continue;
+      }
+      const members = flatNodes.filter(
+        (f) => !f.sitemapNode.isContainer && f.parentContainerId === cid
+      );
+      if (members.length > 0 && members.every((m) => isolatedNodeIds.has(m.sitemapNode.id))) {
+        isolatedContainerIds.add(cid);
+      }
+    }
+    if (isolatedNodeIds.size > 0) {
+      const isVertical = parsed.direction === "TB";
+      let mainRight = 0;
+      let mainBottom = 0;
+      let mainTop = Infinity;
+      let mainLeft = Infinity;
+      for (const n of layoutNodes) {
+        if (!isolatedNodeIds.has(n.id)) {
+          mainRight = Math.max(mainRight, n.x + n.width / 2);
+          mainBottom = Math.max(mainBottom, n.y + n.height);
+          mainTop = Math.min(mainTop, n.y);
+          mainLeft = Math.min(mainLeft, n.x - n.width / 2);
+        }
+      }
+      for (const c of layoutContainers) {
+        if (!isolatedContainerIds.has(c.nodeId)) {
+          mainRight = Math.max(mainRight, c.x + c.width);
+          mainBottom = Math.max(mainBottom, c.y + c.height);
+          mainTop = Math.min(mainTop, c.y);
+          mainLeft = Math.min(mainLeft, c.x);
+        }
+      }
+      let isoLeft = Infinity;
+      let isoTop = Infinity;
+      let isoRight = 0;
+      let isoBottom = 0;
+      for (const n of layoutNodes) {
+        if (isolatedNodeIds.has(n.id)) {
+          isoLeft = Math.min(isoLeft, n.x - n.width / 2);
+          isoTop = Math.min(isoTop, n.y);
+          isoRight = Math.max(isoRight, n.x + n.width / 2);
+          isoBottom = Math.max(isoBottom, n.y + n.height);
+        }
+      }
+      for (const c of layoutContainers) {
+        if (isolatedContainerIds.has(c.nodeId)) {
+          isoLeft = Math.min(isoLeft, c.x);
+          isoTop = Math.min(isoTop, c.y);
+          isoRight = Math.max(isoRight, c.x + c.width);
+          isoBottom = Math.max(isoBottom, c.y + c.height);
+        }
+      }
+      if (isoLeft !== Infinity) {
+        const gap = OVERLAP_GAP * 2;
+        let shiftX;
+        let shiftY;
+        if (isVertical) {
+          shiftX = mainRight + gap - isoLeft;
+          shiftY = (mainTop === Infinity ? 0 : mainTop) - isoTop;
+        } else {
+          shiftX = (mainLeft === Infinity ? 0 : mainLeft) - isoLeft;
+          shiftY = mainBottom + gap - isoTop;
+        }
+        if (shiftX !== 0 || shiftY !== 0) {
+          for (const n of layoutNodes) {
+            if (isolatedNodeIds.has(n.id)) {
+              n.x += shiftX;
+              n.y += shiftY;
+            }
+          }
+          for (const c of layoutContainers) {
+            if (isolatedContainerIds.has(c.nodeId)) {
+              c.x += shiftX;
+              c.y += shiftY;
+            }
+          }
+          for (const e of layoutEdges) {
+            const srcIsolated = isolatedNodeIds.has(e.sourceId);
+            const tgtIsolated = isolatedNodeIds.has(e.targetId);
+            if (srcIsolated || tgtIsolated) {
+              for (const p of e.points) {
+                p.x += shiftX;
+                p.y += shiftY;
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+  let totalWidth = 0;
+  let totalHeight = 0;
+  for (const node of layoutNodes) {
+    const right = node.x + node.width / 2;
+    const bottom = node.y + node.height;
+    if (right > totalWidth) totalWidth = right;
+    if (bottom > totalHeight) totalHeight = bottom;
+  }
+  for (const c of layoutContainers) {
+    const right = c.x + c.width;
+    const bottom = c.y + c.height;
+    if (right > totalWidth) totalWidth = right;
+    if (bottom > totalHeight) totalHeight = bottom;
+  }
+  for (const edge of layoutEdges) {
+    for (const p of edge.points) {
+      if (p.x > totalWidth) totalWidth = p.x;
+      if (p.y > totalHeight) totalHeight = p.y;
+    }
+  }
+  totalWidth += MARGIN;
+  totalHeight += MARGIN;
+  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 root of parsed.roots) walk(root);
+    usedValuesByGroup.set(key, used);
+  }
+  const legendGroups = computeLegendGroups(parsed.tagGroups, usedValuesByGroup);
+  const visibleGroups = activeTagGroup != null ? legendGroups.filter(
+    (g2) => g2.name.toLowerCase() === activeTagGroup.toLowerCase()
+  ) : legendGroups;
+  const allExpanded = expandAllLegend && activeTagGroup == null;
+  const effectiveW = (g2) => activeTagGroup != null || allExpanded ? g2.width : g2.minifiedWidth;
+  if (visibleGroups.length > 0) {
+    const legendShift = LEGEND_HEIGHT + LEGEND_GROUP_GAP;
+    const totalGroupsWidth = visibleGroups.reduce((s, g2) => s + effectiveW(g2), 0) + (visibleGroups.length - 1) * LEGEND_GROUP_GAP;
+    const neededWidth = totalGroupsWidth + MARGIN * 2;
+    if (neededWidth > totalWidth) totalWidth = neededWidth;
+    let cx = (totalWidth - totalGroupsWidth) / 2;
+    const legendY = totalHeight + LEGEND_GROUP_GAP;
+    for (const g2 of visibleGroups) {
+      g2.x = cx;
+      g2.y = legendY;
+      cx += effectiveW(g2) + LEGEND_GROUP_GAP;
+    }
+    totalHeight += legendShift;
+  }
+  return {
+    nodes: layoutNodes,
+    edges: layoutEdges,
+    containers: layoutContainers,
+    legend: legendGroups,
+    width: totalWidth,
+    height: totalHeight
+  };
+}
+
+export {
+  layoutSitemap
+};
+//# sourceMappingURL=chunk-6SM5NJQH.js.map