cspell 5.14.0 → 5.15.3

package/README.md

@@ -56,6 +56,12 @@ cspell lint "src/**/*.js"
 cspell "**"
 ```
 
+**Git: Check Only Changed Files**
+
+```sh
+ git diff --name-only | npx cspell --file-list stdin
+```
+
 ## Command: `lint` -- Spell Checking
 
 The `lint` command is used for spell checking files.
@@ -110,8 +116,8 @@ Options:
   --show-suggestions           Show spelling suggestions.
   --no-must-find-files         Do not error if no files are found.
 
-  --cache                      Only check changed files. (default: false)
-
+  --cache                      Use cache to only check changed files.
+  --no-cache                   Do not use cache.
   --cache-strategy <strategy>  Strategy to use for detecting changed files.
                                (choices: "metadata", "content")
 

package/dist/commandLint.js

@@ -73,12 +73,13 @@ function commandLint(prog) {
         // .option('--force', 'Force the exit value to always be 0')
         .addOption(new commander_1.Option('--legacy', 'Legacy output').hideHelp())
         .addOption(new commander_1.Option('--local <local>', 'Deprecated -- Use: --locale').hideHelp())
-        .option('--cache', 'Only check changed files.', false)
+        .option('--cache', 'Use cache to only check changed files.')
+        .option('--no-cache', 'Do not use cache.')
         .addOption(new commander_1.Option('--cache-strategy <strategy>', 'Strategy to use for detecting changed files.').choices([
         'metadata',
         'content',
     ]))
-        .option('--cache-location <path>', `Path to the cache file or directory.`, cache_1.DEFAULT_CACHE_LOCATION)
+        .option('--cache-location <path>', `Path to the cache file or directory. (default: "${cache_1.DEFAULT_CACHE_LOCATION}")`)
         .option('--dot', 'Include files and directories starting with `.` (period) when matching globs.')
         .option('--gitignore', 'Ignore files matching glob patterns found in .gitignore files.')
         .option('--no-gitignore', 'Do NOT use .gitignore files.')

package/dist/fileHelper.d.ts

@@ -14,6 +14,7 @@ export declare function readConfig(configFile: string | undefined, root: string
 export interface FileInfo {
     filename: string;
     text?: string;
+    errorCode?: string;
 }
 export interface FileResult {
     fileInfo: FileInfo;
@@ -25,7 +26,10 @@ export interface FileResult {
     cached?: boolean;
 }
 export declare function fileInfoToDocument(fileInfo: FileInfo, languageId: string | undefined, locale: string | undefined): Document;
-export declare function readFileInfo(filename: string, encoding?: string): Promise<Required<FileInfo>>;
+interface ReadFileInfoResult extends FileInfo {
+    text: string;
+}
+export declare function readFileInfo(filename: string, encoding?: string, handleNotFound?: boolean): Promise<ReadFileInfoResult>;
 export declare function readFile(filename: string, encoding?: string): Promise<string>;
 /**
  * Looks for matching glob patterns or stdin
@@ -47,4 +51,5 @@ export declare function readFileListFiles(listFiles: string[]): Promise<string[]
  * @returns - a list of files to be processed.
  */
 export declare function readFileListFile(listFile: string): Promise<string[]>;
+export {};
 //# sourceMappingURL=fileHelper.d.ts.map

package/dist/fileHelper.js

@@ -57,12 +57,15 @@ function fileInfoToDocument(fileInfo, languageId, locale) {
     return (0, cspell_lib_1.fileToDocument)(filename, text, languageId, locale);
 }
 exports.fileInfoToDocument = fileInfoToDocument;
-function readFileInfo(filename, encoding = UTF8) {
+function readFileInfo(filename, encoding = UTF8, handleNotFound = false) {
     const pText = filename === STDIN ? (0, get_stdin_1.default)() : fsp.readFile(filename, encoding);
-    return pText.then((text) => ({ text, filename }), (error) => {
-        return error.code === 'EISDIR'
-            ? Promise.resolve({ text: '', filename })
-            : Promise.reject((0, errors_1.toApplicationError)(error, `Error reading file: "${filename}"`));
+    return pText.then((text) => ({ text, filename }), (e) => {
+        const error = (0, errors_1.toError)(e);
+        return handleNotFound && error.code === 'EISDIR'
+            ? Promise.resolve({ text: '', filename, errorCode: error.code })
+            : handleNotFound && error.code === 'ENOENT'
+                ? Promise.resolve({ text: '', filename, errorCode: error.code })
+                : Promise.reject(new errors_1.IOError(`Error reading file: "${filename}"`, error));
     });
 }
 exports.readFileInfo = readFileInfo;

package/dist/lint/lint.js

@@ -45,23 +45,34 @@ async function runLint(cfg) {
     return lintResult;
     async function processFile(filename, configInfo, cache) {
         var _a, _b, _c, _d;
-        const cachedResult = await cache.getCachedLintResults(filename, configInfo);
+        const cachedResult = await cache.getCachedLintResults(filename);
         if (cachedResult) {
             reporter.debug(`Filename: ${filename}, using cache`);
             return cachedResult;
         }
-        const fileInfo = await (0, fileHelper_1.readFileInfo)(filename);
-        const doc = (0, fileHelper_1.fileInfoToDocument)(fileInfo, cfg.options.languageId, cfg.locale);
-        const { text } = fileInfo;
-        reporter.debug(`Filename: ${filename}, LanguageIds: ${(_a = doc.languageId) !== null && _a !== void 0 ? _a : 'default'}`);
         const result = {
-            fileInfo,
+            fileInfo: {
+                filename,
+            },
             issues: [],
             processed: false,
             errors: 0,
             configErrors: 0,
             elapsedTimeMs: 0,
         };
+        const fileInfo = await (0, fileHelper_1.readFileInfo)(filename, undefined, true);
+        if (fileInfo.errorCode) {
+            if (fileInfo.errorCode !== 'EISDIR' && cfg.options.mustFindFiles) {
+                const err = (0, errors_1.toError)(`File not found: "${filename}"`);
+                reporter.error('Linter:', err);
+                result.errors += 1;
+            }
+            return result;
+        }
+        const doc = (0, fileHelper_1.fileInfoToDocument)(fileInfo, cfg.options.languageId, cfg.locale);
+        const { text } = fileInfo;
+        reporter.debug(`Filename: ${filename}, LanguageIds: ${(_a = doc.languageId) !== null && _a !== void 0 ? _a : 'default'}`);
+        result.fileInfo = fileInfo;
         const getElapsedTimeMs = (0, timer_1.getTimeMeasurer)();
         let spellResult = {};
         reporter.info(`Checking: ${filename}, File type: ${(_b = doc.languageId) !== null && _b !== void 0 ? _b : 'auto'}, Language: ${(_c = doc.locale) !== null && _c !== void 0 ? _c : 'default'}`, cspell_types_1.MessageTypes.Info);
@@ -86,7 +97,8 @@ async function runLint(cfg) {
         reporter.info(`Checked: ${filename}, File type: ${config.languageId}, Language: ${config.language} ... Issues: ${result.issues.length} ${elapsed}S`, cspell_types_1.MessageTypes.Info);
         reporter.info(`Config file Used: ${spellResult.localConfigFilepath || configInfo.source}`, cspell_types_1.MessageTypes.Info);
         reporter.info(`Dictionaries Used: ${dictionaries.join(', ')}`, cspell_types_1.MessageTypes.Info);
-        cache.setCachedLintResults(result, configInfo);
+        const dep = calcDependencies(config);
+        cache.setCachedLintResults(result, dep.files);
         return result;
     }
     function mapIssue({ doc: _, ...tdo }) {
@@ -95,9 +107,10 @@ async function runLint(cfg) {
             : { text: tdo.line.text.trimEnd(), offset: tdo.line.offset };
         return { ...tdo, context };
     }
-    async function processFiles(files, configInfo, fileCount) {
+    async function processFiles(files, configInfo, cacheSettings) {
+        const fileCount = files.length;
         const status = runResult();
-        const cache = (0, cache_1.createCache)({ ...cfg.options, root: cfg.root });
+        const cache = (0, cache_1.createCache)(cacheSettings);
         const emitProgress = (filename, fileNum, result) => reporter.progress({
             type: 'ProgressFileComplete',
             fileNum,
@@ -105,7 +118,7 @@ async function runLint(cfg) {
             filename,
             elapsedTimeMs: result === null || result === void 0 ? void 0 : result.elapsedTimeMs,
             processed: result === null || result === void 0 ? void 0 : result.processed,
-            numErrors: result === null || result === void 0 ? void 0 : result.issues.length,
+            numErrors: (result === null || result === void 0 ? void 0 : result.issues.length) || (result === null || result === void 0 ? void 0 : result.errors),
             cached: result === null || result === void 0 ? void 0 : result.cached,
         });
         async function* loadAndProcessFiles() {
@@ -117,12 +130,8 @@ async function runLint(cfg) {
         }
         for await (const fileP of loadAndProcessFiles()) {
             const { filename, fileNum, result } = await fileP;
-            if (!result.fileInfo.text === undefined) {
-                status.files += result.cached ? 1 : 0;
-                emitProgress(filename, fileNum, result);
-                continue;
-            }
             status.files += 1;
+            status.cachedFiles = (status.cachedFiles || 0) + (result.cached ? 1 : 0);
             emitProgress(filename, fileNum, result);
             // Show the spelling errors after emitting the progress.
             result.issues.filter(cfg.uniqueFilter).forEach((issue) => reporter.issue(issue));
@@ -136,6 +145,10 @@ async function runLint(cfg) {
         cache.reconcile();
         return status;
     }
+    function calcDependencies(config) {
+        const { configFiles, dictionaryFiles } = cspell.extractDependencies(config);
+        return { files: configFiles.concat(dictionaryFiles) };
+    }
     async function reportConfigurationErrors(config) {
         const errors = cspell.extractImportErrors(config);
         let count = 0;
@@ -212,12 +225,13 @@ async function runLint(cfg) {
             globOptions.dot = enableGlobDot;
         }
         try {
+            const cacheSettings = await (0, cache_1.calcCacheSettings)(configInfo.config, cfg.options, root);
             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 = filterFiles(filtered, globMatcher);
-            return await processFiles(files, configInfo, files.length);
+            return await processFiles(files, configInfo, cacheSettings);
         }
         catch (e) {
             const err = (0, errors_1.toApplicationError)(e);
@@ -300,8 +314,8 @@ function extractContext(tdo, contextRange) {
     return context;
 }
 function runResult(init = {}) {
-    const { files = 0, filesWithIssues = new Set(), issues = 0, errors = 0 } = init;
-    return { files, filesWithIssues, issues, errors };
+    const { files = 0, filesWithIssues = new Set(), issues = 0, errors = 0, cachedFiles = 0 } = init;
+    return { files, filesWithIssues, issues, errors, cachedFiles };
 }
 function yesNo(value) {
     return value ? 'Yes' : 'No';

package/dist/options.d.ts

@@ -54,15 +54,31 @@ export interface LinterOptions extends BaseOptions, CacheOptions {
      * - an entry of `stdin` means to read the file list from **`stdin`**
      */
     fileLists?: string[] | undefined;
+    /**
+     * Files must be found and processed otherwise it is considered an error.
+     */
+    mustFindFiles?: boolean;
 }
 export interface TraceOptions extends BaseOptions {
     allowCompoundWords?: boolean;
     ignoreCase?: boolean;
 }
 export interface BaseOptions {
+    /**
+     * Path to configuration file.
+     */
     config?: string;
+    /**
+     * Programming Language ID.
+     */
     languageId?: string;
+    /**
+     * Locale to use.
+     */
     locale?: string;
+    /**
+     * @deprecated
+     */
     local?: string;
 }
 export interface LinterCliOptions extends Omit<LinterOptions, 'fileLists'> {

package/dist/util/cache/CSpellLintResultCache.d.ts

@@ -1,13 +1,13 @@
-import { ConfigInfo, FileResult } from '../../fileHelper';
+import { FileResult } from '../../fileHelper';
 export interface CSpellLintResultCache {
     /**
      * Retrieve cached lint results for a given file name, if present in the cache.
      */
-    getCachedLintResults(filename: string, configInfo: ConfigInfo): Promise<FileResult | undefined>;
+    getCachedLintResults(filename: string): Promise<FileResult | undefined>;
     /**
      * Set the cached lint results.
      */
-    setCachedLintResults(result: FileResult, configInfo: ConfigInfo): void;
+    setCachedLintResults(result: FileResult, dependsUponFiles: string[]): void;
     /**
      * Persists the in-memory cache to disk.
      */

package/dist/util/cache/CacheOptions.d.ts

@@ -1,3 +1,4 @@
+import type { CacheStrategy } from '@cspell/cspell-types';
 export interface CacheOptions {
     /**
      * Store the info about processed files in order to only operate on the changed ones.
@@ -12,6 +13,6 @@ export interface CacheOptions {
     /**
      * Strategy to use for detecting changed files, default: metadata
      */
-    cacheStrategy?: 'metadata' | 'content';
+    cacheStrategy?: CacheStrategy;
 }
 //# sourceMappingURL=CacheOptions.d.ts.map

package/dist/util/cache/DiskCache.d.ts

@@ -1,13 +1,34 @@
-import type { ConfigInfo, FileResult } from '../../fileHelper';
+import type { FileDescriptor } from 'file-entry-cache';
+import type { FileResult } from '../../fileHelper';
 import type { CSpellLintResultCache } from './CSpellLintResultCache';
+export declare type CachedFileResult = Omit<FileResult, 'fileInfo' | 'elapsedTimeMs'>;
+/**
+ * This is the data cached.
+ * Property names are short to help keep the cache file size small.
+ */
+interface CachedData {
+    /** results */
+    r: CachedFileResult;
+    /** dependencies */
+    d: string[];
+}
+interface CSpellCachedMetaData {
+    data?: CachedData;
+}
+export declare type CSpellCacheMeta = (FileDescriptor['meta'] & CSpellCachedMetaData) | undefined;
 /**
  * Caches cspell results on disk
  */
 export declare class DiskCache implements CSpellLintResultCache {
     private fileEntryCache;
+    private changedDependencies;
+    private knownDependencies;
     constructor(cacheFileLocation: string, useCheckSum: boolean);
-    getCachedLintResults(filename: string, configInfo: ConfigInfo): Promise<FileResult | undefined>;
-    setCachedLintResults({ fileInfo, elapsedTimeMs: _, ...result }: FileResult, configInfo: ConfigInfo): void;
+    getCachedLintResults(filename: string): Promise<FileResult | undefined>;
+    setCachedLintResults({ fileInfo, elapsedTimeMs: _, ...result }: FileResult, dependsUponFiles: string[]): void;
     reconcile(): void;
+    private cacheDependencies;
+    private checkDependencies;
 }
+export {};
 //# sourceMappingURL=DiskCache.d.ts.map

package/dist/util/cache/DiskCache.js

@@ -1,53 +1,95 @@
 "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.DiskCache = void 0;
-const file_entry_cache_1 = require("file-entry-cache");
+const fileEntryCache = __importStar(require("file-entry-cache"));
+const path_1 = require("path");
 const fileHelper_1 = require("../../fileHelper");
-const getConfigHash_1 = require("./getConfigHash");
 /**
  * Caches cspell results on disk
  */
 class DiskCache {
     constructor(cacheFileLocation, useCheckSum) {
-        this.fileEntryCache = (0, file_entry_cache_1.create)(cacheFileLocation, undefined, useCheckSum);
+        this.changedDependencies = new Set();
+        this.knownDependencies = new Set();
+        this.fileEntryCache = fileEntryCache.createFromFile((0, path_1.resolve)(cacheFileLocation), useCheckSum);
     }
-    async getCachedLintResults(filename, configInfo) {
+    async getCachedLintResults(filename) {
         const fileDescriptor = this.fileEntryCache.getFileDescriptor(filename);
         const meta = fileDescriptor.meta;
+        const data = meta === null || meta === void 0 ? void 0 : meta.data;
+        const result = data === null || data === void 0 ? void 0 : data.r;
         // Cached lint results are valid if and only if:
         // 1. The file is present in the filesystem
         // 2. The file has not changed since the time it was previously linted
         // 3. The CSpell configuration has not changed since the time the file was previously linted
         // If any of these are not true, we will not reuse the lint results.
-        if (fileDescriptor.notFound ||
-            fileDescriptor.changed ||
-            !meta ||
-            meta.configHash !== (0, getConfigHash_1.getConfigHash)(configInfo)) {
+        if (fileDescriptor.notFound || fileDescriptor.changed || !meta || !result || !this.checkDependencies(data.d)) {
             return undefined;
         }
         // Skip reading empty files and files without lint error
-        const hasErrors = meta.result.errors > 0 || meta.result.configErrors > 0 || meta.result.issues.length > 0;
-        const cached = !!meta.size;
+        const hasErrors = !!result && (result.errors > 0 || result.configErrors > 0 || result.issues.length > 0);
+        const cached = true;
         const shouldReadFile = cached && hasErrors;
         return {
-            ...meta.result,
+            ...result,
             elapsedTimeMs: undefined,
             fileInfo: shouldReadFile ? await (0, fileHelper_1.readFileInfo)(filename) : { filename },
             cached,
         };
     }
-    setCachedLintResults({ fileInfo, elapsedTimeMs: _, ...result }, configInfo) {
+    setCachedLintResults({ fileInfo, elapsedTimeMs: _, ...result }, dependsUponFiles) {
         const fileDescriptor = this.fileEntryCache.getFileDescriptor(fileInfo.filename);
         const meta = fileDescriptor.meta;
         if (fileDescriptor.notFound || !meta) {
             return;
         }
-        meta.result = result;
-        meta.configHash = (0, getConfigHash_1.getConfigHash)(configInfo);
+        const data = {
+            r: result,
+            d: dependsUponFiles,
+        };
+        meta.data = data;
+        this.cacheDependencies(dependsUponFiles);
     }
     reconcile() {
         this.fileEntryCache.reconcile();
     }
+    cacheDependencies(files) {
+        this.fileEntryCache.analyzeFiles(files);
+    }
+    checkDependencies(files) {
+        for (const file of files) {
+            if (this.changedDependencies.has(file)) {
+                return false;
+            }
+        }
+        const unknown = files.filter((f) => !this.knownDependencies.has(f));
+        if (!unknown.length) {
+            return true;
+        }
+        const { changedFiles, notFoundFiles } = this.fileEntryCache.analyzeFiles(files);
+        changedFiles.map((f) => this.changedDependencies.add(f));
+        unknown.forEach((f) => this.knownDependencies.add(f));
+        return changedFiles.length === 0 && notFoundFiles.length === 0;
+    }
 }
 exports.DiskCache = DiskCache;
 //# sourceMappingURL=DiskCache.js.map

package/dist/util/cache/createCache.d.ts

@@ -1,11 +1,11 @@
-import { CacheOptions } from './CacheOptions';
+import { CacheSettings, CSpellSettings } from '@cspell/cspell-types';
+import { CacheOptions } from '.';
 import { CSpellLintResultCache } from './CSpellLintResultCache';
 export declare const DEFAULT_CACHE_LOCATION = ".cspellcache";
-export interface CreateCacheOptions extends CacheOptions {
-    root: string;
-}
+export declare type CreateCacheSettings = Required<CacheSettings>;
 /**
  * Creates CSpellLintResultCache (disk cache if caching is enabled in config or dummy otherwise)
  */
-export declare function createCache(options: CreateCacheOptions): CSpellLintResultCache;
+export declare function createCache(options: CreateCacheSettings): CSpellLintResultCache;
+export declare function calcCacheSettings(config: CSpellSettings, cacheOptions: CacheOptions, root: string): Promise<CreateCacheSettings>;
 //# sourceMappingURL=createCache.d.ts.map

package/dist/util/cache/createCache.js

@@ -3,18 +3,47 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createCache = exports.DEFAULT_CACHE_LOCATION = void 0;
+exports.calcCacheSettings = exports.createCache = exports.DEFAULT_CACHE_LOCATION = void 0;
 const path_1 = __importDefault(require("path"));
 const DiskCache_1 = require("./DiskCache");
 const DummyCache_1 = require("./DummyCache");
+const fs_extra_1 = require("fs-extra");
+const errors_1 = require("../errors");
 // cspell:word cspellcache
 exports.DEFAULT_CACHE_LOCATION = '.cspellcache';
 /**
  * Creates CSpellLintResultCache (disk cache if caching is enabled in config or dummy otherwise)
  */
 function createCache(options) {
-    const { cache, cacheLocation = exports.DEFAULT_CACHE_LOCATION, cacheStrategy = 'metadata', root } = options;
-    return cache ? new DiskCache_1.DiskCache(path_1.default.resolve(root, cacheLocation), cacheStrategy === 'content') : new DummyCache_1.DummyCache();
+    const { useCache, cacheLocation, cacheStrategy } = options;
+    return useCache ? new DiskCache_1.DiskCache(path_1.default.resolve(cacheLocation), cacheStrategy === 'content') : new DummyCache_1.DummyCache();
 }
 exports.createCache = createCache;
+async function calcCacheSettings(config, cacheOptions, root) {
+    var _a, _b, _c, _d, _e, _f, _g;
+    const cs = (_a = config.cache) !== null && _a !== void 0 ? _a : {};
+    const useCache = (_c = (_b = cacheOptions.cache) !== null && _b !== void 0 ? _b : cs.useCache) !== null && _c !== void 0 ? _c : false;
+    const cacheLocation = await resolveCacheLocation(path_1.default.resolve(root, (_e = (_d = cacheOptions.cacheLocation) !== null && _d !== void 0 ? _d : cs.cacheLocation) !== null && _e !== void 0 ? _e : exports.DEFAULT_CACHE_LOCATION));
+    const cacheStrategy = (_g = (_f = cacheOptions.cacheStrategy) !== null && _f !== void 0 ? _f : cs.cacheStrategy) !== null && _g !== void 0 ? _g : 'metadata';
+    return {
+        useCache,
+        cacheLocation,
+        cacheStrategy,
+    };
+}
+exports.calcCacheSettings = calcCacheSettings;
+async function resolveCacheLocation(cacheLocation) {
+    try {
+        const s = await (0, fs_extra_1.stat)(cacheLocation);
+        if (s.isFile())
+            return cacheLocation;
+        return path_1.default.join(cacheLocation, exports.DEFAULT_CACHE_LOCATION);
+    }
+    catch (err) {
+        if ((0, errors_1.isError)(err) && err.code === 'ENOENT') {
+            return cacheLocation;
+        }
+        throw err;
+    }
+}
 //# sourceMappingURL=createCache.js.map

package/dist/util/cache/index.d.ts

@@ -1,5 +1,4 @@
-export { createCache, DEFAULT_CACHE_LOCATION } from './createCache';
-export type { CreateCacheOptions } from './createCache';
+export { createCache, calcCacheSettings, DEFAULT_CACHE_LOCATION, type CreateCacheSettings } from './createCache';
 export type { CSpellLintResultCache } from './CSpellLintResultCache';
 export type { CacheOptions } from './CacheOptions';
 //# sourceMappingURL=index.d.ts.map

package/dist/util/cache/index.js

@@ -1,7 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DEFAULT_CACHE_LOCATION = exports.createCache = void 0;
+exports.DEFAULT_CACHE_LOCATION = exports.calcCacheSettings = exports.createCache = void 0;
 var createCache_1 = require("./createCache");
 Object.defineProperty(exports, "createCache", { enumerable: true, get: function () { return createCache_1.createCache; } });
+Object.defineProperty(exports, "calcCacheSettings", { enumerable: true, get: function () { return createCache_1.calcCacheSettings; } });
 Object.defineProperty(exports, "DEFAULT_CACHE_LOCATION", { enumerable: true, get: function () { return createCache_1.DEFAULT_CACHE_LOCATION; } });
 //# sourceMappingURL=index.js.map

package/dist/util/errors.d.ts

@@ -7,7 +7,17 @@ export declare class ApplicationError extends Error {
     readonly cause?: Error | undefined;
     constructor(message: string, exitCode?: number, cause?: Error | undefined);
 }
-export declare function toError(e: unknown): Error;
-export declare function isError(e: unknown): e is Error;
+export declare class IOError extends ApplicationError {
+    readonly cause: NodeError;
+    constructor(message: string, cause: NodeError);
+    get code(): string | undefined;
+    isNotFound(): boolean;
+}
+export declare function toError(e: unknown): NodeError;
+export declare function isError(e: unknown): e is NodeError;
 export declare function toApplicationError(e: unknown, message?: string): ApplicationError;
+export interface NodeError extends Error {
+    code?: string;
+    toString?: () => string;
+}
 //# sourceMappingURL=errors.d.ts.map

package/dist/util/errors.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.toApplicationError = exports.isError = exports.toError = exports.ApplicationError = exports.CheckFailed = void 0;
+exports.toApplicationError = exports.isError = exports.toError = exports.IOError = exports.ApplicationError = exports.CheckFailed = void 0;
 const util_1 = require("util");
 class CheckFailed extends Error {
     constructor(message, exitCode = 1) {
@@ -17,12 +17,27 @@ class ApplicationError extends Error {
     }
 }
 exports.ApplicationError = ApplicationError;
+class IOError extends ApplicationError {
+    constructor(message, cause) {
+        super(message, undefined, cause);
+        this.cause = cause;
+    }
+    get code() {
+        return this.cause.code;
+    }
+    isNotFound() {
+        return this.cause.code === 'ENOENT';
+    }
+}
+exports.IOError = IOError;
 function toError(e) {
     if (isError(e))
         return e;
+    const message = (0, util_1.format)(e);
     return {
         name: 'error',
-        message: (0, util_1.format)(e),
+        message,
+        toString: () => message,
     };
 }
 exports.toError = toError;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cspell",
-  "version": "5.14.0",
+  "version": "5.15.3",
   "description": "A Spelling Checker for Code!",
   "funding": "https://github.com/streetsidesoftware/cspell?sponsor=1",
   "main": "dist/index.js",
@@ -72,9 +72,9 @@
     "chalk": "^4.1.2",
     "commander": "^8.3.0",
     "comment-json": "^4.1.1",
-    "cspell-gitignore": "^5.14.0",
-    "cspell-glob": "^5.14.0",
-    "cspell-lib": "^5.14.0",
+    "cspell-gitignore": "^5.15.3",
+    "cspell-glob": "^5.15.3",
+    "cspell-lib": "^5.15.3",
     "fast-json-stable-stringify": "^2.1.0",
     "file-entry-cache": "^6.0.1",
     "fs-extra": "^10.0.0",
@@ -89,8 +89,8 @@
     "node": ">=12.13.0"
   },
   "devDependencies": {
-    "@cspell/cspell-json-reporter": "^5.14.0",
-    "@cspell/cspell-types": "^5.14.0",
+    "@cspell/cspell-json-reporter": "^5.15.3",
+    "@cspell/cspell-types": "^5.15.3",
     "@types/file-entry-cache": "^5.0.2",
     "@types/fs-extra": "^9.0.13",
     "@types/glob": "^7.2.0",
@@ -98,10 +98,10 @@
     "@types/micromatch": "^4.0.2",
     "@types/minimatch": "^3.0.5",
     "@types/semver": "^7.3.9",
-    "jest": "^27.4.5",
+    "jest": "^27.4.7",
     "micromatch": "^4.0.4",
     "minimatch": "^3.0.4",
     "rimraf": "^3.0.2"
   },
-  "gitHead": "8c8dfb70479584839e8035094771762f77118667"
+  "gitHead": "8a7c55b7d0b340d3c4e964ba91390a405f2cda2d"
 }