cspell 7.0.2 → 7.2.0

package/README.md

@@ -150,7 +150,7 @@ Options:
   --no-progress                Turn off progress messages
   --no-summary                 Turn off summary message in console.
   -s, --silent                 Silent mode, suppress error messages.
-  --quiet                      An alias of --silent
+  --quiet                      Only show spelling issues or errors.
   --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.

package/dist/esm/app.d.ts

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

package/dist/esm/app.js

@@ -0,0 +1,45 @@
+import { Option as CommanderOption, program } from 'commander';
+import { satisfies as semverSatisfies } from 'semver';
+import { npmPackage } from '../lib/pkgInfo.cjs';
+import { commandCheck } from './commandCheck.js';
+import { commandLink } from './commandLink.js';
+import { commandLint } from './commandLint.js';
+import { commandSuggestion } from './commandSuggestion.js';
+import { commandTrace } from './commandTrace.js';
+import { ApplicationError } from './util/errors.js';
+export { CheckFailed } from './util/errors.js';
+export async function run(command, argv) {
+    const prog = command || program;
+    const args = argv || process.argv;
+    prog.exitOverride();
+    prog.version(npmPackage.version).description('Spelling Checker for Code').name('cspell');
+    if (!semverSatisfies(process.versions.node, npmPackage.engines.node)) {
+        throw new ApplicationError(`Unsupported NodeJS version (${process.versions.node}); ${npmPackage.engines.node} is required`);
+    }
+    const optionFlags = new CommanderOption('-f,--flag <flag:value>', 'Declare an execution flag value')
+        .hideHelp()
+        .argParser((value, prev) => prev?.concat(value) || [value]);
+    commandLint(prog).addOption(optionFlags);
+    commandTrace(prog).addOption(optionFlags);
+    commandCheck(prog).addOption(optionFlags);
+    commandSuggestion(prog).addOption(optionFlags);
+    commandLink(prog);
+    /*
+        program
+            .command('init')
+            .description('(Alpha) Initialize a cspell.json file.')
+            .option('-o, --output <cspell.json>', 'define where to write file.')
+            .option('--extends <cspell.json>', 'extend an existing cspell.json file.')
+            .action((options: InitOptions) => {
+                showHelp = false;
+                CSpellApplication.createInit(options).then(
+                    () => process.exit(0),
+                    () => process.exit(1)
+                );
+                console.log('Init');
+            });
+    */
+    prog.exitOverride();
+    await prog.parseAsync(args);
+}
+//# sourceMappingURL=app.js.map

package/dist/esm/app.mjs

@@ -42,3 +42,4 @@ export async function run(command, argv) {
     prog.exitOverride();
     await prog.parseAsync(args);
 }
+//# sourceMappingURL=app.mjs.map

package/dist/esm/application.d.ts

@@ -0,0 +1,16 @@
+/// <reference types="node" resolution-mode="require"/>
+import type { CSpellReporter, RunResult } from '@cspell/cspell-types';
+import type { CheckTextInfo, FeatureFlags, TraceResult } from 'cspell-lib';
+import type { TimedSuggestionsForWordResult } from './emitters/suggestionsEmitter.js';
+import type { BaseOptions, LegacyOptions, LinterCliOptions, SuggestionOptions, TraceOptions } from './options.js';
+export type { TraceResult } from 'cspell-lib';
+export { IncludeExcludeFlag } from 'cspell-lib';
+export type AppError = NodeJS.ErrnoException;
+export declare function lint(fileGlobs: string[], options: LinterCliOptions, reporter?: CSpellReporter): Promise<RunResult>;
+export declare function trace(words: string[], options: TraceOptions): AsyncIterableIterator<TraceResult[]>;
+export type CheckTextResult = CheckTextInfo;
+export declare function checkText(filename: string, options: BaseOptions & LegacyOptions): Promise<CheckTextResult>;
+export declare function suggestions(words: string[], options: SuggestionOptions): AsyncIterable<TimedSuggestionsForWordResult>;
+export declare function createInit(): Promise<void>;
+export declare function parseApplicationFeatureFlags(flags: string[] | undefined): FeatureFlags;
+//# sourceMappingURL=application.d.ts.map

