@amritk/lint 0.0.0 → 0.2.0

package/dist/core/runner.js

@@ -0,0 +1,222 @@
+import { detectFormats } from './formats.js';
+import { matchesGlob } from './glob.js';
+import { compileQuery, queryMany } from './jsonpath.js';
+import { pointerToPath, resolveSourcePath } from './pointers.js';
+import { DiagnosticSeverity, } from './types.js';
+const SEVERITY_NAMES = {
+    error: DiagnosticSeverity.Error,
+    warn: DiagnosticSeverity.Warning,
+    info: DiagnosticSeverity.Information,
+    hint: DiagnosticSeverity.Hint,
+};
+const ZERO_RANGE = { start: { line: 0, character: 0 }, end: { line: 0, character: 0 } };
+const isObject = (value) => typeof value === 'object' && value !== null && !Array.isArray(value);
+const resolveTargets = (value, path, field) => {
+    if (field === undefined)
+        return [{ value, path }];
+    if (field === '$')
+        return [{ value, path }];
+    if (field === '@key') {
+        if (!isObject(value))
+            return [];
+        return Object.keys(value).map((key) => ({ value: key, path: [...path, key] }));
+    }
+    if (isObject(value))
+        return [{ value: value[field], path: [...path, field] }];
+    return [];
+};
+const stringify = (value) => {
+    if (value === undefined)
+        return '';
+    if (typeof value === 'string')
+        return value;
+    return JSON.stringify(value);
+};
+const applyTemplate = (template, ctx) => template.replace(/\{\{([^}]+)\}\}/g, (_match, raw) => {
+    const key = raw.trim();
+    return key in ctx ? stringify(ctx[key]) : '';
+});
+/**
+ * Builds a deduped query plan for `rules` against `data`: each distinct
+ * (expanded) `given` is compiled and evaluated once, then its matches fan out to
+ * every rule that shares it. Recursive descents are evaluated with a single
+ * shared tree walk inside `queryMany`.
+ */
+const runPlan = (ruleset, rules, data, document, formats, out, sources) => {
+    if (rules.length === 0)
+        return;
+    const order = [];
+    const groups = new Map();
+    for (const rule of rules) {
+        for (const given of ruleset.expandGiven(rule.given, formats)) {
+            let group = groups.get(given);
+            if (!group) {
+                group = { compiled: compileQuery(given), rules: [] };
+                groups.set(given, group);
+                order.push(given);
+            }
+            // Guard against a rule listing the same `given` twice.
+            if (group.rules[group.rules.length - 1] !== rule)
+                group.rules.push(rule);
+        }
+    }
+    const compiled = order.map((given) => groups.get(given).compiled);
+    const matchesPerGiven = queryMany(data, compiled);
+    for (let i = 0; i < order.length; i++) {
+        const group = groups.get(order[i]);
+        const matches = matchesPerGiven[i];
+        for (const match of matches) {
+            for (const rule of group.rules) {
+                for (const then of rule.then) {
+                    runThen(ruleset, rule, then, match.value, match.path, document, out, sources);
+                }
+            }
+        }
+    }
+};
+/** Applies `overrides` whose `files` entry includes a JSON pointer scope (`file#/path`). */
+const applyScopedOverrides = (ruleset, source, diagnostics) => {
+    if (!source)
+        return diagnostics;
+    const scoped = [];
+    for (const override of ruleset.overrides) {
+        if (!override.rules)
+            continue;
+        for (const file of override.files) {
+            const hashIndex = file.indexOf('#');
+            if (hashIndex === -1)
+                continue;
+            const glob = file.slice(0, hashIndex);
+            const path = pointerToPath(file.slice(hashIndex));
+            if (path && (glob === '' || matchesGlob(source, [glob]))) {
+                scoped.push({ path, rules: override.rules });
+            }
+        }
+    }
+    if (scoped.length === 0)
+        return diagnostics;
+    const isPrefix = (prefix, path) => prefix.every((segment, index) => String(path[index]) === String(segment));
+    const result = [];
+    for (const diagnostic of diagnostics) {
+        let dropped = false;
+        for (const { path, rules } of scoped) {
+            if (!isPrefix(path, diagnostic.path))
+                continue;
+            const entry = rules[String(diagnostic.code)];
+            if (entry === undefined)
+                continue;
+            if (entry === false || entry === 'off') {
+                dropped = true;
+                break;
+            }
+            if (typeof entry === 'number')
+                diagnostic.severity = entry;
+            else if (typeof entry === 'string' && entry in SEVERITY_NAMES) {
+                diagnostic.severity = SEVERITY_NAMES[entry];
+            }
+        }
+        if (!dropped)
+            result.push(diagnostic);
+    }
+    return result;
+};
+const runThen = (ruleset, rule, then, value, path, document, out, sources) => {
+    // A malformed rule (e.g. a `then` with no `function`, which `validateRuleset`
+    // warns about) is skipped rather than crashing the whole run.
+    if (!then || (typeof then.function !== 'function' && typeof then.function !== 'string'))
+        return;
+    const fn = typeof then.function === 'function' ? then.function : ruleset.getFunction(then.function);
+    if (!fn)
+        throw new Error(`Rule "${rule.name}" references unknown function "${String(then.function)}"`);
+    for (const target of resolveTargets(value, path, then.field)) {
+        const results = fn(target.value, then.functionOptions ?? {}, {
+            document,
+            path: target.path,
+            value: target.value,
+            rule,
+            functionOptions: then.functionOptions,
+        });
+        if (!results)
+            continue;
+        for (const result of results) {
+            out.push(toDiagnostic(rule, result, target, document, sources));
+        }
+    }
+};
+const toDiagnostic = (rule, result, target, document, sources) => {
+    const path = result.path ?? target.path;
+    const property = path.length > 0 ? path[path.length - 1] : undefined;
+    const message = rule.message
+        ? applyTemplate(rule.message, {
+            property,
+            value: target.value,
+            path: path.join('.'),
+            error: result.message,
+            description: rule.description ?? '',
+        })
+        : result.message;
+    // A resolved finding may sit on a node inlined from another file. With a source
+    // set, follow the `$ref` chain across documents so the range and `source` point
+    // at the originating file; otherwise fall back to the root document, following
+    // internal `$ref`s only.
+    let originDocument = document;
+    let sourcePath;
+    if (rule.resolved && sources) {
+        const origin = sources.origin(path);
+        originDocument = sources.get(origin.location) ?? document;
+        sourcePath = origin.path;
+    }
+    else {
+        sourcePath = rule.resolved ? resolveSourcePath(document.data, path) : path;
+    }
+    const location = originDocument.getLocationForJsonPath(sourcePath, true);
+    const diagnostic = {
+        code: rule.name,
+        message,
+        path,
+        severity: rule.severity,
+        range: location?.range ?? ZERO_RANGE,
+    };
+    if (originDocument.source !== undefined)
+        diagnostic.source = originDocument.source;
+    return diagnostic;
+};
+const hasIntersection = (a, b) => {
+    for (const value of a) {
+        if (b.has(value))
+            return true;
+    }
+    return false;
+};
+const byPosition = (a, b) => a.range.start.line - b.range.start.line || a.range.start.character - b.range.start.character;
+/** Creates a {@link Linter} runner bound to a normalized `ruleset`. */
+export const createLinter = (ruleset) => ({
+    run: (document, options = {}) => {
+        const documentFormats = detectFormats(document.data, ruleset.formats);
+        const diagnostics = [];
+        // Rules split by which document they run against (resolved vs raw). Each
+        // dataset is linted with a single deduped query plan so that identical
+        // `given`s evaluate once and all `$..` descents share one tree walk.
+        const resolvedAvailable = options.resolved !== undefined;
+        const rawRules = [];
+        const resolvedRules = [];
+        for (const rule of ruleset.rulesForSource(document.source)) {
+            if (!rule.enabled)
+                continue;
+            if (rule.formats && !hasIntersection(rule.formats, documentFormats))
+                continue;
+            if (rule.resolved && resolvedAvailable)
+                resolvedRules.push(rule);
+            else
+                rawRules.push(rule);
+        }
+        // Raw rules run against the root's unresolved tree, so positions always come
+        // straight from the root document; only resolved rules can land on inlined
+        // external nodes and need the source set.
+        runPlan(ruleset, rawRules, document.data, document, documentFormats, diagnostics, undefined);
+        if (resolvedRules.length > 0) {
+            runPlan(ruleset, resolvedRules, options.resolved, document, documentFormats, diagnostics, options.sources);
+        }
+        return applyScopedOverrides(ruleset, document.source, diagnostics).sort(byPosition);
+    },
+});

