cspell-lib 6.6.1 → 6.7.0

package/dist/Settings/Controller/ImportError.d.ts

@@ -0,0 +1,11 @@
+export declare class ImportError extends Error {
+    readonly cause: Error | undefined;
+    constructor(msg: string, cause?: Error | unknown);
+}
+export declare class UnsupportedSchema extends Error {
+    constructor(msg: string);
+}
+export declare class UnsupportedPnpFile extends Error {
+    constructor(msg: string);
+}
+//# sourceMappingURL=ImportError.d.ts.map

package/dist/Settings/Controller/ImportError.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UnsupportedPnpFile = exports.UnsupportedSchema = exports.ImportError = void 0;
+const errors_1 = require("../../util/errors");
+class ImportError extends Error {
+    constructor(msg, cause) {
+        super(msg);
+        this.cause = (0, errors_1.isError)(cause) ? cause : undefined;
+    }
+}
+exports.ImportError = ImportError;
+class UnsupportedSchema extends Error {
+    constructor(msg) {
+        super(msg);
+    }
+}
+exports.UnsupportedSchema = UnsupportedSchema;
+class UnsupportedPnpFile extends Error {
+    constructor(msg) {
+        super(msg);
+    }
+}
+exports.UnsupportedPnpFile = UnsupportedPnpFile;
+//# sourceMappingURL=ImportError.js.map

package/dist/Settings/Controller/SettingsController.d.ts

@@ -0,0 +1,9 @@
+import { CSpellIO } from 'cspell-io';
+/**
+ * The settings controller manages requests to resolve configuration settings and files.
+ */
+export declare class SettingsController {
+    readonly cspellIO: CSpellIO;
+    constructor(cspellIO: CSpellIO);
+}
+//# sourceMappingURL=SettingsController.d.ts.map

package/dist/Settings/Controller/SettingsController.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SettingsController = void 0;
+/**
+ * The settings controller manages requests to resolve configuration settings and files.
+ */
+class SettingsController {
+    constructor(cspellIO) {
+        this.cspellIO = cspellIO;
+    }
+}
+exports.SettingsController = SettingsController;
+//# sourceMappingURL=SettingsController.js.map

package/dist/Settings/{configLoader.d.ts → Controller/configLoader.d.ts}

@@ -1,7 +1,7 @@
 import type { CSpellSettingsWithSourceTrace, CSpellUserSettings, ImportFileRef, PnPSettings as PnPSettingsStrict } from '@cspell/cspell-types';
 import { URI } from 'vscode-uri';
-import { CSpellSettingsInternal } from '../Models/CSpellSettingsInternalDef';
-import { OptionalOrUndefined } from '../util/types';
+import { CSpellSettingsInternal } from '../../Models/CSpellSettingsInternalDef';
+import { OptionalOrUndefined } from '../../util/types';
 import { LoaderResult } from './pnpLoader';
 declare type CSpellSettingsWST = CSpellSettingsWithSourceTrace;
 declare type CSpellSettingsI = CSpellSettingsInternal;

package/dist/Settings/{configLoader.js → Controller/configLoader.js}

@@ -28,13 +28,13 @@ const json = __importStar(require("comment-json"));
 const cosmiconfig_1 = require("cosmiconfig");
 const path = __importStar(require("path"));
 const vscode_uri_1 = require("vscode-uri");
-const CSpellSettingsInternalDef_1 = require("../Models/CSpellSettingsInternalDef");
-const logger_1 = require("../util/logger");
-const resolveFile_1 = require("../util/resolveFile");
-const util = __importStar(require("../util/util"));
-const CSpellSettingsServer_1 = require("./CSpellSettingsServer");
-const DictionarySettings_1 = require("./DictionarySettings");
-const GlobalSettings_1 = require("./GlobalSettings");
+const CSpellSettingsInternalDef_1 = require("../../Models/CSpellSettingsInternalDef");
+const logger_1 = require("../../util/logger");
+const resolveFile_1 = require("../../util/resolveFile");
+const util = __importStar(require("../../util/util"));
+const CSpellSettingsServer_1 = require("../CSpellSettingsServer");
+const DictionarySettings_1 = require("../DictionarySettings");
+const GlobalSettings_1 = require("../GlobalSettings");
 const ImportError_1 = require("./ImportError");
 const pnpLoader_1 = require("./pnpLoader");
 const supportedCSpellConfigVersions = [CSpellSettingsServer_1.configSettingsFileVersion0_2];

package/dist/Settings/Controller/index.d.ts

@@ -0,0 +1,2 @@
+export { SettingsController } from './SettingsController';
+//# sourceMappingURL=index.d.ts.map

package/dist/Settings/Controller/index.js

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

package/dist/Settings/{pnpLoader.d.ts → Controller/pnpLoader.d.ts}

@@ -28,11 +28,5 @@ export declare class PnpLoader {
     private calcKey;
 }
 export declare function pnpLoader(pnpFiles?: string[]): PnpLoader;
-export declare class UnsupportedSchema extends Error {
-    constructor(msg: string);
-}
-export declare class UnsupportedPnpFile extends Error {
-    constructor(msg: string);
-}
 export declare function clearPnPGlobalCache(): Promise<undefined>;
 //# sourceMappingURL=pnpLoader.d.ts.map

package/dist/Settings/{pnpLoader.js → Controller/pnpLoader.js}

@@ -3,7 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.clearPnPGlobalCache = exports.UnsupportedPnpFile = exports.UnsupportedSchema = exports.pnpLoader = exports.PnpLoader = void 0;
+exports.clearPnPGlobalCache = exports.pnpLoader = exports.PnpLoader = void 0;
 /**
  * Handles loading of `.pnp.js` and `.pnp.js` files.
  */
