cspell-lib 8.2.3 → 8.2.4

package/dist/esm/Settings/Controller/configLoader/configSearch.d.ts

@@ -10,6 +10,7 @@ export declare class ConfigSearch {
     private findUpConfigPath;
     private hasConfig;
     private createHasFileDirSearch;
+    private readDir;
     private createHasFileStatCheck;
     private hasConfigDir;
 }

package/dist/esm/Settings/Controller/configLoader/configSearch.js

@@ -74,17 +74,26 @@ export class ConfigSearch {
                 const parentInfo = await parentInfoP;
                 const name = urlBasename(dir).slice(0, -1);
                 const found = parentInfo.get(name);
-                if (!found?.isDirectory())
+                if (!found?.isDirectory() && !found?.isSymbolicLink())
                     return false;
             }
             const dirUrlHref = dir.href;
-            const dirInfo = await dirInfoCache.get(dirUrlHref, async () => new Map((await this.fs.readDirectory(dir).catch(() => [])).map((ent) => [ent.name, ent])));
+            const dirInfo = await dirInfoCache.get(dirUrlHref, async () => await this.readDir(dir));
             const name = urlBasename(filename);
             const found = dirInfo.get(name);
-            return !!found?.isFile();
+            return found?.isFile() || found?.isSymbolicLink() || false;
         };
         return hasFile;
     }
