@diagrammo/dgmo 0.45.0 → 0.47.0

package/dist/chunk-WCT3NYCV.js

@@ -0,0 +1,160 @@
+// src/utils/text-measure.ts
+var CHAR_W = {
+  " ": 0.28,
+  "!": 0.28,
+  '"': 0.36,
+  "#": 0.56,
+  "$": 0.56,
+  "%": 0.89,
+  "&": 0.67,
+  "'": 0.19,
+  "(": 0.33,
+  ")": 0.33,
+  "*": 0.39,
+  "+": 0.58,
+  ",": 0.28,
+  "-": 0.33,
+  ".": 0.28,
+  "/": 0.28,
+  "0": 0.56,
+  "1": 0.56,
+  "2": 0.56,
+  "3": 0.56,
+  "4": 0.56,
+  "5": 0.56,
+  "6": 0.56,
+  "7": 0.56,
+  "8": 0.56,
+  "9": 0.56,
+  ":": 0.28,
+  ";": 0.28,
+  "<": 0.58,
+  "=": 0.58,
+  ">": 0.58,
+  "?": 0.56,
+  "@": 1.02,
+  A: 0.67,
+  B: 0.67,
+  C: 0.72,
+  D: 0.72,
+  E: 0.67,
+  F: 0.61,
+  G: 0.78,
+  H: 0.72,
+  I: 0.28,
+  J: 0.5,
+  K: 0.67,
+  L: 0.56,
+  M: 0.83,
+  N: 0.72,
+  O: 0.78,
+  P: 0.67,
+  Q: 0.78,
+  R: 0.72,
+  S: 0.67,
+  T: 0.61,
+  U: 0.72,
+  V: 0.67,
+  W: 0.94,
+  X: 0.67,
+  Y: 0.67,
+  Z: 0.61,
+  a: 0.56,
+  b: 0.56,
+  c: 0.5,
+  d: 0.56,
+  e: 0.56,
+  f: 0.28,
+  g: 0.56,
+  h: 0.56,
+  i: 0.22,
+  j: 0.22,
+  k: 0.5,
+  l: 0.22,
+  m: 0.83,
+  n: 0.56,
+  o: 0.56,
+  p: 0.56,
+  q: 0.56,
+  r: 0.33,
+  s: 0.5,
+  t: 0.28,
+  u: 0.56,
+  v: 0.5,
+  w: 0.72,
+  x: 0.5,
+  y: 0.5,
+  z: 0.5
+};
+var DEFAULT_W = 0.56;
+var CHAR_WIDTH_RATIO = DEFAULT_W;
+function measureText(text, fontSize) {
+  let w = 0;
+  for (let i = 0; i < text.length; i++) {
+    w += (CHAR_W[text.charAt(i)] ?? DEFAULT_W) * fontSize;
+  }
+  return w;
+}
+function truncateText(text, fontSize, maxWidth) {
+  if (measureText(text, fontSize) <= maxWidth) return text;
+  const ellipsis = "\u2026";
+  const ellipsisW = measureText(ellipsis, fontSize);
+  if (ellipsisW > maxWidth) return "";
+  let lo = 0;
+  let hi = text.length;
+  while (lo < hi) {
+    const mid = Math.ceil((lo + hi) / 2);
+    if (measureText(text.slice(0, mid), fontSize) + ellipsisW <= maxWidth) {
+      lo = mid;
+    } else {
+      hi = mid - 1;
+    }
+  }
+  return lo === 0 ? ellipsis : text.slice(0, lo) + ellipsis;
+}
+function wrapTextToWidth(text, fontSize, maxWidth, opts) {
+  const words = text.split(/\s+/).filter((w) => w.length > 0);
+  if (words.length === 0) return [""];
+  const hardBreak = opts?.hardBreak ?? false;
+  const lines = [];
+  let current = "";
+  const pushWord = (word) => {
+    const test = current ? `${current} ${word}` : word;
+    if (measureText(test, fontSize) <= maxWidth || !current) {
+      current = test;
+    } else {
+      lines.push(current);
+      current = word;
+    }
+  };
+  for (const word of words) {
+    if (hardBreak && measureText(word, fontSize) > maxWidth) {
+      if (current) {
+        lines.push(current);
+        current = "";
+      }
+      let chunk = "";
+      for (const ch of word) {
+        if (chunk && measureText(chunk + ch, fontSize) > maxWidth) {
+          lines.push(chunk);
+          chunk = ch;
+        } else {
+          chunk += ch;
+        }
+      }
+      current = chunk;
+      continue;
+    }
+    pushWord(word);
+  }
+  if (current) lines.push(current);
+  return lines.length > 0 ? lines : [""];
+}
+
+export {
+  CHAR_WIDTH_RATIO,
+  measureText,
+  truncateText,
+  wrapTextToWidth
+};
+//# sourceMappingURL=chunk-WCT3NYCV.js.map

