@diagrammo/dgmo 0.45.0 → 0.47.0

package/dist/chunk-T2OE3YQB.js

@@ -0,0 +1,550 @@
+import {
+  ScaleContext
+} from "./chunk-YYVTBZZC.js";
+import {
+  measureText,
+  truncateText
+} from "./chunk-WCT3NYCV.js";
+import {
+  preprocessDescriptionLine
+} from "./chunk-IYULMRBE.js";
+import {
+  injectDefaultTagMetadata,
+  resolveTagColor
+} from "./chunk-QLCCJEJI.js";
+
+// src/mindmap/text-wrap.ts
+var H_PAD = 16;
+var MAX_LABEL_LINES = 3;
+var MAX_DESC_LINES = 2;
+function tokenize(text) {
+  const tokens = [];
+  const parts = text.split(/(\s+)/);
+  for (const part of parts) {
+    if (/^\s+$/.test(part)) continue;
+    const hyphenParts = part.split(/(?<=-)(?=\S)/);
+    tokens.push(...hyphenParts);
+  }
+  return tokens;
+}
+function tryWrap(tokens, maxWidth, fontSize, maxLines) {
+  const availWidth = maxWidth - H_PAD;
+  const lines = [];
+  let currentLine = "";
+  for (const token of tokens) {
+    const sep = currentLine && !currentLine.endsWith("-") ? " " : "";
+    const candidate = currentLine + sep + token;
+    if (measureText(candidate, fontSize) <= availWidth) {
+      currentLine = candidate;
+    } else if (!currentLine) {
+      currentLine = token;
+    } else {
+      lines.push(currentLine);
+      if (lines.length >= maxLines) {
+        return null;
+      }
+      currentLine = token;
+    }
+  }
+  if (currentLine) {
+    lines.push(currentLine);
+  }
+  if (lines.length > maxLines) return null;
+  return lines;
+}
+function truncateLastLine(lines, maxWidth, fontSize) {
+  const availWidth = maxWidth - H_PAD;
+  const result = [...lines];
+  const last = result[result.length - 1];
+  if (measureText(last, fontSize) > availWidth) {
+    result[result.length - 1] = truncateText(last, fontSize, availWidth);
+  }
+  return result;
+}
+function wrapText(text, maxWidth, baseFontSize, minFontSize, maxLines = MAX_LABEL_LINES) {
+  if (!text) return { lines: [""], fontSize: baseFontSize };
+  const tokens = tokenize(text);
+  for (let fs = baseFontSize; fs >= minFontSize; fs--) {
+    const lines = tryWrap(tokens, maxWidth, fs, maxLines);
+    if (lines) {
+      return { lines: truncateLastLine(lines, maxWidth, fs), fontSize: fs };
+    }
+  }
+  const allLines = tryWrap(tokens, maxWidth, minFontSize, 999) ?? [text];
+  const capped = allLines.slice(0, maxLines);
+  const truncated = truncateLastLine(capped, maxWidth, minFontSize);
+  if (allLines.length > maxLines) {
+    const last = truncated[truncated.length - 1];
+    if (!last.endsWith("\u2026")) {
+      const availWidth = maxWidth - H_PAD;
+      if (measureText(last + "\u2026", minFontSize) > availWidth) {
+        truncated[truncated.length - 1] = truncateText(
+          last,
+          minFontSize,
+          availWidth
+        );
+      } else {
+        truncated[truncated.length - 1] = last + "\u2026";
+      }
+    }
+  }
+  return {
+    lines: truncated,
+    fontSize: minFontSize
+  };
+}
+var ROOT_FONT_SIZE = 17;
+var MIN_FONT_SIZE = 9;
+var FONT_STEP = 3;
+var DESC_FONT_SIZE = 10;
+function labelFontSize(depth) {
+  return Math.max(MIN_FONT_SIZE, ROOT_FONT_SIZE - depth * FONT_STEP);
+}
+function computeNodeText(label, description, depth, nodeWidth, hideDescriptions) {
+  const baseFontSize = labelFontSize(depth);
+  const labelResult = wrapText(
+    label,
+    nodeWidth,
+    baseFontSize,
+    MIN_FONT_SIZE,
+    MAX_LABEL_LINES
+  );
+  const descLines = [];
+  let descFontSize = DESC_FONT_SIZE;
+  if (!hideDescriptions && description && description.length > 0) {
+    let remaining = MAX_DESC_LINES;
+    for (const rawLine of description) {
+      if (remaining <= 0) break;
+      const line = preprocessDescriptionLine(rawLine);
+      const lineResult = wrapText(
+        line,
+        nodeWidth,
+        DESC_FONT_SIZE,
+        DESC_FONT_SIZE,
+        remaining
+      );
+      descLines.push(...lineResult.lines);
+      remaining -= lineResult.lines.length;
+      descFontSize = lineResult.fontSize;
+    }
+  }
+  return {
+    labelLines: labelResult.lines,
+    labelFontSize: labelResult.fontSize,
+    descLines,
+    descFontSize
+  };
+}
+
+// src/mindmap/layout.ts
+var ROOT_WIDTH = 180;
+var DEPTH1_WIDTH = 150;
+var LEAF_WIDTH = 120;
+var SINGLE_LABEL_HEIGHT = 28;
+var LABEL_LINE_HEIGHT = 18;
+var DESC_LINE_HEIGHT = 14;
+var NODE_V_PAD = 10;
+var H_GAP = 40;
+var V_GAP = 12;
+var MARGIN = 40;
+var MULTI_ROOT_GAP = 60;
+function layoutMindmap(parsed, _palette, options) {
+  const roots = parsed.roots;
+  if (roots.length === 0) {
+    return { nodes: [], edges: [], width: 0, height: 0 };
+  }
+  const hiddenCounts = options?.hiddenCounts ?? /* @__PURE__ */ new Map();
+  const activeTagGroup = options?.activeTagGroup ?? null;
+  const hideDescriptions = options?.hideDescriptions ?? false;
+  const ctx = options?.ctx ?? ScaleContext.identity();
+  const sc = {
+    rootWidth: ctx.structural(ROOT_WIDTH),
+    depth1Width: ctx.structural(DEPTH1_WIDTH),
+    leafWidth: ctx.structural(LEAF_WIDTH),
+    hGap: ctx.aesthetic(H_GAP),
+    vGap: ctx.aesthetic(V_GAP),
+    margin: ctx.aesthetic(MARGIN),
+    multiRootGap: ctx.aesthetic(MULTI_ROOT_GAP)
+  };
+  populateDepthCache(roots);
+  const allNodes = [];
+  const collectAll = (nodes) => {
+    for (const n of nodes) {
+      allNodes.push(n);
+      collectAll(n.children);
+    }
+  };
+  collectAll(roots);
+  injectDefaultTagMetadata(allNodes, parsed.tagGroups);
+  const tagGroups = parsed.tagGroups;
+  if (roots.length === 1) {
+    return layoutSingleRoot(
+      roots[0],
+      hiddenCounts,
+      hideDescriptions,
+      tagGroups,
+      activeTagGroup,
+      sc
+    );
+  }
+  return layoutMultiRoot(
+    roots,
+    parsed,
+    hiddenCounts,
+    hideDescriptions,
+    tagGroups,
+    activeTagGroup,
+    sc
+  );
+}
+function layoutSingleRoot(root, hiddenCounts, hideDescriptions, tagGroups = [], activeTagGroup = null, sc) {
+  const positioned = [];
+  const rootW = nodeWidthS(0, sc);
+  const rootH = nodeHeightS(root, hideDescriptions, sc);
+  const children = root.children;
+  const { right: rightChildren, left: leftChildren } = balancedSplitS(
+    children,
+    hideDescriptions,
+    sc
+  );
+  const rightHeight = computeGroupHeightS(
+    rightChildren,
+    1,
+    hideDescriptions,
+    sc
+  );
+  const leftHeight = computeGroupHeightS(leftChildren, 1, hideDescriptions, sc);
+  const maxSideHeight = Math.max(rightHeight, leftHeight, rootH);
+  const rootX = 0;
+  const rootY = maxSideHeight / 2 - rootH / 2;
+  positioned.push({
+    node: root,
+    x: rootX,
+    y: rootY,
+    width: rootW,
+    height: rootH,
+    depth: 0,
+    direction: "right",
+    subtreeHeight: maxSideHeight
+  });
+  const rootCenterY = rootY + rootH / 2;
+  const rightStartX = rootX + rootW + sc.hGap;
+  layoutSideS(
+    rightChildren,
+    rightStartX,
+    rootCenterY,
+    1,
+    "right",
+    hideDescriptions,
+    positioned,
+    sc
+  );
+  const leftStartX = rootX - sc.hGap;
+  layoutSideS(
+    leftChildren,
+    leftStartX,
+    rootCenterY,
+    1,
+    "left",
+    hideDescriptions,
+    positioned,
+    sc
+  );
+  return finalizeS(
+    positioned,
+    hiddenCounts,
+    hideDescriptions,
+    root,
+    tagGroups,
+    activeTagGroup,
+    sc
+  );
+}
+function layoutMultiRoot(roots, _parsed, hiddenCounts, hideDescriptions, tagGroups, activeTagGroup, sc) {
+  const subResults = [];
+  for (const r of roots) {
+    subResults.push(
+      layoutSingleRoot(
+        r,
+        hiddenCounts,
+        hideDescriptions,
+        tagGroups,
+        activeTagGroup,
+        sc
+      )
+    );
+  }
+  const totalWidth = subResults.reduce((sum, r) => sum + r.width, 0) + sc.multiRootGap * (subResults.length - 1);
+  const maxHeight = Math.max(...subResults.map((r) => r.height));
+  const allNodes = [];
+  const allEdges = [];
+  let xOffset = 0;
+  for (const sub of subResults) {
+    const yOffset = (maxHeight - sub.height) / 2;
+    for (const n of sub.nodes) {
+      allNodes.push({ ...n, x: n.x + xOffset, y: n.y + yOffset });
+    }
+    for (const e of sub.edges) {
+      allEdges.push({
+        sourceId: e.sourceId,
+        targetId: e.targetId,
+        path: offsetPath(e.path, xOffset, yOffset)
+      });
+    }
+    xOffset += sub.width + sc.multiRootGap;
+  }
+  return {
+    nodes: allNodes,
+    edges: allEdges,
+    width: totalWidth,
+    height: maxHeight
+  };
+}
+function layoutSideS(children, startX, parentCenterY, depth, direction, hideDescriptions, positioned, sc) {
+  if (children.length === 0) return;
+  const groupHeight = computeGroupHeightS(
+    children,
+    depth,
+    hideDescriptions,
+    sc
+  );
+  let currentY = parentCenterY - groupHeight / 2;
+  for (const child of children) {
+    const w = nodeWidthS(depth, sc);
+    const h = nodeHeightS(child, hideDescriptions, sc);
+    const subtreeH = computeSubtreeHeightS(child, depth, hideDescriptions, sc);
+    const nodeY = currentY + subtreeH / 2 - h / 2;
+    const nodeX = direction === "right" ? startX : startX - w;
+    positioned.push({
+      node: child,
+      x: nodeX,
+      y: nodeY,
+      width: w,
+      height: h,
+      depth,
+      direction,
+      subtreeHeight: subtreeH
+    });
+    if (child.children.length > 0) {
+      const childCenterY = nodeY + h / 2;
+      const nextX = direction === "right" ? nodeX + w + sc.hGap : nodeX - sc.hGap;
+      layoutSideS(
+        child.children,
+        nextX,
+        childCenterY,
+        depth + 1,
+        direction,
+        hideDescriptions,
+        positioned,
+        sc
+      );
+    }
+    currentY += subtreeH + sc.vGap;
+  }
+}
+function computeGroupHeightS(children, depth, hideDescriptions, sc) {
+  if (children.length === 0) return 0;
+  let total = 0;
+  for (const child of children) {
+    total += computeSubtreeHeightS(child, depth, hideDescriptions, sc);
+  }
+  total += sc.vGap * (children.length - 1);
+  return total;
+}
+function computeSubtreeHeightS(node, depth, hideDescriptions, sc) {
+  const h = nodeHeightS(node, hideDescriptions, sc);
+  if (node.children.length === 0) return h;
+  const childrenHeight = computeGroupHeightS(
+    node.children,
+    depth + 1,
+    hideDescriptions,
+    sc
+  );
+  return Math.max(h, childrenHeight);
+}
+function resolveNodeColor(node, tagGroups, activeGroupName) {
+  if (node.color) return node.color;
+  return resolveTagColor(node.metadata, [...tagGroups], activeGroupName);
+}
+function finalizeS(positioned, hiddenCounts, _hideDescriptions, _rootMindmapNode, tagGroups = [], activeTagGroup = null, sc) {
+  let minX = Infinity, minY = Infinity, maxX = -Infinity, maxY = -Infinity;
+  for (const p of positioned) {
+    minX = Math.min(minX, p.x);
+    minY = Math.min(minY, p.y);
+    maxX = Math.max(maxX, p.x + p.width);
+    maxY = Math.max(maxY, p.y + p.height);
+  }
+  const offsetX = -minX + sc.margin;
+  const offsetY = -minY + sc.margin;
+  const totalWidth = maxX - minX + sc.margin * 2;
+  const totalHeight = maxY - minY + sc.margin * 2;
+  const nodeMap = /* @__PURE__ */ new Map();
+  for (const p of positioned) {
+    nodeMap.set(p.node.id, p);
+  }
+  const nodes = [];
+  const edges = [];
+  for (const p of positioned) {
+    const resolvedColor = resolveNodeColor(p.node, tagGroups, activeTagGroup);
+    const hiddenCount = hiddenCounts.get(p.node.id);
+    nodes.push({
+      id: p.node.id,
+      label: p.node.label,
+      ...p.node.description !== void 0 && {
+        description: [...p.node.description]
+      },
+      metadata: { ...p.node.metadata },
+      lineNumber: p.node.lineNumber,
+      ...resolvedColor !== void 0 && { color: resolvedColor },
+      x: p.x + offsetX,
+      y: p.y + offsetY,
+      width: p.width,
+      height: p.height,
+      depth: p.depth,
+      angle: 0,
+      radius: 0,
+      ...hiddenCount !== void 0 && { hiddenCount },
+      hasChildren: hiddenCounts.has(p.node.id) || p.node.children.length > 0
+    });
+  }
+  const childrenByParent = /* @__PURE__ */ new Map();
+  for (const p of positioned) {
+    if (p.node.parentId) {
+      const arr = childrenByParent.get(p.node.parentId) ?? [];
+      arr.push(p);
+      childrenByParent.set(p.node.parentId, arr);
+    }
+  }
+  const groupedEdges = [];
+  for (const [parentId, children] of childrenByParent) {
+    const rightKids = children.filter((c) => c.direction === "right");
+    const leftKids = children.filter((c) => c.direction === "left");
+    if (rightKids.length > 0) groupedEdges.push([parentId, rightKids]);
+    if (leftKids.length > 0) groupedEdges.push([parentId, leftKids]);
+  }
+  for (const [parentId, children] of groupedEdges) {
+    const parent = nodeMap.get(parentId);
+    const px = parent.x + offsetX;
+    const py = parent.y + offsetY;
+    const isLeft = children[0].direction === "left";
+    const srcX = isLeft ? px : px + parent.width;
+    const srcY = py + parent.height / 2;
+    const firstChild = children[0];
+    const childEdgeX = isLeft ? firstChild.x + offsetX + firstChild.width : firstChild.x + offsetX;
+    const midX = (srcX + childEdgeX) / 2;
+    if (children.length === 1) {
+      const c = children[0];
+      const tgtX = isLeft ? c.x + offsetX + c.width : c.x + offsetX;
+      const tgtY = c.y + offsetY + c.height / 2;
+      edges.push({
+        sourceId: parentId,
+        targetId: c.node.id,
+        path: `M ${srcX} ${srcY} L ${midX} ${srcY} L ${midX} ${tgtY} L ${tgtX} ${tgtY}`
+      });
+    } else {
+      edges.push({
+        sourceId: parentId,
+        targetId: parentId,
+        // self-ref = trunk
+        path: `M ${srcX} ${srcY} L ${midX} ${srcY}`
+      });
+      const childYs = children.map((c) => c.y + offsetY + c.height / 2);
+      const minChildY = Math.min(...childYs);
+      const maxChildY = Math.max(...childYs);
+      edges.push({
+        sourceId: parentId,
+        targetId: parentId,
+        // self-ref = bar
+        path: `M ${midX} ${minChildY} L ${midX} ${maxChildY}`
+      });
+      for (let i = 0; i < children.length; i++) {
+        const c = children[i];
+        const tgtX = isLeft ? c.x + offsetX + c.width : c.x + offsetX;
+        const tgtY = childYs[i];
+        edges.push({
+          sourceId: parentId,
+          targetId: c.node.id,
+          path: `M ${midX} ${tgtY} L ${tgtX} ${tgtY}`
+        });
+      }
+    }
+  }
+  return { nodes, edges, width: totalWidth, height: totalHeight };
+}
+function balancedSplitS(children, hideDescriptions, sc) {
+  if (children.length <= 1) {
+    return { right: [...children], left: [] };
+  }
+  if (children.length === 2) {
+    return { right: [children[0]], left: [children[1]] };
+  }
+  const weights = children.map((c, i) => ({
+    index: i,
+    node: c,
+    height: computeSubtreeHeightS(c, 1, hideDescriptions, sc)
+  }));
+  const right = [];
+  const left = [];
+  let rightWeight = 0;
+  let leftWeight = 0;
+  for (const w of weights) {
+    if (rightWeight <= leftWeight) {
+      right.push(w.node);
+      rightWeight += w.height;
+    } else {
+      left.push(w.node);
+      leftWeight += w.height;
+    }
+  }
+  return { right, left };
+}
+function offsetPath(path, dx, dy) {
+  if (dx === 0 && dy === 0) return path;
+  return path.replace(
+    /([ML])\s*([\d.e+-]+)\s+([\d.e+-]+)/g,
+    (_, cmd, x, y) => `${cmd} ${parseFloat(x) + dx} ${parseFloat(y) + dy}`
+  );
+}
+function nodeWidthS(depth, sc) {
+  if (depth === 0) return sc.rootWidth;
+  if (depth === 1) return sc.depth1Width;
+  return sc.leafWidth;
+}
+function nodeHeightS(node, hideDescriptions, sc) {
+  const depth = getNodeDepth(node);
+  const w = nodeWidthS(depth, sc);
+  const text = computeNodeText(
+    node.label,
+    node.description ? [...node.description] : void 0,
+    depth,
+    w,
+    hideDescriptions
+  );
+  const labelLineCount = text.labelLines.length;
+  const labelH = labelLineCount <= 1 ? SINGLE_LABEL_HEIGHT : LABEL_LINE_HEIGHT * labelLineCount;
+  let h = labelH + NODE_V_PAD;
+  if (text.descLines.length > 0) {
+    h += DESC_LINE_HEIGHT * text.descLines.length + 4;
+  }
+  return h;
+}
+function getNodeDepth(node) {
+  return nodeDepthCache.get(node.id) ?? 0;
+}
+var nodeDepthCache = /* @__PURE__ */ new Map();
+function populateDepthCache(roots) {
+  nodeDepthCache.clear();
+  const walk = (nodes, depth) => {
+    for (const n of nodes) {
+      nodeDepthCache.set(n.id, depth);
+      walk(n.children, depth + 1);
+    }
+  };
+  walk(roots, 0);
+}
+
+export {
+  computeNodeText,
+  layoutMindmap
+};
+//# sourceMappingURL=chunk-T2OE3YQB.js.map