@jpeakai/mermaidjs-lint 0.7.1 → 0.7.2

package/src/parse/graph.ts

@@ -0,0 +1,98 @@
+// The element-level structure of a diagram, read from mermaid's parser result:
+// each node, each edge and each subgraph, with what contains what. The stats in
+// stats.ts count the same result, and this keeps the elements themselves, so
+// the docs site can draw what the parser returned beside the score it earns.
+// Only the types the site draws are read, and any other type throws.
+
+import { getMermaidCore } from "./stats.ts";
+
+export interface GraphNode {
+  id: string;
+  label: string;
+  // The subgraph that holds this node, or null at the top level.
+  parent: string | null;
+}
+
+export interface GraphEdge {
+  source: string;
+  target: string;
+}
+
+export interface DiagramGraph {
+  diagram_type: string;
+  nodes: GraphNode[];
+  edges: GraphEdge[];
+  // A subgraph holds nodes, or other subgraphs through their parent.
+  subgraphs: GraphNode[];
+}
+
+type AnyDb = Record<string, unknown>;
+
+interface FlowVertex {
+  id: string;
+  text?: string;
+}
+interface FlowEdge {
+  start: string;
+  end: string;
+}
+interface FlowSubgraph {
+  id: string;
+  title?: string;
+  nodes?: string[];
+}
+
+// Mermaid lists each member once, under its innermost subgraph, and a nested
+// subgraph is listed by id as a member of the one around it.
+const flowchartGraph = (type: string, db: AnyDb): DiagramGraph => {
+  const vertices = db.vertices instanceof Map ? ([...db.vertices.values()] as FlowVertex[]) : [];
+  const edges = (Array.isArray(db.edges) ? db.edges : []) as FlowEdge[];
+  const subGraphs = (Array.isArray(db.subGraphs) ? db.subGraphs : []) as FlowSubgraph[];
+  const parentOf = new Map<string, string>();
+  for (const sg of subGraphs) for (const member of sg.nodes ?? []) parentOf.set(member, sg.id);
+  return {
+    diagram_type: type,
+    nodes: vertices.map((v) => ({ id: v.id, label: v.text ?? v.id, parent: parentOf.get(v.id) ?? null })),
+    edges: edges.map((e) => ({ source: e.start, target: e.end })),
+    subgraphs: subGraphs.map((sg) => ({ id: sg.id, label: sg.title ?? sg.id, parent: parentOf.get(sg.id) ?? null })),
+  };
+};
+
+interface MindmapNode {
+  id: number;
+  descr?: string;
+  children?: MindmapNode[];
+}
+
+// A mindmap's labels may repeat, so each entry is named by the parser's own id.
+const mindmapGraph = (type: string, db: AnyDb): DiagramGraph => {
+  const getRoot = db.getMindmap;
+  const root = typeof getRoot === "function" ? (getRoot.call(db) as MindmapNode | null) : null;
+  const nodes: GraphNode[] = [];
+  const edges: GraphEdge[] = [];
+  const walk = (node: MindmapNode, parent: string | null): void => {
+    const id = `n${node.id}`;
+    nodes.push({ id, label: node.descr ?? id, parent: null });
+    if (parent) edges.push({ source: parent, target: id });
+    for (const child of node.children ?? []) walk(child, id);
+  };
+  if (root) walk(root, null);
+  return { diagram_type: type, nodes, edges, subgraphs: [] };
+};
+
+const READERS: Record<string, (type: string, db: AnyDb) => DiagramGraph> = {
+  "flowchart-v2": flowchartGraph,
+  flowchart: flowchartGraph,
+  graph: flowchartGraph,
+  mindmap: mindmapGraph,
+};
+
+export const extractGraph = async (content: string): Promise<DiagramGraph> => {
+  const mermaid = await getMermaidCore();
+  await mermaid.parse(content);
+  const diagram = (await mermaid.mermaidAPI.getDiagramFromText(content)) as { db: AnyDb; type?: string };
+  const type = diagram.type ?? "unknown";
+  const read = READERS[type];
+  if (!read) throw new Error(`extractGraph reads ${Object.keys(READERS).join(", ")}, not ${type}`);
+  return read(type, diagram.db);
+};

