@diagrammo/dgmo 0.2.27 → 0.3.0

package/src/utils/inline-markdown.ts

@@ -0,0 +1,75 @@
+// ============================================================
+// Inline Markdown — shared parsing + SVG rendering for text fields
+// ============================================================
+
+import * as d3Selection from 'd3-selection';
+import type { PaletteColors } from '../palettes';
+
+export interface InlineSpan {
+  text: string;
+  bold?: boolean;
+  italic?: boolean;
+  code?: boolean;
+  href?: string;
+}
+
+export function parseInlineMarkdown(text: string): InlineSpan[] {
+  const spans: InlineSpan[] = [];
+  const regex =
+    /\*\*(.+?)\*\*|__(.+?)__|\*(.+?)\*|_(.+?)_|`(.+?)`|\[(.+?)\]\((.+?)\)|(https?:\/\/[^\s)>\]]+|www\.[^\s)>\]]+)|([^*_`[]+?(?=https?:\/\/|www\.|$)|[^*_`[]+)/g;
+  let match;
+  while ((match = regex.exec(text)) !== null) {
+    if (match[1]) spans.push({ text: match[1], bold: true });       // **bold**
+    else if (match[2]) spans.push({ text: match[2], bold: true });  // __bold__
+    else if (match[3]) spans.push({ text: match[3], italic: true }); // *italic*
+    else if (match[4]) spans.push({ text: match[4], italic: true }); // _italic_
+    else if (match[5]) spans.push({ text: match[5], code: true });   // `code`
+    else if (match[6]) spans.push({ text: match[6], href: match[7] }); // [text](url)
+    else if (match[8]) {                                              // bare URL
+      const url = match[8];
+      const href = url.startsWith('www.') ? `https://${url}` : url;
+      spans.push({ text: url, href });
+    } else if (match[9]) spans.push({ text: match[9] });             // plain text
+  }
+  return spans;
+}
+
+const BARE_URL_MAX_DISPLAY = 35;
+
+export function truncateBareUrl(url: string): string {
+  const stripped = url.replace(/^https?:\/\//, '').replace(/^www\./, '');
+  if (stripped.length <= BARE_URL_MAX_DISPLAY) return stripped;
+  return stripped.slice(0, BARE_URL_MAX_DISPLAY - 1) + '\u2026';
+}
+
+export function renderInlineText(
+  textEl: d3Selection.Selection<SVGTextElement, unknown, null, undefined>,
+  text: string,
+  palette: PaletteColors,
+  fontSize?: number
+): void {
+  const spans = parseInlineMarkdown(text);
+  for (const span of spans) {
+    if (span.href) {
+      // Bare URLs (text === href or href with https:// prepended) get truncated display;
+      // markdown links [text](url) keep their user-chosen text as-is.
+      const isBareUrl =
+        span.text === span.href ||
+        `https://${span.text}` === span.href;
+      const display = isBareUrl ? truncateBareUrl(span.text) : span.text;
+      const a = textEl.append('a').attr('href', span.href);
+      a.append('tspan')
+        .text(display)
+        .attr('fill', palette.primary)
+        .style('text-decoration', 'underline');
+    } else {
+      const tspan = textEl.append('tspan').text(span.text);
+      if (span.bold) tspan.attr('font-weight', 'bold');
+      if (span.italic) tspan.attr('font-style', 'italic');
+      if (span.code) {
+        tspan.attr('font-family', 'monospace');
+        if (fontSize) tspan.attr('font-size', fontSize - 1);
+      }
+    }
+  }
+}

package/src/utils/parsing.ts

@@ -0,0 +1,67 @@
+/**
+ * Shared parser utilities — extracted from individual parsers to eliminate
+ * duplication of measureIndent, extractColor, header regexes, and
+ * pipe-metadata parsing.
+ */
+
+import { resolveColor } from '../colors';
+import type { PaletteColors } from '../palettes';
+
+/** Measure leading whitespace of a line, normalizing tabs to 4 spaces. */
+export function measureIndent(line: string): number {
+  let indent = 0;
+  for (const ch of line) {
+    if (ch === ' ') indent++;
+    else if (ch === '\t') indent += 4;
+    else break;
+  }
+  return indent;
+}
+
+/** Matches a trailing `(colorName)` suffix on a label. */
+export const COLOR_SUFFIX_RE = /\(([^)]+)\)\s*$/;
+
+/** Extract an optional trailing color suffix from a label, resolving via palette. */
+export function extractColor(
+  label: string,
+  palette?: PaletteColors,
+): { label: string; color?: string } {
+  const m = label.match(COLOR_SUFFIX_RE);
+  if (!m) return { label };
+  const colorName = m[1].trim();
+  return {
+    label: label.substring(0, m.index!).trim(),
+    color: resolveColor(colorName, palette),
+  };
+}
+
+/** Matches `chart: <type>` header lines. */
+export const CHART_TYPE_RE = /^chart\s*:\s*(.+)/i;
+
+/** Matches `title: <text>` header lines. */
+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;
+
+/** Parse pipe-delimited metadata from segments after the first (name) segment. */
+export function parsePipeMetadata(
+  segments: string[],
+  aliasMap: Map<string, string> = new Map(),
+): Record<string, string> {
+  const metadata: Record<string, string> = {};
+  for (let j = 1; j < segments.length; j++) {
+    for (const part of segments[j].split(',')) {
+      const trimmedPart = part.trim();
+      if (!trimmedPart) continue;
+      const colonIdx = trimmedPart.indexOf(':');
+      if (colonIdx > 0) {
+        const rawKey = trimmedPart.substring(0, colonIdx).trim().toLowerCase();
+        const key = aliasMap.get(rawKey) ?? rawKey;
+        const value = trimmedPart.substring(colonIdx + 1).trim();
+        metadata[key] = value;
+      }
+    }
+  }
+  return metadata;
+}

