cspell-lib 8.0.0 → 8.1.0

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

@@ -1,237 +1,266 @@
-import * as json from 'comment-json';
-import { cosmiconfig, cosmiconfigSync } from 'cosmiconfig';
+import assert from 'assert';
+import { createReaderWriter, CSpellConfigFileInMemory } from 'cspell-config-lib';
 import { getDefaultCSpellIO } from 'cspell-io';
 import * as path from 'path';
+import { fileURLToPath } from 'url';
+import { onClearCache } from '../../../events/index.js';
 import { createCSpellSettingsInternal as csi } from '../../../Models/CSpellSettingsInternalDef.js';
-import { AutoResolveLRUCache } from '../../../util/AutoResolveLRUCache.js';
+import { AutoResolveCache } from '../../../util/AutoResolve.js';
 import { logError, logWarning } from '../../../util/logger.js';
 import { resolveFile } from '../../../util/resolveFile.js';
-import { toUri } from '../../../util/Uri.js';
+import { cwdURL, toFilePathOrHref } from '../../../util/url.js';
 import { configSettingsFileVersion0_1, configSettingsFileVersion0_2, currentSettingsFileVersion, ENV_CSPELL_GLOB_ROOT, } from '../../constants.js';
 import { mergeSettings } from '../../CSpellSettingsServer.js';
-import { getRawGlobalSettings } from '../../GlobalSettings.js';
+import { getGlobalConfig } from '../../GlobalSettings.js';
 import { ImportError } from '../ImportError.js';
 import { pnpLoader } from '../pnpLoader.js';
+import { searchPlaces } from './configLocations.js';
+import { ConfigSearch } from './configSearch.js';
+import { configToRawSettings } from './configToRawSettings.js';
 import { defaultSettings } from './defaultSettings.js';
-import { normalizeCacheSettings, normalizeDictionaryDefs, normalizeGitignoreRoot, normalizeLanguageSettings, normalizeOverrides, normalizeRawConfig, normalizeReporters, normalizeSettingsGlobs, } from './normalizeRawSettings.js';
+import { normalizeCacheSettings, normalizeDictionaryDefs, normalizeGitignoreRoot, normalizeImport, normalizeLanguageSettings, normalizeOverrides, normalizeReporters, normalizeSettingsGlobs, } from './normalizeRawSettings.js';
 import { defaultPnPSettings, normalizePnPSettings } from './PnPSettings.js';
 const supportedCSpellConfigVersions = [configSettingsFileVersion0_2];
 const setOfSupportedConfigVersions = Object.freeze(new Set(supportedCSpellConfigVersions));
 export const sectionCSpell = 'cSpell';
 export const defaultFileName = 'cspell.json';