package/dist/core/types.d.ts

@@ -0,0 +1,170 @@
+import type { DiagnosticSeverity, ILocation, IRange, JsonPath } from '../parsers/index.js';
+import type { Document } from './document.js';
+export type { ILocation, IPosition, IRange, JsonPath } from '../parsers/index.js';
+export { DiagnosticSeverity } from '../parsers/index.js';
+/** The string severities a ruleset author can write, plus `off` to disable a rule. */
+export type HumanReadableSeverity = 'error' | 'warn' | 'info' | 'hint' | 'off';
+/** A single finding produced by a function. */
+export type IFunctionResult = {
+    message: string;
+    path?: JsonPath;
+};
+/** Context passed to every function invocation. */
+export type IFunctionContext = {
+    document: Document;
+    /** The path of the value the function was invoked on. */
+    path: JsonPath;
+    /** The original `given` value the rule matched. */
+    value?: unknown;
+    /** Rule metadata. */
+    rule: ResolvedRule;
+    /** Function options as authored in the ruleset. */
+    functionOptions?: unknown;
+};
+/**
+ * A rule function: given the matched `input`, its authored `options`, and the
+ * run `context`, returns any findings (or `undefined`/`[]` for none).
+ */
+export type RulesetFunction<I = unknown, O = unknown> = (input: I, options: O, context: IFunctionContext) => IFunctionResult[] | undefined;
+/** Functions a ruleset can invoke by name in `then.function`, keyed by that name. */
+export type FunctionRegistry = Record<string, RulesetFunction>;
+/** One action a rule takes on each match: a function plus how to target/configure it. */
+export type IThen = {
+    /**
+     * Narrows the target before running the function. `$` = current value,
+     * `@key` = each property key, or a property name.
+     */
+    field?: string;
+    /**
+     * A built-in/registered function name (YAML/JSON rulesets) or a direct function
+     * reference (JS rulesets that import their own functions).
+     */
+    function: string | RulesetFunction;
+    functionOptions?: Record<string, unknown>;
+};
+/** A rule as authored in a ruleset, before normalization. */
+export type IRuleDefinition = {
+    description?: string;
+    message?: string;
+    severity?: DiagnosticSeverity | HumanReadableSeverity;
+    given: string | string[];
+    then: IThen | IThen[];
+    formats?: string[];
+    recommended?: boolean;
+    /** When false, the rule runs against the unresolved document. Default true. */
+    resolved?: boolean;
+    documentationUrl?: string;
+};
+/** Shorthand a rule may take in `rules`: a definition, a boolean, or a severity. */
+export type RuleEntry = IRuleDefinition | boolean | HumanReadableSeverity;
+export type IRulesetOverride = {
+    files: string[];
+    rules?: Record<string, RuleEntry>;
+    extends?: RulesetExtends;
+    formats?: string[];
+};
+/**
+ * The shape of a ruleset's `extends`: a single target or a list, where each
+ * entry may be paired with a modifier (`all` / `recommended` / `off`) to control
+ * which of the extended rules turn on.
+ */
+export type RulesetExtends = string | RulesetDefinition | (string | RulesetDefinition | [string | RulesetDefinition, 'all' | 'recommended' | 'off'])[];
+/** A ruleset as authored: rules, `extends`, custom functions, overrides, and aliases. */
+export type RulesetDefinition = {
+    extends?: RulesetExtends;
+    rules?: Record<string, RuleEntry>;
+    /**
+     * Names of custom functions a YAML/JSON ruleset references by string in
+     * `then.function`. Loaded from `functionsDir` (default `functions`, relative to
+     * the ruleset file) by the CLI/rulesets layer. JS rulesets can instead pass a
+     * direct function reference and skip this.
+     */
+    functions?: string[];
+    /** Directory (relative to the ruleset file) that `functions` are loaded from. Defaults to `functions`. */
+    functionsDir?: string;
+    overrides?: IRulesetOverride[];
+    aliases?: Record<string, string[] | {
+        description?: string;
+        targets: {
+            formats: string[];
+            given: string[];
+        }[];
+    }>;
+    formats?: string[];
+    documentationUrl?: string;
+    parserOptions?: {
+        duplicateKeys?: DiagnosticSeverity | HumanReadableSeverity;
+        incompatibleValues?: DiagnosticSeverity | HumanReadableSeverity;
+    };
+};
+/** A fully normalized rule ready to execute. */
+export type ResolvedRule = {
+    name: string;
+    description?: string | undefined;
+    message?: string | undefined;
+    severity: DiagnosticSeverity;
+    enabled: boolean;
+    given: string[];
+    then: IThen[];
+    formats?: Set<string> | undefined;
+    recommended: boolean;
+    resolved: boolean;
+    documentationUrl?: string | undefined;
+};
+/** A single finding emitted by the runner, mapped back to a source range. */
+export type IDiagnostic = {
+    code: string | number;
+    message: string;
+    path: JsonPath;
+    severity: DiagnosticSeverity;
+    source?: string;
+    range: IRange;
+};
+/** A single parsed source document with its own line:column source map. */
+export type ISourceDocument = {
+    readonly data: unknown;
+    /** Display path used as a finding's `source` (e.g. a path relative to cwd, or a URL). */
+    readonly source?: string | undefined;
+    getLocationForJsonPath(path: JsonPath, closest?: boolean): ILocation | undefined;
+};
+/** Where a resolved-tree node originated: which source document, and the path within it. */
+export type ISourceOrigin = {
+    /** Absolute location (file path or URL) of the originating document. */
+    location: string;
+    /** The path within that document. */
+    path: JsonPath;
+};
+/**
+ * Source documents keyed by absolute location, with a known root. This is the
+ * input to the cross-document walk that re-derives a node's origin from the
+ * *unresolved* documents (see `resolveSourceOrigin`).
+ */
+export type IDocumentRegistry = {
+    /** Absolute location of the root document (the walk's starting point). */
+    readonly rootLocation: string;
+    get(location: string): ISourceDocument | undefined;
+};
+/**
+ * Per-node origin metadata produced by the resolver (`@amritk/resolve-refs`'
+ * `trackOrigins`): given an inlined object/array, where it came from. Lets us
+ * find a node's origin with a single downward walk of the resolved tree instead
+ * of re-deriving the resolver's `$ref` traversal.
+ */
+export type IOriginMap = {
+    get(node: object): {
+        location: string;
+        pointer: JsonPath;
+    } | undefined;
+};
+/**
+ * The runner-facing view of the source documents behind a resolved tree. Lets
+ * findings on nodes inlined from external files map back to the correct file's
+ * line:column. `get` resolves a location to its document; `origin` maps a
+ * resolved-tree path to the document and in-file path it came from (backed by
+ * either the resolver's origin map or the cross-document walk). A `Document`
+ * satisfies `ISourceDocument`.
+ */
+export type ISourceSet = {
+    get(location: string): ISourceDocument | undefined;
+    origin(path: JsonPath): ISourceOrigin;
+};

