@diagrammo/dgmo 0.46.0 → 0.48.0

package/dist/chunk-RUNNI6VE.js

@@ -0,0 +1,448 @@
+import {
+  tryCollectNote
+} from "./chunk-5MLYVTYM.js";
+import {
+  resolveNotes
+} from "./chunk-FMDSF3OV.js";
+import {
+  validateLabelCharacters
+} from "./chunk-FFUN5D66.js";
+import {
+  displayName,
+  normalizeName
+} from "./chunk-NOTA6TEI.js";
+import {
+  OPTION_NOCOLON_RE,
+  measureIndent,
+  parseFirstLine,
+  tryParseSharedOption
+} from "./chunk-Y3J7VR52.js";
+import {
+  resolveColorWithDiagnostic
+} from "./chunk-TLVIHFRO.js";
+import {
+  NAME_DIAGNOSTIC_CODES,
+  formatDgmoError,
+  makeDgmoError,
+  nameMergedMessage
+} from "./chunk-CXK4DZH3.js";
+
+// src/class/parser.ts
+function classId(name) {
+  return normalizeName(name);
+}
+var CLASS_DECL_RE = /^(?:(abstract|interface|enum)\s+)?(?:"([^"]+)"|([A-Z][^":]*?))(?:\s+extends\s+(?:"([^"]+)"|([A-Z][^":]*?)))?(?:\s+implements\s+(?:"([^"]+)"|([A-Z][^":]*?)))?(?:\s+\[(abstract|interface|enum)\])?(?:\s+(red|orange|yellow|green|blue|purple|teal|cyan|gray|black|white))?(?:\s+as\s+([A-Za-z][A-Za-z0-9_]{0,11}))?\s*$/;
+var INDENT_REL_ARROW_RE = /^(--\|>|\.\.\|>|\*--|o--|\.\.>|->)\s*(?:"([^"]+)"|([A-Za-z][^":]*?))(?:\s+:?\s*(.+))?$/;
+var REL_ARROW_RE = /^(?:"([^"]+)"|([A-Z][^":]*?))\s*(--\|>|\.\.\|>|\*--|o--|\.\.>|->)\s*(?:"([^"]+)"|([A-Z][^":]*?))(?:\s+:?\s*(.+))?$/;
+var VISIBILITY_RE = /^([+\-#])\s*/;
+var STATIC_SUFFIX_RE = /\{static\}\s*$/;
+var METHOD_RE = /^(.+?)\(([^)]*)\)(?:\s*:\s*(.+))?$/;
+var FIELD_RE = /^(.+?)\s*:\s*(.+)$/;
+var ARROW_TO_TYPE = {
+  "--|>": "extends",
+  "..|>": "implements",
+  "*--": "composes",
+  "o--": "aggregates",
+  "..>": "depends",
+  "->": "associates"
+};
+function parseVisibility(prefix) {
+  switch (prefix) {
+    case "-":
+      return "private";
+    case "#":
+      return "protected";
+    default:
+      return "public";
+  }
+}
+function parseMember(line, lineNumber, isEnum) {
+  let text = line.trim();
+  if (!text) return null;
+  if (isEnum) {
+    return {
+      name: text,
+      visibility: "public",
+      isStatic: false,
+      isMethod: false,
+      lineNumber
+    };
+  }
+  let visibility = "public";
+  const visMatch = text.match(VISIBILITY_RE);
+  if (visMatch) {
+    visibility = parseVisibility(visMatch[1]);
+    text = text.substring(visMatch[0].length);
+  }
+  let isStatic = false;
+  if (STATIC_SUFFIX_RE.test(text)) {
+    isStatic = true;
+    text = text.replace(STATIC_SUFFIX_RE, "").trim();
+  }
+  const methodMatch = text.match(METHOD_RE);
+  if (methodMatch) {
+    const methodType = methodMatch[3]?.trim();
+    return {
+      name: methodMatch[1].trim(),
+      params: methodMatch[2].trim(),
+      ...methodType !== void 0 && { type: methodType },
+      visibility,
+      isStatic,
+      isMethod: true,
+      lineNumber
+    };
+  }
+  const fieldMatch = text.match(FIELD_RE);
+  if (fieldMatch) {
+    return {
+      name: fieldMatch[1].trim(),
+      type: fieldMatch[2].trim(),
+      visibility,
+      isStatic,
+      isMethod: false,
+      lineNumber
+    };
+  }
+  return {
+    name: text,
+    visibility,
+    isStatic,
+    isMethod: false,
+    lineNumber
+  };
+}
+function parseClassDiagram(content, palette) {
+  const lines = content.split("\n");
+  const options = {};
+  const result = {
+    type: "class",
+    classes: [],
+    relationships: [],
+    options,
+    diagnostics: [],
+    error: null
+  };
+  const classMap = /* @__PURE__ */ new Map();
+  const notes = [];
+  const nameAliasMap = /* @__PURE__ */ new Map();
+  function resolveAliasName(token) {
+    if (!token) return token;
+    const trimmed = token.trim();
+    const hit = nameAliasMap.get(trimmed);
+    if (hit !== void 0) {
+      for (const [, node] of classMap) {
+        if (classId(node.name) === hit) return node.name;
+      }
+    }
+    return token;
+  }
+  let currentClass = null;
+  let contentStarted = false;
+  function getOrCreateClass(name, lineNumber) {
+    const key = classId(name);
+    const existing = classMap.get(key);
+    if (existing) {
+      const incomingDisplay = displayName(name);
+      const existingDisplay = displayName(existing.name);
+      if (incomingDisplay !== existingDisplay) {
+        result.diagnostics.push(
+          makeDgmoError(
+            lineNumber,
+            nameMergedMessage({
+              incomingDisplay,
+              incomingLine: lineNumber,
+              existingDisplay,
+              existingLine: existing.lineNumber
+            }),
+            "warning",
+            NAME_DIAGNOSTIC_CODES.NAME_MERGED
+          )
+        );
+      }
+      return existing;
+    }
+    const node = {
+      id: key,
+      name,
+      members: [],
+      lineNumber
+    };
+    classMap.set(key, node);
+    result.classes.push(node);
+    return node;
+  }
+  for (let i = 0; i < lines.length; i++) {
+    const raw = lines[i];
+    const trimmed = raw.trim();
+    const lineNumber = i + 1;
+    const indent = measureIndent(raw);
+    if (!trimmed) {
+      if (indent === 0) currentClass = null;
+      continue;
+    }
+    if (trimmed.startsWith("//")) continue;
+    if (indent === 0) {
+      const noteResult = tryCollectNote(
+        lines,
+        i,
+        indent,
+        palette,
+        result.diagnostics
+      );
+      if (noteResult) {
+        currentClass = null;
+        contentStarted = true;
+        if (noteResult.note) notes.push(noteResult.note);
+        i = noteResult.lastIndex;
+        continue;
+      }
+    }
+    if (!contentStarted && indent === 0 && i === 0) {
+      const firstLine = parseFirstLine(trimmed);
+      if (firstLine?.chartType === "class") {
+        if (firstLine.title) {
+          result.title = firstLine.title;
+          result.titleLineNumber = lineNumber;
+        }
+        continue;
+      }
+    }
+    if (!contentStarted && indent === 0 && /^[a-z]/.test(trimmed)) {
+      if (trimmed.toLowerCase() === "no-auto-color") {
+        result.diagnostics.push(
+          makeDgmoError(
+            lineNumber,
+            '"no-auto-color" was removed \u2014 colors are always auto-assigned from the palette; delete this line.',
+            "warning"
+          )
+        );
+        continue;
+      }
+      if (tryParseSharedOption(trimmed, options)) {
+        continue;
+      }
+      const optMatch = trimmed.match(OPTION_NOCOLON_RE);
+      if (optMatch) {
+        const key = optMatch[1].toLowerCase();
+        const value = optMatch[2].trim();
+        if (key !== "abstract" && key !== "interface" && key !== "enum") {
+          options[key] = value;
+          continue;
+        }
+      }
+    }
+    if (indent > 0 && currentClass) {
+      const indentRel = trimmed.match(INDENT_REL_ARROW_RE);
+      if (indentRel) {
+        const arrow = indentRel[1];
+        const rawTarget = (indentRel[2] ?? indentRel[3] ?? "").trim();
+        const targetName = resolveAliasName(rawTarget) ?? rawTarget;
+        const label = indentRel[4]?.trim();
+        getOrCreateClass(targetName, lineNumber);
+        if (label) {
+          result.diagnostics.push(
+            ...validateLabelCharacters(label, lineNumber)
+          );
+        }
+        result.relationships.push({
+          source: currentClass.id,
+          target: classId(targetName),
+          // INDENT_REL_ARROW_RE only matches arrows present in ARROW_TO_TYPE.
+          type: ARROW_TO_TYPE[arrow],
+          ...label && { label },
+          lineNumber
+        });
+        continue;
+      }
+      const member = parseMember(
+        trimmed,
+        lineNumber,
+        currentClass.modifier === "enum"
+      );
+      if (member) {
+        currentClass.members.push(member);
+      }
+      continue;
+    }
+    currentClass = null;
+    contentStarted = true;
+    const relArrow = trimmed.match(REL_ARROW_RE);
+    if (relArrow) {
+      const sourceName = (relArrow[1] ?? relArrow[2] ?? "").trim();
+      const arrow = relArrow[3];
+      const targetName = (relArrow[4] ?? relArrow[5] ?? "").trim();
+      result.diagnostics.push(
+        makeDgmoError(
+          lineNumber,
+          `Relationship "${sourceName} ${arrow} ${targetName}" must be indented under the source class "${sourceName}"`,
+          "warning"
+        )
+      );
+      continue;
+    }
+    const classDecl = trimmed.match(CLASS_DECL_RE);
+    if (classDecl) {
+      const prefixModifier = classDecl[1];
+      const name = (classDecl[2] ?? classDecl[3] ?? "").trim();
+      const extendsRaw = classDecl[4] ?? classDecl[5];
+      const extendsParent = extendsRaw ? extendsRaw.trim() : void 0;
+      const implementsRaw = classDecl[6] ?? classDecl[7];
+      const implementsInterface = implementsRaw ? implementsRaw.trim() : void 0;
+      const bracketModifier = classDecl[8];
+      const modifier = prefixModifier ?? bracketModifier;
+      const colorName = classDecl[9]?.trim();
+      const color = colorName ? resolveColorWithDiagnostic(
+        colorName,
+        lineNumber,
+        result.diagnostics,
+        palette
+      ) : void 0;
+      const aliasLiteral = classDecl[10];
+      const node = getOrCreateClass(name, lineNumber);
+      if (modifier) node.modifier = modifier;
+      if (color) node.color = color;
+      if (aliasLiteral) nameAliasMap.set(aliasLiteral, classId(name));
+      node.lineNumber = lineNumber;
+      if (extendsParent) {
+        const ext = resolveAliasName(extendsParent) ?? extendsParent;
+        getOrCreateClass(ext, lineNumber);
+        result.relationships.push({
+          source: classId(name),
+          target: classId(ext),
+          type: "extends",
+          lineNumber
+        });
+      }
+      if (implementsInterface) {
+        const impl = resolveAliasName(implementsInterface) ?? implementsInterface;
+        getOrCreateClass(impl, lineNumber);
+        result.relationships.push({
+          source: classId(name),
+          target: classId(impl),
+          type: "implements",
+          lineNumber
+        });
+      }
+      currentClass = node;
+      continue;
+    }
+    result.diagnostics.push(
+      makeDgmoError(
+        lineNumber,
+        `Unexpected line: '${trimmed}'. Classes start uppercase at indent 0 ('Ship'); members are indented and colon-typed ('+ name: string', '+ sail(): void'); relationships are indented arrows ('--|> Vessel'). (\xA710)`,
+        "warning"
+      )
+    );
+  }
+  if (notes.length > 0) {
+    result.notes = notes;
+    resolveNotes(
+      notes,
+      result.classes.map((c) => ({ id: c.id, label: c.name })),
+      result.diagnostics
+    );
+  }
+  if (result.classes.length === 0 && !result.error) {
+    const diag = makeDgmoError(
+      1,
+      'No classes found. Add class declarations like "ClassName" or "ClassName [interface]".'
+    );
+    result.diagnostics.push(diag);
+    result.error = formatDgmoError(diag);
+  }
+  if (result.classes.length >= 2 && result.relationships.length >= 1 && !result.error) {
+    const connectedIds = /* @__PURE__ */ new Set();
+    for (const rel of result.relationships) {
+      connectedIds.add(rel.source);
+      connectedIds.add(rel.target);
+    }
+    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"
+          )
+        );
+      }
+    }
+  }
+  return result;
+}
+function looksLikeClassDiagram(content) {
+  const lines = content.split("\n");
+  let hasModifier = false;
+  let hasRelationship = false;
+  let hasIndentedMember = false;
+  let hasClassDecl = false;
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith("//")) continue;
+    if (/^(chart|title)\s*:/i.test(trimmed)) continue;
+    if (/^class(\s|$)/i.test(trimmed)) continue;
+    const indent = measureIndent(line);
+    if (indent === 0) {
+      if (/^(abstract|interface|enum)\s+[A-Z][A-Za-z0-9_]*/i.test(trimmed)) {
+        hasModifier = true;
+        hasClassDecl = true;
+      }
+      if (/^[A-Z][A-Za-z0-9_]*\s+\[(abstract|interface|enum)\]/i.test(trimmed)) {
+        hasModifier = true;
+        hasClassDecl = true;
+      }
+      if (/^[A-Z][A-Za-z0-9_]*\s+(extends|implements)\s+[A-Z]/.test(trimmed)) {
+        hasRelationship = true;
+        hasClassDecl = true;
+      }
+      if (REL_ARROW_RE.test(trimmed)) {
+        hasRelationship = true;
+      }
+      if (CLASS_DECL_RE.test(trimmed)) {
+        hasClassDecl = true;
+      }
+    } else {
+      if (/^[+\-#]?\s*\w+.*[:(]/.test(trimmed)) {
+        hasIndentedMember = true;
+      }
+      if (INDENT_REL_ARROW_RE.test(trimmed)) {
+        hasRelationship = true;
+      }
+    }
+  }
+  if (hasModifier) return true;
+  if (hasRelationship && hasClassDecl && hasIndentedMember) return true;
+  return false;
+}
+function extractSymbols(docText) {
+  const entities = [];
+  let inMetadata = true;
+  for (const rawLine of docText.split("\n")) {
+    const line = rawLine.trim();
+    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;
+    }
+    inMetadata = false;
+    if (line.length === 0 || /^\s/.test(rawLine)) continue;
+    const m = CLASS_DECL_RE.exec(line);
+    if (m) {
+      const name = (m[2] ?? m[3] ?? "").trim();
+      if (name && !entities.includes(name)) entities.push(name);
+    }
+  }
+  return {
+    kind: "class",
+    entities
+  };
+}
+
+export {
+  parseClassDiagram,
+  looksLikeClassDiagram,
+  extractSymbols
+};
+//# sourceMappingURL=chunk-RUNNI6VE.js.map