@redocly/recheck 0.1.0 → 0.2.0

package/dist/core/markdoc-tags.js

@@ -0,0 +1,131 @@
+import { filterByTypes } from '../parser/index.js';
+import { newLineRe } from './line-endings.js';
+/**
+ * The character `scopes/extractor.ts` blanks a markdoc tag's span with when
+ * building prose content. A SPACE, deliberately, and not
+ * `core/inline-code.ts`'s `\0` sentinel:
+ *
+ * - Recheck's prose model must read a tag's span as a GAP, and the word
+ *   tokenizers, `String.prototype.trim`, and the sentence splitter all agree on
+ *   whitespace, so a space makes every one of them treat the tag as absent.
+ * - A user-supplied regex must NOT read it as a gap, and no sentinel can give
+ *   that: `\0` stops `\s+` from crossing a tag, but a negated class (`[^,]+`)
+ *   walks straight through it either way. Regex rules therefore have to reject
+ *   a match by RANGE, after the fact, against the unmodified text — see
+ *   `ScopedSegment.maskedRanges` and `nonProseRanges` in `rules/utils.ts`.
+ */
+export const MARKDOC_TAG_MASK_CHAR = ' ';
+/**
+ * Every markdoc tag's source span in `content`, split per line (see
+ * `MarkdocTagSpan`). Empty for a flag-off parse, since no `markdocTag` tokens
+ * exist in the tree at all, so `--fix` behaves byte-identically.
+ *
+ * Uses `filterByTypes` rather than a raw `tree.flat.filter` so htmlFlow-reparsed
+ * tokens are excluded on the same terms as for every other consumer: they
+ * duplicate positions already covered by their `htmlFlow` parent, and treating a
+ * duplicate as a protected span would block fixes on a line with no real tag.
+ */
+export function markdocTagSpans(tree, content) {
+    const tags = filterByTypes(tree, ['markdocTag']);
+    if (tags.length === 0)
+        return [];
+    const sourceLines = content.split(newLineRe);
+    const spans = [];
+    for (const tag of tags) {
+        for (let line = tag.startLine; line <= tag.endLine; line++) {
+            const sourceLine = sourceLines[line - 1] ?? '';
+            const startColumn = line === tag.startLine ? tag.startColumn : 1;
+            const endColumn = line === tag.endLine ? tag.endColumn : sourceLine.length + 1;
+            if (endColumn <= startColumn)
+                continue;
+            spans.push({
+                line,
+                startColumn,
+                endColumn,
+                text: sourceLine.slice(startColumn - 1, endColumn - 1),
+            });
+        }
+    }
+    return spans;
+}
+/**
+ * The choke point that keeps `--fix` from rewriting a markdoc tag's bytes.
+ *
+ * Prose scope content is masked (see `MARKDOC_TAG_MASK_CHAR`), which breaks the
+ * precondition every whole-span rewriter relied on: `ScopedSegment.content` used
+ * to be a verbatim source slice, so a rule replacing its whole span writes the
+ * mask back over the real source and DELETES the tag. Rather than teach each such
+ * rule to splice its own tags back, every fix from every rule passes through here
+ * once, on its way to `applyFixesToContent`:
+ *
+ * - No tag on the fix's line, or no overlap with one: passes through untouched.
+ *   This is the only path a flag-off run can take, so flag-off byte-identity is
+ *   structural, not a special case.
+ * - Overlap where the fix replaces its span with the SAME number of characters:
+ *   each overlapped tag's original bytes are spliced back at their own offsets.
+ *   Length preservation is what makes those offsets meaningful, and it is the
+ *   same contract `restoreInlineCode` (core/inline-code.ts) already relies on.
+ * - Anything else — a length-changing replacement, a fix that cuts a tag in half,
+ *   a whole-line rewrite (`deleteCount: -1`) on a line with a tag — is DROPPED
+ *   and reported as skipped, since there is no position to splice into without
+ *   inventing one.
+ *
+ * A fix that turns out to change nothing once its tags are restored is dropped
+ * too: it only matched mask characters, and letting it through would report a
+ * byte-identical file as fixed and make `runRulesUntilStable` re-propose it on
+ * every pass.
+ */
+export function protectMarkdocTags(fixes, spans, content) {
+    if (spans.length === 0 || fixes.length === 0)
+        return { fixes, dropped: [] };
+    const byLine = new Map();
+    for (const span of spans) {
+        const existing = byLine.get(span.line);
+        if (existing)
+            existing.push(span);
+        else
+            byLine.set(span.line, [span]);
+    }
+    const sourceLines = content.split(newLineRe);
+    const safe = [];
+    const dropped = [];
+    for (const fix of fixes) {
+        const lineSpans = byLine.get(fix.lineNumber);
+        if (lineSpans === undefined) {
+            safe.push(fix);
+            continue;
+        }
+        const deleteCount = fix.deleteCount ?? 0;
+        if (deleteCount === -1) {
+            dropped.push(fix);
+            continue;
+        }
+        const editColumn = fix.editColumn ?? 1;
+        const editEnd = editColumn + deleteCount;
+        const overlapped = lineSpans.filter((span) => editColumn < span.endColumn && span.startColumn < editEnd);
+        if (overlapped.length === 0) {
+            safe.push(fix);
+            continue;
+        }
+        const insertText = fix.insertText ?? '';
+        const splittable = insertText.length === deleteCount &&
+            overlapped.every((span) => span.startColumn >= editColumn && span.endColumn <= editEnd);
+        if (!splittable) {
+            dropped.push(fix);
+            continue;
+        }
+        let restored = insertText;
+        for (const span of overlapped) {
+            const at = span.startColumn - editColumn;
+            restored = restored.slice(0, at) + span.text + restored.slice(at + span.text.length);
+        }
+        const replaced = (sourceLines[fix.lineNumber - 1] ?? '').slice(editColumn - 1, editEnd - 1);
+        if (restored === replaced) {
+            dropped.push(fix);
+            continue;
+        }
+        safe.push({ ...fix, insertText: restored });
+    }
+    return { fixes: safe, dropped };
+}
+//# sourceMappingURL=markdoc-tags.js.map

