@jpeakai/mermaidjs-lint 0.2.0 → 0.3.0

package/dist/testing.js

@@ -547,12 +547,10 @@ function adaptMindmap(db) {
 }
 function adaptQuadrantChart(db) {
   const data = callGetter(db, "getQuadrantData");
-  const quadrants = data?.quadrants ?? [];
-  const labels = quadrants.map((q) => {
-    const t = q.text;
-    return typeof t === "string" ? t : t?.text ?? "";
-  });
-  return { nodeIds: labels, edges: 0, subgraphNames: [], maxDepth: 0 };
+  const textOf = (t) => typeof t === "string" ? t : t?.text ?? "";
+  const quadrants = (data?.quadrants ?? []).map((q) => textOf(q.text)).filter((t) => t.trim() !== "");
+  const points = (data?.points ?? []).map((p, i) => textOf(p.text) || `point_${i}`);
+  return { nodeIds: [...quadrants, ...points], edges: 0, subgraphNames: [], maxDepth: 0 };
 }
 function adaptRequirement(db) {
   const requirements = db.requirements instanceof Map ? db.requirements : new Map;
@@ -578,18 +576,30 @@ function adaptSankey(db) {
 function adaptState(db) {
   const nodes = db.nodes ?? [];
   const edges = db.edges ?? [];
+  const groups = nodes.filter((n) => n.isGroup === true);
+  const parentOf = new Map(nodes.map((n) => [n.id ?? "", n.parentId]));
+  let maxDepth = 0;
+  for (const g of groups) {
+    let depth = 1;
+    const seen = new Set;
+    for (let cur = g.parentId;cur && !seen.has(cur); cur = parentOf.get(cur)) {
+      seen.add(cur);
+      depth++;
+    }
+    maxDepth = Math.max(maxDepth, depth);
+  }
   return {
     nodeIds: nodes.map((n) => n.id ?? ""),
     edges: edges.length,
-    subgraphNames: [],
-    maxDepth: 0
+    subgraphNames: groups.map((g) => g.id ?? ""),
+    maxDepth
   };
 }
 function adaptTimeline(db) {
   const tasks = callGetter(db, "getTasks") ?? [];
   const sections = callGetter(db, "getSections") ?? [];
   return {
-    nodeIds: tasks.map((t) => t.task ?? ""),
+    nodeIds: tasks.flatMap((t) => [t.task ?? "", ...(t.events ?? []).map((e) => `${t.task ?? ""}: ${e}`)]),
     edges: 0,
     subgraphNames: sections.map((s) => s.sectionName ?? s.section ?? ""),
     maxDepth: sections.length > 0 ? 1 : 0
@@ -619,7 +629,10 @@ function adaptVenn(db) {
 function adaptXychart(db) {
   const data = callGetter(db, "getXYChartData");
   const categories = data?.xAxis?.categories ?? [];
-  return { nodeIds: categories, edges: 0, subgraphNames: [], maxDepth: 0 };
+  if (categories.length > 0)
+    return { nodeIds: categories, edges: 0, subgraphNames: [], maxDepth: 0 };
+  const longest = Math.max(0, ...(data?.plots ?? []).map((p) => p.data?.length ?? 0));
+  return { nodeIds: Array.from({ length: longest }, (_, i) => `x_${i}`), edges: 0, subgraphNames: [], maxDepth: 0 };
 }
 function subgraphNestingDepth(subGraphs) {
   if (subGraphs.length === 0)
@@ -784,6 +797,15 @@ class RuleOptionError extends UsageError {
     this.option = option;
   }
 }
+class FixNotConvergingError extends MermaidLintError {
+  file;
+  rules;
+  constructor(file, passes, rules) {
+    super("fix-not-converging", `${file}: --fix did not converge after ${passes} passes; ${rules.join(", ")} kept proposing edits. A fixer must propose nothing once its edit is applied`);
+    this.file = file;
+    this.rules = rules;
+  }
+}
 
 class PluginLoadError extends MermaidLintError {
   source;
@@ -1663,13 +1685,17 @@ var sameDiagrams = async (before, after) => {
 };
 var verify = async (edit, before, after) => {
   if (edit.expect.kind === "same-tree") {
-    return sameTree(before.tree, after.tree, {}) ? "accept" : "refuse";
+    if (!sameTree(before.tree, after.tree, {}))
+      return "refuse";
+    if (before.kind === "markdown" && after.kind === "markdown")
+      return "accept";
   }
   return await sameDiagrams(before, after) ? "accept" : "refuse";
 };
 
 // src/fix/engine.ts
 var MAX_PASSES = 1000;
+var RECENT_PASSES = 50;
 var splice = (src, edits) => {
   let out = src;
   for (const e of [...edits].sort((a, b) => b.start - a.start))
@@ -1687,6 +1713,7 @@ var fixSourceReport = async (src, file, flags = {}, registry = BUILTIN) => {
   const refused = [];
   const refusedKeys = new Set;
   let current = src;
+  const keptBy = [];
   for (let pass = 0;pass < MAX_PASSES; pass++) {
     const doc = buildDocModel(current, kind);
     const keyOf = (e) => `${e.rule}\x00${current.slice(e.start, e.end)}\x00${e.text}`;
@@ -1719,35 +1746,39 @@ var fixSourceReport = async (src, file, flags = {}, registry = BUILTIN) => {
         continue;
       if (edits.length > 1 && !overlaps(edits) && await attempt(edits)) {
         progressed = true;
-        break;
-      }
-      for (const edit of edits) {
-        if (await attempt([edit])) {
-          progressed = true;
-          break;
+      } else {
+        for (const edit of edits) {
+          if (await attempt([edit])) {
+            progressed = true;
+            break;
+          }
+          refusedKeys.add(keyOf(edit));
+          refused.push(edit);
         }
-        refusedKeys.add(keyOf(edit));
-        refused.push(edit);
       }
-      if (progressed)
+      if (progressed) {
+        keptBy.push(rule.id);
         break;
+      }
     }
     if (!progressed)
       return { output: current, applied, refused };
   }
-  throw new Error(`fix did not converge after ${MAX_PASSES} passes; a fixer keeps proposing edits`);
+  const lingering = [...new Set(keptBy.slice(-RECENT_PASSES))].sort();
+  throw new FixNotConvergingError(file, MAX_PASSES, lingering);
 };
 
 // src/plugins/contract.ts
 var API_VERSION = 1;
 var CATEGORY_WORD = /^[a-z]+$/;
-var NAMESPACE = /^[a-z][a-z0-9-]*$/;
-var RULE_KEY = /^[a-z][a-z0-9-]*$/;
+var NAMESPACE = /^[a-z][a-z0-9]*(-[a-z0-9]+)*$/;
+var RULE_KEY = /^[a-z][a-z0-9]*(-[a-z0-9]+)*$/;
 
 // src/plugins/load.ts
 var isRecord = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
 var message2 = (err) => err instanceof Error ? err.message : String(err);
 var OPTION_TYPES = new Set(["number", "string", "boolean", "string[]"]);
+var RESERVED_OPTIONS = ["preset", "profile"];
 var checkRule = (spec, key, raw, own) => {
   const where = `rule "${key}"`;
   if (!isRecord(raw))
@@ -1777,6 +1808,11 @@ var checkRule = (spec, key, raw, own) => {
     if (!valid) {
       throw new PluginContractError(spec, `${where} options must map names to number, string, boolean or string[]`);
     }
+    for (const name of RESERVED_OPTIONS) {
+      if (name in options && options[name] !== "string") {
+        throw new PluginContractError(spec, `${where} declares option "${name}" as ${String(options[name])}, but "${name}" is reserved for the built-in ${name}, which is a string set by --${name}; declare it as "string" to follow the run's ${name}, or pick another name`);
+      }
+    }
   }
   return raw;
 };

package/dist/types/bin.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/types/check.d.ts

@@ -0,0 +1,10 @@
+import { type DocModel } from "./model.ts";
+import { type Registry } from "./rules/registry.ts";
+import type { Finding, Rule, RuleOptions } from "./rules/types.ts";
+export interface RunFlags {
+    preset?: string;
+    profile?: string;
+}
+export declare const optionsFor: (rule: Rule, configured: RuleOptions | undefined, flags: RunFlags) => RuleOptions;
+export declare const checkModel: (doc: DocModel, file: string, flags?: RunFlags, registry?: Registry) => Promise<Finding[]>;
+export declare const checkMarkdown: (src: string, file: string, flags?: RunFlags, registry?: Registry) => Promise<Finding[]>;

package/dist/types/cli.d.ts

@@ -0,0 +1,9 @@
+import type { PluginFailure } from "./plugins/index.ts";
+import type { LoadedSource, Registry } from "./rules/registry.ts";
+import { type Finding } from "./rules/types.ts";
+export declare const loadedLine: (sources: LoadedSource[], skipped: string[]) => string | null;
+export declare const skippedLines: (failures: PluginFailure[], ignored: string[]) => string[];
+export declare const listRules: (registry: Registry) => string;
+export declare const reportLine: (f: Finding, file: string) => string;
+export declare const describeError: (err: unknown) => string;
+export declare const main: (argv?: string[], cwd?: string) => Promise<number>;

package/dist/types/config.d.ts

@@ -0,0 +1,20 @@
+import { UsageError } from "./errors.ts";
+import type { RuleOptions } from "./rules/types.ts";
+export { UsageError };
+export type Severity = "error" | "off";
+export type PluginLoading = "strict" | "lenient";
+export interface RuleSetting {
+    severity: Severity;
+    options: RuleOptions;
+}
+export interface Config {
+    plugins: string[] | false;
+    pluginLoading: PluginLoading;
+    rules: Map<string, RuleSetting>;
+    file: string | null;
+}
+export declare const NO_CONFIG: Config;
+export declare const CONFIG_FILES: readonly ["mermaidjs-lint.config.json", "mermaidjs-lint.config.mjs"];
+export declare const parseConfig: (file: string, raw: unknown) => Config;
+export declare const findConfig: (root: string) => Promise<string | null>;
+export declare const loadConfig: (file: string) => Promise<Config>;

package/dist/types/errors.d.ts

@@ -0,0 +1,88 @@
+export declare class MermaidLintError extends Error {
+    readonly code: string;
+    constructor(code: string, message: string);
+}
+export declare class UsageError extends MermaidLintError {
+    constructor(message: string, code?: string);
+}
+export declare class FlagError extends UsageError {
+    readonly flag: string;
+    constructor(flag: string, message: string);
+}
+export declare class ConfigFileError extends UsageError {
+    readonly file: string;
+    constructor(file: string, message: string);
+}
+export declare class ConfigNotFoundError extends UsageError {
+    readonly path: string;
+    constructor(path: string);
+}
+export declare class ConfigCodeError extends UsageError {
+    readonly file: string;
+    constructor(file: string);
+}
+export declare class AmbiguousConfigError extends UsageError {
+    readonly files: string[];
+    constructor(root: string, files: string[]);
+}
+export declare class ConfigShapeError extends UsageError {
+    readonly file: string;
+    readonly key: string | null;
+    constructor(file: string, message: string, key?: string | null);
+}
+export declare class RuleSettingError extends UsageError {
+    readonly file: string;
+    readonly rule: string;
+    constructor(file: string, rule: string, message: string);
+}
+export declare class UnknownRuleError extends UsageError {
+    readonly file: string;
+    readonly rule: string;
+    readonly known: string[];
+    constructor(file: string, rule: string, known: string[]);
+}
+export declare class RuleOptionError extends UsageError {
+    readonly file: string;
+    readonly rule: string;
+    readonly option: string;
+    constructor(file: string, rule: string, option: string, message: string);
+}
+export declare class FixOutsideRootError extends UsageError {
+    readonly file: string;
+    readonly target: string;
+    constructor(file: string, target: string, root: string);
+}
+export declare class PackageJsonError extends MermaidLintError {
+    readonly file: string;
+    constructor(file: string);
+}
+export declare class FixNotConvergingError extends MermaidLintError {
+    readonly file: string;
+    readonly rules: string[];
+    constructor(file: string, passes: number, rules: string[]);
+}
+export declare class PluginLoadError extends MermaidLintError {
+    readonly source: string;
+    constructor(source: string, reason: string, code?: string);
+}
+export declare class PluginImportError extends PluginLoadError {
+    constructor(source: string, reason: string);
+}
+export declare class PluginContractError extends PluginLoadError {
+    constructor(source: string, reason: string);
+}
+export declare class PluginConflictError extends PluginLoadError {
+    readonly other: string;
+    constructor(source: string, other: string, reason: string);
+}
+export declare class PluginNotInstalledError extends PluginLoadError {
+    readonly root: string;
+    constructor(source: string, root: string);
+}
+export declare class PluginSourceError extends PluginLoadError {
+    constructor(source: string, reason: string);
+}
+export declare class PluginFixerError extends MermaidLintError {
+    readonly rule: string;
+    constructor(rule: string, reason: string);
+}

package/dist/types/files.d.ts

@@ -0,0 +1,8 @@
+export declare const DIAGRAM_FILE_EXTS: Set<string>;
+export declare const SKIP_DIRS: Set<string>;
+export interface Collected {
+    files: string[];
+    unreadable: string[];
+    symlinks: string[];
+}
+export declare const collectFiles: (paths: string[]) => Collected;

package/dist/types/fix/engine.d.ts

@@ -0,0 +1,10 @@
+import { type RunFlags } from "../check.ts";
+import { type Registry } from "../rules/registry.ts";
+import type { Edit } from "../rules/types.ts";
+export interface FixReport {
+    output: string;
+    applied: Edit[];
+    refused: Edit[];
+}
+export declare const fixSourceReport: (src: string, file: string, flags?: RunFlags, registry?: Registry) => Promise<FixReport>;
+export declare const fixSource: (src: string, file: string, flags?: RunFlags, registry?: Registry) => Promise<string>;

package/dist/types/fix/verify.d.ts

@@ -0,0 +1,12 @@
+import type { Node } from "mdast";
+import type { DocModel } from "../model.ts";
+import type { Edit } from "../rules/types.ts";
+type Plain = {
+    [k: string]: unknown;
+};
+export declare const normalise: (node: Node, opts?: {
+    blankDiagrams?: boolean;
+}) => Plain;
+export type Verdict = "accept" | "refuse";
+export declare const verify: (edit: Edit, before: DocModel, after: DocModel) => Promise<Verdict>;
+export {};

package/dist/types/index.d.ts

@@ -0,0 +1,18 @@
+export { checkMarkdown, checkModel, type RunFlags } from "./check.ts";
+export { main } from "./cli.ts";
+export { type Config, loadConfig, type PluginLoading, parseConfig, type RuleSetting, type Severity } from "./config.ts";
+export * from "./errors.ts";
+export { type Collected, collectFiles } from "./files.ts";
+export { type FixReport, fixSource, fixSourceReport } from "./fix/engine.ts";
+export { buildDocModel, DIAGRAM_EXTS, type Diagram, type DocModel, documentKind } from "./model.ts";
+export type { ContrastAssessment, StyleDirective, ValueSpan } from "./parse/color.ts";
+export { PRESETS, type Preset, type ThresholdConfig, thresholdsFrom } from "./parse/metrics.ts";
+export { type DiagramStats, detectKeyword, extractStats } from "./parse/stats.ts";
+export type { Plugin, PluginEdit, PluginFinding, PluginMeta, PluginRule } from "./plugins/contract.ts";
+export type { SourceKind } from "./plugins/discover.ts";
+export type { PluginFailure } from "./plugins/index.ts";
+export { findProjectRoot, type Setup, type SetupOptions, setUp } from "./project.ts";
+export { FIX_ORDER, RULES } from "./rules/index.ts";
+export { BUILTIN, BUILTIN_CATEGORIES, buildRegistry, type LoadedSource, type Registry, type RegistryInput, } from "./rules/registry.ts";
+export type { Category, CheckContext, CoreRuleId, Edit, Expectation, Finding, FixContext, Helpers, OptionSpec, OptionType, PluginRuleId, Rule, RuleContext, RuleId, RuleOptions, } from "./rules/types.ts";
+export { CATEGORIES, RULE } from "./rules/types.ts";

package/dist/types/model.d.ts

@@ -0,0 +1,27 @@
+import type { Root } from "mdast";
+import { type StyleDirective, type ValueSpan } from "./parse/color.ts";
+import { type DiagramStats } from "./parse/stats.ts";
+export interface Diagram {
+    index: number;
+    source: string;
+    keyword: string | null;
+    startLine: number;
+    endLine: number;
+    firstLine: number;
+    terminated: boolean;
+    endOffset: number;
+    directives: StyleDirective[];
+    offsetOf: (span: ValueSpan) => number | null;
+    stats: () => Promise<DiagramStats>;
+}
+export interface DocModel {
+    src: string;
+    kind: "markdown" | "diagram";
+    tree: Root;
+    diagrams: Diagram[];
+}
+export declare const parse: (src: string) => Root;
+export declare const DIAGRAM_EXTS: readonly [".mmd", ".mermaid"];
+export declare const documentKind: (file: string) => "markdown" | "diagram";
+export declare const buildDocModel: (src: string, kind?: "markdown" | "diagram") => DocModel;
+export declare const isMarkdownFile: (file: string) => boolean;

package/dist/types/parse/color.d.ts

@@ -0,0 +1,28 @@
+export type WcagRating = "AAA" | "AA" | "AA Large" | "Fail";
+export interface ContrastAssessment {
+    foreground: string;
+    background: string;
+    ratio: number;
+    rating: WcagRating;
+    apca_lc: number;
+}
+export declare const wcagRatio: (fg: string, bg: string) => number;
+export declare const apcaLc: (fg: string, bg: string) => number;
+export declare const alphaOf: (color: string) => number;
+export declare const compositeOver: (fg: string, bg: string) => string;
+export declare const wcagRating: (ratio: number) => WcagRating;
+export declare const wcagAssess: (fg: string, bg: string) => ContrastAssessment;
+export interface ValueSpan {
+    line: number;
+    start: number;
+    end: number;
+}
+export interface StyleDirective {
+    kind: "classDef" | "style" | "linkStyle" | "inlineClass";
+    selector: string;
+    class_name?: string;
+    properties: Record<string, string>;
+    spans: Record<string, ValueSpan>;
+    line: number;
+}
+export declare const extractStyleDirectives: (source: string) => StyleDirective[];

package/dist/types/parse/contrast.d.ts

@@ -0,0 +1,35 @@
+import { type ContrastAssessment, type StyleDirective } from "./color.ts";
+export type Profile = "github" | "mkdocs-material";
+export type Theme = "light" | "dark";
+export type PairKind = "text" | "border";
+export type ErRow = "odd" | "even";
+export declare const PROFILES: readonly ["auto", "github", "mkdocs-material"];
+export declare const edgeLabelBackground: (theme: Theme) => string;
+export interface ContrastPair {
+    kind: PairKind;
+    selector: string;
+    directive: StyleDirective;
+    foreground: string;
+    background: string;
+    line: number;
+    assessment: ContrastAssessment;
+    passes: boolean;
+    theme?: Theme;
+    row?: ErRow;
+    advisory?: boolean;
+}
+export interface SkippedDirective {
+    selector: string;
+    line: number;
+    reason: string;
+    blocking?: boolean;
+}
+export interface ContrastResult {
+    pairs: ContrastPair[];
+    skipped: SkippedDirective[];
+}
+export declare const scoreGithub: (directives: StyleDirective[]) => ContrastResult;
+export declare const scoreMkdocs: (directives: StyleDirective[]) => ContrastResult;
+export declare const scoreEr: (directives: StyleDirective[]) => ContrastResult;
+export declare const scoreForProfile: (directives: StyleDirective[], profile: Profile, keyword: string | null) => ContrastResult;
+export declare const detectProfile: (filePath: string) => Profile;

package/dist/types/parse/metrics.d.ts

@@ -0,0 +1,48 @@
+import type { DiagramStats } from "./stats.ts";
+export interface Preset {
+    node_ideal: number;
+    node_acceptable: number;
+    node_complex: number;
+    node_hard_limit: number;
+    vcs_ideal: number;
+    vcs_acceptable: number;
+    vcs_complex: number;
+    vcs_critical: number;
+    node_target: number;
+    vcs_target: number;
+}
+export declare const PRESETS: Record<string, Preset>;
+export declare const DEFAULT_PRESET = "high-density";
+export interface ThresholdConfig extends Preset {
+    edge_weight: number;
+    subgraph_weight: number;
+    depth_weight: number;
+    preset_name: string;
+}
+export declare const THRESHOLD_OPTIONS: {
+    readonly nodeIdeal: "node_ideal";
+    readonly nodeAcceptable: "node_acceptable";
+    readonly nodeComplex: "node_complex";
+    readonly nodeHardLimit: "node_hard_limit";
+    readonly vcsIdeal: "vcs_ideal";
+    readonly vcsAcceptable: "vcs_acceptable";
+    readonly vcsComplex: "vcs_complex";
+    readonly vcsCritical: "vcs_critical";
+    readonly nodeTarget: "node_target";
+    readonly vcsTarget: "vcs_target";
+    readonly edgeWeight: "edge_weight";
+    readonly subgraphWeight: "subgraph_weight";
+    readonly depthWeight: "depth_weight";
+};
+export declare const PRESET_NAMES: string[];
+export declare const canonicalPreset: (name: string) => string | null;
+export declare const configFromPreset: (name: string) => ThresholdConfig;
+export declare const thresholdsFrom: (options: Readonly<Record<string, unknown>>) => ThresholdConfig;
+export interface ComplexityMetrics {
+    visual_complexity_score: number;
+    edge_density: number;
+    cyclomatic_complexity: number;
+}
+export declare const calculateComplexity: (stats: DiagramStats, config: ThresholdConfig) => ComplexityMetrics;
+export declare const parseFailed: (content: string, stats: DiagramStats) => boolean;
+export declare const sourceLines: (content: string) => number;

package/dist/types/parse/stats.d.ts

@@ -0,0 +1,24 @@
+export interface DiagramStats {
+    nodes: number;
+    edges: number;
+    subgraphs: number;
+    max_subgraph_depth: number;
+    node_ids: string[];
+    subgraph_names: string[];
+    parser_used: "langium" | "mermaid-core";
+    diagram_type: string;
+    error: string | null;
+}
+type MermaidStats = DiagramStats;
+export declare function detectKeyword(content: string): string | null;
+export declare function extractStats(content: string): Promise<MermaidStats>;
+export declare const parserReason: (err: unknown) => string;
+export declare function indentTreeStats(items: Array<{
+    label: string;
+    indent: number;
+}>): {
+    labels: string[];
+    edges: number;
+    depth: number;
+};
+export {};

package/dist/types/plugins/contract.d.ts

@@ -0,0 +1,24 @@
+import type { Awaitable, CheckContext, Edit, Finding, FixContext, OptionSpec } from "../rules/types.ts";
+export declare const API_VERSION = 1;
+export type PluginFinding = Pick<Finding, "line" | "message"> & Partial<Pick<Finding, "endLine" | "remediation">>;
+export type PluginEdit = Omit<Edit, "rule">;
+export interface PluginRule {
+    category: string;
+    summary: string;
+    options?: OptionSpec;
+    check: (ctx: CheckContext) => Awaitable<PluginFinding[]>;
+    fix?: (ctx: FixContext) => Awaitable<PluginEdit[]>;
+}
+export interface PluginMeta {
+    name: string;
+    namespace: string;
+    apiVersion: number;
+    categories?: Record<string, string>;
+}
+export interface Plugin {
+    meta: PluginMeta;
+    rules: Record<string, PluginRule>;
+}
+export declare const CATEGORY_WORD: RegExp;
+export declare const NAMESPACE: RegExp;
+export declare const RULE_KEY: RegExp;

package/dist/types/plugins/discover.d.ts

@@ -0,0 +1,20 @@
+import type { Config } from "../config.ts";
+import { PluginLoadError } from "../errors.ts";
+export type SourceKind = "local" | "package" | "config";
+export interface PluginSource {
+    kind: SourceKind;
+    spec: string;
+    path: string;
+}
+export interface UnresolvedSource {
+    kind: SourceKind;
+    error: PluginLoadError;
+}
+export interface Discovery {
+    sources: PluginSource[];
+    failures: UnresolvedSource[];
+}
+export declare const LOCAL_RULES: string;
+export declare const PACKAGE_PATTERN: RegExp;
+export declare const resolvePackage: (root: string, name: string) => Promise<string>;
+export declare const discoverSources: (root: string, config: Config, pluginsOff?: boolean) => Promise<Discovery>;

package/dist/types/plugins/index.d.ts

@@ -0,0 +1,19 @@
+import type { Config } from "../config.ts";
+import { PluginLoadError } from "../errors.ts";
+import { type LoadedSource } from "../rules/registry.ts";
+import type { Rule } from "../rules/types.ts";
+import { type SourceKind } from "./discover.ts";
+export type PluginMode = "off" | "strict" | "lenient" | "collect";
+export interface PluginFailure {
+    source: string;
+    kind: SourceKind;
+    error: PluginLoadError;
+}
+export interface PluginSet {
+    rules: Rule[];
+    categories: Map<string, string>;
+    sources: LoadedSource[];
+    skipped: string[];
+    failures: PluginFailure[];
+}
+export declare const loadPlugins: (root: string, config: Config, mode: PluginMode) => Promise<PluginSet>;

package/dist/types/plugins/load.d.ts

@@ -0,0 +1,14 @@
+import { PluginLoadError } from "../errors.ts";
+import type { Rule } from "../rules/types.ts";
+import { type Plugin, type PluginRule } from "./contract.ts";
+import type { PluginSource } from "./discover.ts";
+import { type RuntimeInfo } from "./runtime.ts";
+export { PluginLoadError };
+export declare const parsePlugin: (spec: string, raw: unknown, reserved: ReadonlySet<string>) => Plugin;
+export declare const loadPackage: (source: PluginSource, reserved: ReadonlySet<string>) => Promise<Plugin>;
+export interface LocalLoad {
+    plugin: Plugin | null;
+    failures: PluginLoadError[];
+}
+export declare const loadLocal: (sources: PluginSource[], runtime?: RuntimeInfo) => Promise<LocalLoad>;
+export declare const toRule: (namespace: string, key: string, rule: PluginRule) => Rule;

package/dist/types/plugins/runtime.d.ts

@@ -0,0 +1,6 @@
+export interface RuntimeInfo {
+    versions: Record<string, string | undefined>;
+    features: Record<string, unknown>;
+}
+export declare const canImportTypeScript: (runtime?: RuntimeInfo) => boolean;
+export declare const TYPESCRIPT_HELP = "TypeScript cannot be imported by this runtime. Run with Bun (bunx --bun @jpeakai/mermaidjs-lint), use Node 22.18 or newer, or write a .js or .mjs file";

package/dist/types/project.d.ts

@@ -0,0 +1,18 @@
+import { type PluginFailure } from "./plugins/index.ts";
+import { type Registry } from "./rules/registry.ts";
+export declare const LOCAL_DIR = ".mermaidjs-lint";
+export declare const findProjectRoot: (cwd: string) => Promise<string>;
+export interface SetupOptions {
+    cwd: string;
+    configPath?: string;
+    noPlugins?: boolean;
+    lenient?: boolean;
+    collect?: boolean;
+}
+export interface Setup {
+    root: string;
+    registry: Registry;
+    skipped: string[];
+    failures: PluginFailure[];
+}
+export declare const setUp: ({ cwd, configPath, noPlugins, lenient, collect, }: SetupOptions) => Promise<Setup>;

package/dist/types/rules/complexity-node-count-acceptable-exceeded.d.ts

@@ -0,0 +1 @@
+export declare const complexityNodeCountAcceptableExceeded: import("./types.ts").Rule;

package/dist/types/rules/complexity-node-count-cognitive-limit.d.ts

@@ -0,0 +1 @@
+export declare const complexityNodeCountCognitiveLimit: import("./types.ts").Rule;

package/dist/types/rules/complexity-node-count-hard-limit.d.ts

@@ -0,0 +1 @@
+export declare const complexityNodeCountHardLimit: import("./types.ts").Rule;

package/dist/types/rules/complexity-subgraph-nesting-too-deep.d.ts

@@ -0,0 +1,2 @@
+export declare const MAX_NESTING = 3;
+export declare const complexitySubgraphNestingTooDeep: import("./types.ts").Rule;

package/dist/types/rules/complexity-visual-score-acceptable-exceeded.d.ts

@@ -0,0 +1 @@
+export declare const complexityVisualScoreAcceptableExceeded: import("./types.ts").Rule;

package/dist/types/rules/complexity-visual-score-critical.d.ts

@@ -0,0 +1 @@
+export declare const complexityVisualScoreCritical: import("./types.ts").Rule;