package/dist/esm/application.js

@@ -0,0 +1,88 @@
+import { opMap, opTap, pipeAsync, toAsyncIterable } from '@cspell/cspell-pipe';
+import { checkTextDocument, getDefaultSettings, getGlobalSettings, mergeSettings, SuggestionError, suggestionsForWords, traceWordsAsync, } from 'cspell-lib';
+import { getReporter } from './cli-reporter.js';
+import { getFeatureFlags, parseFeatureFlags } from './featureFlags/index.js';
+import { LintRequest, runLint } from './lint/index.js';
+import { fixLegacy } from './options.js';
+import { simpleRepl } from './repl/index.js';
+import { fileInfoToDocument, readConfig, readFileInfo } from './util/fileHelper.js';
+import { finalizeReporter } from './util/reporters.js';
+import { readStdin } from './util/stdin.js';
+import { getTimeMeasurer } from './util/timer.js';
+import * as util from './util/util.js';
+export { IncludeExcludeFlag } from 'cspell-lib';
+export function lint(fileGlobs, options, reporter) {
+    options = fixLegacy(options);
+    const cfg = new LintRequest(fileGlobs, options, finalizeReporter(reporter) ?? getReporter({ ...options, fileGlobs }));
+    return runLint(cfg);
+}
+export async function* trace(words, options) {
+    options = fixLegacy(options);
+    const iWords = options.stdin ? toAsyncIterable(words, readStdin()) : words;
+    const { languageId, locale, allowCompoundWords, ignoreCase } = options;
+    const configFile = await readConfig(options.config, undefined);
+    const loadDefault = options.defaultConfiguration ?? configFile.config.loadDefaultConfiguration ?? true;
+    const config = mergeSettings(getDefaultSettings(loadDefault), getGlobalSettings(), configFile.config);
+    yield* traceWordsAsync(iWords, config, util.clean({ languageId, locale, ignoreCase, allowCompoundWords }));
+}
+export async function checkText(filename, options) {
+    options = fixLegacy(options);
+    const fileInfo = await readFileInfo(filename);
+    const { locale, languageId, validateDirectives } = options;
+    const doc = fileInfoToDocument(fileInfo, languageId, locale);
+    const checkOptions = {
+        configFile: options.config,
+        validateDirectives,
+    };
+    const settingsFromCommandLine = util.clean({
+        languageId,
+        language: locale,
+        loadDefaultConfiguration: options.defaultConfiguration,
+    });
+    return checkTextDocument(doc, util.clean({ ...checkOptions }), settingsFromCommandLine);
+}
+export async function* suggestions(words, options) {
+    options = fixLegacy(options);
+    const configFile = await readConfig(options.config, undefined);
+    let timer;
+    function tapStart() {
+        timer = getTimeMeasurer();
+    }
+    function mapStart(v) {
+        tapStart();
+        return v;
+    }
+    function mapEnd(v) {
+        const elapsedTimeMs = timer?.();
+        return elapsedTimeMs ? { ...v, elapsedTimeMs } : v;
+    }
+    const iWords = options.repl
+        ? pipeAsync(toAsyncIterable(words, simpleRepl()), opTap(tapStart))
+        : options.useStdin
+            ? pipeAsync(toAsyncIterable(words, readStdin()), opTap(tapStart))
+            : words.map(mapStart);
+    try {
+        const results = pipeAsync(suggestionsForWords(iWords, util.clean({ ...options }), configFile.config), opMap(mapEnd));
+        yield* results;
+    }
+    catch (e) {
+        if (!(e instanceof SuggestionError))
+            throw e;
+        console.error(e.message);
+        process.exitCode = 1;
+    }
+}
+export function createInit() {
+    return Promise.reject();
+}
+function registerApplicationFeatureFlags() {
+    const ff = getFeatureFlags();
+    const flags = [{ name: 'timer', description: 'Display elapsed time for command.' }];
+    flags.forEach((flag) => ff.register(flag));
+    return ff;
+}
+export function parseApplicationFeatureFlags(flags) {
+    const ff = registerApplicationFeatureFlags();
+    return parseFeatureFlags(flags, ff);
+}
+//# sourceMappingURL=application.js.map

