@diagrammo/dgmo 0.52.0 → 0.53.0

package/dist/{chunk-H7KENAZO.js → chunk-AHXIMHDQ.js}

@@ -4,7 +4,7 @@ import {
 } from "./chunk-PDKUANDZ.js";
 import {
   layoutGraph
-} from "./chunk-HFMYN6N2.js";
+} from "./chunk-3B2GXZCX.js";
 import {
   appendArrowheadMarkers
 } from "./chunk-LP7EC4MI.js";
@@ -14,7 +14,7 @@ import {
   renderNoteBadge,
   renderNoteBox,
   renderNoteConnector
-} from "./chunk-J7TLCB2Q.js";
+} from "./chunk-3IUHKMJI.js";
 import {
   EDGE_STROKE_WIDTH,
   NODE_STROKE_WIDTH
@@ -22,6 +22,12 @@ import {
 import {
   ScaleContext
 } from "./chunk-YYVTBZZC.js";
+import {
+  renderIntegratedLegend
+} from "./chunk-W5KMNC5U.js";
+import {
+  getMaxLegendReservedHeight
+} from "./chunk-774C2FF3.js";
 import {
   TITLE_FONT_SIZE,
   TITLE_FONT_WEIGHT,
@@ -31,20 +37,26 @@ import {
   FONT_FAMILY
 } from "./chunk-6KFWC4CO.js";
 import {
-  measureText
-} from "./chunk-WCT3NYCV.js";
+  parseState
+} from "./chunk-AN2DQB3G.js";
 import {
   contrastText,
   mix,
   shapeFill,
   themeBaseBg
-} from "./chunk-WBM7ZNDI.js";
+} from "./chunk-JYDMBWRP.js";
 import {
-  parseState
-} from "./chunk-ROOE4R4Y.js";
+  measureText
+} from "./chunk-4ASYQ347.js";
 import {
-  fillModeFromOptions
-} from "./chunk-BRENJ2BQ.js";
+  resolveActiveTagGroup,
+  resolveTagColor,
+  tagAttrKey
+} from "./chunk-CMVZWP32.js";
+import {
+  fillModeFromOptions,
+  legendSuppressed
+} from "./chunk-YJVA3QUU.js";
 
 // src/graph/state-renderer.ts
 import * as d3Selection from "d3-selection";
@@ -100,6 +112,23 @@ function renderState(container, graph, layout, palette, isDark, onClickItem, exp
   const sGroupExtraPadding = ctx.aesthetic(GROUP_EXTRA_PADDING);
   const showTitle = !!graph.title && graph.options["no-title"] !== "on";
   const titleHeight = showTitle ? 40 : 0;
+  const tagGroups = graph.tagGroups ?? [];
+  const activeTagGroup = resolveActiveTagGroup(
+    tagGroups,
+    graph.options["active-tag"]
+  );
+  const legendGroups = tagGroups;
+  const hasLegend = legendGroups.length > 0 && !legendSuppressed(graph.options);
+  const legendH = hasLegend ? ctx.structural(
+    getMaxLegendReservedHeight(
+      {
+        groups: legendGroups,
+        position: { placement: "top-center", titleRelation: "below-title" },
+        mode: exportDims ? "export" : "preview"
+      },
+      width
+    )
+  ) + 8 : 0;
   const diagramW = layout.width;
   const diagramH = layout.height;
   const { scale, offsetX, offsetY, canvasHeight } = fitDiagramToCanvas({
@@ -108,7 +137,9 @@ function renderState(container, graph, layout, palette, isDark, onClickItem, exp
     diagramW,
     diagramH,
     padding: sDiagramPadding,
-    titleHeight,
+    // The legend band sits directly under the title, so it reserves the same
+    // top strip fitDiagramToCanvas already offsets the diagram by.
+    titleHeight: titleHeight + legendH,
     maxScale: MAX_SCALE,
     exportMode: !!exportDims
   });
@@ -141,6 +172,21 @@ function renderState(container, graph, layout, palette, isDark, onClickItem, exp
       }
     }
   }
