@redocly/recheck 0.1.0 → 0.2.0

package/dist/rules/scope/spelling.js

@@ -0,0 +1,227 @@
+import * as fs from 'node:fs/promises';
+import * as path from 'node:path';
+import { formatTemplate } from '../token/messages.js';
+import { newLineRe, offsetToLineColumn } from '../../core/line-endings.js';
+import { maskInlineCode } from '../../core/inline-code.js';
+import { isAllCapsWord } from './title-case.js';
+import { TECHNICAL_PROPER_NOUNS } from '../../data/proper-nouns.js';
+// Module-level cache, keyed by dictionary source: parsing a Hunspell
+// dictionary is expensive (the bundled English `.dic` alone is 500+KB), so
+// one speller instance is reused for the lifetime of the process. A cached
+// PROMISE (not a resolved value) so concurrent first callers await the same
+// in-flight load instead of racing separate ones.
+const DEFAULT_DICTIONARY_KEY = '\0default';
+const spellerCache = new Map();
+/**
+ * Resolves a `dictionary` option value (the shared base path WITHOUT the
+ * `.aff`/`.dic` extension) to its two file paths. Resolved relative to
+ * `process.cwd()`, not the config file's directory — consistent with every
+ * other file-shaped config value in this package; an absolute path is used
+ * as-is.
+ *
+ * Exported so `../../config/validate.ts`'s dictionary-file-existence check
+ * (see `checkSpellingPeerDependencies` there) shares this EXACT resolution
+ * rule instead of re-implementing it — a config that validates cleanly must
+ * always name the same files `readCustomDictionary` below actually reads at
+ * lint time, or validate() and the runtime could silently disagree about
+ * which files a `dictionary` path names.
+ */
+export function resolveDictionaryPaths(dictionaryPath) {
+    const resolved = path.isAbsolute(dictionaryPath)
+        ? dictionaryPath
+        : path.join(process.cwd(), dictionaryPath);
+    return { aff: `${resolved}.aff`, dic: `${resolved}.dic` };
+}
+/**
+ * Reads a custom Hunspell `.aff`/`.dic` pair from disk. `dictionaryPath` is
+ * the shared base path WITHOUT the extension (e.g. `'./dict/custom'` reads
+ * `./dict/custom.aff` and `./dict/custom.dic`) — see `resolveDictionaryPaths`
+ * for the resolution rule.
+ */
+async function readCustomDictionary(dictionaryPath) {
+    const { aff: affPath, dic: dicPath } = resolveDictionaryPaths(dictionaryPath);
+    const [aff, dic] = await Promise.all([fs.readFile(affPath), fs.readFile(dicPath)]);
+    return { aff, dic };
+}
+/**
+ * Loads the `{aff, dic}` pair `nspell` needs: a custom pair from disk when
+ * `options.dictionary` is set, otherwise the bundled default English
+ * dictionary. `dictionary-en@4` exports a plain `{ aff, dic }` object as
+ * its ESM default — NOT the v3 Node-style callback API some nspell examples
+ * still show — so there is no callback to bridge, just a destructure.
+ */
+async function loadDictionary(options) {
+    if (options.dictionary)
+        return readCustomDictionary(options.dictionary);
+    const mod = (await import('dictionary-en'));
+    return mod.default;
+}
+function loadSpeller(options) {
+    const cacheKey = options.dictionary && options.dictionary.length > 0
+        ? options.dictionary
+        : DEFAULT_DICTIONARY_KEY;
+    const cached = spellerCache.get(cacheKey);
+    if (cached)
+        return cached;
+    const loading = (async () => {
+        const [{ default: nspell }, dictionary] = await Promise.all([
+            import('nspell'),
+            loadDictionary(options),
+        ]);
+        return nspell(dictionary);
+    })();
+    spellerCache.set(cacheKey, loading);
+    // Evict on rejection: a failed load (missing peer, unreadable/missing
+    // custom dictionary file, etc.) must not poison this cache key for the
+    // rest of the process — a later call after the failure clears (peer
+    // installed, file becomes readable) should retry cleanly instead of
+    // forever replaying the same dead rejection (the High-severity finding
+    // this fixes). Attached as a SEPARATE `.catch` subscriber on `loading`
+    // itself, never reassigning `loading` or the cached map value — every
+    // real caller awaiting the SAME cached promise (via this function's own
+    // `return loading` below, or a concurrent in-flight caller that read
+    // `cached` above) still observes and handles the original rejection
+    // themselves; this handler only ever additionally deletes the now-dead
+    // cache entry alongside them, so it can never swallow the rejection a
+    // consumer sees.
+    loading.catch(() => {
+        // Only remove the entry if it's STILL this exact rejected promise — a
+        // concurrent caller could in principle have already evicted and
+        // replaced it with a newer, unrelated load, which this must never clobber.
+        if (spellerCache.get(cacheKey) === loading) {
+            spellerCache.delete(cacheKey);
+        }
+    });
+    return loading;
+}
+// -- Tokenization -----------------------------------------------------------
+// Letter runs, with an optional apostrophe-joined suffix so contractions
+// ("don't") tokenize as one word. `\p{L}` can never match a digit, so
+// "skip tokens containing digits" is true by construction — but a
+// digit-adjacent identifier like 'sha256' still tokenizes to its letter-only
+// fragments ('sha'), which nspell would flag as misspellings. The
+// `isDigitAdjacent` guard below skips those.
+const WORD_RE = /\p{L}+(?:['’]\p{L}+)?/gu;
+// True when the character immediately before `start` or after `end` is a
+// digit — used to skip a WORD_RE match that is really a truncated fragment
+// of a digit-bearing identifier ('sha256' -> 'sha', 'log4j' -> 'log' and
+// 'j') rather than a standalone word.
+function isDigitAdjacent(text, start, end) {
+    const before = text[start - 1];
+    const after = text[end];
+    return /\d/.test(before ?? '') || /\d/.test(after ?? '');
+}
+// Backtick-delimited inline code spans (extractScopes keeps them as raw
+// text in prose segment content) are masked out with the shared,
+// length-preserving maskInlineCode (core/inline-code.ts) so every remaining
+// token's offset stays aligned with `segment.content` -- see there for the
+// CommonMark span-recognition contract. Fenced/indented CODE BLOCKS need no
+// handling here: they are their own `scope: 'code'` segment, so a
+// prose-scoped rule never sees one (a rule explicitly scoped to `all`/`code`
+// still does -- see the README's `spelling` section).
+// On the segment's first line, segment.content starts mid-source-line (e.g.
+// a heading's content excludes the '## ' marker), so segment.startColumn
+// must be added — see pattern.ts's toSourceColumn.
+function toSourceColumn(segment, lineNumber, column) {
+    return lineNumber === 1 ? segment.startColumn + (column - 1) : column;
+}
+/**
+ * Formats the fallback message's second `%s` slot: `''` for zero
+ * suggestions, or `' — did you mean: a, b, c?'` for one to three.
+ * Exported for direct unit testing.
+ */
+export function formatSuggestionSuffix(suggestions) {
+    if (suggestions.length === 0)
+        return '';
+    return ` — did you mean: ${suggestions.join(', ')}?`;
+}
+// Fallback when a programmatically-built rule has no `message` (validate()
+// requires one). %s slots: the unrecognized word, then
+// formatSuggestionSuffix's output.
+const FALLBACK_MESSAGE = 'Unknown word "%s"%s';
+// The built-in vocabulary's multi-token entries ('Node.js', 'VS Code') are
+// split into their individual word-level parts up front: unlike
+// `capitalization`'s whole-phrase matching (title-case.ts's
+// buildExceptionPlan/recaseWords), this rule's WORD_RE (below)
+// tokenizes per word, so a phrase entry must contribute EACH of its parts
+// ('Node', 'js', 'VS', 'Code') to the accepted-word set rather than the
+// phrase as a whole -- the correct behavior for a per-word spell check, and
+// a deliberate, documented asymmetry with `capitalization` (see
+// SpellingAssertion's `builtinVocabulary` doc comment in ../../types/index.js).
+const BUILTIN_VOCAB_WORDS = TECHNICAL_PROPER_NOUNS.flatMap((entry) => entry.split(/[\s.]+/).filter((part) => part.length > 0)).map((word) => word.toLowerCase());
+const execute = async (rule, file, ctx) => {
+    const options = (rule.assertions['spelling'] ?? {});
+    let speller;
+    try {
+        speller = await loadSpeller(options);
+    }
+    catch (error) {
+        // The optional peer (or a custom dictionary file) failed to load.
+        // validate()'s peer-availability + dictionary-file-existence checks
+        // (see checkSpellingPeerDependencies in ../../config/validate.ts)
+        // normally catch this ahead of time with an actionable error — but a
+        // caller that reaches execute() directly (bypassing validate()), or a
+        // TOCTOU where the dictionary file disappears/breaks between validate()
+        // and this run, must NOT fail closed with zero problems here: that used
+        // to silently disable spelling for the rest of the process (the
+        // rejected promise stayed cached — see spellerCache/loadSpeller above —
+        // and every later call replayed it). Rethrow instead, so runner.ts's own
+        // internalError catch (core/runner.ts) surfaces exactly ONE visible
+        // problem for this file/rule rather than a silent [].
+        const detail = error instanceof Error ? error.message : String(error);
+        throw new Error(`spelling: failed to load dictionary — ${detail}`);
+    }
+    const vocab = new Set((options.vocab ?? []).map((word) => word.toLowerCase()));
+    // Unioned in unless explicitly opted out -- same `builtinVocabulary` flag
+    // and union-not-replace reasoning as `capitalization` (see
+    // rules/scope/capitalization.ts's `collectSites`), so a config's own
+    // `vocab` composes with the built-ins rather than overriding them.
+    if (options.builtinVocabulary !== false) {
+        for (const word of BUILTIN_VOCAB_WORDS)
+            vocab.add(word);
+    }
+    const ignorePatterns = [];
+    for (const pattern of options.ignore ?? []) {
+        try {
+            ignorePatterns.push(new RegExp(pattern));
+        }
+        catch {
+            // ignore invalid regex
+        }
+    }
+    const problems = [];
+    for (const segment of ctx.segments) {
+        const masked = maskInlineCode(segment.content);
+        // newLineRe, not '\n': a bare split leaves a trailing '\r' on CRLF content.
+        const contentLines = segment.content.split(newLineRe);
+        for (const match of masked.matchAll(WORD_RE)) {
+            const word = match[0];
+            const offset = match.index ?? 0;
+            if (vocab.has(word.toLowerCase()))
+                continue;
+            if (ignorePatterns.some((re) => re.test(word)))
+                continue;
+            if (isAllCapsWord(word))
+                continue;
+            if (isDigitAdjacent(masked, offset, offset + word.length))
+                continue;
+            if (speller.correct(word))
+                continue;
+            const { line: lineNumber, column } = offsetToLineColumn(segment.content, offset);
+            const suggestions = speller.suggest(word).slice(0, 3);
+            problems.push({
+                file,
+                line: segment.startLine + lineNumber - 1,
+                column: toSourceColumn(segment, lineNumber, column),
+                text: contentLines[lineNumber - 1] ?? '',
+                match: word,
+                ruleName: rule.name,
+                severity: rule.severity,
+                message: formatTemplate(rule.message ?? FALLBACK_MESSAGE, word, formatSuggestionSuffix(suggestions)),
+            });
+        }
+    }
+    return problems;
+};
+export const spelling = { id: 'spelling', fixable: false, execute };
+//# sourceMappingURL=spelling.js.map

package/dist/rules/scope/spelling.js.map

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

package/dist/rules/scope/swap.d.ts

@@ -0,0 +1,3 @@
+import type { ScopeRule } from '../types.js';
+export declare const swap: ScopeRule;
+//# sourceMappingURL=swap.d.ts.map

package/dist/rules/scope/swap.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"swap.d.ts","sourceRoot":"","sources":["../../../src/rules/scope/swap.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,SAAS,EAAoB,MAAM,aAAa,CAAC;AAgL/D,eAAO,MAAM,IAAI,EAAE,SAAuD,CAAC"}

package/dist/rules/scope/swap.js

@@ -0,0 +1,149 @@
+import { offsetToLineColumn } from '../../core/line-endings.js';
+import { overlapsAnyRange } from '../../core/inline-code.js';
+import { nonProseRanges } from '../utils.js';
+import { applyMatchCase } from '../../core/case-preserve.js';
+// De-overlap matches from DIFFERENT pairs by source span: when two matches
+// overlap, keep the LONGER one (ties: the earlier-starting one; identical
+// spans: first pair in config order, via the sort's stability). Without
+// this, a compound pair like 'he/she' overlapping standalone keys ('he',
+// 'she') emitted all three matches and --fix corrupted 'he/she' to
+// 'they/they'. Zero-width matches have an empty span, so they never
+// overlap anything and pass through unchanged.
+function dropOverlappedShorterMatches(raw) {
+    const byPriority = [...raw].sort((a, b) => b.match.length - a.match.length || a.index - b.index);
+    const kept = [];
+    for (const candidate of byPriority) {
+        const overlapsKept = kept.some((winner) => candidate.index < winner.index + winner.match.length &&
+            winner.index < candidate.index + candidate.match.length);
+        if (!overlapsKept)
+            kept.push(candidate);
+    }
+    return kept.sort((a, b) => a.index - b.index);
+}
+// Prose rules must not lint code: a swap like master -> primary would fire
+// inside `git checkout master`, the usage Google's guide explicitly
+// sanctions in code font. The same goes for a markdoc tag's span, which is
+// markup, not prose.
+//
+// `content` is the original segment content -- the regex always runs against it
+// directly, never against a masked stand-in, because an arbitrary user regex
+// such as a negated-class `keysAreRegex` key like `[^\s,]+` can match straight
+// through a masked run. A match whose span overlaps an `excluded` entry (inline
+// code spans and masked markdoc tag spans -- see `nonProseRanges`) is skipped
+// below rather than recorded.
+function findMatches(content, excluded, options) {
+    const raw = [];
+    const pairs = options.pairs || {};
+    for (const [from, to] of Object.entries(pairs)) {
+        // An empty pair key (only reachable when a caller bypasses validate())
+        // would escape to a zero-width pattern matching nearly every position,
+        // flooding every segment with problems. Skip it, same as
+        // consistency.ts's empty-variant skip.
+        if (String(from).length === 0)
+            continue;
+        const escaped = options.keysAreRegex
+            ? from
+            : String(from).replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+        const pattern = options.wordBoundary ? `\\b${escaped}\\b` : escaped;
+        const flags = options.ignoreCase ? 'gi' : 'g';
+        let regex;
+        try {
+            regex = new RegExp(pattern, flags);
+        }
+        catch {
+            // ignore an invalid regex key (reachable via keysAreRegex) -- this
+            // pair only, so the rule's other pairs still run.
+            continue;
+        }
+        let match;
+        while ((match = regex.exec(content)) !== null) {
+            // A zero-width match (e.g. a `keysAreRegex` pattern like `a*`) never
+            // advances lastIndex on its own -- bump it or the loop hangs. It's
+            // also semantically meaningless for swap (there's no text to find or
+            // replace), so skip recording it too -- otherwise --fix would turn
+            // every such position into a zero-length insert, rewriting the file
+            // at every character offset the pattern passes through.
+            if (match[0].length === 0) {
+                regex.lastIndex++;
+                continue;
+            }
+            const matchEnd = match.index + match[0].length;
+            if (overlapsAnyRange(match.index, matchEnd, excluded)) {
+                continue;
+            }
+            raw.push({
+                index: match.index,
+                match: content.slice(match.index, match.index + match[0].length),
+                replacement: String(to),
+            });
+        }
+    }
+    return dropOverlappedShorterMatches(raw).map(({ index, match, replacement }) => {
+        // offsetToLineColumn (never a bare '\n' split): on a CR-only file a
+        // '\n'-based mapping kept every match on line 1 with a column
+        // counted from the start of the content, so --fix edited the wrong
+        // position entirely.
+        const { line, column } = offsetToLineColumn(content, index);
+        return { line, column, match, replacement };
+    });
+}
+// A match's `column` from findMatches() is relative to its own line within
+// segment.content. On the segment's first line, segment.content starts
+// mid-source-line (e.g. a heading segment's content excludes the '## '
+// marker), so segment.startColumn must be added to get the true source
+// column. Matches on later lines start at source column 1, so they're
+// unaffected.
+function toSourceColumn(segment, localLine, localColumn) {
+    return localLine === 1 ? segment.startColumn + (localColumn - 1) : localColumn;
+}
+const execute = async (rule, file, ctx) => {
+    const options = rule.assertions['swap'];
+    const problems = [];
+    for (const segment of ctx.segments) {
+        const excluded = nonProseRanges(segment, options.includeCode);
+        for (const found of findMatches(segment.content, excluded, options)) {
+            problems.push({
+                file,
+                line: segment.startLine + found.line - 1,
+                column: toSourceColumn(segment, found.line, found.column),
+                // Legacy convention (text === match), kept as-is to avoid changing
+                // swap's reported output.
+                text: found.match,
+                match: found.match,
+                ruleName: rule.name,
+                severity: rule.severity,
+                message: (rule.message ?? '').replace('%s', found.replacement).replace('%s', found.match),
+            });
+        }
+    }
+    return problems;
+};
+const fix = async (rule, file, ctx) => {
+    const options = rule.assertions['swap'];
+    const fixes = [];
+    for (const segment of ctx.segments) {
+        const excluded = nonProseRanges(segment, options.includeCode);
+        for (const found of findMatches(segment.content, excluded, options)) {
+            fixes.push({
+                file,
+                ruleName: rule.name,
+                lineNumber: segment.startLine + found.line - 1,
+                editColumn: toSourceColumn(segment, found.line, found.column),
+                deleteCount: found.match.length,
+                // Apply the MATCHED text's observed casing to the replacement,
+                // not the configured replacement literally: with `ignoreCase:
+                // true`, a sentence-initial "Behaviour" would otherwise be
+                // replaced by literal "behavior", silently lowercasing the start
+                // of the sentence. Works the same for a `keysAreRegex` key --
+                // applyMatchCase reads the MATCHED string, not the key -- though a
+                // regex key whose match has internal mixed case (e.g. "bEhAvIoUr")
+                // falls into the "no confident inference" branch and inserts the
+                // replacement exactly as configured, no guessing.
+                insertText: applyMatchCase(found.match, found.replacement),
+            });
+        }
+    }
+    return fixes;
+};
+export const swap = { id: 'swap', fixable: true, execute, fix };
+//# sourceMappingURL=swap.js.map

package/dist/rules/scope/swap.js.map

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

package/dist/rules/scope/title-case.d.ts

@@ -0,0 +1,42 @@
+/**
+ * True for a word that's already an ALL-CAPS acronym (2+ letters, e.g.
+ * 'API', 'HTML5') -- both styles leave these exactly as written rather
+ * than lowercasing or capitalizing them. Non-letter characters (digits)
+ * don't count toward the length or case check.
+ */
+export declare function isAllCapsWord(word: string): boolean;
+export interface ExceptionPlan {
+    wordMap: Map<string, string>;
+    phrases: string[];
+}
+export declare function buildExceptionPlan(exceptions: string[]): ExceptionPlan;
+/**
+ * Rebuilds `text` with every word re-cased by `caseWord`, which receives the
+ * word plus its `index` in the token sequence and that sequence's `total`
+ * length -- so `index === 0` is the real first word and `index === total - 1`
+ * the real last one. Separators between tokens are copied through verbatim.
+ *
+ * A phrase-exception token is emitted as-written and never passed to
+ * `caseWord`, but it DOES occupy an index. That is the whole point: a leading
+ * or trailing phrase no longer hands its first/last position to a neighbour
+ * (#25610).
+ *
+ * Shared by this module's apTitleCase/chicagoTitleCase and by
+ * capitalization.ts's sentenceCase, so all three `$`-styles agree on
+ * tokenization and phrase protection, not merely on the exception plan.
+ * Length-preserving whenever `caseWord` is.
+ */
+export declare function recaseWords(text: string, phrases: string[], caseWord: (word: string, index: number, total: number) => string): string;
+/**
+ * AP style: lowercases articles, coordinating conjunctions, and
+ * prepositions of 3 letters or fewer -- everything else is capitalized,
+ * except `exceptions` (kept as-written) and ALL-CAPS words (left alone).
+ * The first and last word are always capitalized.
+ */
+export declare function apTitleCase(text: string, exceptions?: string[]): string;
+/**
+ * Chicago style: like AP, but lowercases EVERY preposition regardless of
+ * length (not just the 3-letters-or-fewer ones AP lowercases).
+ */
+export declare function chicagoTitleCase(text: string, exceptions?: string[]): string;
+//# sourceMappingURL=title-case.d.ts.map

package/dist/rules/scope/title-case.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"title-case.d.ts","sourceRoot":"","sources":["../../../src/rules/scope/title-case.ts"],"names":[],"mappings":"AA+EA;;;;;GAKG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAGnD;AAuBD,MAAM,WAAW,aAAa;IAG5B,OAAO,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAI7B,OAAO,EAAE,MAAM,EAAE,CAAC;CACnB;AAED,wBAAgB,kBAAkB,CAAC,UAAU,EAAE,MAAM,EAAE,GAAG,aAAa,CAStE;AAoHD;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,WAAW,CACzB,IAAI,EAAE,MAAM,EACZ,OAAO,EAAE,MAAM,EAAE,EACjB,QAAQ,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,KAAK,MAAM,GAC/D,MAAM,CAYR;AAqED;;;;;GAKG;AACH,wBAAgB,WAAW,CAAC,IAAI,EAAE,MAAM,EAAE,UAAU,GAAE,MAAM,EAAO,GAAG,MAAM,CAE3E;AAED;;;GAGG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,MAAM,EAAE,UAAU,GAAE,MAAM,EAAO,GAAG,MAAM,CAEhF"}