@diagrammo/dgmo 0.46.0 → 0.47.0

package/dist/chunk-LIOHW36Z.js

@@ -0,0 +1,469 @@
+import {
+  GRAPH_DX
+} from "./chunk-I46X5VUA.js";
+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 {
+  NAME_DIAGNOSTIC_CODES,
+  emit,
+  formatDgmoError,
+  makeDgmoError,
+  nameMergedMessage,
+  suggest
+} from "./chunk-CXK4DZH3.js";
+
+// src/graph/flowchart-parser.ts
+function nodeId(shape, label) {
+  return `${shape}:${normalizeName(label)}`;
+}
+function parseNodeRef(text) {
+  const t = text.trim();
+  if (!t) return null;
+  let m = t.match(/^\[\[([^\]]+)\]\]$/);
+  if (m) {
+    const label = m[1].trim();
+    return { id: nodeId("subroutine", label), label, shape: "subroutine" };
+  }
+  m = t.match(/^\[([^\]]+)~\]$/);
+  if (m) {
+    const label = m[1].trim();
+    return { id: nodeId("document", label), label, shape: "document" };
+  }
+  m = t.match(/^\[([^\]]+)\]$/);
+  if (m) {
+    const label = m[1].trim();
+    return { id: nodeId("process", label), label, shape: "process" };
+  }
+  m = t.match(/^\((.+)\)$/);
+  if (m) {
+    const label = m[1].trim();
+    return { id: nodeId("terminal", label), label, shape: "terminal" };
+  }
+  m = t.match(/^<([^>]+)>$/);
+  if (m) {
+    const label = m[1].trim();
+    return { id: nodeId("decision", label), label, shape: "decision" };
+  }
+  m = t.match(/^\/([^/]+)\/$/);
+  if (m) {
+    const label = m[1].trim();
+    return { id: nodeId("io", label), label, shape: "io" };
+  }
+  return null;
+}
+function parseNodeRefLoose(text) {
+  const t = text.trim();
+  const shapeRe = /^(\[\[.+?\]\]|\[.+?~\]|\[.+?\]|\(.+?\)|<.+?>|\/.+?\/)\s+(\S.*)$/;
+  const m = t.match(shapeRe);
+  if (!m) return null;
+  const ref = parseNodeRef(m[1]);
+  if (!ref) return null;
+  return { ref, trailing: m[2].trim() };
+}
+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 parseFlowchart(content, palette) {
+  const lines = content.split("\n");
+  const options = {};
+  const result = {
+    type: "flowchart",
+    direction: "TB",
+    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 contentStarted = false;
+  let firstLineParsed = false;
+  let prevLineLastNodeId = null;
+  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] };
+  }
+  const suffixWarnedLines = /* @__PURE__ */ new Set();
+  function warnUnsupportedSuffix(lineNumber, trailing) {
+    if (suffixWarnedLines.has(lineNumber)) return;
+    suffixWarnedLines.add(lineNumber);
+    result.diagnostics.push(
+      emit(GRAPH_DX.FLOWCHART_NODE_SUFFIX, lineNumber, { trailing })
+    );
+  }
+  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 }
+    };
+    nodeMap.set(key, node);
+    result.nodes.push(node);
+    return node;
+  }
+  function addEdge(sourceId, targetId, lineNumber, label) {
+    const edge = {
+      source: sourceId,
+      target: targetId,
+      lineNumber,
+      ...label && { label }
+    };
+    result.edges.push(edge);
+  }
+  function processContentLine(trimmed, lineNumber, indent) {
+    contentStarted = true;
+    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: length > 0 guarded by ternary.
+      indentStack[indentStack.length - 1].nodeId
+    ) : null;
+    const segments = splitArrows(trimmed);
+    const startsWithArrow = segments.length >= 2 && segments[0].trim() === "";
+    const effectiveSource = implicitSourceId ?? (startsWithArrow ? prevLineLastNodeId : null);
+    if (segments.length === 1) {
+      const peeled = peelAlias(segments[0]);
+      const ref = parseNodeRef(peeled.seg);
+      if (ref) {
+        const node = getOrCreateNode(ref, lineNumber);
+        if (peeled.alias) nameAliasMap.set(peeled.alias, node.id);
+        indentStack.push({ nodeId: node.id, indent });
+        return node.id;
+      }
+      const loose = parseNodeRefLoose(peeled.seg);
+      if (loose) {
+        warnUnsupportedSuffix(lineNumber, loose.trailing);
+        const node = getOrCreateNode(loose.ref, lineNumber);
+        indentStack.push({ nodeId: node.id, indent });
+        return node.id;
+      }
+      const aliasResolved = nameAliasMap.get(peeled.seg.trim());
+      if (aliasResolved !== void 0) {
+        indentStack.push({ nodeId: aliasResolved, indent });
+        return aliasResolved;
+      }
+      return null;
+    }
+    let lastNodeId = null;
+    let pendingArrow = null;
+    for (let i = 0; i < segments.length; i++) {
+      const seg = segments[i];
+      if (seg === "->" || /^-.+->$/.test(seg)) {
+        pendingArrow = parseArrowToken(
+          seg,
+          palette,
+          lineNumber,
+          result.diagnostics
+        );
+        continue;
+      }
+      const peeled = peelAlias(seg);
+      let ref = parseNodeRef(peeled.seg);
+      if (!ref) {
+        const aliasResolved = nameAliasMap.get(peeled.seg.trim());
+        if (aliasResolved !== void 0) {
+          const existing = nodeMap.get(aliasResolved);
+          if (existing) {
+            ref = {
+              id: aliasResolved,
+              label: existing.label,
+              shape: existing.shape
+            };
+          }
+        }
+      }
+      if (!ref) {
+        const loose = parseNodeRefLoose(peeled.seg);
+        if (loose) {
+          warnUnsupportedSuffix(lineNumber, loose.trailing);
+          ref = loose.ref;
+        }
+      }
+      if (!ref) continue;
+      const node = getOrCreateNode(ref, lineNumber);
+      if (peeled.alias) nameAliasMap.set(peeled.alias, node.id);
+      if (pendingArrow !== null) {
+        const sourceId = lastNodeId ?? effectiveSource;
+        if (sourceId) {
+          addEdge(sourceId, node.id, lineNumber, pendingArrow.label);
+        }
+        pendingArrow = null;
+      } else if (lastNodeId === null && effectiveSource === null) {
+      }
+      lastNodeId = node.id;
+    }
+    if (pendingArrow !== null && lastNodeId === null && implicitSourceId) {
+    }
+    if (segments.length >= 2 && segments[0] === "" && implicitSourceId && lastNodeId) {
+    }
+    if (lastNodeId) {
+      indentStack.push({ nodeId: lastNodeId, indent });
+    }
+    return lastNodeId;
+  }
+  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 !== "flowchart") {
+          const allTypes = Array.from(ALL_CHART_TYPES);
+          let msg = `Expected chart type "flowchart", 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;
+    }
+    if (!contentStarted) {
+      if (/^direction-lr$/i.test(trimmed)) {
+        result.direction = "LR";
+        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 node colors are assigned automatically by shape; delete this line.',
+              "warning"
+            )
+          );
+          continue;
+        }
+        options[key] = value;
+        continue;
+      }
+    }
+    const lastId = processContentLine(trimmed, lineNumber, indent);
+    if (lastId) prevLineLastNodeId = lastId;
+  }
+  if (result.nodes.length === 0 && !result.error) {
+    const diag = makeDgmoError(
+      1,
+      "No nodes found. Add flowchart content with shape syntax like [Process] or (Start)."
+    );
+    result.diagnostics.push(diag);
+    result.error = formatDgmoError(diag);
+  }
+  if (notes.length > 0) {
+    result.notes = notes;
+    resolveNotes(notes, result.nodes, result.diagnostics);
+  }
+  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,
+            `Node "${node.label}" is not connected to any other node`,
+            "warning"
+          )
+        );
+      }
+    }
+  }
+  return result;
+}
+function looksLikeFlowchart(content) {
+  if (!content.includes("->")) return false;
+  const hasShapeDelimiter = /\[[^\]]+\]/.test(content) || /\([^)]+\)/.test(content) || /<[^>]+>/.test(content) || /\/[^/]+\//.test(content);
+  if (!hasShapeDelimiter) return false;
+  const shapeNearArrow = /[\])][ \t]*-.*->/.test(content) || // shape ] or ) followed by arrow
+  /->[ \t]*[[(</]/.test(content);
+  return shapeNearArrow;
+}
+var NODE_ID_RE = /^([a-zA-Z_][\w-]*)[\s([</{]/;
+function extractSymbols(docText) {
+  const entities = [];
+  let inMetadata = true;
+  for (const rawLine of docText.split("\n")) {
+    const line = rawLine.trim();
+    if (inMetadata && (/^[a-z-]+\s*:/i.test(line) || /^[a-z-]+\s+\S/i.test(line)))
+      continue;
+    inMetadata = false;
+    if (line.length === 0 || /^\s/.test(rawLine)) continue;
+    const m = NODE_ID_RE.exec(line);
+    if (m && !entities.includes(m[1])) entities.push(m[1]);
+  }
+  return { kind: "flowchart", entities };
+}
+
+export {
+  parseFlowchart,
+  looksLikeFlowchart,
+  extractSymbols
+};
+//# sourceMappingURL=chunk-LIOHW36Z.js.map

package/dist/chunk-LP7EC4MI.js

@@ -0,0 +1,16 @@
+// src/utils/arrow-markers.ts
+function appendArrowheadMarkers(defs, opts) {
+  const { idPrefix, width, height, baseFill, colors } = opts;
+  const appendMarker = (id, fill) => {
+    defs.append("marker").attr("id", id).attr("viewBox", `0 0 ${width} ${height}`).attr("refX", width).attr("refY", height / 2).attr("markerWidth", width).attr("markerHeight", height).attr("orient", "auto").append("polygon").attr("points", `0,0 ${width},${height / 2} 0,${height}`).attr("fill", fill);
+  };
+  appendMarker(`${idPrefix}-arrow`, baseFill);
+  for (const color of colors ?? []) {
+    appendMarker(`${idPrefix}-arrow-${color.replace("#", "")}`, color);
+  }
+}
+
+export {
+  appendArrowheadMarkers
+};
+//# sourceMappingURL=chunk-LP7EC4MI.js.map