@markuplint/ml-core 4.13.2 → 5.0.0-alpha.0

package/lib/ml-rule/ml-rule.js

@@ -1,45 +1,93 @@
-var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
-    if (kind === "m") throw new TypeError("Private method is not writable");
-    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
-    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
-    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
-};
-var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
-    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
-    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
-    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
-};
-var _MLRule_f, _MLRule_v;
 import { deleteUndefProp } from '@markuplint/ml-config';
 // @ts-ignore
 import { isPlainObject } from 'is-plain-object';
 import { MLRuleContext } from './ml-rule-context.js';
+/**
+ * Represents a single markuplint rule that can verify documents and report violations.
+ *
+ * @template T - The type of the rule's configuration value
+ * @template O - The type of the rule's options
+ */
 export class MLRule {
+    /**
+     * For virtual rules, the name of the base rule whose verify/fix logic is reused.
+     * When set, violations report this as `ruleId` for backwards compatibility.
+     */
+    baseRuleId;
+    defaultOptions;
+    defaultSeverity;
+    defaultValue;
+    #f;
+    /**
+     * For multi-entry named nodeRules, the group name shared by all derived virtual rules.
+     * Allows `rules["groupName"]: false` to disable all rules in the group.
+     */
+    groupName;
+    name;
+    /**
+     * The spec conformance classification of this rule, based on RFC 2119 keyword strength.
+     * Set on virtual rules derived from named nodeRules in presets.
+     */
+    specConformance;
+    #v;
     constructor(o) {
-        _MLRule_f.set(this, void 0);
-        _MLRule_v.set(this, void 0);
         this.name = o.name;
+        this.baseRuleId = o.baseRuleId;
+        this.groupName = o.groupName;
+        this.specConformance = o.specConformance;
         this.defaultSeverity = o.defaultSeverity ?? 'error';
-        // TODO: https://github.com/markuplint/markuplint/issues/808
+        // When T is boolean, defaultValue is optional and the runtime default is `true`.
+        // For non-boolean T, the type system now enforces that defaultValue is provided.
+        // See: https://github.com/markuplint/markuplint/issues/808
         this.defaultValue = (o.defaultValue === undefined ? true : o.defaultValue);
         this.defaultOptions = o.defaultOptions;
-        __classPrivateFieldSet(this, _MLRule_v, o.verify, "f");
-        __classPrivateFieldSet(this, _MLRule_f, o.fix, "f");
+        this.#v = o.verify;
+        this.#f = o.fix;
+    }
+    /**
+     * Creates a virtual rule that reuses this rule's verify/fix logic
+     * under a different name (alias). Used by named nodeRules to produce
+     * independent rule instances that can be individually configured.
+     *
+     * @param aliasName - The alias name (must contain `/`)
+     * @param options - Override options for the virtual rule
+     * @returns A new MLRule instance sharing the same verify/fix logic
+     */
+    createAlias(aliasName, options) {
+        return new MLRule({
+            name: aliasName,
+            baseRuleId: this.name,
+            groupName: options?.groupName,
+            specConformance: options?.specConformance,
+            defaultSeverity: options?.defaultSeverity ?? this.defaultSeverity,
+            defaultValue: this.defaultValue,
+            defaultOptions: this.defaultOptions,
+            verify: this.#v,
+            fix: this.#f,
+        });
     }
     /**
      * The following getter is unused internally,
      * only for extending from 3rd party library
      */
     get f() {
-        return __classPrivateFieldGet(this, _MLRule_f, "f");
+        return this.#f;
     }
     /**
      * The following getter is unused internally,
      * only for extending from 3rd party library
      */
     get v() {
-        return __classPrivateFieldGet(this, _MLRule_v, "f");
+        return this.#v;
     }
+    /**
+     * Resolves the full rule information from a ruleset, including node-level
+     * and child-node-level overrides.
+     *
+     * @param ruleSet - The ruleset containing rule definitions and overrides
+     * @param ruleName - The name of this rule
+     * @returns The global rule info with node and child-node overrides
+     */
     getRuleInfo(ruleSet, ruleName) {
         const info = this._optimize(ruleSet.rules, ruleName);
         return {
@@ -48,6 +96,13 @@ export class MLRule {
             childNodeRules: ruleSet.childNodeRules.map(r => this._optimize(r.rules, ruleName)).filter(r => !r.disabled),
         };
     }
+    /**
+     * Normalizes a raw rule setting into a fully resolved {@link RuleInfo} object,
+     * applying defaults for any unspecified fields.
+     *
+     * @param configSettings - The raw rule configuration value
+     * @returns The resolved rule info with defaults applied
+     */
     optimizeOption(configSettings) {
         if (configSettings === undefined || typeof configSettings === 'boolean') {
             return {
@@ -79,16 +134,28 @@ export class MLRule {
             reason: undefined,
         };
     }
+    /**
+     * Executes this rule's verify (and optionally fix) function against a document,
+     * then collects and returns the resulting violations.
+     *
+     * @param document - The parsed document to verify
+     * @param locale - The locale set for translating violation messages
+     * @param fix - Whether to also run the fix function
+     * @returns An array of violations found by this rule
+     */
     async verify(
     // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
     document, locale, fix) {
         document.setRule(this);
         const context = new MLRuleContext(document, locale);
         const providableContext = context.provide();
-        await __classPrivateFieldGet(this, _MLRule_v, "f").call(this, providableContext);
-        if (__classPrivateFieldGet(this, _MLRule_f, "f") && fix) {
-            await __classPrivateFieldGet(this, _MLRule_f, "f").call(this, providableContext);
+        await this.#v(providableContext);
+        if (this.#f && fix) {
+            await this.#f(providableContext);
         }
+        const ruleId = this.baseRuleId ?? this.name;
+        // Only include name and specConformance for virtual rules (named nodeRules)
+        const aliasName = this.baseRuleId ? this.name : undefined;
         const violation = context.reports.map(report => {
             if ('scope' in report) {
                 let line = report.scope.startLine;
@@ -105,7 +172,9 @@ export class MLRule {
                     line,
                     col,
                     raw,
-                    ruleId: this.name,
+                    ruleId,
+                    name: aliasName,
+                    specConformance: this.specConformance,
                     reason: report.scope.rule.reason ?? document.rule.reason,
                 };
                 deleteUndefProp(violation);
@@ -117,7 +186,9 @@ export class MLRule {
                 line: report.line,
                 col: report.col,
                 raw: report.raw,
-                ruleId: this.name,
+                ruleId,
+                name: aliasName,
+                specConformance: this.specConformance,
                 reason: document.rule.reason,
             };
             deleteUndefProp(violation);
@@ -132,7 +203,6 @@ export class MLRule {
         return info;
     }
 }
-_MLRule_f = new WeakMap(), _MLRule_v = new WeakMap();
 function isRuleConfig(data) {
     return isPlainObject(data);
 }

package/lib/ml-rule/types.d.ts

@@ -2,6 +2,13 @@ import type { MLRuleContext } from './ml-rule-context.js';
 import type { Attr, Element } from '../ml-dom/index.js';
 import type { Translator } from '@markuplint/i18n';
 import type { PlainData, Report, RuleConfigValue, Severity } from '@markuplint/ml-config';
+/**
+ * The definition of a markuplint rule, including verification logic, optional fix logic,
+ * and default configuration values.
+ *
+ * @template T - The type of the rule's configuration value (defaults to boolean)
+ * @template O - The type of the rule's options
+ */
 export type RuleSeed<T extends RuleConfigValue = boolean, O extends PlainData = undefined> = {
     readonly meta?: {
         readonly category?: 'validation' | 'style' | 'naming-convention' | 'a11y' | 'maintainability';
@@ -12,12 +19,46 @@ export type RuleSeed<T extends RuleConfigValue = boolean, O extends PlainData =
     verify(context: ReturnType<MLRuleContext<T, O>['provide']>): void | Promise<void>;
     fix?(context: ReturnType<MLRuleContext<T, O>['provide']>): void | Promise<void>;
 };
+/**
+ * A generic checker function that produces a violation report from parameters.
+ *
+ * @template T - The type of the rule's configuration value
+ * @template O - The type of the rule's options
+ * @template P - Additional parameters passed to the checker
+ */
 export type Checker<T extends RuleConfigValue, O extends PlainData = undefined, P extends Record<string, unknown> = {}> = (params: P) => CheckerReport<T, O>;
+/**
+ * A checker function that verifies a specific element and produces a violation report.
+ *
+ * @template T - The type of the rule's configuration value
+ * @template O - The type of the rule's options
+ * @template P - Additional parameters passed alongside the element
+ */
 export type ElementChecker<T extends RuleConfigValue, O extends PlainData = undefined, P extends Record<string, unknown> = {}> = (params: P & {
     el: Element<T, O>;
 }) => CheckerReport<T, O>;
+/**
+ * A checker function that verifies a specific attribute and produces a violation report.
+ *
+ * @template T - The type of the rule's configuration value
+ * @template O - The type of the rule's options
+ * @template P - Additional parameters passed alongside the attribute
+ */
 export type AttrChecker<T extends RuleConfigValue, O extends PlainData = undefined, P extends Record<string, unknown> = {}> = (params: P & {
     attr: Attr<T, O>;
 }) => CheckerReport<T, O>;
+/**
+ * A function that receives a translator and returns a violation report, or `null`/`undefined`
+ * if no violation was found.
+ *
+ * @template T - The type of the rule's configuration value
+ * @template O - The type of the rule's options
+ */
 export type CheckerReport<T extends RuleConfigValue, O extends PlainData = undefined> = (t: Translator) => Report<T, O> | undefined | null;
+/**
+ * A RuleSeed with wildcard value and option types.
+ *
+ * @template T - The type of the rule's configuration value
+ * @template O - The type of the rule's options
+ */
 export type AnyRuleSeed<T extends RuleConfigValue = RuleConfigValue, O extends PlainData = PlainData> = RuleSeed<T, O>;

package/lib/plugin/plugin.d.ts

@@ -1,2 +1,10 @@
 import type { PluginCreator, CreatePluginSettings } from './types.js';
+/**
+ * Factory function for creating a type-safe plugin creator.
+ * Returns the creator object as-is; primarily used for type inference.
+ *
+ * @template S - The settings type accepted by the plugin
+ * @param fn - The plugin creator definition
+ * @returns The same creator object, now fully typed
+ */
 export declare function createPlugin<S extends CreatePluginSettings>(fn: Readonly<PluginCreator<S>>): Readonly<PluginCreator<S>>;

package/lib/plugin/plugin.js

@@ -1,3 +1,11 @@
+/**
+ * Factory function for creating a type-safe plugin creator.
+ * Returns the creator object as-is; primarily used for type inference.
+ *
+ * @template S - The settings type accepted by the plugin
+ * @param fn - The plugin creator definition
+ * @returns The same creator object, now fully typed
+ */
 export function createPlugin(fn) {
     return fn;
 }

package/lib/plugin/types.d.ts

@@ -1,12 +1,33 @@
 import type { RuleSeed } from '../ml-rule/index.js';
 import type { Config } from '@markuplint/ml-config';
+/**
+ * A resolved markuplint plugin containing named rules and/or shared configurations.
+ */
 export type Plugin = {
+    /** The plugin name, used as a prefix for its rules (e.g. `"my-plugin/rule-name"`) */
     readonly name: string;
+    /** Custom rules provided by this plugin */
     readonly rules?: Readonly<Record<string, Readonly<RuleSeed<any, any>>>>;
+    /** Shared configurations that users can extend from */
     readonly configs?: Readonly<Record<string, Config>>;
 };
+/**
+ * A factory interface for creating plugins with custom settings.
+ *
+ * @template S - The settings type accepted by the plugin creator
+ */
 export type PluginCreator<S extends CreatePluginSettings> = {
+    /** The plugin name */
     readonly name: string;
+    /**
+     * Creates the plugin's rules and configs from the given settings.
+     *
+     * @param setting - The user-provided settings for this plugin
+     * @returns The plugin's rules and configurations
+     */
     create(setting: S): Omit<Plugin, 'name'>;
 };
+/**
+ * Base type for plugin settings. A readonly record of string keys to unknown values.
+ */
 export type CreatePluginSettings = Readonly<Record<string, unknown>>;

package/lib/ruleset/index.d.ts

@@ -1,7 +1,17 @@
 import type { ChildNodeRule, Config, NodeRule, Rules } from '@markuplint/ml-config';
+/**
+ * A resolved set of rules, node-specific rule overrides, and child-node-specific
+ * rule overrides extracted from a markuplint {@link Config}.
+ */
 export declare class Ruleset {
+    /** Rule overrides that apply to child nodes matching specific selectors */
     readonly childNodeRules: readonly ChildNodeRule[];
+    /** Rule overrides that apply to nodes matching specific selectors */
     readonly nodeRules: readonly NodeRule[];
+    /** The global rule definitions */
     readonly rules: Rules;
+    /**
+     * @param config - The markuplint configuration to extract rules from
+     */
     constructor(config: Config);
 }

package/lib/ruleset/index.js

@@ -1,4 +1,17 @@
+/**
+ * A resolved set of rules, node-specific rule overrides, and child-node-specific
+ * rule overrides extracted from a markuplint {@link Config}.
+ */
 export class Ruleset {
+    /** Rule overrides that apply to child nodes matching specific selectors */
+    childNodeRules;
+    /** Rule overrides that apply to nodes matching specific selectors */
+    nodeRules;
+    /** The global rule definitions */
+    rules;
+    /**
+     * @param config - The markuplint configuration to extract rules from
+     */
     constructor(config) {
         this.rules = config.rules ?? {};
         this.nodeRules = config.nodeRules ?? [];

package/lib/test/index.d.ts

@@ -5,19 +5,60 @@ import type { MLASTNode, MLASTToken, MLParser } from '@markuplint/ml-ast';
 import type { Config, PlainData, Pretender, RuleConfigValue } from '@markuplint/ml-config';
 import type { MLMLSpec } from '@markuplint/ml-spec';
 import { MLDocument } from '../ml-dom/node/document.js';
+/**
+ * Options for creating test documents and elements.
+ */
 export type CreateTestOptions = {
+    /** The markuplint configuration to apply */
     readonly config?: Config;
+    /** A parser module or parser instance to use instead of the default HTML parser */
     readonly parser?: {
         readonly parser: Readonly<MLParser>;
     } | Readonly<MLParser>;
+    /** The HTML/ARIA specification data to use */
     readonly specs?: MLMLSpec;
+    /** Pretender definitions for component mapping */
     readonly pretenders?: readonly Pretender[];
 };
+/**
+ * Parses markup source code and returns a test document for use in rule tests.
+ *
+ * @template T - The rule config value type
+ * @template O - The rule options type
+ * @param sourceCode - The markup source code to parse
+ * @param options - Options for parser, config, specs, and pretenders
+ * @returns A parsed MLDocument instance
+ */
 export declare function createTestDocument<T extends RuleConfigValue = any, O extends PlainData = any>(sourceCode: string, options?: CreateTestOptions): MLDocument<T, O>;
+/**
+ * Parses markup source code and returns the flat list of AST nodes.
+ *
+ * @param sourceCode - The markup source code to parse
+ * @param options - Options for parser, config, specs, and pretenders
+ * @returns A readonly array of all nodes in the parsed document
+ */
 export declare function createTestNodeList(sourceCode: string, options?: CreateTestOptions): readonly MLNode<any, any, MLASTNode>[];
+/**
+ * Parses markup source code and returns the flat list of tokens.
+ *
+ * @param sourceCode - The markup source code to parse
+ * @param options - Options for parser, config, specs, and pretenders
+ * @returns A readonly array of all tokens in the parsed document
+ */
 export declare function createTestTokenList(sourceCode: string, options?: CreateTestOptions): readonly MLToken<MLASTToken>[];
+/**
+ * Parses markup source code and returns the first element node.
+ * Throws if the source does not produce an element as its first node.
+ *
+ * @param sourceCode - The markup source code containing an element
+ * @param options - Options for parser, config, specs, and pretenders
+ * @returns The first element in the parsed document
+ * @throws {TypeError} If the first node is not an element
+ */
 export declare function createTestElement(sourceCode: string, options?: CreateTestOptions): MLElement<any, any>;
 /**
- * for test suite
+ * Returns the default HTML spec as a schema tuple for use in test suites.
+ *
+ * @returns A single-element tuple containing the HTML specification
  */
 export declare function dummySchemas(): [MLMLSpec];

package/lib/test/index.js

@@ -1,7 +1,17 @@
+import { ARIA_RECOMMENDED_VERSION } from '@markuplint/ml-spec';
 import { parser } from '@markuplint/html-parser';
 import spec from '@markuplint/html-spec';
 import { convertRuleset } from '../convert-ruleset.js';
 import { MLDocument } from '../ml-dom/node/document.js';
+/**
+ * Parses markup source code and returns a test document for use in rule tests.
+ *
+ * @template T - The rule config value type
+ * @template O - The rule options type
+ * @param sourceCode - The markup source code to parse
+ * @param options - Options for parser, config, specs, and pretenders
+ * @returns A parsed MLDocument instance
+ */
 export function createTestDocument(sourceCode, options) {
     const ast = options?.parser
         ? 'parser' in options.parser
@@ -9,17 +19,42 @@ export function createTestDocument(sourceCode, options) {
             : options.parser.parse(sourceCode, options.config?.parserOptions)
         : parser.parse(sourceCode, options?.config?.parserOptions);
     const ruleset = convertRuleset(options?.config);
-    const document = new MLDocument(ast, ruleset, [options?.specs ?? {}, {}]);
+    const document = new MLDocument(ast, ruleset, [options?.specs ?? {}, {}], {
+        ariaVersion: ARIA_RECOMMENDED_VERSION,
+    });
     return document;
 }
+/**
+ * Parses markup source code and returns the flat list of AST nodes.
+ *
+ * @param sourceCode - The markup source code to parse
+ * @param options - Options for parser, config, specs, and pretenders
+ * @returns A readonly array of all nodes in the parsed document
+ */
 export function createTestNodeList(sourceCode, options) {
     const document = createTestDocument(sourceCode, options);
     return document.nodeList;
 }
+/**
+ * Parses markup source code and returns the flat list of tokens.
+ *
+ * @param sourceCode - The markup source code to parse
+ * @param options - Options for parser, config, specs, and pretenders
+ * @returns A readonly array of all tokens in the parsed document
+ */
 export function createTestTokenList(sourceCode, options) {
     const document = createTestDocument(sourceCode, options);
     return document.getTokenList();
 }
+/**
+ * Parses markup source code and returns the first element node.
+ * Throws if the source does not produce an element as its first node.
+ *
+ * @param sourceCode - The markup source code containing an element
+ * @param options - Options for parser, config, specs, and pretenders
+ * @returns The first element in the parsed document
+ * @throws {TypeError} If the first node is not an element
+ */
 export function createTestElement(sourceCode, options) {
     const document = createTestDocument(sourceCode, options);
     const el = document.nodeList[0];
@@ -29,7 +64,9 @@ export function createTestElement(sourceCode, options) {
     throw new TypeError(`Could not parse it to be an element from: ${sourceCode}`);
 }
 /**
- * for test suite
+ * Returns the default HTML spec as a schema tuple for use in test suites.
+ *
+ * @returns A single-element tuple containing the HTML specification
  */
 export function dummySchemas() {
     return [spec];

package/lib/types.d.ts

@@ -2,15 +2,24 @@ import type { AnyMLRule } from './ml-rule/index.js';
 import type { Ruleset } from './ruleset/index.js';
 import type { LocaleSet } from '@markuplint/i18n';
 import type { MLParser, ParserOptions } from '@markuplint/ml-ast';
-import type { Pretender, SeverityOptions } from '@markuplint/ml-config';
+import type { Pretender, RuleCommonSettings, SeverityOptions } from '@markuplint/ml-config';
 import type { ExtendedSpec, MLMLSpec } from '@markuplint/ml-spec';
+/**
+ * A tuple of the base HTML/ARIA specification and zero or more
+ * framework-specific extended specs (e.g. React, Vue, Svelte).
+ */
 export type MLSchema = readonly [MLMLSpec, ...ExtendedSpec[]];
+/**
+ * The set of dependencies required by {@link MLCore} to perform linting.
+ * Includes the parser, ruleset, rules, locale, schemas, and other settings.
+ */
 export type MLFabric = {
     readonly parser: Readonly<MLParser>;
     readonly ruleset: Partial<Readonly<Ruleset>>;
     readonly rules: readonly Readonly<AnyMLRule>[];
     readonly locale: LocaleSet;
     readonly schemas: MLSchema;
+    readonly ruleCommonSettings: RuleCommonSettings;
     readonly parserOptions: ParserOptions;
     readonly severity: SeverityOptions;
     readonly pretenders: readonly Pretender[];

package/lib/violation-collector.d.ts

@@ -1,12 +1,45 @@
 import type { Violation } from '@markuplint/ml-config';
+/**
+ * Collects and manages lint violations across multiple files.
+ * Supports a maximum violation count to stop collecting early.
+ */
 export declare class ViolationCollector {
     #private;
+    /**
+     * @param maxCount - Maximum number of violations to collect; 0 means unlimited
+     */
     constructor(maxCount?: number);
+    /**
+     * Adds violations associated with a specific file path.
+     * Stops collecting once the maximum count is reached.
+     *
+     * @param filePath - The file that produced these violations
+     * @param violations - The violations to add
+     * @returns The current total number of collected violations
+     */
     pushWithFile(filePath: string, ...violations: readonly Violation[]): number;
+    /**
+     * The total number of collected violations.
+     */
     get length(): number;
+    /**
+     * Whether the collector has reached its maximum count and will no longer accept violations.
+     *
+     * @returns `true` if the collector is locked
+     */
     isLocked(): boolean;
+    /**
+     * Returns a copy of all collected violations as an array.
+     *
+     * @returns An array of violations with their associated file paths
+     */
     toArray(): (Violation & {
         filePath: string;
     })[];
+    /**
+     * Groups collected violations by their file path.
+     *
+     * @returns A Map from file path to an array of violations for that file
+     */
     groupByFile(): Map<string, Violation[]>;
 }

package/lib/violation-collector.js

@@ -1,48 +1,69 @@
-var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
-    if (kind === "m") throw new TypeError("Private method is not writable");
-    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
-    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
-    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
-};
-var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
-    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
-    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
-    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
-};
-var _ViolationCollector_violations, _ViolationCollector_maxCount, _ViolationCollector_locked;
+/**
+ * Collects and manages lint violations across multiple files.
+ * Supports a maximum violation count to stop collecting early.
+ */
 export class ViolationCollector {
+    #violations = [];
+    #maxCount = 0;
+    #locked = false;
+    /**
+     * @param maxCount - Maximum number of violations to collect; 0 means unlimited
+     */
     constructor(maxCount = 0) {
-        _ViolationCollector_violations.set(this, []);
-        _ViolationCollector_maxCount.set(this, 0);
-        _ViolationCollector_locked.set(this, false);
-        __classPrivateFieldSet(this, _ViolationCollector_maxCount, maxCount, "f");
-        __classPrivateFieldSet(this, _ViolationCollector_locked, false, "f");
+        this.#maxCount = maxCount;
+        this.#locked = false;
     }
+    /**
+     * Adds violations associated with a specific file path.
+     * Stops collecting once the maximum count is reached.
+     *
+     * @param filePath - The file that produced these violations
+     * @param violations - The violations to add
+     * @returns The current total number of collected violations
+     */
     pushWithFile(filePath, ...violations) {
-        if (__classPrivateFieldGet(this, _ViolationCollector_locked, "f")) {
-            return __classPrivateFieldGet(this, _ViolationCollector_violations, "f").length;
+        if (this.#locked) {
+            return this.#violations.length;
         }
         for (const violation of violations) {
-            __classPrivateFieldGet(this, _ViolationCollector_violations, "f").push({ ...violation, filePath });
-            if (__classPrivateFieldGet(this, _ViolationCollector_maxCount, "f") > 0 && __classPrivateFieldGet(this, _ViolationCollector_violations, "f").length >= __classPrivateFieldGet(this, _ViolationCollector_maxCount, "f")) {
-                __classPrivateFieldSet(this, _ViolationCollector_locked, true, "f");
+            this.#violations.push({ ...violation, filePath });
+            if (this.#maxCount > 0 && this.#violations.length >= this.#maxCount) {
+                this.#locked = true;
                 break;
             }
         }
-        return __classPrivateFieldGet(this, _ViolationCollector_violations, "f").length;
+        return this.#violations.length;
     }
+    /**
+     * The total number of collected violations.
+     */
     get length() {
-        return __classPrivateFieldGet(this, _ViolationCollector_violations, "f").length;
+        return this.#violations.length;
     }
+    /**
+     * Whether the collector has reached its maximum count and will no longer accept violations.
+     *
+     * @returns `true` if the collector is locked
+     */
     isLocked() {
-        return __classPrivateFieldGet(this, _ViolationCollector_locked, "f");
+        return this.#locked;
     }
+    /**
+     * Returns a copy of all collected violations as an array.
+     *
+     * @returns An array of violations with their associated file paths
+     */
     toArray() {
-        return [...__classPrivateFieldGet(this, _ViolationCollector_violations, "f")];
+        return [...this.#violations];
     }
+    /**
+     * Groups collected violations by their file path.
+     *
+     * @returns A Map from file path to an array of violations for that file
+     */
     groupByFile() {
         const grouped = new Map();
-        for (const violation of __classPrivateFieldGet(this, _ViolationCollector_violations, "f")) {
+        for (const violation of this.#violations) {
             const { filePath, ...violationWithoutPath } = violation;
             if (!grouped.has(filePath)) {
                 grouped.set(filePath, []);
@@ -52,4 +73,3 @@ export class ViolationCollector {
         return grouped;
     }
 }
-_ViolationCollector_violations = new WeakMap(), _ViolationCollector_maxCount = new WeakMap(), _ViolationCollector_locked = new WeakMap();