@diagrammo/dgmo 0.46.0 → 0.47.0

package/dist/chunk-IJZFN3HM.js

@@ -0,0 +1,463 @@
+import {
+  buildPlacedNotes
+} from "./chunk-JED6ZDEE.js";
+import {
+  noteCanvasShift
+} from "./chunk-6EK55ART.js";
+import {
+  measureText,
+  truncateText,
+  wrapTextToWidth
+} from "./chunk-WCT3NYCV.js";
+import {
+  resolveNotes
+} from "./chunk-FMDSF3OV.js";
+
+// src/boxes-and-lines/label-placement.ts
+var EDGE_LABEL_FONT_SIZE = 11;
+var LABEL_MAX_WIDTH = 160;
+var MAX_LABEL_LINES = 3;
+var LABEL_LINE_HEIGHT = 1.3;
+var H_PAD = 6;
+var V_PAD = 3;
+var BOX_CLEAR_PAD = 4;
+var PERP_STEP = 8;
+var PERP_MAX = 40;
+var SLIDE_SAMPLES = 9;
+function measureEdgeLabel(label, fontSize = EDGE_LABEL_FONT_SIZE, maxWidth = LABEL_MAX_WIDTH) {
+  let lines = wrapTextToWidth(label, fontSize, maxWidth, { hardBreak: true });
+  if (lines.length > MAX_LABEL_LINES) {
+    const kept = lines.slice(0, MAX_LABEL_LINES - 1);
+    const rest = lines.slice(MAX_LABEL_LINES - 1).join(" ");
+    kept.push(truncateText(rest, fontSize, maxWidth));
+    lines = kept;
+  }
+  let textW = 0;
+  for (const ln of lines) {
+    const w = measureText(ln, fontSize);
+    if (w > textW) textW = w;
+  }
+  return {
+    lines,
+    width: textW + 2 * H_PAD,
+    height: lines.length * fontSize * LABEL_LINE_HEIGHT + 2 * V_PAD
+  };
+}
+function edgePolylineMidpoint(points) {
+  return pointAtArcFraction(points, 0.5).p;
+}
+function pointAtArcFraction(points, t) {
+  if (points.length === 0) return { p: { x: 0, y: 0 }, nx: 0, ny: 1 };
+  if (points.length === 1)
+    return { p: { x: points[0].x, y: points[0].y }, nx: 0, ny: 1 };
+  const segLen = [];
+  let total = 0;
+  for (let k = 1; k < points.length; k++) {
+    const len = Math.hypot(
+      points[k].x - points[k - 1].x,
+      points[k].y - points[k - 1].y
+    );
+    segLen.push(len);
+    total += len;
+  }
+  let want = total * Math.max(0, Math.min(1, t));
+  for (let k = 1; k < points.length; k++) {
+    const len = segLen[k - 1];
+    if (want <= len || k === points.length - 1) {
+      const f = len === 0 ? 0 : Math.min(1, want / len);
+      const ax = points[k - 1].x;
+      const ay = points[k - 1].y;
+      const bx = points[k].x;
+      const by = points[k].y;
+      const dx = bx - ax;
+      const dy = by - ay;
+      const dlen = Math.hypot(dx, dy) || 1;
+      return {
+        p: { x: ax + dx * f, y: ay + dy * f },
+        nx: -dy / dlen,
+        ny: dx / dlen
+      };
+    }
+    want -= len;
+  }
+  const last = points[points.length - 1];
+  return { p: { x: last.x, y: last.y }, nx: 0, ny: 1 };
+}
+function rectFromCenter(cx, cy, w, h) {
+  return {
+    minX: cx - w / 2,
+    minY: cy - h / 2,
+    maxX: cx + w / 2,
+    maxY: cy + h / 2
+  };
+}
+function overlapsAny(cx, cy, w, h, obstacles, pad) {
+  const minX = cx - w / 2 - pad;
+  const minY = cy - h / 2 - pad;
+  const maxX = cx + w / 2 + pad;
+  const maxY = cy + h / 2 + pad;
+  for (const o of obstacles) {
+    if (minX < o.maxX && maxX > o.minX && minY < o.maxY && maxY > o.minY)
+      return true;
+  }
+  return false;
+}
+function slideFractions() {
+  const out = [0.5];
+  for (let k = 1; k <= SLIDE_SAMPLES; k++) {
+    const off = k * 0.08;
+    if (0.5 - off >= 0.12) out.push(0.5 - off);
+    if (0.5 + off <= 0.88) out.push(0.5 + off);
+  }
+  return out;
+}
+function findClearPosition(w, h, points, obstacles) {
+  const ts = slideFractions();
+  for (const t of ts) {
+    const { p } = pointAtArcFraction(points, t);
+    if (!overlapsAny(p.x, p.y, w, h, obstacles, BOX_CLEAR_PAD)) return p;
+  }
+  for (let mag = PERP_STEP; mag <= PERP_MAX; mag += PERP_STEP) {
+    for (const t of ts) {
+      const { p, nx, ny } = pointAtArcFraction(points, t);
+      for (const sign of [-1, 1]) {
+        const x = p.x + nx * mag * sign;
+        const y = p.y + ny * mag * sign;
+        if (!overlapsAny(x, y, w, h, obstacles, BOX_CLEAR_PAD)) return { x, y };
+      }
+    }
+  }
+  return null;
+}
+function resolveLabelOverlaps(boxes) {
+  const MAX_PASSES = 8;
+  const PAD = 4;
+  for (let pass = 0; pass < MAX_PASSES; pass++) {
+    let moved = false;
+    for (let i = 0; i < boxes.length; i++) {
+      for (let j = i + 1; j < boxes.length; j++) {
+        const a = boxes[i];
+        const b = boxes[j];
+        const dx = Math.abs(a.cx - b.cx);
+        const dy = Math.abs(a.cy - b.cy);
+        const overlapX = (a.w + b.w) / 2 + PAD - dx;
+        const overlapY = (a.h + b.h) / 2 + PAD - dy;
+        if (overlapX > 0 && overlapY > 0) {
+          const shift = overlapY / 2 + 1;
+          if (a.cy < b.cy) {
+            a.cy -= shift;
+            b.cy += shift;
+          } else {
+            a.cy += shift;
+            b.cy -= shift;
+          }
+          moved = true;
+        }
+      }
+    }
+    if (!moved) break;
+  }
+}
+function placeEdgeLabels(layout, opts) {
+  const fontSize = opts?.fontSize ?? EDGE_LABEL_FONT_SIZE;
+  const maxWidth = opts?.maxWidth ?? LABEL_MAX_WIDTH;
+  const obstacles = [];
+  for (const n of layout.nodes)
+    obstacles.push(rectFromCenter(n.x, n.y, n.width, n.height));
+  for (const g of layout.groups)
+    if (g.collapsed)
+      obstacles.push(rectFromCenter(g.x, g.y, g.width, g.height));
+  const boxes = [];
+  layout.edges.forEach((e, idx) => {
+    if (!e.label || e.points.length < 2) return;
+    const m = measureEdgeLabel(e.label, fontSize, maxWidth);
+    const mid = edgePolylineMidpoint(e.points);
+    let cy = mid.y;
+    if (e.parallelCount > 1 && e.yOffset !== 0)
+      cy += (e.yOffset < 0 ? -1 : 1) * (m.height / 2);
+    boxes.push({
+      edgeIdx: idx,
+      cx: mid.x,
+      cy,
+      w: m.width,
+      h: m.height,
+      lines: m.lines,
+      resolved: true
+    });
+  });
+  for (const box of boxes) {
+    if (!overlapsAny(box.cx, box.cy, box.w, box.h, obstacles, BOX_CLEAR_PAD))
+      continue;
+    const e = layout.edges[box.edgeIdx];
+    const clear = findClearPosition(box.w, box.h, e.points, obstacles);
+    if (clear) {
+      box.cx = clear.x;
+      box.cy = clear.y;
+    } else {
+      box.resolved = false;
+    }
+  }
+  resolveLabelOverlaps(boxes);
+  for (const box of boxes) {
+    if (overlapsAny(box.cx, box.cy, box.w, box.h, obstacles, BOX_CLEAR_PAD))
+      box.resolved = false;
+  }
+  const boxByIdx = /* @__PURE__ */ new Map();
+  for (const b of boxes) boxByIdx.set(b.edgeIdx, b);
+  const edges = layout.edges.map((e, idx) => {
+    const b = boxByIdx.get(idx);
+    if (!b) return e;
+    return {
+      ...e,
+      labelX: b.cx,
+      labelY: b.cy,
+      labelWidth: b.w,
+      labelHeight: b.h,
+      labelLines: b.lines
+    };
+  });
+  return {
+    layout: { ...layout, edges },
+    unresolved: boxes.filter((b) => !b.resolved).map((b) => b.edgeIdx)
+  };
+}
+
+// src/boxes-and-lines/layout.ts
+var MARGIN = 40;
+var MAX_PARALLEL_EDGES = 5;
+var PARALLEL_SPACING = 22;
+var PHI = 1.618;
+var NODE_HEIGHT = 60;
+var NODE_WIDTH = Math.round(NODE_HEIGHT * PHI);
+var DESC_NODE_WIDTH = 140;
+var DESC_FONT_SIZE = 10;
+var DESC_LINE_HEIGHT = 1.4;
+var DESC_PADDING = 8;
+var SEPARATOR_GAP = 4;
+var MAX_DESC_LINES = 6;
+var MAX_LABEL_LINES2 = 3;
+var LABEL_LINE_HEIGHT2 = 1.3;
+var LABEL_PAD = 12;
+var VALUE_ROW_FONT = 11;
+var VALUE_ROW_H = SEPARATOR_GAP + VALUE_ROW_FONT * DESC_LINE_HEIGHT + DESC_PADDING;
+function splitCamelCase(word) {
+  const parts = [];
+  let start = 0;
+  for (let i = 1; i < word.length; i++) {
+    const prev = word.charAt(i - 1);
+    const curr = word.charAt(i);
+    const next = i + 1 < word.length ? word.charAt(i + 1) : "";
+    const lowerToUpper = prev >= "a" && prev <= "z" && curr >= "A" && curr <= "Z";
+    const upperRunEnd = prev >= "A" && prev <= "Z" && curr >= "A" && curr <= "Z" && next >= "a" && next <= "z";
+    if (lowerToUpper || upperRunEnd) {
+      parts.push(word.slice(start, i));
+      start = i;
+    }
+  }
+  parts.push(word.slice(start));
+  return parts.length > 1 ? parts : [word];
+}
+function estimateLabelLines(label, nodeWidth = NODE_WIDTH) {
+  const rawParts = label.split(/[\s-]+/);
+  const words = [];
+  for (const part of rawParts) {
+    if (!part) continue;
+    words.push(...splitCamelCase(part));
+  }
+  const maxTextWidth = nodeWidth - 24;
+  for (let fontSize = 13; fontSize >= 9; fontSize--) {
+    if (maxTextWidth < measureText("MM", fontSize)) continue;
+    let lines = 1;
+    let current = "";
+    for (const word of words) {
+      const test = current ? `${current} ${word}` : word;
+      if (measureText(test, fontSize) <= maxTextWidth) {
+        current = test;
+      } else {
+        lines++;
+        current = word;
+      }
+    }
+    if (lines <= MAX_LABEL_LINES2) return Math.min(lines, MAX_LABEL_LINES2);
+  }
+  return MAX_LABEL_LINES2;
+}
+function computeNodeSize(node, reserveValueRow) {
+  if (!node.description || node.description.length === 0) {
+    return { width: NODE_WIDTH, height: NODE_HEIGHT };
+  }
+  const w = DESC_NODE_WIDTH;
+  const labelLines = estimateLabelLines(node.label, w);
+  const labelHeight = labelLines * 13 * LABEL_LINE_HEIGHT2 + LABEL_PAD;
+  const maxTextWidth = w - 24;
+  let totalRenderedLines = 0;
+  for (const line of node.description) {
+    if (measureText(line, DESC_FONT_SIZE) <= maxTextWidth) {
+      totalRenderedLines += 1;
+    } else {
+      totalRenderedLines += wrapTextToWidth(
+        line,
+        DESC_FONT_SIZE,
+        maxTextWidth,
+        {
+          hardBreak: true
+        }
+      ).length;
+    }
+  }
+  totalRenderedLines = Math.min(totalRenderedLines, MAX_DESC_LINES);
+  const descriptionHeight = totalRenderedLines * DESC_FONT_SIZE * DESC_LINE_HEIGHT;
+  const totalHeight = labelHeight + SEPARATOR_GAP + DESC_PADDING + descriptionHeight + DESC_PADDING + (reserveValueRow ? VALUE_ROW_H : 0);
+  return { width: w, height: Math.max(NODE_HEIGHT, totalHeight) };
+}
+async function layoutBoxesAndLines(parsed, collapseInfo, layoutOptions) {
+  const { layoutBoxesAndLinesSearch } = await import("./layout-search-OYV77HHS.js");
+  const searchOpts = {
+    ...layoutOptions?.hideDescriptions !== void 0 && {
+      hideDescriptions: layoutOptions.hideDescriptions
+    },
+    ...layoutOptions?.previousPositions !== void 0 && {
+      previousPositions: layoutOptions.previousPositions
+    },
+    ...layoutOptions?.onProgress !== void 0 && {
+      onProgress: layoutOptions.onProgress
+    }
+  };
+  const searched = await layoutBoxesAndLinesSearch(
+    parsed,
+    collapseInfo,
+    searchOpts
+  );
+  let placed = placeEdgeLabels(applyParallelEdgeOffsets(searched));
+  if (placed.unresolved.length > 0) {
+    const relaid = await layoutBoxesAndLinesSearch(parsed, collapseInfo, {
+      ...searchOpts,
+      reserveEdgeLabels: true
+    });
+    const relaidPlaced = placeEdgeLabels(applyParallelEdgeOffsets(relaid));
+    if (relaidPlaced.unresolved.length < placed.unresolved.length)
+      placed = relaidPlaced;
+  }
+  return attachNotes(placed.layout, parsed, layoutOptions?.collapsedNotes);
+}
+function attachNotes(layout, parsed, collapsedNotes) {
+  const notesSuppressed = parsed.options?.["no-notes"] === "on";
+  const noteByNode = notesSuppressed || !parsed.notes ? /* @__PURE__ */ new Map() : resolveNotes(
+    parsed.notes,
+    parsed.nodes.map((n) => ({ id: n.label, label: n.label }))
+  );
+  if (noteByNode.size === 0) return layout;
+  const placed = buildPlacedNotes(
+    layout.nodes.map((n) => ({
+      id: n.label,
+      x: n.x,
+      y: n.y,
+      width: n.width,
+      height: n.height
+    })),
+    noteByNode,
+    parsed.direction === "TB" ? "TB" : "LR",
+    collapsedNotes
+  );
+  const notedNodes = layout.nodes.map((n) => {
+    const note = placed.get(n.label);
+    return note ? { ...n, note } : n;
+  });
+  let bbMinX = Infinity;
+  let bbMinY = Infinity;
+  let bbMaxX = -Infinity;
+  let bbMaxY = -Infinity;
+  const extend = (l, t, r, b) => {
+    if (l < bbMinX) bbMinX = l;
+    if (t < bbMinY) bbMinY = t;
+    if (r > bbMaxX) bbMaxX = r;
+    if (b > bbMaxY) bbMaxY = b;
+  };
+  for (const n of notedNodes) {
+    extend(
+      n.x - n.width / 2,
+      n.y - n.height / 2,
+      n.x + n.width / 2,
+      n.y + n.height / 2
+    );
+    if (n.note && !n.note.collapsed) {
+      extend(
+        n.x + n.note.x,
+        n.y + n.note.y,
+        n.x + n.note.x + n.note.width,
+        n.y + n.note.y + n.note.height
+      );
+    }
+  }
+  for (const grp of layout.groups) {
+    extend(
+      grp.x - grp.width / 2,
+      grp.y - grp.height / 2,
+      grp.x + grp.width / 2,
+      grp.y + grp.height / 2
+    );
+  }
+  if (!Number.isFinite(bbMinX)) return { ...layout, nodes: notedNodes };
+  const { shiftX, shiftY } = noteCanvasShift(bbMinX, bbMinY);
+  const shifted = shiftX !== 0 || shiftY !== 0;
+  const finalNodes = shifted ? notedNodes.map((n) => ({ ...n, x: n.x + shiftX, y: n.y + shiftY })) : notedNodes;
+  const finalEdges = shifted ? layout.edges.map((e) => ({
+    ...e,
+    points: e.points.map((pt) => ({ x: pt.x + shiftX, y: pt.y + shiftY })),
+    ...e.labelX !== void 0 && { labelX: e.labelX + shiftX },
+    ...e.labelY !== void 0 && { labelY: e.labelY + shiftY }
+    // labelWidth/labelHeight/labelLines are shift-invariant — carried via spread.
+  })) : layout.edges;
+  const finalGroups = shifted ? layout.groups.map((grp) => ({
+    ...grp,
+    x: grp.x + shiftX,
+    y: grp.y + shiftY
+  })) : layout.groups;
+  return {
+    nodes: finalNodes,
+    edges: finalEdges,
+    groups: finalGroups,
+    width: bbMaxX + shiftX + MARGIN,
+    height: bbMaxY + shiftY + MARGIN
+  };
+}
+function applyParallelEdgeOffsets(layout) {
+  const groups = /* @__PURE__ */ new Map();
+  layout.edges.forEach((e, i) => {
+    const [a, b] = e.source < e.target ? [e.source, e.target] : [e.target, e.source];
+    const key = `${a}\0${b}`;
+    const arr = groups.get(key);
+    if (arr) arr.push(i);
+    else groups.set(key, [i]);
+  });
+  if ([...groups.values()].every((g) => g.length < 2)) return layout;
+  const yOffset = new Array(layout.edges.length).fill(0);
+  const count = new Array(layout.edges.length).fill(1);
+  for (const idxs of groups.values()) {
+    const capped = idxs.slice(0, MAX_PARALLEL_EDGES);
+    for (const drop of idxs.slice(MAX_PARALLEL_EDGES)) count[drop] = 0;
+    if (capped.length < 2) continue;
+    capped.forEach((idx, j) => {
+      yOffset[idx] = (j - (capped.length - 1) / 2) * PARALLEL_SPACING;
+      count[idx] = capped.length;
+    });
+  }
+  return {
+    ...layout,
+    edges: layout.edges.map((e, i) => ({
+      ...e,
+      yOffset: yOffset[i],
+      parallelCount: count[i]
+    }))
+  };
+}
+
+export {
+  EDGE_LABEL_FONT_SIZE,
+  measureEdgeLabel,
+  NODE_HEIGHT,
+  NODE_WIDTH,
+  computeNodeSize,
+  layoutBoxesAndLines
+};
+//# sourceMappingURL=chunk-IJZFN3HM.js.map