@diagrammo/dgmo 0.3.2 → 0.4.1

package/src/sequence/parser.ts

@@ -53,18 +53,13 @@ export interface SequenceParticipant {
 
 /**
  * A message between two participants.
- * Placeholder for future stories — included in the interface now for completeness.
  */
 export interface SequenceMessage {
   from: string;
   to: string;
   label: string;
-  returnLabel?: string;
   lineNumber: number;
   async?: boolean;
-  bidirectional?: boolean;
-  /** Standalone return — the message itself IS a return (dashed arrow, no call). */
-  standaloneReturn?: boolean;
 }
 
 /**
@@ -164,70 +159,13 @@ const GROUP_HEADING_PATTERN = /^##\s+(.+?)(?:\(([^)]+)\))?\s*$/;
 // Section divider pattern — "== Label ==", "== Label(color) ==", or "== Label" (trailing == optional)
 const SECTION_PATTERN = /^==\s+(.+?)(?:\s*==)?\s*$/;
 
-// Arrow pattern for sequence inference — "A -> B: message", "A ~> B: message",
-// "A -label-> B", "A ~label~> B", "A <-> B", "A <~> B"
-const ARROW_PATTERN = /\S+\s*(?:<->|<~>|->|~>|-\S+->|~\S+~>|<-\S+->|<~\S+~>)\s*\S+/;
-
-// <- return syntax: "Login <- 200 OK"
-const ARROW_RETURN_PATTERN = /^(.+?)\s*<-\s*(.+)$/;
-
-// UML method(args): returnType syntax: "getUser(id): UserObj"
-const UML_RETURN_PATTERN = /^(\w+\([^)]*\))\s*:\s*(.+)$/;
+// Arrow pattern for sequence inference — detects any arrow form
+const ARROW_PATTERN = /\S+\s*(?:<-\S+-|<~\S+~|-\S+->|~\S+~>|->|~>|<-|<~)\s*\S+/;
 
 // Note patterns — "note: text", "note right of API: text", "note left of User"
 const NOTE_SINGLE = /^note(?:\s+(right|left)\s+of\s+(\S+))?\s*:\s*(.+)$/i;
 const NOTE_MULTI = /^note(?:\s+(right|left)\s+of\s+([^\s:]+))?\s*:?\s*$/i;
 
-/**
- * Extract return label from a message label string.
- * Priority: `<-` syntax first, then UML `method(): return` syntax,
- * then shorthand ` : ` separator (splits on last occurrence).
- */
-function parseReturnLabel(rawLabel: string): {
-  label: string;
-  returnLabel?: string;
-  standaloneReturn?: boolean;
-} {
-  if (!rawLabel) return { label: '' };
-
-  // Standalone return: label starts with `<-` (no forward label)
-  const standaloneMatch = rawLabel.match(/^<-\s*(.*)$/);
-  if (standaloneMatch) {
-    return {
-      label: standaloneMatch[1].trim(),
-      standaloneReturn: true,
-    };
-  }
-
-  // Check <- syntax first (separates forward label from return label)
-  const arrowReturn = rawLabel.match(ARROW_RETURN_PATTERN);
-  if (arrowReturn) {
-    return { label: arrowReturn[1].trim(), returnLabel: arrowReturn[2].trim() };
-  }
-
-  // Check UML method(args): returnType syntax
-  const umlReturn = rawLabel.match(UML_RETURN_PATTERN);
-  if (umlReturn) {
-    return { label: umlReturn[1].trim(), returnLabel: umlReturn[2].trim() };
-  }
-
-  // Shorthand colon return syntax (split on last ":")
-  // Skip if the colon is part of a URL scheme (followed by //)
-  const lastColon = rawLabel.lastIndexOf(':');
-  if (lastColon > 0 && lastColon < rawLabel.length - 1) {
-    const afterColon = rawLabel.substring(lastColon + 1);
-    if (!afterColon.startsWith('//')) {
-      const reqPart = rawLabel.substring(0, lastColon).trim();
-      const resPart = afterColon.trim();
-      if (reqPart && resPart) {
-        return { label: reqPart, returnLabel: resPart };
-      }
-    }
-  }
-
-  return { label: rawLabel };
-}
-
 /**
  * Parse a .dgmo file with `chart: sequence` into a structured representation.
  */
@@ -365,7 +303,7 @@ export function parseSequenceDgmo(content: string): ParsedSequenceDgmo {
     // Parse header key: value lines (always top-level)
     // Skip 'note' lines — parsed in the indent-aware section below
     const colonIndex = trimmed.indexOf(':');
-    if (colonIndex > 0 && !trimmed.includes('->') && !trimmed.includes('~>')) {
+    if (colonIndex > 0 && !trimmed.includes('->') && !trimmed.includes('~>') && !trimmed.includes('<-') && !trimmed.includes('<~')) {
       const key = trimmed.substring(0, colonIndex).trim().toLowerCase();
       if (key === 'note' || key.startsWith('note ')) {
         // Fall through to indent-aware note parsing below
@@ -522,7 +460,7 @@ export function parseSequenceDgmo(content: string): ParsedSequenceDgmo {
       continue;
     }
 
-    // ---- Labeled arrows: -label->, ~label~>, <-label->, <~label~> ----
+    // ---- Labeled arrows: -label->, ~label~> ----
     // Must be checked BEFORE plain arrow patterns to avoid partial matches
     const labeledArrow = parseArrow(trimmed);
     if (labeledArrow && 'error' in labeledArrow) {
@@ -531,17 +469,15 @@ export function parseSequenceDgmo(content: string): ParsedSequenceDgmo {
     }
     if (labeledArrow) {
       contentStarted = true;
-      const { from, to, label, async: isAsync, bidirectional } = labeledArrow;
+      const { from, to, label, async: isAsync } = labeledArrow;
       lastMsgFrom = from;
 
       const msg: SequenceMessage = {
         from,
         to,
         label,
-        returnLabel: undefined,
         lineNumber,
         ...(isAsync ? { async: true } : {}),
-        ...(bidirectional ? { bidirectional: true } : {}),
       };
       result.messages.push(msg);
       currentContainer().push(msg);
@@ -566,89 +502,73 @@ export function parseSequenceDgmo(content: string): ParsedSequenceDgmo {
       continue;
     }
 
-    // ---- Plain bidi arrows: <-> and <~> ----
-    // Must be checked BEFORE unidirectional plain arrows
-    const bidiSyncMatch = trimmed.match(
-      /^(\S+)\s*<->\s*([^\s:]+)\s*(?::\s*(.+))?$/
+    // ---- Error: old colon-postfix syntax (A -> B: msg) ----
+    const colonPostfixSync = trimmed.match(
+      /^(\S+)\s*->\s*([^\s:]+)\s*:\s*(.+)$/
     );
-    const bidiAsyncMatch = trimmed.match(
-      /^(\S+)\s*<~>\s*([^\s:]+)\s*(?::\s*(.+))?$/
+    const colonPostfixAsync = trimmed.match(
+      /^(\S+)\s*~>\s*([^\s:]+)\s*:\s*(.+)$/
     );
-    const bidiMatch = bidiSyncMatch || bidiAsyncMatch;
-    if (bidiMatch) {
-      contentStarted = true;
-      const from = bidiMatch[1];
-      const to = bidiMatch[2];
-      lastMsgFrom = from;
-      const rawLabel = bidiMatch[3]?.trim() || '';
-      const isBidiAsync = !!bidiAsyncMatch;
-
-      const msg: SequenceMessage = {
-        from,
-        to,
-        label: rawLabel,
+    const colonPostfix = colonPostfixSync || colonPostfixAsync;
+    if (colonPostfix) {
+      const a = colonPostfix[1];
+      const b = colonPostfix[2];
+      const msg = colonPostfix[3].trim();
+      const arrowChar = colonPostfixAsync ? '~' : '-';
+      const arrowEnd = colonPostfixAsync ? '~>' : '->';
+      pushError(
         lineNumber,
-        bidirectional: true,
-        ...(isBidiAsync ? { async: true } : {}),
-      };
-      result.messages.push(msg);
-      currentContainer().push(msg);
-
-      if (!result.participants.some((p) => p.id === from)) {
-        result.participants.push({
-          id: from,
-          label: from,
-          type: inferParticipantType(from),
-          lineNumber,
-        });
-      }
-      if (!result.participants.some((p) => p.id === to)) {
-        result.participants.push({
-          id: to,
-          label: to,
-          type: inferParticipantType(to),
-          lineNumber,
-        });
-      }
+        `Colon syntax is no longer supported. Use '${a} ${arrowChar}${msg}${arrowEnd} ${b}' instead`
+      );
       continue;
     }
 
-    // Match ~> (async arrow) or -> (sync arrow)
-    let isAsync = false;
-    const asyncArrowMatch = trimmed.match(
-      /^(\S+)\s*~>\s*([^\s:]+)\s*(?::\s*(.+))?$/
-    );
-    const syncArrowMatch = trimmed.match(
-      /^(\S+)\s*->\s*([^\s:]+)\s*(?::\s*(.+))?$/
+    // ---- Error: plain bidirectional arrows (A <-> B, A <~> B) ----
+    const bidiPlainMatch = trimmed.match(
+      /^(\S+)\s*(?:<->|<~>)\s*(\S+)/
     );
-    const arrowMatch = asyncArrowMatch || syncArrowMatch;
-    if (asyncArrowMatch) isAsync = true;
+    if (bidiPlainMatch) {
+      pushError(
+        lineNumber,
+        "Bidirectional arrows are no longer supported. Use two separate lines: 'A -msg-> B' and 'B -msg-> A'"
+      );
+      continue;
+    }
+
+    // ---- Deprecated bare return arrows: A <- B, A <~ B ----
+    const bareReturnSync = trimmed.match(/^(\S+)\s+<-\s+(\S+)$/);
+    const bareReturnAsync = trimmed.match(/^(\S+)\s+<~\s+(\S+)$/);
+    const bareReturn = bareReturnSync || bareReturnAsync;
+    if (bareReturn) {
+      const to = bareReturn[1];
+      const from = bareReturn[2];
+      pushError(
+        lineNumber,
+        `Left-pointing arrows are no longer supported. Write '${from} -> ${to}' instead`
+      );
+      continue;
+    }
 
-    if (arrowMatch) {
+    // ---- Bare (unlabeled) call arrows: A -> B, A ~> B ----
+    const bareCallSync = trimmed.match(/^(\S+)\s*->\s*(\S+)$/);
+    const bareCallAsync = trimmed.match(/^(\S+)\s*~>\s*(\S+)$/);
+    const bareCall = bareCallSync || bareCallAsync;
+    if (bareCall) {
       contentStarted = true;
-      const from = arrowMatch[1];
-      const to = arrowMatch[2];
+      const from = bareCall[1];
+      const to = bareCall[2];
       lastMsgFrom = from;
-      const rawLabel = arrowMatch[3]?.trim() || '';
-
-      // Extract return label — skip for async messages
-      const { label, returnLabel, standaloneReturn } = isAsync
-        ? { label: rawLabel, returnLabel: undefined, standaloneReturn: undefined }
-        : parseReturnLabel(rawLabel);
 
       const msg: SequenceMessage = {
         from,
         to,
-        label,
-        returnLabel,
+        label: '',
         lineNumber,
-        ...(isAsync ? { async: true } : {}),
-        ...(standaloneReturn ? { standaloneReturn: true } : {}),
+        ...(bareCallAsync ? { async: true } : {}),
       };
       result.messages.push(msg);
       currentContainer().push(msg);
 
-      // Auto-register participants from message usage with type inference
       if (!result.participants.some((p) => p.id === from)) {
         result.participants.push({
           id: from,

package/src/sequence/renderer.ts

@@ -538,7 +538,6 @@ export interface RenderStep {
   label: string;
   messageIndex: number;
   async?: boolean;
-  bidirectional?: boolean;
 }
 
 /**
@@ -551,7 +550,6 @@ export function buildRenderSequence(messages: SequenceMessage[]): RenderStep[] {
   const stack: {
     from: string;
     to: string;
-    returnLabel?: string;
     messageIndex: number;
   }[] = [];
 
@@ -566,33 +564,11 @@ export function buildRenderSequence(messages: SequenceMessage[]): RenderStep[] {
         type: 'return',
         from: top.to,
         to: top.from,
-        label: top.returnLabel || '',
+        label: '',
         messageIndex: top.messageIndex,
       });
     }
 
-    // Standalone return: emit as a return step directly (no call, no stack).
-    // Also pop the matching pending call from the stack so it doesn't
-    // generate a duplicate empty return later.
-    if (msg.standaloneReturn) {
-      // Find and remove the stack entry this return satisfies
-      // (the pending call where from→to matches to→from of this return)
-      for (let si = stack.length - 1; si >= 0; si--) {
-        if (stack[si].from === msg.to && stack[si].to === msg.from) {
-          stack.splice(si, 1);
-          break;
-        }
-      }
-      steps.push({
-        type: 'return',
-        from: msg.from,
-        to: msg.to,
-        label: msg.label,
-        messageIndex: mi,
-      });
-      continue;
-    }
-
     // Emit call
     steps.push({
       type: 'call',
@@ -601,14 +577,8 @@ export function buildRenderSequence(messages: SequenceMessage[]): RenderStep[] {
       label: msg.label,
       messageIndex: mi,
       ...(msg.async ? { async: true } : {}),
-      ...(msg.bidirectional ? { bidirectional: true } : {}),
     });
 
-    // Bidirectional messages: no activation bar, no return
-    if (msg.bidirectional) {
-      continue;
-    }
-
     // Async messages: no return arrow, no activation on target
     if (msg.async) {
       continue;
@@ -620,7 +590,7 @@ export function buildRenderSequence(messages: SequenceMessage[]): RenderStep[] {
         type: 'return',
         from: msg.to,
         to: msg.from,
-        label: msg.returnLabel || '',
+        label: '',
         messageIndex: mi,
       });
     } else {
@@ -628,7 +598,6 @@ export function buildRenderSequence(messages: SequenceMessage[]): RenderStep[] {
       stack.push({
         from: msg.from,
         to: msg.to,
-        returnLabel: msg.returnLabel,
         messageIndex: mi,
       });
     }
@@ -641,7 +610,7 @@ export function buildRenderSequence(messages: SequenceMessage[]): RenderStep[] {
       type: 'return',
       from: top.to,
       to: top.from,
-      label: top.returnLabel || '',
+      label: '',
       messageIndex: top.messageIndex,
     });
   }
@@ -1368,42 +1337,6 @@ export function renderSequenceDiagram(
     .attr('stroke', palette.text)
     .attr('stroke-width', 1.2);
 
-  // Filled reverse arrowhead for bidirectional sync arrows (marker-start)
-  defs
-    .append('marker')
-    .attr('id', 'seq-arrowhead-reverse')
-    .attr('viewBox', `0 0 ${ARROWHEAD_SIZE} ${ARROWHEAD_SIZE}`)
-    .attr('refX', 0)
-    .attr('refY', ARROWHEAD_SIZE / 2)
-    .attr('markerWidth', ARROWHEAD_SIZE)
-    .attr('markerHeight', ARROWHEAD_SIZE)
-    .attr('orient', 'auto')
-    .append('polygon')
-    .attr(
-      'points',
-      `${ARROWHEAD_SIZE},0 0,${ARROWHEAD_SIZE / 2} ${ARROWHEAD_SIZE},${ARROWHEAD_SIZE}`
-    )
-    .attr('fill', palette.text);
-
-  // Open reverse arrowhead for bidirectional async arrows (marker-start)
-  defs
-    .append('marker')
-    .attr('id', 'seq-arrowhead-async-reverse')
-    .attr('viewBox', `0 0 ${ARROWHEAD_SIZE} ${ARROWHEAD_SIZE}`)
-    .attr('refX', 0)
-    .attr('refY', ARROWHEAD_SIZE / 2)
-    .attr('markerWidth', ARROWHEAD_SIZE)
-    .attr('markerHeight', ARROWHEAD_SIZE)
-    .attr('orient', 'auto')
-    .append('polyline')
-    .attr(
-      'points',
-      `${ARROWHEAD_SIZE},0 0,${ARROWHEAD_SIZE / 2} ${ARROWHEAD_SIZE},${ARROWHEAD_SIZE}`
-    )
-    .attr('fill', 'none')
-    .attr('stroke', palette.text)
-    .attr('stroke-width', 1.2);
-
   // Render title
   if (title) {
     const titleEl = svg
@@ -1958,12 +1891,7 @@ export function renderSequenceDiagram(
         const markerRef = step.async
           ? 'url(#seq-arrowhead-async)'
           : 'url(#seq-arrowhead)';
-        const markerStartRef = step.bidirectional
-          ? step.async
-            ? 'url(#seq-arrowhead-async-reverse)'
-            : 'url(#seq-arrowhead-reverse)'
-          : null;
-        const line = svg
+        svg
           .append('line')
           .attr('x1', x1)
           .attr('y1', y)
@@ -1979,12 +1907,6 @@ export function renderSequenceDiagram(
           )
           .attr('data-msg-index', String(step.messageIndex))
           .attr('data-step-index', String(i));
-        if (markerStartRef) {
-          line.attr('marker-start', markerStartRef);
-        }
-        if (step.bidirectional && step.async) {
-          line.attr('stroke-dasharray', '6 4');
-        }
 
         if (step.label) {
           const midX = (x1 + x2) / 2;

package/src/utils/arrows.ts

@@ -2,49 +2,70 @@
 // Shared Arrow Parsing Utility
 // ============================================================
 //
-// Labeled arrow syntax: `-label->`, `~label~>`, `<-label->`, `<~label~>`
-// Used by sequence, C4, and init-status parsers.
+// Labeled arrow syntax (always left-to-right):
+//   Sync:  `-label->`
+//   Async: `~label~>`
 
 export interface ParsedArrow {
   from: string;
   to: string;
   label: string;
   async: boolean;
-  bidirectional: boolean;
 }
 
-// Bidi patterns checked FIRST — longer prefix avoids partial match
-const BIDI_SYNC_LABELED_RE = /^(\S+)\s+<-(.+)->\s+(\S+)$/;
-const BIDI_ASYNC_LABELED_RE = /^(\S+)\s+<~(.+)~>\s+(\S+)$/;
+// Forward (call) patterns
 const SYNC_LABELED_RE = /^(\S+)\s+-(.+)->\s+(\S+)$/;
 const ASYNC_LABELED_RE = /^(\S+)\s+~(.+)~>\s+(\S+)$/;
 
-const ARROW_CHARS = ['->', '~>', '<->', '<~>'];
+// Deprecated patterns — produce errors
+const RETURN_SYNC_LABELED_RE = /^(\S+)\s+<-(.+)-\s+(\S+)$/;
+const RETURN_ASYNC_LABELED_RE = /^(\S+)\s+<~(.+)~\s+(\S+)$/;
+const BIDI_SYNC_RE = /^(\S+)\s+<-(.+)->\s+(\S+)$/;
+const BIDI_ASYNC_RE = /^(\S+)\s+<~(.+)~>\s+(\S+)$/;
+
+const ARROW_CHARS = ['->', '~>'];
 
 /**
  * Try to parse a labeled arrow from a trimmed line.
  *
  * Returns:
  *  - `ParsedArrow` if matched and valid
- *  - `{ error: string }` if matched but label contains arrow chars
- *  - `null` if not a labeled arrow (caller should fall through to plain patterns)
+ *  - `{ error: string }` if matched but invalid (deprecated syntax)
+ *  - `null` if not a labeled arrow (caller should fall through to bare patterns)
  */
 export function parseArrow(
   line: string,
 ): ParsedArrow | { error: string } | null {
-  // Order: bidi first (longer prefix), then unidirectional
+  // Check bidi patterns first — return error
+  if (BIDI_SYNC_RE.test(line) || BIDI_ASYNC_RE.test(line)) {
+    return {
+      error:
+        "Bidirectional arrows are no longer supported. Use two separate lines: 'A -msg-> B' and 'B -msg-> A'",
+    };
+  }
+
+  // Check deprecated return arrow patterns — return error
+  if (RETURN_SYNC_LABELED_RE.test(line) || RETURN_ASYNC_LABELED_RE.test(line)) {
+    const m =
+      line.match(RETURN_SYNC_LABELED_RE) ??
+      line.match(RETURN_ASYNC_LABELED_RE);
+    const from = m![3];
+    const to = m![1];
+    const label = m![2].trim();
+    return {
+      error: `Left-pointing arrows are no longer supported. Write '${from} -${label}-> ${to}' instead`,
+    };
+  }
+
   const patterns: {
     re: RegExp;
     async: boolean;
-    bidirectional: boolean;
   }[] = [
-    { re: BIDI_SYNC_LABELED_RE, async: false, bidirectional: true },
-    { re: BIDI_ASYNC_LABELED_RE, async: true, bidirectional: true },
-    { re: SYNC_LABELED_RE, async: false, bidirectional: false },
-    { re: ASYNC_LABELED_RE, async: true, bidirectional: false },
+    { re: SYNC_LABELED_RE, async: false },
+    { re: ASYNC_LABELED_RE, async: true },
   ];
 
-  for (const { re, async: isAsync, bidirectional } of patterns) {
+  for (const { re, async: isAsync } of patterns) {
     const m = line.match(re);
     if (!m) continue;
 
@@ -67,7 +88,6 @@ export function parseArrow(
       to: m[3],
       label,
       async: isAsync,
-      bidirectional,
     };
   }
 

package/src/utils/parsing.ts

@@ -75,6 +75,49 @@ export function collectIndentedValues(
   return { values, newIndex: j - 1 };
 }
 
+/**
+ * Parse series names from a `series:` value or indented block, extracting
+ * optional per-name color suffixes. Shared between chart.ts and echarts.ts.
+ *
+ * Returns the parsed names, optional colors, and the raw series string
+ * (for single-series display), plus `newIndex` if indented values were consumed.
+ */
+export function parseSeriesNames(
+  value: string,
+  lines: string[],
+  lineIndex: number,
+  palette?: PaletteColors,
+): {
+  series: string;
+  names: string[];
+  nameColors: (string | undefined)[];
+  newIndex: number;
+} {
+  let rawNames: string[];
+  let series: string;
+  let newIndex = lineIndex;
+  if (value) {
+    series = value;
+    rawNames = value.split(',').map((s) => s.trim()).filter(Boolean);
+  } else {
+    const collected = collectIndentedValues(lines, lineIndex);
+    newIndex = collected.newIndex;
+    rawNames = collected.values;
+    series = rawNames.join(', ');
+  }
+  const names: string[] = [];
+  const nameColors: (string | undefined)[] = [];
+  for (const raw of rawNames) {
+    const extracted = extractColor(raw, palette);
+    nameColors.push(extracted.color);
+    names.push(extracted.label);
+  }
+  if (names.length === 1) {
+    series = names[0];
+  }
+  return { series, names, nameColors, newIndex };
+}
+
 /** Parse pipe-delimited metadata from segments after the first (name) segment. */
 export function parsePipeMetadata(
   segments: string[],