@miragon/design-iq-validator 5.4.0 → 5.5.0

package/README.md

@@ -5,8 +5,9 @@ structural checks (flow soundness, complete BPMNDI coverage), DMN structure and
 the generic cross-model reference rule (every required reference — `callActivity` calls,
 `businessRuleTask` decides — must resolve in the repo), and a per-mediaKind parse baseline for
 every other registered notation (a broken `.tt`/`.vc.json` is an ERROR; DSL notations are
-lenient by design; a Mermaid diagram that does not start with a diagram type such as
-`flowchart` or `sequenceDiagram` is a WARN, `mermaid/diagram-type`). Every finding carries a stable `ruleId` (e.g. `bpmn/flow`, `dmn/di`,
+lenient by design; a `mermaid` fence in a Markdown document that does not start with a diagram
+type such as `flowchart` or `sequenceDiagram` is a WARN, `mermaid/diagram-type`, naming the
+document's line). Every finding carries a stable `ruleId` (e.g. `bpmn/flow`, `dmn/di`,
 `refs/dangling`). It treats the target repo as pure data — it never executes content-repo code.
 Exit code 0 = no errors (warnings allowed), 1 = errors.
 

package/dist/cli.js

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { a as runCli } from "./validate-Dy2lNoBR.js";
+import { a as runCli } from "./validate-DjtZJTGk.js";
 //#region src/cli.ts
 /**
 * CLI entry for the platform validator. A dedicated entry file (instead of an

package/dist/{content-DJ1x-ykR.js → content-Bsv9ZLFd.js}

@@ -126,18 +126,6 @@ const NOTATIONS = [
 		mediaKind: "markdown",
 		docShape: "text",
 		monacoLanguage: "markdown"
-	},
-	{
-		id: "mermaid",
-		label: "Mermaid",
-		noun: {
-			singular: "diagram",
-			plural: "diagrams"
-		},
-		extensions: [".mmd", ".mermaid"],
-		mediaKind: "dsl",
-		docShape: "text",
-		monacoLanguage: "plaintext"
 	}
 ];
 function byId(id) {

package/dist/{content-Dld6ZUbs.js → content-wjC_epKd.js}

@@ -1 +1 @@
-export { t as CONTENT_CONFIG_FILE, i as contentConfigConflict, a as discoverModels, o as legacyContentConfigFile, s as loadContentConfig } from "./content-DJ1x-ykR.js";
+export { t as CONTENT_CONFIG_FILE, i as contentConfigConflict, a as discoverModels, o as legacyContentConfigFile, s as loadContentConfig } from "./content-Bsv9ZLFd.js";

package/dist/{validate-Dy2lNoBR.js → validate-DjtZJTGk.js}

@@ -1,4 +1,4 @@
-import { _ as byId, c as resolveContentConfigFile, d as extractModelGraph, f as parseXml, g as byExtension, h as kindOf, l as XMLValidator, m as requirementHref, p as readBpmn, r as CONTENT_CONFIG_NAMES, u as asArray } from "./content-DJ1x-ykR.js";
+import { _ as byId, c as resolveContentConfigFile, d as extractModelGraph, f as parseXml, g as byExtension, h as kindOf, l as XMLValidator, m as requirementHref, p as readBpmn, r as CONTENT_CONFIG_NAMES, u as asArray } from "./content-Bsv9ZLFd.js";
 import { readFileSync } from "node:fs";
 import { relative, resolve } from "node:path";
 //#region ../notations/refs.ts
@@ -84,6 +84,343 @@ const notContentRepoError = (root) => {
 	return found === void 0 ? `[ERROR] ${root}: no ${CONTENT_CONFIG_NAMES} at the root — not a content repo (or wrong --root)` : `[ERROR] ${root}: ${found} at the root names no models folder — not a content repo (or wrong --root)`;
 };
 //#endregion
+//#region ../notations/markdown.ts
+const NONE = { kind: "none" };
+const PARAGRAPH = { kind: "paragraph" };
+const CODE = { kind: "code" };
+const FENCE_OPEN = /^(`{3,}|~{3,})(.*)$/;
+const THEMATIC_BREAK = /^(?:(?:\*[ \t]*){3,}|(?:-[ \t]*){3,}|(?:_[ \t]*){3,})$/;
+const ATX_HEADING = /^#{1,6}(?:[ \t]|$)/;
+const SETEXT_UNDERLINE = /^(?:=+|-+)[ \t]*$/;
+const BULLET = /^[-+*](?=[ \t]|$)/;
+const ORDERED = /^(\d{1,9})[.)](?=[ \t]|$)/;
+const BLANK = /^[ \t]*$/;
+/** a link reference definition on one line: [label]: destination "title" (a
+*  "[^" label is a footnote, which render.ts keeps as paragraph text; a bare
+*  destination ends at a space or a control character, as in markdown-it) */
+const LINK_DEFINITION = /^\[(?!\^)((?:[^[\]\\]|\\.)*)\]:[ \t]*(<(?:[^<>\\]|\\.)*>|[^ <\x00-\x1f\x7f][^ \x00-\x1f\x7f]*)(?:[ \t]+(?:"(?:[^"\\]|\\.)*"|'(?:[^'\\]|\\.)*'|\((?:[^()\\]|\\.)*\)))?[ \t]*$/;
+/** the destinations markdown-it's validateLink refuses: no definition then */
+const BAD_LINK = /^(?:vbscript|javascript|file|data):/i;
+const GOOD_DATA_LINK = /^data:image\/(?:gif|png|jpeg|webp);/i;
+/** markdown-it's maxNesting: content nested this deep (a Container's `level`)
+*  it does not parse, and drops the rest of the innermost quote around it,
+*  or of the document */
+const MAX_NESTING = 100;
+/** start, end and whether it may interrupt a paragraph; an end of /^$/ is the next blank line */
+const HTML_BLOCKS = [
+	[
+		/^<(?:script|pre|style|textarea)(?=\s|>|$)/i,
+		/<\/(?:script|pre|style|textarea)>/i,
+		true
+	],
+	[
+		/^<!--/,
+		/-->/,
+		true
+	],
+	[
+		/^<\?/,
+		/\?>/,
+		true
+	],
+	[
+		/^<![A-Za-z]/,
+		/>/,
+		true
+	],
+	[
+		/^<!\[CDATA\[/,
+		/\]\]>/,
+		true
+	],
+	[
+		new RegExp(`^</?(?:address|article|aside|base|basefont|blockquote|body|caption|center|col|colgroup|dd|details|dialog|dir|div|dl|dt|fieldset|figcaption|figure|footer|form|frame|frameset|h1|h2|h3|h4|h5|h6|head|header|hr|html|iframe|legend|li|link|main|menu|menuitem|nav|noframes|ol|optgroup|option|p|param|search|section|summary|table|tbody|td|tfoot|th|thead|title|tr|track|ul)(?=\\s|/?>|$)`, "i"),
+		/^$/,
+		true
+	],
+	[
+		new RegExp(`^(?:<[A-Za-z][A-Za-z0-9\\-]*(?:\\s+[a-zA-Z_:][a-zA-Z0-9:._-]*(?:\\s*=\\s*(?:[^"'=<>\`\\x00-\\x20]+|'[^']*'|"[^"]*"))?)*\\s*\\/?>|<\\/[A-Za-z][A-Za-z0-9\\-]*\\s*>)\\s*$`),
+		/^$/,
+		false
+	]
+];
+/** the leading blanks of a rest */
+function leading(rest) {
+	let col = rest.col;
+	let i = 0;
+	for (; i < rest.text.length; i++) {
+		const ch = rest.text[i];
+		if (ch === " ") col++;
+		else if (ch === "	") col += 4 - col % 4;
+		else break;
+	}
+	return {
+		indent: col - rest.col,
+		blank: i === rest.text.length
+	};
+}
+/** the columns of leading blanks */
+const indentOf = (rest) => leading(rest).indent;
+/** drop up to `n` columns of leading blanks; a tab cut in two leaves its other columns as spaces */
+function dropIndent(rest, n) {
+	const target = rest.col + n;
+	let col = rest.col;
+	let i = 0;
+	while (i < rest.text.length && col < target) {
+		const ch = rest.text[i];
+		if (ch === " ") col++;
+		else if (ch === "	") {
+			const next = col + 4 - col % 4;
+			if (next > target) return {
+				text: " ".repeat(next - target) + rest.text.slice(i + 1),
+				col: target
+			};
+			col = next;
+		} else break;
+		i++;
+	}
+	return {
+		text: rest.text.slice(i),
+		col
+	};
+}
+/** the line after its indent, when that is at most three columns (more is indented code) */
+function blockStart(rest) {
+	const indent = indentOf(rest);
+	return indent < 4 ? dropIndent(rest, indent) : void 0;
+}
+/** a quote's ">" and the one column of blank after it: a space, or the first
+*  column of a tab (which stays, a column narrower, as in markdown-it) */
+function afterQuoteMarker(at) {
+	const rest = {
+		text: at.text.slice(1),
+		col: at.col + 1
+	};
+	if (rest.text.startsWith(" ") || rest.text.startsWith("	") && rest.col % 4 === 3) return {
+		text: rest.text.slice(1),
+		col: rest.col + 1
+	};
+	return rest.text.startsWith("	") ? {
+		text: rest.text,
+		col: rest.col + 1
+	} : rest;
+}
+/** the rest of the line when it continues the container, undefined when the
+*  container ends. `lead` is the rest's leading blanks, kept up to date across
+*  the columns a list item drops, so a line is not measured once per container */
+function continues(container, rest, lead) {
+	if (container.kind === "quote") {
+		const at = dropIndent(rest, lead.indent);
+		return at.text.startsWith(">") ? afterQuoteMarker(at) : void 0;
+	}
+	const fresh = container.fresh;
+	container.fresh = false;
+	if (lead.blank ? fresh : lead.indent < container.indent) return void 0;
+	lead.indent = Math.max(0, lead.indent - container.indent);
+	return dropIndent(rest, container.indent);
+}
+/** a list item opening at `at` (the line after its indent of `indent` columns),
+*  inside containers nested `level` deep */
+function listItem(at, indent, level, interruptsParagraph) {
+	const ordered = ORDERED.exec(at.text);
+	const marker = ordered ?? BULLET.exec(at.text);
+	if (!marker) return void 0;
+	const after = {
+		text: at.text.slice(marker[0].length),
+		col: at.col + marker[0].length
+	};
+	const empty = BLANK.test(after.text);
+	if (interruptsParagraph && (empty || ordered && Number(ordered[1]) !== 1)) return void 0;
+	const blanks = indentOf(after);
+	const gap = empty || blanks > 4 ? 1 : blanks;
+	return {
+		item: {
+			kind: "item",
+			level: level + 2,
+			indent: indent + marker[0].length + gap,
+			fresh: empty
+		},
+		rest: dropIndent(after, gap)
+	};
+}
+/** the HTML block starting at `text` (a line after its indent), if any */
+function htmlBlock(text) {
+	return text.startsWith("<") ? HTML_BLOCKS.find(([start]) => start.test(text)) : void 0;
+}
+/** whether a line that does not continue a paragraph's containers starts a
+*  block of its own (else it is a lazy continuation line of the paragraph) */
+function startsBlock(rest) {
+	const at = blockStart(rest);
+	if (!at) return false;
+	const text = at.text;
+	return text.startsWith(">") || fenceOpen(text) !== void 0 || THEMATIC_BREAK.test(text) || BULLET.test(text) || ORDERED.test(text) || ATX_HEADING.test(text) || htmlBlock(text)?.[2] === true;
+}
+/** whether `text` (a line after its indent) is a link reference definition that
+*  fits on it and that markdown-it takes: a label with more than blanks, a
+*  destination with balanced parentheses and a scheme its validateLink allows */
+function linkDefinition(text) {
+	const definition = LINK_DEFINITION.exec(text);
+	if (!definition || definition[1].trim() === "") return false;
+	let destination = definition[2];
+	if (destination.startsWith("<")) destination = destination.slice(1, -1);
+	else {
+		let depth = 0;
+		for (let i = 0; i < destination.length && depth >= 0; i++) {
+			const ch = destination[i];
+			if (ch === "\\") i++;
+			else if (ch === "(") depth = depth < 32 ? depth + 1 : -1;
+			else if (ch === ")") depth--;
+		}
+		if (depth !== 0) return false;
+	}
+	destination = destination.trim();
+	return !BAD_LINK.test(destination) || GOOD_DATA_LINK.test(destination);
+}
+/** the opening run of a fence at `text` (a line after its indent), if any */
+function fenceOpen(text) {
+	const open = FENCE_OPEN.exec(text);
+	if (!open) return void 0;
+	const run = open[1];
+	const info = open[2];
+	if (run.startsWith("`") && info.includes("`")) return void 0;
+	return {
+		char: run[0],
+		size: run.length,
+		info: info.trim()
+	};
+}
+/** whether the line is the closing run of `fence` */
+function closes(rest, fence) {
+	const at = blockStart(rest);
+	if (!at) return false;
+	let n = 0;
+	while (at.text[n] === fence.char) n++;
+	return n >= fence.size && BLANK.test(at.text.slice(n));
+}
+/** every fenced code block of a Markdown document, in document order */
+function markdownFences(source) {
+	const lines = source.split(/\r\n|\r|\n/);
+	const brokenLast = BLANK.test(lines[lines.length - 1]);
+	if (brokenLast) lines.pop();
+	const fences = [];
+	const stack = [];
+	const level = () => stack.length > 0 ? stack[stack.length - 1].level : 0;
+	let leaf = NONE;
+	let dropping;
+	const finish = (fence, closed) => {
+		fences.push({
+			line: fence.line,
+			endLine: fence.line + fence.content.length + (closed ? 1 : 0),
+			info: fence.info,
+			lang: (fence.info.split(/\s+/)[0] ?? "").toLowerCase(),
+			content: fence.content.join(""),
+			closed
+		});
+	};
+	for (let i = 0; i < lines.length; i++) {
+		let rest = {
+			text: lines[i],
+			col: 0
+		};
+		const lineBreak = i < lines.length - 1 || brokenLast ? "\n" : "";
+		let matched = 0;
+		let lead;
+		for (const container of stack) {
+			const next = continues(container, rest, lead ??= leading(rest));
+			if (!next) break;
+			rest = next;
+			if (container.kind === "quote") lead = void 0;
+			matched++;
+		}
+		const all = matched === stack.length;
+		if (dropping) {
+			if (all) {
+				dropping.lastBlank = BLANK.test(rest.text);
+				continue;
+			}
+			if (!dropping.lastBlank && !BLANK.test(rest.text) && !startsBlock(rest)) continue;
+			dropping = void 0;
+		}
+		if (leaf.kind === "fence" && all) {
+			if (closes(rest, leaf)) {
+				finish(leaf, true);
+				leaf = NONE;
+			} else leaf.content.push(dropIndent(rest, leaf.indent).text + lineBreak);
+			continue;
+		}
+		if (leaf.kind === "html" && all) {
+			if (leaf.end.test(dropIndent(rest, indentOf(rest)).text)) leaf = NONE;
+			continue;
+		}
+		if (!all) {
+			if (leaf.kind === "paragraph" && !BLANK.test(rest.text) && !startsBlock(rest)) continue;
+			if (leaf.kind === "fence") finish(leaf, false);
+			stack.length = matched;
+			leaf = NONE;
+		}
+		while (level() < MAX_NESTING && !BLANK.test(rest.text)) {
+			const at = blockStart(rest);
+			if (!at) break;
+			if (at.text.startsWith(">")) {
+				stack.push({
+					kind: "quote",
+					level: level() + 1
+				});
+				rest = afterQuoteMarker(at);
+			} else {
+				if (THEMATIC_BREAK.test(at.text)) break;
+				const opening = listItem(at, indentOf(rest), level(), leaf.kind === "paragraph");
+				if (!opening) break;
+				stack.push(opening.item);
+				rest = opening.rest;
+			}
+			leaf = NONE;
+		}
+		if (BLANK.test(rest.text)) {
+			if (leaf.kind === "paragraph") leaf = NONE;
+			continue;
+		}
+		if (level() >= MAX_NESTING) {
+			const quote = stack.findLastIndex((container) => container.kind === "quote");
+			if (quote < 0) break;
+			stack.length = quote + 1;
+			leaf = NONE;
+			dropping = { lastBlank: false };
+			continue;
+		}
+		const at = blockStart(rest);
+		if (!at) {
+			if (leaf.kind !== "paragraph") leaf = CODE;
+			continue;
+		}
+		const open = fenceOpen(at.text);
+		if (open) {
+			leaf = {
+				kind: "fence",
+				...open,
+				indent: indentOf(rest),
+				line: i + 1,
+				content: []
+			};
+			continue;
+		}
+		const html = htmlBlock(at.text);
+		if (html && (html[2] || leaf.kind !== "paragraph")) {
+			leaf = html[1].test(at.text) ? NONE : {
+				kind: "html",
+				end: html[1]
+			};
+			continue;
+		}
+		if (leaf.kind !== "paragraph" && linkDefinition(at.text)) leaf = NONE;
+		else if (ATX_HEADING.test(at.text) || THEMATIC_BREAK.test(at.text)) leaf = NONE;
+		else if (leaf.kind === "paragraph" && SETEXT_UNDERLINE.test(at.text)) leaf = NONE;
+		else leaf = PARAGRAPH;
+	}
+	if (leaf.kind === "fence") finish(leaf, false);
+	return fences;
+}
+//#endregion
 //#region ../notations/mermaid.ts
 /**
 * Every diagram type MERMAID_VERSION renders, spelled as its header keyword
@@ -453,27 +790,20 @@ function checkDmnXml(raw, opts = {}) {
 const COMMON_MERMAID_TYPES = "flowchart, sequenceDiagram, classDiagram, stateDiagram-v2, erDiagram, gantt, pie, mindmap";
 /**
 * Mermaid's own first step (its type detection, @designiq/notations/mermaid
-* mirrors it): after the front matter, directives and comments, the first
-* line must start with a diagram type. Light on purpose: the grammar itself
-* needs mermaid and a DOM, which the validator never loads; the web viewer
-* shows those errors live. A WARN, not an ERROR: .mmd files a content repo
-* already keeps (snippets, a zenuml diagram mermaid does not bundle) turn
-* up as models with this notation, and must neither fail its CI nor block a
-* save.
+* mirrors it) for a ```mermaid fence opening on document line `line`: after
+* the front matter, directives and comments, the diagram's first line must
+* start with a diagram type. Light on purpose: the grammar itself needs
+* mermaid and a DOM, which the validator never loads; the Markdown view
+* shows those errors live. The message names the document's line (a Finding
+* has no line of its own).
 */
