@diagrammo/dgmo 0.46.0 → 0.48.0

package/dist/chunk-FCIIHT24.js

@@ -0,0 +1,384 @@
+import {
+  buildHeatScale,
+  buildLegend,
+  compactNumber,
+  formatPct,
+  resolveCellColor,
+  resolveColorMode
+} from "./chunk-IZMRON6C.js";
+import {
+  renderIntegratedLegend
+} from "./chunk-PWIHZ6NJ.js";
+import {
+  getMaxLegendReservedHeight
+} from "./chunk-YAA6IID3.js";
+import {
+  TITLE_FONT_SIZE,
+  TITLE_FONT_WEIGHT,
+  TITLE_Y
+} from "./chunk-A4GOY3PE.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,
+  mix
+} from "./chunk-P6T66CCZ.js";
+import {
+  tagAttrKey
+} from "./chunk-QLCCJEJI.js";
+
+// src/treemap/renderer.ts
+import * as d3Selection from "d3-selection";
+
+// src/treemap/layout.ts
+import {
+  hierarchy,
+  treemap,
+  treemapSquarify
+} 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 layoutTreemap(roots, opts) {
+  const maxDepth = opts.maxDepth ?? Infinity;
+  const rootDatum = {
+    label: "__root",
+    children: roots.map((r) => toDatum(r))
+  };
+  const h = hierarchy(rootDatum).sum((d) => d.children?.length ? 0 : d.value ?? 0).sort((a, b) => (b.value ?? 0) - (a.value ?? 0));
+  const hroot = treemap().tile(treemapSquarify).size([opts.width, opts.height]).paddingOuter(opts.paddingOuter ?? 3).paddingTop(opts.headerH > 0 ? opts.headerH : opts.paddingInner ?? 2).paddingInner(opts.paddingInner ?? 2).round(true)(h);
+  const total = hroot.value ?? 0;
+  (hroot.children ?? []).forEach((top, i) => {
+    top.each((d) => {
+      d._topIndex = i;
+    });
+  });
+  const cells = [];
+  for (const d of hroot.descendants()) {
+    if (d.depth === 0) continue;
+    if (d.depth > maxDepth) continue;
+    const hasChildren = !!d.children && d.children.length > 0;
+    const isCollapsed = hasChildren && d.depth >= maxDepth;
+    const isContainer = hasChildren && !isCollapsed;
+    const path = [];
+    let p = d;
+    while (p && p.depth > 0) {
+      path.unshift(p.data.label);
+      p = p.parent;
+    }
+    const heatVal = datumHeat(d);
+    cells.push({
+      node: d.data.ref ?? null,
+      label: d.data.label,
+      x0: d.x0,
+      y0: d.y0,
+      x1: d.x1,
+      y1: d.y1,
+      depth: d.depth,
+      value: d.value ?? 0,
+      isContainer,
+      isCollapsed,
+      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 };
+}
+
+// src/treemap/renderer.ts
+var PADDING = 12;
+var HEADER_H = 18;
+var TITLE_BAND = 36;
+var LEAF_MUTE_PCT = 50;
+var LEGEND_POSITION = {
+  placement: "top-center",
+  titleRelation: "below-title"
+};
+function renderTreemapForExport(container, parsed, palette, isDark, exportDims, options) {
+  renderTreemap(container, parsed, palette, isDark, exportDims, {
+    exportMode: true,
+    ...options
+  });
+}
+function renderTreemap(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 solid = opts.solidFill;
+  const exportMode = options.exportMode ?? false;
+  const seriesColorsTop = getSeriesColors(palette);
+  const showTitle = !!parsed.title;
+  const titleH = showTitle ? TITLE_BAND : 0;
+  const heat = buildHeatScale(parsed, palette);
+  const legend = !opts.noLegend ? buildLegend(mode, parsed, heat, seriesColorsTop, options.colorOffset ?? 0) : null;
+  const legendReserve = legend ? getMaxLegendReservedHeight(
+    { groups: legend.groups, position: LEGEND_POSITION, mode: "preview" },
+    width
+  ) + LEGEND_GROUP_GAP : 0;
+  const headerH = opts.noHeaders ? 0 : HEADER_H;
+  const areaX = PADDING;
+  const areaY = titleH + legendReserve + PADDING;
+  const areaW = Math.max(1, width - PADDING * 2);
+  const areaH = Math.max(1, height - areaY - PADDING);
+  const layout = layoutTreemap(parsed.roots, {
+    width: areaW,
+    height: areaH,
+    headerH,
+    ...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").style("font-family", FONT_FAMILY);
+  svg.append("style").text(
+    ".dgmo-treemap-focus{opacity:.3;transition:opacity .12s}.dgmo-treemap-cell:hover .dgmo-treemap-focus{opacity:.7}"
+  );
+  svg.append("rect").attr("width", width).attr("height", height).attr("fill", palette.bg);
+  if (showTitle) {
+    const title = svg.append("text").attr("class", "chart-title").attr("x", width / 2).attr("y", TITLE_Y).attr("text-anchor", "middle").attr("fill", palette.text).attr("font-family", FONT_FAMILY).attr("font-size", TITLE_FONT_SIZE).attr("font-weight", TITLE_FONT_WEIGHT).text(parsed.title);
+    if (parsed.titleLineNumber !== null) {
+      title.attr("data-line-number", parsed.titleLineNumber);
+    }
+  }
+  const root = svg.append("g").attr("class", "dgmo-treemap-cells").attr("transform", `translate(${areaX},${areaY})`);
+  const seriesColors = seriesColorsTop;
+  const colorOffset = options.colorOffset ?? 0;
+  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,
+    bg: palette.bg
+  };
+  for (const cell of layout.cells) {
+    const w = Math.max(0, cell.x1 - cell.x0);
+    const h = Math.max(0, cell.y1 - cell.y0);
+    if (w <= 0 || h <= 0) continue;
+    const baseColor = resolveCellColor(cell, colorCtx);
+    const fill = cell.isContainer ? baseColor : solid ? baseColor : mix(baseColor, palette.bg, LEAF_MUTE_PCT);
+    const drillable = cell.isContainer || cell.isCollapsed;
+    const g = root.append("g").attr("class", "dgmo-treemap-cell").attr("transform", `translate(${cell.x0},${cell.y0})`).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);
+    }
+    const rect = g.append("rect").attr(
+      "class",
+      cell.isContainer ? "dgmo-treemap-rect branch" : "dgmo-treemap-rect"
+    ).attr("width", w).attr("height", h).attr("rx", 2).attr("fill", fill).attr("fill-opacity", 1).attr("stroke", palette.bg).attr("stroke-width", cell.isContainer ? 1 : 0);
+    if (drillable && options.onClickItem && cell.lineNumber !== void 0) {
+      const ln = cell.lineNumber;
+      rect.style("cursor", "pointer").on("click", () => options.onClickItem(ln));
+    }
+    const ink = contrastText(
+      fill,
+      palette.textOnFillLight,
+      palette.textOnFillDark
+    );
+    if (cell.isContainer && headerH > 0 && w > 34 && h > headerH) {
+      const valParts = [];
+      if (!opts.noValues) valParts.push(compactNumber(cell.value));
+      if (!opts.noPercent) valParts.push(formatPct(cell.pctOfRoot));
+      const valStr = valParts.join(" \xB7 ");
+      const ICON_RESERVE = drillable ? 16 : 4;
+      const showVal = valStr.length > 0 && w > 110;
+      const valW = showVal ? measureText(valStr, 10.5) : 0;
+      const labelMax = w - 8 - ICON_RESERVE - (showVal ? valW + 10 : 0);
+      g.append("text").attr("class", "dgmo-treemap-header").attr("x", 6).attr("y", 13).attr("font-size", 11).attr("font-weight", 700).attr("fill", ink).text(clipLabel(cell.label, Math.max(0, labelMax), 11));
+      if (showVal) {
+        g.append("text").attr("class", "dgmo-treemap-header-value").attr("x", w - ICON_RESERVE - 4).attr("y", 13).attr("text-anchor", "end").attr("font-size", 10.5).attr("fill", ink).attr("opacity", 0.75).text(valStr);
+      }
+    }
+    const PAD = Math.max(4, Math.min(14, Math.floor(Math.min(w, h) / 5)));
+    const MIN_FS = 7;
+    if (!cell.isContainer && w >= 2 * PAD + 8 && h >= 2 * PAD + 8) {
+      const maxW = w - 2 * PAD;
+      const horizMinW = measureText(cell.label, MIN_FS) * 1.06;
+      if (horizMinW > maxW && h > w * 1.25 && h - 2 * PAD > maxW) {
+        drawVerticalLabel(g, cell.label, w, h, PAD, ink);
+        if (drillable && w > 30 && h > 22) drawFocusIcon(g, w, ink, 9);
+        continue;
+      }
+      let fs = clamp(Math.round(Math.min(w / 3.6, h / 3.4)), MIN_FS, 72);
+      const nameW = measureText(cell.label, fs) * 1.06;
+      if (nameW > maxW) fs = Math.max(MIN_FS, Math.floor(fs * maxW / nameW));
+      const tg = clamp((fs - MIN_FS) / (72 - MIN_FS), 0, 1);
+      const nameOpacity = 0.95 - tg * 0.5;
+      const vfs = clamp(Math.round(fs * 0.42), 11, 28);
+      const valOpacity = Math.max(0.45, nameOpacity - 0.1);
+      let y = PAD + Math.round(fs * 0.78);
+      g.append("text").attr("class", "dgmo-treemap-label").attr("x", PAD).attr("y", y).attr("font-size", fs).attr("font-weight", 600).attr("fill", ink).attr("opacity", nameOpacity).text(clipLabel(cell.label, maxW, fs));
+      const valParts = [
+        opts.noValues ? "" : compactNumber(cell.value),
+        opts.noPercent ? "" : formatPct(cell.pctOfRoot)
+      ].filter(Boolean);
+      const combined = valParts.join(" \xB7 ");
+      const nameBaseY = y;
+      const addLineAt = (text, yy, size, opacity) => {
+        g.append("text").attr("class", "dgmo-treemap-value").attr("x", PAD).attr("y", yy).attr("font-size", size).attr("fill", ink).attr("opacity", opacity).text(text);
+      };
+      if (combined) {
+        const fitsW = measureText(combined, vfs) <= maxW;
+        const valY = y + lineDrop(fs, vfs);
+        const roomBelow = valY + descent(vfs) <= h - PAD;
+        if (fitsW && roomBelow) {
+          addLineAt(combined, valY, vfs, valOpacity);
+        } else if (fitsW) {
+          const ivfs = clamp(Math.round(fs * 0.5), 11, Math.max(11, vfs));
+          const rendered = clipLabel(cell.label, maxW, fs);
+          const nW = measureText(rendered, fs) * 1.12;
+          const gap = Math.max(12, Math.round(fs * 0.25));
+          if (PAD + nW + gap + measureText(combined, ivfs) <= w - PAD) {
+            g.append("text").attr("class", "dgmo-treemap-value").attr("x", PAD + nW + gap).attr("y", nameBaseY).attr("font-size", ivfs).attr("fill", ink).attr("opacity", valOpacity).text(combined);
+          }
+        } else if (valParts.length === 2) {
+          const d1 = lineDrop(fs, vfs);
+          if (y + d1 + descent(vfs) <= h - PAD) {
+            y += d1;
+            addLineAt(valParts[0], y, vfs, valOpacity);
+          }
+          const pfs = Math.max(10, Math.round(vfs * 0.9));
+          const d2 = lineDrop(vfs, pfs);
+          if (y + d2 + descent(pfs) <= h - PAD) {
+            y += d2;
+            addLineAt(valParts[1], y, pfs, valOpacity);
+          }
+        } else {
+          const onlyY = y + lineDrop(fs, vfs);
+          if (onlyY + descent(vfs) <= h - PAD) {
+            addLineAt(combined, onlyY, vfs, valOpacity);
+          }
+        }
+      }
+    }
+    if (drillable && w > 30 && h > 22) {
+      drawFocusIcon(g, w, ink, 9);
+    }
+  }
+  if (legend) {
+    const legendG = svg.append("g").attr("class", "dgmo-treemap-legend").attr("transform", `translate(0, ${titleH})`);
+    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,
+      // The color-mode switcher is the legend itself: each applicable mode is a
+      // group pill; the active one is the open capsule, the rest are clickable
+      // pills that switch mode. Export shows only the active group.
+      showInactivePills: !exportMode,
+      showEmptyGroups: !exportMode,
+      ...options.onSelectMode !== void 0 && {
+        callbacks: {
+          onGroupToggle: (name) => {
+            const m = legend.modeByName.get(name);
+            if (m) options.onSelectMode(m);
+          }
+        }
+      }
+    });
+  }
+}
+function drawFocusIcon(g, w, ink, cy) {
+  const r = 4.5;
+  const cx = w - r - 5;
+  const fi = g.append("g").attr("class", "dgmo-treemap-focus").attr("data-export-ignore", "true");
+  fi.append("rect").attr("x", cx - 9).attr("y", cy - 9).attr("width", 18).attr("height", 18).attr("fill", "transparent");
+  fi.append("circle").attr("cx", cx).attr("cy", cy).attr("r", r).attr("fill", "none").attr("stroke", ink).attr("stroke-width", 1.25);
+  fi.append("circle").attr("cx", cx).attr("cy", cy).attr("r", 1.4).attr("fill", ink);
+}
+function drawVerticalLabel(g, label, w, h, pad, ink) {
+  const MIN_FS = 6;
+  const availLen = h - 2 * pad;
+  const availThick = w - 2 * pad;
+  let fs = clamp(Math.round(Math.min(availThick / 0.8, 14)), MIN_FS, 22);
+  const nameW = measureText(label, fs) * 1.06;
+  if (nameW > availLen)
+    fs = Math.max(MIN_FS, Math.floor(fs * availLen / nameW));
+  const text = clipLabel(label, availLen, fs);
+  if (!text) return;
+  g.append("text").attr("class", "dgmo-treemap-label").attr("transform", `translate(${w / 2},${h / 2}) rotate(-90)`).attr("y", Math.round(fs * 0.28)).attr("text-anchor", "middle").attr("font-size", fs).attr("font-weight", 600).attr("fill", ink).attr("opacity", 0.95).text(text);
+}
+function descent(fs) {
+  return Math.ceil(fs * 0.26);
+}
+function lineDrop(prevFs, nextFs, gap = 4) {
+  return descent(prevFs) + gap + Math.round(nextFs * 0.72);
+}
+function clamp(x, lo, hi) {
+  return Math.max(lo, Math.min(hi, x));
+}
+function clipLabel(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 {
+  layoutTreemap,
+  renderTreemapForExport,
+  renderTreemap
+};
+//# sourceMappingURL=chunk-FCIIHT24.js.map

package/dist/chunk-FFUN5D66.js

@@ -0,0 +1,97 @@
+import {
+  makeDgmoError
+} from "./chunk-CXK4DZH3.js";
+
+// src/utils/arrows.ts
+var ARROW_DIAGNOSTIC_CODES = {
+  /** Active: label contains `->` or `~>` substring (TD-13). */
+  ARROW_SUBSTRING_IN_LABEL: "E_ARROW_SUBSTRING_IN_LABEL",
+  /** Active: label contains a forbidden control character (TD-14). */
+  CONTROL_CHAR_IN_LABEL: "E_CONTROL_CHAR_IN_LABEL"
+};
+function validateLabelCharacters(label, lineNumber) {
+  const out = [];
+  if (label.includes("->") || label.includes("~>")) {
+    out.push(
+      makeDgmoError(
+        lineNumber,
+        'Arrow symbols (-> or ~>) are not allowed inside a label. Move the label after the arrow: "A -> B: uses -> to chain". See "In-Arrow Message Labels" \u2192 Forbidden.',
+        "error",
+        ARROW_DIAGNOSTIC_CODES.ARROW_SUBSTRING_IN_LABEL
+      )
+    );
+  }
+  for (const ch of label) {
+    const cp = ch.codePointAt(0);
+    const isC0 = cp >= 0 && cp <= 31 && cp !== 9;
+    const isDel = cp === 127;
+    if (isC0 || isDel) {
+      const hex = cp.toString(16).toUpperCase().padStart(4, "0");
+      out.push(
+        makeDgmoError(
+          lineNumber,
+          `Label contains a control character (U+${hex}). Remove it and use plain text.`,
+          "error",
+          ARROW_DIAGNOSTIC_CODES.CONTROL_CHAR_IN_LABEL
+        )
+      );
+      break;
+    }
+  }
+  return out;
+}
+function parseInArrowLabel(rawLabel, lineNumber) {
+  const trimmed = rawLabel.trim();
+  if (trimmed.length === 0) {
+    return { label: void 0, diagnostics: [] };
+  }
+  const diagnostics = validateLabelCharacters(trimmed, lineNumber);
+  return { label: trimmed, diagnostics };
+}
+var SYNC_LABELED_RE = /^(.+?)\s*-(.+)->\s*(.+)$/;
+var ASYNC_LABELED_RE = /^(.+?)\s*~(.+)~>\s*(.+)$/;
+var RETURN_SYNC_LABELED_RE = /^(.+?)\s*<-(.+)-\s*(.+)$/;
+var RETURN_ASYNC_LABELED_RE = /^(.+?)\s*<~(.+)~\s*(.+)$/;
+var BIDI_SYNC_RE = /^(.+?)\s*<-(.+)->\s*(.+)$/;
+var BIDI_ASYNC_RE = /^(.+?)\s*<~(.+)~>\s*(.+)$/;
+function parseArrow(line) {
+  if (BIDI_SYNC_RE.test(line) || BIDI_ASYNC_RE.test(line)) {
+    return {
+      error: "Bidirectional arrows are no longer supported. Use two separate lines: 'A -msg-> B' and 'B -msg-> A'"
+    };
+  }
+  if (RETURN_SYNC_LABELED_RE.test(line) || RETURN_ASYNC_LABELED_RE.test(line)) {
+    const m = line.match(RETURN_SYNC_LABELED_RE) ?? line.match(RETURN_ASYNC_LABELED_RE);
+    const from = m[3];
+    const to = m[1];
+    const label = m[2].trim();
+    return {
+      error: `Left-pointing arrows are no longer supported. Write '${from} -${label}-> ${to}' instead`
+    };
+  }
+  const patterns = [
+    { re: SYNC_LABELED_RE, async: false },
+    { re: ASYNC_LABELED_RE, async: true }
+  ];
+  for (const { re, async: isAsync } of patterns) {
+    const m = line.match(re);
+    if (!m) continue;
+    const label = m[2].trim();
+    if (!label) return null;
+    return {
+      from: m[1],
+      to: m[3],
+      label,
+      async: isAsync
+    };
+  }
+  return null;
+}
+
+export {
+  ARROW_DIAGNOSTIC_CODES,
+  validateLabelCharacters,
+  parseInArrowLabel,
+  parseArrow
+};
+//# sourceMappingURL=chunk-FFUN5D66.js.map