cspell 5.15.2 → 5.17.0

package/README.md

@@ -11,6 +11,9 @@ A Spell Checker for Code!
 ## Support Future Development
 
 - Become a [<img src="https://github.githubassets.com/images/modules/site/icons/funding_platforms/patreon.svg" width="16" height="16" alt="Patreon">Patreon!](https://patreon.com/streetsidesoftware)
+- [Support through ![PayPal](https://raw.githubusercontent.com/streetsidesoftware/vscode-spell-checker/main/images/PayPal/paypal-logo-wide-18.png)](https://www.paypal.com/donate/?hosted_button_id=26LNBP2Q6MKCY)
+- [Open Collective](https://opencollective.com/cspell)
+- [Street Side Software](https://streetsidesoftware.com/support)
 
 ## Features
 
@@ -110,6 +113,7 @@ Options:
   --no-progress                Turn off progress messages
   --no-summary                 Turn off summary message in console.
   -s, --silent                 Silent mode, suppress error messages.
+  --fail-fast                  Exit after first file with an issue or error.
   -r, --root <root folder>     Root directory, defaults to current directory.
   --relative                   Issues are displayed relative to root.
   --show-context               Show the surrounding text around an issue.
@@ -206,7 +210,7 @@ npm install -SD cspell
 ```
 #!/bin/sh
 
-exec git diff --cached --name-only | npx cspell -- --no-summary --no-progress --no-must-find-files --file-list stdin
+exec git diff --cached --name-only | npx cspell --no-summary --no-progress --no-must-find-files --file-list stdin
 ```
 
 ## Requirements

package/dist/app.d.ts

@@ -1,5 +1,5 @@
-import * as commander from 'commander';
+import type { Command } from 'commander';
 export { LinterCliOptions as Options } from './options';
 export { CheckFailed } from './util/errors';
-export declare function run(program?: commander.Command, argv?: string[]): Promise<void>;
+export declare function run(command?: Command, argv?: string[]): Promise<void>;
 //# sourceMappingURL=app.d.ts.map

package/dist/app.js

@@ -20,30 +20,32 @@ var __importStar = (this && this.__importStar) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.run = exports.CheckFailed = void 0;
-const commander = __importStar(require("commander"));
+const commander_1 = require("commander");
 const path = __importStar(require("path"));
-const semver = __importStar(require("semver"));
+const semver_1 = require("semver");
 const commandCheck_1 = require("./commandCheck");
 const commandLink_1 = require("./commandLink");
 const commandLint_1 = require("./commandLint");
+const commandSuggestion_1 = require("./commandSuggestion");
 const commandTrace_1 = require("./commandTrace");
 const errors_1 = require("./util/errors");
 // eslint-disable-next-line @typescript-eslint/no-var-requires
 const npmPackage = require(path.join(__dirname, '..', 'package.json'));
 var errors_2 = require("./util/errors");
 Object.defineProperty(exports, "CheckFailed", { enumerable: true, get: function () { return errors_2.CheckFailed; } });
-async function run(program, argv) {
-    const prog = program || commander.program;
+async function run(command, argv) {
+    const prog = command || commander_1.program;
     const args = argv || process.argv;
     prog.exitOverride();
     prog.version(npmPackage.version).description('Spelling Checker for Code').name('cspell');
-    if (!semver.satisfies(process.versions.node, npmPackage.engines.node)) {
+    if (!(0, semver_1.satisfies)(process.versions.node, npmPackage.engines.node)) {
         throw new errors_1.ApplicationError(`Unsupported NodeJS version (${process.versions.node}); ${npmPackage.engines.node} is required`);
     }
     (0, commandLint_1.commandLint)(prog);
     (0, commandTrace_1.commandTrace)(prog);
     (0, commandCheck_1.commandCheck)(prog);
     (0, commandLink_1.commandLink)(prog);
+    (0, commandSuggestion_1.commandSuggestion)(prog);
     /*
         program
             .command('init')

package/dist/application.d.ts

@@ -1,13 +1,14 @@
 /// <reference types="node" />
 import type { CSpellReporter, RunResult } from '@cspell/cspell-types';
-import { CheckTextInfo, TraceResult } from 'cspell-lib';
-import { BaseOptions, LinterOptions, TraceOptions } from './options';
+import type { CheckTextInfo, SuggestionsForWordResult, TraceResult } from 'cspell-lib';
+import { BaseOptions, LegacyOptions, LinterOptions, SuggestionOptions, TraceOptions } from './options';
 export { IncludeExcludeFlag } from 'cspell-lib';
 export type { TraceResult } from 'cspell-lib';
 export declare type AppError = NodeJS.ErrnoException;
 export declare function lint(fileGlobs: string[], options: LinterOptions, emitters: CSpellReporter): Promise<RunResult>;
-export declare function trace(words: string[], options: TraceOptions): Promise<TraceResult[]>;
+export declare function trace(words: string[], options: TraceOptions): AsyncIterableIterator<TraceResult[]>;
 export declare type CheckTextResult = CheckTextInfo;
-export declare function checkText(filename: string, options: BaseOptions): Promise<CheckTextResult>;
+export declare function checkText(filename: string, options: BaseOptions & LegacyOptions): Promise<CheckTextResult>;
+export declare function suggestions(words: string[], options: SuggestionOptions): AsyncIterable<SuggestionsForWordResult>;
 export declare function createInit(): Promise<void>;
 //# sourceMappingURL=application.d.ts.map

package/dist/application.js

@@ -19,30 +19,34 @@ var __importStar = (this && this.__importStar) || function (mod) {
     return result;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createInit = exports.checkText = exports.trace = exports.lint = exports.IncludeExcludeFlag = void 0;
-const cspell = __importStar(require("cspell-lib"));
+exports.createInit = exports.suggestions = exports.checkText = exports.trace = exports.lint = exports.IncludeExcludeFlag = void 0;
 const cspell_lib_1 = require("cspell-lib");
 const path = __importStar(require("path"));
-const fileHelper_1 = require("./fileHelper");
 const lint_1 = require("./lint");
+const options_1 = require("./options");
+const async = __importStar(require("./util/async"));
+const fileHelper_1 = require("./util/fileHelper");
+const stdin_1 = require("./util/stdin");
 const util = __importStar(require("./util/util"));
 var cspell_lib_2 = require("cspell-lib");
 Object.defineProperty(exports, "IncludeExcludeFlag", { enumerable: true, get: function () { return cspell_lib_2.IncludeExcludeFlag; } });
 function lint(fileGlobs, options, emitters) {
+    options = (0, options_1.fixLegacy)(options);
     const cfg = new lint_1.LintRequest(fileGlobs, options, emitters);
     return (0, lint_1.runLint)(cfg);
 }
 exports.lint = lint;
-async function trace(words, options) {
-    const { local } = options;
-    const { languageId, locale = local, allowCompoundWords, ignoreCase } = options;
+async function* trace(words, options) {
+    options = (0, options_1.fixLegacy)(options);
+    const iWords = options.stdin ? async.mergeAsyncIterables(words, (0, stdin_1.readStdin)()) : words;
+    const { languageId, locale, allowCompoundWords, ignoreCase } = options;
     const configFile = await (0, fileHelper_1.readConfig)(options.config, undefined);
-    const config = cspell.mergeSettings(cspell.getDefaultSettings(), cspell.getGlobalSettings(), configFile.config);
-    const results = await (0, cspell_lib_1.traceWords)(words, config, { languageId, locale, ignoreCase, allowCompoundWords });
-    return results;
+    const config = (0, cspell_lib_1.mergeSettings)((0, cspell_lib_1.getDefaultSettings)(), (0, cspell_lib_1.getGlobalSettings)(), configFile.config);
+    yield* (0, cspell_lib_1.traceWordsAsync)(iWords, config, { languageId, locale, ignoreCase, allowCompoundWords });
 }
 exports.trace = trace;
 async function checkText(filename, options) {
+    options = (0, options_1.fixLegacy)(options);
     const pSettings = (0, fileHelper_1.readConfig)(options.config, path.dirname(filename));
     const [foundSettings, text] = await Promise.all([pSettings, (0, fileHelper_1.readFile)(filename)]);
     const settingsFromCommandLine = util.clean({
@@ -50,9 +54,25 @@ async function checkText(filename, options) {
         language: options.locale || options.local || undefined,
     });
     const info = (0, fileHelper_1.calcFinalConfigInfo)(foundSettings, settingsFromCommandLine, filename, text);
-    return cspell.checkText(text, info.configInfo.config);
+    return (0, cspell_lib_1.checkText)(text, info.configInfo.config);
 }
 exports.checkText = checkText;
+async function* suggestions(words, options) {
+    options = (0, options_1.fixLegacy)(options);
+    const configFile = await (0, fileHelper_1.readConfig)(options.config, undefined);
+    const iWords = options.useStdin ? async.mergeAsyncIterables(words, (0, stdin_1.readStdin)()) : words;
+    try {
+        const results = (0, cspell_lib_1.suggestionsForWords)(iWords, options, configFile.config);
+        yield* results;
+    }
+    catch (e) {
+        if (!(e instanceof cspell_lib_1.SuggestionError))
+            throw e;
+        console.error(e.message);
+        process.exitCode = 1;
+    }
+}
+exports.suggestions = suggestions;
 function createInit() {
     return Promise.reject();
 }

package/dist/commandLink.js

@@ -7,7 +7,7 @@ const table_1 = require("./util/table");
 function commandLink(prog) {
     const linkCommand = prog
         .command('link')
-        .description('Link dictionaries any other settings to the cspell global config.');
+        .description('Link dictionaries and other settings to the cspell global config.');
     linkCommand
         .command('list', { isDefault: true })
         .alias('ls')

package/dist/commandLint.js

@@ -62,6 +62,8 @@ function commandLint(prog) {
         .option('--no-progress', 'Turn off progress messages')
         .option('--no-summary', 'Turn off summary message in console.')
         .option('-s, --silent', 'Silent mode, suppress error messages.')
+        .option('--fail-fast', 'Exit after first file with an issue or error.')
+        .addOption(new commander_1.Option('--no-fail-fast', 'Process all files even if there is an error.').hideHelp())
         .option('-r, --root <root folder>', 'Root directory, defaults to current directory.')
         .option('--relative', 'Issues are displayed relative to root.')
         .option('--show-context', 'Show the surrounding text around an issue.')

package/dist/commandSuggestion.d.ts

@@ -0,0 +1,3 @@
+import { Command } from 'commander';
+export declare function commandSuggestion(prog: Command): Command;
+//# sourceMappingURL=commandSuggestion.d.ts.map

package/dist/commandSuggestion.js

@@ -0,0 +1,83 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (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.commandSuggestion = void 0;
+const commander_1 = require("commander");
+const App = __importStar(require("./application"));
+const suggestionsEmitter_1 = require("./emitters/suggestionsEmitter");
+const errors_1 = require("./util/errors");
+function collect(value, previous) {
+    value = value.replace(/^=/, '');
+    if (!previous) {
+        return [value];
+    }
+    return previous.concat([value]);
+}
+function count(_, previous) {
+    return (previous || 0) + 1;
+}
+function asNumber(value, prev) {
+    var _a;
+    return (_a = parseInt(value, 10)) !== null && _a !== void 0 ? _a : prev;
+}
+function commandSuggestion(prog) {
+    const suggestionCommand = prog.command('suggestions');
+    suggestionCommand
+        .aliases(['sug', 'suggest'])
+        .description('Spelling Suggestions for words.')
+        .option('-c, --config <cspell.json>', 'Configuration file to use.  By default cspell looks for cspell.json in the current directory.')
+        .option('--locale <locale>', 'Set language locales. i.e. "en,fr" for English and French, or "en-GB" for British English.')
+        .option('--language-id <language>', 'Use programming language. i.e. "php" or "scala".')
+        .addOption(new commander_1.Option('--languageId <language>', 'Use programming language. i.e. "php" or "scala".').hideHelp())
+        .option('-s, --no-strict', 'Ignore case and accents when searching for words.')
+        .option('--ignore-case', 'Alias of --no-strict.')
+        .option('--num-changes <number>', 'Number of changes allowed to a word', asNumber, 4)
+        .option('--num-suggestions <number>', 'Number of suggestions', asNumber, 8)
+        .option('--no-include-ties', 'Force the number of suggested to be limited, by not including suggestions that have the same edit cost.')
+        .option('--stdin', 'Use stdin for input.')
+        .option('-v, --verbose', 'Show detailed output.', count, 0)
+        .option('-d, --dictionary <dictionary name>', 'Use the dictionary specified. Only dictionaries specified will be used.', collect)
+        .option('--dictionaries <dictionary names...>', 'Use the dictionaries specified. Only dictionaries specified will be used.')
+        .option('--no-color', 'Turn off color.')
+        .option('--color', 'Force color')
+        .arguments('[words...]')
+        .action(async (words, options) => {
+        options.useStdin = options.stdin;
+        options.dictionaries = mergeArrays(options.dictionaries, options.dictionary);
+        if (!words.length && !options.useStdin) {
+            suggestionCommand.outputHelp();
+            throw new errors_1.CheckFailed('outputHelp', 1);
+        }
+        for await (const r of App.suggestions(words, options)) {
+            (0, suggestionsEmitter_1.emitSuggestionResult)(r, options);
+        }
+    });
+    return suggestionCommand;
+}
+exports.commandSuggestion = commandSuggestion;
+function mergeArrays(a, b) {
+    if (a === undefined)
+        return b;
+    if (b === undefined)
+        return a;
+    return a.concat(b);
+}
+//# sourceMappingURL=commandSuggestion.js.map

package/dist/commandTrace.js

@@ -22,13 +22,12 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.commandTrace = void 0;
 const commander_1 = require("commander");
 const App = __importStar(require("./application"));
-const traceEmitter_1 = require("./traceEmitter");
+const traceEmitter_1 = require("./emitters/traceEmitter");
 const errors_1 = require("./util/errors");
 function commandTrace(prog) {
     return prog
         .command('trace')
-        .description(`Trace words
-  Search for words in the configuration and dictionaries.`)
+        .description(`Trace words -- Search for words in the configuration and dictionaries.`)
         .option('-c, --config <cspell.json>', 'Configuration file to use.  By default cspell looks for cspell.json in the current directory.')
         .option('--locale <locale>', 'Set language locales. i.e. "en,fr" for English and French, or "en-GB" for British English.')
         .option('--language-id <language>', 'Use programming language. i.e. "php" or "scala"')
@@ -37,22 +36,25 @@ function commandTrace(prog) {
         .addOption(new commander_1.Option('--allowCompoundWords', 'Turn on allowCompoundWords').hideHelp())
         .option('--no-allow-compound-words', 'Turn off allowCompoundWords')
         .option('--no-ignore-case', 'Do not ignore case and accents when searching for words')
+        .option('--stdin', 'Read words from stdin.')
         .option('--no-color', 'Turn off color.')
         .option('--color', 'Force color')
-        .arguments('<words...>')
+        .arguments('[words...]')
         .action(async (words, options) => {
-        const results = await App.trace(words, options);
-        (0, traceEmitter_1.emitTraceResults)(results, { cwd: process.cwd() });
-        const numFound = results.reduce((n, r) => n + (r.found ? 1 : 0), 0);
+        let numFound = 0;
+        for await (const results of App.trace(words, options)) {
+            (0, traceEmitter_1.emitTraceResults)(results, { cwd: process.cwd() });
+            numFound += results.reduce((n, r) => n + (r.found ? 1 : 0), 0);
+            const numErrors = results.map((r) => { var _a; return ((_a = r.errors) === null || _a === void 0 ? void 0 : _a.length) || 0; }).reduce((n, r) => n + r, 0);
+            if (numErrors) {
+                console.error('Dictionary Errors.');
+                throw new errors_1.CheckFailed('dictionary errors', 1);
+            }
+        }
         if (!numFound) {
             console.error('No matches found');
             throw new errors_1.CheckFailed('no matches', 1);
         }
-        const numErrors = results.map((r) => { var _a; return ((_a = r.errors) === null || _a === void 0 ? void 0 : _a.length) || 0; }).reduce((n, r) => n + r, 0);
-        if (numErrors) {
-            console.error('Dictionary Errors.');
-            throw new errors_1.CheckFailed('dictionary errors', 1);
-        }
     });
 }
 exports.commandTrace = commandTrace;

package/dist/emitters/suggestionsEmitter.d.ts

@@ -0,0 +1,10 @@
+import type { SuggestionsForWordResult } from 'cspell-lib';
+export interface EmitSuggestionOptions {
+    verbose?: number;
+    lineWidth?: number;
+    output?: {
+        log: (text: string) => void;
+    };
+}
+export declare function emitSuggestionResult(result: SuggestionsForWordResult, options: EmitSuggestionOptions): void;
+//# sourceMappingURL=suggestionsEmitter.d.ts.map

package/dist/emitters/suggestionsEmitter.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.emitSuggestionResult = void 0;
+const chalk = require("chalk");
+const util_1 = require("../util/util");
+function emitSuggestionResult(result, options) {
+    const { word, suggestions } = result;
+    const { verbose, output = console } = options;
+    output.log(word ? chalk.green(word) : chalk.yellow('<empty>') + ':');
+    if (!suggestions.length) {
+        console.log(chalk.yellow(' <no suggestions>'));
+        return;
+    }
+    if (verbose) {
+        const maxWidth = suggestions.map((r) => r.word.length).reduce((max, len) => Math.max(max, len), 0);
+        for (const sug of suggestions) {
+            const { word, cost, dictionaries } = sug;
+            const padding = ' '.repeat(maxWidth - word.length);
+            const forbid = sug.forbidden ? chalk.red('X') : ' ';
+            const ignore = sug.noSuggest ? chalk.yellow('N') : ' ';
+            const strCost = (0, util_1.padLeft)(cost.toString(10), 4);
+            const dicts = dictionaries.map((n) => chalk.gray(n)).join(', ');
+            output.log(` - ${formatWord(word, sug)}${padding} ${forbid}${ignore} - ${chalk.yellow(strCost)} ${dicts}`);
+        }
+    }
+    else {
+        for (const r of suggestions) {
+            output.log(` - ${formatWordSingle(r)}`);
+        }
+    }
+}
+exports.emitSuggestionResult = emitSuggestionResult;
+function formatWord(word, r) {
+    return r.forbidden || r.noSuggest ? chalk.gray(chalk.strikethrough(word)) : word;
+}
+function formatWordSingle(s) {
+    let word = formatWord(s.word, s);
+    word = s.forbidden ? word + chalk.red(' X') : word;
+    word = s.noSuggest ? word + chalk.yellow(' Not suggested.') : word;
+    return word;
+}
+//# sourceMappingURL=suggestionsEmitter.js.map

package/dist/{traceEmitter.d.ts → emitters/traceEmitter.d.ts}

@@ -1,4 +1,4 @@
-import { TraceResult } from './application';
+import { TraceResult } from '../application';
 export interface EmitTraceOptions {
     /** current working directory */
     cwd: string;

package/dist/{traceEmitter.js → emitters/traceEmitter.js}

@@ -23,9 +23,10 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.emitTraceResults = void 0;
-const chalk = require("chalk");
-const strip_ansi_1 = __importDefault(require("strip-ansi"));
 const Path = __importStar(require("path"));
+const strip_ansi_1 = __importDefault(require("strip-ansi"));
+const util_1 = require("../util/util");
+const chalk = require("chalk");
 const colWidthDictionaryName = 20;
 function emitTraceResults(results, options) {
     var _a;
@@ -45,10 +46,10 @@ function emitTraceResults(results, options) {
 exports.emitTraceResults = emitTraceResults;
 function emitHeader(colWidths) {
     const line = [
-        pad('Word', colWidths.word),
+        (0, util_1.pad)('Word', colWidths.word),
         'F',
-        pad('Dictionary', colWidths.dictName),
-        pad('Dictionary Location', 30),
+        (0, util_1.pad)('Dictionary', colWidths.dictName),
+        (0, util_1.pad)('Dictionary Location', 30),
     ];
     console.log(chalk.underline(line.join(' ').slice(0, colWidths.terminalWidth)));
 }
@@ -56,12 +57,12 @@ function emitTraceResult(r, colWidths, options) {
     var _a, _b;
     const { word: wordColWidth, terminalWidth, dictName: widthName } = colWidths;
     const errors = ((_b = (_a = r.errors) === null || _a === void 0 ? void 0 : _a.map((e) => e.message)) === null || _b === void 0 ? void 0 : _b.join('\n\t')) || '';
-    const word = pad(r.foundWord || r.word, wordColWidth);
+    const word = (0, util_1.pad)(r.foundWord || r.word, wordColWidth);
     const cWord = word.replace(/[+]/g, chalk.yellow('+'));
     const w = r.forbidden ? chalk.red(cWord) : chalk.green(cWord);
     const f = calcFoundChar(r);
     const a = r.dictActive ? '*' : ' ';
-    const dictName = pad(r.dictName.slice(0, widthName - 1) + a, widthName);
+    const dictName = (0, util_1.pad)(r.dictName.slice(0, widthName - 1) + a, widthName);
     const dictColor = r.dictActive ? chalk.yellowBright : chalk.rgb(200, 128, 50);
     const n = dictColor(dictName);
     const info = [w, f, n].join(' ') + ' ';
@@ -75,9 +76,6 @@ function emitTraceResult(r, colWidths, options) {
         console.error('\t' + chalk.red(errors));
     }
 }
-function pad(s, w) {
-    return (s + ' '.repeat(w)).substr(0, w);
-}
 function trimMid(s, w) {
     s = s.trim();
     if (s.length <= w) {
@@ -85,7 +83,7 @@ function trimMid(s, w) {
     }
     const l = Math.floor((w - 3) / 2);
     const r = Math.ceil((w - 3) / 2);
-    return s.substr(0, l) + '...' + s.substr(-r);
+    return s.slice(0, l) + '...' + s.slice(-r);
 }
 function calcFoundChar(r) {
     var _a, _b;

package/dist/lint/LintRequest.js

@@ -32,7 +32,7 @@ class LintRequest {
         this.root = path.resolve(options.root || process.cwd());
         this.configFile = options.config;
         this.excludes = (0, glob_1.calcExcludeGlobInfo)(this.root, options.exclude);
-        this.locale = options.locale || options.local || '';
+        this.locale = options.locale || '';
         this.enableGlobDot = options.dot;
         this.uniqueFilter = options.unique ? util.uniqueFilterFnGenerator((issue) => issue.text) : () => true;
         this.showContext =