package/dist/esm/application.mjs

@@ -85,3 +85,4 @@ export function parseApplicationFeatureFlags(flags) {
     const ff = registerApplicationFeatureFlags();
     return parseFeatureFlags(flags, ff);
 }
+//# sourceMappingURL=application.mjs.map

package/dist/esm/cli-reporter.d.ts

@@ -0,0 +1,16 @@
+import type { Issue } from '@cspell/cspell-types';
+import type { LinterCliOptions } from './options.js';
+import type { FinalizedReporter } from './util/reporters.js';
+export interface ReporterIssue extends Issue {
+    filename: string;
+}
+export interface ReporterOptions extends Pick<LinterCliOptions, 'debug' | 'issues' | 'legacy' | 'progress' | 'relative' | 'root' | 'showContext' | 'showSuggestions' | 'silent' | 'summary' | 'verbose' | 'wordsOnly'> {
+    fileGlobs: string[];
+}
+export declare function getReporter(options: ReporterOptions): FinalizedReporter;
+declare function formatIssue(templateStr: string, issue: ReporterIssue, maxIssueTextWidth: number): string;
+export declare const __testing__: {
+    formatIssue: typeof formatIssue;
+};
+export {};
+//# sourceMappingURL=cli-reporter.d.ts.map

package/dist/esm/cli-reporter.js

