@diagrammo/dgmo 0.46.0 → 0.47.0

package/dist/chunk-3MQQNXPD.js

@@ -0,0 +1,415 @@
+import {
+  tryCollectNote
+} from "./chunk-5MLYVTYM.js";
+import {
+  resolveNotes
+} from "./chunk-FMDSF3OV.js";
+import {
+  parseInArrowLabel
+} from "./chunk-FFUN5D66.js";
+import {
+  displayName,
+  normalizeName
+} from "./chunk-NOTA6TEI.js";
+import {
+  ALL_CHART_TYPES,
+  OPTION_NOCOLON_RE,
+  measureIndent,
+  parseFirstLine,
+  tryParseSharedOption
+} from "./chunk-Y3J7VR52.js";
+import {
+  resolveColorWithDiagnostic
+} from "./chunk-TLVIHFRO.js";
+import {
+  NAME_DIAGNOSTIC_CODES,
+  formatDgmoError,
+  makeDgmoError,
+  nameMergedMessage,
+  suggest
+} from "./chunk-CXK4DZH3.js";
+
+// src/graph/state-parser.ts
+var PSEUDOSTATE_ID = "pseudostate:[*]";
+var PSEUDOSTATE_LABEL = "[*]";
+var GROUP_BRACKET_RE = /^\[([^\]]+)\](?:\s+(red|orange|yellow|green|blue|purple|teal|cyan|gray|black|white))?(?:,?\s+collapsed:\s*(\S+))?\s*$/;
+function splitArrows(line) {
+  const segments = [];
+  const arrowPositions = [];
+  let searchFrom = 0;
+  let scanFloor = 0;
+  while (searchFrom < line.length) {
+    const idx = line.indexOf("->", searchFrom);
+    if (idx === -1) break;
+    let runStart = idx;
+    while (runStart > scanFloor && line[runStart - 1] === "-") runStart--;
+    const arrowEnd = idx + 2;
+    let arrowStart;
+    let label;
+    let openingStart = -1;
+    for (let i = scanFloor; i < runStart; i++) {
+      if (line[i] !== "-") continue;
+      const prevIsWsOrFloor = i === 0 || i === scanFloor || /\s/.test(line.charAt(i - 1));
+      if (prevIsWsOrFloor) {
+        openingStart = i;
+        break;
+      }
+    }
+    if (openingStart !== -1) {
+      let openingEnd = openingStart;
+      while (openingEnd < runStart && line[openingEnd] === "-") openingEnd++;
+      const labelPart = line.substring(openingEnd, runStart).trim();
+      if (labelPart) label = labelPart;
+      arrowStart = openingStart;
+    } else {
+      arrowStart = runStart;
+    }
+    arrowPositions.push({
+      start: arrowStart,
+      end: arrowEnd,
+      ...label !== void 0 && { label }
+    });
+    searchFrom = arrowEnd;
+    scanFloor = arrowEnd;
+  }
+  if (arrowPositions.length === 0) return [line];
+  let lastIndex = 0;
+  for (let i = 0; i < arrowPositions.length; i++) {
+    const arrow = arrowPositions[i];
+    const beforeText = line.substring(lastIndex, arrow.start).trim();
+    if (beforeText || i === 0) segments.push(beforeText);
+    const arrowToken = arrow.label ? `-${arrow.label}->` : "->";
+    segments.push(arrowToken);
+    lastIndex = arrow.end;
+  }
+  const remaining = line.substring(lastIndex).trim();
+  if (remaining) segments.push(remaining);
+  return segments;
+}
+function parseArrowToken(token, _palette, lineNumber, diagnostics) {
+  if (token === "->") return {};
+  const m = token.match(/^-(.+?)->$/);
+  if (m) {
+    const rawLabel = m[1] ?? "";
+    const labelResult = parseInArrowLabel(rawLabel, lineNumber);
+    diagnostics.push(...labelResult.diagnostics);
+    return {
+      ...labelResult.label !== void 0 && { label: labelResult.label }
+    };
+  }
+  return {};
+}
+function parseStateNodeRef(text) {
+  const t = text.trim();
+  if (!t) return null;
+  if (t === "[*]") {
+    return {
+      id: PSEUDOSTATE_ID,
+      label: PSEUDOSTATE_LABEL,
+      shape: "pseudostate"
+    };
+  }
+  const label = t;
+  if (!label) return null;
+  return {
+    id: `state:${normalizeName(label)}`,
+    label,
+    shape: "state"
+  };
+}
+function parseState(content, palette) {
+  const lines = content.split("\n");
+  const options = {};
+  const result = {
+    type: "state",
+    direction: "LR",
+    nodes: [],
+    edges: [],
+    options,
+    diagnostics: [],
+    error: null
+  };
+  const fail = (line, message) => {
+    const diag = makeDgmoError(line, message);
+    result.diagnostics.push(diag);
+    result.error = formatDgmoError(diag);
+    return result;
+  };
+  const nodeMap = /* @__PURE__ */ new Map();
+  const indentStack = [];
+  const notes = [];
+  let currentGroup = null;
+  let groupIndent = -1;
+  const groups = [];
+  let contentStarted = false;
+  let firstLineParsed = false;
+  const nameAliasMap = /* @__PURE__ */ new Map();
+  function peelAlias(seg) {
+    const trimmed = seg.trim();
+    const m = trimmed.match(/^(.*?)\s+as\s+([A-Za-z][A-Za-z0-9_]{0,11})\s*$/);
+    if (!m) return { seg: trimmed };
+    return { seg: m[1].trim(), alias: m[2] };
+  }
+  function getOrCreateNode(ref, lineNumber) {
+    const key = ref.id;
+    const existing = nodeMap.get(key);
+    if (existing) {
+      const incomingDisplay = displayName(ref.label);
+      const existingDisplay = displayName(existing.label);
+      if (incomingDisplay !== existingDisplay) {
+        result.diagnostics.push(
+          makeDgmoError(
+            lineNumber,
+            nameMergedMessage({
+              incomingDisplay,
+              incomingLine: lineNumber,
+              existingDisplay,
+              existingLine: existing.lineNumber
+            }),
+            "warning",
+            NAME_DIAGNOSTIC_CODES.NAME_MERGED
+          )
+        );
+      }
+      return existing;
+    }
+    const node = {
+      id: key,
+      label: ref.label,
+      shape: ref.shape,
+      lineNumber,
+      ...ref.color && { color: ref.color },
+      ...currentGroup && { group: currentGroup.id }
+    };
+    nodeMap.set(key, node);
+    result.nodes.push(node);
+    if (currentGroup && !currentGroup.nodeIds.includes(key)) {
+      currentGroup.nodeIds.push(key);
+    }
+    return node;
+  }
+  function addEdge(sourceId, targetId, lineNumber, label) {
+    result.edges.push({
+      source: sourceId,
+      target: targetId,
+      lineNumber,
+      ...label && { label }
+    });
+  }
+  for (let i = 0; i < lines.length; i++) {
+    const raw = lines[i];
+    const trimmed = raw.trim();
+    const lineNumber = i + 1;
+    const indent = measureIndent(raw);
+    if (!trimmed) continue;
+    if (trimmed.startsWith("//")) continue;
+    if (!firstLineParsed && !contentStarted) {
+      const firstLineResult = parseFirstLine(trimmed);
+      if (firstLineResult) {
+        firstLineParsed = true;
+        if (firstLineResult.chartType !== "state") {
+          const allTypes = Array.from(ALL_CHART_TYPES);
+          let msg = `Expected chart type "state", got "${firstLineResult.chartType}"`;
+          const hint = suggest(firstLineResult.chartType, allTypes);
+          if (hint) msg += `. ${hint}`;
+          return fail(lineNumber, msg);
+        }
+        if (firstLineResult.title) {
+          result.title = firstLineResult.title;
+          result.titleLineNumber = lineNumber;
+        }
+        continue;
+      }
+    }
+    const noteResult = tryCollectNote(
+      lines,
+      i,
+      indent,
+      palette,
+      result.diagnostics
+    );
+    if (noteResult) {
+      if (noteResult.note) notes.push(noteResult.note);
+      i = noteResult.lastIndex;
+      continue;
+    }
+    const groupMatch = trimmed.match(GROUP_BRACKET_RE);
+    if (groupMatch && groupMatch[1].trim() !== "*") {
+      const groupLabel = groupMatch[1].trim();
+      const groupColorName = groupMatch[2]?.trim();
+      const groupColor = groupColorName ? resolveColorWithDiagnostic(
+        groupColorName,
+        lineNumber,
+        result.diagnostics,
+        palette
+      ) : void 0;
+      const groupCollapsed = groupMatch[3]?.toLowerCase() === "true";
+      currentGroup = {
+        id: `group:${groupLabel.toLowerCase()}`,
+        label: groupLabel,
+        nodeIds: [],
+        lineNumber,
+        ...groupColor && { color: groupColor },
+        ...groupCollapsed && { collapsed: true }
+      };
+      groupIndent = indent;
+      groups.push(currentGroup);
+      continue;
+    }
+    if (!contentStarted) {
+      if (/^direction-tb$/i.test(trimmed)) {
+        result.direction = "TB";
+        continue;
+      }
+      if (/^solid-fill$/i.test(trimmed)) {
+        options["solid-fill"] = "on";
+        continue;
+      }
+      if (/^no-color$/i.test(trimmed)) {
+        result.diagnostics.push(
+          makeDgmoError(lineNumber, '"no-color" has been removed.', "warning")
+        );
+        continue;
+      }
+      if (tryParseSharedOption(trimmed, options)) {
+        continue;
+      }
+      const optMatch = trimmed.match(OPTION_NOCOLON_RE);
+      if (optMatch && !trimmed.includes("->")) {
+        const key = optMatch[1].toLowerCase();
+        const value = optMatch[2].trim();
+        if (key === "no-color") {
+          result.diagnostics.push(
+            makeDgmoError(
+              lineNumber,
+              '"no-color" was removed \u2014 state colors are assigned automatically; delete this line.',
+              "warning"
+            )
+          );
+          continue;
+        }
+        options[key] = value;
+        continue;
+      }
+    }
+    contentStarted = true;
+    if (currentGroup && indent <= groupIndent) {
+      currentGroup = null;
+      groupIndent = -1;
+    }
+    while (indentStack.length > 0) {
+      const top = indentStack[indentStack.length - 1];
+      if (top.indent >= indent) {
+        indentStack.pop();
+      } else {
+        break;
+      }
+    }
+    const implicitSourceId = indentStack.length > 0 ? (
+      // In-bounds by length check above.
+      indentStack[indentStack.length - 1].nodeId
+    ) : null;
+    const segments = splitArrows(trimmed);
+    if (segments.length === 1) {
+      const peeled = peelAlias(segments[0]);
+      const ref = parseStateNodeRef(peeled.seg);
+      if (ref) {
+        const node = getOrCreateNode(ref, lineNumber);
+        if (peeled.alias) nameAliasMap.set(peeled.alias, node.id);
+        node.lineNumber = lineNumber;
+        indentStack.push({ nodeId: node.id, indent });
+      } else {
+        const aliasResolved = nameAliasMap.get(peeled.seg.trim());
+        if (aliasResolved !== void 0) {
+          indentStack.push({ nodeId: aliasResolved, indent });
+        }
+      }
+      continue;
+    }
+    let lastNodeId = null;
+    let pendingArrow = null;
+    for (let j = 0; j < segments.length; j++) {
+      const seg = segments[j];
+      if (seg === "->" || /^-.+->$/.test(seg)) {
+        pendingArrow = parseArrowToken(
+          seg,
+          palette,
+          lineNumber,
+          result.diagnostics
+        );
+        continue;
+      }
+      const peeled = peelAlias(seg);
+      let ref = parseStateNodeRef(peeled.seg);
+      if (!ref) {
+        const aliasResolved = nameAliasMap.get(peeled.seg.trim());
+        if (aliasResolved !== void 0) {
+          const existing = nodeMap.get(aliasResolved);
+          if (existing) {
+            const shape = existing.shape;
+            ref = {
+              id: aliasResolved,
+              label: existing.label,
+              shape
+            };
+          }
+        }
+      }
+      if (!ref) continue;
+      const node = getOrCreateNode(ref, lineNumber);
+      if (peeled.alias) nameAliasMap.set(peeled.alias, node.id);
+      if (pendingArrow !== null) {
+        const sourceId = lastNodeId ?? implicitSourceId;
+        if (sourceId) {
+          addEdge(sourceId, node.id, lineNumber, pendingArrow.label);
+        }
+        pendingArrow = null;
+      }
+      lastNodeId = node.id;
+    }
+    if (lastNodeId) {
+      indentStack.push({ nodeId: lastNodeId, indent });
+    }
+  }
+  if (groups.length > 0) result.groups = groups;
+  if (notes.length > 0) {
+    result.notes = notes;
+    resolveNotes(notes, result.nodes, result.diagnostics);
+  }
+  if (result.nodes.length === 0 && !result.error) {
+    const diag = makeDgmoError(
+      1,
+      "No states found. Add state transitions like: Idle -> Active"
+    );
+    result.diagnostics.push(diag);
+    result.error = formatDgmoError(diag);
+  }
+  if (result.nodes.length >= 2 && result.edges.length >= 1 && !result.error) {
+    const connectedIds = /* @__PURE__ */ new Set();
+    for (const edge of result.edges) {
+      connectedIds.add(edge.source);
+      connectedIds.add(edge.target);
+    }
+    for (const node of result.nodes) {
+      if (!connectedIds.has(node.id)) {
+        result.diagnostics.push(
+          makeDgmoError(
+            node.lineNumber,
+            `State "${node.label}" is not connected to any other state`,
+            "warning"
+          )
+        );
+      }
+    }
+  }
+  return result;
+}
+function looksLikeState(content) {
+  return content.includes("[*]") && content.includes("->");
+}
+
+export {
+  parseState,
+  looksLikeState
+};
+//# sourceMappingURL=chunk-3MQQNXPD.js.map