package/src/parse/metrics.ts

@@ -111,7 +111,7 @@ export const canonicalPreset = (name: string): string | null => {
 export const configFromPreset = (name: string): ThresholdConfig => {
   const canonical = canonicalPreset(name);
   const preset = canonical ? PRESETS[canonical] : undefined;
-  if (!canonical || !preset) {
+  if (!(canonical && preset)) {
     throw new Error(`Unknown preset '${name}'. Valid: ${PRESET_NAMES.join(", ")}`);
   }
   return {

package/src/parse/stats.ts

@@ -71,10 +71,18 @@ export interface DiagramStats {
 
 type MermaidStats = DiagramStats;
 
-const LANGIUM_TYPES: Record<
-  string,
-  "architecture" | "info" | "pie" | "gitGraph" | "packet" | "radar" | "treemap" | "treeView" | "wardley"
-> = {
+type LangiumType =
+  | "architecture"
+  | "info"
+  | "pie"
+  | "gitGraph"
+  | "packet"
+  | "radar"
+  | "treemap"
+  | "treeView"
+  | "wardley";
+
+const LANGIUM_TYPES: Record<string, LangiumType> = {
   "architecture-beta": "architecture",
   architecture: "architecture",
   info: "info",
@@ -180,7 +188,7 @@ export const parserReason = (err: unknown): string => {
   const lines = message.split("\n");
   if (message.startsWith("No diagram type detected")) return (lines[0] ?? "").trim();
   return lines
-    .filter((line, i) => !POINTER.test(line.trim()) && !POINTER.test((lines[i + 1] ?? "").trim()))
+    .filter((line, i) => !(POINTER.test(line.trim()) || POINTER.test((lines[i + 1] ?? "").trim())))
     .join(" ")
     .replace(/\s+/g, " ")
     .trim();
@@ -217,83 +225,7 @@ async function extractLangiumStats(content: string, keyword: string): Promise<Me
   const mapped = LANGIUM_TYPES[keyword];
   if (!mapped) throw new Error(`not a langium keyword: ${keyword}`);
   const ast = (await langiumParseAny(mapped, content)) as Record<string, unknown>;
-
-  const nodeIds: string[] = [];
-  const subgraphNames: string[] = [];
-  let edges = 0;
-  let maxDepth = 0;
-  let treeDepth = 0;
-
-  switch (mapped) {
-    case "architecture": {
-      const services = (ast.services as Array<{ id?: string }> | undefined) ?? [];
-      const groups = (ast.groups as Array<{ id?: string; title?: string; in?: string }> | undefined) ?? [];
-      const edgeArr = (ast.edges as Array<unknown> | undefined) ?? [];
-      nodeIds.push(...services.map((s) => s.id ?? ""));
-      subgraphNames.push(...groups.map((g) => g.title ?? g.id ?? ""));
-      maxDepth = architectureDepth(groups);
-      edges = edgeArr.length;
-      break;
-    }
-    case "pie": {
-      const sections = (ast.sections as Array<{ label?: string }> | undefined) ?? [];
-      nodeIds.push(...sections.map((s, i) => s.label ?? `slice_${i}`));
-      break;
-    }
-    case "packet": {
-      const blocks = (ast.blocks as Array<unknown> | undefined) ?? [];
-      nodeIds.push(...blocks.map((_, i) => `block_${i}`));
-      break;
-    }
-    case "gitGraph": {
-      const statements = (ast.statements as Array<{ $type?: string; id?: string; name?: string }> | undefined) ?? [];
-      for (const s of statements) {
-        if (s.$type === "Commit") nodeIds.push(s.id ?? `commit_${nodeIds.length}`);
-        else if (s.$type === "Branch") subgraphNames.push(s.name ?? `branch_${subgraphNames.length}`);
-        else if (s.$type === "Merge") edges++;
-      }
-      break;
-    }
-    case "radar": {
-      const axes = (ast.axes as Array<{ name?: string }> | undefined) ?? [];
-      const curves = (ast.curves as Array<{ name?: string }> | undefined) ?? [];
-      nodeIds.push(...axes.map((a, i) => a.name ?? `axis_${i}`));
-      nodeIds.push(...curves.map((c, i) => c.name ?? `curve_${i}`));
-      edges = axes.length * curves.length;
-      break;
-    }
-    case "treeView": {
-      // AST shape: flat ast.nodes[] with { name, indent }. Tree structure
-      // derives from indent values; edges = nodes - roots.
-      const nodes = (ast.nodes as Array<{ name?: string; indent?: number }> | undefined) ?? [];
-      const stats = indentTreeStats(nodes.map((n, i) => ({ label: n.name ?? `node_${i}`, indent: n.indent ?? 0 })));
-      nodeIds.push(...stats.labels);
-      edges = stats.edges;
-      treeDepth = stats.depth;
-      break;
-    }
-    case "treemap": {
-      // AST shape: ast.TreemapRows[] with .indent and .item.{Section|Leaf}.name.
-      const rows = (ast.TreemapRows as Array<{ indent?: number; item?: { name?: string } }> | undefined) ?? [];
-      const stats = indentTreeStats(rows.map((r, i) => ({ label: r.item?.name ?? `row_${i}`, indent: r.indent ?? 0 })));
-      nodeIds.push(...stats.labels);
-      edges = stats.edges;
-      treeDepth = stats.depth;
-      break;
-    }
-    case "wardley": {
-      // AST shape: ast.anchors[], ast.components[], ast.links[] — NOT ast.edges.
-      const components = (ast.components as Array<{ name?: string }> | undefined) ?? [];
-      const anchors = (ast.anchors as Array<{ name?: string }> | undefined) ?? [];
-      const links = (ast.links as Array<unknown> | undefined) ?? [];
-      nodeIds.push(...anchors.map((a, i) => a.name ?? `anchor_${i}`));
-      nodeIds.push(...components.map((c, i) => c.name ?? `comp_${i}`));
-      edges = links.length;
-      break;
-    }
-    case "info":
-      break; // trivial diagram type, no structure
-  }
+  const { nodeIds, edges, subgraphNames, maxDepth, treeDepth = 0 } = LANGIUM_ADAPTERS[mapped](ast);
 
   return {
     nodes: new Set(nodeIds.filter(Boolean)).size,
@@ -309,6 +241,103 @@ async function extractLangiumStats(content: string, keyword: string): Promise<Me
   };
 }
 
+// ─── Per-type Langium AST adapters ──
+// Each adapter reads ONLY the typed AST its grammar produces, the way the
+// mermaid-core adapters below read only their type's DB.
+
+type LangiumAdapter = (ast: Record<string, unknown>) => Structure;
+
+const LANGIUM_ADAPTERS: Record<LangiumType, LangiumAdapter> = {
+  architecture: adaptLangiumArchitecture,
+  info: adaptLangiumInfo,
+  pie: adaptLangiumPie,
+  gitGraph: adaptLangiumGitGraph,
+  packet: adaptLangiumPacket,
+  radar: adaptLangiumRadar,
+  treemap: adaptLangiumTreemap,
+  treeView: adaptLangiumTreeView,
+  wardley: adaptLangiumWardley,
+};
+
+function adaptLangiumArchitecture(ast: Record<string, unknown>): Structure {
+  const services = (ast.services as Array<{ id?: string }> | undefined) ?? [];
+  const groups = (ast.groups as Array<{ id?: string; title?: string; in?: string }> | undefined) ?? [];
+  const edgeArr = (ast.edges as Array<unknown> | undefined) ?? [];
+  return {
+    nodeIds: services.map((s) => s.id ?? ""),
+    edges: edgeArr.length,
+    subgraphNames: groups.map((g) => g.title ?? g.id ?? ""),
+    maxDepth: architectureDepth(groups),
+  };
+}
+
+// A trivial diagram type, with no structure.
+function adaptLangiumInfo(): Structure {
+  return { nodeIds: [], edges: 0, subgraphNames: [], maxDepth: 0 };
+}
+
+function adaptLangiumPie(ast: Record<string, unknown>): Structure {
+  const sections = (ast.sections as Array<{ label?: string }> | undefined) ?? [];
+  return { nodeIds: sections.map((s, i) => s.label ?? `slice_${i}`), edges: 0, subgraphNames: [], maxDepth: 0 };
+}
+
+function adaptLangiumPacket(ast: Record<string, unknown>): Structure {
+  const blocks = (ast.blocks as Array<unknown> | undefined) ?? [];
+  return { nodeIds: blocks.map((_, i) => `block_${i}`), edges: 0, subgraphNames: [], maxDepth: 0 };
+}
+
+function adaptLangiumGitGraph(ast: Record<string, unknown>): Structure {
+  const statements = (ast.statements as Array<{ $type?: string; id?: string; name?: string }> | undefined) ?? [];
+  const nodeIds: string[] = [];
+  const subgraphNames: string[] = [];
+  let edges = 0;
+  for (const s of statements) {
+    if (s.$type === "Commit") nodeIds.push(s.id ?? `commit_${nodeIds.length}`);
+    else if (s.$type === "Branch") subgraphNames.push(s.name ?? `branch_${subgraphNames.length}`);
+    else if (s.$type === "Merge") edges++;
+  }
+  return { nodeIds, edges, subgraphNames, maxDepth: 0 };
+}
+
+function adaptLangiumRadar(ast: Record<string, unknown>): Structure {
+  const axes = (ast.axes as Array<{ name?: string }> | undefined) ?? [];
+  const curves = (ast.curves as Array<{ name?: string }> | undefined) ?? [];
+  return {
+    nodeIds: [...axes.map((a, i) => a.name ?? `axis_${i}`), ...curves.map((c, i) => c.name ?? `curve_${i}`)],
+    edges: axes.length * curves.length,
+    subgraphNames: [],
+    maxDepth: 0,
+  };
+}
+
+function adaptLangiumTreeView(ast: Record<string, unknown>): Structure {
+  // AST shape: flat ast.nodes[] with { name, indent }. Tree structure
+  // derives from indent values; edges = nodes - roots.
+  const nodes = (ast.nodes as Array<{ name?: string; indent?: number }> | undefined) ?? [];
+  const stats = indentTreeStats(nodes.map((n, i) => ({ label: n.name ?? `node_${i}`, indent: n.indent ?? 0 })));
+  return { nodeIds: stats.labels, edges: stats.edges, subgraphNames: [], maxDepth: 0, treeDepth: stats.depth };
+}
+
+function adaptLangiumTreemap(ast: Record<string, unknown>): Structure {
+  // AST shape: ast.TreemapRows[] with .indent and .item.{Section|Leaf}.name.
+  const rows = (ast.TreemapRows as Array<{ indent?: number; item?: { name?: string } }> | undefined) ?? [];
+  const stats = indentTreeStats(rows.map((r, i) => ({ label: r.item?.name ?? `row_${i}`, indent: r.indent ?? 0 })));
+  return { nodeIds: stats.labels, edges: stats.edges, subgraphNames: [], maxDepth: 0, treeDepth: stats.depth };
+}
+
+function adaptLangiumWardley(ast: Record<string, unknown>): Structure {
+  // AST shape: ast.anchors[], ast.components[], ast.links[] — NOT ast.edges.
+  const components = (ast.components as Array<{ name?: string }> | undefined) ?? [];
+  const anchors = (ast.anchors as Array<{ name?: string }> | undefined) ?? [];
+  const links = (ast.links as Array<unknown> | undefined) ?? [];
+  return {
+    nodeIds: [...anchors.map((a, i) => a.name ?? `anchor_${i}`), ...components.map((c, i) => c.name ?? `comp_${i}`)],
+    edges: links.length,
+    subgraphNames: [],
+    maxDepth: 0,
+  };
+}
+
 function architectureDepth(groups: Array<{ id?: string; in?: string }>): number {
   const parentOf = new Map<string, string | undefined>();
   for (const g of groups) parentOf.set(g.id ?? "", g.in);

package/src/plugins/discover.ts

@@ -79,23 +79,21 @@ const localSources = async (root: string): Promise<PluginSource[]> => {
 
 // An approximation of Node resolution, read from a package's package.json:
 // exports "." by node, import, default priority, then main, then index.js.
+const CONDITIONS = ["node", "import", "default"];
+
+// The first candidate that resolves to a target, in order.
+const pickFirst = (candidates: unknown[]): string | null => {
+  for (const item of candidates) {
+    const found = pick(item);
+    if (found) return found;
+  }
+  return null;
+};
+
 const pick = (target: unknown): string | null => {
   if (typeof target === "string") return target;
-  if (Array.isArray(target)) {
-    for (const item of target) {
-      const found = pick(item);
-      if (found) return found;
-    }
-    return null;
-  }
-  if (isRecord(target)) {
-    for (const condition of ["node", "import", "default"]) {
-      if (condition in target) {
-        const found = pick(target[condition]);
-        if (found) return found;
-      }
-    }
-  }
+  if (Array.isArray(target)) return pickFirst(target);
+  if (isRecord(target)) return pickFirst(CONDITIONS.filter((c) => c in target).map((c) => target[c]));
   return null;
 };
 

package/src/plugins/index.ts

@@ -12,7 +12,7 @@ import { PluginConflictError, PluginLoadError } from "../errors.ts";
 import { BUILTIN_CATEGORIES, type LoadedSource } from "../rules/registry.ts";
 import type { Rule } from "../rules/types.ts";
 import type { Plugin } from "./contract.ts";
-import { discoverSources, LOCAL_RULES, type SourceKind } from "./discover.ts";
+import { discoverSources, LOCAL_RULES, type PluginSource, type SourceKind } from "./discover.ts";
 import { loadLocal, loadPackage, toRule } from "./load.ts";
 
 export type PluginMode = "off" | "strict" | "lenient" | "collect";
@@ -33,27 +33,17 @@ export interface PluginSet {
   failures: PluginFailure[];
 }
 
-export const loadPlugins = async (root: string, config: Config, mode: PluginMode): Promise<PluginSet> => {
-  const { sources: found, failures: unresolved } = await discoverSources(root, config, mode === "off");
-  const set: PluginSet = {
-    rules: [],
-    categories: new Map(BUILTIN_CATEGORIES),
-    sources: [],
-    skipped: [],
-    failures: [],
-  };
-  if (mode === "off") {
-    return { ...set, skipped: [...found.map((s) => s.spec), ...unresolved.map((u) => u.error.source)] };
-  }
+type Settle = (error: PluginLoadError, kind: SourceKind) => void;
 
-  // Strict stops at the first failure. The others record it and carry on.
-  const settle = (error: PluginLoadError, kind: SourceKind): void => {
-    if (mode === "strict") throw error;
-    if (!set.failures.some((f) => f.source === error.source)) set.failures.push({ source: error.source, kind, error });
-  };
-  for (const { error, kind } of unresolved) settle(error, kind);
+interface LoadedPlugin {
+  plugin: Plugin;
+  kind: SourceKind;
+  spec: string;
+}
 
-  const loaded: { plugin: Plugin; kind: SourceKind; spec: string }[] = [];
+// Local files load as one plugin, then each package or config source on its own.
+const loadAll = async (found: PluginSource[], settle: Settle): Promise<LoadedPlugin[]> => {
+  const loaded: LoadedPlugin[] = [];
   const locals = found.filter((s) => s.kind === "local");
   if (locals.length > 0) {
     const local = await loadLocal(locals);
@@ -68,34 +58,73 @@ export const loadPlugins = async (root: string, config: Config, mode: PluginMode
       settle(err, source.kind);
     }
   }
+  return loaded;
+};
+
+// Who already holds each namespace and each new category word.
+interface Claims {
+  namespaces: Map<string, string>;
+  declaredBy: Map<string, string>;
+}
 
-  // Namespaces and new categories are global. The first plugin to claim one
-  // keeps it, and a later claimant fails, naming both.
-  const namespaces = new Map<string, string>();
-  const declaredBy = new Map<string, string>();
-  const accepted: typeof loaded = [];
+// The reason a plugin cannot claim its namespace or categories, or null when
+// it can.
+const conflictOf = (plugin: Plugin, spec: string, claims: Claims): PluginConflictError | null => {
+  const { namespace } = plugin.meta;
+  const words = Object.keys(plugin.meta.categories ?? {});
+  const taken = claims.namespaces.get(namespace);
+  const clash = words.find((w) => claims.declaredBy.has(w));
+  if (!(taken || clash)) return null;
+  const other = (taken ?? claims.declaredBy.get(clash as string)) as string;
+  const reason = taken
+    ? `namespace "${namespace}" is already used by ${other}`
+    : `category "${clash}" is already declared by ${other}`;
+  return new PluginConflictError(spec, other, reason);
+};
+
+// Namespaces and new categories are global. The first plugin to claim one
+// keeps it, and a later claimant fails, naming both.
+const acceptClaims = (loaded: LoadedPlugin[], set: PluginSet, settle: Settle): LoadedPlugin[] => {
+  const claims: Claims = { namespaces: new Map(), declaredBy: new Map() };
+  const accepted: LoadedPlugin[] = [];
   for (const entry of loaded) {
     const { plugin, spec, kind } = entry;
-    const { namespace } = plugin.meta;
-    const words = Object.keys(plugin.meta.categories ?? {});
-    const taken = namespaces.get(namespace);
-    const clash = words.find((w) => declaredBy.has(w));
-    if (taken || clash) {
-      const other = (taken ?? declaredBy.get(clash as string)) as string;
-      const reason = taken
-        ? `namespace "${namespace}" is already used by ${other}`
-        : `category "${clash}" is already declared by ${other}`;
-      settle(new PluginConflictError(spec, other, reason), kind);
+    const conflict = conflictOf(plugin, spec, claims);
+    if (conflict) {
+      settle(conflict, kind);
       continue;
     }
-    namespaces.set(namespace, spec);
+    claims.namespaces.set(plugin.meta.namespace, spec);
     for (const [word, description] of Object.entries(plugin.meta.categories ?? {})) {
-      declaredBy.set(word, spec);
+      claims.declaredBy.set(word, spec);
       set.categories.set(word, description);
     }
     accepted.push(entry);
   }
+  return accepted;
+};
+
+export const loadPlugins = async (root: string, config: Config, mode: PluginMode): Promise<PluginSet> => {
+  const { sources: found, failures: unresolved } = await discoverSources(root, config, mode === "off");
+  const set: PluginSet = {
+    rules: [],
+    categories: new Map(BUILTIN_CATEGORIES),
+    sources: [],
+    skipped: [],
+    failures: [],
+  };
+  if (mode === "off") {
+    return { ...set, skipped: [...found.map((s) => s.spec), ...unresolved.map((u) => u.error.source)] };
+  }
+
+  // Strict stops at the first failure. The others record it and carry on.
+  const settle: Settle = (error, kind) => {
+    if (mode === "strict") throw error;
+    if (!set.failures.some((f) => f.source === error.source)) set.failures.push({ source: error.source, kind, error });
+  };
+  for (const { error, kind } of unresolved) settle(error, kind);
 
+  const accepted = acceptClaims(await loadAll(found, settle), set, settle);
   for (const { plugin, kind, spec } of accepted) {
     const rules = Object.entries(plugin.rules).map(([key, rule]) => toRule(plugin.meta.namespace, key, rule));
     set.rules.push(...rules);