package/dist/core/types.js

@@ -0,0 +1 @@
+export { DiagnosticSeverity } from '../parsers/index.js';

package/dist/core/validate-ruleset.d.ts

@@ -0,0 +1,14 @@
+import type { JsonPath } from './types.js';
+/** A problem found in a ruleset definition (structural, not a document finding). */
+export type IRulesetProblem = {
+    message: string;
+    /** Path into the ruleset object, joined with `.` for display. */
+    path: JsonPath;
+};
+/**
+ * Validates the *shape* of a ruleset definition, returning a list of problems
+ * (empty when valid). This is a lightweight structural check — it does not load
+ * `extends` targets or verify that referenced functions exist — so a malformed
+ * ruleset surfaces actionable diagnostics instead of failing obscurely at runtime.
+ */
+export declare const validateRuleset: (definition: unknown) => IRulesetProblem[];

package/dist/core/validate-ruleset.js

@@ -0,0 +1,105 @@
+const SEVERITIES = new Set(['error', 'warn', 'info', 'hint', 'off']);
+const isObject = (value) => typeof value === 'object' && value !== null && !Array.isArray(value);
+const isValidSeverity = (value) => {
+    if (typeof value === 'number')
+        return Number.isInteger(value) && value >= 0 && value <= 3;
+    return typeof value === 'string' && SEVERITIES.has(value);
+};
+const validateThen = (then, path, problems) => {
+    const entries = Array.isArray(then) ? then : [then];
+    entries.forEach((entry, index) => {
+        const at = Array.isArray(then) ? [...path, index] : path;
+        if (!isObject(entry)) {
+            problems.push({ message: '`then` must be an object (or array of objects)', path: at });
+            return;
+        }
+        const fn = entry['function'];
+        if (typeof fn !== 'string' && typeof fn !== 'function') {
+            problems.push({ message: '`then.function` must be a function name or reference', path: [...at, 'function'] });
+        }
+        if (entry['field'] !== undefined && typeof entry['field'] !== 'string') {
+            problems.push({ message: '`then.field` must be a string', path: [...at, 'field'] });
+        }
+    });
+};
+const validateRule = (name, entry, path, problems) => {
+    // Shorthand: boolean toggle or a severity string.
+    if (typeof entry === 'boolean')
+        return;
+    if (typeof entry === 'string') {
+        if (!isValidSeverity(entry)) {
+            problems.push({ message: `Rule "${name}" has invalid severity "${entry}"`, path });
+        }
+        return;
+    }
+    if (!isObject(entry)) {
+        problems.push({ message: `Rule "${name}" must be an object, boolean, or severity string`, path });
+        return;
+    }
+    if (entry['given'] === undefined) {
+        problems.push({ message: `Rule "${name}" is missing \`given\``, path: [...path, 'given'] });
+    }
+    else if (typeof entry['given'] !== 'string' && !Array.isArray(entry['given'])) {
+        problems.push({ message: `Rule "${name}" \`given\` must be a string or array`, path: [...path, 'given'] });
+    }
+    if (entry['then'] === undefined) {
+        problems.push({ message: `Rule "${name}" is missing \`then\``, path: [...path, 'then'] });
+    }
+    else {
+        validateThen(entry['then'], [...path, 'then'], problems);
+    }
+    if (entry['severity'] !== undefined && !isValidSeverity(entry['severity'])) {
+        problems.push({ message: `Rule "${name}" has invalid severity`, path: [...path, 'severity'] });
+    }
+    if (entry['formats'] !== undefined && !Array.isArray(entry['formats'])) {
+        problems.push({ message: `Rule "${name}" \`formats\` must be an array`, path: [...path, 'formats'] });
+    }
+};
+/**
+ * Validates the *shape* of a ruleset definition, returning a list of problems
+ * (empty when valid). This is a lightweight structural check — it does not load
+ * `extends` targets or verify that referenced functions exist — so a malformed
+ * ruleset surfaces actionable diagnostics instead of failing obscurely at runtime.
+ */
+export const validateRuleset = (definition) => {
+    const problems = [];
+    if (!isObject(definition)) {
+        return [{ message: 'Ruleset must be an object', path: [] }];
+    }
+    if (definition['rules'] !== undefined) {
+        if (!isObject(definition['rules'])) {
+            problems.push({ message: '`rules` must be an object', path: ['rules'] });
+        }
+        else {
+            for (const [name, entry] of Object.entries(definition['rules'])) {
+                validateRule(name, entry, ['rules', name], problems);
+            }
+        }
+    }
+    const ext = definition['extends'];
+    if (ext !== undefined && typeof ext !== 'string' && !Array.isArray(ext) && !isObject(ext)) {
+        problems.push({ message: '`extends` must be a string, array, or object', path: ['extends'] });
+    }
+    if (definition['overrides'] !== undefined && !Array.isArray(definition['overrides'])) {
+        problems.push({ message: '`overrides` must be an array', path: ['overrides'] });
+    }
+    else if (Array.isArray(definition['overrides'])) {
+        definition['overrides'].forEach((override, index) => {
+            if (!isObject(override) || !Array.isArray(override['files'])) {
+                problems.push({ message: 'Each override must have a `files` array', path: ['overrides', index] });
+            }
+        });
+    }
+    if (definition['functions'] !== undefined && !Array.isArray(definition['functions'])) {
+        problems.push({ message: '`functions` must be an array of names', path: ['functions'] });
+    }
+    if (definition['formats'] !== undefined && !Array.isArray(definition['formats'])) {
+        problems.push({ message: '`formats` must be an array', path: ['formats'] });
+    }
+    // A ruleset with neither rules nor extends does nothing — flag it.
+    if (definition.rules === undefined &&
+        definition.extends === undefined) {
+        problems.push({ message: 'Ruleset has no `rules` and no `extends` (it will produce no findings)', path: [] });
+    }
+    return problems;
+};

