@aoelite/refpact-ts 0.0.0-stage → 0.2.0

package/dist/rules.js

@@ -0,0 +1,665 @@
+/** Rules for TypeScript projects, written as plain values in a test file. */
+import { isBuiltin } from "node:module";
+import { applyBaseline, diagram, evaluate, graph, renderErrors, renderStale, renderViolations, select, tangles } from "./core/index.js";
+import { ItemScope, Scope } from "./custom.js";
+import { addFilters } from "./filters.js";
+import { filePattern, targetPattern } from "./patterns.js";
+import { KINDS, MARKERS } from "./frontend/imports.js";
+import { ItemSelection } from "./items.js";
+import { exportSegment, globalSegment, nodeSegment, packageSegment } from "./frontend/paths.js";
+import { DEPENDENCY_KINDS, NAMED_DEPENDENCY_KINDS, PACKAGE_ITEM_KIND } from "./frontend/dependencies.js";
+import path from "node:path";
+/** A package, a subpath of a package, or one export of it, as a target of a rule. */
+export class PackageTarget {
+    /** @internal */
+    segments;
+    /** @internal */
+    constructor(segments) {
+        this.segments = segments;
+    }
+    /** One export of the package: `pkg("lodash").export("debounce")`. Use `default` for the default export. */
+    export(name) {
+        return new PackageTarget([...this.segments, exportSegment(name)]);
+    }
+}
+/**
+ * A package as a target: `pkg("lodash")`, `pkg("@scope/name")`, `pkg("lodash/fp")` for a
+ * subpath, `pkg("node:fs")` or `pkg("fs")` for a module of Node. The target covers all
+ * subpaths and all exports of the package. `*` matches a part of the name: `pkg("@aws-sdk/*")`.
+ */
+export function pkg(specifier) {
+    if (specifier.startsWith("node:") || isBuiltin(specifier)) {
+        const [name, ...rest] = specifier.replace(/^node:/, "").split("/");
+        return new PackageTarget([nodeSegment(name), ...rest]);
+    }
+    const parts = specifier.split("/");
+    const nameLength = specifier.startsWith("@") ? 2 : 1;
+    return new PackageTarget([packageSegment(parts.slice(0, nameLength).join("/")), ...parts.slice(nameLength)]);
+}
+/**
+ * A global of the host as a target: `globalApi("fetch")`, `globalApi("process")`, or one member
+ * of it, `globalApi("process.env")`. The target of a global covers its members. A use of a
+ * global counts as an import of it, of the kind `global`: see {@link KINDS}. `*` matches a
+ * part of the name: `globalApi("*Storage")`.
+ *
+ * A global is a name that no file of the project declares and that the ECMAScript library
+ * does not declare: the globals of Node, of the browser and of other hosts, such as
+ * `process`, `fetch`, `window`, `document` and `localStorage`. `Math`, `Date`, `JSON` and
+ * `Promise` are part of the language and are no globals here.
+ */
+export function globalApi(name) {
+    const [global, ...members] = name.split(".");
+    return new PackageTarget([globalSegment(global), ...members.slice(0, 1).map(exportSegment)]);
+}
+/** A selection of files. */
+export class Files {
+    /** @internal */
+    include;
+    /** @internal */
+    excluded;
+    /** @internal */
+    constructor(include, excluded) {
+        this.include = include;
+        this.excluded = excluded;
+    }
+}
+/** A set of forbidden targets. */
+export class Targets {
+    /** @internal */
+    anyOf;
+    /** @internal */
+    unverified;
+    /** @internal */
+    constructor(anyOf, unverified) {
+        this.anyOf = anyOf;
+        this.unverified = unverified;
+    }
+}
+/** A list of patterns that form a union. */
+export class AnyOf {
+    /** @internal */
+    patterns;
+    /** @internal */
+    constructor(patterns) {
+        this.patterns = patterns;
+    }
+    /** Removes the files that match one of `patterns` from the selection. */
+    except(...patterns) {
+        return new Files(this.patterns, patterns);
+    }
+    /** Adds targets that are not checked for existence. See {@link unverified}. */
+    andUnverified(...patterns) {
+        return new Targets(this.patterns, patterns);
+    }
+}
+export function anyOf(...patterns) {
+    return new AnyOf(patterns);
+}
+/** All files of the project. */
+export function all() {
+    return new Files(undefined, undefined);
+}
+/** All files of the project except those that match one of the patterns. */
+export function allExcept(...patterns) {
+    return new Files(undefined, patterns);
+}
+/**
+ * Targets that are not checked for existence. Use this only for files of the project that
+ * the compiler does not load, such as generated files that are not there yet.
+ */
+export function unverified(...patterns) {
+    return new Targets([], patterns);
+}
+/** Starts a rule. The name is printed with every violation. */
+export function rule(name) {
+    return new NamedRule(name);
+}
+/** A rule with a name. Say which files it applies to. */
+export class NamedRule {
+    name;
+    /** @internal */
+    constructor(name) {
+        this.name = name;
+    }
+    /** The files that the rule constrains: `anyOf(..)`, `all()`, `allExcept(..)` or `anyOf(..).except(..)`. */
+    files(files) {
+        if (files instanceof AnyOf) {
+            for (const pattern of files.patterns) {
+                if (typeof pattern !== "string") {
+                    throw new TypeError(`refpact: rule \`${this.name}\`: files(..) takes file patterns, not packages`);
+                }
+            }
+            return new ScopedRule(this.name, new Files(files.patterns, undefined));
+        }
+        return new ScopedRule(this.name, files);
+    }
+    /**
+     * The items that these files declare at their top level: functions, classes, interfaces,
+     * types, enums, variables and namespaces. Narrow them with the filters of
+     * {@link ItemSelection}, then say what they must meet, for example with
+     * {@link ItemSelection.mustResideIn}.
+     */
+    items(files) {
+        const selection = files instanceof AnyOf ? new Files(files.patterns, undefined) : files;
+        return new ItemSelection(this.name, selection, {
+            rule: (made, finder) => new ImportRule(made, finder),
+            custom: customCheck,
+            subjects,
+            file: filePattern,
+            target: targetPattern,
+        });
+    }
+}
+/**
+ * A rule with a name and files. Say what the files must or must not do, for example with
+ * `mustNotImport`, `mustOnlyImport` or `mustBeAcyclic`.
+ */
+export class ScopedRule {
+    name;
+    selection;
+    /** @internal */
+    constructor(name, selection) {
+        this.name = name;
+        this.selection = selection;
+    }
+    /**
+     * The files must not import any of the targets, in any form: `import`, `import type`,
+     * `import()`, `require`, or `export .. from`. An import through a barrel file counts as
+     * an import of the file that declares the name.
+     */
+    mustNotImport(targets) {
+        return this.rule({ type: "must-not-use", targets: this.targets(targets) });
+    }
+    /**
+     * Every import of the files must lead to one of the targets. An import is allowed when the
+     * module in the code is allowed, or when the file that declares the name is.
+     *
+     * The list must name everything the files import, also packages and modules of Node:
+     * `pkg("*")` is every package, and `pkg("node:*")` is every module of Node.
+     */
+    mustOnlyImport(targets) {
+        return this.rule({ type: "must-only-use", targets: this.targets(targets) });
+    }
+    /**
+     * The files must not form a cycle: no file may reach itself through the imports between
+     * them. Each tangle of files is reported once, with one of its cycles.
+     */
+    mustBeAcyclic() {
+        return this.rule({ type: "must-be-acyclic" });
+    }
+    /**
+     * Like {@link ScopedRule.mustBeAcyclic}, between slices. The slice of a file is the
+     * shortest start of its path that matches one of the patterns: with `src/features/*`, the
+     * file `src/features/cart/view/list.ts` is in the slice `src/features/cart`. Imports inside
+     * a slice do not count, and a file without a slice is left out.
+     */
+    mustBeAcyclicBetween(slices) {
+        return this.rule({ type: "must-be-acyclic", slices: slices.patterns.map(filePattern) });
+    }
+    /**
+     * No file of one slice may import a file of another slice. Slices are as in
+     * {@link ScopedRule.mustBeAcyclicBetween}: with `src/features/*`, no feature may import
+     * another feature.
+     *
+     * A file that the rule does not select is in no slice. Leave a shared part out with
+     * `allExcept("src/features/shared/**")`.
+     */
+    mustBeIndependentBetween(slices) {
+        return this.rule({ type: "must-be-independent", slices: slices.patterns.map(filePattern) });
+    }
+    /**
+     * The files must not contain any of the markers: `console`, a use of the global
+     * `console`, `debugger`, a `debugger` statement, and `unresolved-import`, an import of a
+     * relative path, a `paths` alias or a `#name` of `imports` that leads to no file. A local
+     * variable named `console` is no marker. An import of a package is never an `unresolved-import`:
+     * refpact does not check that a package is installed.
+     *
+     * ```ts
+     * rule("every import resolves").files(all()).mustNotContain("unresolved-import").check(app);
+     * ```
+     */
+    mustNotContain(...markers) {
+        return this.rule({ type: "must-not-contain", markers });
+    }
+    /**
+     * Each file must have at most this number of lines. The blank lines and the comments
+     * count.
+     *
+     * ```ts
+     * rule("no file is longer than 400 lines").files(anyOf("src/**")).mustNotExceedLines(400).check(app);
+     * ```
+     */
+    mustNotExceedLines(lines) {
+        return this.rule({ type: "must-not-exceed-lines", lines });
+    }
+    /**
+     * Each file must be imported by another file. Leave the entry points out of the files:
+     * `allExcept("src/main.ts")`.
+     */
+    mustBeImported() {
+        return this.rule({ type: "must-be-used" });
+    }
+    /**
+     * No chain of imports may lead from the files to one of the targets: not the files
+     * themselves, and not a file that they import, at any distance. The report shows the
+     * shortest chain.
+     */
+    mustNotReach(targets) {
+        return this.rule({ type: "must-not-reach", targets: this.targets(targets) });
+    }
+    /** A chain of imports must lead from one of the root files to each file. Give the entry points as roots. */
+    mustBeReachableFrom(roots) {
+        return this.rule({ type: "must-be-reachable-from", roots: roots.patterns.map(filePattern) });
+    }
+    /**
+     * Only the importers, and the files of the rule themselves, may import the files of the
+     * rule. Every other file that imports one of them breaks the rule, also through a barrel
+     * file. Importers match files as the files of a rule do.
+     */
+    mustOnlyBeImportedBy(importers) {
+        return this.rule({ type: "must-only-be-used-by", users: importers.patterns.map(filePattern) });
+    }
+    /**
+     * Each file must be one that a place matches. The layers use it for `everyFileInALayer`.
+     *
+     * @internal
+     */
+    mustBeIn(places) {
+        return this.rule({ type: "must-be-in", places: places.map(filePattern) });
+    }
+    /**
+     * Every package that the files import must be in the `package.json` that the file belongs
+     * to: the nearest one above it. Any of `dependencies`, `devDependencies`,
+     * `peerDependencies` and `optionalDependencies` counts. A type import of `name` is also
+     * declared by `@types/name`. A package may import itself by its own name.
+     *
+     * The project must be loaded with `readDependencies`: the rule reads the references that
+     * the `package.json` files give, as a check of your own can.
+     */
+    mustOnlyImportDeclaredPackages() {
+        return this.custom(ANY_PACKAGE, PACKAGE_NAMES, (scope) => undeclared(scope, "declared"));
+    }
+    /**
+     * The files must not import a package that their `package.json` has only in
+     * `devDependencies`. Select the files that are shipped: `allExcept("**\/*.test.ts")`.
+     * The project must be loaded with `readDependencies`.
+     */
+    mustNotImportDevDependencies() {
+        return this.custom(ANY_PACKAGE, PACKAGE_NAMES, (scope) => undeclared(scope, "not-development"));
+    }
+    /**
+     * The files must pass a check of your own: a function that gets the {@link Scope} of the
+     * rule and returns the violations. The rule selects the files, applies its filters and its
+     * exemptions, and reports and baselines the violations, as for the rules above.
+     *
+     * A function cannot match a pattern, so the check names the lists of patterns that it
+     * needs, and the rule matches them: see {@link CheckPatterns}. A pattern that matches
+     * nothing is an error, as it is for `mustNotImport`.
+     *
+     * ```ts
+     * rule("a file imports at most ten files")
+     *   .files(anyOf("src/**"))
+     *   .mustSatisfy((scope) =>
+     *     scope.subjects
+     *       .filter((file) => scope.imports.filter((seen) => seen.file === file).length > 10)
+     *       .map((file) => scope.violationOfFile(file, "imports more than ten files")),
+     *   )
+     *   .check(app);
+     * ```
+     */
+    mustSatisfy(check, patterns) {
+        const { constraint, names } = customCheck(patterns);
+        return this.custom(constraint, names, (scope) => check(scope));
+    }
+    targets(targets) {
+        return coreTargets(targets);
+    }
+    rule(constraint) {
+        return new ImportRule({ name: this.name, subjects: subjects(this.selection), constraint });
+    }
+    custom(constraint, names, find) {
+        return new ImportRule({ name: this.name, subjects: subjects(this.selection), constraint }, { names, find });
+    }
+}
+function coreTargets(targets) {
+    const set = targets instanceof AnyOf ? new Targets(targets.patterns, []) : targets;
+    return { anyOf: set.anyOf.map(targetPattern), unverified: set.unverified.map(targetPattern) };
+}
+/** The custom check that the core gets for these lists, and the names of the lists in their order. */
+function customCheck(patterns) {
+    const targets = Object.entries(patterns?.targets ?? {});
+    const files = Object.entries(patterns?.files ?? {});
+    return {
+        constraint: {
+            type: "custom",
+            targets: targets.map(([, list]) => coreTargets(list)),
+            units: files.map(([, list]) => list.patterns.map(filePattern)),
+        },
+        names: { targets: targets.map(([name]) => name), files: files.map(([name]) => name) },
+    };
+}
+/** The subjects of a rule about these files. */
+function subjects(files) {
+    return {
+        include: files.include === undefined ? { type: "all" } : { type: "any-of", patterns: files.include.map(filePattern) },
+        ...(files.excluded !== undefined ? { except: files.excluded.map(filePattern) } : {}),
+    };
+}
+/** The rules about `package.json` look at the imports of packages: the hit of an import is its package. */
+const ANY_PACKAGE = { type: "custom", targets: [{ anyOf: [], unverified: [[packageSegment("*")]] }] };
+const PACKAGE_NAMES = { targets: ["package"], files: [] };
+/** The imports of packages by the selected files, as violations of a rule about uses. */
+function packageImports(scope) {
+    const found = [];
+    for (const seen of scope.imports) {
+        const hit = seen.hits["package"];
+        const { reference } = seen;
+        // What a package.json names is no import.
+        if (!seen.subject || hit === undefined || DEPENDENCY_KINDS.includes(reference.kind)) {
+            continue;
+        }
+        const written = hit.length !== reference.target.length || hit.some((segment, index) => segment !== reference.target[index]);
+        found.push(scope.violationAt(seen.fact, {
+            type: "uses",
+            target: hit,
+            ...(written ? { written: reference.target } : {}),
+            kind: reference.kind,
+            certainty: reference.certainty,
+        }));
+    }
+    return found;
+}
+/**
+ * From the imports of packages by the selected files, those that break a rule about
+ * `package.json`. The rule reads what a check of the user can read: the references and the
+ * items that the `package.json` files give to a project that is loaded with
+ * `readDependencies`. Throws an {@link ArchitectureError} when no `package.json` can make
+ * the rule fail.
+ */
+function undeclared(scope, check) {
+    const rule = scope.ruleName;
+    const malformed = (problem) => new ArchitectureError({ type: "malformed", rule, message: `rule \`${rule}\` cannot be checked:\n  ${problem}` });
+    const { facts } = scope;
+    if (!facts.kinds.includes("dependency")) {
+        throw malformed("the project is loaded without `readDependencies`, so it has no package.json");
+    }
+    const manifests = new Map();
+    const manifestAt = (unit) => {
+        const file = unit.join("/");
+        const known = manifests.get(file);
+        if (known !== undefined) {
+            return known;
+        }
+        const made = { directory: unit.slice(0, -1).join("/"), name: undefined, production: new Set(), development: new Set() };
+        manifests.set(file, made);
+        return made;
+    };
+    for (const declaration of facts.declarations ?? []) {
+        if (declaration.kind === PACKAGE_ITEM_KIND) {
+            manifestAt(declaration.unit).name = declaration.name;
+        }
+    }
+    for (const fact of facts.facts) {
+        if (fact.what.type === "reference" && NAMED_DEPENDENCY_KINDS.includes(fact.what.kind)) {
+            const name = fact.what.target[0].slice(packageSegment("").length);
+            const manifest = manifestAt(fact.unit);
+            (fact.what.kind === "dev-dependency" ? manifest.development : manifest.production).add(name);
+        }
+    }
+    // The package.json of a file is the nearest one above it.
+    const nearest = new Map();
+    const manifestOf = (file) => {
+        if (!nearest.has(file)) {
+            let found;
+            for (const manifest of manifests.values()) {
+                const inside = !path.posix.relative(manifest.directory, file).startsWith("..");
+                if (inside && (found === undefined || path.posix.resolve(manifest.directory).length > path.posix.resolve(found.directory).length)) {
+                    found = manifest;
+                }
+            }
+            nearest.set(file, found);
+        }
+        const manifest = nearest.get(file);
+        if (manifest === undefined) {
+            throw malformed(`no package.json is above ${file}`);
+        }
+        return manifest;
+    };
+    if (check === "not-development" && ![...manifests.values()].some((manifest) => manifest.development.size > 0)) {
+        throw malformed("no package.json of the project has devDependencies");
+    }
+    return packageImports(scope).filter((violation) => {
+        const detail = violation.detail;
+        if (detail.type !== "uses") {
+            return false;
+        }
+        const manifest = manifestOf(violation.file);
+        const name = detail.target[0].slice(packageSegment("").length);
+        const declares = (entry) => manifest.production.has(entry) || manifest.development.has(entry);
+        const types = typesPackage(name);
+        // A type import of `name` can come from `@types/name`.
+        const entry = declares(name) ? name : TYPE_KINDS.includes(detail.kind) && declares(types) ? types : undefined;
+        if (check === "declared") {
+            return entry === undefined && name !== manifest.name;
+        }
+        return entry !== undefined && !manifest.production.has(entry);
+    });
+}
+const TYPE_KINDS = ["import-type", "export-type-from"];
+/** `@types/name` for `name`, and `@types/scope__name` for `@scope/name`. */
+function typesPackage(name) {
+    return `@types/${name.startsWith("@") ? name.slice(1).replace("/", "__") : name}`;
+}
+/** An answer of the core without errors. Throws the errors of the rule. */
+function answered(rule, answer) {
+    if (!answer.ok) {
+        const { errors } = answer;
+        throw new ArchitectureError({ type: "invalid", rule, errors, message: renderErrors(rule, errors) });
+    }
+    return answer;
+}
+/** The error that `check` throws. Its message is the report. */
+export class ArchitectureError extends Error {
+    /** Why the rule did not pass. */
+    failure;
+    constructor(failure) {
+        super(failure.message);
+        this.name = "ArchitectureError";
+        this.failure = failure;
+    }
+}
+export class ImportRule {
+    rule;
+    /** The check of a rule with a custom check. */
+    finder;
+    /** @internal */
+    constructor(rule, finder) {
+        this.rule = rule;
+        this.finder = finder;
+    }
+    /** The name of the rule. */
+    get name() {
+        return this.rule.name;
+    }
+    /** @internal The rule with one more filter. */
+    filtered(filter) {
+        return new ImportRule(filter.apply(this.rule), this.finder);
+    }
+    /**
+     * Names the properties of imports that a check of your own reads, such as `license`. A
+     * name that the load does not produce is then an error, as a kind that it does not produce
+     * is: a check that reads `licence` for `license`, or the properties of a load without
+     * `readDependencies`, cannot pass because it finds nothing.
+     */
+    readingProperties(...names) {
+        return new ImportRule({ ...this.rule, properties: [...(this.rule.properties ?? []), ...names] }, this.finder);
+    }
+    /**
+     * Evaluates the rule and returns the violations, which may be none, or the errors of the
+     * rule. A rule about `package.json` throws an {@link ArchitectureError} when no
+     * `package.json` can make it fail.
+     */
+    evaluate(project) {
+        if (this.finder === undefined) {
+            return evaluate(this.rule, project.facts);
+        }
+        // The core applies the subjects, the filters and the exemptions; the check does the rest.
+        const { rule, finder } = this;
+        const selection = select(rule, project.facts);
+        if (!selection.ok) {
+            return selection;
+        }
+        const scope = new (rule.constraint.type === "items" ? ItemScope : Scope)(rule.name, project.facts, selection, finder.names, {
+            graph: (subjects) => answered(rule.name, graph(rule, project.facts, subjects)),
+            tangles: (subjects) => answered(rule.name, tangles(rule, project.facts, subjects)).tangles,
+        });
+        return { ok: true, violations: finder.find(scope, project) };
+    }
+    /**
+     * Evaluates the rule and returns the failure, or `undefined` when the rule passes. The
+     * violations of a warning are reported with `console.warn` and are no failure: see
+     * {@link ImportRule.asWarning}.
+     */
+    verify(project) {
+        const found = this.found(project);
+        if (!Array.isArray(found)) {
+            return found;
+        }
+        return this.violated(found, project);
+    }
+    /** The violations, or the reason why the rule cannot be evaluated. */
+    found(project) {
+        const rule = this.rule.name;
+        let result;
+        try {
+            result = this.evaluate(project);
+        }
+        catch (error) {
+            if (error instanceof ArchitectureError) {
+                return error.failure;
+            }
+            throw error;
+        }
+        if (!result.ok) {
+            return { type: "invalid", rule, errors: result.errors, message: renderErrors(rule, result.errors) };
+        }
+        return result.violations;
+    }
+    /**
+     * A diagram of what the rule sees, in Mermaid (the default) or DOT. The nodes are the files
+     * of the rule, or its slices when the rule is about slices, such as
+     * {@link ScopedRule.mustBeAcyclicBetween}. An edge is an import between two nodes that the
+     * filters and the exemptions of the rule let pass. The files and imports of a cycle are
+     * red. The constraint of the rule is not evaluated, so a rule of any kind draws its files.
+     * Throws an {@link ArchitectureError} when the rule cannot be evaluated.
+     *
+     * A Markdown viewer that knows Mermaid, such as GitHub's, draws the text in a block
+     * ` ```mermaid `.
+     *
+     * ```ts
+     * const text = rule("the features").files(all()).mustBeAcyclicBetween(anyOf("src/features/*")).diagram(app);
+     * writeFileSync("docs/features.md", `\`\`\`mermaid\n${text}\`\`\`\n`);
+     * ```
+     */
+    diagram(project, format = "mermaid") {
+        const { constraint } = this.rule;
+        const slices = constraint.type === "must-be-acyclic" || constraint.type === "must-be-independent" ? constraint.slices : undefined;
+        return this.draw(project, slices === undefined ? undefined : { slices }, format);
+    }
+    /** @internal The diagram of the rule with these nodes. */
+    draw(project, nodes, format) {
+        const { name } = this.rule;
+        const result = diagram(this.rule, project.facts, nodes, format);
+        if (!result.ok) {
+            throw new ArchitectureError({ type: "invalid", rule: name, errors: result.errors, message: renderErrors(name, result.errors) });
+        }
+        return result.text;
+    }
+    /** Throws an {@link ArchitectureError} when the rule is violated or cannot be evaluated. */
+    check(project) {
+        const failure = this.verify(project);
+        if (failure !== undefined) {
+            throw new ArchitectureError(failure);
+        }
+    }
+    /**
+     * Like {@link ImportRule.verify}, but violations that the baseline file accepts do not fail.
+     *
+     * A baseline is used only through this method and {@link ImportRule.checkWithBaseline}. It
+     * can only shrink: an entry that accepts more violations than the code has is a failure.
+     * When the environment variable `REFPACT_BASELINE` is `update`, this writes the violations
+     * of the rule to the file and passes.
+     */
+    verifyWithBaseline(project, baseline) {
+        if (process.env["REFPACT_BASELINE"] === "update") {
+            return this.writeBaseline(project, baseline);
+        }
+        const found = this.violationsForBaseline(project);
+        if (!Array.isArray(found)) {
+            return found;
+        }
+        const entries = baseline.read();
+        if (!Array.isArray(entries)) {
+            return entries;
+        }
+        const rule = this.rule.name;
+        const applied = applyBaseline(rule, found, entries, project.facts);
+        const violated = this.violated(applied.remaining, project);
+        if (violated !== undefined) {
+            return violated;
+        }
+        if (applied.stale.length > 0) {
+            const message = renderStale(rule, baseline.file, applied.stale);
+            return { type: "stale-baseline", rule, file: baseline.file, entries: applied.stale, message };
+        }
+        return undefined;
+    }
+    /**
+     * Throws an {@link ArchitectureError} when the rule has violations that the baseline file
+     * does not accept, when the baseline has stale entries, or when the rule cannot be evaluated.
+     */
+    checkWithBaseline(project, baseline) {
+        const failure = this.verifyWithBaseline(project, baseline);
+        if (failure !== undefined) {
+            throw new ArchitectureError(failure);
+        }
+    }
+    /**
+     * Writes the current violations of this rule to the baseline file. Entries of other rules
+     * in the file are kept. Returns the failure, or `undefined` when the file is written.
+     */
+    writeBaseline(project, baseline) {
+        const found = this.violationsForBaseline(project);
+        if (!Array.isArray(found)) {
+            return found;
+        }
+        return baseline.write(this.rule.name, found, project.facts);
+    }
+    /** The failure of the violations. A warning reports them and fails not. */
+    violated(violations, project) {
+        if (violations.length === 0) {
+            return undefined;
+        }
+        const { name: rule, reason, severity } = this.rule;
+        if (severity === "warning") {
+            console.warn(renderViolations(rule, violations, project.facts, reason, severity));
+            return undefined;
+        }
+        const message = renderViolations(rule, violations, project.facts, reason);
+        return { type: "violated", rule, ...(reason !== undefined ? { reason } : {}), violations, message };
+    }
+    violationsForBaseline(project) {
+        const rule = this.rule.name;
+        if (/[\t\r\n]/.test(rule)) {
+            const message = `refpact: the name of rule ${JSON.stringify(rule)} has a tab or a line break, so it cannot be in a baseline`;
+            return { type: "baseline", message };
+        }
+        return this.found(project);
+    }
+    /** The rule as the core sees it. */
+    toCore() {
+        return this.rule;
+    }
+}
+addFilters(ImportRule);
+export { KINDS, MARKERS };