@cspell/eslint-plugin 6.19.2 → 6.20.1

package/dist/{index.mjs → spellCheck.js}

@@ -1,185 +1,37 @@
-/*!
- * @cspell/eslint-plugin v6.19.2
- * Copyright 2023 Jason Dent <jason@streetsidesoftware.nl>
- * Released under the MIT License
- * https://github.com/streetsidesoftware/cspell/tree/main/packages/cspell-eslint-plugin#readme
- */
-
-import assert from 'assert';
-import { refreshDictionaryCache, DocumentValidator, createTextDocument } from 'cspell-lib';
-import * as path from 'path';
-import { format } from 'util';
-import * as fs from 'fs';
-
-var $schema = "http://json-schema.org/draft-07/schema#";
-var additionalProperties = false;
-var definitions = {
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
 };
-var properties = {
-	checkComments: {
-		"default": true,
-		description: "Spell check comments",
-		type: "boolean"
-	},
-	checkIdentifiers: {
-		"default": true,
-		description: "Spell check identifiers (variables names, function names, class names, etc.)",
-		type: "boolean"
-	},
-	checkJSXText: {
-		"default": true,
-		description: "Spell check JSX Text",
-		type: "boolean"
-	},
-	checkStringTemplates: {
-		"default": true,
-		description: "Spell check template strings",
-		type: "boolean"
-	},
-	checkStrings: {
-		"default": true,
-		description: "Spell check strings",
-		type: "boolean"
-	},
-	customWordListFile: {
-		anyOf: [
-			{
-				description: "Specify a path to a custom word list file",
-				type: "string"
-			},
-			{
-				additionalProperties: false,
-				properties: {
-					addWords: {
-						description: "**Experimental**: Provide a fix option to add words to the file.\n\nNote: this does not yet work perfectly.",
-						type: "boolean"
-					},
-					path: {
-						description: "Path to word list file. File format: 1 word per line",
-						type: "string"
-					}
-				},
-				required: [
-					"path"
-				],
-				type: "object"
-			}
-		],
-		description: "Specify a path to a custom word list file.\n\nexample: ```js customWordListFile: \"./myWords.txt\" ```"
-	},
-	debugMode: {
-		"default": false,
-		description: "Output debug logs",
-		type: "boolean"
-	},
-	generateSuggestions: {
-		"default": true,
-		description: "Generate suggestions",
-		type: "boolean"
-	},
-	ignoreImportProperties: {
-		"default": true,
-		description: "Ignore the properties of imported variables, structures, and types.\n\nExample: ``` import { example } from 'third-party';\n\nconst msg = example.property; // `property` is not spell checked. ```",
-		type: "boolean"
-	},
-	ignoreImports: {
-		"default": true,
-		description: "Ignore import and require names",
-		type: "boolean"
-	},
-	numSuggestions: {
-		"default": 8,
-		description: "Number of spelling suggestions to make.",
-		type: "number"
-	}
-};
-var required = [
-	"numSuggestions",
-	"generateSuggestions"
-];
-var type = "object";
-var optionsSchema = {
-	$schema: $schema,
-	additionalProperties: additionalProperties,
-	definitions: definitions,
-	properties: properties,
-	required: required,
-	type: type
-};
-
-const sortFn = new Intl.Collator().compare;
-function addWordToCustomWordList(customWordListPath, word) {
-    const content = readFile(customWordListPath) || '\n';
-    const lineEndingMatch = content.match(/\r?\n/);
-    const lineEnding = (lineEndingMatch === null || lineEndingMatch === void 0 ? void 0 : lineEndingMatch[0]) || '\n';
-    const words = new Set(content
-        .split(/\n/g)
-        .map((a) => a.trim())
-        .filter((a) => !!a));
-    words.add(word);
-    const lines = [...words];
-    lines.sort(sortFn);
-    writeFile(customWordListPath, lines.join(lineEnding) + lineEnding);
-}
-function readFile(file) {
-    try {
-        return fs.readFileSync(file, 'utf-8');
-    }
-    catch (e) {
-        return undefined;
-    }
-}
-function writeFile(file, content) {
-    makeDir(path.dirname(file));
-    fs.writeFileSync(file, content);
-}
-function makeDir(dir) {
-    try {
-        fs.mkdirSync(dir, { recursive: true });
-    }
-    catch (e) {
-        console.log(e);
-    }
-}
-
-const defaultCheckOptions = {
-    checkComments: true,
-    checkIdentifiers: true,
-    checkJSXText: true,
-    checkStrings: true,
-    checkStringTemplates: true,
-    customWordListFile: undefined,
-    ignoreImportProperties: true,
-    ignoreImports: true,
-};
-const defaultOptions = {
-    ...defaultCheckOptions,
-    numSuggestions: 8,
-    generateSuggestions: true,
-    debugMode: false,
-};
-function normalizeOptions(opts) {
-    const options = Object.assign({}, defaultOptions, opts || {});
-    return options;
-}
-
-const schema = optionsSchema;
-const messages = {
-    wordUnknown: 'Unknown word: "{{word}}"',
-    wordForbidden: 'Forbidden word: "{{word}}"',
-    suggestWord: '{{word}}',
-    addWordToDictionary: 'Add "{{word}}" to {{dictionary}}',
-};
-const meta = {
-    docs: {
-        description: 'CSpell spellchecker',
-        category: 'Possible Errors',
-        recommended: false,
-    },
-    messages,
-    hasSuggestions: true,
-    schema: [schema],
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
 };
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.spellCheck = void 0;
+const assert_1 = __importDefault(require("assert"));
+const cspell_lib_1 = require("cspell-lib");
+const path = __importStar(require("path"));
+const util_1 = require("util");
+const walkTree_1 = require("./walkTree");
 const defaultSettings = {
     patterns: [
     // @todo: be able to use cooked / transformed strings.
@@ -196,15 +48,16 @@ function log(...args) {
         return;
     console.log(...args);
 }
-function create(context) {
-    const options = normalizeOptions(context.options[0]);
+async function spellCheck(filename, text, root, options) {
     const toIgnore = new Set();
     const importedIdentifiers = new Set();
     isDebugMode = options.debugMode || false;
-    isDebugMode && logContext(context);
-    const validator = getDocValidator(context);
-    validator.prepareSync();
+    const validator = getDocValidator(filename, text, options);
+    await validator.prepare();
+    const issues = [];
     function checkLiteral(node) {
+        if (node.type !== 'Literal')
+            return;
         if (!options.checkStrings)
             return;
         if (typeof node.value === 'string') {
@@ -217,6 +70,8 @@ function create(context) {
         }
     }
     function checkJSXText(node) {
+        if (node.type !== 'JSXText')
+            return;
         if (!options.checkJSXText)
             return;
         if (typeof node.value === 'string') {
@@ -225,12 +80,16 @@ function create(context) {
         }
     }
     function checkTemplateElement(node) {
+        if (node.type !== 'TemplateElement')
+            return;
         if (!options.checkStringTemplates)
             return;
         debugNode(node, node.value);
         checkNodeText(node, node.value.cooked || node.value.raw);
     }
     function checkIdentifier(node) {
+        if (node.type !== 'Identifier')
+            return;
         debugNode(node, node.name);
         if (options.ignoreImports) {
             if (isRawImportIdentifier(node)) {
@@ -257,6 +116,8 @@ function create(context) {
         checkNodeText(node, node.name);
     }
     function checkComment(node) {
+        if (node.type !== 'Line' && node.type !== 'Block')
+            return;
         if (!options.checkComments)
             return;
         debugNode(node, node.value);
@@ -267,7 +128,7 @@ function create(context) {
             return;
         const adj = node.type === 'Literal' ? 1 : 0;
         const range = [node.range[0] + adj, node.range[1] - adj];
-        const scope = calcScope();
+        const scope = calcScope(node);
         const result = validator.checkText(range, text, scope);
         result.forEach((issue) => reportIssue(issue));
     }
@@ -320,74 +181,25 @@ function create(context) {
         return ((_a = node.parent) === null || _a === void 0 ? void 0 : _a.type) === 'MemberExpression';
     }
     function reportIssue(issue) {
-        var _a;
-        const messageId = issue.isFlagged ? 'wordForbidden' : 'wordUnknown';
-        const data = {
-            word: issue.text,
-        };
-        const code = context.getSourceCode();
+        const word = issue.text;
         const start = issue.offset;
         const end = issue.offset + (issue.length || issue.text.length);
-        const startPos = code.getLocFromIndex(start);
-        const endPos = code.getLocFromIndex(end);
-        const loc = { start: startPos, end: endPos };
-        function fixFactory(word) {
-            return (fixer) => fixer.replaceTextRange([start, end], word);
-        }
-        function createSug(word) {
-            const data = { word };
-            const messageId = 'suggestWord';
-            return {
-                messageId,
-                data,
-                fix: fixFactory(word),
-            };
-        }
-        function createAddWordToDictionaryFix(word) {
-            if (!isCustomWordListFile(options.customWordListFile) || !options.customWordListFile.addWords) {
-                return undefined;
-            }
-            const dictFile = path.resolve(context.getCwd(), options.customWordListFile.path);
-            const data = { word, dictionary: path.basename(dictFile) };
-            const messageId = 'addWordToDictionary';
-            return {
-                messageId,
-                data,
-                fix: (_fixer) => {
-                    // This wrapper is a hack to delay applying the fix until it is actually used.
-                    // But it is not reliable, since ESLint + extension will randomly read the value.
-                    return new WrapFix({ range: [start, end], text: word }, () => {
-                        refreshDictionaryCache(0);
-                        addWordToCustomWordList(dictFile, word);
-                        validator.updateDocumentText(context.getSourceCode().getText());
-                    });
-                },
-            };
-        }
-        log('Suggestions: %o', issue.suggestions);
-        const suggestions = (_a = issue.suggestions) === null || _a === void 0 ? void 0 : _a.map(createSug);
-        const addWordFix = createAddWordToDictionaryFix(issue.text);
-        const suggest = suggestions || addWordFix ? (suggestions || []).concat(addWordFix ? [addWordFix] : []) : undefined;
-        const des = {
-            messageId,
-            data,
-            loc,
-            suggest,
-        };
-        context.report(des);
+        const suggestions = issue.suggestions;
+        const severity = issue.isFlagged ? 'Forbidden' : 'Unknown';
+        issues.push({ word, start, end, suggestions, severity });
     }
-    context
-        .getSourceCode()
-        .getAllComments()
-        .forEach(function (commentNode) {
-        checkComment(commentNode);
-    });
-    return {
+    const processors = {
+        Line: checkComment,
+        Block: checkComment,
         Literal: checkLiteral,
         TemplateElement: checkTemplateElement,
         Identifier: checkIdentifier,
         JSXText: checkJSXText,
     };
+    function checkNode(node) {
+        var _a;
+        (_a = processors[node.type]) === null || _a === void 0 ? void 0 : _a.call(processors, node);
+    }
     function mapNode(node, index, nodes) {
         const child = nodes[index + 1];
         if (node.type === 'ImportSpecifier') {
@@ -442,9 +254,15 @@ function create(context) {
         return node.type;
     }
     function inheritance(node) {
-        const a = [...context.getAncestors(), node];
+        const a = [...parents(node), node];
         return a.map(mapNode);
     }
+    function* parents(node) {
+        while (node && node.parent) {
+            yield node.parent;
+            node = node.parent;
+        }
+    }
     function inheritanceSummary(node) {
         return inheritance(node).join(' ');
     }
@@ -474,13 +292,16 @@ function create(context) {
     function debugNode(node, value) {
         if (!isDebugMode)
             return;
-        const val = format('%o', value);
+        const val = (0, util_1.format)('%o', value);
         log(`${inheritanceSummary(node)}: ${val}`);
     }
+    (0, walkTree_1.walkTree)(root, checkNode);
+    return issues;
 }
+exports.spellCheck = spellCheck;
 function tagLiteral(node) {
     var _a;
-    assert(node.type === 'Literal');
+    (0, assert_1.default)(node.type === 'Literal');
     const kind = typeof node.value;
     const extra = kind === 'string'
         ? ((_a = node.raw) === null || _a === void 0 ? void 0 : _a[0]) === '"'
@@ -491,59 +312,24 @@ function tagLiteral(node) {
             : kind;
     return node.type + '.' + extra;
 }
-const rules = {
-    spellchecker: {
-        meta,
-        create,
-    },
-};
-function logContext(context) {
-    log('\n\n************************');
-    // log(context.getSourceCode().text);
-    log(`
-
-id: ${context.id}
-cwd: ${context.getCwd()}
-filename: ${context.getFilename()}
-physicalFilename: ${context.getPhysicalFilename()}
-scope: ${context.getScope().type}
-`);
-}
-const configs = {
-    recommended: {
-        plugins: ['@cspell'],
-        rules: {
-            '@cspell/spellchecker': ['warn', {}],
-        },
-    },
-    debug: {
-        plugins: ['@cspell'],
-        rules: {
-            '@cspell/spellchecker': ['warn', { debugMode: true }],
-        },
-    },
-};
 const cache = { lastDoc: undefined };
 const docValCache = new WeakMap();
-function getDocValidator(context) {
-    const text = context.getSourceCode().getText();
-    const doc = getTextDocument(context.getFilename(), text);
+function getDocValidator(filename, text, options) {
+    const doc = getTextDocument(filename, text);
     const cachedValidator = docValCache.get(doc);
     if (cachedValidator) {
-        refreshDictionaryCache(0);
+        (0, cspell_lib_1.refreshDictionaryCache)(0);
         cachedValidator.updateDocumentText(text);
         return cachedValidator;
     }
-    const options = normalizeOptions(context.options[0]);
-    const settings = calcInitialSettings(options, context.getCwd());
+    const settings = calcInitialSettings(options);
     isDebugMode = options.debugMode || false;
-    isDebugMode && logContext(context);
-    const validator = new DocumentValidator(doc, options, settings);
+    const validator = new cspell_lib_1.DocumentValidator(doc, options, settings);
     docValCache.set(doc, validator);
     return validator;
 }
-function calcInitialSettings(options, cwd) {
-    const { customWordListFile } = options;
+function calcInitialSettings(options) {
+    const { customWordListFile, cwd } = options;
     if (!customWordListFile)
         return defaultSettings;
     const filePath = isCustomWordListFile(customWordListFile) ? customWordListFile.path : customWordListFile;
@@ -560,39 +346,10 @@ function getTextDocument(filename, content) {
     if (((_a = cache.lastDoc) === null || _a === void 0 ? void 0 : _a.filename) === filename) {
         return cache.lastDoc.doc;
     }
-    const doc = createTextDocument({ uri: filename, content });
+    const doc = (0, cspell_lib_1.createTextDocument)({ uri: filename, content });
     cache.lastDoc = { filename, doc };
     return doc;
 }
-/**
- * This wrapper is used to add a
- */
-class WrapFix {
-    /**
-     *
-     * @param fix - the example Fix
-     * @param onGetText - called when `fix.text` is accessed
-     * @param limit - limit the number of times onGetText is called. Set it to `-1` for infinite.
-     */
-    constructor(fix, onGetText, limit = 1) {
-        this.fix = fix;
-        this.onGetText = onGetText;
-        this.limit = limit;
-    }
-    get range() {
-        return this.fix.range;
-    }
-    get text() {
-        if (this.limit) {
-            this.limit--;
-            this.onGetText();
-        }
-        return this.fix.text;
-    }
-}
 function isCustomWordListFile(value) {
     return !!value && typeof value === 'object';
 }
-
-export { configs, rules };
-//# sourceMappingURL=index.mjs.map

package/dist/walkTree.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.walkTree = void 0;
+const estree_walker_1 = require("estree-walker");
+function walkTree(node, enter) {
+    const visited = new Set();
+    (0, estree_walker_1.walk)(node, {
+        enter: function (node, parent, key) {
+            if (visited.has(node) || key === 'tokens') {
+                this.skip();
+                return;
+            }
+            visited.add(node);
+            enter(node, parent, key);
+        },
+    });
+}
+exports.walkTree = walkTree;

package/dist/worker.js

@@ -0,0 +1,52 @@
+"use strict";
+/* eslint-disable import/no-unresolved */
+/* eslint-disable node/no-missing-import */
+/* eslint-disable node/no-unsupported-features/es-syntax */
+// @ts-check
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+/**
+ * @typedef {import('estree').Node} Node
+ * @typedef {import('./spellCheck').Issue} Issue
+ * @typedef {import('./options').WorkerOptions} WorkerOptions
+ */
+const { runAsWorker } = require('synckit');
+/**
+ * @type {typeof import('./spellCheck')}
+ */
+let spellChecker;
+runAsWorker(
+/**
+ * @param {string} filename
+ * @param {string} text
+ * @param {Node} root
+ * @param {WorkerOptions} options
+ * @returns {Promise<Issue[]>} The issues found.
+ */
+async (filename, text, root, options) => {
+    if (!spellChecker) {
+        spellChecker = await Promise.resolve().then(() => __importStar(require('./spellCheck')));
+    }
+    return spellChecker.spellCheck(filename, text, root, options);
+});

package/package.json

@@ -3,7 +3,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "6.19.2",
+  "version": "6.20.1",
   "description": "CSpell ESLint plugin",
   "keywords": [
     "cspell",
@@ -33,10 +33,10 @@
     "!**/*.map"
   ],
   "scripts": {
-    "build": "pnpm run build-schema && pnpm run build-rollup",
-    "build-rollup": "rollup --config rollup.config.ts --configPlugin typescript",
-    "build-schema": "ts-json-schema-generator --no-top-ref --expose none --path src/options.ts --type Options  -o  ./src/_auto_generated_/options.schema.json",
-    "watch": "pnpm run build-rollup -- --watch",
+    "build": "pnpm build:schema && pnpm build:src",
+    "build:src": "tsc -p .",
+    "build:schema": "ts-json-schema-generator --no-top-ref --expose none --path src/options.ts --type Options  -o  ./src/_auto_generated_/options.schema.json",
+    "watch": "tsc -p . --watch",
     "clean": "shx rm -rf dist coverage .tsbuildinfo",
     "clean-build": "pnpm run clean && pnpm run build",
     "coverage": "echo coverage",
@@ -54,25 +54,21 @@
     "node": ">=14"
   },
   "devDependencies": {
-    "@rollup/plugin-commonjs": "^24.0.0",
-    "@rollup/plugin-json": "^6.0.0",
-    "@rollup/plugin-node-resolve": "^15.0.1",
-    "@rollup/plugin-typescript": "^11.0.0",
     "@types/eslint": "^8.4.10",
     "@types/estree": "^1.0.0",
     "@types/node": "^18.11.18",
-    "@typescript-eslint/parser": "^5.48.2",
-    "@typescript-eslint/types": "^5.48.2",
-    "@typescript-eslint/typescript-estree": "^5.48.2",
-    "eslint": "^8.32.0",
-    "eslint-plugin-react": "^7.32.1",
+    "@typescript-eslint/parser": "^5.50.0",
+    "@typescript-eslint/types": "^5.50.0",
+    "@typescript-eslint/typescript-estree": "^5.50.0",
+    "eslint": "^8.33.0",
+    "eslint-plugin-react": "^7.32.2",
     "mocha": "^10.2.0",
-    "rollup": "^3.10.0",
-    "rollup-plugin-dts": "^5.1.1",
     "ts-json-schema-generator": "^1.2.0"
   },
   "dependencies": {
-    "cspell-lib": "6.19.2"
+    "cspell-lib": "6.20.1",
+    "estree-walker": "^2.0.2",
+    "synckit": "^0.8.5"
   },
-  "gitHead": "0413716934fdfde59971d24773e7df83623bb529"
+  "gitHead": "508a06d32dd59d881d07cb60fe8c0a7c0bddf8eb"
 }