package/dist/chunk-WVAJFAIA.js

@@ -0,0 +1,529 @@
+import {
+  AUTO_TAG_COLOR_SENTINEL,
+  finalizeAutoTagColors,
+  matchTagBlockHeading,
+  stripDefaultModifier,
+  tagAttrKey
+} from "./chunk-QLCCJEJI.js";
+import {
+  extractColor,
+  measureIndent,
+  parseFirstLine
+} from "./chunk-Y3J7VR52.js";
+import {
+  emit
+} from "./chunk-CXK4DZH3.js";
+
+// src/swimlane/diagnostics.ts
+var SWIMLANE_DX = {
+  DUPLICATE_NODE: {
+    code: "E_SWIMLANE_DUPLICATE_NODE",
+    severity: "error",
+    chartType: "swimlane",
+    title: "Duplicate node",
+    message: (p) => `Duplicate node name '${p.name ?? "Foo"}'`,
+    hint: "Every node name must be unique across the diagram \u2014 rename or remove the second declaration.",
+    example: `swimlane T
+lane L
+L
+  Foo
+  Foo`
+  },
+  UNKNOWN_NODE: {
+    code: "E_SWIMLANE_UNKNOWN_NODE",
+    severity: "error",
+    chartType: "swimlane",
+    title: "Unknown node in edge",
+    message: (p) => `Edge references unknown node '${p.node ?? "Bar"}'`,
+    hint: "Declare the node under a lane before referencing it in a flow arrow.",
+    example: `swimlane T
+lane L
+L
+  Foo
+Foo -> Bar`
+  },
+  UNKNOWN_LANE: {
+    code: "E_SWIMLANE_UNKNOWN_LANE",
+    severity: "error",
+    chartType: "swimlane",
+    title: "Node outside a lane",
+    message: (p) => `Node '${p.node ?? "Foo"}' is not inside a lane \u2014 declare a lane first`,
+    hint: "Open a lane context (a bare line matching a declared lane) before the node line.",
+    example: `swimlane T
+lane L
+[Start]
+  Foo`
+  },
+  NO_LANES: {
+    code: "E_SWIMLANE_NO_LANES",
+    severity: "error",
+    chartType: "swimlane",
+    title: "Phase without lanes",
+    message: (p) => `Phase '${p.phase ?? "Start"}' declared but no lanes exist`,
+    hint: "Declare at least one `lane <Name>` before any `[Phase]` header.",
+    example: `swimlane T
+[Start]`
+  },
+  // One code, many wordings — the call site passes the exact `reason`:
+  //   parseNodeToken: 'inclusive gateway (<o …>) is fast-follow', event-based,
+  //                   timer|message|signal events; declareNode: 'notes are
+  //                   deferred past v1', 'data objects are deferred past v1',
+  //                   `${k} events are fast-follow`; addChain: 'message flow
+  //                   (~>) is fast-follow'.
+  UNSUPPORTED: {
+    code: "E_SWIMLANE_UNSUPPORTED",
+    severity: "error",
+    chartType: "swimlane",
+    title: "Unsupported construct",
+    message: (p) => typeof p.reason === "string" && p.reason ? p.reason : "inclusive gateway (<o \u2026>) is fast-follow",
+    hint: "This construct is deferred past v1 / fast-follow \u2014 remove it or use a supported shape, event, or flow.",
+    example: `swimlane T
+lane L
+L
+  <o Maybe>`
+  }
+};
+var SWIMLANE_DIAGNOSTICS = Object.values(SWIMLANE_DX);
+
+// src/swimlane/parser.ts
+function normKey(label) {
+  return label.trim().replace(/\s+/g, " ").toLowerCase();
+}
+function parseNodeToken(raw) {
+  const t = raw.trim();
+  if (t.startsWith("<") && t.endsWith(">") && t.length >= 2) {
+    const inner = t.slice(1, -1).trim();
+    if (inner.startsWith("+")) {
+      return {
+        shape: "parallel",
+        event: "none",
+        label: inner.slice(1).trim()
+      };
+    }
+    if (inner.startsWith("o ") || inner === "o") {
+      return {
+        shape: "exclusive",
+        event: "none",
+        label: inner.replace(/^o\s*/, "").trim(),
+        unsupported: "inclusive gateway (<o \u2026>) is fast-follow"
+      };
+    }
+    if (inner.startsWith("* ") || inner === "*") {
+      return {
+        shape: "exclusive",
+        event: "none",
+        label: inner.replace(/^\*\s*/, "").trim(),
+        unsupported: "event-based gateway (<* \u2026>) is fast-follow"
+      };
+    }
+    return { shape: "exclusive", event: "none", label: inner };
+  }
+  if (t.startsWith("[[") && t.endsWith("]]") && t.length >= 4) {
+    return { shape: "subprocess", event: "none", label: t.slice(2, -2).trim() };
+  }
+  if (t.startsWith("(")) {
+    const close = t.indexOf(")");
+    if (close > 0) {
+      let inner = t.slice(1, close).trim();
+      let event = "none";
+      let unsupported;
+      if (inner.startsWith("!")) {
+        event = "error";
+        inner = inner.slice(1).trim();
+      }
+      const trailing = t.slice(close + 1).trim().toLowerCase();
+      if (trailing) {
+        if (trailing === "success") event = "success";
+        else if (trailing === "terminate") event = "terminate";
+        else if (trailing === "error") event = "error";
+        else if (trailing === "timer")
+          unsupported = "timer events are fast-follow";
+        else if (trailing === "message")
+          unsupported = "message events are fast-follow";
+        else if (trailing === "signal")
+          unsupported = "signal events are fast-follow";
+      }
+      return {
+        shape: "terminal",
+        event,
+        label: inner,
+        ...unsupported !== void 0 && { unsupported }
+      };
+    }
+  }
+  return { shape: "task", event: "none", label: t };
+}
+var ARROW_RE = /(?:^|\s)-([^>]+?)->|->/g;
+function splitChain(line) {
+  const parts = [];
+  ARROW_RE.lastIndex = 0;
+  let lastIndex = 0;
+  let m;
+  const rawLabels = [];
+  const segments = [];
+  while ((m = ARROW_RE.exec(line)) !== null) {
+    segments.push(line.slice(lastIndex, m.index));
+    let lbl = m[1]?.trim();
+    if (lbl === "") lbl = void 0;
+    rawLabels.push(lbl);
+    lastIndex = m.index + m[0].length;
+  }
+  segments.push(line.slice(lastIndex));
+  for (let i = 0; i < segments.length; i++) {
+    parts.push({
+      text: segments[i].trim(),
+      ...rawLabels[i] !== void 0 && { labelAfter: rawLabels[i] }
+    });
+  }
+  return parts;
+}
+function splitNodeMeta(line) {
+  const m = line.match(/(^|\s)([A-Za-z][\w-]*)\s*:/);
+  if (m?.index === void 0) {
+    return { token: line.trim(), meta: {} };
+  }
+  const cut = m.index + (m[1] ? m[1].length : 0);
+  const token = line.slice(0, cut).trim();
+  const region = line.slice(cut);
+  const meta = {};
+  for (const pair of region.split(",")) {
+    const idx = pair.indexOf(":");
+    if (idx <= 0) continue;
+    const key = pair.slice(0, idx).trim().toLowerCase();
+    const value = pair.slice(idx + 1).trim();
+    if (!key) continue;
+    meta[key] = value;
+  }
+  return { token, meta };
+}
+function parseSwimlane(content, palette) {
+  const diagnostics = [];
+  const lanes = [];
+  const phases = [];
+  const nodes = [];
+  const edges = [];
+  const tagGroups = [];
+  const laneByKey = /* @__PURE__ */ new Map();
+  const phaseByKey = /* @__PURE__ */ new Map();
+  const nodeByKey = /* @__PURE__ */ new Map();
+  const metaAliasMap = /* @__PURE__ */ new Map();
+  const options = {};
+  let direction = "LR";
+  const rawLines = content.split("\n");
+  let title;
+  let titleLineNumber;
+  let startIdx = 0;
+  for (let i = 0; i < rawLines.length; i++) {
+    const t = rawLines[i].trim();
+    if (!t || t.startsWith("//")) continue;
+    const fl = parseFirstLine(rawLines[i]);
+    if (fl?.chartType === "swimlane") {
+      title = fl.title;
+      titleLineNumber = i + 1;
+    }
+    startIdx = i + 1;
+    break;
+  }
+  let currentTagGroup = null;
+  let sawContent = false;
+  for (let i = startIdx; i < rawLines.length; i++) {
+    const raw = rawLines[i];
+    const lineNum = i + 1;
+    const trimmed = raw.trim();
+    if (!trimmed || trimmed.startsWith("//")) continue;
+    const indent = measureIndent(raw);
+    const tagMatch = matchTagBlockHeading(trimmed);
+    if (tagMatch && indent === 0) {
+      const newGroup = {
+        name: tagMatch.name,
+        ...tagMatch.alias !== void 0 && { alias: tagMatch.alias },
+        entries: [],
+        lineNumber: lineNum
+      };
+      currentTagGroup = newGroup;
+      if (tagMatch.alias) {
+        metaAliasMap.set(normKey(tagMatch.alias), tagAttrKey(tagMatch.name));
+      }
+      metaAliasMap.set(normKey(tagMatch.name), tagAttrKey(tagMatch.name));
+      if (tagMatch.inlineValues) {
+        for (const rawVal of tagMatch.inlineValues) {
+          const { text, isDefault } = stripDefaultModifier(rawVal);
+          const { label, color } = extractColor(
+            text,
+            palette,
+            diagnostics,
+            lineNum
+          );
+          newGroup.entries.push({
+            value: label,
+            color: color ?? AUTO_TAG_COLOR_SENTINEL,
+            lineNumber: lineNum
+          });
+          if (isDefault) newGroup.defaultValue = label;
+        }
+        if (!newGroup.defaultValue && newGroup.entries.length > 0) {
+          newGroup.defaultValue = newGroup.entries[0].value;
+        }
+      }
+      tagGroups.push(newGroup);
+      continue;
+    }
+    if (currentTagGroup && indent > 0 && !sawContent) {
+      const { text, isDefault } = stripDefaultModifier(trimmed);
+      const { label, color } = extractColor(
+        text,
+        palette,
+        diagnostics,
+        lineNum
+      );
+      currentTagGroup.entries.push({
+        value: label,
+        color: color ?? AUTO_TAG_COLOR_SENTINEL,
+        lineNumber: lineNum
+      });
+      if (isDefault || currentTagGroup.entries.length === 1) {
+        currentTagGroup.defaultValue = label;
+      }
+      continue;
+    }
+    if (indent === 0) currentTagGroup = null;
+    if (indent === 0 && /^solid-fill\s*$/i.test(trimmed)) {
+      options["solid-fill"] = "on";
+      continue;
+    }
+    if (indent === 0 && /^direction\s+/i.test(trimmed)) {
+      const val = trimmed.replace(/^direction\s+/i, "").trim().toUpperCase();
+      if (val === "LR" || val === "TB") {
+        direction = val;
+        options["direction"] = val;
+      }
+      continue;
+    }
+    if (indent === 0 && /^lane\s+/i.test(trimmed)) {
+      const rest = trimmed.replace(/^lane\s+/i, "").trim();
+      const { label, color } = extractColor(
+        rest,
+        palette,
+        diagnostics,
+        lineNum
+      );
+      const key = normKey(label);
+      if (laneByKey.has(key)) continue;
+      const lane = {
+        id: label,
+        label,
+        ...color !== void 0 && { color },
+        lineNumber: lineNum
+      };
+      lanes.push(lane);
+      laneByKey.set(key, lane);
+      continue;
+    }
+    if (indent === 0 && !trimmed.startsWith("tag ")) sawContent = true;
+  }
+  let currentPhase = null;
+  let currentLane = null;
+  let laneIndent = -1;
+  let currentFlowSource = null;
+  const declareNode = (token, meta, lineNum) => {
+    const parsed = parseNodeToken(token);
+    if (parsed.unsupported) {
+      diagnostics.push(
+        emit(SWIMLANE_DX.UNSUPPORTED, lineNum, { reason: parsed.unsupported })
+      );
+      return;
+    }
+    if (!parsed.label) return;
+    if (!currentLane) {
+      diagnostics.push(
+        emit(SWIMLANE_DX.UNKNOWN_LANE, lineNum, { node: parsed.label })
+      );
+      return;
+    }
+    const { label: cleanLabel, color } = extractColor(
+      parsed.label,
+      palette,
+      diagnostics,
+      lineNum
+    );
+    const key = normKey(cleanLabel);
+    if (nodeByKey.has(key)) {
+      diagnostics.push(
+        emit(SWIMLANE_DX.DUPLICATE_NODE, lineNum, { name: cleanLabel })
+      );
+      return;
+    }
+    const tags = {};
+    for (const [k, v] of Object.entries(meta)) {
+      if (k === "note") {
+        diagnostics.push(
+          emit(SWIMLANE_DX.UNSUPPORTED, lineNum, {
+            reason: "notes are deferred past v1"
+          })
+        );
+        continue;
+      }
+      if (k === "data") {
+        diagnostics.push(
+          emit(SWIMLANE_DX.UNSUPPORTED, lineNum, {
+            reason: "data objects are deferred past v1"
+          })
+        );
+        continue;
+      }
+      if (k === "timer" || k === "message" || k === "signal") {
+        diagnostics.push(
+          emit(SWIMLANE_DX.UNSUPPORTED, lineNum, {
+            reason: `${k} events are fast-follow`
+          })
+        );
+        continue;
+      }
+      const canonical = metaAliasMap.get(k) ?? k;
+      tags[canonical] = v;
+    }
+    const node = {
+      id: cleanLabel,
+      label: cleanLabel,
+      shape: parsed.shape,
+      event: parsed.event,
+      lane: currentLane.id,
+      ...currentPhase && { phase: currentPhase.id },
+      ...color !== void 0 && { color },
+      tags,
+      lineNumber: lineNum
+    };
+    nodes.push(node);
+    nodeByKey.set(key, node);
+  };
+  const resolveRef = (token, lineNum) => {
+    const parsed = parseNodeToken(token);
+    if (parsed.unsupported) {
+      diagnostics.push(
+        emit(SWIMLANE_DX.UNSUPPORTED, lineNum, { reason: parsed.unsupported })
+      );
+      return null;
+    }
+    const { label } = extractColor(parsed.label, palette);
+    const key = normKey(label);
+    const node = nodeByKey.get(key);
+    if (!node) {
+      diagnostics.push(
+        emit(SWIMLANE_DX.UNKNOWN_NODE, lineNum, { node: parsed.label })
+      );
+      return null;
+    }
+    return node.id;
+  };
+  const addChain = (line, lineNum) => {
+    if (line.includes("~>")) {
+      diagnostics.push(
+        emit(SWIMLANE_DX.UNSUPPORTED, lineNum, {
+          reason: "message flow (~>) is fast-follow"
+        })
+      );
+      return;
+    }
+    const parts = splitChain(line);
+    if (parts.length < 2) return;
+    const resolved = [];
+    for (let p = 0; p < parts.length; p++) {
+      const text = parts[p].text;
+      if (p === 0 && text === "") {
+        resolved.push(currentFlowSource);
+        continue;
+      }
+      resolved.push(resolveRef(text, lineNum));
+    }
+    for (let p = 0; p < parts.length - 1; p++) {
+      const src = resolved[p];
+      const tgt = resolved[p + 1];
+      const label = parts[p].labelAfter;
+      if (!src || !tgt) continue;
+      edges.push({
+        source: src,
+        target: tgt,
+        ...label !== void 0 && { label },
+        lineNumber: lineNum
+      });
+    }
+  };
+  let inTagBlock = false;
+  for (let i = startIdx; i < rawLines.length; i++) {
+    const raw = rawLines[i];
+    const lineNum = i + 1;
+    let trimmed = raw.trim();
+    if (!trimmed || trimmed.startsWith("//")) continue;
+    const cIdx = trimmed.indexOf("//");
+    if (cIdx > 0) trimmed = trimmed.slice(0, cIdx).trim();
+    if (!trimmed) continue;
+    const indent = measureIndent(raw);
+    if (indent === 0 && /^(lane|direction|tag)\s+/i.test(trimmed)) {
+      inTagBlock = /^tag\s+/i.test(trimmed);
+      continue;
+    }
+    if (indent === 0 && /^solid-fill\s*$/i.test(trimmed)) continue;
+    if (matchTagBlockHeading(trimmed) && indent === 0) {
+      inTagBlock = true;
+      continue;
+    }
+    if (indent === 0) inTagBlock = false;
+    if (inTagBlock && indent > 0) continue;
+    if (indent === 0 && trimmed.startsWith("[") && trimmed.endsWith("]") && !trimmed.startsWith("[[")) {
+      const label = trimmed.slice(1, -1).trim();
+      if (lanes.length === 0) {
+        diagnostics.push(emit(SWIMLANE_DX.NO_LANES, lineNum, { phase: label }));
+      }
+      const key = normKey(label);
+      let phase = phaseByKey.get(key);
+      if (!phase) {
+        phase = { id: label, label, lineNumber: lineNum };
+        phases.push(phase);
+        phaseByKey.set(key, phase);
+      }
+      currentPhase = phase;
+      currentLane = null;
+      laneIndent = -1;
+      currentFlowSource = null;
+      continue;
+    }
+    if (trimmed.includes("->") || trimmed.includes("~>")) {
+      addChain(trimmed, lineNum);
+      continue;
+    }
+    const laneRef = laneByKey.get(normKey(trimmed));
+    if (laneRef && (laneIndent < 0 || indent <= laneIndent)) {
+      currentLane = laneRef;
+      laneIndent = indent;
+      currentFlowSource = null;
+      continue;
+    }
+    if (indent === 0) {
+      const ref = resolveRef(trimmed, lineNum);
+      if (ref) currentFlowSource = ref;
+      continue;
+    }
+    const { token, meta } = splitNodeMeta(trimmed);
+    declareNode(token, meta, lineNum);
+  }
+  finalizeAutoTagColors(tagGroups, palette);
+  return {
+    ...title !== void 0 && { title },
+    ...titleLineNumber !== void 0 && { titleLineNumber },
+    direction,
+    lanes,
+    phases,
+    nodes,
+    edges,
+    tagGroups,
+    options,
+    diagnostics,
+    error: null
+  };
+}
+
+export {
+  SWIMLANE_DIAGNOSTICS,
+  parseSwimlane
+};
+//# sourceMappingURL=chunk-WVAJFAIA.js.map