package/dist/core/markdoc-tags.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"markdoc-tags.js","sourceRoot":"","sources":["../../src/core/markdoc-tags.ts"],"names":[],"mappings":"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"}

package/dist/core/runner.d.ts

@@ -1,4 +1,93 @@
-import type { Problem, NormalizedRule } from '../types/index.js';
-import type { RunOptions } from '../commands/run.js';
-export declare function runRecheck(files: string[], rules: NormalizedRule[], options?: RunOptions): Promise<Problem[]>;
+import type { NormalizedRule, Problem } from '../types/index.js';
+import type { Fix } from '../types/index.js';
+import type { ScopeRuleContext } from '../rules/types.js';
+import { type MarkdocSchema } from '../parser/markdoc/schema.js';
+export interface RunnerOptions {
+    fix?: boolean;
+    /**
+     * Cap on the total problems a run may collect, enforced BETWEEN files:
+     * once a file's lint pushes the total to (or past) the cap, that file's
+     * overflow is truncated and NO further file is linted at all — so a
+     * pathological input set can't ballon memory past cap + one file's worth
+     * of problems. Runs that hit the cap report `truncated: true` on their
+     * RunResult. Omit for unbounded collection (the default).
+     */
+    maxProblems?: number;
+    /**
+     * FULL set of configured rule names, used only to decide which inline
+     * directive names get an "unknown rule" warning (see core/directives.ts).
+     * Callers filter `severity: off` rules out of `rules` before runRules, so
+     * without this a directive suppressing an off-rule — a deliberate no-op,
+     * not a typo — would warn as unknown. Defaults to the names of `rules`
+     * (correct for callers that never pre-filter).
+     */
+    knownRuleNames?: Set<string>;
+    /**
+     * Opt-in Markdoc tokenization, passed through to every `parseMarkdown` call
+     * this run makes. Defaults to disabled, matching `parseMarkdown`'s own
+     * default, which leaves the parse byte-identical.
+     */
+    markdoc?: boolean;
+    /**
+     * The resolved schema used to derive `ctx.markdoc.pairing`'s self-closing
+     * set; only meaningful alongside `markdoc: true`. `null` or omitted means no
+     * schema: parsing and pairing still run, every rule reading
+     * `ctx.markdoc.schema` sees `null`, and no tag name counts as self-closing,
+     * so an unclosed one lands in `pairing.unclosed` rather than
+     * `voidMissingSlash`.
+     */
+    markdocSchema?: MarkdocSchema | null;
+}
+export interface FileInput {
+    path: string;
+    content: string;
+    metadata?: ScopeRuleContext['fileMetadata'];
+}
+export interface RunResult {
+    problems: Problem[];
+    fixedFiles: Map<string, string>;
+    /**
+     * Flat list of the fixes that GENUINELY landed in `fixedFiles`, for
+     * reporting. Proposed fixes dropped by the applier's overlap resolution
+     * are NOT here — they're in `skippedFixes` (see applyFixesToContent's
+     * applied/skipped classification).
+     */
+    fixes: Fix[];
+    /**
+     * Proposed fixes that could not be applied (overlapping edits,
+     * out-of-range lines). For runRulesUntilStable this holds only the fixes
+     * still pending after the final pass — a fix skipped in one pass but
+     * re-proposed and applied in a later pass is (correctly) reported in
+     * `fixes` instead.
+     */
+    skippedFixes: Fix[];
+    /**
+     * True when `RunnerOptions.maxProblems` cut the run short: problems were
+     * dropped past the cap and/or later files were never linted. Always false
+     * for uncapped runs, and for capped runs whose problem count never
+     * exceeded the cap with files left over.
+     */
+    truncated: boolean;
+}
+export declare function runRules(files: FileInput[], rules: NormalizedRule[], options?: RunnerOptions): Promise<RunResult>;
+/**
+ * Runs rules with fix:true repeatedly (lint → apply fixes → re-lint the
+ * fixed content) until a pass produces zero fixes, capped at
+ * MAX_FIX_PASSES. runRules() itself is single-pass by design (library
+ * callers that need convergence should loop, as this helper does). This is
+ * what public API's lintFiles() and the CLI's run
+ * command use so a single --fix invocation fully converges instead of
+ * requiring the user to re-run --fix multiple times.
+ *
+ * The returned `problems` are from the FIRST pass (matching prior
+ * single-pass behavior: --fix reports the issues it found/fixed, not the
+ * post-fix state) while `fixedFiles` reflects the final, fully-converged
+ * content. `fixes` is the flat list of every fix genuinely applied across
+ * all passes; `skippedFixes` holds only the fixes still pending after the
+ * final pass. A fix skipped mid-run (overlap) is normally re-proposed
+ * against the fixed content and applied by a later pass — it then counts
+ * in `fixes`, not `skippedFixes` — so a non-empty `skippedFixes` here
+ * means the run hit MAX_FIX_PASSES with conflicting edits unresolved.
+ */
+export declare function runRulesUntilStable(files: FileInput[], rules: NormalizedRule[], options?: Omit<RunnerOptions, 'fix'>): Promise<RunResult>;
 //# sourceMappingURL=runner.d.ts.map

