cspell 5.17.0-alpha.0 → 5.18.1

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,25 +20,25 @@ 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 commandTrace_1 = require("./commandTrace");
 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);

package/dist/application.d.ts

@@ -1,7 +1,6 @@
 /// <reference types="node" />
 import type { CSpellReporter, RunResult } from '@cspell/cspell-types';
-import * as cspell from 'cspell-lib';
-import { CheckTextInfo, TraceResult } from 'cspell-lib';
+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';
@@ -10,6 +9,6 @@ export declare function lint(fileGlobs: string[], options: LinterOptions, emitte
 export declare function trace(words: string[], options: TraceOptions): AsyncIterableIterator<TraceResult[]>;
 export declare type CheckTextResult = CheckTextInfo;
 export declare function checkText(filename: string, options: BaseOptions & LegacyOptions): Promise<CheckTextResult>;
-export declare function suggestions(words: string[], options: SuggestionOptions): AsyncIterable<cspell.SuggestionsForWordResult>;
+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

@@ -20,15 +20,14 @@ var __importStar = (this && this.__importStar) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createInit = exports.suggestions = exports.checkText = exports.trace = exports.lint = exports.IncludeExcludeFlag = void 0;
-const cspell = __importStar(require("cspell-lib"));
 const cspell_lib_1 = require("cspell-lib");
 const path = __importStar(require("path"));
-const fileHelper_1 = require("./util/fileHelper");
 const lint_1 = require("./lint");
 const options_1 = require("./options");
+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"));
-const async = __importStar(require("./util/async"));
 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) {
@@ -39,10 +38,10 @@ 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 = cspell.mergeSettings(cspell.getDefaultSettings(), cspell.getGlobalSettings(), configFile.config);
+    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;
@@ -55,13 +54,13 @@ 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;
+    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,7 +6,7 @@ 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;
@@ -14,13 +14,14 @@ function emitSuggestionResult(result, options) {
     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 { word, cost, dictionaries, compoundWord } = sug;
+            const w = compoundWord || word;
+            const padding = ' '.repeat(maxWidth - w.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}`);
+            output.log(` - ${formatWord(w, sug)}${padding} ${forbid}${ignore} - ${chalk.yellow(strCost)} ${dicts}`);
         }
     }
     else {

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/glob.d.ts

@@ -1,7 +1,15 @@
 import type { CSpellUserSettings, Glob } from '@cspell/cspell-types';
 import { GlobMatcher, GlobPatternWithRoot } from 'cspell-glob';
-import type { IOptions as IGlobOptions } from 'glob';
-export declare type GlobOptions = IGlobOptions;
+/**
+ * This is a subset of IOptions from 'glob'.
+ */
+export interface GlobOptions {
+    cwd?: string | undefined;
+    root?: string | undefined;
+    dot?: boolean | undefined;
+    nodir?: boolean | undefined;
+    ignore?: string | ReadonlyArray<string> | undefined;
+}
 /**
  *
  * @param pattern - glob patterns and NOT file paths. It can be a file path turned into a glob.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cspell",
-  "version": "5.17.0-alpha.0",
+  "version": "5.18.1",
   "description": "A Spelling Checker for Code!",
   "funding": "https://github.com/streetsidesoftware/cspell?sponsor=1",
   "main": "dist/index.js",
@@ -36,7 +36,8 @@
   ],
   "scripts": {
     "clean": "rimraf dist coverage .tsbuildinfo",
-    "build": "npm run compile",
+    "build": "npm run compile && npm run build-api",
+    "build-api": "rollup -c rollup.config.mjs",
     "build-dev": "tsc -p tsconfig.dev.json",
     "clean-build": "npm run clean && npm run build",
     "compile": "tsc -p .",
@@ -69,12 +70,13 @@
   },
   "homepage": "https://streetsidesoftware.github.io/cspell/",
   "dependencies": {
+    "@cspell/cspell-pipe": "^5.18.1",
     "chalk": "^4.1.2",
-    "commander": "^8.3.0",
+    "commander": "^9.0.0",
     "comment-json": "^4.1.1",
-    "cspell-gitignore": "^5.17.0-alpha.0",
-    "cspell-glob": "^5.17.0-alpha.0",
-    "cspell-lib": "^5.17.0-alpha.0",
+    "cspell-gitignore": "^5.18.1",
+    "cspell-glob": "^5.18.1",
+    "cspell-lib": "^5.18.1",
     "fast-json-stable-stringify": "^2.1.0",
     "file-entry-cache": "^6.0.1",
     "fs-extra": "^10.0.0",
@@ -89,8 +91,8 @@
     "node": ">=12.13.0"
   },
   "devDependencies": {
-    "@cspell/cspell-json-reporter": "^5.17.0-alpha.0",
-    "@cspell/cspell-types": "^5.17.0-alpha.0",
+    "@cspell/cspell-json-reporter": "^5.18.1",
+    "@cspell/cspell-types": "^5.18.1",
     "@types/file-entry-cache": "^5.0.2",
     "@types/fs-extra": "^9.0.13",
     "@types/glob": "^7.2.0",
@@ -101,7 +103,9 @@
     "jest": "^27.4.7",
     "micromatch": "^4.0.4",
     "minimatch": "^3.0.4",
-    "rimraf": "^3.0.2"
+    "rimraf": "^3.0.2",
+    "rollup": "^2.66.1",
+    "rollup-plugin-dts": "^4.1.0"
   },
-  "gitHead": "d884218703cac72186fd69e8ba1e9eb78558c7ca"
+  "gitHead": "8b94979b57a7b1a11f8efbd5bc086d29d496f7be"
 }