@@ -11,6 +11,7 @@ const vscode_uri_1 = require("vscode-uri");
 const import_fresh_1 = __importDefault(require("import-fresh"));
 const find_up_1 = __importDefault(require("find-up"));
 const clear_module_1 = __importDefault(require("clear-module"));
+const ImportError_1 = require("./ImportError");
 const defaultPnpFiles = ['.pnp.cjs', '.pnp.js'];
 const supportedSchemas = new Set(['file']);
 const cachedRequests = new Map();
@@ -28,6 +29,8 @@ class PnpLoader {
      * @returns promise - rejects on error - success if loaded or not found.
      */
     async load(uriDirectory) {
+        if (!supportedSchemas.has(uriDirectory.scheme))
+            return undefined;
         await lock;
         const cacheKey = this.calcKey(uriDirectory);
         const cached = cachedRequests.get(cacheKey);
@@ -40,6 +43,8 @@ class PnpLoader {
         return result;
     }
     async peek(uriDirectory) {
+        if (!supportedSchemas.has(uriDirectory.scheme))
+            return undefined;
         await lock;
         const cacheKey = this.calcKey(uriDirectory);
         return cachedRequests.get(cacheKey) ?? Promise.resolve(undefined);
@@ -50,6 +55,8 @@ class PnpLoader {
      * @returns promise - rejects on error - success if loaded or not found.
      */
     loadSync(uriDirectory) {
+        if (!supportedSchemas.has(uriDirectory.scheme))
+            return undefined;
         const cacheKey = this.calcKey(uriDirectory);
         const cached = cachedRequestsSync.get(cacheKey);
         if (cached)
@@ -60,6 +67,8 @@ class PnpLoader {
         return r;
     }
     peekSync(uriDirectory) {
+        if (!supportedSchemas.has(uriDirectory.scheme))
+            return undefined;
         const cacheKey = this.calcKey(uriDirectory);
         return cachedRequestsSync.get(cacheKey);
     }
@@ -78,23 +87,10 @@ function pnpLoader(pnpFiles) {
     return new PnpLoader(pnpFiles);
 }
 exports.pnpLoader = pnpLoader;
-class UnsupportedSchema extends Error {
-    constructor(msg) {
-        super(msg);
-    }
-}
-exports.UnsupportedSchema = UnsupportedSchema;
-class UnsupportedPnpFile extends Error {
-    constructor(msg) {
-        super(msg);
-    }
-}
-exports.UnsupportedPnpFile = UnsupportedPnpFile;
 /**
  * @param uriDirectory - directory to start at.
  */
 async function findPnpAndLoad(uriDirectory, pnpFiles) {
-    validateSchema(uriDirectory);
     const found = await (0, find_up_1.default)(pnpFiles, { cwd: uriDirectory.fsPath });
     return loadPnpIfNeeded(found);
 }
@@ -102,7 +98,6 @@ async function findPnpAndLoad(uriDirectory, pnpFiles) {
  * @param uriDirectory - directory to start at.
  */
 function findPnpAndLoadSync(uriDirectory, pnpFiles) {
-    validateSchema(uriDirectory);
     const found = find_up_1.default.sync(pnpFiles, { cwd: uriDirectory.fsPath });
     return loadPnpIfNeeded(found);
 }
@@ -122,13 +117,7 @@ function loadPnp(pnpFile) {
         pnp.setup();
         return vscode_uri_1.URI.file(pnpFile);
     }
-    throw new UnsupportedPnpFile(`Unsupported pnp file: "${pnpFile}"`);
-}
-function validateSchema(uri) {
-    if (!supportedSchemas.has(uri.scheme)) {
-        throw new UnsupportedSchema(`Unsupported schema for PNP: "${uri.scheme}"`);
-    }
-    return true;
+    throw new ImportError_1.UnsupportedPnpFile(`Unsupported pnp file: "${pnpFile}"`);
 }
 function clearPnPGlobalCache() {
     if (lock)

package/dist/Settings/DefaultSettings.js

@@ -28,7 +28,7 @@ const cspell_grammar_1 = require("cspell-grammar");
 const CSpellSettingsInternalDef_1 = require("../Models/CSpellSettingsInternalDef");
 const PatternRegExp_1 = require("../Models/PatternRegExp");
 const resolveFile_1 = require("../util/resolveFile");
-const configLoader_1 = require("./configLoader");
+const configLoader_1 = require("./Controller/configLoader");
 const index_1 = require("./index");
 const LanguageSettings = __importStar(require("./LanguageSettings"));
 const RegPat = __importStar(require("./RegExpPatterns"));

package/dist/Settings/index.d.ts

@@ -1,6 +1,6 @@
-export { clearCachedSettingsFiles, defaultConfigFilenames, defaultFileName, extractImportErrors, getCachedFileSize, getGlobalSettings, loadConfig, loadPnP, loadPnPSync, readRawSettings, readSettings, readSettingsFiles, searchForConfig, sectionCSpell, } from './configLoader';
+export { clearCachedSettingsFiles, defaultConfigFilenames, defaultFileName, extractImportErrors, getCachedFileSize, getGlobalSettings, loadConfig, loadPnP, loadPnPSync, readRawSettings, readSettings, readSettingsFiles, searchForConfig, sectionCSpell, } from './Controller/configLoader';
 export { calcOverrideSettings, checkFilenameMatchesGlob, currentSettingsFileVersion, ENV_CSPELL_GLOB_ROOT, extractDependencies, finalizeSettings, getSources, mergeInDocSettings, mergeSettings, } from './CSpellSettingsServer';
 export type { ConfigurationDependencies, ImportFileRefWithError } from './CSpellSettingsServer';
 export { getDefaultSettings, getDefaultBundledSettings } from './DefaultSettings';
-export { ImportError } from './ImportError';
+export { ImportError } from './Controller/ImportError';
 //# sourceMappingURL=index.d.ts.map

package/dist/Settings/index.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ImportError = exports.getDefaultBundledSettings = exports.getDefaultSettings = exports.mergeSettings = exports.mergeInDocSettings = exports.getSources = exports.finalizeSettings = exports.extractDependencies = exports.ENV_CSPELL_GLOB_ROOT = exports.currentSettingsFileVersion = exports.checkFilenameMatchesGlob = exports.calcOverrideSettings = exports.sectionCSpell = exports.searchForConfig = exports.readSettingsFiles = exports.readSettings = exports.readRawSettings = exports.loadPnPSync = exports.loadPnP = exports.loadConfig = exports.getGlobalSettings = exports.getCachedFileSize = exports.extractImportErrors = exports.defaultFileName = exports.defaultConfigFilenames = exports.clearCachedSettingsFiles = void 0;
-var configLoader_1 = require("./configLoader");
+var configLoader_1 = require("./Controller/configLoader");
 Object.defineProperty(exports, "clearCachedSettingsFiles", { enumerable: true, get: function () { return configLoader_1.clearCachedSettingsFiles; } });
 Object.defineProperty(exports, "defaultConfigFilenames", { enumerable: true, get: function () { return configLoader_1.defaultConfigFilenames; } });
 Object.defineProperty(exports, "defaultFileName", { enumerable: true, get: function () { return configLoader_1.defaultFileName; } });
@@ -29,6 +29,6 @@ Object.defineProperty(exports, "mergeSettings", { enumerable: true, get: functio
 var DefaultSettings_1 = require("./DefaultSettings");
 Object.defineProperty(exports, "getDefaultSettings", { enumerable: true, get: function () { return DefaultSettings_1.getDefaultSettings; } });
 Object.defineProperty(exports, "getDefaultBundledSettings", { enumerable: true, get: function () { return DefaultSettings_1.getDefaultBundledSettings; } });
-var ImportError_1 = require("./ImportError");
+var ImportError_1 = require("./Controller/ImportError");
 Object.defineProperty(exports, "ImportError", { enumerable: true, get: function () { return ImportError_1.ImportError; } });
 //# sourceMappingURL=index.js.map

package/dist/Settings/link.js

@@ -27,7 +27,7 @@ exports.__testing__ = exports.removePathsFromGlobalImports = exports.addPathsToG
 const fs = __importStar(require("fs"));
 const Path = __importStar(require("path"));
 const util_1 = require("../util/util");
-const configLoader_1 = require("./configLoader");
+const configLoader_1 = require("./Controller/configLoader");
 const GlobalSettings_1 = require("./GlobalSettings");
 function listGlobalImports() {
     const globalSettings = (0, GlobalSettings_1.getRawGlobalSettings)();

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

@@ -0,0 +1,30 @@
+import { CSpellIO } from 'cspell-io';
+import { DictionaryDefinitionInternal } from '../../Models/CSpellSettingsInternalDef';
+import { SpellingDictionary } from '../SpellingDictionary';
+export declare type LoadOptions = DictionaryDefinitionInternal;
+export declare class DictionaryLoader {
+    private cspellIO;
+    private dictionaryCache;
+    private dictionaryCacheByDef;
+    private reader;
+    private readerSync;
+    constructor(cspellIO: CSpellIO);
+    loadDictionary(def: DictionaryDefinitionInternal): Promise<SpellingDictionary>;
+    loadDictionarySync(def: DictionaryDefinitionInternal): SpellingDictionary;
+    /**
+     * Check to see if any of the cached dictionaries have changed. If one has changed, reload it.
+     * @param maxAge - Only check the dictionary if it has been at least `maxAge` ms since the last check.
+     * @param now - optional timestamp representing now. (Mostly used in testing)
+     */
+    refreshCacheEntries(maxAge?: number, now?: number): Promise<void>;
+    private getCacheEntry;
+    private setCacheEntry;
+    private refreshEntry;
+    private loadEntry;
+    private loadEntrySync;
+    private getStat;
+    private getStatSync;
+    private isEqual;
+    private normalizeOptions;
+}
+//# sourceMappingURL=DictionaryLoader.d.ts.map

package/dist/SpellingDictionary/DictionaryController/DictionaryLoader.js

@@ -0,0 +1,273 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DictionaryLoader = void 0;
+const cspell_pipe_1 = require("@cspell/cspell-pipe");
+const errors_1 = require("../../util/errors");
+const createSpellingDictionary_1 = require("../createSpellingDictionary");
+const SpellingDictionaryError_1 = require("../SpellingDictionaryError");
+const SpellingDictionaryFromTrie_1 = require("../SpellingDictionaryFromTrie");
+const MAX_AGE = 10000;
+const loaders = {
+    S: loadSimpleWordList,
+    C: legacyWordList,
+    W: wordsPerLineWordList,
+    T: loadTrie,
+    default: loadSimpleWordList,
+};
+const loadersSync = {
+    S: loadSimpleWordListSync,
+    C: legacyWordListSync,
+    W: wordsPerLineWordListSync,
+    T: loadTrieSync,
+    default: loadSimpleWordListSync,
+};
+var LoadingState;
+(function (LoadingState) {
+    LoadingState[LoadingState["Loaded"] = 0] = "Loaded";
+    LoadingState[LoadingState["Loading"] = 1] = "Loading";
+})(LoadingState || (LoadingState = {}));
+class DictionaryLoader {
+    constructor(cspellIO) {
+        this.cspellIO = cspellIO;
+        this.dictionaryCache = new Map();
+        this.dictionaryCacheByDef = new Map();
+        this.reader = toReader(cspellIO);
+        this.readerSync = toReaderSync(cspellIO);
+    }
+    loadDictionary(def) {
+        const { key, entry } = this.getCacheEntry(def);
+        if (entry) {
+            return entry.pending.then(([dictionary]) => dictionary);
+        }
+        const loadedEntry = this.loadEntry(def.path, def);
+        this.setCacheEntry(key, loadedEntry, def);
+        return loadedEntry.pending.then(([dictionary]) => dictionary);
+    }
+    loadDictionarySync(def) {
+        const { key, entry } = this.getCacheEntry(def);
+        if (entry?.dictionary && entry.loadingState === LoadingState.Loaded) {
+            return entry.dictionary;
+        }
+        const loadedEntry = this.loadEntrySync(def.path, def);
+        this.setCacheEntry(key, loadedEntry, def);
+        return loadedEntry.dictionary;
+    }
+    /**
+     * Check to see if any of the cached dictionaries have changed. If one has changed, reload it.
+     * @param maxAge - Only check the dictionary if it has been at least `maxAge` ms since the last check.
+     * @param now - optional timestamp representing now. (Mostly used in testing)
+     */
+    async refreshCacheEntries(maxAge = MAX_AGE, now = Date.now()) {
+        await Promise.all([...this.dictionaryCache.values()].map((entry) => this.refreshEntry(entry, maxAge, now)));
+    }
+    getCacheEntry(def) {
+        const defEntry = this.dictionaryCacheByDef.get(def);
+        if (defEntry) {
+            return defEntry;
+        }
+        const key = calcKey(def);
+        const entry = this.dictionaryCache.get(key);
+        if (entry) {
+            // replace old entry so it can be released.
+            entry.options = def;
+        }
+        return { key, entry };
+    }
+    setCacheEntry(key, entry, def) {
+        this.dictionaryCache.set(key, entry);
+        this.dictionaryCacheByDef.set(def, { key, entry });
+    }
+    async refreshEntry(entry, maxAge, now) {
+        if (now - entry.ts >= maxAge) {
+            const sig = now + Math.random();
+            // Write to the ts, so the next one will not do it.
+            entry.sig = sig;
+            entry.ts = now;
+            const pStat = this.getStat(entry.uri);
+            const [newStat] = await Promise.all([pStat, entry.pending]);
+            const hasChanged = !this.isEqual(newStat, entry.stat);
+            const sigMatches = entry.sig === sig;
+            if (sigMatches && hasChanged) {
+                entry.loadingState = LoadingState.Loading;
+                const key = calcKey(entry.options);
+                const newEntry = this.loadEntry(entry.uri, entry.options);
+                this.dictionaryCache.set(key, newEntry);
+                this.dictionaryCacheByDef.set(entry.options, { key, entry: newEntry });
+            }
+        }
+    }
+    loadEntry(uri, options, now = Date.now()) {
+        options = this.normalizeOptions(uri, options);
+        const pDictionary = load(this.reader, uri, options).catch((e) => (0, createSpellingDictionary_1.createFailedToLoadDictionary)(new SpellingDictionaryError_1.SpellingDictionaryLoadError(uri, options, e, 'failed to load')));
+        const pStat = this.getStat(uri);
+        const pending = Promise.all([pDictionary, pStat]);
+        const sig = now + Math.random();
+        const entry = {
+            uri,
+            options,
+            ts: now,
+            stat: undefined,
+            dictionary: undefined,
+            pending,
+            loadingState: LoadingState.Loading,
+            sig,
+        };
+        // eslint-disable-next-line promise/catch-or-return
+        pending.then(([dictionary, stat]) => {
+            entry.stat = stat;
+            entry.dictionary = dictionary;
+            entry.loadingState = LoadingState.Loaded;
+            return;
+        });
+        return entry;
+    }
+    loadEntrySync(uri, options, now = Date.now()) {
+        options = this.normalizeOptions(uri, options);
+        const stat = this.getStatSync(uri);
+        const sig = now + Math.random();
+        try {
+            const dictionary = loadSync(this.readerSync, uri, options);
+            const pending = Promise.resolve([dictionary, stat]);
+            return {
+                uri,
+                options,
+                ts: now,
+                stat,
+                dictionary,
+                pending,
+                loadingState: LoadingState.Loaded,
+                sig,
+            };
+        }
+        catch (e) {
+            const error = (0, errors_1.toError)(e);
+            const dictionary = (0, createSpellingDictionary_1.createFailedToLoadDictionary)(new SpellingDictionaryError_1.SpellingDictionaryLoadError(uri, options, error, 'failed to load'));
+            const pending = Promise.resolve([dictionary, stat]);
+            return {
+                uri,
+                options,
+                ts: now,
+                stat,
+                dictionary,
+                pending,
+                loadingState: LoadingState.Loaded,
+                sig,
+            };
+        }
+    }
+    getStat(uri) {
+        return this.cspellIO.getStat(uri).catch(errors_1.toError);
+    }
+    getStatSync(uri) {
+        try {
+            return this.cspellIO.getStatSync(uri);
+        }
+        catch (e) {
+            return (0, errors_1.toError)(e);
+        }
+    }
+    isEqual(a, b) {
+        if (!b)
+            return false;
+        if (isError(a)) {
+            return isError(b) && a.message === b.message && a.name === b.name;
+        }
+        return !isError(b) && !this.cspellIO.compareStats(a, b);
+    }
+    normalizeOptions(uri, options) {
+        if (options.name)
+            return options;
+        return { ...options, name: this.cspellIO.uriBasename(uri) };
+    }
+}
+exports.DictionaryLoader = DictionaryLoader;
+function toReader(cspellIO) {
+    return async function (filename) {
+        const res = await cspellIO.readFile(filename);
+        return res.content.split(/\n|\r\n|\r/);
+    };
+}
+function toReaderSync(cspellIO) {
+    return function (filename) {
+        const res = cspellIO.readFileSync(filename);
+        return res.content.split(/\n|\r\n|\r/);
+    };
+}
+const importantOptionKeys = ['name', 'noSuggest', 'useCompounds', 'type'];
+function calcKey(def) {
+    const path = def.path;
+    const loaderType = determineType(path, def);
+    const optValues = importantOptionKeys.map((k) => def[k]?.toString() || '');
+    const parts = [path, loaderType].concat(optValues);
+    return parts.join('|');
+}
+function isError(e) {
+    const err = e;
+    return !!err.message;
+}
+function determineType(uri, opts) {
+    const t = (opts.type && opts.type in loaders && opts.type) || 'S';
+    const defLoaderType = t;
+    const defType = uri.endsWith('.trie.gz') ? 'T' : defLoaderType;
+    const regTrieTest = /\.trie\b/i;
+    return regTrieTest.test(uri) ? 'T' : defType;
+}
+function load(reader, uri, options) {
+    const type = determineType(uri, options);
+    const loader = loaders[type] || loaders.default;
+    return loader(reader, uri, options);
+}
+function loadSync(reader, uri, options) {
+    const type = determineType(uri, options);
+    const loader = loadersSync[type] || loaders.default;
+    return loader(reader, uri, options);
+}
+async function legacyWordList(readLines, filename, options) {
+    const lines = await readLines(filename);
+    return _legacyWordListSync(lines, filename, options);
+}
+function legacyWordListSync(readLinesSync, filename, options) {
+    const lines = readLinesSync(filename);
+    return _legacyWordListSync(lines, filename, options);
+}
+function _legacyWordListSync(lines, filename, options) {
+    const words = (0, cspell_pipe_1.pipeSync)(lines, 
+    // Remove comments
+    (0, cspell_pipe_1.opMap)((line) => line.replace(/#.*/g, '')), 
+    // Split on everything else
+    (0, cspell_pipe_1.opConcatMap)((line) => line.split(/[^\w\p{L}\p{M}'’]+/gu)), (0, cspell_pipe_1.opFilter)((word) => !!word));
+    return (0, createSpellingDictionary_1.createSpellingDictionary)(words, options.name, filename, options);
+}
+async function wordsPerLineWordList(readLines, filename, options) {
+    const lines = await readLines(filename);
+    return _wordsPerLineWordList(lines, filename, options);
+}
+function wordsPerLineWordListSync(readLinesSync, filename, options) {
+    const lines = readLinesSync(filename);
+    return _wordsPerLineWordList(lines, filename, options);
+}
+function _wordsPerLineWordList(lines, filename, options) {
+    const words = (0, cspell_pipe_1.pipeSync)(lines, 
+    // Remove comments
+    (0, cspell_pipe_1.opMap)((line) => line.replace(/#.*/g, '')), 
+    // Split on everything else
+    (0, cspell_pipe_1.opConcatMap)((line) => line.split(/\s+/gu)), (0, cspell_pipe_1.opFilter)((word) => !!word));
+    return (0, createSpellingDictionary_1.createSpellingDictionary)(words, options.name, filename, options);
+}
+async function loadSimpleWordList(reader, filename, options) {
+    const lines = await reader(filename);
+    return (0, createSpellingDictionary_1.createSpellingDictionary)(lines, options.name, filename, options);
+}
+function loadSimpleWordListSync(readLinesSync, filename, options) {
+    const lines = readLinesSync(filename);
+    return (0, createSpellingDictionary_1.createSpellingDictionary)(lines, options.name, filename, options);
+}
+async function loadTrie(readLines, filename, options) {
+    const lines = await readLines(filename);
+    return (0, SpellingDictionaryFromTrie_1.createSpellingDictionaryTrie)(lines, options.name, filename, options);
+}
+function loadTrieSync(readLinesSync, filename, options) {
+    const lines = readLinesSync(filename);
+    return (0, SpellingDictionaryFromTrie_1.createSpellingDictionaryTrie)(lines, options.name, filename, options);
+}
+//# sourceMappingURL=DictionaryLoader.js.map

package/dist/SpellingDictionary/DictionaryController/index.d.ts

@@ -0,0 +1,2 @@
+export { DictionaryLoader, type LoadOptions } from './DictionaryLoader';
+//# sourceMappingURL=index.d.ts.map

package/dist/SpellingDictionary/DictionaryController/index.js

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

package/dist/SpellingDictionary/DictionaryLoader.d.ts

@@ -1,38 +1,9 @@
-import { Stats } from 'cspell-io';
+import { CSpellIO } from 'cspell-io';
 import { DictionaryDefinitionInternal } from '../Models/CSpellSettingsInternalDef';
+import { DictionaryLoader } from './DictionaryController';
 import { SpellingDictionary } from './SpellingDictionary';
-export declare type LoadOptions = DictionaryDefinitionInternal;
-declare enum LoadingState {
-    Loaded = 0,
-    Loading = 1
-}
-interface CacheEntry {
-    uri: string;
-    options: LoadOptions;
-    ts: number;
-    stat: Stats | Error | undefined;
-    dictionary: SpellingDictionary | undefined;
-    pending: Promise<readonly [SpellingDictionary, Stats | Error]>;
-    loadingState: LoadingState;
-    sig: number;
-}
-export declare type LoaderType = keyof Loaders;
-export declare type Loader = (filename: string, options: LoadOptions) => Promise<SpellingDictionary>;
-export declare type LoaderSync = (filename: string, options: LoadOptions) => SpellingDictionary;
-export interface Loaders {
-    S: Loader;
-    C: Loader;
-    T: Loader;
-    W: Loader;
-    default: Loader;
-}
-export interface SyncLoaders {
-    S: LoaderSync;
-    C: LoaderSync;
-    T: LoaderSync;
-    W: LoaderSync;
-    default: LoaderSync;
-}
+export type { LoadOptions } from './DictionaryController';
+export declare function getDictionaryLoader(cspellIO?: CSpellIO): DictionaryLoader;
 export declare function loadDictionary(def: DictionaryDefinitionInternal): Promise<SpellingDictionary>;
 export declare function loadDictionarySync(def: DictionaryDefinitionInternal): SpellingDictionary;
 /**
@@ -41,17 +12,4 @@ export declare function loadDictionarySync(def: DictionaryDefinitionInternal): S
  * @param now - optional timestamp representing now. (Mostly used in testing)
  */
 export declare function refreshCacheEntries(maxAge?: number, now?: number): Promise<void>;
-declare function refreshEntry(entry: CacheEntry, maxAge: number, now: number): Promise<void>;
-declare function loadEntry(uri: string, options: LoadOptions, now?: number): CacheEntry;
-declare function load(uri: string, options: LoadOptions): Promise<SpellingDictionary>;
-export declare const testing: {
-    dictionaryCache: Map<string, CacheEntry>;
-    refreshEntry: typeof refreshEntry;
-    loadEntry: typeof loadEntry;
-    load: typeof load;
-};
-export declare const __testing__: {
-    debugLog: string[];
-};
-export {};
 //# sourceMappingURL=DictionaryLoader.d.ts.map

package/dist/SpellingDictionary/DictionaryLoader.js

@@ -1,294 +1,30 @@
 "use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (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.__testing__ = exports.testing = exports.refreshCacheEntries = exports.loadDictionarySync = exports.loadDictionary = void 0;
-const cspell_io_1 = require("cspell-io");
-const gensequence_1 = require("gensequence");
-const path = __importStar(require("path"));
-const util_1 = require("util");
-const fileReader_1 = require("../util/fileReader");
-const createSpellingDictionary_1 = require("./createSpellingDictionary");
-const SpellingDictionaryError_1 = require("./SpellingDictionaryError");
-const SpellingDictionaryFromTrie_1 = require("./SpellingDictionaryFromTrie");
-const MAX_AGE = 10000;
-const loaders = {
-    S: loadSimpleWordList,
-    C: legacyWordList,
-    W: wordsPerLineWordList,
-    T: loadTrie,
-    default: loadSimpleWordList,
-};
-const loadersSync = {
-    S: loadSimpleWordListSync,
-    C: legacyWordListSync,
-    W: wordsPerLineWordListSync,
-    T: loadTrieSync,
-    default: loadSimpleWordListSync,
-};
-var LoadingState;
-(function (LoadingState) {
-    LoadingState[LoadingState["Loaded"] = 0] = "Loaded";
-    LoadingState[LoadingState["Loading"] = 1] = "Loading";
-})(LoadingState || (LoadingState = {}));
-const debugLog = [];
-const debugMode = false;
-function __log(msg) {
-    debugMode && debugLog.push(msg);
-}
-const dictionaryCache = new Map();
-const dictionaryCacheByDef = new Map();
-function getCacheEntry(def) {
-    const defEntry = dictionaryCacheByDef.get(def);
-    if (defEntry) {
-        return defEntry;
-    }
-    const key = calcKey(def);
-    const entry = dictionaryCache.get(key);
-    if (entry) {
-        // replace old entry so it can be released.
-        entry.options = def;
-    }
-    return { key, entry };
-}
-function setCacheEntry(key, entry, def) {
-    dictionaryCache.set(key, entry);
-    dictionaryCacheByDef.set(def, { key, entry });
-}
+exports.refreshCacheEntries = exports.loadDictionarySync = exports.loadDictionary = exports.getDictionaryLoader = void 0;
+const static_1 = require("../static");
+const DictionaryController_1 = require("./DictionaryController");
+let loader;
+function getDictionaryLoader(cspellIO) {
+    if (loader)
+        return loader;
+    return (loader = new DictionaryController_1.DictionaryLoader(cspellIO || (0, static_1.getCSpellIO)()));
+}
+exports.getDictionaryLoader = getDictionaryLoader;
 function loadDictionary(def) {
-    const { key, entry } = getCacheEntry(def);
-    if (entry) {
-        return entry.pending.then(([dictionary]) => dictionary);
-    }
-    const loadedEntry = loadEntry(def.path, def);
-    setCacheEntry(key, loadedEntry, def);
-    return loadedEntry.pending.then(([dictionary]) => dictionary);
+    return getDictionaryLoader().loadDictionary(def);
 }
 exports.loadDictionary = loadDictionary;
 function loadDictionarySync(def) {
-    const { key, entry } = getCacheEntry(def);
-    if (entry?.dictionary && entry.loadingState === LoadingState.Loaded) {
-        return entry.dictionary;
-    }
-    const loadedEntry = loadEntrySync(def.path, def);
-    setCacheEntry(key, loadedEntry, def);
-    return loadedEntry.dictionary;
+    return getDictionaryLoader().loadDictionarySync(def);
 }
 exports.loadDictionarySync = loadDictionarySync;
-const importantOptionKeys = ['name', 'noSuggest', 'useCompounds', 'type'];
-function calcKey(def) {
-    const path = def.path;
-    const loaderType = determineType(path, def);
-    const optValues = importantOptionKeys.map((k) => def[k]?.toString() || '');
-    const parts = [path, loaderType].concat(optValues);
-    return parts.join('|');
-}
 /**
  * Check to see if any of the cached dictionaries have changed. If one has changed, reload it.
  * @param maxAge - Only check the dictionary if it has been at least `maxAge` ms since the last check.
  * @param now - optional timestamp representing now. (Mostly used in testing)
  */
-async function refreshCacheEntries(maxAge = MAX_AGE, now = Date.now()) {
-    await Promise.all([...dictionaryCache.values()].map((entry) => refreshEntry(entry, maxAge, now)));
+async function refreshCacheEntries(maxAge, now) {
+    return getDictionaryLoader().refreshCacheEntries(maxAge, now);
 }
 exports.refreshCacheEntries = refreshCacheEntries;
-async function refreshEntry(entry, maxAge, now) {
-    if (now - entry.ts >= maxAge) {
-        const sig = now + Math.random();
-        // Write to the ts, so the next one will not do it.
-        entry.sig = sig;
-        entry.ts = now;
-        const pStat = (0, cspell_io_1.getStat)(entry.uri);
-        const [newStat] = await Promise.all([pStat, entry.pending]);
-        const hasChanged = !isEqual(newStat, entry.stat);
-        const sigMatches = entry.sig === sig;
-        // if (entry.options.name === 'temp') {
-        //     const processedAt = Date.now();
-        //     __log(
-        //         `Refresh ${entry.options.name}; sig: ${sig.toFixed(
-        //             2
-        //         )} at ${processedAt}; Sig Matches: ${sigMatches.toString()}; changed: ${hasChanged.toString()}; file: ${path.relative(
-        //             process.cwd(),
-        //             entry.uri
-        //         )}`
-        //     );
-        // }
-        if (sigMatches && hasChanged) {
-            entry.loadingState = LoadingState.Loading;
-            const key = calcKey(entry.options);
-            const newEntry = loadEntry(entry.uri, entry.options);
-            dictionaryCache.set(key, newEntry);
-            dictionaryCacheByDef.set(entry.options, { key, entry: newEntry });
-        }
-    }
-}
-function isEqual(a, b) {
-    if (!b)
-        return false;
-    if (isError(a)) {
-        return isError(b) && a.message === b.message && a.name === b.name;
-    }
-    return !isError(b) && a.mtimeMs === b.mtimeMs && a.size === b.size && a.eTag === b.eTag;
-}
-function isError(e) {
-    const err = e;
-    return !!err.message;
-}
-function loadEntry(uri, options, now = Date.now()) {
-    const pDictionary = load(uri, options).catch((e) => (0, createSpellingDictionary_1.createFailedToLoadDictionary)(new SpellingDictionaryError_1.SpellingDictionaryLoadError(uri, options, e, 'failed to load')));
-    const pStat = (0, cspell_io_1.getStat)(uri);
-    const pending = Promise.all([pDictionary, pStat]);
-    const sig = now + Math.random();
-    const entry = {
-        uri,
-        options,
-        ts: now,
-        stat: undefined,
-        dictionary: undefined,
-        pending,
-        loadingState: LoadingState.Loading,
-        sig,
-    };
-    // eslint-disable-next-line promise/catch-or-return
-    pending.then(([dictionary, stat]) => {
-        entry.stat = stat;
-        entry.dictionary = dictionary;
-        entry.loadingState = LoadingState.Loaded;
-        return;
-    });
-    return entry;
-}
-function loadEntrySync(uri, options, now = Date.now()) {
-    const stat = (0, cspell_io_1.getStatSync)(uri);
-    const sig = now + Math.random();
-    try {
-        const dictionary = loadSync(uri, options);
-        const pending = Promise.resolve([dictionary, stat]);
-        return {
-            uri,
-            options,
-            ts: now,
-            stat,
-            dictionary,
-            pending,
-            loadingState: LoadingState.Loaded,
-            sig,
-        };
-    }
-    catch (e) {
-        const error = e instanceof Error ? e : new Error((0, util_1.format)(e));
-        const dictionary = (0, createSpellingDictionary_1.createFailedToLoadDictionary)(new SpellingDictionaryError_1.SpellingDictionaryLoadError(uri, options, error, 'failed to load'));
-        const pending = Promise.resolve([dictionary, stat]);
-        return {
-            uri,
-            options,
-            ts: now,
-            stat,
-            dictionary,
-            pending,
-            loadingState: LoadingState.Loaded,
-            sig,
-        };
-    }
-}
-function determineType(uri, opts) {
-    const t = (opts.type && opts.type in loaders && opts.type) || 'S';
-    const defLoaderType = t;
-    const defType = uri.endsWith('.trie.gz') ? 'T' : defLoaderType;
-    const regTrieTest = /\.trie\b/i;
-    return regTrieTest.test(uri) ? 'T' : defType;
-}
-function load(uri, options) {
-    const type = determineType(uri, options);
-    const loader = loaders[type] || loaders.default;
-    return loader(uri, options);
-}
-function loadSync(uri, options) {
-    const type = determineType(uri, options);
-    const loader = loadersSync[type] || loaders.default;
-    return loader(uri, options);
-}
-async function legacyWordList(filename, options) {
-    const lines = await (0, fileReader_1.readLines)(filename);
-    return _legacyWordListSync(lines, filename, options);
-}
-function legacyWordListSync(filename, options) {
-    const lines = (0, fileReader_1.readLinesSync)(filename);
-    return _legacyWordListSync(lines, filename, options);
-}
-function _legacyWordListSync(lines, filename, options) {
-    const words = (0, gensequence_1.genSequence)(lines)
-        // Remove comments
-        .map((line) => line.replace(/#.*/g, ''))
-        // Split on everything else
-        .concatMap((line) => line.split(/[^\w\p{L}\p{M}'’]+/gu))
-        .filter((word) => !!word);
-    return (0, createSpellingDictionary_1.createSpellingDictionary)(words, determineName(filename, options), filename, options);
-}
-async function wordsPerLineWordList(filename, options) {
-    const lines = await (0, fileReader_1.readLines)(filename);
-    return _wordsPerLineWordList(lines, filename, options);
-}
-function wordsPerLineWordListSync(filename, options) {
-    const lines = (0, fileReader_1.readLinesSync)(filename);
-    return _wordsPerLineWordList(lines, filename, options);
-}
-function _wordsPerLineWordList(lines, filename, options) {
-    const words = (0, gensequence_1.genSequence)(lines)
-        // Remove comments
-        .map((line) => line.replace(/#.*/g, ''))
-        // Split on everything else
-        .concatMap((line) => line.split(/\s+/gu))
-        .filter((word) => !!word);
-    return (0, createSpellingDictionary_1.createSpellingDictionary)(words, determineName(filename, options), filename, options);
-}
-async function loadSimpleWordList(filename, options) {
-    const lines = await (0, fileReader_1.readLines)(filename);
-    return (0, createSpellingDictionary_1.createSpellingDictionary)(lines, determineName(filename, options), filename, options);
-}
-function loadSimpleWordListSync(filename, options) {
-    const lines = (0, fileReader_1.readLinesSync)(filename);
-    return (0, createSpellingDictionary_1.createSpellingDictionary)(lines, determineName(filename, options), filename, options);
-}
-async function loadTrie(filename, options) {
-    const lines = await (0, fileReader_1.readLines)(filename);
-    return (0, SpellingDictionaryFromTrie_1.createSpellingDictionaryTrie)(lines, determineName(filename, options), filename, options);
-}
-function loadTrieSync(filename, options) {
-    const lines = (0, fileReader_1.readLinesSync)(filename);
-    return (0, SpellingDictionaryFromTrie_1.createSpellingDictionaryTrie)(lines, determineName(filename, options), filename, options);
-}
-function determineName(filename, options) {
-    return options.name || path.basename(filename);
-}
-exports.testing = {
-    dictionaryCache,
-    refreshEntry,
-    loadEntry,
-    load,
-};
-exports.__testing__ = {
-    debugLog,
-};
 //# sourceMappingURL=DictionaryLoader.js.map

package/dist/static.d.ts

@@ -0,0 +1,3 @@
+import { CSpellIO } from 'cspell-io';
+export declare function getCSpellIO(): CSpellIO;
+//# sourceMappingURL=static.d.ts.map

package/dist/static.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getCSpellIO = void 0;
+const cspell_io_1 = require("cspell-io");
+const cspellIO = new cspell_io_1.CSpellIONode();
+function getCSpellIO() {
+    return cspellIO;
+}
+exports.getCSpellIO = getCSpellIO;
+//# sourceMappingURL=static.js.map

package/dist/textValidation/docValidator.js

@@ -9,7 +9,7 @@ const assert_1 = __importDefault(require("assert"));
 const cspell_glob_1 = require("cspell-glob");
 const TextDocument_1 = require("../Models/TextDocument");
 const Settings_1 = require("../Settings");
-const configLoader_1 = require("../Settings/configLoader");
+const configLoader_1 = require("../Settings/Controller/configLoader");
 const SpellingDictionary_1 = require("../SpellingDictionary");
 const errors_1 = require("../util/errors");
 const Memorizer_1 = require("../util/Memorizer");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cspell-lib",
-  "version": "6.6.1",
+  "version": "6.7.0",
   "description": "A library of useful functions used across various cspell tools.",
   "main": "dist/index.js",
   "typings": "dist/index.d.ts",
@@ -48,17 +48,17 @@
   },
   "homepage": "https://github.com/streetsidesoftware/cspell#readme",
   "dependencies": {
-    "@cspell/cspell-bundled-dicts": "^6.6.1",
-    "@cspell/cspell-pipe": "^6.6.1",
-    "@cspell/cspell-types": "^6.6.1",
+    "@cspell/cspell-bundled-dicts": "^6.7.0",
+    "@cspell/cspell-pipe": "^6.7.0",
+    "@cspell/cspell-types": "^6.7.0",
     "clear-module": "^4.1.2",
-    "comment-json": "^4.2.2",
+    "comment-json": "^4.2.3",
     "configstore": "^5.0.1",
     "cosmiconfig": "^7.0.1",
-    "cspell-glob": "^6.6.1",
-    "cspell-grammar": "^6.6.1",
-    "cspell-io": "^6.6.1",
-    "cspell-trie-lib": "^6.6.1",
+    "cspell-glob": "^6.7.0",
+    "cspell-grammar": "^6.7.0",
+    "cspell-io": "^6.7.0",
+    "cspell-trie-lib": "^6.7.0",
     "fast-equals": "^4.0.1",
     "find-up": "^5.0.0",
     "fs-extra": "^10.1.0",
@@ -83,15 +83,15 @@
     "@cspell/dict-python": "^2.0.6",
     "@types/configstore": "^5.0.1",
     "@types/fs-extra": "^9.0.13",
-    "@types/jest": "^28.1.6",
-    "@types/node": "^18.6.5",
+    "@types/jest": "^28.1.7",
+    "@types/node": "^18.7.6",
     "cspell-dict-nl-nl": "^1.1.2",
     "jest": "^28.1.3",
     "lorem-ipsum": "^2.0.8",
     "rimraf": "^3.0.2",
-    "rollup": "^2.77.2",
+    "rollup": "^2.78.0",
     "rollup-plugin-dts": "^4.2.2",
-    "ts-jest": "^28.0.7"
+    "ts-jest": "^28.0.8"
   },
-  "gitHead": "3c9c24d1cebd558ac3729d3fbf441e6ed751d8cf"
+  "gitHead": "3a7312a15d2df1507d9e01863ec5842f5a99e0cc"
 }

package/dist/Settings/ImportError.d.ts

@@ -1,5 +0,0 @@
-export declare class ImportError extends Error {
-    readonly cause: Error | undefined;
-    constructor(msg: string, cause?: Error | unknown);
-}
-//# sourceMappingURL=ImportError.d.ts.map

package/dist/Settings/ImportError.js

@@ -1,12 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ImportError = void 0;
-const errors_1 = require("../util/errors");
-class ImportError extends Error {
-    constructor(msg, cause) {
-        super(msg);
-        this.cause = (0, errors_1.isError)(cause) ? cause : undefined;
-    }
-}
-exports.ImportError = ImportError;
-//# sourceMappingURL=ImportError.js.map