+    async readDir(dir) {
+        try {
+            const dirInfo = await this.fs.readDirectory(dir);
+            return new Map(dirInfo.map((ent) => [ent.name, ent]));
+        }
+        catch (e) {
+            return new Map();
+        }
+    }
     createHasFileStatCheck() {
         const hasFile = async (filename) => {
             const stat = await this.fs.stat(filename).catch(() => undefined);

package/dist/esm/Settings/DictionarySettings.js

@@ -1,7 +1,7 @@
 import { mapDictionaryInformationToWeightMap } from 'cspell-trie-lib';
 import * as path from 'path';
 import { isDictionaryDefinitionInlineInternal } from '../Models/CSpellSettingsInternalDef.js';
-import { AutoResolveWeakCache } from '../util/AutoResolve.js';
+import { createAutoResolveWeakWeakCache } from '../util/AutoResolve.js';
 import { resolveRelativeTo } from '../util/resolveFile.js';
 import { toFilePathOrHref } from '../util/url.js';
 import { clean } from '../util/util.js';
@@ -40,7 +40,7 @@ function fixDicPath(defPath, defFile) {
 export function mapDictDefsToInternal(defs, pathToSettingsFile) {
     return defs?.map((def) => mapDictDefToInternal(def, pathToSettingsFile));
 }
-const internalDefs = new AutoResolveWeakCache();
+const internalDefs = createAutoResolveWeakWeakCache();
 export function mapDictDefToInternal(def, pathToSettingsFile) {
     return internalDefs.get(def, (def) => _mapDictDefToInternal(def, pathToSettingsFile));
 }

package/dist/esm/SpellingDictionary/DictionaryController/DictionaryLoader.d.ts

@@ -8,7 +8,9 @@ export declare class DictionaryLoader {
     private inlineDictionaryCache;
     private dictionaryCacheByDef;
     private reader;
-    constructor(fs: VFileSystem);
+    /** The keepAliveCache is to hold onto the most recently loaded dictionaries. */
+    private keepAliveCache;
+    constructor(fs: VFileSystem, keepAliveSize?: number);
     loadDictionary(def: DictionaryDefinitionInternal): Promise<SpellingDictionary>;
     /**
      * Check to see if any of the cached dictionaries have changed. If one has changed, reload it.

package/dist/esm/SpellingDictionary/DictionaryController/DictionaryLoader.js

@@ -3,8 +3,9 @@ import { StrongWeakMap } from '@cspell/strong-weak-map';
 import { createFailedToLoadDictionary, createInlineSpellingDictionary, createSpellingDictionary, createSpellingDictionaryFromTrieFile, } from 'cspell-dictionary';
 import { compareStats, toFileURL, urlBasename } from 'cspell-io';
 import { isDictionaryDefinitionInlineInternal } from '../../Models/CSpellSettingsInternalDef.js';
-import { AutoResolveWeakCache } from '../../util/AutoResolve.js';
+import { AutoResolveWeakCache, AutoResolveWeakWeakCache } from '../../util/AutoResolve.js';
 import { toError } from '../../util/errors.js';
+import { SimpleCache } from '../../util/simpleCache.js';
 import { SpellingDictionaryLoadError } from '../SpellingDictionaryError.js';
 const MAX_AGE = 10000;
 const loaders = {
@@ -23,11 +24,14 @@ export class DictionaryLoader {
     fs;
     dictionaryCache = new StrongWeakMap();
     inlineDictionaryCache = new AutoResolveWeakCache();
-    dictionaryCacheByDef = new StrongWeakMap();
+    dictionaryCacheByDef = new AutoResolveWeakWeakCache();
     reader;
-    constructor(fs) {
+    /** The keepAliveCache is to hold onto the most recently loaded dictionaries. */
+    keepAliveCache;
+    constructor(fs, keepAliveSize = 10) {
         this.fs = fs;
         this.reader = toReader(fs);
+        this.keepAliveCache = new SimpleCache(keepAliveSize);
     }
     loadDictionary(def) {
         if (isDictionaryDefinitionInlineInternal(def)) {
@@ -39,6 +43,7 @@ export class DictionaryLoader {
         }
         const loadedEntry = this.loadEntry(def.path, def);
         this.setCacheEntry(key, loadedEntry, def);
+        this.keepAliveCache.set(def, loadedEntry);
         return loadedEntry.pending.then(([dictionary]) => dictionary);
     }
     /**
@@ -52,6 +57,7 @@ export class DictionaryLoader {
     getCacheEntry(def) {
         const defEntry = this.dictionaryCacheByDef.get(def);
         if (defEntry) {
+            this.keepAliveCache.get(def);
             return defEntry;
         }
         const key = this.calcKey(def);
@@ -59,6 +65,7 @@ export class DictionaryLoader {
         if (entry) {
             // replace old entry so it can be released.
             entry.options = def;
+            this.keepAliveCache.set(def, entry);
         }
         return { key, entry };
     }

package/dist/esm/textValidation/docValidator.d.ts

@@ -72,6 +72,21 @@ export declare class DocumentValidator {
     checkDocumentDirectives(forceCheck?: boolean): ValidationIssue[];
     get document(): TextDocument;
     updateDocumentText(text: string): Promise<void>;
+    /**
+     * Get the calculated ranges of text that should be included in the spell checking.
+     * @returns MatchRanges of text to include.
+     */
+    getCheckedTextRanges(): MatchRange[];
+    traceWord(word: string): {
+        word: string;
+        found: boolean;
+        foundWord: string | undefined;
+        forbidden: boolean;
+        noSuggest: boolean;
+        dictName: string;
+        dictSource: string;
+        errors: Error[] | undefined;
+    }[];
     private defaultParser;
     private _checkParsedText;
     private addPossibleError;

package/dist/esm/textValidation/docValidator.js

@@ -11,6 +11,7 @@ import { calcSuggestionAdjustedToToMatchCase } from '../suggestions.js';
 import { catchPromiseError, toError } from '../util/errors.js';
 import { AutoCache } from '../util/simpleCache.js';
 import { uriToFilePath } from '../util/Uri.js';
+import { toFilePathOrHref } from '../util/url.js';
 import { defaultMaxDuplicateProblems, defaultMaxNumberOfProblems } from './defaultConstants.js';
 import { determineTextDocumentSettings } from './determineTextDocumentSettings.js';
 import { textValidatorFactory } from './lineValidatorFactory.js';
@@ -237,6 +238,36 @@ export class DocumentValidator {
         updateTextDocument(this._document, [{ text }]);
         await this._updatePrep();
     }
+    /**
+     * Get the calculated ranges of text that should be included in the spell checking.
+     * @returns MatchRanges of text to include.
+     */
+    getCheckedTextRanges() {
+        assert(this._preparations, ERROR_NOT_PREPARED);
+        return this._preparations.includeRanges;
+    }
+    traceWord(word) {
+        assert(this._preparations, ERROR_NOT_PREPARED);
+        const dictCollection = this._preparations.dictionary;
+        const config = this._preparations.config;
+        const opts = {
+            ignoreCase: true,
+            allowCompoundWords: config.allowCompoundWords || false,
+        };
+        const trace = dictCollection.dictionaries
+            .map((dict) => ({ dict, findResult: dict.find(word, opts) }))
+            .map(({ dict, findResult }) => ({
+            word,
+            found: !!findResult?.found,
+            foundWord: findResult?.found || undefined,
+            forbidden: findResult?.forbidden || false,
+            noSuggest: findResult?.noSuggest || false,
+            dictName: dict.name,
+            dictSource: toFilePathOrHref(dict.source),
+            errors: normalizeErrors(dict.getErrors?.()),
+        }));
+        return trace;
+    }
     defaultParser() {
         return pipeSync(this.document.getLines(), opMap((line) => {
             const { text, offset } = line;
@@ -378,4 +409,7 @@ function recordPerfTime(timings, name) {
 function timePromise(timings, name, p) {
     return p.finally(recordPerfTime(timings, name));
 }
+function normalizeErrors(errors) {
+    return errors?.length ? errors : undefined;
+}
 //# sourceMappingURL=docValidator.js.map

package/dist/esm/trace.js

@@ -1,9 +1,9 @@
-import { fileURLToPath } from 'node:url';
 import { genSequence } from 'gensequence';
 import { toInternalSettings } from './Settings/CSpellSettingsServer.js';
 import { finalizeSettings, mergeSettings } from './Settings/index.js';
 import { calcSettingsForLanguageId } from './Settings/LanguageSettings.js';
 import { getDictionaryInternal, refreshDictionaryCache } from './SpellingDictionary/index.js';
+import { toFilePathOrHref } from './util/url.js';
 import * as util from './util/util.js';
 export async function traceWords(words, settings, options) {
     const results = await util.asyncIterableToArray(traceWordsAsync(words, settings, options));
@@ -64,9 +64,6 @@ export async function* traceWordsAsync(words, settings, options) {
     }
 }
 function dictSourceToFilename(source) {
-    if (source.startsWith('file:')) {
-        return fileURLToPath(source);
-    }
-    return source;
+    return toFilePathOrHref(source);
 }
 //# sourceMappingURL=trace.js.map

package/dist/esm/util/AutoResolve.d.ts

@@ -46,5 +46,20 @@ export declare class AutoResolveWeakCache<K extends object, V> implements IWeakM
     stats(): AutoResolveCacheStats;
 }
 export declare function createAutoResolveWeakCache<K extends object, V>(): AutoResolveWeakCache<K, V>;
+export declare class AutoResolveWeakWeakCache<K extends object, V extends object> implements IWeakMap<K, V> {
+    private _map;
+    private _stats;
+    get(k: K): V | undefined;
+    get(k: K, resolve: (k: K) => V): V;
+    get(k: K, resolve?: (k: K) => V): V | undefined;
+    get map(): WeakMap<K, WeakRef<V>>;
+    has(k: K): boolean;
+    set(k: K, v: V): this;
+    clear(): void;
+    delete(k: K): boolean;
+    dispose(): void;
+    stats(): AutoResolveCacheStats;
+}
+export declare function createAutoResolveWeakWeakCache<K extends object, V extends object>(): AutoResolveWeakWeakCache<K, V>;
 export {};
 //# sourceMappingURL=AutoResolve.d.ts.map

package/dist/esm/util/AutoResolve.js

@@ -116,4 +116,57 @@ export class AutoResolveWeakCache {
 export function createAutoResolveWeakCache() {
     return new AutoResolveWeakCache();
 }
+export class AutoResolveWeakWeakCache {
+    _map = new WeakMap();
+    _stats = new CacheStatsTracker();
+    get(k, resolve) {
+        const map = this._map;
+        const found = map.get(k);
+        const foundValue = found?.deref();
+        if (found !== undefined && foundValue) {
+            ++this._stats.hits;
+            return foundValue;
+        }
+        ++this._stats.misses;
+        if (!resolve) {
+            if (found) {
+                map.delete(k);
+            }
+            return undefined;
+        }
+        ++this._stats.resolved;
+        const value = resolve(k);
+        map.set(k, new WeakRef(value));
+        return value;
+    }
+    get map() {
+        return this._map;
+    }
+    has(k) {
+        return !!this._map.get(k)?.deref();
+    }
+    set(k, v) {
+        ++this._stats.sets;
+        this._map.set(k, new WeakRef(v));
+        return this;
+    }
+    clear() {
+        this._stats.clear();
+        this._map = new WeakMap();
+    }
+    delete(k) {
+        ++this._stats.deletes;
+        return this._map.delete(k);
+    }
+    dispose() {
+        ++this._stats.disposals;
+        this.clear();
+    }
+    stats() {
+        return this._stats.stats();
+    }
+}
+export function createAutoResolveWeakWeakCache() {
+    return new AutoResolveWeakWeakCache();
+}
 //# sourceMappingURL=AutoResolve.js.map

package/dist/esm/util/TextRange.d.ts

@@ -1,3 +1,7 @@
+/**
+ * A range of text in a document.
+ * The range is inclusive of the startPos and exclusive of the endPos.
+ */
 export interface MatchRange {
     startPos: number;
     endPos: number;

package/dist/esm/util/simpleCache.d.ts

@@ -34,6 +34,7 @@ export declare class SimpleCache<K, T> {
     has(key: K): boolean;
     get(key: K): T | undefined;
     set(key: K, value: T): void;
+    delete(key: K): boolean;
     private _set;
     private caches;
     private rotate;

package/dist/esm/util/simpleCache.js

@@ -103,6 +103,13 @@ export class SimpleCache {
     set(key, value) {
         this._set(key, { v: value });
     }
+    delete(key) {
+        let deleted = false;
+        for (const c of this.caches()) {
+            deleted = c.delete(key) || deleted;
+        }
+        return deleted;
+    }
     _set(key, entry) {
         if (this.L0.has(key)) {
             this.L0.set(key, entry);
@@ -117,9 +124,11 @@ export class SimpleCache {
         return [this.L0, this.L1, this.L2];
     }
     rotate() {
+        const L2 = this.L2;
         this.L2 = this.L1;
         this.L1 = this.L0;
-        this.L0 = new Map();
+        this.L0 = L2;
+        this.L0.clear();
     }
 }
 export class AutoCache extends SimpleCache {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cspell-lib",
-  "version": "8.2.3",
+  "version": "8.2.4",
   "description": "A library of useful functions used across various cspell tools.",
   "type": "module",
   "sideEffects": false,
@@ -57,21 +57,21 @@
   },
   "homepage": "https://github.com/streetsidesoftware/cspell#readme",
   "dependencies": {
-    "@cspell/cspell-bundled-dicts": "8.2.3",
-    "@cspell/cspell-pipe": "8.2.3",
-    "@cspell/cspell-resolver": "8.2.3",
-    "@cspell/cspell-types": "8.2.3",
-    "@cspell/dynamic-import": "8.2.3",
-    "@cspell/strong-weak-map": "8.2.3",
+    "@cspell/cspell-bundled-dicts": "8.2.4",
+    "@cspell/cspell-pipe": "8.2.4",
+    "@cspell/cspell-resolver": "8.2.4",
+    "@cspell/cspell-types": "8.2.4",
+    "@cspell/dynamic-import": "8.2.4",
+    "@cspell/strong-weak-map": "8.2.4",
     "clear-module": "^4.1.2",
     "comment-json": "^4.2.3",
     "configstore": "^6.0.0",
-    "cspell-config-lib": "8.2.3",
-    "cspell-dictionary": "8.2.3",
-    "cspell-glob": "8.2.3",
-    "cspell-grammar": "8.2.3",
-    "cspell-io": "8.2.3",
-    "cspell-trie-lib": "8.2.3",
+    "cspell-config-lib": "8.2.4",
+    "cspell-dictionary": "8.2.4",
+    "cspell-glob": "8.2.4",
+    "cspell-grammar": "8.2.4",
+    "cspell-io": "8.2.4",
+    "cspell-trie-lib": "8.2.4",
     "fast-equals": "^5.0.1",
     "gensequence": "^6.0.0",
     "import-fresh": "^3.3.0",
@@ -90,10 +90,10 @@
     "@cspell/dict-fr-fr": "^2.2.2",
     "@cspell/dict-html": "^4.0.5",
     "@cspell/dict-nl-nl": "^2.3.0",
-    "@cspell/dict-python": "^4.1.10",
+    "@cspell/dict-python": "^4.1.11",
     "@types/configstore": "^6.0.2",
     "cspell-dict-nl-nl": "^1.1.2",
     "lorem-ipsum": "^2.0.8"
   },
-  "gitHead": "e3098b21e0a199d61226f8ff4989d48b385eddfa"
+  "gitHead": "d3c5ff685b3aa2bf984f557d81380f2c994547e0"
 }