@diagrammo/dgmo 0.3.0 → 0.3.1

package/docs/language-reference.md

@@ -44,6 +44,41 @@ Set via CLI: `dgmo diagram.dgmo --palette catppuccin --theme dark`
 
 Text fields support: `*italic*`, `**bold**`, `` `code` ``, `[link text](url)`. Bare URLs are auto-linked.
 
+### Multi-line Values
+
+Properties that accept comma-separated lists (`series`, `columns`, `rows`, `x-axis`, `y-axis`) also accept an indented multi-line format. Leave the value after the colon empty and list each value on its own indented line:
+
+```
+// Single-line (still works)
+series: Rum, Spices, Silk, Gold
+
+// Multi-line equivalent
+series:
+  Rum
+  Spices
+  Silk
+  Gold
+```
+
+Multi-line blocks support blank lines and `//` comments within the block. Trailing commas on values are stripped for convenience.
+
+```
+series:
+  Rum (red)
+  Spices (green)
+  // gold last
+  Gold (yellow)
+```
+
+Works with `columns:` and `rows:` in heatmaps:
+
+```
+columns:
+  January
+  February
+  March
+```
+
 ---
 
 ## Chart Types

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@diagrammo/dgmo",
-  "version": "0.3.0",
+  "version": "0.3.1",
   "description": "DGMO diagram markup language — parser, renderer, and color system",
   "license": "MIT",
   "type": "module",

package/src/chart.ts