-function mermaidHeaderProblem(raw) {
-	const header = mermaidHeader(raw);
-	if (!header) return `empty Mermaid diagram: the first line must name a diagram type (${COMMON_MERMAID_TYPES}, …)`;
+function mermaidFenceProblem(content, line) {
+	const header = mermaidHeader(content);
+	if (!header) return `line ${line}: empty Mermaid diagram: the first line must name a diagram type (${COMMON_MERMAID_TYPES}, …)`;
 	if (header.diagramType) return void 0;
 	const word = header.text.split(/[\s:;]/, 1)[0];
-	return `line ${header.line}: '${word}' is not a Mermaid diagram type (${COMMON_MERMAID_TYPES}, …)`;
+	return `line ${line + header.line}: '${word}' is not a Mermaid diagram type (${COMMON_MERMAID_TYPES}, …)`;
 }
-/** notation id → the check of its DSL's header line (a WARN under its own
-*  rule id); a DSL without one stays as lenient as its extractor */
-const DSL_HEADER_CHECKS = { mermaid: {
-	ruleId: "mermaid/diagram-type",
-	problem: mermaidHeaderProblem
-} };
 /**
 * Baseline parse gate for models WITHOUT a dedicated checker (any registered
 * notation that is not .bpmn/.dmn): a discovered model must at minimum parse
@@ -507,21 +837,21 @@ function checkModelBaseline(raw, opts) {
 			if (wf !== true) err(`not well-formed XML: ${wf.err.msg}`);
 			break;
 		}
-		case "dsl": {
+		case "dsl":
 			try {
 				extractModelGraph(opts.notation, raw);
 			} catch (e) {
 				err(`not parseable: ${e.message}`);
 			}
-			const header = DSL_HEADER_CHECKS[opts.notation];
-			const problem = header?.problem(raw);
-			if (header && problem) findings.push({
+			break;
+		case "markdown": for (const fence of markdownFences(raw)) {
+			const problem = fence.lang === "mermaid" ? mermaidFenceProblem(fence.content, fence.line) : void 0;
+			if (problem) findings.push({
 				severity: "WARN",
-				ruleId: header.ruleId,
+				ruleId: "mermaid/diagram-type",
 				file,
 				message: problem
 			});
-			break;
 		}
 	}
 	return findings;
@@ -586,7 +916,7 @@ async function runCli() {
 	/** optional single-model filter (a model file stem) */
 	const only = argv[0];
 	const rel = (p) => p.startsWith("/") ? relative(ROOT, p) : p;
-	const { CONTENT_CONFIG_FILE, contentConfigConflict, discoverModels, legacyContentConfigFile, loadContentConfig } = await import("./content-Dld6ZUbs.js");
+	const { CONTENT_CONFIG_FILE, contentConfigConflict, discoverModels, legacyContentConfigFile, loadContentConfig } = await import("./content-wjC_epKd.js");
 	const cfg = loadContentConfig(ROOT);
 	if (!cfg) {
 		console.error(notContentRepoError(ROOT));

package/dist/validate.js

@@ -1 +1 @@
-export { t as checkBpmnXml, n as checkDmnXml, r as checkModel, i as checkModelBaseline, a as runCli } from "./validate-Dy2lNoBR.js";
+export { t as checkBpmnXml, n as checkDmnXml, r as checkModel, i as checkModelBaseline, a as runCli } from "./validate-DjtZJTGk.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@miragon/design-iq-validator",
-  "version": "5.4.0",
+  "version": "5.5.0",
   "type": "module",
   "description": "Platform-owned validator for designIQ content repos — designiq.yml discovery, BPMN/DMN structure and diagram coverage, cross-model references, and a parse check for every other notation. Runs against any checkout via --root; never executes content-repo code.",
   "license": "MIT",