@diagrammo/dgmo 0.7.3 → 0.8.0

package/src/utils/parsing.ts

@@ -7,6 +7,20 @@
 import { resolveColor } from '../colors';
 import type { PaletteColors } from '../palettes';
 
+// ── All known chart types ────────────────────────────────────
+/** Complete set of recognized chart type identifiers. */
+export const ALL_CHART_TYPES = new Set([
+  // data charts
+  'bar', 'line', 'pie', 'doughnut', 'area', 'polar-area', 'radar',
+  'bar-stacked', 'multi-line', 'scatter', 'sankey', 'chord', 'function',
+  'heatmap', 'funnel',
+  // visualizations
+  'slope', 'wordcloud', 'arc', 'timeline', 'venn', 'quadrant',
+  // diagrams
+  'sequence', 'flowchart', 'class', 'er', 'org', 'kanban', 'c4',
+  'initiative-status', 'state', 'sitemap', 'infra', 'gantt',
+]);
+
 /** Measure leading whitespace of a line, normalizing tabs to 4 spaces. */
 export function measureIndent(line: string): number {
   let indent = 0;
@@ -31,19 +45,210 @@ export function extractColor(
   const colorName = m[1].trim();
   return {
     label: label.substring(0, m.index!).trim(),
-    color: resolveColor(colorName, palette),
+    color: resolveColor(colorName, palette) ?? undefined,
   };
 }
 
-/** Matches `chart: <type>` header lines. */
+/** @deprecated Matches `chart: <type>` header lines. Remove after all parsers migrate. */
 export const CHART_TYPE_RE = /^chart\s*:\s*(.+)/i;
 
-/** Matches `title: <text>` header lines. */
+/** @deprecated Matches `title: <text>` header lines. Remove after all parsers migrate. */
 export const TITLE_RE = /^title\s*:\s*(.+)/i;
 
-/** Matches `option: value` header lines. */
+/** @deprecated Matches `option: value` header lines. Remove after all parsers migrate. */
 export const OPTION_RE = /^([a-z][a-z0-9-]*)\s*:\s*(.+)$/i;
 
+/** Matches `option value` header lines (space-separated, no colon). */
+export const OPTION_NOCOLON_RE = /^([a-z][a-z0-9-]*)\s+(.+)$/i;
+
+/** Matches `# GroupName` lines — alternate group notation. */
+export const GROUP_HASH_RE = /^#\s+(.+)$/;
+
+/** Matches `## ...` lines — parse error with helpful hint. */
+export const DOUBLE_HASH_RE = /^##\s/;
+
+// ── New shared utilities ─────────────────────────────────────
+
+/**
+ * Parse the first non-empty, non-comment line to extract chart type and optional title.
+ * The first token is matched against `ALL_CHART_TYPES`; the remainder is the title.
+ *
+ * Returns `null` if the first token is not a recognized chart type.
+ */
+export function parseFirstLine(
+  line: string,
+): { chartType: string; title: string | undefined } | null {
+  const trimmed = line.trim();
+  if (!trimmed || trimmed.startsWith('//')) return null;
+
+  // Try old-style `chart: type` first (for transition)
+  const oldMatch = trimmed.match(CHART_TYPE_RE);
+  if (oldMatch) {
+    const parts = oldMatch[1].trim();
+    // Could be `chart: gantt My Title` — first token is type
+    const spaceIdx = parts.indexOf(' ');
+    if (spaceIdx === -1) {
+      const ct = parts.toLowerCase();
+      return ALL_CHART_TYPES.has(ct) ? { chartType: ct, title: undefined } : null;
+    }
+    const ct = parts.substring(0, spaceIdx).toLowerCase();
+    if (ALL_CHART_TYPES.has(ct)) {
+      return { chartType: ct, title: parts.substring(spaceIdx + 1).trim() || undefined };
+    }
+    return null;
+  }
+
+  // New-style: first token is chart type, rest is title
+  const spaceIdx = trimmed.indexOf(' ');
+  if (spaceIdx === -1) {
+    const ct = trimmed.toLowerCase();
+    return ALL_CHART_TYPES.has(ct) ? { chartType: ct, title: undefined } : null;
+  }
+  const firstToken = trimmed.substring(0, spaceIdx).toLowerCase();
+  if (!ALL_CHART_TYPES.has(firstToken)) return null;
+  return { chartType: firstToken, title: trimmed.substring(spaceIdx + 1).trim() || undefined };
+}
+
+/** Result of `prescanOptions()` — options collected from a two-pass scan. */
+export interface PrescanResult {
+  /** Key-value options, e.g., `direction LR` → `{ direction: 'LR' }` */
+  options: Record<string, string>;
+  /** Presence-based boolean options, e.g., `critical-path` → Set('critical-path') */
+  booleans: Set<string>;
+  /** Negated booleans, e.g., `no-dependencies` → Set('dependencies') */
+  negated: Set<string>;
+}
+
+/**
+ * Pre-scan all lines to collect options that can appear anywhere in the file.
+ *
+ * For each non-indented, non-comment line:
+ * - If the first token is a known option key and the line has more tokens → key-value option
+ * - If the first token is a known boolean key (bare keyword) → boolean enabled
+ * - If the first token starts with `no-` and the rest is a known boolean → negated
+ *
+ * Comment handling: full comment lines (`// ...`) are skipped. Inline comments
+ * are stripped before extraction (`direction LR // override` → option `direction: LR`).
+ *
+ * @param lines All lines of the document
+ * @param knownOptions Set of recognized option key names (e.g., `direction`, `start`, `notation`)
+ * @param knownBooleans Set of recognized boolean option names (e.g., `critical-path`, `animate`)
+ */
+export function prescanOptions(
+  lines: string[],
+  knownOptions: Set<string>,
+  knownBooleans: Set<string> = new Set(),
+): PrescanResult {
+  const options: Record<string, string> = {};
+  const booleans = new Set<string>();
+  const negated = new Set<string>();
+
+  for (const raw of lines) {
+    // Skip indented lines — these are content, not top-level options
+    if (raw.length > 0 && (raw[0] === ' ' || raw[0] === '\t')) continue;
+
+    const trimmed = raw.trim();
+    if (!trimmed || trimmed.startsWith('//')) continue;
+
+    // Strip inline comments
+    const commentIdx = trimmed.indexOf(' //');
+    const effective = commentIdx >= 0 ? trimmed.substring(0, commentIdx).trim() : trimmed;
+    if (!effective) continue;
+
+    // Extract first token
+    const spaceIdx = effective.indexOf(' ');
+    const firstToken = (spaceIdx === -1 ? effective : effective.substring(0, spaceIdx)).toLowerCase();
+
+    // Check for bare boolean (presence = on)
+    if (spaceIdx === -1 && knownBooleans.has(firstToken)) {
+      booleans.add(firstToken);
+      continue;
+    }
+
+    // Check for negated boolean: `no-X` where X is a known boolean
+    if (spaceIdx === -1 && firstToken.startsWith('no-')) {
+      const base = firstToken.substring(3);
+      if (knownBooleans.has(base)) {
+        negated.add(base);
+        continue;
+      }
+    }
+
+    // Check for boolean with a value (e.g., `today-marker 2026-03-26`) —
+    // must come before pure key-value check so booleans flag is also set
+    if (spaceIdx !== -1 && knownBooleans.has(firstToken)) {
+      booleans.add(firstToken);
+      options[firstToken] = effective.substring(spaceIdx + 1).trim();
+      continue;
+    }
+
+    // Check for key-value option
+    if (spaceIdx !== -1 && knownOptions.has(firstToken)) {
+      options[firstToken] = effective.substring(spaceIdx + 1).trim();
+      continue;
+    }
+  }
+
+  return { options, booleans, negated };
+}
+
+/**
+ * Normalize a comma-grouped number string to a plain integer string.
+ * Validates the strict pattern: leftmost group 1-3 digits, then groups of exactly 3.
+ *
+ * Examples: `1,087` → `'1087'`, `1,250,000` → `'1250000'`
+ * Returns `null` if the string is not a valid comma-grouped number.
+ */
+export function normalizeGroupedNumber(token: string): string | null {
+  if (!/^\d{1,3}(,\d{3})+$/.test(token)) return null;
+  return token.replace(/,/g, '');
+}
+
+/**
+ * Strip surrounding quotes (`"` or `'`) from a token.
+ * Returns the unquoted content, or the original string if not quoted.
+ */
+export function stripQuotes(token: string): string {
+  if (token.length >= 2) {
+    if ((token[0] === '"' && token[token.length - 1] === '"') ||
+        (token[0] === "'" && token[token.length - 1] === "'")) {
+      return token.substring(1, token.length - 1);
+    }
+  }
+  return token;
+}
+
+/**
+ * Quote-aware tokenizer — splits a string by whitespace but keeps quoted
+ * substrings (`"double"` or `'single'`) as single tokens.
+ * Quotes are preserved in the output tokens — call `stripQuotes()` to remove them.
+ */
+export function tokenizeQuoteAware(input: string): string[] {
+  const tokens: string[] = [];
+  let i = 0;
+  while (i < input.length) {
+    // Skip whitespace
+    if (input[i] === ' ' || input[i] === '\t') { i++; continue; }
+
+    // Quoted token
+    if (input[i] === '"' || input[i] === "'") {
+      const quote = input[i];
+      const start = i;
+      i++; // skip opening quote
+      while (i < input.length && input[i] !== quote) i++;
+      if (i < input.length) i++; // skip closing quote
+      tokens.push(input.substring(start, i));
+      continue;
+    }
+
+    // Unquoted token
+    const start = i;
+    while (i < input.length && input[i] !== ' ' && input[i] !== '\t') i++;
+    tokens.push(input.substring(start, i));
+  }
+  return tokens;
+}
+
 /**
  * Collect indented continuation lines as individual values.
  * Used when a property like `series:` has an empty value — subsequent
@@ -57,8 +262,9 @@ export const OPTION_RE = /^([a-z][a-z0-9-]*)\s*:\s*(.+)$/i;
 export function collectIndentedValues(
   lines: string[],
   startIndex: number,
-): { values: string[]; newIndex: number } {
+): { values: string[]; lineNumbers: number[]; newIndex: number } {
   const values: string[] = [];
+  const lineNumbers: number[] = [];
   let j = startIndex + 1;
   for (; j < lines.length; j++) {
     const raw = lines[j];
@@ -71,8 +277,9 @@ export function collectIndentedValues(
     if (raw[0] !== ' ' && raw[0] !== '\t') break;
     // Strip trailing comma and collect
     values.push(trimmed.replace(/,\s*$/, ''));
+    lineNumbers.push(j + 1); // 1-based
   }
-  return { values, newIndex: j - 1 };
+  return { values, lineNumbers, newIndex: j - 1 };
 }
 
 /**
@@ -91,18 +298,23 @@ export function parseSeriesNames(
   series: string;
   names: string[];
   nameColors: (string | undefined)[];
+  nameLineNumbers: number[];
   newIndex: number;
 } {
   let rawNames: string[];
   let series: string;
   let newIndex = lineIndex;
+  let nameLineNumbers: number[] = [];
   if (value) {
     series = value;
     rawNames = value.split(',').map((s) => s.trim()).filter(Boolean);
+    // Inline series names all share the same line number
+    nameLineNumbers = rawNames.map(() => lineIndex + 1);
   } else {
     const collected = collectIndentedValues(lines, lineIndex);
     newIndex = collected.newIndex;
     rawNames = collected.values;
+    nameLineNumbers = collected.lineNumbers;
     series = rawNames.join(', ');
   }
   const names: string[] = [];
@@ -115,7 +327,35 @@ export function parseSeriesNames(
   if (names.length === 1) {
     series = names[0];
   }
-  return { series, names, nameColors, newIndex };
+  return { series, names, nameColors, nameLineNumbers, newIndex };
+}
+
+/**
+ * Normalize a direction/orientation value to canonical form ('LR' | 'TB').
+ * Accepts 'lr', 'tb', 'horizontal', 'vertical' (case-insensitive).
+ * Returns null if the value is not recognized.
+ */
+export function normalizeDirection(value: string): 'LR' | 'TB' | null {
+  const v = value.trim().toLowerCase();
+  if (v === 'lr' || v === 'horizontal') return 'LR';
+  if (v === 'tb' || v === 'vertical') return 'TB';
+  return null;
+}
+
+/**
+ * Infer arrow color from label text.
+ * Returns a named palette color or undefined if no inference applies.
+ * Case-insensitive, exact match only (not prefix/substring).
+ */
+export function inferArrowColor(label: string): string | undefined {
+  const lower = label.toLowerCase();
+  // Green: positive/affirmative
+  if (lower === 'yes' || lower === 'success' || lower === 'ok' || lower === 'true') return 'green';
+  // Red: negative/failure
+  if (lower === 'no' || lower === 'fail' || lower === 'error' || lower === 'false') return 'red';
+  // Orange: uncertain/warning
+  if (lower === 'maybe' || lower === 'warning') return 'orange';
+  return undefined;
 }
 
 /** Warning message for multiple pipes on a single line. */

package/src/utils/tag-groups.ts

@@ -2,6 +2,8 @@
 // Shared tag-group types, regexes, and matchers
 // ============================================================
 
+import { stripQuotes, tokenizeQuoteAware } from './parsing';
+
 /** A single entry inside a tag group: `Value(color)` */
 export interface TagEntry {
   value: string;
@@ -14,7 +16,7 @@ export interface TagGroup {
   name: string;
   alias?: string;
   entries: TagEntry[];
-  /** Value of the entry marked `default` (nodes without metadata get this) */
+  /** First value in the tag declaration is the default (nodes without metadata get this) */
   defaultValue?: string;
   lineNumber: number;
 }
@@ -26,23 +28,154 @@ export interface TagBlockMatch {
   colorHint: string | undefined;
   /** true when the heading used `## …` (deprecated) */
   deprecated: boolean;
+  /** Inline tag values parsed from single-line form (e.g., `tag Priority p High(red), Low(blue)`) */
+  inlineValues?: string[];
 }
 
 // ── Regexes ─────────────────────────────────────────────────
 
-/** New canonical syntax: `tag: GroupName [alias X] [(color)]` (case-insensitive) */
+/** @deprecated Old syntax: `tag: GroupName [alias X] [(color)]` — remove after migration. */
 export const TAG_BLOCK_RE =
   /^tag:\s+(.+?)(?:\s+alias\s+(\w+))?(?:\s*\(([^)]+)\))?\s*$/i;
 
-/** Legacy syntax: `## GroupName [alias X] [(color)]` */
+/** New canonical syntax: line starting with `tag` keyword (no colon). */
+export const TAG_BLOCK_NOCOLON_RE = /^tag\s+/i;
+
+/** @deprecated Legacy syntax: `## GroupName [alias X] [(color)]` */
 export const GROUP_HEADING_RE =
   /^##\s+(.+?)(?:\s+alias\s+(\w+))?(?:\s*\(([^)]+)\))?\s*$/;
 
+// ── Alias Inference ─────────────────────────────────────────
+
+/** Returns true if the token looks like an alias: 1-4 lowercase ASCII characters. */
+function isAliasToken(token: string): boolean {
+  return /^[a-z]{1,4}$/.test(token);
+}
+
 // ── Matchers ────────────────────────────────────────────────
 
-/** Returns true if `trimmed` is a tag block heading in either syntax. */
+/** Returns true if `trimmed` is a tag block heading in any syntax. */
 export function isTagBlockHeading(trimmed: string): boolean {
-  return TAG_BLOCK_RE.test(trimmed) || GROUP_HEADING_RE.test(trimmed);
+  return TAG_BLOCK_NOCOLON_RE.test(trimmed) || TAG_BLOCK_RE.test(trimmed) || GROUP_HEADING_RE.test(trimmed);
+}
+
+/**
+ * Parse a new-syntax tag declaration line: `tag Name [alias] [Values...]`
+ *
+ * Alias inference: the token immediately after the name is the alias if it's 1-4 lowercase chars.
+ * Everything after the alias (or name, if no alias) that contains a comma or `(` is treated as inline values.
+ *
+ * Supports quoted names: `tag "Marketing mktg"` → name="Marketing mktg", no alias.
+ */
+export function parseTagDeclaration(line: string): TagBlockMatch | null {
+  // Must start with `tag ` (case-insensitive)
+  if (!TAG_BLOCK_NOCOLON_RE.test(line)) return null;
+
+  // Strip the `tag ` prefix
+  const afterTag = line.replace(/^tag\s+/i, '');
+  if (!afterTag.trim()) return null;
+
+  // Check if there are inline values (indicated by presence of `(` for colors after the name part)
+  // Strategy: tokenize, identify name + optional alias, rest is inline values
+  const tokens = tokenizeQuoteAware(afterTag);
+  if (tokens.length === 0) return null;
+
+  // First token (or quoted token) is the tag name
+  let name = stripQuotes(tokens[0]);
+  let alias: string | undefined;
+  let inlineValues: string[] | undefined;
+  let colorHint: string | undefined;
+  let restStartIdx = 1;
+
+  // If the first token is quoted, name is the quoted content — check for alias next
+  if (tokens[0][0] === '"' || tokens[0][0] === "'") {
+    // Quoted name — check if next token is alias
+    if (tokens.length > 1 && isAliasToken(tokens[1])) {
+      alias = tokens[1];
+      restStartIdx = 2;
+    }
+  } else {
+    // Unquoted — collect multi-word name. The alias is the last token that's 1-4 lowercase
+    // BEFORE any value tokens (values have `(color)` suffixes or appear after we see a comma).
+
+    // First check for explicit `alias` keyword: `tag Name alias X`
+    const aliasKeywordIdx = tokens.findIndex((t, i) => i > 0 && t.toLowerCase() === 'alias');
+    if (aliasKeywordIdx > 0 && aliasKeywordIdx + 1 < tokens.length) {
+      // Everything before `alias` is the name, the token after `alias` is the alias
+      name = tokens.slice(0, aliasKeywordIdx).map(t => stripQuotes(t)).join(' ');
+      alias = tokens[aliasKeywordIdx + 1];
+      restStartIdx = aliasKeywordIdx + 2;
+    } else {
+      // Find where inline values start — look for a token with `(` in it (color suffix)
+      // or the presence of a comma in the remaining text
+      const remainingText = tokens.slice(1).join(' ');
+      const commaInRemaining = remainingText.includes(',');
+
+      if (tokens.length === 1) {
+        // Just `tag Name` — no alias, no values
+      } else if (tokens.length === 2 && isAliasToken(tokens[1]) && !commaInRemaining) {
+        // `tag Priority p` — alias only, no values
+        alias = tokens[1];
+        restStartIdx = 2;
+      } else if (tokens.length >= 2) {
+        // Check if token[1] is an alias
+        if (isAliasToken(tokens[1])) {
+          alias = tokens[1];
+          restStartIdx = 2;
+          // Multi-word name not applicable when alias is right after first token
+        } else {
+          // Could be multi-word name: `tag Risk Level lo`
+          // Walk tokens to find the alias at the end (before inline values)
+          // Find where inline values begin — first token containing `(` or after comma
+          let valueStart = tokens.length; // default: no values
+          for (let i = 1; i < tokens.length; i++) {
+            // A token containing `(` suggests a value with color: `High(red)`
+            if (tokens[i].includes('(')) {
+              valueStart = i;
+              break;
+            }
+          }
+
+          // Check if the token just before valueStart is an alias
+          if (valueStart > 1 && isAliasToken(tokens[valueStart - 1])) {
+            alias = tokens[valueStart - 1];
+            // Name is everything from token[0] to token[valueStart-2]
+            name = tokens.slice(0, valueStart - 1).map(t => stripQuotes(t)).join(' ');
+            restStartIdx = valueStart;
+          } else {
+            // No alias — name is everything before values
+            name = tokens.slice(0, valueStart).map(t => stripQuotes(t)).join(' ');
+            restStartIdx = valueStart;
+          }
+        }
+      }
+    }
+  }
+
+  // Parse remaining tokens as inline values (if any)
+  if (restStartIdx < tokens.length) {
+    // Rejoin and split by comma for inline values
+    const valueStr = tokens.slice(restStartIdx).join(' ');
+    inlineValues = valueStr.split(',').map(v => v.trim()).filter(Boolean);
+  }
+
+  // Check for trailing color hint on name (without inline values)
+  // e.g., `tag Location(blue)` — colorHint on the tag group itself
+  if (!inlineValues || inlineValues.length === 0) {
+    const colorMatch = name.match(/\(([^)]+)\)\s*$/);
+    if (colorMatch) {
+      colorHint = colorMatch[1];
+      name = name.substring(0, colorMatch.index!).trim();
+    }
+  }
+
+  return {
+    name,
+    alias,
+    colorHint,
+    deprecated: false,
+    inlineValues: inlineValues && inlineValues.length > 0 ? inlineValues : undefined,
+  };
 }
 
 /**
@@ -119,15 +252,23 @@ export function validateTagValues(
         (e) => e.value.toLowerCase() === value.toLowerCase()
       );
       if (!match) {
-        const defined = group.entries.map((e) => e.value);
-        let msg = `Unknown value '${value}' for tag group '${group.name}'`;
-        const hint = suggestFn?.(value, defined);
-        if (hint) {
-          msg += `. ${hint}`;
-        } else {
-          msg += ` — defined values: ${defined.join(', ')}`;
+        // Suppress warning if the value is a prefix of any valid entry —
+        // the user is likely still typing (live parse during editing).
+        const valueLower = value.toLowerCase();
+        const isPrefix = group.entries.some(
+          (e) => e.value.toLowerCase().startsWith(valueLower)
+        );
+        if (!isPrefix) {
+          const defined = group.entries.map((e) => e.value);
+          let msg = `Unknown value '${value}' for tag group '${group.name}'`;
+          const hint = suggestFn?.(value, defined);
+          if (hint) {
+            msg += `. ${hint}`;
+          } else {
+            msg += ` — defined values: ${defined.join(', ')}`;
+          }
+          pushWarning(entity.lineNumber, msg);
         }
-        pushWarning(entity.lineNumber, msg);
       }
     }
   }
@@ -169,7 +310,11 @@ export function injectDefaultTagMetadata(
 // ── Matchers ────────────────────────────────────────────────
 
 export function matchTagBlockHeading(trimmed: string): TagBlockMatch | null {
-  // Try new syntax first
+  // Try new no-colon syntax first: `tag Name [alias] [Values...]`
+  const nocolonResult = parseTagDeclaration(trimmed);
+  if (nocolonResult) return nocolonResult;
+
+  // Try old colon syntax: `tag: GroupName [alias X] [(color)]`
   const tagMatch = trimmed.match(TAG_BLOCK_RE);
   if (tagMatch) {
     return {
@@ -180,7 +325,7 @@ export function matchTagBlockHeading(trimmed: string): TagBlockMatch | null {
     };
   }
 
-  // Fall back to legacy syntax
+  // Fall back to legacy ## syntax
   const groupMatch = trimmed.match(GROUP_HEADING_RE);
   if (groupMatch) {
     return {

package/src/utils/title-constants.ts

@@ -0,0 +1,9 @@
+// ============================================================
+// Shared chart title constants
+// All renderers import from here to stay in sync.
+// ============================================================
+
+export const TITLE_FONT_SIZE = 20;
+export const TITLE_FONT_WEIGHT = '700';
+export const TITLE_Y = 30;
+export const TITLE_OFFSET = 40;