@@ -47,6 +47,7 @@ export interface ParsedChart {
 import { resolveColor } from './colors';
 import type { PaletteColors } from './palettes';
 import { makeDgmoError, formatDgmoError, suggest } from './diagnostics';
+import { collectIndentedValues } from './utils/parsing';
 
 // ============================================================
 // Parser
@@ -181,12 +182,17 @@ export function parseChart(
     }
 
     if (key === 'series') {
-      result.series = value;
-      // Parse comma-separated series names for multi-series chart types
-      const rawNames = value
-        .split(',')
-        .map((s) => s.trim())
-        .filter(Boolean);
+      // Parse series names — comma-separated on one line, or indented multi-line
+      let rawNames: string[];
+      if (value) {
+        result.series = value;
+        rawNames = value.split(',').map((s) => s.trim()).filter(Boolean);
+      } else {
+        const collected = collectIndentedValues(lines, i);
+        i = collected.newIndex;
+        rawNames = collected.values;
+        result.series = rawNames.join(', ');
+      }
       const names: string[] = [];
       const nameColors: (string | undefined)[] = [];
       for (const raw of rawNames) {

package/src/d3.ts

@@ -180,6 +180,7 @@ import type { PaletteColors } from './palettes';
 import { getSeriesColors } from './palettes';
 import type { DgmoError } from './diagnostics';
 import { makeDgmoError, formatDgmoError, suggest } from './diagnostics';
+import { collectIndentedValues } from './utils/parsing';
 
 // ============================================================
 // Timeline Date Helper
@@ -517,10 +518,18 @@ export function parseD3(content: string, palette?: PaletteColors): ParsedD3 {
 
     // Quadrant-specific parsing
     if (result.type === 'quadrant') {
-      // x-axis: Low, High
-      const xAxisMatch = line.match(/^x-axis\s*:\s*(.+)/i);
+      // x-axis: Low, High  — or indented multi-line
+      const xAxisMatch = line.match(/^x-axis\s*:\s*(.*)/i);
       if (xAxisMatch) {
-        const parts = xAxisMatch[1].split(',').map((s) => s.trim());
+        const val = xAxisMatch[1].trim();
+        let parts: string[];
+        if (val) {
+          parts = val.split(',').map((s) => s.trim());
+        } else {
+          const collected = collectIndentedValues(lines, i);
+          i = collected.newIndex;
+          parts = collected.values;
+        }
         if (parts.length >= 2) {
           result.quadrantXAxis = [parts[0], parts[1]];
           result.quadrantXAxisLineNumber = lineNumber;
@@ -528,10 +537,18 @@ export function parseD3(content: string, palette?: PaletteColors): ParsedD3 {
         continue;
       }
 
-      // y-axis: Low, High
-      const yAxisMatch = line.match(/^y-axis\s*:\s*(.+)/i);
+      // y-axis: Low, High  — or indented multi-line
+      const yAxisMatch = line.match(/^y-axis\s*:\s*(.*)/i);
       if (yAxisMatch) {
-        const parts = yAxisMatch[1].split(',').map((s) => s.trim());
+        const val = yAxisMatch[1].trim();
+        let parts: string[];
+        if (val) {
+          parts = val.split(',').map((s) => s.trim());
+        } else {
+          const collected = collectIndentedValues(lines, i);
+          i = collected.newIndex;
+          parts = collected.values;
+        }
         if (parts.length >= 2) {
           result.quadrantYAxis = [parts[0], parts[1]];
           result.quadrantYAxisLineNumber = lineNumber;

package/src/echarts.ts

@@ -88,6 +88,7 @@ import { getSeriesColors, getSegmentColors } from './palettes';
 import { parseChart } from './chart';
 import type { ParsedChart } from './chart';
 import { makeDgmoError, formatDgmoError, suggest } from './diagnostics';
+import { collectIndentedValues } from './utils/parsing';
 
 // ============================================================
 // Parser
@@ -193,11 +194,16 @@ export function parseEChart(
     }
 
     if (key === 'series') {
-      result.series = value;
-      const rawNames = value
-        .split(',')
-        .map((s) => s.trim())
-        .filter(Boolean);
+      let rawNames: string[];
+      if (value) {
+        result.series = value;
+        rawNames = value.split(',').map((s) => s.trim()).filter(Boolean);
+      } else {
+        const collected = collectIndentedValues(lines, i);
+        i = collected.newIndex;
+        rawNames = collected.values;
+        result.series = rawNames.join(', ');
+      }
       const names: string[] = [];
       const nameColors: (string | undefined)[] = [];
       for (const raw of rawNames) {
@@ -241,12 +247,24 @@ export function parseEChart(
 
     // Heatmap columns and rows headers
     if (key === 'columns') {
-      result.columns = value.split(',').map((s) => s.trim());
+      if (value) {
+        result.columns = value.split(',').map((s) => s.trim());
+      } else {
+        const collected = collectIndentedValues(lines, i);
+        i = collected.newIndex;
+        result.columns = collected.values;
+      }
       continue;
     }
 
     if (key === 'rows') {
-      result.rows = value.split(',').map((s) => s.trim());
+      if (value) {
+        result.rows = value.split(',').map((s) => s.trim());
+      } else {
+        const collected = collectIndentedValues(lines, i);
+        i = collected.newIndex;
+        result.rows = collected.values;
+      }
       continue;
     }
 

package/src/sequence/parser.ts

@@ -63,6 +63,8 @@ export interface SequenceMessage {
   lineNumber: number;
   async?: boolean;
   bidirectional?: boolean;
+  /** Standalone return — the message itself IS a return (dashed arrow, no call). */
+  standaloneReturn?: boolean;
 }
 
 /**
@@ -184,10 +186,20 @@ const NOTE_MULTI = /^note(?:\s+(right|left)\s+of\s+([^\s:]+))?\s*:?\s*$/i;
 function parseReturnLabel(rawLabel: string): {
   label: string;
   returnLabel?: string;
+  standaloneReturn?: boolean;
 } {
   if (!rawLabel) return { label: '' };
 
-  // Check <- syntax first
+  // 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() };
@@ -620,8 +632,8 @@ export function parseSequenceDgmo(content: string): ParsedSequenceDgmo {
       const rawLabel = arrowMatch[3]?.trim() || '';
 
       // Extract return label — skip for async messages
-      const { label, returnLabel } = isAsync
-        ? { label: rawLabel, returnLabel: undefined }
+      const { label, returnLabel, standaloneReturn } = isAsync
+        ? { label: rawLabel, returnLabel: undefined, standaloneReturn: undefined }
         : parseReturnLabel(rawLabel);
 
       const msg: SequenceMessage = {
@@ -631,6 +643,7 @@ export function parseSequenceDgmo(content: string): ParsedSequenceDgmo {
         returnLabel,
         lineNumber,
         ...(isAsync ? { async: true } : {}),
+        ...(standaloneReturn ? { standaloneReturn: true } : {}),
       };
       result.messages.push(msg);
       currentContainer().push(msg);

package/src/sequence/renderer.ts

@@ -571,6 +571,28 @@ export function buildRenderSequence(messages: SequenceMessage[]): RenderStep[] {
       });
     }
 
+    // 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',

package/src/utils/parsing.ts

@@ -44,6 +44,37 @@ export const TITLE_RE = /^title\s*:\s*(.+)/i;
 /** Matches `option: value` header lines. */
 export const OPTION_RE = /^([a-z][a-z0-9-]*)\s*:\s*(.+)$/i;
 
+/**
+ * Collect indented continuation lines as individual values.
+ * Used when a property like `series:` has an empty value — subsequent
+ * indented lines each become one value entry.
+ *
+ * - Skips blank lines and `//` comment lines within the block
+ * - Stops at first non-indented non-empty line (or EOF)
+ * - Strips trailing commas from values (user habit tolerance)
+ * - Returns `newIndex` so caller does `i = newIndex` and the loop's `i++` lands correctly
+ */
+export function collectIndentedValues(
+  lines: string[],
+  startIndex: number,
+): { values: string[]; newIndex: number } {
+  const values: string[] = [];
+  let j = startIndex + 1;
+  for (; j < lines.length; j++) {
+    const raw = lines[j];
+    const trimmed = raw.trim();
+    // Skip blank lines within the block
+    if (!trimmed) continue;
+    // Skip comment lines within the block
+    if (trimmed.startsWith('//')) continue;
+    // Stop at non-indented lines (first char is not whitespace)
+    if (raw[0] !== ' ' && raw[0] !== '\t') break;
+    // Strip trailing comma and collect
+    values.push(trimmed.replace(/,\s*$/, ''));
+  }
+  return { values, newIndex: j - 1 };
+}
+
 /** Parse pipe-delimited metadata from segments after the first (name) segment. */
 export function parsePipeMetadata(
   segments: string[],