@diagrammo/dgmo 0.8.2 → 0.8.4

package/src/chart.ts

@@ -21,9 +21,9 @@ export interface ChartDataPoint {
 }
 
 export interface ChartEra {
-  start: string;        // exact category label, e.g. "'77"
-  end: string;          // exact category label, e.g. "'81"
-  label: string;        // display name, e.g. "Carter"
+  start: string; // exact category label, e.g. "'77"
+  end: string; // exact category label, e.g. "'81"
+  label: string; // display name, e.g. "Carter"
   color: string | null; // resolved CSS color, or null → palette default
   lineNumber: number;
 }
@@ -46,7 +46,9 @@ export interface ParsedChart {
   orientation?: 'horizontal' | 'vertical';
   color?: string;
   label?: string;
-  labels?: 'name' | 'value' | 'percent' | 'full';
+  noLabelName?: boolean;
+  noLabelValue?: boolean;
+  noLabelPercent?: boolean;
   data: ChartDataPoint[];
   eras?: ChartEra[];
   diagnostics: DgmoError[];
@@ -60,7 +62,11 @@ export interface ParsedChart {
 import { resolveColor } from './colors';
 import type { PaletteColors } from './palettes';
 import { makeDgmoError, formatDgmoError, suggest } from './diagnostics';
-import { extractColor, normalizeDirection, normalizeGroupedNumber, parseFirstLine, parseSeriesNames } from './utils/parsing';
+import {
+  extractColor,
+  parseFirstLine,
+  parseSeriesNames,
+} from './utils/parsing';
 
 // ============================================================
 // Parser
@@ -83,10 +89,21 @@ const TYPE_ALIASES: Record<string, ChartType> = {
 
 /** Known option keywords for the simple chart parser. */
 const KNOWN_OPTIONS = new Set([
-  'chart', 'title', 'series', 'xlabel', 'ylabel', 'label', 'labels',
-  'orientation', 'direction', 'color',
+  'chart',
+  'title',
+  'series',
+  'x-label',
+  'y-label',
+  'label',
+  'no-label-name',
+  'no-label-value',
+  'no-label-percent',
+  'color',
 ]);
 
+/** Known boolean options for the simple chart parser. */
+const KNOWN_BOOLEANS = new Set(['orientation-horizontal']);
+
 /**
  * Parses the simple chart text format into a structured object.
  *
@@ -106,7 +123,12 @@ export function parseChart(
 ): ParsedChart {
   const lines = content.split('\n');
   const parsedEras: ChartEra[] = [];
-  const rawEras: { start: string; afterArrow: string; color: string | null; lineNumber: number }[] = [];
+  const rawEras: {
+    start: string;
+    afterArrow: string;
+    color: string | null;
+    lineNumber: number;
+  }[] = [];
   const result: ParsedChart = {
     type: 'bar',
     data: [],
@@ -133,7 +155,12 @@ export function parseChart(
 
     // Reject legacy ## section headers
     if (/^#{2,}\s+/.test(trimmed)) {
-      result.diagnostics.push(makeDgmoError(lineNumber, `'${trimmed}' — ## syntax is no longer supported. Use [Group] containers instead`));
+      result.diagnostics.push(
+        makeDgmoError(
+          lineNumber,
+          `'${trimmed}' — ## syntax is no longer supported. Use [Group] containers instead`
+        )
+      );
       continue;
     }
 
@@ -163,7 +190,11 @@ export function parseChart(
       }
       // If the first line is a single word (no spaces, no colon, no numbers),
       // treat it as an unrecognized chart type rather than falling through
-      if (!trimmed.includes(' ') && !trimmed.includes(':') && !/\d/.test(trimmed)) {
+      if (
+        !trimmed.includes(' ') &&
+        !trimmed.includes(':') &&
+        !/\d/.test(trimmed)
+      ) {
         let msg = `Unsupported chart type: ${trimmed}. Supported types: ${[...VALID_TYPES].join(', ')}.`;
         const hint = suggest(trimmed.toLowerCase(), [...VALID_TYPES]);
         if (hint) msg += ` ${hint}`;
@@ -173,7 +204,9 @@ export function parseChart(
     }
 
     // Era line: era Day 1 -> Day 3 Rough Seas (blue) — colon-free
-    const eraMatch = trimmed.match(/^era\s+(.+?)\s*->\s*(.+?)(?:\s*\(([^)]+)\))?\s*$/);
+    const eraMatch = trimmed.match(
+      /^era\s+(.+?)\s*->\s*(.+?)(?:\s*\(([^)]+)\))?\s*$/
+    );
     if (eraMatch) {
       // Store start and raw afterArrow — resolved against data labels after parsing
       const afterArrow = eraMatch[2].trim();
@@ -191,7 +224,17 @@ export function parseChart(
 
     // Extract first token to check for known options
     const spaceIdx = trimmed.indexOf(' ');
-    const firstToken = (spaceIdx >= 0 ? trimmed.substring(0, spaceIdx) : trimmed).toLowerCase();
+    const firstToken = (
+      spaceIdx >= 0 ? trimmed.substring(0, spaceIdx) : trimmed
+    ).toLowerCase();
+
+    // Bare boolean options (e.g. orientation-horizontal)
+    if (KNOWN_BOOLEANS.has(firstToken) && spaceIdx < 0) {
+      if (firstToken === 'orientation-horizontal') {
+        result.orientation = 'horizontal';
+      }
+      continue;
+    }
 
     // Known option with a value
     if (KNOWN_OPTIONS.has(firstToken) && spaceIdx >= 0) {
@@ -217,13 +260,13 @@ export function parseChart(
         continue;
       }
 
-      if (firstToken === 'xlabel') {
+      if (firstToken === 'x-label') {
         result.xlabel = value;
         result.xlabelLineNumber = lineNumber;
         continue;
       }
 
-      if (firstToken === 'ylabel') {
+      if (firstToken === 'y-label') {
         result.ylabel = value;
         result.ylabelLineNumber = lineNumber;
         continue;
@@ -234,29 +277,6 @@ export function parseChart(
         continue;
       }
 
-      if (firstToken === 'labels') {
-        const v = value.toLowerCase();
-        if (v === 'name' || v === 'value' || v === 'percent' || v === 'full') {
-          result.labels = v;
-        }
-        continue;
-      }
-
-      if (firstToken === 'orientation' || firstToken === 'direction') {
-        // Only bar and bar-stacked support orientation (axis swapping)
-        if (result.type === 'bar' || result.type === 'bar-stacked') {
-          const vLower = value.toLowerCase();
-          if (vLower === 'horizontal' || vLower === 'vertical') {
-            result.orientation = vLower;
-          } else {
-            const dir = normalizeDirection(value);
-            if (dir === 'LR') result.orientation = 'horizontal';
-            else if (dir === 'TB') result.orientation = 'vertical';
-          }
-        }
-        continue;
-      }
-
       if (firstToken === 'color') {
         result.color = resolveColor(value.trim(), palette) ?? undefined;
         continue;
@@ -271,11 +291,26 @@ export function parseChart(
           result.seriesNames = parsed.names;
           result.seriesNameLineNumbers = parsed.nameLineNumbers;
         }
-        if (parsed.nameColors.some(Boolean)) result.seriesNameColors = parsed.nameColors;
+        if (parsed.nameColors.some(Boolean))
+          result.seriesNameColors = parsed.nameColors;
         continue;
       }
     }
 
+    // Bare boolean options: no-label-name, no-label-value, no-label-percent
+    if (firstToken === 'no-label-name') {
+      result.noLabelName = true;
+      continue;
+    }
+    if (firstToken === 'no-label-value') {
+      result.noLabelValue = true;
+      continue;
+    }
+    if (firstToken === 'no-label-percent') {
+      result.noLabelPercent = true;
+      continue;
+    }
+
     // Bare "series" keyword with no value — collect indented names
     if (firstToken === 'series' && spaceIdx === -1) {
       const parsed = parseSeriesNames('', lines, i, palette);
@@ -286,16 +321,22 @@ export function parseChart(
         result.seriesNames = parsed.names;
         result.seriesNameLineNumbers = parsed.nameLineNumbers;
       }
-      if (parsed.nameColors.some(Boolean)) result.seriesNameColors = parsed.nameColors;
+      if (parsed.nameColors.some(Boolean))
+        result.seriesNameColors = parsed.nameColors;
       continue;
     }
 
     // Data row: parse from the right — rightmost numeric token(s) = value(s), everything left = label
     // Supports comma-separated multi-values: "Jan 100, 200, 300"
+    // Supports space-separated multi-values when series are defined: "Jan 100 200 300"
     // Supports comma-grouped numbers: "Revenue 1,200, 1,500" → [1200, 1500]
-    const dataValues = parseDataRowValues(trimmed);
+    const multiValue = (result.seriesNames?.length ?? 0) >= 2;
+    const dataValues = parseDataRowValues(trimmed, { multiValue });
     if (dataValues) {
-      const { label: rawLabel, color: pointColor } = extractColor(dataValues.label, palette);
+      const { label: rawLabel, color: pointColor } = extractColor(
+        dataValues.label,
+        palette
+      );
       const [first, ...rest] = dataValues.values;
       result.data.push({
         label: rawLabel,
@@ -304,7 +345,14 @@ export function parseChart(
         ...(pointColor && { color: pointColor }),
         lineNumber,
       });
+      continue;
     }
+
+    // Catch-all: nothing matched this line
+    let msg = `Unexpected line: '${trimmed}'.`;
+    const hint = suggest(firstToken, [...KNOWN_OPTIONS, ...KNOWN_BOOLEANS]);
+    if (hint) msg += ` ${hint}`;
+    result.diagnostics.push(makeDgmoError(lineNumber, msg, 'warning'));
   }
 
   // Resolve raw eras against known data labels (longest-prefix match for multi-word labels)
@@ -329,7 +377,13 @@ export function parseChart(
       end = words[0];
       label = words.slice(1).join(' ');
     }
-    parsedEras.push({ start: raw.start, end, label, color: raw.color, lineNumber: raw.lineNumber });
+    parsedEras.push({
+      start: raw.start,
+      end,
+      label,
+      color: raw.color,
+      lineNumber: raw.lineNumber,
+    });
   }
 
   // Eras are only valid for line, multi-line (aliased to 'line'), and area chart types
@@ -353,7 +407,10 @@ export function parseChart(
   }
 
   if (!result.error && result.type === 'bar-stacked' && !result.seriesNames) {
-    setChartError(1, 'Chart type "bar-stacked" requires multiple series names. Use: series Name1, Name2, Name3');
+    setChartError(
+      1,
+      'Chart type "bar-stacked" requires multiple series names. Use: series Name1, Name2, Name3'
+    );
   }
 
   if (!result.error && result.seriesNames) {
@@ -361,7 +418,10 @@ export function parseChart(
     for (const dp of result.data) {
       const actualCount = 1 + (dp.extraValues?.length ?? 0);
       if (actualCount !== expectedCount) {
-        warn(dp.lineNumber, `Data point "${dp.label}" has ${actualCount} value(s), but ${expectedCount} series defined. Each row must have ${expectedCount} comma-separated values.`);
+        warn(
+          dp.lineNumber,
+          `Data point "${dp.label}" has ${actualCount} value(s), but ${expectedCount} series defined. Each row must have ${expectedCount} values.`
+        );
       }
     }
     // Filter out mismatched data points so renderers get clean data
@@ -380,20 +440,22 @@ export function parseChart(
 
 /**
  * Parse a data row line: everything before the last numeric token(s) is the label,
- * numeric tokens at the end are the values. Supports comma-separated multi-values
- * and comma-grouped numbers (e.g., "1,087").
+ * numeric tokens at the end are the values. Supports comma-separated multi-values,
+ * space-separated multi-values, and comma-grouped numbers (e.g., "1,087").
  *
  * Examples:
- *   "Jan 120"           → { label: "Jan", values: [120] }
- *   "North America 250" → { label: "North America", values: [250] }
- *   "Region 5 300"      → { label: "Region 5", values: [300] }
- *   "Q1 10, 20, 30"     → { label: "Q1", values: [10, 20, 30] }
- *   "Revenue 1,200"     → { label: "Revenue", values: [1200] }
+ *   "Jan 120"             → { label: "Jan", values: [120] }
+ *   "North America 250"   → { label: "North America", values: [250] }
+ *   "Q1 10, 20, 30"       → { label: "Q1", values: [10, 20, 30] }
+ *   "Q1 10 20 30"         → { label: "Q1", values: [10, 20, 30] }
+ *   "Revenue 1,200"       → { label: "Revenue", values: [1200] }
+ *   "Revenue 3,984,078.65"→ { label: "Revenue", values: [3984078.65] }
  *
  * Returns null if the line has no numeric value at the end.
  */
 export function parseDataRowValues(
   line: string,
+  options?: { multiValue?: boolean }
 ): { label: string; values: number[] } | null {
   // First, normalize comma-grouped numbers: replace patterns like "1,087" with "1087"
   // We need to be careful: commas also separate multi-values.
@@ -407,11 +469,12 @@ export function parseDataRowValues(
   const normalized: string[] = [];
   for (let i = 0; i < segments.length; i++) {
     const seg = segments[i].trim();
-    // Check if this segment is a continuation of a grouped number
-    // A continuation looks like exactly 3 digits and follows a segment ending in digits.
+    // Check if this segment is a continuation of a grouped number.
+    // A continuation starts with exactly 3 digits (possibly followed by a decimal like ".65")
+    // and follows a segment ending in digits.
     // Grouped numbers have NO space around the comma (e.g., "1,087"), so skip if
     // the raw segment has leading whitespace (e.g., ", 350" is a value separator).
-    if (i > 0 && /^\d{3}$/.test(seg) && !/^\s/.test(segments[i])) {
+    if (i > 0 && /^\d{3}(\.\d+)?$/.test(seg) && !/^\s/.test(segments[i])) {
       const prevSeg = normalized[normalized.length - 1].trimEnd();
       // Check if previous segment ends with a number (1-3 digits at the end of the last token)
       if (/\d{1,3}$/.test(prevSeg)) {
@@ -420,7 +483,6 @@ export function parseDataRowValues(
         const prevMatch = prevSeg.match(/(\d{1,3})$/);
         if (prevMatch) {
           // Tentatively merge and validate
-          const mergedTail = prevMatch[1] + ',' + seg;
           // Build full token by looking at what's left in normalized
           // Simple approach: just merge
           normalized[normalized.length - 1] = prevSeg + seg;
@@ -462,7 +524,11 @@ export function parseDataRowValues(
       const lastSpaceIdx = firstPart.lastIndexOf(' ');
       if (lastSpaceIdx >= 0) {
         const possibleFirstVal = firstPart.substring(lastSpaceIdx + 1).trim();
-        if (possibleFirstVal && !isNaN(parseFloat(possibleFirstVal)) && isFinite(Number(possibleFirstVal))) {
+        if (
+          possibleFirstVal &&
+          !isNaN(parseFloat(possibleFirstVal)) &&
+          isFinite(Number(possibleFirstVal))
+        ) {
           const label = firstPart.substring(0, lastSpaceIdx).trim();
           if (label) {
             const values = [parseFloat(possibleFirstVal)];
@@ -476,16 +542,35 @@ export function parseDataRowValues(
     }
   }
 
-  // No commas or comma parsing didn't work — split by spaces from right
-  // Last space-separated token that is numeric = the value
-  const lastSpaceIdx = rebuilt.lastIndexOf(' ');
-  if (lastSpaceIdx < 0) return null;
+  // No commas or comma parsing didn't work — split by spaces from right.
+  // When multiValue is enabled, walk backward collecting consecutive numeric tokens.
+  // Otherwise (default), take only the last token — preserving labels that contain
+  // numbers (e.g., "Region 5 300" → label "Region 5", value 300).
+  const tokens = rebuilt.split(/\s+/);
+  if (tokens.length < 2) return null;
+
+  if (options?.multiValue) {
+    const values: number[] = [];
+    let idx = tokens.length - 1;
+    while (idx >= 1) {
+      const tok = tokens[idx];
+      const num = parseFloat(tok);
+      if (isNaN(num) || !isFinite(Number(tok))) break;
+      values.unshift(num);
+      idx--;
+    }
+    if (values.length === 0) return null;
+    const label = tokens.slice(0, idx + 1).join(' ');
+    if (!label) return null;
+    return { label, values };
+  }
 
-  const possibleValue = rebuilt.substring(lastSpaceIdx + 1).trim();
-  const num = parseFloat(possibleValue);
-  if (isNaN(num) || !isFinite(Number(possibleValue))) return null;
+  // Single-value mode: only the last space-separated token
+  const lastToken = tokens[tokens.length - 1];
+  const num = parseFloat(lastToken);
+  if (isNaN(num) || !isFinite(Number(lastToken))) return null;
 
-  const label = rebuilt.substring(0, lastSpaceIdx).trim();
+  const label = tokens.slice(0, -1).join(' ');
   if (!label) return null;
 
   return { label, values: [num] };

package/src/class/parser.ts

@@ -1,7 +1,11 @@
 import { resolveColor } from '../colors';
 import type { PaletteColors } from '../palettes';
-import { makeDgmoError, formatDgmoError, suggest } from '../diagnostics';
-import { measureIndent, parseFirstLine, OPTION_NOCOLON_RE } from '../utils/parsing';
+import { makeDgmoError, formatDgmoError } from '../diagnostics';
+import {
+  measureIndent,
+  parseFirstLine,
+  OPTION_NOCOLON_RE,
+} from '../utils/parsing';
 import type {
   ParsedClassDiagram,
   ClassNode,
@@ -30,12 +34,16 @@ function classId(name: string): string {
 const CLASS_DECL_RE =
   /^(?:(abstract|interface|enum)\s+)?([A-Z][A-Za-z0-9_]*)(?:\s+(extends|implements)\s+([A-Z][A-Za-z0-9_]*))?(?:\s+\[(abstract|interface|enum)\])?(?:\s+\(([^)]+)\))?\s*$/;
 
-// Relationship — arrow syntax:
-// ClassName --|> TargetClass label  (new: space-separated)
-// ClassName --|> TargetClass : label  (old: colon-separated, kept for transition)
+// Relationship — arrow syntax (indented under source class):
+//   --|> TargetClass label  (space-separated)
+//   --|> TargetClass : label  (colon-separated, kept for transition)
 // Arrows: --|>  ..|>  *--  o--  ..>  ->
+const INDENT_REL_ARROW_RE =
+  /^(--\|>|\.\.\|>|\*--|o--|\.\.>|->)\s*([A-Z][A-Za-z0-9_]*)(?:\s+:?\s*(.+))?$/;
+
+// Legacy top-level relationship regex (used only for detection/rejection)
 const REL_ARROW_RE =
-  /^([A-Z][A-Za-z0-9_]*)\s*(--\|>|\.\.\|>|\*--|o--|\.\.\>|->)\s*([A-Z][A-Za-z0-9_]*)(?:\s+:?\s*(.+))?$/;
+  /^([A-Z][A-Za-z0-9_]*)\s*(--\|>|\.\.\|>|\*--|o--|\.\.>|->)\s*([A-Z][A-Za-z0-9_]*)(?:\s+:?\s*(.+))?$/;
 
 // Member line patterns
 const VISIBILITY_RE = /^([+\-#])\s*/;
@@ -156,7 +164,8 @@ export function parseClassDiagram(
     error: null,
   };
 
-  const fail = (line: number, message: string): ParsedClassDiagram => {
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  const _fail = (line: number, message: string): ParsedClassDiagram => {
     const diag = makeDgmoError(line, message);
     result.diagnostics.push(diag);
     result.error = formatDgmoError(diag);
@@ -211,9 +220,14 @@ export function parseClassDiagram(
       }
     }
 
-    // Space-separated options before content (new syntax): `color off`
+    // Space-separated options before content (new syntax): `no-auto-color`
     // Only match lines starting with a lowercase token (options), not uppercase (class names)
     if (!contentStarted && indent === 0 && /^[a-z]/.test(trimmed)) {
+      // Bare boolean option (single keyword, no value)
+      if (trimmed.toLowerCase() === 'no-auto-color') {
+        result.options['no-auto-color'] = 'on';
+        continue;
+      }
       const optMatch = trimmed.match(OPTION_NOCOLON_RE);
       if (optMatch) {
         const key = optMatch[1].toLowerCase();
@@ -226,8 +240,27 @@ export function parseClassDiagram(
       }
     }
 
-    // Indented lines = members of current class
+    // Indented lines = relationships or members of current class
     if (indent > 0 && currentClass) {
+      // Try indented relationship arrow: --|> TargetClass [label]
+      const indentRel = trimmed.match(INDENT_REL_ARROW_RE);
+      if (indentRel) {
+        const arrow = indentRel[1];
+        const targetName = indentRel[2];
+        const label = indentRel[3]?.trim();
+
+        getOrCreateClass(targetName, lineNumber);
+
+        result.relationships.push({
+          source: currentClass.id,
+          target: classId(targetName),
+          type: ARROW_TO_TYPE[arrow],
+          ...(label && { label }),
+          lineNumber,
+        });
+        continue;
+      }
+
       const member = parseMember(
         trimmed,
         lineNumber,
@@ -243,25 +276,19 @@ export function parseClassDiagram(
     currentClass = null;
     contentStarted = true;
 
-    // Try relationship — arrow syntax
+    // Reject top-level relationship arrows — must be indented under source class
     const relArrow = trimmed.match(REL_ARROW_RE);
     if (relArrow) {
       const sourceName = relArrow[1];
       const arrow = relArrow[2];
       const targetName = relArrow[3];
-      const label = relArrow[4]?.trim();
-
-      // Ensure both classes exist
-      getOrCreateClass(sourceName, lineNumber);
-      getOrCreateClass(targetName, lineNumber);
-
-      result.relationships.push({
-        source: classId(sourceName),
-        target: classId(targetName),
-        type: ARROW_TO_TYPE[arrow],
-        ...(label && { label }),
-        lineNumber,
-      });
+      result.diagnostics.push(
+        makeDgmoError(
+          lineNumber,
+          `Relationship "${sourceName} ${arrow} ${targetName}" must be indented under the source class "${sourceName}"`,
+          'warning'
+        )
+      );
       continue;
     }
 
@@ -297,17 +324,29 @@ export function parseClassDiagram(
       currentClass = node;
       continue;
     }
+
+    // Catch-all: nothing matched this line
+    result.diagnostics.push(
+      makeDgmoError(lineNumber, `Unexpected line: '${trimmed}'.`, 'warning')
+    );
   }
 
   // Validation
   if (result.classes.length === 0 && !result.error) {
-    const diag = makeDgmoError(1, 'No classes found. Add class declarations like "ClassName" or "ClassName [interface]".');
+    const diag = makeDgmoError(
+      1,
+      'No classes found. Add class declarations like "ClassName" or "ClassName [interface]".'
+    );
     result.diagnostics.push(diag);
     result.error = formatDgmoError(diag);
   }
 
   // Warn about isolated classes (not in any relationship)
-  if (result.classes.length >= 2 && result.relationships.length >= 1 && !result.error) {
+  if (
+    result.classes.length >= 2 &&
+    result.relationships.length >= 1 &&
+    !result.error
+  ) {
     const connectedIds = new Set<string>();
     for (const rel of result.relationships) {
       connectedIds.add(rel.source);
@@ -315,7 +354,13 @@ export function parseClassDiagram(
     }
     for (const cls of result.classes) {
       if (!connectedIds.has(cls.id)) {
-        result.diagnostics.push(makeDgmoError(cls.lineNumber, `Class "${cls.name}" is not connected to any other class`, 'warning'));
+        result.diagnostics.push(
+          makeDgmoError(
+            cls.lineNumber,
+            `Class "${cls.name}" is not connected to any other class`,
+            'warning'
+          )
+        );
       }
     }
   }
@@ -358,7 +403,9 @@ export function looksLikeClassDiagram(content: string): boolean {
         hasClassDecl = true;
       }
       // Check for old modifier pattern: ClassName [abstract|interface|enum]
-      if (/^[A-Z][A-Za-z0-9_]*\s+\[(abstract|interface|enum)\]/i.test(trimmed)) {
+      if (
+        /^[A-Z][A-Za-z0-9_]*\s+\[(abstract|interface|enum)\]/i.test(trimmed)
+      ) {
         hasModifier = true;
         hasClassDecl = true;
       }
@@ -380,6 +427,10 @@ export function looksLikeClassDiagram(content: string): boolean {
       if (/^[+\-#]?\s*\w+.*[:(]/.test(trimmed)) {
         hasIndentedMember = true;
       }
+      // Indented relationship arrows
+      if (INDENT_REL_ARROW_RE.test(trimmed)) {
+        hasRelationship = true;
+      }
     }
   }
 
@@ -409,7 +460,12 @@ export function extractSymbols(docText: string): DiagramSymbols {
   for (const rawLine of docText.split('\n')) {
     const line = rawLine.trim();
     // Skip old-style colon metadata and new-style first line / space-separated options
-    if (inMetadata && (/^[a-z-]+\s*:/i.test(line) || /^class(\s|$)/i.test(line))) continue;
+    if (
+      inMetadata &&
+      (/^[a-z-]+\s*:/i.test(line) || /^class(\s|$)/i.test(line))
+    )
+      continue;
+    if (inMetadata && line.toLowerCase() === 'no-auto-color') continue;
     if (inMetadata && /^[a-z]/.test(line) && OPTION_NOCOLON_RE.test(line)) {
       const key = line.match(OPTION_NOCOLON_RE)![1].toLowerCase();
       if (key !== 'abstract' && key !== 'interface' && key !== 'enum') continue;

package/src/class/renderer.ts

@@ -82,7 +82,7 @@ const CLASS_TYPE_MAP: Record<string, ClassLegendEntry> = {
 const CLASS_TYPE_ORDER = ['class', 'abstract', 'interface', 'enum'];
 
 function collectClassTypes(parsed: ParsedClassDiagram): ClassLegendEntry[] {
-  if (parsed.options?.color === 'off') return [];
+  if (parsed.options?.['no-auto-color']) return [];
 
   const present = new Set<string>();
   for (const c of parsed.classes) {
@@ -500,7 +500,7 @@ export function renderClassDiagram(
 
     const w = node.width;
     const h = node.height;
-    const colorOff = parsed.options?.color === 'off';
+    const colorOff = !!parsed.options?.['no-auto-color'];
     // When legend is collapsed, use neutral color for nodes without explicit color
     const neutralize = hasLegend && !isLegendExpanded && !node.color;
     const effectiveColor = neutralize ? palette.primary : node.color;