@@ -0,0 +1,218 @@
+import chalk from 'chalk';
+import chalkTemplate from 'chalk-template';
+import { isSpellingDictionaryLoadError } from 'cspell-lib';
+import * as path from 'path';
+import { URI } from '../lib/uri.cjs';
+const templateIssue = `{green $filename}:{yellow $row:$col} - $message ({red $text}) $quickFix`;
+const templateIssueNoFix = `{green $filename}:{yellow $row:$col} - $message ({red $text})`;
+const templateIssueWithSuggestions = `{green $filename}:{yellow $row:$col} - $message ({red $text}) Suggestions: {yellow [$suggestions]}`;
+const templateIssueWithContext = `{green $filename}:{yellow $row:$col} $padRowCol- $message ({red $text})$padContext -- {gray $contextLeft}{red {underline $text}}{gray $contextRight}`;
+const templateIssueWithContextWithSuggestions = `{green $filename}:{yellow $row:$col} $padRowCol- $message ({red $text})$padContext -- {gray $contextLeft}{red {underline $text}}{gray $contextRight}\n\t Suggestions: {yellow [$suggestions]}`;
+const templateIssueLegacy = `${chalk.green('$filename')}[$row, $col]: $message: ${chalk.red('$text')}`;
+const templateIssueWordsOnly = '$text';
+function genIssueEmitter(template) {
+    const defaultWidth = 10;
+    let maxWidth = defaultWidth;
+    let uri;
+    return function issueEmitter(issue) {
+        if (uri !== issue.uri) {
+            maxWidth = defaultWidth;
+            uri = issue.uri;
+        }
+        maxWidth = Math.max(maxWidth * 0.999, issue.text.length, 10);
+        console.log(formatIssue(template, issue, Math.ceil(maxWidth)));
+    };
+}
+function errorEmitter(message, error) {
+    if (isSpellingDictionaryLoadError(error)) {
+        error = error.cause;
+    }
+    console.error(chalk.red(message), error.toString());
+}
+function nullEmitter() {
+    /* empty */
+}
+function relativeFilename(filename, cwd = process.cwd()) {
+    const rel = path.relative(cwd, filename);
+    if (rel.startsWith('..'))
+        return filename;
+    return '.' + path.sep + rel;
+}
+function relativeUriFilename(uri, fsPathRoot) {
+    const fsPath = URI.parse(uri).fsPath;
+    const rel = path.relative(fsPathRoot, fsPath);
+    if (rel.startsWith('..'))
+        return fsPath;
+    return '.' + path.sep + rel;
+}
+function reportProgress(p) {
+    if (p.type === 'ProgressFileComplete') {
+        return reportProgressFileComplete(p);
+    }
+    if (p.type === 'ProgressFileBegin') {
+        return reportProgressFileBegin(p);
+    }
+}
+function reportProgressFileBegin(p) {
+    const fc = '' + p.fileCount;
+    const fn = (' '.repeat(fc.length) + p.fileNum).slice(-fc.length);
+    const idx = fn + '/' + fc;
+    const filename = chalk.gray(relativeFilename(p.filename));
+    process.stderr.write(`\r${idx} ${filename}`);
+}
+function reportProgressFileComplete(p) {
+    const time = reportTime(p.elapsedTimeMs, !!p.cached);
+    const skipped = p.processed === false ? ' skipped' : '';
+    const hasErrors = p.numErrors ? chalk.red ` X` : '';
+    console.error(` ${time}${skipped}${hasErrors}`);
+}
+function reportTime(elapsedTimeMs, cached) {
+    if (cached)
+        return chalk.green('cached');
+    if (elapsedTimeMs === undefined)
+        return '-';
+    const color = elapsedTimeMs < 1000 ? chalk.white : elapsedTimeMs < 2000 ? chalk.yellow : chalk.redBright;
+    return color(elapsedTimeMs.toFixed(2) + 'ms');
+}
+export function getReporter(options) {
+    const issueTemplate = options.wordsOnly
+        ? templateIssueWordsOnly
+        : options.legacy
+            ? templateIssueLegacy
+            : options.showContext
+                ? options.showSuggestions
+                    ? templateIssueWithContextWithSuggestions
+                    : templateIssueWithContext
+                : options.showSuggestions
+                    ? templateIssueWithSuggestions
+                    : options.showSuggestions === false
+                        ? templateIssueNoFix
+                        : templateIssue;
+    const { fileGlobs, silent, summary, issues, progress, verbose, debug } = options;
+    const emitters = {
+        Debug: !silent && debug ? (s) => console.info(chalk.cyan(s)) : nullEmitter,
+        Info: !silent && verbose ? (s) => console.info(chalk.yellow(s)) : nullEmitter,
+        Warning: (s) => console.info(chalk.yellow(s)),
+    };
+    function infoEmitter(message, msgType) {
+        emitters[msgType]?.(message);
+    }
+    const root = URI.file(options.root || process.cwd());
+    const fsPathRoot = root.fsPath;
+    function relativeIssue(fn) {
+        const fnFilename = options.relative
+            ? (uri) => relativeUriFilename(uri, fsPathRoot)
+            : (uri) => URI.parse(uri).fsPath;
+        return (i) => {
+            const filename = i.uri ? fnFilename(i.uri) : '';
+            const r = { ...i, filename };
+            fn(r);
+        };
+    }
+    const resultEmitter = (result) => {
+        if (!fileGlobs.length && !result.files) {
+            return;
+        }
+        if (result.cachedFiles) {
+            console.error('CSpell\x3a Files checked: %d (%d from cache), Issues found: %d in %d files', result.files, result.cachedFiles, result.issues, result.filesWithIssues.size);
+            return;
+        }
+        console.error('CSpell\x3a Files checked: %d, Issues found: %d in %d files', result.files, result.issues, result.filesWithIssues.size);
+    };
+    return {
+        issue: relativeIssue(silent || !issues ? nullEmitter : genIssueEmitter(issueTemplate)),
+        error: silent ? nullEmitter : errorEmitter,
+        info: infoEmitter,
+        debug: emitters.Debug,
+        progress: !silent && progress ? reportProgress : nullEmitter,
+        result: !silent && summary ? resultEmitter : nullEmitter,
+    };
+}
+function formatIssue(templateStr, issue, maxIssueTextWidth) {
+    function clean(t) {
+        return t.replace(/\s+/, ' ');
+    }
+    const { uri = '', filename, row, col, text, context, offset } = issue;
+    const contextLeft = clean(context.text.slice(0, offset - context.offset));
+    const contextRight = clean(context.text.slice(offset + text.length - context.offset));
+    const contextFull = clean(context.text);
+    const padContext = ' '.repeat(Math.max(maxIssueTextWidth - text.length, 0));
+    const rowText = row.toString();
+    const colText = col.toString();
+    const padRowCol = ' '.repeat(Math.max(1, 8 - (rowText.length + colText.length)));
+    const suggestions = formatSuggestions(issue);
+    const msg = issue.message || (issue.isFlagged ? 'Forbidden word' : 'Unknown word');
+    const message = issue.isFlagged ? `{yellow ${msg}}` : msg;
+    const substitutions = {
+        $col: colText,
+        $contextFull: contextFull,
+        $contextLeft: contextLeft,
+        $contextRight: contextRight,
+        $filename: filename,
+        $padContext: padContext,
+        $padRowCol: padRowCol,
+        $row: rowText,
+        $suggestions: suggestions,
+        $text: text,
+        $uri: uri,
+        $quickFix: formatQuickFix(issue),
+    };
+    const t = template(templateStr.replace(/\$message/g, message));
+    return substitute(chalkTemplate(t), substitutions).trimEnd();
+}
+function formatSuggestions(issue) {
+    if (issue.suggestionsEx) {
+        return issue.suggestionsEx
+            .map((sug) => sug.isPreferred
+            ? chalk.italic(chalk.bold(sug.wordAdjustedToMatchCase || sug.word)) + '*'
+            : sug.wordAdjustedToMatchCase || sug.word)
+            .join(', ');
+    }
+    if (issue.suggestions) {
+        return issue.suggestions.join(', ');
+    }
+    return '';
+}
+function formatQuickFix(issue) {
+    if (!issue.suggestionsEx?.length)
+        return '';
+    const preferred = issue.suggestionsEx
+        .filter((sug) => sug.isPreferred)
+        .map((sug) => sug.wordAdjustedToMatchCase || sug.word);
+    if (!preferred.length)
+        return '';
+    const fixes = preferred.map((w) => chalk.italic(chalk.yellow(w)));
+    return `fix: (${fixes.join(', ')})`;
+}
+class TS extends Array {
+    constructor(s) {
+        super(s);
+        this.raw = [s];
+    }
+}
+function template(s) {
+    return new TS(s);
+}
+function substitute(text, substitutions) {
+    const subs = [];
+    for (const [match, replaceWith] of Object.entries(substitutions)) {
+        const len = match.length;
+        for (let i = text.indexOf(match); i >= 0; i = text.indexOf(match, i + 1)) {
+            subs.push([i, i + len, replaceWith]);
+        }
+    }
+    subs.sort((a, b) => a[0] - b[0]);
+    let i = 0;
+    function sub(r) {
+        const [a, b, t] = r;
+        const prefix = text.slice(i, a);
+        i = b;
+        return prefix + t;
+    }
+    const parts = subs.map(sub);
+    return parts.join('') + text.slice(i);
+}
+export const __testing__ = {
+    formatIssue,
+};
+//# sourceMappingURL=cli-reporter.js.map