package/dist/fix/apply.d.ts

@@ -0,0 +1,21 @@
+import type { IDiagnostic } from '../core/index.js';
+import { type ParserFormat } from '../parsers/index.js';
+import type { FixerRegistry, FixResult } from './types.js';
+/** Options for {@link applyFixes}. */
+export type ApplyFixesOptions = {
+    /** When true (the default), fixers marked `safe: false` are skipped. */
+    safeOnly?: boolean;
+};
+/**
+ * Computes the structural edits for every fixable finding in `diagnostics`, then
+ * applies them to `input` in one pass. Edits from different findings that come
+ * out identical (e.g. several "not alphabetical" findings on one array all asking
+ * for the same reorder) are de-duplicated so the edit is applied once.
+ *
+ * `data` is the *unresolved* parsed document: fixers read the real node at a
+ * finding's path to derive the edit, and edits whose path no longer resolves are
+ * dropped — so a finding on an inlined `$ref` node simply isn't fixed rather than
+ * corrupting the source. A finding is only reported in `applied` when one of its
+ * edits actually changed the text, so dropped edits are not mistaken for fixes.
+ */
+export declare const applyFixes: (input: string, format: ParserFormat, data: unknown, diagnostics: IDiagnostic[], fixers: FixerRegistry, options?: ApplyFixesOptions) => FixResult;

