cspell-lib 8.1.2 → 8.2.0

package/dist/esm/Settings/CSpellSettingsServer.d.ts

@@ -4,6 +4,7 @@ import type { OptionalOrUndefined } from '../util/types.js';
 type CSpellSettingsWST = AdvancedCSpellSettingsWithSourceTrace;
 export type CSpellSettingsWSTO = OptionalOrUndefined<AdvancedCSpellSettingsWithSourceTrace>;
 export type CSpellSettingsI = CSpellSettingsInternal;
+export { stats as getMergeStats } from './mergeList.js';
 declare function mergeObjects(left: undefined, right: undefined): undefined;
 declare function mergeObjects<T>(left: T, right: undefined): T;
 declare function mergeObjects<T>(left: T, right: T): T;
@@ -35,5 +36,4 @@ export declare function extractDependencies(settings: CSpellSettingsWSTO | CSpel
 export declare const __testing__: {
     mergeObjects: typeof mergeObjects;
 };
-export {};
 //# sourceMappingURL=CSpellSettingsServer.d.ts.map

package/dist/esm/Settings/CSpellSettingsServer.js

@@ -9,6 +9,7 @@ import { configSettingsFileVersion0_1, ENV_CSPELL_GLOB_ROOT } from './constants.
 import { calcDictionaryDefsToLoad, mapDictDefsToInternal } from './DictionarySettings.js';
 import { mergeList, mergeListUnique } from './mergeList.js';
 import { resolvePatterns } from './patterns.js';
+export { stats as getMergeStats } from './mergeList.js';
 const emptyWords = [];
 Object.freeze(emptyWords);
 const cachedMerges = new AutoResolveWeakCache();

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

@@ -1,12 +1,13 @@
 import type { CSpellUserSettings, ImportFileRef } from '@cspell/cspell-types';
 import type { CSpellConfigFile, CSpellConfigFileReaderWriter } from 'cspell-config-lib';
-import type { CSpellIO } from 'cspell-io';
+import type { VFileSystem } from '../../../fileSystem.js';
 import { AutoResolveCache } from '../../../util/AutoResolve.js';
+import { FileResolver } from '../../../util/resolveFile.js';
 import type { LoaderResult } from '../pnpLoader.js';
 import { ConfigSearch } from './configSearch.js';
 import { normalizeCacheSettings } from './normalizeRawSettings.js';
 import type { PnPSettingsOptional } from './PnPSettings.js';
-import type { CSpellSettingsI } from './types.js';
+import type { CSpellSettingsI, CSpellSettingsWST } from './types.js';
 export declare const sectionCSpell = "cSpell";
 export declare const defaultFileName = "cspell.json";
 interface ImportedConfigEntry {
@@ -69,15 +70,18 @@ export interface IConfigLoader {
      * Unsubscribe from any events and dispose of any resources including caches.
      */
     dispose(): void;
+    getStats(): Readonly<Record<string, Readonly<Record<string, number>>>>;
 }
 export declare class ConfigLoader implements IConfigLoader {
-    readonly cspellIO: CSpellIO;
+    readonly fs: VFileSystem;
+    readonly templateVariables: Record<string, string>;
     onReady: Promise<void>;
+    readonly fileResolver: FileResolver;
     /**
      * Use `createConfigLoader`
-     * @param cspellIO - CSpellIO interface for reading files.
+     * @param virtualFs - virtual file system to use.
      */
-    protected constructor(cspellIO: CSpellIO);
+    protected constructor(fs: VFileSystem, templateVariables?: Record<string, string>);
     private subscribeToEvents;
     protected cachedConfig: Map<string, ImportedConfigEntry>;
     protected cachedConfigFiles: Map<string, CSpellConfigFile>;
@@ -113,22 +117,29 @@ export declare class ConfigLoader implements IConfigLoader {
      * @param rawSettings - raw configuration settings
      * @param pathToSettingsFile - path to the source file of the configuration settings.
      */
-    protected mergeImports(cfgFile: CSpellConfigFile, importedSettings: CSpellUserSettings[]): CSpellSettingsI;
+    protected mergeImports(cfgFile: CSpellConfigFile, importedSettings: CSpellUserSettings[]): Promise<CSpellSettingsI>;
     createCSpellConfigFile(filename: URL | string, settings: CSpellUserSettings): CSpellConfigFile;
     dispose(): void;
+    getStats(): {
+        cacheMergeListUnique: Readonly<import("../../../util/AutoResolve.js").CacheStats>;
+        cacheMergeLists: Readonly<import("../../../util/AutoResolve.js").CacheStats>;
+    };
+    private resolveFilename;
 }
 declare class ConfigLoaderInternal extends ConfigLoader {
-    constructor(cspellIO: CSpellIO);
+    constructor(vfs: VFileSystem);
     get _cachedFiles(): Map<string, ImportedConfigEntry>;
 }
 export declare function loadPnP(pnpSettings: PnPSettingsOptional, searchFrom: URL): Promise<LoaderResult>;
+declare function resolveGlobRoot(settings: CSpellSettingsWST, urlSettingsFile: URL): string;
 declare function validateRawConfigVersion(config: CSpellConfigFile): void;
-export declare function createConfigLoader(cspellIO?: CSpellIO): IConfigLoader;
+export declare function createConfigLoader(fs?: VFileSystem): IConfigLoader;
 export declare function getDefaultConfigLoaderInternal(): ConfigLoaderInternal;
 export declare const __testing__: {
     getDefaultConfigLoaderInternal: typeof getDefaultConfigLoaderInternal;
     normalizeCacheSettings: typeof normalizeCacheSettings;
     validateRawConfigVersion: typeof validateRawConfigVersion;
+    resolveGlobRoot: typeof resolveGlobRoot;
 };
 export {};
 //# sourceMappingURL=configLoader.d.ts.map

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

@@ -1,16 +1,19 @@
 import assert from 'assert';
 import { createReaderWriter, CSpellConfigFileInMemory } from 'cspell-config-lib';
-import { getDefaultCSpellIO } from 'cspell-io';
-import * as path from 'path';
+import { isUrlLike, toFileURL } from 'cspell-io';
+import path from 'path';
 import { fileURLToPath, pathToFileURL } from 'url';
+import { URI, Utils as UriUtils } from 'vscode-uri';
 import { onClearCache } from '../../../events/index.js';
+import { createTextFileResource, getVirtualFS } from '../../../fileSystem.js';
 import { createCSpellSettingsInternal as csi } from '../../../Models/CSpellSettingsInternalDef.js';
 import { AutoResolveCache } from '../../../util/AutoResolve.js';
 import { logError, logWarning } from '../../../util/logger.js';
-import { resolveFile } from '../../../util/resolveFile.js';
-import { cwdURL, toFilePathOrHref } from '../../../util/url.js';
+import { FileResolver } from '../../../util/resolveFile.js';
+import { envToTemplateVars } from '../../../util/templates.js';
+import { addTrailingSlash, cwdURL, resolveFileWithURL, toFilePathOrHref, windowsDriveLetterToUpper, } from '../../../util/url.js';
 import { configSettingsFileVersion0_1, configSettingsFileVersion0_2, currentSettingsFileVersion, ENV_CSPELL_GLOB_ROOT, } from '../../constants.js';
-import { mergeSettings } from '../../CSpellSettingsServer.js';
+import { getMergeStats, mergeSettings } from '../../CSpellSettingsServer.js';
 import { getGlobalConfig } from '../../GlobalSettings.js';
 import { ImportError } from '../ImportError.js';
 import { pnpLoader } from '../pnpLoader.js';
@@ -26,15 +29,20 @@ export const sectionCSpell = 'cSpell';
 export const defaultFileName = 'cspell.json';
 let defaultConfigLoader = undefined;
 export class ConfigLoader {
-    cspellIO;
+    fs;
+    templateVariables;
     onReady;
+    fileResolver;
     /**
      * Use `createConfigLoader`
-     * @param cspellIO - CSpellIO interface for reading files.
+     * @param virtualFs - virtual file system to use.
      */
-    constructor(cspellIO) {
-        this.cspellIO = cspellIO;
-        this.cspellConfigFileReaderWriter = createReaderWriter(undefined, undefined, createIO(cspellIO));
+    constructor(fs, templateVariables = envToTemplateVars(process.env)) {
+        this.fs = fs;
+        this.templateVariables = templateVariables;
+        this.configSearch = new ConfigSearch(searchPlaces, fs);
+        this.cspellConfigFileReaderWriter = createReaderWriter(undefined, undefined, createIO(fs));
+        this.fileResolver = new FileResolver(fs, this.templateVariables);
         this.onReady = this.prefetchGlobalSettingsAsync();
         this.subscribeToEvents();
     }
@@ -47,17 +55,17 @@ export class ConfigLoader {
     cachedMergedConfig = new WeakMap();
     globalSettings;
     cspellConfigFileReaderWriter;
-    configSearch = new ConfigSearch(searchPlaces);
+    configSearch;
     toDispose = [];
     async readSettingsAsync(filename, relativeTo, pnpSettings) {
         await this.onReady;
-        const ref = resolveFilename(filename, relativeTo || pathToFileURL('./'));
+        const ref = await this.resolveFilename(filename, relativeTo || pathToFileURL('./'));
         const entry = this.importSettings(ref, pnpSettings || defaultPnPSettings, []);
         return entry.onReady;
     }
     async readConfigFile(filenameOrURL, relativeTo) {
-        const ref = resolveFilename(filenameOrURL.toString(), relativeTo || pathToFileURL('./'));
-        const url = this.cspellIO.toFileURL(ref.filename);
+        const ref = await this.resolveFilename(filenameOrURL.toString(), relativeTo || pathToFileURL('./'));
+        const url = toFileURL(ref.filename);
         const href = url.href;
         if (ref.error)
             return new ImportError(`Failed to read config file: "${ref.filename}"`, ref.error);
@@ -80,8 +88,14 @@ export class ConfigLoader {
             }
         });
     }
-    searchForConfigFileLocation(searchFrom) {
-        const url = this.cspellIO.toFileURL(searchFrom || cwdURL());
+    async searchForConfigFileLocation(searchFrom) {
+        const url = toFileURL(searchFrom || cwdURL(), cwdURL());
+        if (typeof searchFrom === 'string' && !isUrlLike(searchFrom) && url.protocol === 'file:') {
+            // check to see if it is a directory
+            if (await isDirectory(this.fs, url)) {
+                return this.configSearch.searchForConfig(addTrailingSlash(url));
+            }
+        }
         return this.configSearch.searchForConfig(url);
     }
     async searchForConfigFile(searchFrom) {
@@ -131,7 +145,7 @@ export class ConfigLoader {
         return this.onReady;
     }
     importSettings(fileRef, pnpSettings, backReferences) {
-        const url = this.cspellIO.toFileURL(fileRef.filename);
+        const url = toFileURL(fileRef.filename);
         const cacheKey = url.href;
         const cachedImport = this.cachedConfig.get(cacheKey);
         if (cachedImport) {
@@ -226,7 +240,7 @@ export class ConfigLoader {
         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 __imports = await Promise.all(imports.map((name) => this.resolveFilename(name, cfgFile.url)));
         const toImport = __imports.map((ref) => this.importSettings(ref, pnpSettings, [...referencedBy, href]));
         // Add ourselves to the import sources.
         toImport.forEach((entry) => {
@@ -239,7 +253,7 @@ export class ConfigLoader {
                 : entry.onReady;
         });
         const importSettings = await Promise.all(pendingImports);
-        const cfg = this.mergeImports(cfgFile, importSettings);
+        const cfg = await this.mergeImports(cfgFile, importSettings);
         return cfg;
     }
     /**
@@ -247,12 +261,11 @@ export class ConfigLoader {
      * @param rawSettings - raw configuration settings
      * @param pathToSettingsFile - path to the source file of the configuration settings.
      */
-    mergeImports(cfgFile, importedSettings) {
+    async 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 = {
@@ -264,7 +277,7 @@ export class ConfigLoader {
         const normalizedDictionaryDefs = normalizeDictionaryDefs(settings, url);
         const normalizedSettingsGlobs = normalizeSettingsGlobs(settings, url);
         const normalizedOverrides = normalizeOverrides(settings, url);
-        const normalizedReporters = normalizeReporters(settings, url);
+        const normalizedReporters = await normalizeReporters(settings, url);
         const normalizedGitignoreRoot = normalizeGitignoreRoot(settings, url);
         const normalizedCacheSettings = normalizeCacheSettings(settings, url);
         const fileSettings = csi({
@@ -284,11 +297,13 @@ export class ConfigLoader {
         const finalizeSettings = mergeSettings(mergedImportedSettings, fileSettings);
         finalizeSettings.name = settings.name || finalizeSettings.name || '';
         finalizeSettings.id = settings.id || finalizeSettings.id || '';
-        finalizeSettings.__importRef = fileRef;
+        if (fileRef) {
+            finalizeSettings.__importRef = fileRef;
+        }
         return finalizeSettings;
     }
     createCSpellConfigFile(filename, settings) {
-        return new CSpellConfigFileInMemory(this.cspellIO.toFileURL(filename), settings);
+        return new CSpellConfigFileInMemory(toFileURL(filename), settings);
     }
     dispose() {
         while (this.toDispose.length) {
@@ -300,10 +315,25 @@ export class ConfigLoader {
             }
         }
     }
+    getStats() {
+        return { ...getMergeStats() };
+    }
+    async resolveFilename(filename, relativeTo) {
+        if (filename instanceof URL)
+            return { filename: toFilePathOrHref(filename) };
+        const r = await this.fileResolver.resolveFile(filename, relativeTo);
+        if (r.warning) {
+            logWarning(r.warning);
+        }
+        return {
+            filename: r.filename.startsWith('file:/') ? fileURLToPath(r.filename) : r.filename,
+            error: r.found ? undefined : new Error(`Failed to resolve file: "${filename}"`),
+        };
+    }
 }
 class ConfigLoaderInternal extends ConfigLoader {
-    constructor(cspellIO) {
-        super(cspellIO);
+    constructor(vfs) {
+        super(vfs);
     }
     get _cachedFiles() {
         return this.cachedConfig;
@@ -316,26 +346,17 @@ export function loadPnP(pnpSettings, searchFrom) {
     const loader = pnpLoader(pnpSettings.pnpFiles);
     return loader.load(searchFrom);
 }
-function resolveFilename(filename, relativeTo) {
-    if (filename instanceof URL)
-        return { filename: toFilePathOrHref(filename) };
-    const r = resolveFile(filename, relativeTo);
-    return {
-        filename: r.filename.startsWith('file:/') ? fileURLToPath(r.filename) : r.filename,
-        error: r.found ? undefined : new Error(`Failed to resolve file: "${filename}"`),
-    };
-}
 const nestedConfigDirectories = {
     '.vscode': true,
-    '.config': true,
+    '.config': true, // this should be removed in the future, but it is a breaking change.
 };
 function resolveGlobRoot(settings, urlSettingsFile) {
-    const pathToSettingsFile = fileURLToPath(urlSettingsFile);
-    const settingsFileDirRaw = path.dirname(pathToSettingsFile);
-    const settingsFileDirName = path.basename(settingsFileDirRaw);
+    const urlSettingsFileDir = new URL('.', urlSettingsFile);
+    const uriSettingsFileDir = URI.parse(urlSettingsFileDir.href);
+    const settingsFileDirName = UriUtils.basename(uriSettingsFileDir);
     const isNestedConfig = settingsFileDirName in nestedConfigDirectories;
     const isVSCode = settingsFileDirName === '.vscode';
-    const settingsFileDir = isNestedConfig ? path.dirname(settingsFileDirRaw) : settingsFileDirRaw;
+    const settingsFileDir = (isNestedConfig ? UriUtils.dirname(uriSettingsFileDir) : uriSettingsFileDir).toString();
     const envGlobRoot = process.env[ENV_CSPELL_GLOB_ROOT];
     const defaultGlobRoot = envGlobRoot ?? '${cwd}';
     const rawRoot = settings.globRoot ??
@@ -344,8 +365,12 @@ function resolveGlobRoot(settings, urlSettingsFile) {
             (isVSCode && !settings.version)
             ? defaultGlobRoot
             : settingsFileDir);
-    const globRoot = rawRoot.startsWith('${cwd}') ? rawRoot : path.resolve(settingsFileDir, rawRoot);
-    return globRoot;
+    const globRoot = rawRoot.startsWith('${cwd}') ? rawRoot : resolveFileWithURL(rawRoot, new URL(settingsFileDir));
+    return typeof globRoot === 'string'
+        ? globRoot
+        : globRoot.protocol === 'file:'
+            ? windowsDriveLetterToUpper(path.resolve(fileURLToPath(globRoot)))
+            : addTrailingSlash(globRoot).href;
 }
 function validationMessage(msg, url) {
     return msg + `\n  File: "${toFilePathOrHref(url)}"`;
@@ -369,28 +394,37 @@ function validateRawConfigVersion(config) {
         : `Legacy config file version found: "${version}", upgrade to "${currentSettingsFileVersion}"`;
     logWarning(validationMessage(msg, config.url));
 }
-function createConfigLoaderInternal(cspellIO) {
-    return new ConfigLoaderInternal(cspellIO ?? getDefaultCSpellIO());
+function createConfigLoaderInternal(fs) {
+    return new ConfigLoaderInternal(fs ?? getVirtualFS().fs);
 }
-export function createConfigLoader(cspellIO) {
-    return createConfigLoaderInternal(cspellIO);
+export function createConfigLoader(fs) {
+    return createConfigLoaderInternal(fs);
 }
 export function getDefaultConfigLoaderInternal() {
     if (defaultConfigLoader)
         return defaultConfigLoader;
     return (defaultConfigLoader = createConfigLoaderInternal());
 }
-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);
+function createIO(fs) {
+    const readFile = (url) => fs.readFile(url).then((file) => ({ url: file.url, content: createTextFileResource(file).getText() }));
+    const writeFile = (file) => fs.writeFile(file);
     return {
         readFile,
         writeFile,
     };
 }
+async function isDirectory(fs, path) {
+    try {
+        return (await fs.stat(path)).isDirectory();
+    }
+    catch (e) {
+        return false;
+    }
+}
 export const __testing__ = {
     getDefaultConfigLoaderInternal,
     normalizeCacheSettings,
     validateRawConfigVersion,
+    resolveGlobRoot,
 };
 //# sourceMappingURL=configLoader.js.map

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

@@ -1,12 +1,16 @@
+import { type VFileSystem } from '../../../fileSystem.js';
 export declare class ConfigSearch {
     readonly searchPlaces: readonly string[];
+    private fs;
     private searchCache;
     private searchDirCache;
-    constructor(searchPlaces: readonly string[]);
-    searchForConfig(searchFrom: URL | string): Promise<URL | undefined>;
+    constructor(searchPlaces: readonly string[], fs: VFileSystem);
+    searchForConfig(searchFromURL: URL): Promise<URL | undefined>;
     clearCache(): void;
-    private findUpConfig;
     private findUpConfigPath;
     private hasConfig;
+    private createHasFileDirSearch;
+    private createHasFileStatCheck;
+    private hasConfigDir;
 }
 //# sourceMappingURL=configSearch.d.ts.map

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

@@ -1,35 +1,19 @@
-import { readdir, readFile, stat } from 'node:fs/promises';
-import path from 'node:path';
-import { pathToFileURL } from 'url';
+import { urlBasename } from 'cspell-io';
+import { createTextFileResource } from '../../../fileSystem.js';
 import { createAutoResolveCache } from '../../../util/AutoResolve.js';
-import { findUp } from '../../../util/findUp.js';
-import { addTrailingSlash, fileURLOrPathToPath, toFileDirUrl, toURL } from '../../../util/url.js';
+import { findUpFromUrl } from '../../../util/findUpFromUrl.js';
 export class ConfigSearch {
     searchPlaces;
+    fs;
     searchCache = new Map();
     searchDirCache = new Map();
-    constructor(searchPlaces) {
+    constructor(searchPlaces, fs) {
         this.searchPlaces = searchPlaces;
+        this.fs = fs;
         this.searchPlaces = searchPlaces;
     }
-    async searchForConfig(searchFrom) {
-        if (typeof searchFrom === 'string') {
-            if (!searchFrom.startsWith('file:')) {
-                return undefined;
-            }
-        }
-        else {
-            if (searchFrom.protocol !== 'file:') {
-                return undefined;
-            }
-        }
-        const searchFromURL = toURL(searchFrom);
-        let dirUrl = new URL('.', searchFrom);
-        if (dirUrl.toString() !== searchFrom.toString()) {
-            // check to see if searchFrom is a directory
-            const isDir = await isDirectory(searchFrom);
-            dirUrl = isDir ? addTrailingSlash(searchFromURL) : dirUrl;
-        }
+    searchForConfig(searchFromURL) {
+        const dirUrl = new URL('.', searchFromURL);
         const searchHref = dirUrl.href;
         const searchCache = this.searchCache;
         const cached = searchCache.get(searchHref);
@@ -37,80 +21,100 @@ export class ConfigSearch {
             return cached;
         }
         const toPatchCache = [];
-        const foundPath = await this.findUpConfigPath(fileURLOrPathToPath(dirUrl), storeVisit);
-        const foundUrl = foundPath ? pathToFileURL(foundPath) : undefined;
-        const pFoundPath = Promise.resolve(foundPath);
-        const pFoundUrl = Promise.resolve(foundUrl);
+        const pFoundUrl = this.findUpConfigPath(dirUrl, storeVisit);
+        this.searchCache.set(searchHref, pFoundUrl);
         const searchDirCache = this.searchDirCache;
-        for (const dir of toPatchCache) {
-            searchDirCache.set(dir, searchDirCache.get(dir) || pFoundPath);
-            const dirHref = toFileDirUrl(dir).href;
-            searchCache.set(dirHref, searchCache.get(dirHref) || pFoundUrl);
-        }
-        const result = searchCache.get(searchHref) || pFoundUrl;
-        searchCache.set(searchHref, result);
-        return result;
+        const patch = async () => {
+            try {
+                await pFoundUrl;
+                for (const dir of toPatchCache) {
+                    searchDirCache.set(dir.href, searchDirCache.get(dir.href) || pFoundUrl);
+                    searchCache.set(dir.href, searchCache.get(dir.href) || pFoundUrl);
+                }
+                const result = searchCache.get(searchHref) || pFoundUrl;
+                searchCache.set(searchHref, result);
+            }
+            catch (e) {
+                // ignore
+            }
+        };
+        patch();
+        return pFoundUrl;
         function storeVisit(dir) {
             toPatchCache.push(dir);
         }
     }
     clearCache() {
         this.searchCache.clear();
-    }
-    async findUpConfig(searchFromPath, visit) {
-        const cwd = fileURLOrPathToPath(searchFromPath);
-        const found = await this.findUpConfigPath(cwd, visit);
-        return found ? pathToFileURL(found) : undefined;
+        this.searchDirCache.clear();
     }
     findUpConfigPath(cwd, visit) {
         const searchDirCache = this.searchDirCache;
-        const cached = searchDirCache.get(cwd);
+        const cached = searchDirCache.get(cwd.href);
         if (cached)
             return cached;
-        return findUp((dir) => this.hasConfig(dir, visit), { cwd, type: 'file' });
+        return findUpFromUrl((dir) => this.hasConfig(dir, visit), cwd, { type: 'file' });
     }
-    async hasConfig(dir, visited) {
-        dir = path.normalize(dir + '/');
-        const cached = this.searchDirCache.get(dir);
+    hasConfig(dir, visited) {
+        const cached = this.searchDirCache.get(dir.href);
         if (cached)
             return cached;
         visited(dir);
+        const result = this.hasConfigDir(dir);
+        this.searchDirCache.set(dir.href, result);
+        return result;
+    }
+    createHasFileDirSearch() {
         const dirInfoCache = createAutoResolveCache();
-        async function hasFile(filename) {
-            const dirInfo = await dirInfoCache.get(path.dirname(filename), async (dir) => new Map((await readdir(dir, { withFileTypes: true }).catch(() => [])).map((ent) => [ent.name, ent])));
-            const name = path.basename(filename);
+        const hasFile = async (filename) => {
+            const dir = new URL('.', filename);
+            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 name = urlBasename(filename);
             const found = dirInfo.get(name);
             return !!found?.isFile();
-        }
+        };
+        return hasFile;
+    }
+    createHasFileStatCheck() {
+        const hasFile = async (filename) => {
+            const stat = await this.fs.stat(filename).catch(() => undefined);
+            return !!stat?.isFile();
+        };
+        return hasFile;
+    }
+    async hasConfigDir(dir) {
+        const hasFile = this.fs.getCapabilities(dir).readDirectory
+            ? this.createHasFileDirSearch()
+            : this.createHasFileStatCheck();
         for (const searchPlace of this.searchPlaces) {
-            const file = path.join(dir, searchPlace);
+            const file = new URL(searchPlace, dir);
             const found = await hasFile(file);
             if (found) {
-                if (path.basename(file) !== 'package.json')
+                if (urlBasename(file) !== 'package.json')
                     return file;
-                if (await checkPackageJson(file))
+                if (await checkPackageJson(this.fs, file))
                     return file;
             }
         }
         return undefined;
     }
 }
-async function checkPackageJson(filename) {
+async function checkPackageJson(fs, filename) {
     try {
-        const content = await readFile(filename, 'utf8');
-        const pkg = JSON.parse(content);
+        const file = createTextFileResource(await fs.readFile(filename));
+        const pkg = JSON.parse(file.getText());
         return typeof pkg.cspell === 'object';
     }
     catch (e) {
         return false;
     }
 }
-async function isDirectory(path) {
-    try {
-        return (await stat(path)).isDirectory();
-    }
-    catch (e) {
-        return false;
-    }
-}
+// async function isDirectory(virtualFs: VirtualFS, path: URL): Promise<boolean> {
+//     try {
+//         return (await virtualFs.fs.stat(path)).isDirectory();
+//     } catch (e) {
+//         return false;
+//     }
+// }
 //# sourceMappingURL=configSearch.js.map

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

@@ -17,13 +17,16 @@ export function configToRawSettings(cfgFile) {
     };
     const source = {
         name: cfgFile.settings.name || filename,
-        filename,
+        filename: cfgFile.virtual ? undefined : filename,
     };
     const rawSettings = { ...cfgFile.settings };
     rawSettings.import = normalizeImport(rawSettings.import);
     normalizeRawConfig(rawSettings);
     rawSettings.source = source;
-    rawSettings.__importRef = fileRef;
+    // in virtual config files are ignored for the purposes of import history.
+    if (!cfgFile.virtual) {
+        rawSettings.__importRef = fileRef;
+    }
     const id = rawSettings.id || urlToSimpleId(url);
     const name = rawSettings.name || id;
     rawSettings.id = id;

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

@@ -35,7 +35,7 @@ type NormalizeOverrides = Pick<CSpellUserSettings, 'globRoot' | 'overrides'>;
 type NormalizeOverridesResult = Pick<CSpellUserSettings, 'overrides'>;
 export declare function normalizeOverrides(settings: NormalizeOverrides, pathToSettingsFile: URL): NormalizeOverridesResult;
 type NormalizeReporters = Pick<CSpellUserSettings, 'reporters'>;
-export declare function normalizeReporters(settings: NormalizeReporters, pathToSettingsFile: URL): NormalizeReporters;
+export declare function normalizeReporters(settings: NormalizeReporters, pathToSettingsFile: URL): Promise<NormalizeReporters>;
 export declare function normalizeLanguageSettings(languageSettings: LanguageSetting[] | undefined): LanguageSetting[] | undefined;
 type NormalizeGitignoreRoot = Pick<CSpellUserSettings, 'gitignoreRoot'>;
 export declare function normalizeGitignoreRoot(settings: NormalizeGitignoreRoot, pathToSettingsFile: URL): NormalizeGitignoreRoot;

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

@@ -38,20 +38,20 @@ export function normalizeOverrides(settings, pathToSettingsFile) {
     });
     return overrides ? { overrides } : {};
 }
-export function normalizeReporters(settings, pathToSettingsFile) {
+export async function normalizeReporters(settings, pathToSettingsFile) {
     if (settings.reporters === undefined)
         return {};
-    function resolve(s) {
+    async function resolve(s) {
         if (s === 'default')
             return s;
-        const r = resolveFile(s, pathToSettingsFile);
+        const r = await resolveFile(s, pathToSettingsFile);
         if (!r.found) {
             // console.warn('Not found: %o', { filename: s, relativeTo: pathToSettingsFile.href });
             throw new Error(`Not found: "${s}"`);
         }
         return r.filename;
     }
-    function resolveReporter(s) {
+    async function resolveReporter(s) {
         if (typeof s === 'string') {
             return resolve(s);
         }
@@ -59,10 +59,10 @@ export function normalizeReporters(settings, pathToSettingsFile) {
             throw new Error('Invalid Reporter');
         // Preserve the shape of Reporter Setting while resolving the reporter file.
         const [r, ...rest] = s;
-        return [resolve(r), ...rest];
+        return [await resolve(r), ...rest];
     }
     return {
-        reporters: settings.reporters.map(resolveReporter),
+        reporters: await Promise.all(settings.reporters.map(resolveReporter)),
     };
 }
 export function normalizeLanguageSettings(languageSettings) {