package/src/utils/tag-groups.ts

@@ -0,0 +1,76 @@
+// ============================================================
+// Shared tag-group types, regexes, and matchers
+// ============================================================
+
+/** A single entry inside a tag group: `Value(color)` */
+export interface TagEntry {
+  value: string;
+  color: string;
+  lineNumber: number;
+}
+
+/** A tag group block: heading + entries */
+export interface TagGroup {
+  name: string;
+  alias?: string;
+  entries: TagEntry[];
+  /** Value of the entry marked `default` (nodes without metadata get this) */
+  defaultValue?: string;
+  lineNumber: number;
+}
+
+/** Result of matching a tag block heading */
+export interface TagBlockMatch {
+  name: string;
+  alias: string | undefined;
+  colorHint: string | undefined;
+  /** true when the heading used `## …` (deprecated) */
+  deprecated: boolean;
+}
+
+// ── Regexes ─────────────────────────────────────────────────
+
+/** New canonical syntax: `tag: GroupName [alias X] [(color)]` (case-insensitive) */
+export const TAG_BLOCK_RE =
+  /^tag:\s+(.+?)(?:\s+alias\s+(\w+))?(?:\s*\(([^)]+)\))?\s*$/i;
+
+/** Legacy syntax: `## GroupName [alias X] [(color)]` */
+export const GROUP_HEADING_RE =
+  /^##\s+(.+?)(?:\s+alias\s+(\w+))?(?:\s*\(([^)]+)\))?\s*$/;
+
+// ── Matchers ────────────────────────────────────────────────
+
+/** Returns true if `trimmed` is a tag block heading in either syntax. */
+export function isTagBlockHeading(trimmed: string): boolean {
+  return TAG_BLOCK_RE.test(trimmed) || GROUP_HEADING_RE.test(trimmed);
+}
+
+/**
+ * Parse a tag block heading line into structured data.
+ * Returns `null` if the line is not a tag block heading.
+ */
+export function matchTagBlockHeading(trimmed: string): TagBlockMatch | null {
+  // Try new syntax first
+  const tagMatch = trimmed.match(TAG_BLOCK_RE);
+  if (tagMatch) {
+    return {
+      name: tagMatch[1].trim(),
+      alias: tagMatch[2] || undefined,
+      colorHint: tagMatch[3] || undefined,
+      deprecated: false,
+    };
+  }
+
+  // Fall back to legacy syntax
+  const groupMatch = trimmed.match(GROUP_HEADING_RE);
+  if (groupMatch) {
+    return {
+      name: groupMatch[1].trim(),
+      alias: groupMatch[2] || undefined,
+      colorHint: groupMatch[3] || undefined,
+      deprecated: true,
+    };
+  }
+
+  return null;
+}