package/dist/fix/apply.js

@@ -0,0 +1,51 @@
+import { applyEditOpsWithChanges } from '../parsers/index.js';
+/**
+ * Computes the structural edits for every fixable finding in `diagnostics`, then
+ * applies them to `input` in one pass. Edits from different findings that come
+ * out identical (e.g. several "not alphabetical" findings on one array all asking
+ * for the same reorder) are de-duplicated so the edit is applied once.
+ *
+ * `data` is the *unresolved* parsed document: fixers read the real node at a
+ * finding's path to derive the edit, and edits whose path no longer resolves are
+ * dropped — so a finding on an inlined `$ref` node simply isn't fixed rather than
+ * corrupting the source. A finding is only reported in `applied` when one of its
+ * edits actually changed the text, so dropped edits are not mistaken for fixes.
+ */
+export const applyFixes = (input, format, data, diagnostics, fixers, options = {}) => {
+    const safeOnly = options.safeOnly !== false;
+    const ops = [];
+    const indexByKey = new Map();
+    // Each candidate finding remembers the edits it contributed (by key) so we can
+    // tell afterwards whether any of them actually landed.
+    const candidates = [];
+    for (const diagnostic of diagnostics) {
+        const fixer = fixers[String(diagnostic.code)];
+        if (!fixer)
+            continue;
+        if (safeOnly && fixer.safe === false)
+            continue;
+        const produced = fixer.fix({ diagnostic, data, format });
+        if (!produced)
+            continue;
+        const keys = [];
+        for (const op of Array.isArray(produced) ? produced : [produced]) {
+            const key = JSON.stringify(op);
+            // De-duplicate identical edits (e.g. several findings on one array all asking
+            // for the same reorder) so the edit is applied — and counted — once.
+            if (!indexByKey.has(key)) {
+                indexByKey.set(key, ops.length);
+                ops.push(op);
+            }
+            keys.push(key);
+        }
+        if (keys.length > 0)
+            candidates.push({ fix: { code: diagnostic.code, path: diagnostic.path }, keys });
+    }
+    if (ops.length === 0)
+        return { output: input, applied: [], changed: false };
+    const { output, changed } = applyEditOpsWithChanges(input, format, ops);
+    const applied = candidates
+        .filter((candidate) => candidate.keys.some((key) => changed[indexByKey.get(key)]))
+        .map((candidate) => candidate.fix);
+    return { output, applied, changed: output !== input };
+};

