@diagrammo/dgmo 0.46.0 → 0.48.0

package/dist/chunk-DZAQBW35.js

@@ -0,0 +1,751 @@
+import {
+  NODE_STROKE_WIDTH
+} from "./chunk-3CIOJ5YJ.js";
+import {
+  ScaleContext
+} from "./chunk-YYVTBZZC.js";
+import {
+  TITLE_FONT_SIZE,
+  TITLE_FONT_WEIGHT,
+  TITLE_Y
+} from "./chunk-A4GOY3PE.js";
+import {
+  FONT_FAMILY
+} from "./chunk-6KFWC4CO.js";
+import {
+  measureText,
+  truncateText,
+  wrapTextToWidth
+} from "./chunk-WCT3NYCV.js";
+import {
+  VARIANTS,
+  allTasks
+} from "./chunk-RYEGFMUO.js";
+import {
+  contrastText,
+  mix,
+  themeBaseBg
+} from "./chunk-P6T66CCZ.js";
+
+// src/raci/renderer.ts
+import * as d3Selection from "d3-selection";
+function groupDiagnosticsByTask(parsed) {
+  const map = /* @__PURE__ */ new Map();
+  if (parsed.diagnostics.length === 0) return map;
+  const tasks = [];
+  for (const t of parsed.tasksWithoutPhase) tasks.push(t);
+  for (const p of parsed.phases) for (const t of p.tasks) tasks.push(t);
+  for (const d of parsed.diagnostics) {
+    if (d.line <= 0) continue;
+    const owner = tasks.find(
+      (t) => d.line >= t.lineNumber && d.line <= t.endLineNumber
+    );
+    if (!owner) continue;
+    let bucket = map.get(owner.id);
+    if (!bucket) {
+      bucket = { errors: [], warnings: [], firstLine: d.line };
+      map.set(owner.id, bucket);
+    } else if (d.line < bucket.firstLine) {
+      bucket.firstLine = d.line;
+    }
+    const entry = { line: d.line, message: d.message };
+    if (d.severity === "error") bucket.errors.push(entry);
+    else bucket.warnings.push(entry);
+  }
+  return map;
+}
+function trimTaskPrefix(message) {
+  const prefix = message.match(/^Task '[^']*'\s+(.+)$/);
+  if (prefix) {
+    const rest = prefix[1];
+    return rest.charAt(0).toUpperCase() + rest.slice(1);
+  }
+  return message.replace(/\s+on task '[^']*'/, "");
+}
+function topRoundedRectPath(x, y, w, h, r) {
+  const rr = Math.min(r, w / 2, h / 2);
+  return `M ${x} ${y + rr} A ${rr} ${rr} 0 0 1 ${x + rr} ${y} H ${x + w - rr} A ${rr} ${rr} 0 0 1 ${x + w} ${y + rr} V ${y + h} H ${x} Z`;
+}
+function sortByAlphabet(markers, alphabet) {
+  const order = new Map(
+    alphabet.map((m, i) => [m, i])
+  );
+  return [...markers].sort(
+    (a, b) => (order.get(a) ?? 99) - (order.get(b) ?? 99)
+  );
+}
+var MARKER_LABELS = {
+  raci: { R: "Responsible", A: "Accountable", C: "Consulted", I: "Informed" },
+  rasci: {
+    R: "Responsible",
+    A: "Accountable",
+    S: "Support",
+    C: "Consulted",
+    I: "Informed"
+  },
+  daci: { D: "Driver", A: "Approver", C: "Contributor", I: "Informed" }
+};
+var TITLE_AREA_HEIGHT = 50;
+var H_MARGIN = 24;
+var V_MARGIN = 16;
+var LEGEND_HEIGHT = 28;
+var LEGEND_CHIP_GAP = 8;
+var LEGEND_CHIP_LABEL_MIN = 96;
+var LEGEND_LETTER_CHIP_W = 28;
+var TITLE_LEGEND_GAP = 16;
+var LEGEND_LABEL_FONT = 12;
+var LEGEND_LETTER_FONT = 14;
+var HEADER_HEIGHT = 36;
+var ROW_HEIGHT = 36;
+var PHASE_HEIGHT = 40;
+var TASK_LABEL_MIN = 200;
+var TASK_LABEL_MAX = 360;
+var ROLE_COL_MIN = 64;
+var ROLE_COL_MAX = 120;
+var CELL_PAD = 4;
+var VIOLATION_LINE_HEIGHT = 14;
+var STACK_TOP_GAP = 8;
+var DESC_FONT = 11;
+var COLUMN_RADIUS = 8;
+var COLUMN_INSET = 8;
+var COLUMN_BOTTOM_PAD = 14;
+var MARKER_FONT = 14;
+var MARKER_FONT_WEIGHT = 600;
+var LABEL_FONT = 13;
+var ROLE_HEADER_FONT = 12;
+var PHASE_FONT = 13;
+var TINT_PCT = 25;
+var NODE_RADIUS = 6;
+var AUTO_ACCENTS = [
+  "blue",
+  "orange",
+  "green",
+  "purple",
+  "yellow",
+  "cyan",
+  "red",
+  "teal"
+];
+function autoAccent(index, palette) {
+  return palette.colors[AUTO_ACCENTS[index % AUTO_ACCENTS.length]];
+}
+function markerColor(marker, palette) {
+  switch (marker) {
+    case "R":
+      return palette.colors.green;
+    case "A":
+      return palette.colors.red;
+    case "S":
+      return palette.colors.teal;
+    case "C":
+      return palette.colors.yellow;
+    case "I":
+      return palette.colors.gray;
+    case "D":
+      return palette.colors.purple;
+  }
+}
+function renderRaci(container, parsed, palette, isDark, handlers, exportDims) {
+  const opts = typeof handlers === "function" ? { onClickLine: handlers } : handlers ?? {};
+  const onClickLine = opts.onClickLine;
+  const onMarkerDragStart = opts.onMarkerDragStart;
+  const hideLegend = opts.hideLegend ?? false;
+  const collapsedPhases = opts.collapsedPhases ?? /* @__PURE__ */ new Set();
+  const hideTitle = (opts.hideTitle ?? false) || parsed.options["no-title"] === "on";
+  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 tasksAll = [...allTasks(parsed)];
+  if (tasksAll.length === 0 && parsed.phases.length === 0) return;
+  const solid = parsed.options["solid-fill"] === "on";
+  const surfaceBg = themeBaseBg(palette, isDark);
+  const roleCount = Math.max(1, parsed.roles.length);
+  const idealWidth = roleCount * ROLE_COL_MAX + TASK_LABEL_MAX + 2 * H_MARGIN;
+  const ctx = exportDims ? ScaleContext.identity() : ScaleContext.from(width, idealWidth);
+  const sTitleFontSize = ctx.text(TITLE_FONT_SIZE);
+  const sTitleY = ctx.structural(TITLE_Y);
+  const sHMargin = ctx.aesthetic(H_MARGIN);
+  const sVMargin = ctx.aesthetic(V_MARGIN);
+  const sTitleAreaHeight = ctx.structural(TITLE_AREA_HEIGHT);
+  const sHeaderHeight = ctx.structural(HEADER_HEIGHT);
+  const sRowHeight = ctx.structural(ROW_HEIGHT);
+  const sPhaseHeight = ctx.structural(PHASE_HEIGHT);
+  const sTaskLabelMin = ctx.structural(TASK_LABEL_MIN);
+  const sTaskLabelMax = ctx.structural(TASK_LABEL_MAX);
+  const sRoleColMin = ctx.structural(ROLE_COL_MIN);
+  const sRoleColMax = ctx.structural(ROLE_COL_MAX);
+  const sCellPad = ctx.structural(CELL_PAD);
+  const sLabelFont = ctx.text(LABEL_FONT);
+  const sRoleHeaderFont = ctx.text(ROLE_HEADER_FONT);
+  const sPhaseFont = ctx.text(PHASE_FONT);
+  const sMarkerFont = ctx.text(MARKER_FONT);
+  const sDescFont = ctx.text(DESC_FONT);
+  const sColumnRadius = ctx.structural(COLUMN_RADIUS);
+  const sColumnInset = ctx.structural(COLUMN_INSET);
+  const sColumnBottomPad = ctx.structural(COLUMN_BOTTOM_PAD);
+  const sLegendHeight = ctx.structural(LEGEND_HEIGHT);
+  const sLegendChipGap = ctx.structural(LEGEND_CHIP_GAP);
+  const sLegendChipLabelMin = ctx.structural(LEGEND_CHIP_LABEL_MIN);
+  const sLegendLetterChipW = ctx.structural(LEGEND_LETTER_CHIP_W);
+  const sTitleLegendGap = ctx.aesthetic(TITLE_LEGEND_GAP);
+  const sLegendLabelFont = ctx.text(LEGEND_LABEL_FONT);
+  const sLegendLetterFont = ctx.text(LEGEND_LETTER_FONT);
+  const sViolationLineHeight = ctx.structural(VIOLATION_LINE_HEIGHT);
+  const sStackTopGap = ctx.structural(STACK_TOP_GAP);
+  const sNodeStrokeWidth = ctx.structural(NODE_STROKE_WIDTH);
+  const sNodeRadius = ctx.structural(NODE_RADIUS);
+  const innerWidth = Math.max(0, width - 2 * sHMargin);
+  let roleColW = Math.max(
+    sRoleColMin,
+    Math.min(sRoleColMax, Math.floor((innerWidth - sTaskLabelMin) / roleCount))
+  );
+  let labelW = innerWidth - roleColW * roleCount;
+  if (labelW > sTaskLabelMax) {
+    labelW = sTaskLabelMax;
+    roleColW = Math.max(
+      sRoleColMin,
+      Math.floor((innerWidth - labelW) / roleCount)
+    );
+  }
+  if (labelW < sTaskLabelMin) labelW = sTaskLabelMin;
+  const taskDiagnostics = groupDiagnosticsByTask(parsed);
+  const phasedRows = [];
+  for (const t of parsed.tasksWithoutPhase)
+    phasedRows.push({ kind: "task", task: t });
+  for (const p of parsed.phases) {
+    const collapsed = collapsedPhases.has(p.id);
+    phasedRows.push({ kind: "phase", phase: p, collapsed });
+    if (!collapsed) {
+      for (const t of p.tasks) phasedRows.push({ kind: "task", task: t });
+    }
+  }
+  const hasTopRow = !hideTitle || !hideLegend;
+  const titleArea = hasTopRow ? sTitleAreaHeight : sVMargin;
+  const legendY = (sTitleAreaHeight - sLegendHeight) / 2;
+  const headerY = titleArea + sVMargin;
+  const bodyTop = headerY + sHeaderHeight;
+  let cursorY = bodyTop;
+  const rowYs = [];
+  const labelMaxW = labelW - 16;
+  const taskRowContent = /* @__PURE__ */ new Map();
+  for (const row of phasedRows) {
+    if (row.kind === "task") {
+      const bucket = taskDiagnostics.get(row.task.id);
+      taskRowContent.set(
+        row.task.id,
+        prepareRowContent(
+          row.task,
+          bucket,
+          labelMaxW,
+          sLabelFont,
+          sDescFont,
+          sRowHeight,
+          sStackTopGap,
+          sViolationLineHeight
+        )
+      );
+    }
+  }
+  for (const row of phasedRows) {
+    rowYs.push(cursorY);
+    if (row.kind === "phase") {
+      cursorY += sPhaseHeight;
+    } else {
+      const content = taskRowContent.get(row.task.id);
+      cursorY += content?.rowHeight ?? sRowHeight;
+    }
+  }
+  const colBottomY = cursorY + sColumnBottomPad;
+  const totalHeight = colBottomY + sVMargin;
+  const svgHeight = exportDims ? totalHeight : Math.max(height, totalHeight);
+  const svg = d3Selection.select(container).append("svg").attr("xmlns", "http://www.w3.org/2000/svg").attr("width", width).attr("height", svgHeight).attr("viewBox", `0 0 ${width} ${svgHeight}`).attr("preserveAspectRatio", "xMidYMin meet").attr("font-family", FONT_FAMILY).style("background", "transparent");
+  if (ctx.isBelowFloor) {
+    svg.attr("width", "100%");
+  }
+  const variantLabels = MARKER_LABELS[parsed.variant];
+  const legendMarkers = Object.keys(variantLabels).filter(
+    (m) => variantLabels[m] !== void 0
+  );
+  const numChips = legendMarkers.length;
+  const chipGapTotal = sLegendChipGap * Math.max(0, numChips - 1);
+  const longestLabelPx = legendMarkers.reduce(
+    (n, m) => Math.max(n, measureText(variantLabels[m] ?? "", sLegendLabelFont)),
+    0
+  );
+  const fullChipW = Math.max(
+    sLegendChipLabelMin,
+    Math.ceil(4 + 24 + 8 + longestLabelPx + 8)
+  );
+  const fullLegendW = numChips * fullChipW + chipGapTotal;
+  const letterLegendW = numChips * sLegendLetterChipW + chipGapTotal;
+  const titleEstW = parsed.title && !hideTitle ? measureText(parsed.title, sTitleFontSize) : 0;
+  let legendMode = "full";
+  let legendTotalW = fullLegendW;
+  let legendChipW = fullChipW;
+  if (!hideLegend) {
+    const remaining = innerWidth - titleEstW - sTitleLegendGap;
+    if (remaining < fullLegendW) {
+      legendMode = "letters";
+      legendTotalW = letterLegendW;
+      legendChipW = sLegendLetterChipW;
+    }
+  } else {
+    legendTotalW = 0;
+  }
+  const legendX = sHMargin + innerWidth - legendTotalW;
+  const titleMaxW = hideLegend ? innerWidth : legendX - sHMargin - sTitleLegendGap;
+  if (parsed.title && !hideTitle) {
+    svg.append("text").attr("x", sHMargin).attr("y", sTitleY).attr("text-anchor", "start").attr("font-size", sTitleFontSize).attr("font-weight", TITLE_FONT_WEIGHT).attr("fill", palette.text).text(truncateText(parsed.title, sTitleFontSize, titleMaxW));
+  }
+  if (!hideLegend && numChips > 0) {
+    renderLegend(
+      svg,
+      legendMarkers,
+      parsed.variant,
+      legendX,
+      legendY,
+      legendMode,
+      legendChipW,
+      palette,
+      surfaceBg,
+      solid,
+      onMarkerDragStart,
+      sLegendChipGap,
+      sLegendHeight,
+      sNodeRadius,
+      sNodeStrokeWidth,
+      sLegendLetterFont,
+      sLegendLabelFont
+    );
+  }
+  const roleX = (i) => sHMargin + labelW + i * roleColW;
+  const colTotalHeight = colBottomY - headerY;
+  if (parsed.phases.length === 0) {
+    const bandsG = svg.append("g").attr("class", "raci-row-bands");
+    phasedRows.forEach((row, i) => {
+      if (row.kind !== "task") return;
+      const taskIdx = parsed.tasksWithoutPhase.indexOf(row.task);
+      if (taskIdx < 0) return;
+      const yTop = rowYs[i];
+      const rh = taskRowContent.get(row.task.id)?.rowHeight ?? sRowHeight;
+      bandsG.append("rect").attr("class", "raci-row-band").attr("data-task-id", row.task.id).attr("x", sHMargin).attr("y", yTop + 2).attr("width", innerWidth).attr("height", rh - 4).attr("rx", 6).attr("fill", mix(autoAccent(taskIdx, palette), surfaceBg, 12));
+    });
+  }
+  const columnsG = svg.append("g").attr("class", "raci-columns");
+  parsed.roles.forEach((roleId, i) => {
+    const cx = roleX(i) + sColumnInset;
+    const cw = roleColW - 2 * sColumnInset;
+    const roleColor = parsed.roleColors[i] ?? autoAccent(i, palette);
+    const bodyFill = mix(roleColor, themeBaseBg(palette, isDark), 16);
+    const headerFill = mix(
+      roleColor,
+      themeBaseBg(palette, isDark),
+      30
+    );
+    const colG = columnsG.append("g").attr("class", "raci-column").attr("data-role-id", roleId);
+    colG.append("rect").attr("class", "raci-column-body").attr("x", cx).attr("y", headerY).attr("width", cw).attr("height", colTotalHeight).attr("rx", sColumnRadius).attr("fill", bodyFill);
+    colG.append("path").attr("class", "raci-column-header").attr(
+      "d",
+      topRoundedRectPath(cx, headerY, cw, sHeaderHeight, sColumnRadius)
+    ).attr("fill", headerFill);
+    const cxText = roleX(i) + roleColW / 2;
+    colG.append("text").attr("class", "raci-column-label").attr("x", cxText).attr("y", headerY + sHeaderHeight / 2).attr("text-anchor", "middle").attr("dominant-baseline", "central").attr("font-size", sRoleHeaderFont).attr("font-weight", 600).attr("fill", palette.text).text(
+      truncateText(
+        parsed.roleDisplayNames[i] ?? "",
+        sRoleHeaderFont,
+        roleColW - 2 * sCellPad
+      )
+    );
+  });
+  const hasAnyDiagnostic = taskDiagnostics.size > 0;
+  const SUMMARY_MIN_SLICE_W = 22;
+  const summaryInsetForCheck = sColumnInset + 4;
+  const summaryColBodyWForCheck = roleColW - 2 * summaryInsetForCheck;
+  let chartCanShowSummaries = true;
+  for (const row of phasedRows) {
+    if (row.kind !== "phase" || !row.collapsed) continue;
+    for (const roleId of parsed.roles) {
+      const used = /* @__PURE__ */ new Set();
+      for (const t of row.phase.tasks) {
+        const a = t.roleAssignments.find((r) => r.id === roleId);
+        if (!a) continue;
+        for (const m of a.markers) used.add(m);
+      }
+      if (used.size === 0) continue;
+      const totalGap = SLICE_GAP * Math.max(0, used.size - 1);
+      const sliceW = (summaryColBodyWForCheck - totalGap) / used.size;
+      if (sliceW < SUMMARY_MIN_SLICE_W) {
+        chartCanShowSummaries = false;
+        break;
+      }
+    }
+    if (!chartCanShowSummaries) break;
+  }
+  for (let i = 0; i < phasedRows.length; i++) {
+    const row = phasedRows[i];
+    const y = rowYs[i];
+    if (row.kind === "phase") {
+      const phaseIdx = parsed.phases.indexOf(row.phase);
+      renderPhaseBar(
+        svg,
+        row.phase,
+        sHMargin,
+        y,
+        innerWidth,
+        palette,
+        row.collapsed,
+        autoAccent(Math.max(0, phaseIdx), palette),
+        parsed.roles,
+        roleX,
+        roleColW,
+        parsed.variant,
+        surfaceBg,
+        solid,
+        chartCanShowSummaries,
+        sPhaseHeight,
+        sPhaseFont,
+        sColumnInset,
+        sNodeRadius
+      );
+    } else {
+      renderTaskRow(
+        svg,
+        row.task,
+        parsed,
+        sHMargin,
+        y,
+        labelW,
+        roleX,
+        roleColW,
+        palette,
+        surfaceBg,
+        solid,
+        taskDiagnostics,
+        hasAnyDiagnostic,
+        taskRowContent.get(row.task.id),
+        onClickLine,
+        onMarkerDragStart,
+        sLabelFont,
+        sDescFont,
+        sCellPad,
+        sRowHeight,
+        sColumnInset,
+        sNodeRadius,
+        sNodeStrokeWidth,
+        sMarkerFont,
+        sLegendLabelFont,
+        sStackTopGap,
+        sViolationLineHeight
+      );
+    }
+  }
+  const anyMarker = tasksAll.some(
+    (t) => t.roleAssignments.some((a) => a.markers.length > 0)
+  );
+  if (!anyMarker) {
+    svg.append("text").attr("x", width / 2).attr("y", totalHeight - sVMargin - 2).attr("text-anchor", "middle").attr("font-size", 12).attr("fill", palette.textMuted).text(
+      "Drag a marker from the legend onto any cell. Drag a marker out to remove."
+    );
+  }
+  setupColumnHover(svg);
+}
+function setupColumnHover(svg) {
+  const node = svg.node();
+  if (!node) return;
+  let current = null;
+  const findRole = (target) => {
+    let el = target;
+    while (el && el !== node) {
+      const r = el.getAttribute && el.getAttribute("data-role-id");
+      if (r) return r;
+      el = el.parentElement;
+    }
+    return null;
+  };
+  const set = (role) => {
+    if (role === current) return;
+    if (current) {
+      svg.selectAll(
+        `.raci-cell[data-role-id="${current}"], .raci-column[data-role-id="${current}"]`
+      ).classed("raci-col-active", false);
+    }
+    current = role;
+    if (role) {
+      svg.attr("data-hover-col", role);
+      svg.selectAll(
+        `.raci-cell[data-role-id="${role}"], .raci-column[data-role-id="${role}"]`
+      ).classed("raci-col-active", true);
+    } else {
+      svg.attr("data-hover-col", null);
+    }
+  };
+  svg.on("mouseover", (event) => set(findRole(event.target)));
+  svg.on("mouseleave", () => set(null));
+}
+function renderLegend(svg, markers, variant, x, y, mode, chipW, palette, surfaceBg, solid, _onMarkerDragStart, sLegendChipGap, sLegendHeight, sNodeRadius, sNodeStrokeWidth, sLegendLetterFont, sLegendLabelFont) {
+  if (markers.length === 0) return;
+  const labels = MARKER_LABELS[variant];
+  const legendG = svg.append("g").attr("class", "raci-legend").attr("aria-label", `${variant.toUpperCase()} marker legend`);
+  markers.forEach((marker, i) => {
+    const cx = x + i * (chipW + sLegendChipGap);
+    const rawColor = markerColor(marker, palette);
+    const labelText = labels[marker];
+    const chipG = legendG.append("g").attr("class", "raci-legend-chip").attr("data-marker", marker).style("cursor", "grab");
+    if (mode === "letters") {
+      const fill2 = solid ? rawColor : mix(rawColor, surfaceBg, TINT_PCT);
+      const stroke2 = solid ? mix(rawColor, surfaceBg, 70) : rawColor;
+      chipG.append("rect").attr("x", cx).attr("y", y).attr("width", chipW).attr("height", sLegendHeight).attr("rx", sNodeRadius).attr("fill", fill2).attr("stroke", stroke2).attr("stroke-width", sNodeStrokeWidth);
+      chipG.append("text").attr("x", cx + chipW / 2).attr("y", y + sLegendHeight / 2).attr("text-anchor", "middle").attr("dominant-baseline", "central").attr("font-size", sLegendLetterFont).attr("font-weight", 700).attr(
+        "fill",
+        solid ? contrastText(
+          fill2,
+          palette.textOnFillLight,
+          palette.textOnFillDark
+        ) : palette.text
+      ).text(marker);
+      return;
+    }
+    const fill = solid ? rawColor : mix(rawColor, surfaceBg, TINT_PCT);
+    const stroke = mix(rawColor, surfaceBg, 70);
+    chipG.append("rect").attr("x", cx).attr("y", y).attr("width", chipW).attr("height", sLegendHeight).attr("rx", sNodeRadius).attr("fill", fill).attr("stroke", stroke).attr("stroke-width", sNodeStrokeWidth);
+    const slabPad = 4;
+    const slabW = 24;
+    const slabFill = solid ? mix(rawColor, surfaceBg, 70) : mix(rawColor, surfaceBg, 55);
+    chipG.append("rect").attr("x", cx + slabPad).attr("y", y + slabPad).attr("width", slabW).attr("height", sLegendHeight - 2 * slabPad).attr("rx", 4).attr("fill", slabFill);
+    chipG.append("text").attr("x", cx + slabPad + slabW / 2).attr("y", y + sLegendHeight / 2).attr("text-anchor", "middle").attr("dominant-baseline", "central").attr("font-size", sLegendLetterFont).attr("font-weight", 700).attr(
+      "fill",
+      solid ? contrastText(
+        slabFill,
+        palette.textOnFillLight,
+        palette.textOnFillDark
+      ) : palette.text
+    ).text(marker);
+    chipG.append("text").attr("x", cx + slabPad + slabW + 8).attr("y", y + sLegendHeight / 2).attr("dominant-baseline", "central").attr("font-size", sLegendLabelFont).attr("font-weight", 600).attr("fill", palette.text).text(
+      truncateText(
+        labelText,
+        sLegendLabelFont,
+        chipW - slabW - slabPad * 2 - 12
+      )
+    );
+  });
+}
+function renderRaciForExport(container, parsed, palette, isDark, exportDims) {
+  renderRaci(container, parsed, palette, isDark, {}, exportDims);
+}
+function renderPhaseBar(svg, phase, x, y, width, palette, collapsed, autoColor, roles, roleX, roleColW, variant, surfaceBg, solid, showSummary, sPhaseHeight, sPhaseFont, sColumnInset, sNodeRadius) {
+  const phaseG = svg.append("g").attr("class", "raci-phase").attr("data-section", `phase-${phase.id}`).attr("data-section-toggle", "").attr("data-line-number", String(phase.lineNumber)).attr("data-phase-id", phase.id).attr("data-collapsed", collapsed ? "1" : "0").style("cursor", "pointer");
+  const phaseFill = mix(phase.color ?? autoColor, palette.bg, 30);
+  phaseG.append("rect").attr("x", x).attr("y", y + 4).attr("width", width).attr("height", sPhaseHeight - 8).attr("fill", phaseFill).attr("rx", 4);
+  const chevX = x + 12;
+  const chevY = y + sPhaseHeight / 2;
+  phaseG.append("text").attr("x", chevX).attr("y", chevY).attr("text-anchor", "middle").attr("dominant-baseline", "central").attr("font-family", FONT_FAMILY).attr("font-size", 9).attr("fill", palette.text).attr("opacity", 0.6).text(collapsed ? "\u25B6" : "\u25BC");
+  phaseG.append("text").attr("x", x + 26).attr("y", y + (sPhaseHeight - 4) / 2 + 2).attr("dominant-baseline", "central").attr("font-size", sPhaseFont).attr("font-weight", 600).attr("fill", palette.text).text(phase.displayName);
+  if (collapsed) {
+    const taskCount = phase.tasks.length;
+    if (taskCount > 0) {
+      const labelTextWidth = measureText(phase.displayName, sPhaseFont);
+      phaseG.append("text").attr("x", x + 26 + labelTextWidth + 10).attr("y", y + (sPhaseHeight - 4) / 2 + 2).attr("dominant-baseline", "central").attr("font-size", sPhaseFont - 1).attr("font-weight", 500).attr("fill", palette.textMuted).text(`${taskCount} ${taskCount === 1 ? "task" : "tasks"}`);
+    }
+    if (!showSummary) return;
+    const alphabet = VARIANTS[variant].alphabet;
+    const summaryInset = sColumnInset + 4;
+    const summaryColBodyW = roleColW - 2 * summaryInset;
+    const SUMMARY_CHIP_H = 24;
+    const SUMMARY_LETTER_FONT = 13;
+    const summaryY = y + (sPhaseHeight - SUMMARY_CHIP_H) / 2;
+    roles.forEach((roleId, colIdx) => {
+      const used = /* @__PURE__ */ new Set();
+      for (const t of phase.tasks) {
+        const a = t.roleAssignments.find((r) => r.id === roleId);
+        if (!a) continue;
+        for (const m of a.markers) used.add(m);
+      }
+      if (used.size === 0) return;
+      const ordered = sortByAlphabet([...used], alphabet);
+      const totalGap = SLICE_GAP * Math.max(0, ordered.length - 1);
+      const sliceW = (summaryColBodyW - totalGap) / ordered.length;
+      const startX = roleX(colIdx) + summaryInset;
+      ordered.forEach((marker, i) => {
+        const cx = startX + i * (sliceW + SLICE_GAP);
+        const rawColor = markerColor(marker, palette);
+        const fill = solid ? rawColor : mix(rawColor, surfaceBg, TINT_PCT);
+        const stroke = solid ? mix(rawColor, surfaceBg, 70) : rawColor;
+        const chipG = phaseG.append("g").attr("class", "raci-phase-summary");
+        chipG.append("rect").attr("x", cx).attr("y", summaryY).attr("width", sliceW).attr("height", SUMMARY_CHIP_H).attr("rx", sNodeRadius).attr("fill", fill).attr("stroke", stroke).attr("stroke-width", 1.25);
+        chipG.append("text").attr("x", cx + sliceW / 2).attr("y", summaryY + SUMMARY_CHIP_H / 2).attr("text-anchor", "middle").attr("dominant-baseline", "central").attr("font-size", SUMMARY_LETTER_FONT).attr("font-weight", 700).attr(
+          "fill",
+          solid ? contrastText(
+            fill,
+            palette.textOnFillLight,
+            palette.textOnFillDark
+          ) : palette.text
+        ).text(marker);
+      });
+    });
+  }
+}
+var SLICE_GAP = 4;
+function renderTaskRow(svg, task, parsed, x, y, labelW, roleX, roleColW, palette, surfaceBg, solid, taskDiagnostics, _hasAnyDiagnostic, rowContent, onClickLine, _onMarkerDragStart, sLabelFont, sDescFont, sCellPad, sRowHeight, sColumnInset, sNodeRadius, sNodeStrokeWidth, sMarkerFont, sLegendLabelFont, sStackTopGap, sViolationLineHeight) {
+  const rowG = svg.append("g").attr("class", "raci-task-row").attr("data-task-id", task.id).attr("data-line-number", String(task.lineNumber));
+  const labelX = x + 8;
+  const labelMaxW = labelW - 16;
+  const content = rowContent ?? prepareRowContent(
+    task,
+    taskDiagnostics?.get(task.id),
+    labelMaxW,
+    sLabelFont,
+    sDescFont,
+    sRowHeight,
+    sStackTopGap,
+    sViolationLineHeight
+  );
+  const { nameLines, descLines, violations, rowHeight } = content;
+  const labelG = rowG.append("g").attr("class", "raci-task-label-area");
+  labelG.append("rect").attr("class", "raci-task-label-zone").attr("x", x).attr("y", y).attr("width", labelW).attr("height", rowHeight).attr("fill", "transparent").attr("pointer-events", "all");
+  const nameTopY = y + sLabelFont / 2 + 6;
+  const nameEl = labelG.append("text").attr("class", "raci-task-label").attr("x", labelX).attr("y", nameTopY).attr("dominant-baseline", "central").attr("font-size", sLabelFont).attr("fill", palette.text);
+  nameLines.forEach((line, i) => {
+    const tspan = nameEl.append("tspan").attr("x", labelX).text(line);
+    if (i > 0) tspan.attr("dy", NAME_LINE_HEIGHT);
+  });
+  let stackY = nameTopY + Math.max(0, nameLines.length - 1) * NAME_LINE_HEIGHT + sLabelFont / 2 + 4 + sStackTopGap;
+  if (descLines.length > 0) {
+    const descEl = labelG.append("text").attr("class", "raci-task-description").attr("x", labelX).attr("y", stackY).attr("dominant-baseline", "central").attr("font-size", sDescFont).attr("fill", palette.textMuted);
+    descLines.forEach((line, i) => {
+      const tspan = descEl.append("tspan").attr("x", labelX).text(line);
+      if (i > 0) tspan.attr("dy", DESC_LINE_HEIGHT);
+    });
+    stackY += descLines.length * DESC_LINE_HEIGHT;
+  }
+  for (const v of violations) {
+    const lineColor = v.severity === "error" ? palette.colors.red : palette.colors.orange;
+    const lineG = labelG.append("g").attr("class", "raci-violation-line").attr("data-severity", v.severity).style("cursor", onClickLine ? "pointer" : "default");
+    const violationFont = sLabelFont - 2;
+    const textEl = lineG.append("text").attr("x", labelX).attr("y", stackY).attr("dominant-baseline", "central").attr("font-size", violationFont).attr("fill", lineColor);
+    v.lines.forEach((line, i) => {
+      const segs = parseQuotedSegments(line);
+      segs.forEach((seg, segIdx) => {
+        const tspan = textEl.append("tspan").text(seg.text);
+        if (i > 0 && segIdx === 0)
+          tspan.attr("x", labelX).attr("dy", sViolationLineHeight);
+        if (seg.bold) tspan.attr("font-weight", 700);
+      });
+    });
+    if (onClickLine) {
+      const targetLine = v.sourceLine;
+      lineG.on("click", (e) => {
+        e.stopPropagation();
+        onClickLine(targetLine);
+      });
+    }
+    stackY += v.lines.length * sViolationLineHeight;
+  }
+  const cellByRole = /* @__PURE__ */ new Map();
+  for (const a of task.roleAssignments) {
+    cellByRole.set(a.id, a.markers);
+  }
+  const alphabet = VARIANTS[parsed.variant].alphabet;
+  parsed.roles.forEach((roleId, idx) => {
+    const cellInset = sColumnInset + 4;
+    const cx = roleX(idx) + cellInset;
+    const cy = y + sCellPad;
+    const cw = roleColW - 2 * cellInset;
+    const ch = sRowHeight - 2 * sCellPad;
+    const markersSource = cellByRole.get(roleId) ?? [];
+    const markers = sortByAlphabet(markersSource, alphabet);
+    const assignment = task.roleAssignments.find((a) => a.id === roleId);
+    const cellG = rowG.append("g").attr("class", "raci-cell").attr("data-task-id", task.id).attr("data-role-id", roleId);
+    if (assignment) {
+      cellG.attr("data-line-number", String(assignment.lineNumber));
+    }
+    cellG.append("rect").attr("class", "raci-cell-hit").attr("x", roleX(idx) + sColumnInset).attr("y", y).attr("width", roleColW - 2 * sColumnInset).attr("height", sRowHeight).attr("fill", "transparent").attr("pointer-events", "all");
+    const totalGap = SLICE_GAP * (markers.length - 1);
+    const sliceW = markers.length > 0 ? (cw - totalGap) / markers.length : 0;
+    const variantLabels = MARKER_LABELS[parsed.variant];
+    markers.forEach((m, i) => {
+      const rawColor = markerColor(m, palette);
+      const fill = solid ? rawColor : mix(rawColor, surfaceBg, TINT_PCT);
+      const stroke = rawColor;
+      const sliceX = cx + i * (sliceW + SLICE_GAP);
+      const sliceG = cellG.append("g").attr("class", "raci-marker-slice").attr("data-marker", m).style("cursor", "grab");
+      sliceG.append("rect").attr("x", sliceX).attr("y", cy).attr("width", sliceW).attr("height", ch).attr("rx", sNodeRadius).attr("fill", fill).attr("stroke", stroke).attr("stroke-width", sNodeStrokeWidth);
+      const fullLabel = variantLabels[m] ?? m;
+      const labelPx = measureText(fullLabel, sLegendLabelFont);
+      const showFullLabel = labelPx + 16 <= sliceW;
+      const textContent = showFullLabel ? fullLabel : m;
+      const textFont = showFullLabel ? sLegendLabelFont : sMarkerFont;
+      sliceG.append("text").attr("x", sliceX + sliceW / 2).attr("y", cy + ch / 2).attr("text-anchor", "middle").attr("dominant-baseline", "central").attr("font-size", textFont).attr("font-weight", MARKER_FONT_WEIGHT).attr(
+        "fill",
+        solid ? contrastText(
+          fill,
+          palette.textOnFillLight,
+          palette.textOnFillDark
+        ) : palette.text
+      ).text(textContent);
+    });
+    cellG.append("rect").attr("class", "raci-cell-drop-preview").attr("x", cx).attr("y", cy).attr("width", cw).attr("height", ch).attr("rx", sNodeRadius).attr("fill", "transparent").attr("stroke", "transparent").attr("pointer-events", "none");
+    if (onClickLine && assignment) {
+      cellG.on("click", () => onClickLine(assignment.lineNumber));
+    }
+  });
+}
+var NAME_LINE_HEIGHT = 16;
+var DESC_LINE_HEIGHT = 16;
+function prepareRowContent(task, bucket, labelMaxW, sLabelFont = LABEL_FONT, sDescFont = DESC_FONT, sRowHeight = ROW_HEIGHT, sStackTopGap = STACK_TOP_GAP, sViolationLineHeight = VIOLATION_LINE_HEIGHT) {
+  const nameLines = wrapTextToWidth(task.displayName, sLabelFont, labelMaxW, {
+    hardBreak: true
+  });
+  const description = task.description?.trim() ?? "";
+  const descLines = description.length > 0 ? description.split("\n").flatMap(
+    (line) => wrapTextToWidth(line, sDescFont, labelMaxW, { hardBreak: true })
+  ) : [];
+  const violations = [];
+  if (bucket) {
+    const collect = (arr, severity) => {
+      for (const e of arr) {
+        const text = trimTaskPrefix(e.message);
+        violations.push({
+          severity,
+          sourceLine: e.line,
+          text,
+          lines: wrapTextToWidth(text, sLabelFont - 2, labelMaxW, {
+            hardBreak: true
+          })
+        });
+      }
+    };
+    collect(bucket.errors, "error");
+    collect(bucket.warnings, "warning");
+  }
+  const totalViolationLines = violations.reduce(
+    (n, v) => n + v.lines.length,
+    0
+  );
+  const hasStacked = descLines.length > 0 || violations.length > 0;
+  const labelExtra = Math.max(0, nameLines.length - 1) * NAME_LINE_HEIGHT;
+  const rowHeight = sRowHeight + labelExtra + (hasStacked ? sStackTopGap : 0) + descLines.length * DESC_LINE_HEIGHT + totalViolationLines * sViolationLineHeight;
+  return { nameLines, descLines, violations, rowHeight };
+}
+function parseQuotedSegments(message) {
+  const out = [];
+  const re = /'([^']+)'/g;
+  let last = 0;
+  let m;
+  while ((m = re.exec(message)) !== null) {
+    if (m.index > last)
+      out.push({ text: message.slice(last, m.index), bold: false });
+    out.push({ text: m[1], bold: true });
+    last = m.index + m[0].length;
+  }
+  if (last < message.length)
+    out.push({ text: message.slice(last), bold: false });
+  return out;
+}
+
+export {
+  MARKER_LABELS,
+  renderRaci,
+  renderRaciForExport
+};
+//# sourceMappingURL=chunk-DZAQBW35.js.map