cspell 5.17.0 → 5.18.2

package/dist/application.js

@@ -24,7 +24,7 @@ const cspell_lib_1 = require("cspell-lib");
 const path = __importStar(require("path"));
 const lint_1 = require("./lint");
 const options_1 = require("./options");
-const async = __importStar(require("./util/async"));
+const async = __importStar(require("@cspell/cspell-pipe"));
 const fileHelper_1 = require("./util/fileHelper");
 const stdin_1 = require("./util/stdin");
 const util = __importStar(require("./util/util"));
@@ -38,7 +38,7 @@ function lint(fileGlobs, options, emitters) {
 exports.lint = lint;
 async function* trace(words, options) {
     options = (0, options_1.fixLegacy)(options);
-    const iWords = options.stdin ? async.mergeAsyncIterables(words, (0, stdin_1.readStdin)()) : words;
+    const iWords = options.stdin ? async.toAsyncIterable(words, (0, stdin_1.readStdin)()) : words;
     const { languageId, locale, allowCompoundWords, ignoreCase } = options;
     const configFile = await (0, fileHelper_1.readConfig)(options.config, undefined);
     const config = (0, cspell_lib_1.mergeSettings)((0, cspell_lib_1.getDefaultSettings)(), (0, cspell_lib_1.getGlobalSettings)(), configFile.config);
@@ -60,7 +60,7 @@ 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;
+    const iWords = options.useStdin ? async.toAsyncIterable(words, (0, stdin_1.readStdin)()) : words;
     try {
         const results = (0, cspell_lib_1.suggestionsForWords)(iWords, options, configFile.config);
         yield* results;

package/dist/emitters/suggestionsEmitter.js

@@ -6,21 +6,24 @@ 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>') + ':');
+    output.log(word ? chalk.yellow(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);
+        const maxWidth = suggestions
+            .map((r) => (0, util_1.width)(r.compoundWord || r.word))
+            .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 { word, cost, dictionaries, compoundWord } = sug;
+            const w = compoundWord || word;
+            const padding = ' '.repeat((0, util_1.padWidth)(w, maxWidth));
             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}`);
+            output.log(` - ${formatWord(w, sug)}${padding} ${forbid}${ignore} - ${chalk.yellow(strCost)} ${dicts}`);
         }
     }
     else {

package/dist/emitters/traceEmitter.js

@@ -32,7 +32,7 @@ function emitTraceResults(results, options) {
     var _a;
     const maxWordLength = results
         .map((r) => r.foundWord || r.word)
-        .reduce((a, b) => Math.max(a, b.length), 'Word'.length);
+        .reduce((a, b) => Math.max(a, (0, util_1.width)(b)), 'Word'.length);
     const cols = {
         word: maxWordLength,
         dictName: colWidthDictionaryName,
@@ -66,7 +66,7 @@ function emitTraceResult(r, colWidths, options) {
     const dictColor = r.dictActive ? chalk.yellowBright : chalk.rgb(200, 128, 50);
     const n = dictColor(dictName);
     const info = [w, f, n].join(' ') + ' ';
-    const used = (0, strip_ansi_1.default)(info).length;
+    const used = (0, util_1.width)((0, strip_ansi_1.default)(info));
     const widthSrc = terminalWidth - used;
     const c = errors ? chalk.red : chalk.white;
     const s = c(formatDictionaryLocation(r.dictSource, widthSrc, options.cwd));

package/dist/lint/lint.js

@@ -28,14 +28,15 @@ const cspell = __importStar(require("cspell-lib"));
 const path = __importStar(require("path"));
 const util_1 = require("util");
 const vscode_uri_1 = require("vscode-uri");
-const fileHelper_1 = require("../util/fileHelper");
+const cspell_pipe_1 = require("@cspell/cspell-pipe");
 const cache_1 = require("../util/cache");
 const errors_1 = require("../util/errors");
+const fileHelper_1 = require("../util/fileHelper");
 const glob_1 = require("../util/glob");
 const reporters_1 = require("../util/reporters");
 const timer_1 = require("../util/timer");
 const util = __importStar(require("../util/util"));
-const async_1 = require("../util/async");
+const chalk = require("chalk");
 async function runLint(cfg) {
     let { reporter } = cfg;
     cspell.setLogger(getLoggerFromReporter(reporter));
@@ -200,6 +201,7 @@ async function runLint(cfg) {
             return runResult();
         }
         header(fileGlobs, excludeGlobs);
+        checkGlobs(cfg.fileGlobs, reporter);
         reporter.info(`Config Files Found:\n    ${configInfo.source}\n`, cspell_types_1.MessageTypes.Info);
         const configErrors = await countConfigErrors(configInfo);
         if (configErrors)
@@ -233,6 +235,12 @@ Options:
     }
 }
 exports.runLint = runLint;
+function checkGlobs(globs, reporter) {
+    globs
+        .filter((g) => g.startsWith("'") || g.endsWith("'"))
+        .map((glob) => chalk.yellow(glob))
+        .forEach((glob) => reporter.error('Linter', new errors_1.CheckFailed(`Glob starting or ending with ' (single quote) is not likely to match any files: ${glob}.`)));
+}
 async function determineGlobs(configInfo, cfg) {
     var _a, _b, _c;
     const useGitignore = (_b = (_a = cfg.options.gitignore) !== null && _a !== void 0 ? _a : configInfo.config.useGitignore) !== null && _b !== void 0 ? _b : false;
@@ -270,14 +278,14 @@ async function determineFilesToCheck(configInfo, cfg, reporter, globInfo) {
         if (enableGlobDot !== undefined) {
             globOptions.dot = enableGlobDot;
         }
-        const filterFiles = (0, async_1.filter)(filterFilesFn(globMatcher));
+        const filterFiles = (0, cspell_pipe_1.opFilter)(filterFilesFn(globMatcher));
         const foundFiles = await (hasFileLists
             ? useFileLists(fileLists, allGlobs, root, enableGlobDot)
             : (0, fileHelper_1.findFiles)(fileGlobs, globOptions));
         const filtered = gitIgnore ? await gitIgnore.filterOutIgnored(foundFiles) : foundFiles;
-        const files = (0, async_1.isAsyncIterable)(filtered)
-            ? (0, async_1.pipeAsync)(filtered, filterFiles)
-            : [...(0, async_1.pipeSync)(filtered, filterFiles)];
+        const files = (0, cspell_pipe_1.isAsyncIterable)(filtered)
+            ? (0, cspell_pipe_1.pipeAsync)(filtered, filterFiles)
+            : [...(0, cspell_pipe_1.pipeSync)(filtered, filterFiles)];
         return files;
     }
     function isExcluded(filename, globMatcherExclude) {
@@ -384,6 +392,6 @@ async function useFileLists(fileListFiles, includeGlobPatterns, root, dot) {
     const globMatcher = new cspell_glob_1.GlobMatcher(includeGlobPatterns, options);
     const files = await (0, fileHelper_1.readFileListFiles)(fileListFiles);
     const filterFiles = (file) => globMatcher.match(file);
-    return files instanceof Array ? files.filter(filterFiles) : (0, async_1.pipeAsync)(files, (0, async_1.filter)(filterFiles));
+    return files instanceof Array ? files.filter(filterFiles) : (0, cspell_pipe_1.pipeAsync)(files, (0, cspell_pipe_1.opFilter)(filterFiles));
 }
 //# sourceMappingURL=lint.js.map

package/dist/util/async.d.ts

@@ -1,46 +1,2 @@
-export declare const map: <T, U>(fn: (v: T) => U) => PipeFn<T, U>;
-export declare function asyncAwait<T>(): (iter: AsyncIterable<T>) => AsyncIterable<Awaited<T>>;
-export declare const filter: <T>(fn: (i: T) => boolean) => PipeFn<T, T>;
-interface PipeFnSync<T, U> {
-    (iter: Iterable<T>): Iterable<U>;
-    /** This is just to help TypeScript figure out the type. */
-    __PipeFnSync__?: [T, U];
-}
-interface PipeFnAsync<T, U> {
-    (iter: AsyncIterable<T>): AsyncIterable<U>;
-    /** This is just to help TypeScript figure out the type. */
-    __PipeFnAsync__?: [T, U];
-}
-declare type PipeFn<T, U> = PipeFnSync<T, U> & PipeFnAsync<T, U>;
-export declare function pipeAsync<T>(i: AnyIterable<T>): AsyncIterable<T>;
-export declare function pipeAsync<T, T0>(i: AnyIterable<T>, ...f: PipeAsyncTx<[T, T0]>): AsyncIterable<T0>;
-export declare function pipeAsync<T, T0, T1>(i: AnyIterable<T>, ...f: PipeAsyncTx<[T, T0, T1]>): AsyncIterable<T1>;
-export declare function pipeAsync<T, T0, T1, T2>(i: AnyIterable<T>, ...f: PipeAsyncTx<[T, T0, T1, T2]>): AsyncIterable<T2>;
-export declare function pipeAsync<T, T0, T1, T2, T3>(i: AnyIterable<T>, ...f: PipeAsyncTx<[T, T0, T1, T2, T3]>): AsyncIterable<T3>;
-export declare function pipeAsync<T, T0, T1, T2, T3, T4>(i: AnyIterable<T>, ...f: PipeAsyncTx<[T, T0, T1, T2, T3, T4]>): AsyncIterable<T4>;
-export declare function pipeAsync<T, T0, T1, T2, T3, T4, T5>(i: AnyIterable<T>, ...f: PipeAsyncTx<[T, T0, T1, T2, T3, T4, T5]>): AsyncIterable<T5>;
-declare type PsFn<T, U> = PipeFnSync<T, U> | ((i: Iterable<T>) => Iterable<U>);
-export declare function pipeSync<T>(i: Iterable<T>): Iterable<T>;
-export declare function pipeSync<T, T0 = T>(i: Iterable<T>, ...f: PipeSyncTx<[T, T0]>): Iterable<T0>;
-export declare function pipeSync<T, T0, T1>(i: Iterable<T>, ...f: PipeSyncTx<[T, T0, T1]>): Iterable<T1>;
-export declare function pipeSync<T, T0, T1, T2>(i: Iterable<T>, ...f: PipeSyncTx<[T, T0, T1, T2]>): Iterable<T2>;
-export declare function pipeSync<T, T0, T1, T2, T3>(i: Iterable<T>, ...f: PipeSyncTx<[T, T0, T1, T2, T3]>): Iterable<T3>;
-export declare function pipeSync<T, T0, T1, T2, T3, T4>(i: Iterable<T>, ...f: PipeSyncTx<[T, T0, T1, T2, T3, T4]>): Iterable<T4>;
-export declare function pipeSync<T, T0, T1, T2, T3, T4, T5>(i: Iterable<T>, ...f: PipeSyncTx<[T, T0, T1, T2, T3, T4, T5]>): Iterable<T5>;
-declare type AnyIterable<T> = Iterable<T> | AsyncIterable<T> | Promise<Iterable<T>> | Iterable<Promise<T>>;
-export declare function mergeAsyncIterables<T>(iter: Iterable<T>): AsyncIterable<T>;
-export declare function mergeAsyncIterables<T>(iter: AsyncIterable<T>): AsyncIterable<T>;
-export declare function mergeAsyncIterables<T>(iter: Promise<Iterable<T>>): AsyncIterable<T>;
-export declare function mergeAsyncIterables<T>(iter: AnyIterable<T>): AsyncIterable<T>;
-export declare function mergeAsyncIterables<T>(iter: AnyIterable<T>, ...rest: AnyIterable<T>[]): AsyncIterable<T>;
-/**
- * Convert one or more iterables to an AsyncIterable
- */
-export declare const toAsyncIterable: typeof mergeAsyncIterables;
-export declare function asyncIterableToArray<T>(iter: Iterable<T> | AsyncIterable<T>): Promise<Awaited<T>[]>;
-export declare function isAsyncIterable<T>(i: AnyIterable<T>): i is AsyncIterable<T>;
-declare type PaFn<T, U> = PipeFnAsync<T, U> | ((i: AsyncIterable<T>) => AsyncIterable<U>);
-declare type PipeAsyncTx<T extends [...any]> = T extends [infer Left, infer Right, ...infer Rest] ? Rest extends [any, ...any] ? [PaFn<Left, Right>, ...PipeAsyncTx<[Right, ...Rest]>] : [PaFn<Left, Right>] : never;
-declare type PipeSyncTx<T extends [...any]> = T extends [infer Left, infer Right, ...infer Rest] ? Rest extends [any, ...any] ? [PsFn<Left, Right>, ...PipeSyncTx<[Right, ...Rest]>] : [PsFn<Left, Right>] : never;
-export {};
+export { toAsyncIterable as mergeAsyncIterables, toArray as asyncIterableToArray } from '@cspell/cspell-pipe';
 //# sourceMappingURL=async.d.ts.map

package/dist/util/async.js

@@ -1,101 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isAsyncIterable = exports.asyncIterableToArray = exports.toAsyncIterable = exports.mergeAsyncIterables = exports.pipeSync = exports.pipeAsync = exports.filter = exports.asyncAwait = exports.map = void 0;
-function asyncMap(mapFn) {
-    async function* fn(iter) {
-        for await (const v of iter) {
-            yield mapFn(v);
-        }
-    }
-    return fn;
-}
-function syncMap(mapFn) {
-    function* fn(iter) {
-        for (const v of iter) {
-            yield mapFn(v);
-        }
-    }
-    return fn;
-}
-const map = (fn) => toPipeFn(syncMap(fn), asyncMap(fn));
-exports.map = map;
-function asyncFilter(filterFn) {
-    async function* fn(iter) {
-        for await (const v of iter) {
-            if (filterFn(v))
-                yield v;
-        }
-    }
-    return fn;
-}
-function syncFilter(filterFn) {
-    function* fn(iter) {
-        for (const v of iter) {
-            if (filterFn(v))
-                yield v;
-        }
-    }
-    return fn;
-}
-async function* _asyncAwait(iter) {
-    for await (const v of iter) {
-        yield v;
-    }
-}
-function asyncAwait() {
-    return _asyncAwait;
-}
-exports.asyncAwait = asyncAwait;
-const filter = (fn) => toPipeFn(syncFilter(fn), asyncFilter(fn));
-exports.filter = filter;
-function toPipeFn(syncFn, asyncFn) {
-    function _(i) {
-        return isAsyncIterable(i) ? asyncFn(i) : syncFn(i);
-    }
-    return _;
-}
-function pipeAsync(i, ...fns) {
-    let iter = (0, exports.toAsyncIterable)(i);
-    for (const fn of fns) {
-        iter = fn(iter);
-    }
-    return iter;
-}
-exports.pipeAsync = pipeAsync;
-function pipeSync(i, ...fns) {
-    let iter = i;
-    for (const fn of fns) {
-        iter = fn(iter);
-    }
-    return iter;
-}
-exports.pipeSync = pipeSync;
-/**
- * Merge multiple iterables into an AsyncIterable
- * @param iter - initial iterable.
- * @param rest - iterables to merge.
- */
-async function* mergeAsyncIterables(iter, ...rest) {
-    for await (const i of [iter, ...rest]) {
-        yield* i;
-    }
-}
-exports.mergeAsyncIterables = mergeAsyncIterables;
-/**
- * Convert one or more iterables to an AsyncIterable
- */
-exports.toAsyncIterable = mergeAsyncIterables;
-async function asyncIterableToArray(iter) {
-    const r = [];
-    for await (const t of iter) {
-        r.push(t);
-    }
-    return r;
-}
-exports.asyncIterableToArray = asyncIterableToArray;
-function isAsyncIterable(i) {
-    return typeof i[Symbol.asyncIterator] === 'function';
-}
-exports.isAsyncIterable = isAsyncIterable;
-//  type Last<T extends [...any]> = T extends [infer U, ...infer R] ? (R extends [any, ...any] ? Last<R> : U) : never;
+exports.asyncIterableToArray = exports.mergeAsyncIterables = void 0;
+var cspell_pipe_1 = require("@cspell/cspell-pipe");
+Object.defineProperty(exports, "mergeAsyncIterables", { enumerable: true, get: function () { return cspell_pipe_1.toAsyncIterable; } });
+Object.defineProperty(exports, "asyncIterableToArray", { enumerable: true, get: function () { return cspell_pipe_1.toArray; } });
 //# sourceMappingURL=async.js.map

package/dist/util/util.d.ts

@@ -4,7 +4,9 @@ export declare function uniqueFilterFnGenerator<T>(): FilterFn<T>;
 export declare function uniqueFilterFnGenerator<T, U>(extractFn: (v: T) => U): FilterFn<T>;
 export declare function unique<T>(src: T[]): T[];
 export declare function clean<T>(src: T): T;
+export declare function padWidth(s: string, target: number): number;
 export declare function pad(s: string, w: number): string;
 export declare function padLeft(s: string, w: number): string;
+export declare function width(s: string): number;
 export {};
 //# sourceMappingURL=util.d.ts.map

package/dist/util/util.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.padLeft = exports.pad = exports.clean = exports.unique = exports.uniqueFilterFnGenerator = exports.uniqueFn = void 0;
+exports.width = exports.padLeft = exports.pad = exports.padWidth = exports.clean = exports.unique = exports.uniqueFilterFnGenerator = exports.uniqueFn = void 0;
 // alias for uniqueFilterFnGenerator
 exports.uniqueFn = uniqueFilterFnGenerator;
 function uniqueFilterFnGenerator(extractFn) {
@@ -28,16 +28,28 @@ function clean(src) {
     return r;
 }
 exports.clean = clean;
+function padWidth(s, target) {
+    const sWidth = width(s);
+    return Math.max(target - sWidth, 0);
+}
+exports.padWidth = padWidth;
 function pad(s, w) {
-    if (s.length >= w)
+    const p = padWidth(s, w);
+    if (!p)
         return s;
-    return (s + ' '.repeat(w)).slice(0, w);
+    return s + ' '.repeat(p);
 }
 exports.pad = pad;
 function padLeft(s, w) {
-    if (s.length >= w)
+    const p = padWidth(s, w);
+    if (!p)
         return s;
-    return (' '.repeat(w) + s).slice(-w);
+    return ' '.repeat(p) + s;
 }
 exports.padLeft = padLeft;
+function width(s) {
+    // eslint-disable-next-line no-control-regex
+    return s.replace(/[\u0300-\u036f\x00-\x1f]/g, '').length;
+}
+exports.width = width;
 //# sourceMappingURL=util.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cspell",
-  "version": "5.17.0",
+  "version": "5.18.2",
   "description": "A Spelling Checker for Code!",
   "funding": "https://github.com/streetsidesoftware/cspell?sponsor=1",
   "main": "dist/index.js",
@@ -70,12 +70,13 @@
   },
   "homepage": "https://streetsidesoftware.github.io/cspell/",
   "dependencies": {
+    "@cspell/cspell-pipe": "^5.18.2",
     "chalk": "^4.1.2",
-    "commander": "^8.3.0",
+    "commander": "^9.0.0",
     "comment-json": "^4.1.1",
-    "cspell-gitignore": "^5.17.0",
-    "cspell-glob": "^5.17.0",
-    "cspell-lib": "^5.17.0",
+    "cspell-gitignore": "^5.18.2",
+    "cspell-glob": "^5.18.2",
+    "cspell-lib": "^5.18.2",
     "fast-json-stable-stringify": "^2.1.0",
     "file-entry-cache": "^6.0.1",
     "fs-extra": "^10.0.0",
@@ -90,8 +91,8 @@
     "node": ">=12.13.0"
   },
   "devDependencies": {
-    "@cspell/cspell-json-reporter": "^5.17.0",
-    "@cspell/cspell-types": "^5.17.0",
+    "@cspell/cspell-json-reporter": "^5.18.2",
+    "@cspell/cspell-types": "^5.18.2",
     "@types/file-entry-cache": "^5.0.2",
     "@types/fs-extra": "^9.0.13",
     "@types/glob": "^7.2.0",
@@ -103,8 +104,8 @@
     "micromatch": "^4.0.4",
     "minimatch": "^3.0.4",
     "rimraf": "^3.0.2",
-    "rollup": "^2.66.1",
+    "rollup": "^2.67.0",
     "rollup-plugin-dts": "^4.1.0"
   },
-  "gitHead": "4e02d88a7add382088eb16d9b200e4bf07434f8f"
+  "gitHead": "baa92d5154ccf0a3a27d00ed169dd79cc80ea6cc"
 }