-const gcl = getDefaultConfigLoaderInternal;
-const CACHE_SIZE_SEARCH_CONFIG = 32;
-/**
- * Logic of the locations:
- * - Support backward compatibility with the VS Code Spell Checker
- *   the spell checker extension can only write to `.json` files because
- *   it would be too difficult to automatically modify a `.js` or `.cjs` file.
- * - To support `cspell.config.js` in a VS Code environment, have a `cspell.json` import
- *   the `cspell.config.js`.
- */
-const searchPlaces = Object.freeze([
-    'package.json',
-    // Original locations
-    '.cspell.json',
-    'cspell.json',
-    '.cSpell.json',
-    'cSpell.json',
-    // Original locations jsonc
-    '.cspell.jsonc',
-    'cspell.jsonc',
-    // Alternate locations
-    '.vscode/cspell.json',
-    '.vscode/cSpell.json',
-    '.vscode/.cspell.json',
-    // Standard Locations
-    '.cspell.config.json',
-    '.cspell.config.jsonc',
-    '.cspell.config.yaml',
-    '.cspell.config.yml',
-    'cspell.config.json',
-    'cspell.config.jsonc',
-    'cspell.config.yaml',
-    'cspell.config.yml',
-    '.cspell.yaml',
-    '.cspell.yml',
-    'cspell.yaml',
-    'cspell.yml',
-    // Dynamic config is looked for last
-    'cspell.config.js',
-    'cspell.config.cjs',
-    // .config
-    '.config/.cspell.json',
-    '.config/cspell.json',
-    '.config/.cSpell.json',
-    '.config/cSpell.json',
-    '.config/.cspell.jsonc',
-    '.config/cspell.jsonc',
-    '.config/cspell.config.json',
-    '.config/cspell.config.jsonc',
-    '.config/cspell.config.yaml',
-    '.config/cspell.config.yml',
-    '.config/cspell.yaml',
-    '.config/cspell.yml',
-    '.config/cspell.config.js',
-    '.config/cspell.config.cjs',
-]);
-const cspellCosmiconfig = {
-    searchPlaces: searchPlaces.concat(),
-    loaders: {
-        '.json': parseJson,
-        '.jsonc': parseJson,
-    },
-};
-function parseJson(_filename, content) {
-    return json.parse(content);
-}
-export const defaultConfigFilenames = Object.freeze(searchPlaces.concat());
 let defaultConfigLoader = undefined;
 export class ConfigLoader {
     cspellIO;
+    onReady;
     /**
      * Use `createConfigLoader`
      * @param cspellIO - CSpellIO interface for reading files.
      */
     constructor(cspellIO) {
         this.cspellIO = cspellIO;
+        this.cspellConfigFileReaderWriter = createReaderWriter(undefined, undefined, createIO(cspellIO));
+        this.onReady = this.getGlobalSettingsAsync().then(() => undefined, (e) => logError(e));
+        this.subscribeToEvents();
     }
-    cachedFiles = new Map();
-    cspellConfigExplorer = cosmiconfig('cspell', cspellCosmiconfig);
-    cspellConfigExplorerSync = cosmiconfigSync('cspell', cspellCosmiconfig);
-    globalSettings;
-    readSettings(filename, relativeToOrDefault, defaultValue) {
-        // console.log('Read Settings: %o', { filename, relativeToOrDefault });
-        const relativeTo = (typeof relativeToOrDefault === 'string' ? relativeToOrDefault : '') || process.cwd();
-        defaultValue = defaultValue || (typeof relativeToOrDefault !== 'string' ? relativeToOrDefault : undefined);
-        const ref = resolveFilename(filename, relativeTo);
-        return this.importSettings(ref, defaultValue, defaultValue || defaultPnPSettings);
+    subscribeToEvents() {
+        this.toDispose.push(onClearCache(() => this.clearCachedSettingsFiles()));
     }
+    cachedConfig = new Map();
+    cachedConfigFiles = new Map();
+    cachedPendingConfigFile = new AutoResolveCache();
+    cachedMergedConfig = new WeakMap();
+    globalSettings;
+    cspellConfigFileReaderWriter;
+    configSearch = new ConfigSearch(searchPlaces);
+    toDispose = [];
     async readSettingsAsync(filename, relativeTo, pnpSettings) {
         const ref = resolveFilename(filename, relativeTo || process.cwd());
-        return this.importSettings(ref, undefined, pnpSettings || defaultPnPSettings);
+        const entry = this.importSettings(ref, pnpSettings || defaultPnPSettings, []);
+        return entry.onReady;
+    }
+    async readConfigFile(filenameOrURL, relativeTo) {
+        const ref = resolveFilename(filenameOrURL.toString(), relativeTo || process.cwd());
+        const url = this.cspellIO.toFileURL(ref.filename);
+        const href = url.href;
+        if (ref.error)
+            return new ImportError(`Failed to read config file: "${ref.filename}"`, ref.error);
+        const cached = this.cachedConfigFiles.get(href);
+        if (cached)
+            return cached;
+        return this.cachedPendingConfigFile.get(href, async () => {
+            try {
+                const file = await this.cspellConfigFileReaderWriter.readConfig(href);
+                this.cachedConfigFiles.set(href, file);
+                // validateRawConfigVersion(file);
+                return file;
+            }
+            catch (error) {
+                // console.warn('Debug: %o', { href, error });
+                return new ImportError(`Failed to read config file: "${ref.filename}"`, error);
+            }
+            finally {
+                setTimeout(() => this.cachedPendingConfigFile.delete(href), 1);
+            }
+        });
+    }
+    searchForConfigFileLocation(searchFrom) {
+        const url = this.cspellIO.toFileURL(searchFrom || cwdURL());
+        return this.configSearch.searchForConfig(url);
+    }
+    async searchForConfigFile(searchFrom) {
+        const location = await this.searchForConfigFileLocation(searchFrom);
+        if (!location)
+            return undefined;
+        const file = await this.readConfigFile(location);
+        return file instanceof Error ? undefined : file;
     }
     /**
      *
-     * @param searchFrom the directory / file to start searching from.
+     * @param searchFrom the directory / file URL to start searching from.
      * @param pnpSettings - related to Using Yarn PNP.
      * @returns the resulting settings
      */
-    searchForConfig(searchFrom, pnpSettings = defaultPnPSettings) {
-        pnpSettings = normalizePnPSettings(pnpSettings);
-        return this.searchConfigLRU.get({ searchFrom, pnpSettings }, (p) => this._searchForConfig(p));
-    }
-    searchConfigLRU = new AutoResolveLRUCache(CACHE_SIZE_SEARCH_CONFIG, (a, b) => a.searchFrom === b.searchFrom && a.pnpSettings === b.pnpSettings);
-    _searchForConfig(params) {
-        // console.log('_searchForConfig: %o', { params, stats: this.searchConfigLRU.stats() });
-        return gcl()
-            .normalizeSearchForConfigResultAsync(params.searchFrom || process.cwd(), this.cspellConfigExplorer.search(params.searchFrom), params.pnpSettings)
-            .then((r) => (r.filepath ? r.config : undefined));
+    async searchForConfig(searchFrom, pnpSettings = defaultPnPSettings) {
+        const configFile = await this.searchForConfigFile(searchFrom);
+        if (!configFile)
+            return undefined;
+        return this.mergeConfigFileWithImports(configFile, pnpSettings);
     }
     getGlobalSettings() {
+        assert(this.globalSettings);
+        return this.globalSettings;
+    }
+    async getGlobalSettingsAsync() {
         if (!this.globalSettings) {
-            const globalConf = getRawGlobalSettings();
-            this.globalSettings = {
-                id: 'global_config',
-                ...this.normalizeSettings(globalConf || {}, './global_config', {}),
-            };
+            const globalConfFile = await getGlobalConfig();
+            const normalized = await this.mergeConfigFileWithImports(globalConfFile, undefined);
+            normalized.id ??= 'global_config';
+            this.globalSettings = normalized;
         }
         return this.globalSettings;
     }
     clearCachedSettingsFiles() {
-        this.searchConfigLRU.clear();
         this.globalSettings = undefined;
-        this.cachedFiles.clear();
-        this.cspellConfigExplorer.clearCaches();
-        this.cspellConfigExplorerSync.clearCaches();
+        this.cachedConfig.clear();
+        this.cachedConfigFiles.clear();
+        this.configSearch.clearCache();
+        this.cachedPendingConfigFile.clear();
+        this.cspellConfigFileReaderWriter.clearCachedFiles();
+        this.cachedMergedConfig = new WeakMap();
     }
-    /**
-     * Read a config file and inject the fileRef.
-     * @param fileRef - filename plus context, injected into the resulting config.
-     */
-    readConfig(fileRef) {
-        // cspellConfigExplorerSync
-        const { filename, error } = fileRef;
-        if (error) {
-            fileRef.error =
-                error instanceof ImportError
-                    ? error
-                    : new ImportError(`Failed to read config file: "${filename}"`, error);
-            return { __importRef: fileRef };
+    importSettings(fileRef, pnpSettings, backReferences) {
+        const url = this.cspellIO.toFileURL(fileRef.filename);
+        const cacheKey = url.href;
+        const cachedImport = this.cachedConfig.get(cacheKey);
+        if (cachedImport) {
+            backReferences.forEach((ref) => cachedImport.referencedSet.add(ref));
+            return cachedImport;
         }
-        const s = {};
-        try {
-            const r = this.cspellConfigExplorerSync.load(filename);
-            if (!r?.config)
-                throw new Error(`not found: "${filename}"`);
-            Object.assign(s, r.config);
-            normalizeRawConfig(s);
-            validateRawConfig(s, fileRef);
+        if (fileRef.error) {
+            const settings = csi({
+                __importRef: fileRef,
+                source: { name: fileRef.filename, filename: fileRef.filename },
+            });
+            const importedConfig = {
+                href: cacheKey,
+                fileRef,
+                configFile: undefined,
+                settings,
+                isReady: true,
+                onReady: Promise.resolve(settings),
+                onConfigFileReady: Promise.resolve(fileRef.error),
+                referencedSet: new Set(backReferences),
+            };
+            this.cachedConfig.set(cacheKey, importedConfig);
+            return importedConfig;
         }
-        catch (err) {
-            fileRef.error =
-                err instanceof ImportError ? err : new ImportError(`Failed to read config file: "${filename}"`, err);
+        const source = {
+            name: fileRef.filename,
+            filename: fileRef.filename,
+        };
+        const mergeImports = (cfgFile) => {
+            if (cfgFile instanceof Error) {
+                fileRef.error = cfgFile;
+                return csi({ __importRef: fileRef, source });
+            }
+            return this.mergeConfigFileWithImports(cfgFile, pnpSettings, backReferences);
+        };
+        const referencedSet = new Set(backReferences);
+        const onConfigFileReady = onConfigFileReadyFixUp(this.readConfigFile(fileRef.filename));
+        const importedConfig = {
+            href: cacheKey,
+            fileRef,
+            configFile: undefined,
+            settings: undefined,
+            isReady: false,
+            onReady: onReadyFixUp(onConfigFileReady.then(mergeImports)),
+            onConfigFileReady,
+            referencedSet,
+        };
+        this.cachedConfig.set(cacheKey, importedConfig);
+        return importedConfig;
+        async function onReadyFixUp(pSettings) {
+            const settings = await pSettings;
+            settings.source ??= source;
+            settings.__importRef ??= fileRef;
+            importedConfig.isReady = true;
+            importedConfig.settings = settings;
+            return settings;
+        }
+        async function onConfigFileReadyFixUp(pCfgFile) {
+            const cfgFile = await pCfgFile;
+            if (cfgFile instanceof Error) {
+                importedConfig.fileRef.error = cfgFile;
+                return cfgFile;
+            }
+            source.name = cfgFile.settings.name || source.name;
+            importedConfig.configFile = cfgFile;
+            return cfgFile;
         }
-        s.__importRef = fileRef;
-        return s;
     }
-    importSettings(fileRef, defaultValues, pnpSettings) {
-        defaultValues = defaultValues ?? defaultSettings;
-        const { filename } = fileRef;
-        const importRef = { ...fileRef };
-        const cached = this.cachedFiles.get(filename);
-        if (cached) {
-            const cachedImportRef = cached.__importRef || importRef;
-            cachedImportRef.referencedBy = mergeSourceList(cachedImportRef.referencedBy || [], importRef.referencedBy);
-            cached.__importRef = cachedImportRef;
-            return cached;
+    async setupPnp(cfgFile, pnpSettings) {
+        if (!pnpSettings?.usePnP || pnpSettings === defaultPnPSettings)
+            return;
+        if (cfgFile.url.protocol !== 'file:')
+            return;
+        // Try to load any .pnp files before reading dictionaries or other config files.
+        const { usePnP = pnpSettings.usePnP, pnpFiles = pnpSettings.pnpFiles } = cfgFile.settings;
+        const pnpSettingsToUse = normalizePnPSettings({ usePnP, pnpFiles });
+        const pathToSettingsDir = new URL('.', cfgFile.url);
+        await loadPnP(pnpSettingsToUse, pathToSettingsDir);
+    }
+    mergeConfigFileWithImports(cfgFile, pnpSettings, referencedBy) {
+        const cached = this.cachedMergedConfig.get(cfgFile);
+        if (cached && cached.pnpSettings === pnpSettings && cached.referencedBy === referencedBy) {
+            return cached.result;
         }
-        const id = [path.basename(path.dirname(filename)), path.basename(filename)].join('/');
-        const name = '';
-        const finalizeSettings = csi({ id, name, __importRef: importRef });
-        this.cachedFiles.set(filename, finalizeSettings); // add an empty entry to prevent circular references.
-        const settings = { ...defaultValues, id, name, ...this.readConfig(importRef) };
-        Object.assign(finalizeSettings, this.normalizeSettings(settings, filename, pnpSettings));
-        const finalizeSrc = { name: path.basename(filename), ...finalizeSettings.source };
-        finalizeSettings.source = { ...finalizeSrc, filename };
-        this.cachedFiles.set(filename, finalizeSettings);
-        return finalizeSettings;
+        // console.warn('missing cache %o', cfgFile.url.href);
+        const result = this._mergeConfigFileWithImports(cfgFile, pnpSettings, referencedBy);
+        this.cachedMergedConfig.set(cfgFile, { pnpSettings, referencedBy, result });
+        return result;
+    }
+    async _mergeConfigFileWithImports(cfgFile, pnpSettings, referencedBy = []) {
+        await this.setupPnp(cfgFile, pnpSettings);
+        const href = cfgFile.url.href;
+        const referencedSet = new Set(referencedBy);
+        const imports = normalizeImport(cfgFile.settings.import);
+        const __imports = imports.map((name) => resolveFilename(name, cfgFile.url));
+        const toImport = __imports.map((ref) => this.importSettings(ref, pnpSettings, [...referencedBy, href]));
+        // Add ourselves to the import sources.
+        toImport.forEach((entry) => {
+            entry.referencedSet.add(href);
+        });
+        const pendingImports = toImport.map((entry) => {
+            // Detect circular references, return raw settings if circular.
+            return referencedSet.has(entry.href)
+                ? entry.settings || configToRawSettings(entry.configFile)
+                : entry.onReady;
+        });
+        const importSettings = await Promise.all(pendingImports);
+        const cfg = this.mergeImports(cfgFile, importSettings);
+        return cfg;
     }
     /**
      * normalizeSettings handles correcting all relative paths, anchoring globs, and importing other config files.
      * @param rawSettings - raw configuration settings
      * @param pathToSettingsFile - path to the source file of the configuration settings.
      */
-    normalizeSettings(rawSettings, pathToSettingsFile, pnpSettings) {
-        const id = rawSettings.id ||
-            [path.basename(path.dirname(pathToSettingsFile)), path.basename(pathToSettingsFile)].join('/');
-        const name = rawSettings.name || id;
-        // Try to load any .pnp files before reading dictionaries or other config files.
-        const { usePnP = pnpSettings.usePnP, pnpFiles = pnpSettings.pnpFiles } = rawSettings;
-        const pnpSettingsToUse = normalizePnPSettings({ usePnP, pnpFiles });
-        const pathToSettingsDir = path.dirname(pathToSettingsFile);
-        loadPnPSync(pnpSettingsToUse, toUri(pathToSettingsDir));
+    mergeImports(cfgFile, importedSettings) {
+        const rawSettings = configToRawSettings(cfgFile);
+        const url = cfgFile.url;
+        const fileRef = rawSettings.__importRef;
+        const source = rawSettings.source;
+        assert(fileRef);
+        assert(source);
         // Fix up dictionaryDefinitions
         const settings = {
             version: defaultSettings.version,
             ...rawSettings,
-            id,
-            name,
-            globRoot: resolveGlobRoot(rawSettings, pathToSettingsFile),
+            globRoot: resolveGlobRoot(rawSettings, cfgFile.url),
             languageSettings: normalizeLanguageSettings(rawSettings.languageSettings),
         };
-        const pathToSettings = path.dirname(pathToSettingsFile);
-        const normalizedDictionaryDefs = normalizeDictionaryDefs(settings, pathToSettingsFile);
-        const normalizedSettingsGlobs = normalizeSettingsGlobs(settings, pathToSettingsFile);
-        const normalizedOverrides = normalizeOverrides(settings, pathToSettingsFile);
-        const normalizedReporters = normalizeReporters(settings, pathToSettingsFile);
-        const normalizedGitignoreRoot = normalizeGitignoreRoot(settings, pathToSettingsFile);
-        const normalizedCacheSettings = normalizeCacheSettings(settings, pathToSettingsDir);
-        const imports = typeof settings.import === 'string' ? [settings.import] : settings.import || [];
-        const source = settings.source || {
-            name: settings.name,
-            filename: pathToSettingsFile,
-        };
+        const normalizedDictionaryDefs = normalizeDictionaryDefs(settings, url);
+        const normalizedSettingsGlobs = normalizeSettingsGlobs(settings, url);
+        const normalizedOverrides = normalizeOverrides(settings, url);
+        const normalizedReporters = normalizeReporters(settings, url);
+        const normalizedGitignoreRoot = normalizeGitignoreRoot(settings, url);
+        const normalizedCacheSettings = normalizeCacheSettings(settings, url);
         const fileSettings = csi({
             ...settings,
             source,
@@ -242,132 +271,37 @@ export class ConfigLoader {
             ...normalizedGitignoreRoot,
             ...normalizedCacheSettings,
         });
-        if (!imports.length) {
+        if (!importedSettings.length) {
             return fileSettings;
         }
-        const importedSettings = imports
-            .map((name) => resolveFilename(name, pathToSettings))
-            .map((ref) => ((ref.referencedBy = [source]), ref))
-            .map((ref) => this.importSettings(ref, undefined, pnpSettingsToUse))
-            .reduce((a, b) => mergeSettings(a, b));
-        const finalizeSettings = mergeSettings(importedSettings, fileSettings);
+        const mergedImportedSettings = importedSettings.reduce((a, b) => mergeSettings(a, b));
+        const finalizeSettings = mergeSettings(mergedImportedSettings, fileSettings);
         finalizeSettings.name = settings.name || finalizeSettings.name || '';
         finalizeSettings.id = settings.id || finalizeSettings.id || '';
+        finalizeSettings.__importRef = fileRef;
         return finalizeSettings;
     }
-}
-class ConfigLoaderInternal extends ConfigLoader {
-    constructor(cspellIO) {
-        super(cspellIO);
-    }
-    get _cachedFiles() {
-        return this.cachedFiles;
-    }
-    get _cspellConfigExplorer() {
-        return this.cspellConfigExplorer;
-    }
-    get _cspellConfigExplorerSync() {
-        return this.cspellConfigExplorerSync;
-    }
-    _readConfig = this.readConfig.bind(this);
-    _normalizeSettings = this.normalizeSettings.bind(this);
-    async normalizeSearchForConfigResultAsync(searchPath, searchResult, pnpSettings) {
-        let result;
-        try {
-            result = (await searchResult) || undefined;
-        }
-        catch (cause) {
-            result = new ImportError(`Failed to find config file at: "${searchPath}"`, cause);
-        }
-        return this.normalizeSearchForConfigResult(searchPath, result, pnpSettings);
+    createCSpellConfigFile(filename, settings) {
+        return new CSpellConfigFileInMemory(this.cspellIO.toFileURL(filename), settings);
     }
-    normalizeSearchForConfigResult(searchPath, searchResult, pnpSettings) {
-        const error = searchResult instanceof ImportError ? searchResult : undefined;
-        const result = searchResult instanceof ImportError ? undefined : searchResult;
-        const filepath = result?.filepath;
-        if (filepath) {
-            const cached = cachedFiles().get(filepath);
-            if (cached) {
-                return {
-                    config: cached,
-                    filepath,
-                    error,
-                };
+    dispose() {
+        while (this.toDispose.length) {
+            try {
+                this.toDispose.pop()?.dispose();
+            }
+            catch (e) {
+                logError(e);
             }
-        }
-        const { config = csi({}) } = result || {};
-        const filename = result?.filepath ?? searchPath;
-        const importRef = { filename: filename, error };
-        const id = [path.basename(path.dirname(filename)), path.basename(filename)].join('/');
-        const name = result?.filepath ? id : `Config not found: ${id}`;
-        const finalizeSettings = csi({ id, name, __importRef: importRef });
-        const settings = { id, ...config };
-        cachedFiles().set(filename, finalizeSettings); // add an empty entry to prevent circular references.
-        Object.assign(finalizeSettings, this.normalizeSettings(settings, filename, pnpSettings));
-        return {
-            config: finalizeSettings,
-            filepath,
-            error,
-        };
-    }
-}
-function mergeSourceList(orig, append) {
-    const collection = new Map(orig.map((s) => [s.name + (s.filename || ''), s]));
-    for (const s of append || []) {
-        const key = s.name + (s.filename || '');
-        if (!collection.has(key)) {
-            collection.set(key, s);
         }
     }
-    return [...collection.values()];
 }
-/**
- *
- * @param searchFrom the directory / file to start searching from.
- * @param pnpSettings - related to Using Yarn PNP.
- * @returns the resulting settings
- */
-export function searchForConfig(searchFrom, pnpSettings = defaultPnPSettings) {
-    return gcl().searchForConfig(searchFrom, pnpSettings);
-}
-/**
- *
- * @param searchFrom the directory / file to start searching from.
- * @param pnpSettings - related to Using Yarn PNP.
- * @returns the resulting settings
- * @deprecated
- * @deprecationMessage Use `searchForConfig`. It is very difficult to support Sync files when settings include web requests.
- */
-export function searchForConfigSync(searchFrom, pnpSettings = defaultPnPSettings) {
-    pnpSettings = normalizePnPSettings(pnpSettings);
-    let searchResult;
-    try {
-        searchResult = cspellConfigExplorerSync().search(searchFrom) || undefined;
+class ConfigLoaderInternal extends ConfigLoader {
+    constructor(cspellIO) {
+        super(cspellIO);
     }
-    catch (err) {
-        searchResult = new ImportError(`Failed to find config file from: "${searchFrom}"`, err);
+    get _cachedFiles() {
+        return this.cachedConfig;
     }
-    return gcl().normalizeSearchForConfigResult(searchFrom || process.cwd(), searchResult, pnpSettings).config;
-}
-/**
- * Load a CSpell configuration files.
- * @param file - path or package reference to load.
- * @param pnpSettings - PnP settings
- * @returns normalized CSpellSettings
- */
-export async function loadConfig(file, pnpSettings = defaultPnPSettings) {
-    return gcl().readSettingsAsync(file, undefined, pnpSettings);
-}
-/**
- * Load a CSpell configuration files.
- * @param filename - path or package reference to load.
- * @param pnpSettings - PnP settings
- * @returns normalized CSpellSettings
- * @deprecated
- */
-export function loadConfigSync(filename, pnpSettings = defaultPnPSettings) {
-    const pnp = normalizePnPSettings(pnpSettings);
-    return gcl().readSettings(filename, pnp);
 }
 export function loadPnP(pnpSettings, searchFrom) {
     if (!pnpSettings.usePnP) {
@@ -376,39 +310,21 @@ export function loadPnP(pnpSettings, searchFrom) {
     const loader = pnpLoader(pnpSettings.pnpFiles);
     return loader.load(searchFrom);
 }
-export function loadPnPSync(pnpSettings, searchFrom) {
-    if (!pnpSettings.usePnP) {
-        return undefined;
-    }
-    const loader = pnpLoader(pnpSettings.pnpFiles);
-    return loader.loadSync(searchFrom);
-}
-export function readRawSettings(filename, relativeTo) {
-    relativeTo = relativeTo || process.cwd();
-    const ref = resolveFilename(filename, relativeTo);
-    return gcl()._readConfig(ref);
-}
 function resolveFilename(filename, relativeTo) {
+    if (filename instanceof URL)
+        return { filename: toFilePathOrHref(filename) };
     const r = resolveFile(filename, relativeTo);
     return {
-        filename: r.filename,
+        filename: r.filename.startsWith('file:/') ? fileURLToPath(r.filename) : r.filename,
         error: r.found ? undefined : new Error(`Failed to resolve file: "${filename}"`),
     };
 }
-export function getGlobalSettings() {
-    return gcl().getGlobalSettings();
-}
-export function getCachedFileSize() {
-    return cachedFiles().size;
-}
-export function clearCachedSettingsFiles() {
-    return gcl().clearCachedSettingsFiles();
-}
 const nestedConfigDirectories = {
     '.vscode': true,
     '.config': true,
 };
-function resolveGlobRoot(settings, pathToSettingsFile) {
+function resolveGlobRoot(settings, urlSettingsFile) {
+    const pathToSettingsFile = fileURLToPath(urlSettingsFile);
     const settingsFileDirRaw = path.dirname(pathToSettingsFile);
     const settingsFileDirName = path.basename(settingsFileDirRaw);
     const isNestedConfig = settingsFileDirName in nestedConfigDirectories;
@@ -425,36 +341,27 @@ function resolveGlobRoot(settings, pathToSettingsFile) {
     const globRoot = rawRoot.startsWith('${cwd}') ? rawRoot : path.resolve(settingsFileDir, rawRoot);
     return globRoot;
 }
-function validationMessage(msg, fileRef) {
-    return msg + `\n  File: "${fileRef.filename}"`;
+function validationMessage(msg, url) {
+    return msg + `\n  File: "${toFilePathOrHref(url)}"`;
 }
-function validateRawConfigVersion(config, fileRef) {
-    const { version } = config;
+function validateRawConfigVersion(config) {
+    const { version } = config.settings;
     if (version === undefined)
         return;
     if (typeof version !== 'string') {
-        logError(validationMessage(`Unsupported config file version: "${version}", string expected`, fileRef));
+        logError(validationMessage(`Unsupported config file version: "${version}", string expected`, config.url));
         return;
     }
     if (setOfSupportedConfigVersions.has(version))
         return;
     if (!/^\d+(\.\d+)*$/.test(version)) {
-        logError(validationMessage(`Unsupported config file version: "${version}"`, fileRef));
+        logError(validationMessage(`Unsupported config file version: "${version}"`, config.url));
         return;
     }
     const msg = version > currentSettingsFileVersion
         ? `Newer config file version found: "${version}". Supported version is "${currentSettingsFileVersion}"`
         : `Legacy config file version found: "${version}", upgrade to "${currentSettingsFileVersion}"`;
-    logWarning(validationMessage(msg, fileRef));
-}
-function validateRawConfigExports(config, fileRef) {
-    if (config.default) {
-        throw new ImportError(validationMessage('Module `export default` is not supported.\n  Use `module.exports =` instead.', fileRef));
-    }
-}
-function validateRawConfig(config, fileRef) {
-    const validations = [validateRawConfigExports, validateRawConfigVersion];
-    validations.forEach((fn) => fn(config, fileRef));
+    logWarning(validationMessage(msg, config.url));
 }
 function createConfigLoaderInternal(cspellIO) {
     return new ConfigLoaderInternal(cspellIO ?? getDefaultCSpellIO());
@@ -462,24 +369,22 @@ function createConfigLoaderInternal(cspellIO) {
 export function createConfigLoader(cspellIO) {
     return createConfigLoaderInternal(cspellIO);
 }
-function getDefaultConfigLoaderInternal() {
+export function getDefaultConfigLoaderInternal() {
     if (defaultConfigLoader)
         return defaultConfigLoader;
     return (defaultConfigLoader = createConfigLoaderInternal());
 }
-export function getDefaultConfigLoader() {
-    return getDefaultConfigLoaderInternal();
-}
-function cachedFiles() {
-    return gcl()._cachedFiles;
-}
-function cspellConfigExplorerSync() {
-    return gcl()._cspellConfigExplorerSync;
+function createIO(cspellIO) {
+    const readFile = (url) => cspellIO.readFile(url).then((file) => ({ url: file.url, content: file.getText() }));
+    const writeFile = (file) => cspellIO.writeFile(file.url, file.content);
+    return {
+        readFile,
+        writeFile,
+    };
 }
 export const __testing__ = {
     getDefaultConfigLoaderInternal,
     normalizeCacheSettings,
-    validateRawConfigExports,
     validateRawConfigVersion,
 };
 //# sourceMappingURL=configLoader.js.map