package/dist/esm/cli-reporter.mjs

@@ -215,3 +215,4 @@ function substitute(text, substitutions) {
 export const __testing__ = {
     formatIssue,
 };
+//# sourceMappingURL=cli-reporter.mjs.map

package/dist/esm/commandCheck.d.ts

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

package/dist/esm/commandCheck.js

@@ -0,0 +1,48 @@
+import chalk from 'chalk';
+import { Option as CommanderOption } from 'commander';
+import * as App from './application.js';
+import { checkText } from './application.js';
+import { CheckFailed } from './util/errors.js';
+export function commandCheck(prog) {
+    return prog
+        .command('check <files...>')
+        .description('Spell check file(s) and display the result. The full file is displayed in color.')
+        .option('-c, --config <cspell.json>', 'Configuration file to use.  By default cspell looks for cspell.json in the current directory.')
+        .option('--validate-directives', 'Validate in-document CSpell directives.')
+        .option('--no-validate-directives', 'Do not validate in-document CSpell directives.')
+        .option('--no-color', 'Turn off color.')
+        .option('--color', 'Force color')
+        .addOption(new CommanderOption('--default-configuration', 'Load the default configuration and dictionaries.').hideHelp())
+        .addOption(new CommanderOption('--no-default-configuration', 'Do not load the default configuration and dictionaries.'))
+        .action(async (files, options) => {
+        App.parseApplicationFeatureFlags(options.flag);
+        let issueCount = 0;
+        for (const filename of files) {
+            console.log(chalk.yellowBright(`Check file: ${filename}`));
+            console.log();
+            try {
+                const result = await checkText(filename, options);
+                for (const item of result.items) {
+                    const fn = item.flagIE === App.IncludeExcludeFlag.EXCLUDE
+                        ? chalk.gray
+                        : item.isError
+                            ? chalk.red
+                            : chalk.whiteBright;
+                    const t = fn(item.text);
+                    process.stdout.write(t);
+                    issueCount += item.isError ? 1 : 0;
+                }
+                console.log();
+            }
+            catch (e) {
+                console.error(`File not found "${filename}"`);
+                throw new CheckFailed('File not found', 1);
+            }
+            console.log();
+        }
+        if (issueCount) {
+            throw new CheckFailed('Issues found', 1);
+        }
+    });
+}
+//# sourceMappingURL=commandCheck.js.map

package/dist/esm/commandCheck.mjs

@@ -45,3 +45,4 @@ export function commandCheck(prog) {
         }
     });
 }
