@diagrammo/dgmo 0.96.0 → 0.97.0

package/dist/chunk-QLNLRZ37.js

@@ -0,0 +1,181 @@
+import {
+  parseMindmap
+} from "./chunk-KTGJQJB3.js";
+import {
+  parseDgmoChartType
+} from "./chunk-XEMCNQQW.js";
+import {
+  parseSitemap
+} from "./chunk-KMB754DO.js";
+import {
+  parseOrg
+} from "./chunk-YCIBBVI2.js";
+
+// src/utils/collapse-marker.ts
+var MARKER_VALUE = /collapsed:\s*\S+/;
+var BARE_FLAG = /(?:\s*,)?[ \t]+collapsed\s*$/;
+var META_KEY = /(?:^|[\s,|])[\w-]+\s*:/;
+var hasBareFlag = (line, label) => line.trim() !== label && BARE_FLAG.test(line);
+function applyCollapsedMarker(line, label, collapse) {
+  if (collapse) {
+    if (MARKER_VALUE.test(line)) {
+      return line.replace(MARKER_VALUE, "collapsed: true");
+    }
+    if (hasBareFlag(line, label)) return line;
+    const stripped = line.replace(/\s+$/, "");
+    const body = line.trimStart();
+    const hasMeta = body.startsWith(label) && META_KEY.test(body.slice(label.length));
+    return hasMeta ? `${stripped}, collapsed: true` : `${stripped} collapsed: true`;
+  }
+  const expanded = line.replace(/\s*,\s*collapsed:\s*[^,\s]+/, "").replace(/\bcollapsed:\s*[^,\s]+\s*,\s*/, "").replace(/\s+collapsed:\s*[^,\s]+/, "").replace(/\s+$/, "");
+  return hasBareFlag(expanded, label) ? expanded.replace(BARE_FLAG, "") : expanded;
+}
+function applyCollapsedMarkerAtLine(text, lineNumber, label, collapse) {
+  const lines = text.split("\n");
+  const idx = lineNumber - 1;
+  const target = lines[idx];
+  if (target === void 0) return text;
+  lines[idx] = applyCollapsedMarker(target, label, collapse);
+  return lines.join("\n");
+}
+function applyGroupHeaderCollapsedMarkerAtLine(text, lineNumber, collapse) {
+  const lines = text.split("\n");
+  const idx = lineNumber - 1;
+  const target = lines[idx];
+  if (target === void 0) return text;
+  const close = target.indexOf("]");
+  if (close === -1) return text;
+  const header = target.slice(0, close + 1).trimStart();
+  lines[idx] = applyCollapsedMarker(target, header, collapse);
+  return lines.join("\n");
+}
+var INDENT = (s) => s.length - s.trimStart().length;
+var COLLAPSED_LINE = /^\s*collapsed:\s*\S+\s*$/;
+function applyIndentedGroupCollapsedMarkerAtLine(text, headerLineNumber, collapse) {
+  const lines = text.split("\n");
+  const hIdx = headerLineNumber - 1;
+  const header = lines[hIdx];
+  if (header === void 0) return text;
+  const headerIndent = INDENT(header);
+  let blockEnd = lines.length;
+  let childIndent = null;
+  for (let i = hIdx + 1; i < lines.length; i++) {
+    const line = lines[i];
+    if (line.trim() === "") continue;
+    const ind = INDENT(line);
+    if (ind <= headerIndent) {
+      blockEnd = i;
+      break;
+    }
+    childIndent ??= ind;
+  }
+  const indentStr = " ".repeat(childIndent ?? headerIndent + 2);
+  if (collapse) {
+    for (let i = hIdx + 1; i < blockEnd; i++) {
+      if (COLLAPSED_LINE.test(lines[i])) {
+        lines[i] = `${indentStr}collapsed: true`;
+        return lines.join("\n");
+      }
+    }
+    lines.splice(hIdx + 1, 0, `${indentStr}collapsed: true`);
+    return lines.join("\n");
+  }
+  for (let i = hIdx + 1; i < blockEnd; i++) {
+    if (COLLAPSED_LINE.test(lines[i])) {
+      lines.splice(i, 1);
+      return lines.join("\n");
+    }
+  }
+  return text;
+}
+function applyNoteCollapsedMarkerAtLine(text, lineNumber, collapse) {
+  const lines = text.split("\n");
+  const idx = lineNumber - 1;
+  const target = lines[idx];
+  if (target === void 0) return text;
+  const head = target.trim().replace(/(?:\s*,)?\s+collapsed:\s*\S+$/, "").replace(BARE_FLAG, "");
+  if (!/^note(\s|$)/i.test(head)) return text;
+  lines[idx] = applyCollapsedMarker(target, head, collapse);
+  return lines.join("\n");
+}
+
+// src/utils/fold-at-line.ts
+var NODE_TREES = {
+  mindmap: (s) => parseMindmap(s).roots,
+  org: (s) => parseOrg(s).roots,
+  sitemap: (s) => parseSitemap(s).roots
+};
+var GROUP_HEADER_TYPES = /* @__PURE__ */ new Set([
+  "block",
+  "boxes-and-lines",
+  "event-line",
+  "gantt",
+  "infra",
+  "journey-map",
+  "kanban",
+  "org",
+  "pert",
+  "raci",
+  "sequence",
+  "sitemap",
+  "state",
+  "timeline"
+]);
+var GROUP_HEAD = /^(?:[+-]\S*\s+)?\[/;
+var SECTION_LINE = /^==\s+\S/;
+var SECTION_MARKER = /(?:\s*,)?\s+collapsed(?::\s*\S+)?\s*$/;
+function labelAtLine(nodes, line) {
+  for (const n of nodes) {
+    if (n.lineNumber === line) return n.label;
+    const inner = labelAtLine(n.children, line);
+    if (inner !== null) return inner;
+  }
+  return null;
+}
+function foldSection(source, line, text, collapse) {
+  const label = text.trim().replace(SECTION_MARKER, "");
+  return applyCollapsedMarkerAtLine(source, line, label, collapse);
+}
+function foldGroupHeader(source, chartType, line, collapse) {
+  if (chartType === "infra" && !collapse) {
+    const next = applyIndentedGroupCollapsedMarkerAtLine(source, line, false);
+    if (next !== source) return next;
+  }
+  return applyGroupHeaderCollapsedMarkerAtLine(source, line, collapse);
+}
+function foldAtLine(source, line, collapse) {
+  if (!Number.isInteger(line) || line < 1) return null;
+  const chartType = parseDgmoChartType(source);
+  if (chartType === null) return null;
+  const text = source.split("\n")[line - 1];
+  if (text === void 0) return null;
+  const trimmed = text.trim();
+  let next = null;
+  if (GROUP_HEAD.test(trimmed)) {
+    if (GROUP_HEADER_TYPES.has(chartType)) {
+      next = foldGroupHeader(source, chartType, line, collapse);
+    }
+  } else if (chartType === "sequence") {
+    if (SECTION_LINE.test(trimmed)) {
+      next = foldSection(source, line, text, collapse);
+    } else if (/^note(\s|$)/i.test(trimmed)) {
+      next = applyNoteCollapsedMarkerAtLine(source, line, collapse);
+    }
+  } else {
+    const tree = NODE_TREES[chartType];
+    const label = tree ? labelAtLine(tree(source), line) : null;
+    if (label !== null) {
+      next = applyCollapsedMarkerAtLine(source, line, label, collapse);
+    }
+  }
+  return next === null || next === source ? null : next;
+}
+
+export {
+  applyCollapsedMarker,
+  applyCollapsedMarkerAtLine,
+  applyGroupHeaderCollapsedMarkerAtLine,
+  applyIndentedGroupCollapsedMarkerAtLine,
+  applyNoteCollapsedMarkerAtLine,
+  foldAtLine
+};

package/dist/{chunk-P6LKX3IQ.js → chunk-QOLRTPGH.js}

@@ -3,13 +3,13 @@ import {
   mapLegendConfig,
   mapLegendGroups,
   parsePathRings
-} from "./chunk-EMGNCG5C.js";
+} from "./chunk-XZGXVN4T.js";
 import {
   buildSwatches
 } from "./chunk-T7NWBVSC.js";
 import {
   parseClock
-} from "./chunk-EZ6BI5LL.js";
+} from "./chunk-6OUMYNAJ.js";
 import {
   fixedParts,
   fixedTimeCells,
@@ -22,19 +22,19 @@ import {
   TITLE_FONT_SIZE,
   TITLE_FONT_WEIGHT,
   TITLE_Y
-} from "./chunk-VLC6WNRD.js";
+} from "./chunk-GULGSH2Z.js";
 import {
   renderIntegratedLegend
-} from "./chunk-PGD6CNWO.js";
+} from "./chunk-DFEVFLEG.js";
 import {
   FONT_FAMILY
 } from "./chunk-ICLB27PZ.js";
 import {
   tagAttrKey
-} from "./chunk-LGUFJ7Y2.js";
+} from "./chunk-KW3CC7SB.js";
 import {
   measureText
-} from "./chunk-KAO7JL4I.js";
+} from "./chunk-PU5X3P3T.js";
 import {
   mix,
   themeBaseBg

package/dist/{chunk-FBK32S4D.js → chunk-R4SXMBGF.js}

@@ -2,7 +2,7 @@ import {
   extractColor,
   measureIndent,
   parseFirstLine
-} from "./chunk-FUYEXLAN.js";
+} from "./chunk-RFGQDIOI.js";
 import {
   emit,
   formatDgmoError,

package/dist/chunk-R4U7IIRX.js

@@ -0,0 +1,178 @@
+import {
+  isSequenceBlock,
+  isSequenceNote,
+  isSequenceSection
+} from "./chunk-ROH4LYBL.js";
+
+// src/sequence/collapse.ts
+function isCollapsibleGroup(group) {
+  return group.participantIds.length > 1;
+}
+function collapsedGroupId(group, groups) {
+  const shared = groups.some((g) => g !== group && g.name === group.name);
+  return shared ? `${group.name}@${group.lineNumber}` : group.name;
+}
+function applyCollapseProjection(parsed, requestedGroups) {
+  const collapsedGroups = new Set(
+    parsed.groups.filter((g) => requestedGroups.has(g.lineNumber) && isCollapsibleGroup(g)).map((g) => g.lineNumber)
+  );
+  if (collapsedGroups.size === 0) {
+    return {
+      participants: parsed.participants,
+      messages: parsed.messages,
+      elements: parsed.elements,
+      groups: parsed.groups,
+      collapsedGroupIds: /* @__PURE__ */ new Map()
+    };
+  }
+  const byName = new Map(parsed.groups.map((g) => [g.name, g]));
+  const insideCollapsed = (group) => {
+    let parentName = group.parent;
+    const seen = /* @__PURE__ */ new Set();
+    while (parentName !== void 0 && !seen.has(parentName)) {
+      seen.add(parentName);
+      const ancestor = byName.get(parentName);
+      if (!ancestor) return false;
+      if (collapsedGroups.has(ancestor.lineNumber)) return true;
+      parentName = ancestor.parent;
+    }
+    return false;
+  };
+  const memberToGroup = /* @__PURE__ */ new Map();
+  const virtualIds = /* @__PURE__ */ new Set();
+  const groupById = /* @__PURE__ */ new Map();
+  const byDepth = [...parsed.groups].sort((a, b) => a.depth - b.depth);
+  for (const group of byDepth) {
+    if (!collapsedGroups.has(group.lineNumber)) continue;
+    if (insideCollapsed(group)) continue;
+    const id = collapsedGroupId(group, parsed.groups);
+    virtualIds.add(id);
+    groupById.set(id, group);
+    for (const memberId of group.participantIds) {
+      if (!memberToGroup.has(memberId)) {
+        memberToGroup.set(memberId, id);
+      }
+    }
+  }
+  const participants = [];
+  const insertedGroups = /* @__PURE__ */ new Set();
+  for (const p of parsed.participants) {
+    const groupId = memberToGroup.get(p.id);
+    if (groupId) {
+      if (!insertedGroups.has(groupId)) {
+        insertedGroups.add(groupId);
+        const group = groupById.get(groupId);
+        participants.push({
+          id: groupId,
+          label: group.name,
+          type: "default",
+          lineNumber: group.lineNumber
+        });
+      }
+    } else if (virtualIds.has(p.id)) {
+    } else {
+      participants.push(p);
+    }
+  }
+  const remap = (id) => memberToGroup.get(id) ?? id;
+  const messages = parsed.messages.map((msg) => ({
+    ...msg,
+    from: remap(msg.from),
+    to: remap(msg.to)
+  }));
+  const elements = remapElements(parsed.elements, memberToGroup);
+  const groups = parsed.groups.filter((g) => !collapsedGroups.has(g.lineNumber) && !insideCollapsed(g)).map((g) => {
+    const remapped = [];
+    for (const id of g.participantIds) {
+      const to = memberToGroup.get(id) ?? id;
+      if (!remapped.includes(to)) remapped.push(to);
+    }
+    return { ...g, participantIds: remapped };
+  });
+  return {
+    participants,
+    messages,
+    elements,
+    groups,
+    collapsedGroupIds: memberToGroup
+  };
+}
+function remapElements(elements, memberToGroup) {
+  const remap = (id) => memberToGroup.get(id) ?? id;
+  const result = [];
+  for (const el of elements) {
+    if (isSequenceSection(el)) {
+      result.push(el);
+    } else if (isSequenceNote(el)) {
+      result.push({
+        ...el,
+        participantId: remap(el.participantId)
+      });
+    } else if (isSequenceBlock(el)) {
+      result.push({
+        ...el,
+        children: remapElements(el.children, memberToGroup),
+        elseChildren: remapElements(el.elseChildren, memberToGroup),
+        ...el.elseIfBranches ? {
+          elseIfBranches: el.elseIfBranches.map((branch) => ({
+            ...branch,
+            children: remapElements(branch.children, memberToGroup)
+          }))
+        } : {}
+      });
+    } else {
+      const msg = el;
+      const from = remap(msg.from);
+      const to = remap(msg.to);
+      if (from === to && from !== msg.from && !msg.label) {
+        continue;
+      }
+      result.push({ ...msg, from, to });
+    }
+  }
+  return result;
+}
+function isFoldableSequenceNote(note) {
+  return note.text.includes("\n");
+}
+function collectNotes(els, out) {
+  for (const el of els) {
+    if (isSequenceNote(el)) out.push(el);
+    else if (isSequenceBlock(el)) {
+      collectNotes(el.children, out);
+      for (const branch of el.elseIfBranches ?? [])
+        collectNotes(branch.children, out);
+      collectNotes(el.elseChildren, out);
+    }
+  }
+  return out;
+}
+function collapsedSequenceNoteLinesFromSource(parsed) {
+  return new Set(
+    collectNotes(parsed.elements, []).filter((n) => n.collapsed === true && isFoldableSequenceNote(n)).map((n) => n.lineNumber)
+  );
+}
+function unionCollapsedSequenceNotes(parsed, runtime) {
+  const out = collapsedSequenceNoteLinesFromSource(parsed);
+  if (runtime === void 0) return out;
+  const foldable = new Set(
+    collectNotes(parsed.elements, []).filter(isFoldableSequenceNote).map((n) => n.lineNumber)
+  );
+  for (const line of runtime) if (foldable.has(line)) out.add(line);
+  return out;
+}
+function collapsedSequenceSectionLinesFromSource(parsed) {
+  return new Set(
+    parsed.sections.filter((s) => s.collapsed === true).map((s) => s.lineNumber)
+  );
+}
+
+export {
+  isCollapsibleGroup,
+  collapsedGroupId,
+  applyCollapseProjection,
+  isFoldableSequenceNote,
+  collapsedSequenceNoteLinesFromSource,
+  unionCollapsedSequenceNotes,
+  collapsedSequenceSectionLinesFromSource
+};

package/dist/{chunk-DWMQ24JR.js → chunk-RC6PISCK.js}

@@ -9,13 +9,13 @@ import {
   tagAttrKey,
   validateTagGroupNames,
   validateTagValues
-} from "./chunk-LGUFJ7Y2.js";
+} from "./chunk-KW3CC7SB.js";
 import {
   extractColor,
   fillModeFromToken,
   measureIndent,
   parseFirstLine
-} from "./chunk-FUYEXLAN.js";
+} from "./chunk-RFGQDIOI.js";
 import {
   formatDgmoError,
   makeDgmoError,
@@ -332,6 +332,8 @@ function parseBlockTail(tail, aliasMap) {
     if (rawKey === "span") {
       const num = parseInt(value, 10);
       if (Number.isFinite(num) && num >= 1) span = num;
+    } else if (rawKey === "collapsed") {
+      collapsed = value.toLowerCase() === "true";
     } else if (value) {
       meta[aliasMap.get(rawKey) ?? rawKey] = value;
     }

package/dist/{chunk-R5L5E3TC.js → chunk-REKLKGR6.js}

@@ -1,13 +1,13 @@
 import {
   TITLE_FONT_SIZE,
   TITLE_Y
-} from "./chunk-VLC6WNRD.js";
+} from "./chunk-GULGSH2Z.js";
 import {
   LEGEND_HEIGHT
-} from "./chunk-UOCWYLYT.js";
+} from "./chunk-OZXKW5NA.js";
 import {
   measureText
-} from "./chunk-KAO7JL4I.js";
+} from "./chunk-PU5X3P3T.js";
 
 // src/utils/inline-header.ts
 var LEGEND_INLINE_SUPPORTED = /* @__PURE__ */ new Set([