@cspell/eslint-plugin 6.19.2 → 6.20.0

package/dist/ASTNode.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/_auto_generated_/options.schema.json

@@ -0,0 +1,84 @@
+{
+    "$schema": "http://json-schema.org/draft-07/schema#",
+    "additionalProperties": false,
+    "definitions": {},
+    "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": {
+                        "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"
+        }
+    },
+    "required": [
+        "numSuggestions",
+        "generateSuggestions"
+    ],
+    "type": "object"
+}

package/dist/cspell-eslint-plugin.js

@@ -0,0 +1,121 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.configs = exports.rules = void 0;
+const synckit_1 = require("synckit");
+const options_schema_json_1 = __importDefault(require("./_auto_generated_/options.schema.json"));
+const options_1 = require("./options");
+const walkTree_1 = require("./walkTree");
+const schema = options_schema_json_1.default;
+const spellCheck = (0, synckit_1.createSyncFn)(require.resolve('./worker'), undefined, 30000);
+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],
+};
+let isDebugMode = false;
+function log(...args) {
+    if (!isDebugMode)
+        return;
+    console.log(...args);
+}
+const debugTree = false;
+function dumpTree(context) {
+    if (!debugTree)
+        return;
+    (0, walkTree_1.walkTree)(context.getSourceCode().ast, function (node, _parent, key) {
+        const withValue = node;
+        console.log('key: %o, node: %o', key, { type: node.type, value: withValue.value });
+    });
+}
+function create(context) {
+    const options = (0, options_1.normalizeOptions)(context.options[0], context.getCwd());
+    isDebugMode = options.debugMode || false;
+    isDebugMode && logContext(context);
+    dumpTree(context);
+    function reportIssue(issue) {
+        var _a;
+        const messageId = issue.severity === 'Forbidden' ? 'wordForbidden' : 'wordUnknown';
+        const { word, start, end } = issue;
+        const data = {
+            word,
+        };
+        const code = context.getSourceCode();
+        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),
+            };
+        }
+        log('Suggestions: %o', issue.suggestions);
+        const suggestions = (_a = issue.suggestions) === null || _a === void 0 ? void 0 : _a.map(createSug);
+        const suggest = suggestions;
+        const des = {
+            messageId,
+            data,
+            loc,
+            suggest,
+        };
+        context.report(des);
+    }
+    function checkProgram() {
+        const sc = context.getSourceCode();
+        const issues = spellCheck(context.getFilename(), sc.text, sc.ast, options);
+        issues.forEach((issue) => reportIssue(issue));
+    }
+    return { Program: checkProgram };
+}
+exports.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}
+`);
+}
+exports.configs = {
+    recommended: {
+        plugins: ['@cspell'],
+        rules: {
+            '@cspell/spellchecker': ['warn', {}],
+        },
+    },
+    debug: {
+        plugins: ['@cspell'],
+        rules: {
+            '@cspell/spellchecker': ['warn', { debugMode: true }],
+        },
+    },
+};

package/dist/customWordList.js

@@ -0,0 +1,63 @@
+"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;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addWordToCustomWordList = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+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);
+}
+exports.addWordToCustomWordList = addWordToCustomWordList;
+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);
+    }
+}