@cspell/eslint-plugin 9.4.0 → 9.6.0

package/README.md

@@ -96,7 +96,16 @@ interface Options {
    * Generate suggestions
    * @default true
    */
-  generateSuggestions: boolean;
+  generateSuggestions?: boolean;
+  /**
+   * Control the reporting level for unknown words.
+   * - `'all'` — report all unknown words.
+   * - `'simple'` — report unknown words except for more complex or compound cases.
+   * - `'typos'` — focus on words that are likely simple typographical errors.
+   * - `'flagged'` — only report words that match flagged terms.
+   * @default 'all'
+   */
+  report?: 'all' | 'simple' | 'typos' | 'flagged';
   /**
    * Ignore import, require names, and export from names
    * @default true

package/dist/common/logger.cjs

@@ -49,7 +49,7 @@ function prefixLines(text, prefix, startIndex = 1) {
     return text
         .split('\n')
         .map((line, index) => (index >= startIndex ? prefix + line : line))
-        .map((line) => (line.trim() == '' ? '' : line))
+        .map((line) => (line.trim() === '' ? '' : line))
         .join('\n');
 }
 //# sourceMappingURL=logger.cjs.map

package/dist/common/options.d.cts

@@ -7,9 +7,8 @@ export interface Options extends Check {
     numSuggestions: number;
     /**
      * Generate suggestions
-     * @default true
      */
-    generateSuggestions: boolean;
+    generateSuggestions?: boolean;
     /**
      * Automatically fix common mistakes.
      * This is only possible if a single preferred suggestion is available.
@@ -21,6 +20,17 @@ export interface Options extends Check {
      * default false
      */
     debugMode?: boolean;
+    /**
+     * Reporting level for unknown words
+     *
+     * - 'all' - Report all unknown words (default)
+     * - 'simple' - Report unknown words with simple suggestions and flagged words
+     * - 'typos' - Report only common typos and flagged words
+     * - 'flagged' - Report only flagged words
+     *
+     *  default is 'all' unless overridden by CSpell settings
+     */
+    report?: 'all' | 'simple' | 'typos' | 'flagged' | undefined;
 }
 interface DictOptions {
     /**
@@ -38,7 +48,7 @@ type DictionaryDefinition = (DictBase & Pick<DictionaryDefinitionPreferred, 'pat
 export type CSpellOptions = Pick<CSpellSettings, 'allowCompoundWords' | 'caseSensitive' | 'dictionaries' | 'enabled' | 'flagWords' | 'ignoreWords' | 'ignoreRegExpList' | 'includeRegExpList' | 'import' | 'language' | 'words'> & {
     dictionaryDefinitions?: DictionaryDefinition[];
 };
-export type RequiredOptions = Required<Pick<Options, Exclude<keyof Options, 'debugMode'>>> & Pick<Options, 'debugMode'>;
+export type RequiredOptions = Options & Required<Pick<Options, Exclude<keyof Options, 'debugMode' | 'report' | 'generateSuggestions'>>>;
 export interface Check {
     /**
      * Ignore import and require names
@@ -148,7 +158,7 @@ export interface CustomWordListFile {
 export type WorkerOptions = RequiredOptions & {
     cwd: string;
 };
-export declare const defaultOptions: Options;
+export declare const defaultOptions: Options & Required<Pick<Options, 'generateSuggestions' | 'numSuggestions' | 'autoFix'>>;
 /**
  * The scope selector is a string that defines the context in which a rule applies.
  * Examples:

package/dist/generated/schema.cjs

@@ -127,8 +127,8 @@ exports.optionsSchema = {
                                         "type": "string"
                                     },
                                     "path": {
-                                        "description": "Path to the file.",
-                                        "markdownDescription": "Path to the file.",
+                                        "description": "Path or url to the dictionary file.",
+                                        "markdownDescription": "Path or url to the dictionary file.",
                                         "type": "string"
                                     },
                                     "supportNonStrictSearches": {
@@ -409,7 +409,6 @@ exports.optionsSchema = {
             "type": "boolean"
         },
         "generateSuggestions": {
-            "default": true,
             "description": "Generate suggestions",
             "markdownDescription": "Generate suggestions",
             "type": "boolean"
@@ -431,11 +430,21 @@ exports.optionsSchema = {
             "description": "Number of spelling suggestions to make.",
             "markdownDescription": "Number of spelling suggestions to make.",
             "type": "number"
+        },
+        "report": {
+            "description": "Reporting level for unknown words\n\n- 'all' - Report all unknown words (default)\n- 'simple' - Report unknown words with simple suggestions and flagged words\n- 'typos' - Report only common typos and flagged words\n- 'flagged' - Report only flagged words\n\n default is 'all' unless overridden by CSpell settings",
+            "enum": [
+                "all",
+                "simple",
+                "typos",
+                "flagged"
+            ],
+            "markdownDescription": "Reporting level for unknown words\n\n- 'all' - Report all unknown words (default)\n- 'simple' - Report unknown words with simple suggestions and flagged words\n- 'typos' - Report only common typos and flagged words\n- 'flagged' - Report only flagged words\n\n default is 'all' unless overridden by CSpell settings",
+            "type": "string"
         }
     },
     "required": [
         "numSuggestions",
-        "generateSuggestions",
         "autoFix"
     ],
     "type": "object"

package/dist/plugin/cspell-eslint-plugin.cjs

@@ -7,8 +7,11 @@ const schema_cjs_1 = require("../generated/schema.cjs");
 const index_cjs_1 = require("../spellCheckAST/index.cjs");
 const defaultCheckOptions_cjs_1 = require("./defaultCheckOptions.cjs");
 const messages = {
-    wordUnknown: 'Unknown word: "{{word}}"',
     wordForbidden: 'Forbidden word: "{{word}}"',
+    wordForbiddenWithSuggestions: 'Forbidden word: "{{word}}" ({{suggestions}})',
+    wordMisspelled: 'Misspelled word: "{{word}}" ({{suggestions}})',
+    wordUnknown: 'Unknown word: "{{word}}"',
+    wordUnknownWithSuggestions: 'Unknown word: "{{word}}" ({{suggestions}})',
     suggestWord: '{{word}}{{preferred}}',
 };
 const ruleMeta = {
@@ -36,10 +39,24 @@ function create(context) {
     logger.enabled = options.debugMode ?? (logger.enabled || isDebugMode);
     logContext(log, context);
     function reportIssue(issue) {
-        const messageId = issue.severity === 'Forbidden' ? 'wordForbidden' : 'wordUnknown';
+        const allowNonPreferred = options.report === 'simple' && issue.hasSimpleSuggestions;
+        const sugs = issue.suggestions
+            ?.filter((sug) => sug.isPreferred || allowNonPreferred)
+            .map((sug) => sug.wordAdjustedToMatchCase || sug.word);
+        let messageId = 'wordUnknown';
+        messageId = issue.hasSimpleSuggestions && sugs?.length ? 'wordUnknownWithSuggestions' : messageId;
+        messageId = issue.severity === 'Misspelled' ? 'wordMisspelled' : messageId;
+        messageId =
+            issue.severity === 'Forbidden'
+                ? issue.hasPreferredFixes
+                    ? 'wordForbiddenWithSuggestions'
+                    : 'wordForbidden'
+                : messageId;
+        const corrections = sugs?.join(', ') || 'no suggestions';
         const { word, start, end } = issue;
         const data = {
             word,
+            suggestions: corrections,
         };
         const code = contextSourceCode(context);
         const startPos = code.getLocFromIndex(start);

package/dist/plugin/defaultCheckOptions.cjs

@@ -23,7 +23,6 @@ exports.defaultCheckOptions = {
 exports.defaultOptions = {
     ...exports.defaultCheckOptions,
     numSuggestions: 8,
-    generateSuggestions: true,
     autoFix: false,
 };
 function normalizeOptions(opts, cwd) {

package/dist/spellCheckAST/scope.cjs

@@ -58,7 +58,7 @@ class AstScopeMatcher {
                 return 0;
             if (curr.childKey && !item.childKey && matchKey)
                 return 0;
-            if (curr.childKey && (curr.childKey == item.childKey || !matchKey)) {
+            if (curr.childKey && (curr.childKey === item.childKey || !matchKey)) {
                 score += scale;
             }
             score += scale * 2;

package/dist/spellCheckAST/spellCheck.d.mts

@@ -1,3 +1,4 @@
+import type { UnknownWordsChoices } from 'cspell-lib';
 import type { Options } from '../common/options.cjs';
 export type SpellCheckOptions = Options & {
     cwd: string;
@@ -25,9 +26,13 @@ export interface SpellCheckIssue {
     /** the word that was flagged */
     word: string;
     /** the severity of the issue. */
-    severity: 'Forbidden' | 'Unknown' | 'Hint';
+    severity: 'Forbidden' | 'Misspelled' | 'Unknown' | 'Hint';
     /** suggestions to be presented. */
     suggestions: Suggestions;
+    /** Indicates that there preferred suggestions. */
+    hasPreferredFixes: boolean;
+    /** Indicates that there are simple suggestions available. */
+    hasSimpleSuggestions: boolean;
     /** The range of text in which this issue occurred. */
     range: CheckTextRange;
     /** The index of the range in which this issues occurred. */
@@ -41,5 +46,10 @@ export type CheckTextRange = readonly [number, number];
 export type SpellCheckFn = typeof spellCheck;
 export type SpellCheckSyncFn = (...p: Parameters<SpellCheckFn>) => Awaited<ReturnType<SpellCheckFn>>;
 export declare function spellCheck(filename: string, text: string, ranges: CheckTextRange[], options: SpellCheckOptions): Promise<SpellCheckResults>;
+export type ReportTypes = Exclude<Options['report'], undefined>;
+type MapReportToUnknownWordChoices = {
+    [key in ReportTypes]: UnknownWordsChoices;
+};
+export declare const mapReportToUnknownWordChoices: MapReportToUnknownWordChoices;
 export {};
 //# sourceMappingURL=spellCheck.d.mts.map

package/dist/spellCheckAST/spellCheck.mjs

@@ -4,6 +4,9 @@ import * as path from 'node:path';
 import { toFileDirURL, toFileURL } from '@cspell/url';
 import { createTextDocument, DocumentValidator, extractImportErrors, getDictionary, refreshDictionaryCache, } from 'cspell-lib';
 import { getDefaultLogger } from '../common/logger.cjs';
+import { defaultOptions } from '../common/options.cjs';
+const ALLOWED_ISSUES_FOR_FLAGGED = new Set(['Forbidden']);
+const ALLOWED_ISSUES_FOR_TYPOS = new Set([...ALLOWED_ISSUES_FOR_FLAGGED, 'Misspelled']);
 const defaultSettings = {
     name: 'eslint-configuration-file',
     patterns: [
@@ -23,6 +26,7 @@ export async function spellCheck(filename, text, ranges, options) {
     const debugMode = forceLogging || options.debugMode || false;
     logger.enabled = forceLogging || (options.debugMode ?? (logger.enabled || isDebugModeExtended));
     const log = logger.log;
+    const filterIssues = generateReportingPredicate(options.report);
     log('options: %o', options);
     const validator = getDocValidator(filename, text, options);
     await validator.prepare();
@@ -33,7 +37,8 @@ export async function spellCheck(filename, text, ranges, options) {
         .map((range, idx) => {
         const issues = validator
             .checkText(range, undefined, undefined)
-            .map((issue) => normalizeIssue(issue, range, idx));
+            .map((issue) => normalizeIssue(issue, range, idx))
+            .filter(filterIssues);
         return issues.length ? issues : undefined;
     })
         .filter((issues) => !!issues)
@@ -46,14 +51,32 @@ export async function spellCheck(filename, text, ranges, options) {
         return found;
     }
     function normalizeIssue(issue, range, rangeIdx) {
-        const word = issue.text;
-        const start = issue.offset;
+        const { text: word, offset: start, suggestionsEx: suggestions } = issue;
         const end = issue.offset + (issue.length || issue.text.length);
-        const suggestions = issue.suggestionsEx;
-        const severity = issue.isFlagged ? 'Forbidden' : 'Unknown';
-        return { word, start, end, suggestions, severity, range, rangeIdx };
+        let severity = 'Unknown';
+        severity = issue.hasPreferredSuggestions ? 'Misspelled' : severity;
+        severity = issue.isFlagged ? 'Forbidden' : severity;
+        const hasPreferredFixes = issue.hasPreferredSuggestions || false;
+        const hasSimpleSuggestions = issue.hasSimpleSuggestions || false;
+        return { word, start, end, suggestions, severity, range, rangeIdx, hasPreferredFixes, hasSimpleSuggestions };
     }
 }
+function generateReportingPredicate(report) {
+    switch (report) {
+        case 'simple': {
+            return (issue) => ALLOWED_ISSUES_FOR_TYPOS.has(issue.severity) ||
+                (issue.severity === 'Unknown' && issue.hasSimpleSuggestions);
+        }
+        case 'flagged': {
+            return (issue) => ALLOWED_ISSUES_FOR_FLAGGED.has(issue.severity);
+        }
+        case 'typos': {
+            return (issue) => ALLOWED_ISSUES_FOR_TYPOS.has(issue.severity);
+        }
+    }
+    // report === 'all' or undefined
+    return () => true;
+}
 const cache = { lastDoc: undefined };
 const docValCache = new WeakMap();
 function getDocValidator(filename, text, options) {
@@ -66,10 +89,24 @@ function getDocValidator(filename, text, options) {
         return cachedValidator;
     }
     const resolveImportsRelativeTo = toFileURL(options.cspellOptionsRoot || import.meta.url, toFileDirURL(options.cwd));
-    const validator = new DocumentValidator(doc, { ...options, resolveImportsRelativeTo }, settings);
+    const report = options.report || 'all';
+    const generateSuggestions = report && report !== 'all'
+        ? (options.generateSuggestions ?? false)
+        : (options.generateSuggestions ?? defaultOptions.generateSuggestions);
+    const validator = new DocumentValidator(doc, { ...options, resolveImportsRelativeTo, generateSuggestions }, settings);
     docValCache.set(doc, validator);
     return validator;
 }
+export const mapReportToUnknownWordChoices = {
+    all: 'report-all',
+    simple: 'report-simple',
+    typos: 'report-common-typos',
+    flagged: 'report-flagged',
+};
+function mapReportToUnknownWords(report) {
+    const unknownWords = report ? mapReportToUnknownWordChoices[report] : undefined;
+    return unknownWords ? { unknownWords } : {};
+}
 function calcInitialSettings(options) {
     const { customWordListFile, cspell, cwd } = options;
     const settings = {
@@ -78,6 +115,7 @@ function calcInitialSettings(options) {
         words: cspell?.words || [],
         ignoreWords: cspell?.ignoreWords || [],
         flagWords: cspell?.flagWords || [],
+        ...mapReportToUnknownWords(options.report),
     };
     if (options.configFile) {
         const optionCspellImport = options.cspell?.import;

package/dist/spellCheckAST/spellCheckAST.cjs

@@ -175,11 +175,25 @@ function spellCheckAST(filename, text, root, options) {
         return node.parent?.type === 'MemberExpression';
     }
     function reportIssue(issue) {
-        const { word, start, end, severity } = issue;
+        const { word, start, end, severity, hasPreferredFixes, hasSimpleSuggestions } = issue;
         const node = toBeChecked[issue.rangeIdx].node;
         const nodeType = node.type;
         const suggestions = normalizeSuggestions(issue.suggestions, nodeType);
-        return { word, start, end, nodeType, node, suggestions, severity };
+        const preferredFixes = suggestions
+            ?.filter((sug) => sug.isPreferred)
+            .map((sug) => sug.wordAdjustedToMatchCase || sug.word);
+        return {
+            word,
+            start,
+            end,
+            nodeType,
+            node,
+            suggestions,
+            hasPreferredFixes,
+            hasSimpleSuggestions,
+            preferredFixes,
+            severity,
+        };
     }
     const processors = {
         Line: checkComment,

package/dist/spellCheckAST/types.d.ts

@@ -18,8 +18,13 @@ export interface Issue {
     start: number;
     end: number;
     word: string;
-    severity: 'Forbidden' | 'Unknown' | 'Hint';
+    severity: 'Forbidden' | 'Misspelled' | 'Unknown' | 'Hint';
+    /** Possible suggestions. */
     suggestions: Suggestions;
+    /** Indicates that there preferred suggestions. */
+    hasPreferredFixes: boolean;
+    hasSimpleSuggestions: boolean;
+    preferredFixes: string[] | undefined;
     nodeType: NodeType;
     node: ASTNode | undefined;
 }

package/package.json

@@ -4,7 +4,7 @@
     "access": "public",
     "provenance": true
   },
-  "version": "9.4.0",
+  "version": "9.6.0",
   "description": "CSpell ESLint plugin",
   "keywords": [
     "cspell",
@@ -79,35 +79,35 @@
   },
   "devDependencies": {
     "@eslint/eslintrc": "^3.3.3",
-    "@eslint/js": "^9.39.1",
+    "@eslint/js": "^9.39.2",
     "@internal/cspell-eslint-plugin-scripts": "",
     "@types/estree": "^1.0.8",
     "@types/mocha": "^10.0.10",
-    "@typescript-eslint/parser": "^8.48.0",
-    "@typescript-eslint/types": "^8.48.0",
-    "eslint": "^9.39.1",
+    "@typescript-eslint/parser": "^8.52.0",
+    "@typescript-eslint/types": "^8.52.0",
+    "eslint": "^9.39.2",
     "eslint-plugin-jsonc": "^2.21.0",
     "eslint-plugin-mdx": "^3.6.2",
     "eslint-plugin-n": "^17.23.1",
     "eslint-plugin-react": "^7.37.5",
     "eslint-plugin-simple-import-sort": "^12.1.1",
-    "eslint-plugin-yml": "^1.19.0",
-    "globals": "^16.5.0",
-    "jsonc-eslint-parser": "^2.4.1",
+    "eslint-plugin-yml": "^1.19.1",
+    "globals": "^17.0.0",
+    "jsonc-eslint-parser": "^2.4.2",
     "mocha": "^11.7.5",
     "ts-json-schema-generator": "^2.4.0",
     "typescript": "~5.9.3",
-    "typescript-eslint": "^8.48.0",
-    "yaml-eslint-parser": "^1.3.1"
+    "typescript-eslint": "^8.52.0",
+    "yaml-eslint-parser": "^1.3.2"
   },
   "dependencies": {
-    "@cspell/cspell-types": "9.4.0",
-    "@cspell/url": "9.4.0",
-    "cspell-lib": "9.4.0",
+    "@cspell/cspell-types": "9.6.0",
+    "@cspell/url": "9.6.0",
+    "cspell-lib": "9.6.0",
     "synckit": "^0.11.11"
   },
   "peerDependencies": {
     "eslint": "^7 || ^8 || ^9"
   },
-  "gitHead": "12dba3d8b880384d1401c765cb2186647f5a266f"
+  "gitHead": "163793ddf2a0ad90bc7c90351698a106003297af"
 }