+//# sourceMappingURL=commandCheck.mjs.map

package/dist/esm/commandLink.d.ts

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

package/dist/esm/commandLink.js

@@ -0,0 +1,47 @@
+import { addPathsToGlobalImports, addPathsToGlobalImportsResultToTable, listGlobalImports, listGlobalImportsResultToTable, removePathsFromGlobalImports, } from './link.js';
+import { CheckFailed } from './util/errors.js';
+import { tableToLines } from './util/table.js';
+export function commandLink(prog) {
+    const linkCommand = prog
+        .command('link')
+        .description('Link dictionaries and other settings to the cspell global config.');
+    linkCommand
+        .command('list', { isDefault: true })
+        .alias('ls')
+        .description('List currently linked configurations.')
+        .action(() => {
+        const imports = listGlobalImports();
+        const table = listGlobalImportsResultToTable(imports.list);
+        tableToLines(table).forEach((line) => console.log(line));
+        return;
+    });
+    linkCommand
+        .command('add <dictionaries...>')
+        .alias('a')
+        .description('Add dictionaries any other settings to the cspell global config.')
+        .action((dictionaries) => {
+        const r = addPathsToGlobalImports(dictionaries);
+        const table = addPathsToGlobalImportsResultToTable(r);
+        console.log('Adding:');
+        tableToLines(table).forEach((line) => console.log(line));
+        if (r.error) {
+            throw new CheckFailed(r.error, 1);
+        }
+        return;
+    });
+    linkCommand
+        .command('remove <paths...>')
+        .alias('r')
+        .description('Remove matching paths / packages from the global config.')
+        .action((dictionaries) => {
+        const r = removePathsFromGlobalImports(dictionaries);
+        console.log('Removing:');
+        if (r.error) {
+            throw new CheckFailed(r.error, 1);
+        }
+        r.removed.map((f) => console.log(f));
+        return;
+    });
+    return linkCommand;
+}
+//# sourceMappingURL=commandLink.js.map

package/dist/esm/commandLink.mjs

@@ -44,3 +44,4 @@ export function commandLink(prog) {
     });
     return linkCommand;
 }
+//# sourceMappingURL=commandLink.mjs.map

package/dist/esm/commandLint.d.ts

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