package/dist/fix/index.d.ts

@@ -0,0 +1,3 @@
+export { type ApplyFixesOptions, applyFixes } from './apply.js';
+export { createFixPlugin, FIX_PLUGIN_NAME, type FixPluginData } from './plugin.js';
+export type { AppliedFix, EditOp, FixContext, Fixer, FixerRegistry, FixResult, ParserFormat } from './types.js';

package/dist/fix/index.js

@@ -0,0 +1,2 @@
+export { applyFixes } from './apply.js';
+export { createFixPlugin, FIX_PLUGIN_NAME } from './plugin.js';

package/dist/fix/plugin.d.ts

@@ -0,0 +1,18 @@
+import type { LintPlugin } from '../core/index.js';
+import { type ApplyFixesOptions } from './apply.js';
+import type { AppliedFix, FixerRegistry } from './types.js';
+/** The name the fix plugin registers under (its `data` is surfaced here). */
+export declare const FIX_PLUGIN_NAME = "fix";
+/** Structured output the fix plugin returns under {@link FIX_PLUGIN_NAME}. */
+export type FixPluginData = {
+    applied: AppliedFix[];
+};
+/**
+ * Builds the auto-fix {@link LintPlugin} from a {@link FixerRegistry}. As a
+ * post-lint plugin it reads the run's findings and the raw document text, applies
+ * the fixers' edits, and returns the rewritten text as `output` plus the list of
+ * repaired findings as `data`. The core engine stays unaware of fixing — remove
+ * this plugin (and the `../fix` dependency) and Linter lints exactly as
+ * before.
+ */
+export declare const createFixPlugin: (fixers: FixerRegistry, options?: ApplyFixesOptions) => LintPlugin;

package/dist/fix/plugin.js

@@ -0,0 +1,21 @@
+import { applyFixes } from './apply.js';
+/** The name the fix plugin registers under (its `data` is surfaced here). */
+export const FIX_PLUGIN_NAME = 'fix';
+/**
+ * Builds the auto-fix {@link LintPlugin} from a {@link FixerRegistry}. As a
+ * post-lint plugin it reads the run's findings and the raw document text, applies
+ * the fixers' edits, and returns the rewritten text as `output` plus the list of
+ * repaired findings as `data`. The core engine stays unaware of fixing — remove
+ * this plugin (and the `../fix` dependency) and Linter lints exactly as
+ * before.
+ */
+export const createFixPlugin = (fixers, options = {}) => ({
+    name: FIX_PLUGIN_NAME,
+    afterLint: (diagnostics, context) => {
+        const result = applyFixes(context.input, context.format, context.document.data, diagnostics, fixers, options);
+        if (!result.changed)
+            return undefined;
+        const data = { applied: result.applied };
+        return { output: result.output, data };
+    },
+});