+  if (hasLegend) {
+    const legendG = svg.append("g").attr("transform", `translate(0, ${titleHeight + 4})`);
+    renderIntegratedLegend(legendG, {
+      groups: legendGroups,
+      activeGroup: activeTagGroup,
+      mode: exportDims ? "export" : "preview",
+      // Inactive sibling groups stay visible as collapsed pills so the user
+      // can click one to flip the active colouring dimension (as in b&l).
+      showInactivePills: true,
+      palette,
+      isDark,
+      width
+    });
+    legendG.selectAll("[data-legend-group]").classed("st-legend-group", true);
+  }
   const contentG = svg.append("g").attr("transform", `translate(${offsetX}, ${offsetY}) scale(${scale})`);
   for (const group of layout.groups) {
     if (group.collapsed) continue;
@@ -246,9 +292,22 @@ function renderState(container, graph, layout, palette, isDark, onClickItem, exp
   const colorOff = graph.options?.["color"] === "off";
   const fillMode = fillModeFromOptions(graph.options ?? {});
   const noNotes = graph.options?.["no-notes"] === "on";
+  const mutableTagGroups = [...tagGroups];
+  const nodeIntentColor = (node) => node.color ?? (activeTagGroup ? resolveTagColor(
+    node.metadata ?? {},
+    mutableTagGroups,
+    activeTagGroup
+  ) : void 0);
   for (const node of layout.nodes) {
     const isCollapsedGroup = collapsedGroupIds.has(node.id);
     const nodeG = contentG.append("g").attr("transform", `translate(${node.x}, ${node.y})`).attr("class", isCollapsedGroup ? "st-group-wrapper st-node" : "st-node").attr("data-line-number", String(node.lineNumber)).attr("data-node-id", node.id).style("cursor", "pointer");
+    if (activeTagGroup && node.shape !== "pseudostate") {
+      const tagKey = tagAttrKey(activeTagGroup);
+      const metaValue = node.metadata?.[tagKey];
+      if (metaValue) {
+        nodeG.attr(`data-tag-${tagKey}`, metaValue.toLowerCase());
+      }
+    }
     if (isCollapsedGroup) {
       nodeG.attr("data-group-toggle", node.id).attr("tabindex", "0").attr("role", "button").attr("aria-expanded", "false").attr("aria-label", `Expand group ${node.label}`);
     }
@@ -263,7 +322,7 @@ function renderState(container, graph, layout, palette, isDark, onClickItem, exp
     } else if (isCollapsedGroup) {
       const w = node.width;
       const h = node.height;
-      const groupColor = node.color ?? stateDefaultColor(palette, colorOff);
+      const groupColor = nodeIntentColor(node) ?? stateDefaultColor(palette, colorOff);
       const fillColor = shapeFill(palette, groupColor, isDark, {
         mode: fillMode
       });
@@ -284,14 +343,15 @@ function renderState(container, graph, layout, palette, isDark, onClickItem, exp
     } else {
       const w = node.width;
       const h = node.height;
+      const intentColor = nodeIntentColor(node);
       const resolvedFill = stateFill(
         palette,
         isDark,
-        node.color,
+        intentColor,
         colorOff,
         fillMode
       );
-      nodeG.append("rect").attr("x", -w / 2).attr("y", -h / 2).attr("width", w).attr("height", h).attr("rx", sStateCornerRadius).attr("ry", sStateCornerRadius).attr("fill", resolvedFill).attr("stroke", stateStroke(palette, node.color, colorOff)).attr("stroke-width", sNodeStrokeWidth);
+      nodeG.append("rect").attr("x", -w / 2).attr("y", -h / 2).attr("width", w).attr("height", h).attr("rx", sStateCornerRadius).attr("ry", sStateCornerRadius).attr("fill", resolvedFill).attr("stroke", stateStroke(palette, intentColor, colorOff)).attr("stroke-width", sNodeStrokeWidth);
       nodeG.append("text").attr("x", 0).attr("y", 0).attr("text-anchor", "middle").attr("dominant-baseline", "central").attr(
         "fill",
         contrastText(
@@ -379,4 +439,4 @@ export {
   renderState,
   renderStateForExport
 };
-//# sourceMappingURL=chunk-H7KENAZO.js.map
+//# sourceMappingURL=chunk-AHXIMHDQ.js.map

package/dist/chunk-AIMLCDAO.js

@@ -0,0 +1,404 @@
+import {
+  formatLocalISODate
+} from "./chunk-3TYUXC7D.js";
+import {
+  isTagBlockHeading,
+  matchTagBlockHeading
+} from "./chunk-CMVZWP32.js";
+import {
+  makeDgmoError
+} from "./chunk-4W2PE66Q.js";
+
+// src/pert/share-normalize.ts
+var START_DATE_NOW_RE = /^(\s*start-date\s+)now(\s*)$/i;
+function splitTrailingComment(line) {
+  const m = line.match(/^(.*?)(\s+#.*)$/);
+  if (!m) return { code: line, comment: "" };
+  return { code: m[1], comment: m[2] };
+}
+function normalizePertSourceForShare(dsl) {
+  const today = formatLocalISODate(/* @__PURE__ */ new Date());
+  const lines = dsl.split("\n");
+  const out = [];
+  for (const line of lines) {
+    const { code, comment } = splitTrailingComment(line);
+    const m = code.match(START_DATE_NOW_RE);
+    if (m) {
+      out.push(`${m[1]}${today}${m[2]}${comment}`);
+    } else {
+      out.push(line);
+    }
+  }
+  return out.join("\n");
+}
+
+// src/org/resolver.ts
+var MAX_DEPTH = 10;
+var IMPORT_RE = /^(\s+)import:?\s+(.+\.dgmo)\s*$/i;
+var TAGS_RE = /^tags:?\s+(.+\.dgmo)\s*$/i;
+var HEADER_RE = /^(org|kanban|title\s*:)/i;
+var KNOWN_HEADER_OPTIONS = /* @__PURE__ */ new Set([
+  "direction-tb",
+  "direction-lr",
+  "sub-node-label",
+  "hide",
+  "show-sub-node-count",
+  "color-off",
+  "fill-tint",
+  "fill-solid",
+  "fill-outline",
+  "active-tag"
+]);
+function dirname(filePath) {
+  const last = filePath.lastIndexOf("/");
+  return last > 0 ? filePath.substring(0, last) : "/";
+}
+function resolvePath(base, relative) {
+  const parts = dirname(base).split("/");
+  for (const seg of relative.split("/")) {
+    if (seg === "..") {
+      if (parts.length > 1) parts.pop();
+    } else if (seg !== "." && seg !== "") {
+      parts.push(seg);
+    }
+  }
+  return parts.join("/") || "/";
+}
+function extractTagGroups(lines) {
+  const blocks = [];
+  let current = null;
+  for (const line of lines) {
+    const trimmed = line.trim();
+    const headingMatch = matchTagBlockHeading(trimmed);
+    if (headingMatch) {
+      const name = headingMatch.name.toLowerCase();
+      current = { name, lines: [line] };
+      blocks.push(current);
+    } else if (current) {
+      if (trimmed === "" || trimmed.startsWith("//")) {
+        current = null;
+      } else if (line.match(/^\s+/)) {
+        current.lines.push(line);
+      } else {
+        current = null;
+      }
+    }
+  }
+  return blocks;
+}
+function parseFileHeader(lines) {
+  const tagGroups = extractTagGroups(lines);
+  const tagGroupLineSet = /* @__PURE__ */ new Set();
+  for (const group of tagGroups) {
+    for (let i = 0; i < lines.length; i++) {
+      if (lines[i] === group.lines[0]) {
+        for (let j = 0; j < group.lines.length; j++) {
+          tagGroupLineSet.add(i + j);
+        }
+        break;
+      }
+    }
+  }
+  let tagsDirective = null;
+  const contentLines = [];
+  const contentLineIndices = [];
+  let headerDone = false;
+  for (let i = 0; i < lines.length; i++) {
+    if (tagGroupLineSet.has(i)) continue;
+    const rawLine = lines[i];
+    const trimmed = rawLine.trim();
+    if (!headerDone && (trimmed === "" || trimmed.startsWith("//"))) continue;
+    if (!headerDone) {
+      if (HEADER_RE.test(trimmed)) continue;
+      const tagsMatch = trimmed.match(TAGS_RE);
+      if (tagsMatch) {
+        tagsDirective = tagsMatch[1].trim();
+        continue;
+      }
+      if (!rawLine.match(/^\s/) && !isTagBlockHeading(trimmed) && !trimmed.includes("|")) {
+        const firstToken = trimmed.split(/\s/)[0].toLowerCase();
+        if (KNOWN_HEADER_OPTIONS.has(firstToken)) {
+          continue;
+        }
+      }
+      headerDone = true;
+    }
+    contentLines.push(rawLine);
+    contentLineIndices.push(i);
+  }
+  return { contentLines, contentLineIndices, tagGroups, tagsDirective };
+}
+async function resolveOrgImports(content, filePath, readFileFn) {
+  const diagnostics = [];
+  const result = await resolveFile(
+    content,
+    filePath,
+    readFileFn,
+    diagnostics,
+    /* @__PURE__ */ new Set([filePath]),
+    0
+  );
+  return {
+    content: result.content,
+    diagnostics,
+    lineMap: result.lineMap,
+    importSourceMap: result.importSourceMap
+  };
+}
+async function resolveFile(content, filePath, readFileFn, diagnostics, ancestorChain, depth) {
+  const lines = content.split("\n");
+  const headerLines = [];
+  let tagsDirective = null;
+  const inlineTagGroups = extractTagGroups(lines);
+  const bodyStartIndex = findBodyStart(lines);
+  let tagsLineNumber = 0;
+  for (let i = 0; i < bodyStartIndex; i++) {
+    const rawLine = lines[i];
+    const trimmed = rawLine.trim();
+    if (trimmed === "" || trimmed.startsWith("//")) {
+      headerLines.push({ text: rawLine, originalLine: i + 1 });
+      continue;
+    }
+    if (isTagBlockHeading(trimmed)) continue;
+    if (/^\s/.test(rawLine)) continue;
+    const tagsMatch = trimmed.match(TAGS_RE);
+    if (tagsMatch) {
+      tagsDirective = tagsMatch[1].trim();
+      tagsLineNumber = i + 1;
+      continue;
+    }
+    headerLines.push({ text: rawLine, originalLine: i + 1 });
+  }
+  let tagsFileGroups = [];
+  if (tagsDirective) {
+    const tagsPath = resolvePath(filePath, tagsDirective);
+    try {
+      const tagsContent = await readFileFn(tagsPath);
+      const tagsLines = tagsContent.split("\n");
+      tagsFileGroups = extractTagGroups(tagsLines);
+    } catch {
+      diagnostics.push(
+        makeDgmoError(tagsLineNumber, `Tags file not found: ${tagsDirective}`)
+      );
+    }
+  }
+  const bodyLines = lines.slice(bodyStartIndex);
+  const resolvedBodyLines = [];
+  const importedTagGroups = [];
+  for (let i = 0; i < bodyLines.length; i++) {
+    const line = bodyLines[i];
+    const lineNumber = bodyStartIndex + i + 1;
+    const importMatch = line.match(IMPORT_RE);
+    if (!importMatch) {
+      const trimmed = line.trim();
+      if (isTagBlockHeading(trimmed) || inlineTagGroups.length > 0 && isTagGroupEntry(line, bodyLines, i)) {
+        continue;
+      }
+      resolvedBodyLines.push({
+        text: line,
+        originalLine: lineNumber,
+        importSource: null
+      });
+      continue;
+    }
+    const indent = importMatch[1];
+    const importRelPath = importMatch[2].trim();
+    const importAbsPath = resolvePath(filePath, importRelPath);
+    if (depth >= MAX_DEPTH) {
+      diagnostics.push(
+        makeDgmoError(
+          lineNumber,
+          `Import depth limit exceeded (${MAX_DEPTH}): ${importRelPath}`
+        )
+      );
+      continue;
+    }
+    if (ancestorChain.has(importAbsPath)) {
+      const chain = [...ancestorChain, importAbsPath].map((p) => p.split("/").pop()).join(" -> ");
+      diagnostics.push(
+        makeDgmoError(lineNumber, `Circular import detected: ${chain}`)
+      );
+      continue;
+    }
+    let importedContent;
+    try {
+      importedContent = await readFileFn(importAbsPath);
+    } catch {
+      diagnostics.push(
+        makeDgmoError(lineNumber, `Import file not found: ${importRelPath}`)
+      );
+      continue;
+    }
+    const nestedChain = new Set(ancestorChain);
+    nestedChain.add(importAbsPath);
+    const resolved = await resolveFile(
+      importedContent,
+      importAbsPath,
+      readFileFn,
+      diagnostics,
+      nestedChain,
+      depth + 1
+    );
+    const resolvedLines = resolved.content.split("\n");
+    const parsed = parseFileHeader(resolvedLines);
+    for (const group of parsed.tagGroups) {
+      importedTagGroups.push(group);
+    }
+    const importedContentLines = [];
+    for (let j = 0; j < parsed.contentLines.length; j++) {
+      const cText = parsed.contentLines[j];
+      const cIndex = parsed.contentLineIndices[j];
+      if (cText.trim() !== "") {
+        importedContentLines.push({
+          text: cText,
+          index: cIndex
+        });
+      }
+    }
+    let lastNonEmpty = importedContentLines.length - 1;
+    while (lastNonEmpty >= 0 && importedContentLines[lastNonEmpty].text.trim() === "") {
+      lastNonEmpty--;
+    }
+    const trimmedImported = importedContentLines.slice(0, lastNonEmpty + 1);
+    for (const entry of trimmedImported) {
+      const resolvedLineNum = entry.index + 1;
+      let importSource = null;
+      if (resolved.importSourceMap[resolvedLineNum]) {
+        importSource = resolved.importSourceMap[resolvedLineNum];
+      } else {
+        const origLine = resolved.lineMap[resolvedLineNum];
+        if (origLine != null) {
+          importSource = { filePath: importAbsPath, sourceLine: origLine };
+        }
+      }
+      if (entry.text.trim() === "") {
+        resolvedBodyLines.push({
+          text: "",
+          originalLine: lineNumber,
+          importSource
+        });
+      } else {
+        resolvedBodyLines.push({
+          text: indent + entry.text,
+          originalLine: lineNumber,
+          importSource
+        });
+      }
+    }
+  }
+  const mergedGroups = mergeTagGroups(
+    inlineTagGroups,
+    tagsFileGroups,
+    importedTagGroups
+  );
+  const outputLines = [];
+  const lineMap = [null];
+  const importSourceMap = [null];
+  for (const entry of headerLines) {
+    outputLines.push(entry.text);
+    lineMap.push(entry.originalLine);
+    importSourceMap.push(null);
+  }
+  if (mergedGroups.length > 0) {
+    if (outputLines.length > 0 && // In-bounds by length guard.
+    outputLines[outputLines.length - 1].trim() !== "") {
+      outputLines.push("");
+      lineMap.push(null);
+      importSourceMap.push(null);
+    }
+    for (const group of mergedGroups) {
+      const inlineMatch = inlineTagGroups.find((g) => g.name === group.name);
+      for (const line of group.lines) {
+        outputLines.push(line);
+        if (inlineMatch) {
+          const srcIdx = lines.indexOf(line);
+          lineMap.push(srcIdx >= 0 ? srcIdx + 1 : null);
+        } else {
+          lineMap.push(null);
+        }
+        importSourceMap.push(null);
+      }
+      outputLines.push("");
+      lineMap.push(null);
+      importSourceMap.push(null);
+    }
+  }
+  if (resolvedBodyLines.length > 0 && outputLines.length > 0 && // In-bounds by length guard.
+  outputLines[outputLines.length - 1].trim() !== "") {
+    outputLines.push("");
+    lineMap.push(null);
+    importSourceMap.push(null);
+  }
+  for (const entry of resolvedBodyLines) {
+    outputLines.push(entry.text);
+    lineMap.push(entry.originalLine);
+    importSourceMap.push(entry.importSource);
+  }
+  return { content: outputLines.join("\n"), lineMap, importSourceMap };
+}
+function findBodyStart(lines) {
+  let inTagGroup = false;
+  for (let i = 0; i < lines.length; i++) {
+    const rawLine = lines[i];
+    const trimmed = rawLine.trim();
+    if (trimmed === "" || trimmed.startsWith("//")) {
+      if (inTagGroup) inTagGroup = false;
+      continue;
+    }
+    if (isTagBlockHeading(trimmed)) {
+      inTagGroup = true;
+      continue;
+    }
+    if (inTagGroup && rawLine.match(/^\s+/)) {
+      continue;
+    }
+    if (inTagGroup) {
+      inTagGroup = false;
+    }
+    if (HEADER_RE.test(trimmed)) continue;
+    if (TAGS_RE.test(trimmed)) continue;
+    if (!rawLine.match(/^\s/) && !trimmed.includes("|") && !isTagBlockHeading(trimmed)) {
+      const firstToken = trimmed.split(/\s/)[0].toLowerCase();
+      if (KNOWN_HEADER_OPTIONS.has(firstToken)) {
+        continue;
+      }
+    }
+    return i;
+  }
+  return lines.length;
+}
+function isTagGroupEntry(line, allLines, index) {
+  if (!line.match(/^\s+/)) return false;
+  for (let i = index - 1; i >= 0; i--) {
+    const prevRaw = allLines[i];
+    const prev = prevRaw.trim();
+    if (prev === "" || prev.startsWith("//")) continue;
+    if (isTagBlockHeading(prev)) return true;
+    if (prevRaw.match(/^\s+/)) continue;
+    return false;
+  }
+  return false;
+}
+function mergeTagGroups(inline, tagsFile, imported) {
+  const seen = /* @__PURE__ */ new Map();
+  for (const group of inline) {
+    seen.set(group.name, group);
+  }
+  for (const group of tagsFile) {
+    if (!seen.has(group.name)) {
+      seen.set(group.name, group);
+    }
+  }
+  for (const group of imported) {
+    if (!seen.has(group.name)) {
+      seen.set(group.name, group);
+    }
+  }
+  return Array.from(seen.values());
+}
+
+export {
+  normalizePertSourceForShare,
+  resolveOrgImports
+};
+//# sourceMappingURL=chunk-AIMLCDAO.js.map

package/dist/{chunk-4IHAV6O7.js → chunk-ALYZ3MAA.js}

@@ -10,10 +10,10 @@ import {
   splitNameAndMeta,
   tryParseSharedOption,
   warnUnknownMetaKeys
-} from "./chunk-BRENJ2BQ.js";
+} from "./chunk-YJVA3QUU.js";
 import {
   resolveColorWithDiagnostic
-} from "./chunk-TLVIHFRO.js";
+} from "./chunk-ZKPPI6BF.js";
 import {
   NAME_DIAGNOSTIC_CODES,
   emit,
@@ -21,7 +21,7 @@ import {
   makeFail,
   nameMergedMessage,
   suggest
-} from "./chunk-CXK4DZH3.js";
+} from "./chunk-4W2PE66Q.js";
 
 // src/raci/diagnostics.ts
 var RACI_DX = {
@@ -952,4 +952,4 @@ export {
   parseRaci,
   allTasks
 };
-//# sourceMappingURL=chunk-4IHAV6O7.js.map
+//# sourceMappingURL=chunk-ALYZ3MAA.js.map