cspell 5.10.0 → 5.11.1

package/dist/app.js

@@ -32,6 +32,7 @@ const table_1 = require("./util/table");
 const traceEmitter_1 = require("./traceEmitter");
 const cli_reporter_1 = require("./cli-reporter");
 const errors_1 = require("./util/errors");
+const cache_1 = require("./util/cache");
 var errors_2 = require("./util/errors");
 Object.defineProperty(exports, "CheckFailed", { enumerable: true, get: function () { return errors_2.CheckFailed; } });
 // interface InitOptions extends Options {}
@@ -71,6 +72,12 @@ async function run(program, argv) {
         // .option('--force', 'Force the exit value to always be 0')
         .option('--legacy', 'Legacy output')
         .option('--local <local>', 'Deprecated -- Use: --locale')
+        .option('--cache', 'Only check changed files', false)
+        .addOption(new commander.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)
         .addHelpText('after', usage)
         .arguments('[files...]')
         .action((files, options) => {

package/dist/cli-reporter.d.ts

@@ -1,4 +1,12 @@
-import type { CSpellReporter } from '@cspell/cspell-types';
+import type { CSpellReporter, Issue } from '@cspell/cspell-types';
 import { Options } from './app';
+export interface ReporterIssue extends Issue {
+    filename: string;
+}
 export declare function getReporter(options: Options): CSpellReporter;
+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/cli-reporter.js

@@ -19,15 +19,16 @@ var __importStar = (this && this.__importStar) || function (mod) {
     return result;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getReporter = void 0;
+exports.__testing__ = exports.getReporter = void 0;
 const chalk = require("chalk");
 const cspell_lib_1 = require("cspell-lib");
 const path = __importStar(require("path"));
-const templateIssue = `{green $uri}:{yellow $row:$col} - $message ({red $text})`;
-const templateIssueWithSuggestions = `{green $uri}:{yellow $row:$col} - $message ({red $text}) Suggestions: {yellow [$suggestions]}`;
-const templateIssueWithContext = `{green $uri}:{yellow $row:$col} $padRowCol- $message ({red $text})$padContext -- {gray $contextLeft}{red {underline $text}}{gray $contextRight}`;
-const templateIssueWithContextWithSuggestions = `{green $uri}:{yellow $row:$col} $padRowCol- $message ({red $text})$padContext -- {gray $contextLeft}{red {underline $text}}{gray $contextRight}\n\t Suggestions: {yellow [$suggestions]}`;
-const templateIssueLegacy = `${chalk.green('$uri')}[$row, $col]: $message: ${chalk.red('$text')}`;
+const vscode_uri_1 = require("vscode-uri");
+const templateIssue = `{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;
@@ -57,6 +58,13 @@ function relativeFilename(filename, cwd = process.cwd()) {
         return filename;
     return '.' + path.sep + rel;
 }
+function relativeUriFilename(uri, fsPathRoot) {
+    const fsPath = vscode_uri_1.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;
@@ -98,13 +106,15 @@ function getReporter(options) {
         var _a;
         (_a = emitters[msgType]) === null || _a === void 0 ? void 0 : _a.call(emitters, message);
     }
-    const root = options.root || process.cwd();
+    const root = vscode_uri_1.URI.file(options.root || process.cwd());
+    const fsPathRoot = root.fsPath;
     function relativeIssue(fn) {
-        if (!options.relative)
-            return fn;
+        const fnFilename = options.relative
+            ? (uri) => relativeUriFilename(uri, fsPathRoot)
+            : (uri) => vscode_uri_1.URI.parse(uri).fsPath;
         return (i) => {
-            const r = { ...i };
-            r.uri = r.uri ? relativeFilename(r.uri, root) : r.uri;
+            const filename = i.uri ? fnFilename(i.uri) : '';
+            const r = { ...i, filename };
             fn(r);
         };
     }
@@ -129,7 +139,7 @@ function formatIssue(templateStr, issue, maxIssueTextWidth) {
     function clean(t) {
         return t.replace(/\s+/, ' ');
     }
-    const { uri = '', row, col, text, context, offset } = issue;
+    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);
@@ -139,22 +149,21 @@ function formatIssue(templateStr, issue, maxIssueTextWidth) {
     const padRowCol = ' '.repeat(Math.max(1, 8 - (rowText.length + colText.length)));
     const suggestions = ((_a = issue.suggestions) === null || _a === void 0 ? void 0 : _a.join(', ')) || '';
     const message = issue.isFlagged ? '{yellow Forbidden word}' : 'Unknown word';
+    const substitutions = {
+        $col: colText,
+        $contextFull: contextFull,
+        $contextLeft: contextLeft,
+        $contextRight: contextRight,
+        $filename: filename,
+        $padContext: padContext,
+        $padRowCol: padRowCol,
+        $row: rowText,
+        $suggestions: suggestions,
+        $text: text,
+        $uri: uri,
+    };
     const t = template(templateStr.replace(/\$message/g, message));
-    return chalk(t)
-        .replace(/\$\{col\}/g, colText)
-        .replace(/\$\{row\}/g, rowText)
-        .replace(/\$\{text\}/g, text)
-        .replace(/\$\{uri\}/g, uri)
-        .replace(/\$col/g, colText)
-        .replace(/\$contextFull/g, contextFull)
-        .replace(/\$contextLeft/g, contextLeft)
-        .replace(/\$contextRight/g, contextRight)
-        .replace(/\$padContext/g, padContext)
-        .replace(/\$padRowCol/g, padRowCol)
-        .replace(/\$row/g, rowText)
-        .replace(/\$suggestions/g, suggestions)
-        .replace(/\$text/g, text)
-        .replace(/\$uri/g, uri);
+    return substitute(chalk(t), substitutions);
 }
 class TS extends Array {
     constructor(s) {
@@ -165,4 +174,26 @@ class TS extends Array {
 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);
+}
+exports.__testing__ = {
+    formatIssue,
+};
 //# sourceMappingURL=cli-reporter.js.map

package/dist/fileHelper.d.ts

@@ -1,5 +1,5 @@
 import { GlobOptions } from './util/glob';
-import { CSpellUserSettings, Document } from 'cspell-lib';
+import { CSpellUserSettings, Document, Issue } from 'cspell-lib';
 export interface ConfigInfo {
     source: string;
     config: CSpellUserSettings;
@@ -13,10 +13,18 @@ export interface FileConfigInfo {
 export declare function readConfig(configFile: string | undefined, root: string | undefined): Promise<ConfigInfo>;
 export interface FileInfo {
     filename: string;
-    text: string;
+    text?: string;
+}
+export interface FileResult {
+    fileInfo: FileInfo;
+    processed: boolean;
+    issues: Issue[];
+    errors: number;
+    configErrors: number;
+    elapsedTimeMs: number;
 }
 export declare function fileInfoToDocument(fileInfo: FileInfo, languageId: string | undefined, locale: string | undefined): Document;
-export declare function readFileInfo(filename: string, encoding?: string): Promise<FileInfo>;
+export declare function readFileInfo(filename: string, encoding?: string): Promise<Required<FileInfo>>;
 export declare function readFile(filename: string, encoding?: string): Promise<string>;
 /**
  * Looks for matching glob patterns or stdin

package/dist/lint.d.ts

@@ -1,13 +1,4 @@
-import type { Issue, RunResult } from '@cspell/cspell-types';
+import type { RunResult } from '@cspell/cspell-types';
 import { CSpellApplicationConfiguration } from './CSpellApplicationConfiguration';
-import { FileInfo } from './fileHelper';
-export interface FileResult {
-    fileInfo: FileInfo;
-    processed: boolean;
-    issues: Issue[];
-    errors: number;
-    configErrors: number;
-    elapsedTimeMs: number;
-}
 export declare function runLint(cfg: CSpellApplicationConfiguration): Promise<RunResult>;
 //# sourceMappingURL=lint.d.ts.map

package/dist/lint.js

@@ -27,6 +27,7 @@ const path = __importStar(require("path"));
 const util_1 = require("util");
 const vscode_uri_1 = require("vscode-uri");
 const fileHelper_1 = require("./fileHelper");
+const cache_1 = require("./util/cache");
 const errors_1 = require("./util/errors");
 const glob_1 = require("./util/glob");
 const reporters_1 = require("./util/reporters");
@@ -39,11 +40,17 @@ async function runLint(cfg) {
     const lintResult = await run();
     await reporter.result(lintResult);
     return lintResult;
-    async function processFile(fileInfo, configInfo) {
+    async function processFile(filename, configInfo, cache) {
         var _a, _b, _c, _d;
+        const cachedResult = await cache.getCachedLintResults(filename, configInfo);
+        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 { filename, text } = fileInfo;
-        reporter.debug(`Filename: ${fileInfo.filename}, LanguageIds: ${(_a = doc.languageId) !== null && _a !== void 0 ? _a : 'default'}`);
+        const { text } = fileInfo;
+        reporter.debug(`Filename: ${filename}, LanguageIds: ${(_a = doc.languageId) !== null && _a !== void 0 ? _a : 'default'}`);
         const result = {
             fileInfo,
             issues: [],
@@ -52,7 +59,7 @@ async function runLint(cfg) {
             configErrors: 0,
             elapsedTimeMs: 0,
         };
-        const startTime = Date.now();
+        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);
         try {
@@ -60,13 +67,13 @@ async function runLint(cfg) {
             const r = await cspell.spellCheckDocument(doc, validateOptions, configInfo.config);
             spellResult = r;
             result.processed = r.checked;
-            result.issues = cspell.Text.calculateTextDocumentOffsets(filename, text, r.issues).map(mapIssue);
+            result.issues = cspell.Text.calculateTextDocumentOffsets(doc.uri, text, r.issues).map(mapIssue);
         }
         catch (e) {
             reporter.error(`Failed to process "${filename}"`, (0, errors_1.toError)(e));
             result.errors += 1;
         }
-        result.elapsedTimeMs = Date.now() - startTime;
+        result.elapsedTimeMs = getElapsedTimeMs();
         const config = (_d = spellResult.settingsUsed) !== null && _d !== void 0 ? _d : {};
         result.configErrors += await reportConfigurationErrors(config);
         const debugCfg = { config: { ...config, source: null }, source: spellResult.localConfigFilepath };
@@ -76,59 +83,52 @@ 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);
         return result;
     }
-    function mapIssue(tdo) {
+    function mapIssue({ doc: _, ...tdo }) {
         const context = cfg.showContext
             ? extractContext(tdo, cfg.showContext)
             : { text: tdo.line.text.trimEnd(), offset: tdo.line.offset };
         return { ...tdo, context };
     }
-    /**
-     * The file loader is written this way to cause files to be loaded in parallel while the previous one is being processed.
-     * @param fileNames names of files to load one at a time.
-     */
-    function* fileLoader(fileNames) {
-        for (const filename of fileNames) {
-            const file = (0, fileHelper_1.readFileInfo)(filename);
-            yield file;
-        }
-    }
     async function processFiles(files, configInfo, fileCount) {
         const status = runResult();
-        let n = 0;
-        for (const fileP of files) {
-            ++n;
-            const fileNum = n;
-            const file = await fileP;
-            const emitProgress = (elapsedTimeMs, processed, numErrors) => reporter.progress({
-                type: 'ProgressFileComplete',
-                fileNum,
-                fileCount,
-                filename: file.filename,
-                elapsedTimeMs,
-                processed,
-                numErrors,
-            });
-            if (!file.text) {
-                emitProgress();
+        const cache = (0, cache_1.createCache)(cfg);
+        const emitProgress = (filename, fileNum, result) => reporter.progress({
+            type: 'ProgressFileComplete',
+            fileNum,
+            fileCount,
+            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,
+        });
+        async function* loadAndProcessFiles() {
+            for (let i = 0; i < files.length; i++) {
+                const filename = files[i];
+                const result = await processFile(filename, configInfo, cache);
+                yield { filename, fileNum: i + 1, result };
+            }
+        }
+        for await (const fileP of loadAndProcessFiles()) {
+            const { filename, fileNum, result } = await fileP;
+            if (!result.fileInfo.text) {
+                emitProgress(filename, fileNum);
                 continue;
             }
-            const p = processFile(file, configInfo);
-            const { elapsedTimeMs } = await (0, timer_1.measurePromise)(p);
-            const result = await p;
-            emitProgress(elapsedTimeMs, result.processed, result.issues.length);
+            emitProgress(filename, fileNum, result);
             // Show the spelling errors after emitting the progress.
             result.issues.filter(cfg.uniqueFilter).forEach((issue) => reporter.issue(issue));
-            const r = await p;
             status.files += 1;
-            if (r.issues.length || r.errors) {
-                status.filesWithIssues.add(file.filename);
-                status.issues += r.issues.length;
-                status.errors += r.errors;
+            if (result.issues.length || result.errors) {
+                status.filesWithIssues.add(filename);
+                status.issues += result.issues.length;
+                status.errors += result.errors;
             }
-            status.errors += r.configErrors;
+            status.errors += result.configErrors;
         }
+        cache.reconcile();
         return status;
     }
     async function reportConfigurationErrors(config) {
@@ -190,9 +190,10 @@ async function runLint(cfg) {
         const globsToExclude = (configInfo.config.ignorePaths || []).concat(excludeGlobs);
         const globMatcher = (0, glob_1.buildGlobMatcher)(globsToExclude, root, true);
         const ignoreGlobs = (0, glob_1.extractGlobsFromMatcher)(globMatcher);
-        const globOptions = { root, cwd: root, ignore: ignoreGlobs.concat(normalizedExcludes) };
+        // cspell:word nodir
+        const globOptions = { root, cwd: root, ignore: ignoreGlobs.concat(normalizedExcludes), nodir: true };
         const files = filterFiles(await (0, fileHelper_1.findFiles)(fileGlobs, globOptions), globMatcher);
-        return processFiles(fileLoader(files), configInfo, files.length);
+        return processFiles(files, configInfo, files.length);
     }
     function header(files, cliExcludes) {
         const formattedFiles = files.length > 100 ? files.slice(0, 100).concat(['...']) : files;

package/dist/options.d.ts

@@ -33,6 +33,20 @@ export interface CSpellApplicationOptions extends BaseOptions {
      * Show suggestions for spelling errors.
      */
     showSuggestions?: boolean;
+    /**
+     * Store the info about processed files in order to only operate on the changed ones.
+     */
+    cache?: boolean;
+    /**
+     * Path to the cache location. Can be a file or a directory.
+     * If none specified .cspellcache will be used.
+     * The file will be created in the directory where the cspell command is executed.
+     */
+    cacheLocation?: string;
+    /**
+     * Strategy to use for detecting changed files, default: metadata
+     */
+    cacheStrategy?: 'metadata' | 'content';
 }
 export declare type TraceOptions = BaseOptions;
 export interface BaseOptions {

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

@@ -0,0 +1,13 @@
+import type { ConfigInfo, FileResult } from '../../fileHelper';
+import { CSpellLintResultCache } from '.';
+/**
+ * Caches cspell results on disk
+ */
+export declare class DiskCache implements CSpellLintResultCache {
+    private fileEntryCache;
+    constructor(cacheFileLocation: string, useCheckSum: boolean);
+    getCachedLintResults(filename: string, configInfo: ConfigInfo): Promise<FileResult | undefined>;
+    setCachedLintResults({ fileInfo, elapsedTimeMs: _, ...result }: FileResult, configInfo: ConfigInfo): void;
+    reconcile(): void;
+}
+//# sourceMappingURL=DiskCache.d.ts.map

package/dist/util/cache/DiskCache.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DiskCache = void 0;
+const file_entry_cache_1 = require("file-entry-cache");
+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);
+    }
+    async getCachedLintResults(filename, configInfo) {
+        const fileDescriptor = this.fileEntryCache.getFileDescriptor(filename);
+        const meta = fileDescriptor.meta;
+        // 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)) {
+            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 shouldReadFile = meta.size !== 0 && hasErrors;
+        return {
+            ...meta.result,
+            elapsedTimeMs: 0,
+            fileInfo: shouldReadFile ? await (0, fileHelper_1.readFileInfo)(filename) : { filename },
+        };
+    }
+    setCachedLintResults({ fileInfo, elapsedTimeMs: _, ...result }, configInfo) {
+        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);
+    }
+    reconcile() {
+        this.fileEntryCache.reconcile();
+    }
+}
+exports.DiskCache = DiskCache;
+//# sourceMappingURL=DiskCache.js.map

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

@@ -0,0 +1,10 @@
+import type { CSpellLintResultCache } from '.';
+/**
+ * Dummy cache implementation that should be usd if caching option is disabled.
+ */
+export declare class DummyCache implements CSpellLintResultCache {
+    getCachedLintResults(): Promise<undefined>;
+    setCachedLintResults(): void;
+    reconcile(): void;
+}
+//# sourceMappingURL=DummyCache.d.ts.map

package/dist/util/cache/DummyCache.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DummyCache = void 0;
+/**
+ * Dummy cache implementation that should be usd if caching option is disabled.
+ */
+class DummyCache {
+    getCachedLintResults() {
+        return Promise.resolve(undefined);
+    }
+    setCachedLintResults() {
+        return;
+    }
+    reconcile() {
+        return;
+    }
+}
+exports.DummyCache = DummyCache;
+//# sourceMappingURL=DummyCache.js.map

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

@@ -0,0 +1,6 @@
+import { ConfigInfo } from '../../fileHelper';
+/**
+ * Hashes ConfigInfo and cspell version for using in DiskCache
+ */
+export declare function getConfigHash(configInfo: ConfigInfo): string;
+//# sourceMappingURL=getConfigHash.d.ts.map

package/dist/util/cache/getConfigHash.js

@@ -0,0 +1,26 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getConfigHash = void 0;
+const fast_json_stable_stringify_1 = __importDefault(require("fast-json-stable-stringify"));
+const path_1 = __importDefault(require("path"));
+const hash_1 = require("./hash");
+// eslint-disable-next-line @typescript-eslint/no-var-requires
+const { version } = require(path_1.default.join(__dirname, '..', '..', '..', 'package.json'));
+const configHashes = new WeakMap();
+/**
+ * Hashes ConfigInfo and cspell version for using in DiskCache
+ */
+function getConfigHash(configInfo) {
+    const cachedHash = configHashes.get(configInfo);
+    if (cachedHash !== undefined) {
+        return cachedHash;
+    }
+    const hashValue = (0, hash_1.hash)(`${version}_${(0, fast_json_stable_stringify_1.default)(configInfo)}`);
+    configHashes.set(configInfo, hashValue);
+    return hashValue;
+}
+exports.getConfigHash = getConfigHash;
+//# sourceMappingURL=getConfigHash.js.map

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

@@ -0,0 +1,5 @@
+/**
+ * Hash the given string using MurmurHash3
+ */
+export declare function hash(str: string): string;
+//# sourceMappingURL=hash.d.ts.map

package/dist/util/cache/hash.js

@@ -0,0 +1,16 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hash = void 0;
+// cspell:word imurmurhash
+const imurmurhash_1 = __importDefault(require("imurmurhash"));
+/**
+ * Hash the given string using MurmurHash3
+ */
+function hash(str) {
+    return (0, imurmurhash_1.default)(str).result().toString(36);
+}
+exports.hash = hash;
+//# sourceMappingURL=hash.js.map

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

@@ -0,0 +1,22 @@
+import type { CSpellApplicationConfiguration } from '../../CSpellApplicationConfiguration';
+import type { ConfigInfo, FileResult } from '../../fileHelper';
+export declare const DEFAULT_CACHE_LOCATION = ".cspellcache";
+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>;
+    /**
+     * Set the cached lint results.
+     */
+    setCachedLintResults(result: FileResult, configInfo: ConfigInfo): void;
+    /**
+     * Persists the in-memory cache to disk.
+     */
+    reconcile(): void;
+}
+/**
+ * Creates CSpellLintResultCache (disk cache if caching is enabled in config or dummy otherwise)
+ */
+export declare function createCache(cfg: CSpellApplicationConfiguration): CSpellLintResultCache;
+//# sourceMappingURL=index.d.ts.map

package/dist/util/cache/index.js

@@ -0,0 +1,20 @@
+"use strict";
+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;
+const path_1 = __importDefault(require("path"));
+const DummyCache_1 = require("./DummyCache");
+const DiskCache_1 = require("./DiskCache");
+// cspell:word cspellcache
+exports.DEFAULT_CACHE_LOCATION = '.cspellcache';
+/**
+ * Creates CSpellLintResultCache (disk cache if caching is enabled in config or dummy otherwise)
+ */
+function createCache(cfg) {
+    const { cache, cacheLocation = exports.DEFAULT_CACHE_LOCATION, cacheStrategy = 'metadata' } = cfg.options;
+    return cache ? new DiskCache_1.DiskCache(path_1.default.resolve(cfg.root, cacheLocation), cacheStrategy === 'content') : new DummyCache_1.DummyCache();
+}
+exports.createCache = createCache;
+//# sourceMappingURL=index.js.map

package/dist/util/glob.js

@@ -66,7 +66,7 @@ function _globP(pattern, state) {
             }
             resolve(matches);
         };
-        const options = state.glob ? { ...state.glob, ...state.options } : state.options;
+        const options = { ...(state.glob || {}), ...state.options };
         state.glob = (0, glob_1.default)(pattern, options, cb);
     });
 }

package/dist/util/timer.d.ts

@@ -2,7 +2,7 @@ export interface MeasurePromiseResult {
     elapsedTimeMs: number;
     success: boolean;
 }
-export declare function measurePromise<T>(p: Promise<T>): Promise<MeasurePromiseResult>;
+export declare function getTimeMeasurer(): () => number;
 export declare function elapsedTimeMsFrom(relativeTo: [number, number]): number;
 export declare function hrTimeToMs(hrTime: [number, number]): number;
 //# sourceMappingURL=timer.d.ts.map

package/dist/util/timer.js

@@ -1,22 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.hrTimeToMs = exports.elapsedTimeMsFrom = exports.measurePromise = void 0;
-async function measurePromise(p) {
+exports.hrTimeToMs = exports.elapsedTimeMsFrom = exports.getTimeMeasurer = void 0;
+function getTimeMeasurer() {
     const start = process.hrtime();
-    let success = true;
-    try {
-        await p;
-    }
-    catch (e) {
-        success = false;
-    }
-    const elapsedTimeMs = hrTimeToMs(process.hrtime(start));
-    return {
-        elapsedTimeMs,
-        success,
-    };
+    return () => hrTimeToMs(process.hrtime(start));
 }
-exports.measurePromise = measurePromise;
+exports.getTimeMeasurer = getTimeMeasurer;
 function elapsedTimeMsFrom(relativeTo) {
     return hrTimeToMs(process.hrtime(relativeTo));
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cspell",
-  "version": "5.10.0",
+  "version": "5.11.1",
   "description": "A Spelling Checker for Code!",
   "funding": "https://github.com/streetsidesoftware/cspell?sponsor=1",
   "main": "dist/index.js",
@@ -72,27 +72,32 @@
     "chalk": "^4.1.2",
     "commander": "^8.2.0",
     "comment-json": "^4.1.1",
-    "cspell-glob": "^5.10.0",
-    "cspell-lib": "^5.10.0",
+    "cspell-glob": "^5.11.1",
+    "cspell-lib": "^5.11.1",
+    "fast-json-stable-stringify": "^2.1.0",
+    "file-entry-cache": "^6.0.1",
     "fs-extra": "^10.0.0",
     "get-stdin": "^8.0.0",
-    "glob": "^7.1.7",
-    "strip-ansi": "^6.0.0",
+    "glob": "^7.2.0",
+    "imurmurhash": "^0.1.4",
+    "strip-ansi": "^6.0.1",
     "vscode-uri": "^3.0.2"
   },
   "engines": {
     "node": ">=12.13.0"
   },
   "devDependencies": {
-    "@cspell/cspell-types": "^5.10.0",
-    "@types/fs-extra": "^9.0.12",
+    "@cspell/cspell-types": "^5.11.1",
+    "@types/file-entry-cache": "^5.0.2",
+    "@types/fs-extra": "^9.0.13",
     "@types/glob": "^7.1.4",
+    "@types/imurmurhash": "^0.1.1",
     "@types/micromatch": "^4.0.2",
     "@types/minimatch": "^3.0.5",
-    "jest": "^27.2.0",
+    "jest": "^27.2.3",
     "micromatch": "^4.0.4",
     "minimatch": "^3.0.4",
     "rimraf": "^3.0.2"
   },
-  "gitHead": "7112fa0160844fc206dcd7aa100c7c14abd49a27"
+  "gitHead": "ef2cd2332a126afba25f288d5a3d726db7b6ca90"
 }