package/dist/core/runner.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"runner.d.ts","sourceRoot":"","sources":["../../src/core/runner.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,OAAO,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AACjE,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAC;AA0DrD,wBAAsB,UAAU,CAC9B,KAAK,EAAE,MAAM,EAAE,EACf,KAAK,EAAE,cAAc,EAAE,EACvB,OAAO,GAAE,UAAe,GACvB,OAAO,CAAC,OAAO,EAAE,CAAC,CAsGpB"}
+{"version":3,"file":"runner.d.ts","sourceRoot":"","sources":["../../src/core/runner.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,OAAO,EAAE,MAAM,mBAAmB,CAAC;AACjE,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,mBAAmB,CAAC;AAE7C,OAAO,KAAK,EAAE,gBAAgB,EAAoB,MAAM,mBAAmB,CAAC;AAc5E,OAAO,EAAuB,KAAK,aAAa,EAAE,MAAM,6BAA6B,CAAC;AAEtF,MAAM,WAAW,aAAa;IAC5B,GAAG,CAAC,EAAE,OAAO,CAAC;IACd;;;;;;;OAOG;IACH,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB;;;;;;;OAOG;IACH,cAAc,CAAC,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;IAC7B;;;;OAIG;IACH,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB;;;;;;;OAOG;IACH,aAAa,CAAC,EAAE,aAAa,GAAG,IAAI,CAAC;CACtC;AAED,MAAM,WAAW,SAAS;IACxB,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,CAAC,EAAE,gBAAgB,CAAC,cAAc,CAAC,CAAC;CAC7C;AAED,MAAM,WAAW,SAAS;IACxB,QAAQ,EAAE,OAAO,EAAE,CAAC;IACpB,UAAU,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAChC;;;;;OAKG;IACH,KAAK,EAAE,GAAG,EAAE,CAAC;IACb;;;;;;OAMG;IACH,YAAY,EAAE,GAAG,EAAE,CAAC;IACpB;;;;;OAKG;IACH,SAAS,EAAE,OAAO,CAAC;CACpB;AA0ED,wBAAsB,QAAQ,CAC5B,KAAK,EAAE,SAAS,EAAE,EAClB,KAAK,EAAE,cAAc,EAAE,EACvB,OAAO,GAAE,aAAkB,GAC1B,OAAO,CAAC,SAAS,CAAC,CAqPpB;AAOD;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAsB,mBAAmB,CACvC,KAAK,EAAE,SAAS,EAAE,EAClB,KAAK,EAAE,cAAc,EAAE,EACvB,OAAO,GAAE,IAAI,CAAC,aAAa,EAAE,KAAK,CAAM,GACvC,OAAO,CAAC,SAAS,CAAC,CAuCpB"}