cspell-lib 8.2.0 → 8.2.3

package/dist/esm/Models/TextDocument.js

@@ -1,6 +1,6 @@
 import assert from 'assert';
-import { promises as fs } from 'fs';
 import { TextDocument as VsTextDocument } from 'vscode-languageserver-textdocument';
+import { getFileSystem } from '../fileSystem.js';
 import { getLanguagesForBasename } from '../LanguageIds.js';
 import * as Uri from '../util/Uri.js';
 class TextDocumentImpl {
@@ -103,8 +103,9 @@ function isTextDocumentImpl(doc) {
 }
 export async function loadTextDocument(filename, languageId) {
     const uri = Uri.toUri(filename);
-    const content = await fs.readFile(Uri.uriToFilePath(uri), 'utf8');
-    return createTextDocument({ uri, languageId, content });
+    const url = new URL(uri.toString());
+    const file = await getFileSystem().readFile(url);
+    return createTextDocument({ uri, languageId, content: file.getText() });
 }
 export const isTextDocument = isTextDocumentImpl;
 //# sourceMappingURL=TextDocument.js.map

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

@@ -5,7 +5,7 @@ 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 { 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';
@@ -321,6 +321,8 @@ export class ConfigLoader {
     async resolveFilename(filename, relativeTo) {
         if (filename instanceof URL)
             return { filename: toFilePathOrHref(filename) };
+        if (isUrlLike(filename))
+            return { filename: toFilePathOrHref(filename) };
         const r = await this.fileResolver.resolveFile(filename, relativeTo);
         if (r.warning) {
             logWarning(r.warning);
@@ -406,7 +408,7 @@ export function getDefaultConfigLoaderInternal() {
     return (defaultConfigLoader = createConfigLoaderInternal());
 }
 function createIO(fs) {
-    const readFile = (url) => fs.readFile(url).then((file) => ({ url: file.url, content: createTextFileResource(file).getText() }));
+    const readFile = (url) => fs.readFile(url).then((file) => ({ url: file.url, content: file.getText() }));
     const writeFile = (file) => fs.writeFile(file);
     return {
         readFile,

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

@@ -1,4 +1,4 @@
-import { type VFileSystem } from '../../../fileSystem.js';
+import type { VFileSystem } from '../../../fileSystem.js';
 export declare class ConfigSearch {
     readonly searchPlaces: readonly string[];
     private fs;

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

@@ -1,5 +1,4 @@
 import { urlBasename } from 'cspell-io';
-import { createTextFileResource } from '../../../fileSystem.js';
 import { createAutoResolveCache } from '../../../util/AutoResolve.js';
 import { findUpFromUrl } from '../../../util/findUpFromUrl.js';
 export class ConfigSearch {
@@ -68,6 +67,16 @@ export class ConfigSearch {
         const dirInfoCache = createAutoResolveCache();
         const hasFile = async (filename) => {
             const dir = new URL('.', filename);
+            const parent = new URL('..', dir);
+            const parentHref = parent.href;
+            const parentInfoP = dirInfoCache.get(parentHref);
+            if (parentInfoP) {
+                const parentInfo = await parentInfoP;
+                const name = urlBasename(dir).slice(0, -1);
+                const found = parentInfo.get(name);
+                if (!found?.isDirectory())
+                    return false;
+            }
             const dirUrlHref = dir.href;
             const dirInfo = await dirInfoCache.get(dirUrlHref, async () => new Map((await this.fs.readDirectory(dir).catch(() => [])).map((ent) => [ent.name, ent])));
             const name = urlBasename(filename);
@@ -102,7 +111,7 @@ export class ConfigSearch {
 }
 async function checkPackageJson(fs, filename) {
     try {
-        const file = createTextFileResource(await fs.readFile(filename));
+        const file = await fs.readFile(filename);
         const pkg = JSON.parse(file.getText());
         return typeof pkg.cspell === 'object';
     }
@@ -110,11 +119,4 @@ async function checkPackageJson(fs, filename) {
         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/index.d.ts

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

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

@@ -1,2 +1,2 @@
-export { SettingsController } from './SettingsController.js';
+export { defaultConfigFilenames } from './configLoader/index.js';
 //# sourceMappingURL=index.js.map

package/dist/esm/SpellingDictionary/Dictionaries.d.ts

@@ -1,8 +1,6 @@
 import type { SpellingDictionary, SpellingDictionaryCollection } from 'cspell-dictionary';
 import type { CSpellSettingsInternal, DictionaryDefinitionInternal } from '../Models/CSpellSettingsInternalDef.js';
 export declare function loadDictionaryDefs(defsToLoad: DictionaryDefinitionInternal[]): Promise<SpellingDictionary>[];
-export declare function loadDictionaryDefsSync(defsToLoad: DictionaryDefinitionInternal[]): SpellingDictionary[];
 export declare function refreshDictionaryCache(maxAge?: number): Promise<void>;
 export declare function getDictionaryInternal(settings: CSpellSettingsInternal): Promise<SpellingDictionaryCollection>;
-export declare function getDictionaryInternalSync(settings: CSpellSettingsInternal): SpellingDictionaryCollection;
 //# sourceMappingURL=Dictionaries.d.ts.map

package/dist/esm/SpellingDictionary/Dictionaries.js

@@ -1,13 +1,10 @@
 import { createCollection, createForbiddenWordsDictionary, createIgnoreWordsDictionary, createSpellingDictionary, createSuggestDictionary, } from 'cspell-dictionary';
 import { calcDictionaryDefsToLoad } from '../Settings/DictionarySettings.js';
 import { isDefined } from '../util/util.js';
-import { loadDictionary, loadDictionarySync, refreshCacheEntries } from './DictionaryLoader.js';
+import { loadDictionary, refreshCacheEntries } from './DictionaryLoader.js';
 export function loadDictionaryDefs(defsToLoad) {
     return defsToLoad.map(loadDictionary);
 }
-export function loadDictionaryDefsSync(defsToLoad) {
-    return defsToLoad.map(loadDictionarySync);
-}
 export function refreshDictionaryCache(maxAge) {
     return refreshCacheEntries(maxAge);
 }
@@ -16,10 +13,6 @@ export async function getDictionaryInternal(settings) {
     const spellDictionaries = await Promise.all(loadDictionaryDefs(calcDictionaryDefsToLoad(settings)));
     return _getDictionaryInternal(settings, spellDictionaries);
 }
-export function getDictionaryInternalSync(settings) {
-    const spellDictionaries = loadDictionaryDefsSync(calcDictionaryDefsToLoad(settings));
-    return _getDictionaryInternal(settings, spellDictionaries);
-}
 function _getDictionaryInternal(settings, spellDictionaries) {
     const { words = emptyWords, userWords = emptyWords, flagWords = emptyWords, ignoreWords = emptyWords, suggestWords = emptyWords, } = settings;
     const settingsWordsDictionary = createSpellingDictionary(words, '[words]', 'From Settings `words`', {

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

@@ -1,16 +1,15 @@
 import type { SpellingDictionary } from 'cspell-dictionary';
-import type { CSpellIO } from 'cspell-io';
+import type { VFileSystem } from 'cspell-io';
 import type { DictionaryDefinitionInternal } from '../../Models/CSpellSettingsInternalDef.js';
 export type LoadOptions = DictionaryDefinitionInternal;
 export declare class DictionaryLoader {
-    private cspellIO;
+    private fs;
     private dictionaryCache;
     private inlineDictionaryCache;
     private dictionaryCacheByDef;
     private reader;
-    constructor(cspellIO: CSpellIO);
+    constructor(fs: VFileSystem);
     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.
@@ -21,9 +20,7 @@ export declare class DictionaryLoader {
     private setCacheEntry;
     private refreshEntry;
     private loadEntry;
-    private loadEntrySync;
     private getStat;
-    private getStatSync;
     private isEqual;
     private normalizeOptions;
     private loadInlineDict;

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

@@ -1,6 +1,7 @@
 import { opConcatMap, opFilter, opMap, pipe } from '@cspell/cspell-pipe/sync';
 import { StrongWeakMap } from '@cspell/strong-weak-map';
 import { createFailedToLoadDictionary, createInlineSpellingDictionary, createSpellingDictionary, createSpellingDictionaryFromTrieFile, } from 'cspell-dictionary';
+import { compareStats, toFileURL, urlBasename } from 'cspell-io';
 import { isDictionaryDefinitionInlineInternal } from '../../Models/CSpellSettingsInternalDef.js';
 import { AutoResolveWeakCache } from '../../util/AutoResolve.js';
 import { toError } from '../../util/errors.js';
@@ -13,27 +14,20 @@ const loaders = {
     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 = {}));
 export class DictionaryLoader {
-    cspellIO;
+    fs;
     dictionaryCache = new StrongWeakMap();
     inlineDictionaryCache = new AutoResolveWeakCache();
     dictionaryCacheByDef = new StrongWeakMap();
     reader;
-    constructor(cspellIO) {
-        this.cspellIO = cspellIO;
-        this.reader = toReader(cspellIO);
+    constructor(fs) {
+        this.fs = fs;
+        this.reader = toReader(fs);
     }
     loadDictionary(def) {
         if (isDictionaryDefinitionInlineInternal(def)) {
@@ -47,18 +41,6 @@ export class DictionaryLoader {
         this.setCacheEntry(key, loadedEntry, def);
         return loadedEntry.pending.then(([dictionary]) => dictionary);
     }
-    loadDictionarySync(def) {
-        if (isDictionaryDefinitionInlineInternal(def)) {
-            return this.loadInlineDict(def);
-        }
-        const { key, entry } = this.getCacheEntry(def);
-        if (entry?.dictionary && entry.loadingState === LoadingState.Loaded) {
-            return entry.dictionary;
-        }
-        const loadedEntry = this.loadEntrySync(this.cspellIO.toFileURL(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.
@@ -104,9 +86,9 @@ export class DictionaryLoader {
         }
     }
     loadEntry(fileOrUri, options, now = Date.now()) {
-        const url = this.cspellIO.toFileURL(fileOrUri);
+        const url = toFileURL(fileOrUri);
         options = this.normalizeOptions(url, options);
-        const pDictionary = load(this.reader, this.cspellIO.toFileURL(fileOrUri), options).catch((e) => createFailedToLoadDictionary(options.name, fileOrUri, new SpellingDictionaryLoadError(url.href, options, e, 'failed to load'), options));
+        const pDictionary = load(this.reader, toFileURL(fileOrUri), options).catch((e) => createFailedToLoadDictionary(options.name, fileOrUri, new SpellingDictionaryLoadError(url.href, options, e, 'failed to load'), options));
         const pStat = this.getStat(fileOrUri);
         const pending = Promise.all([pDictionary, pStat]);
         const sig = now + Math.random();
@@ -129,51 +111,8 @@ export class DictionaryLoader {
         });
         return entry;
     }
-    loadEntrySync(fileOrUri, options, now = Date.now()) {
-        const url = this.cspellIO.toFileURL(fileOrUri);
-        options = this.normalizeOptions(url, options);
-        const stat = this.getStatSync(url);
-        const sig = now + Math.random();
-        try {
-            const dictionary = loadSync(this.reader, url, options);
-            const pending = Promise.resolve([dictionary, stat]);
-            return {
-                uri: url.href,
-                options,
-                ts: now,
-                stat,
-                dictionary,
-                pending,
-                loadingState: LoadingState.Loaded,
-                sig,
-            };
-        }
-        catch (e) {
-            const error = toError(e);
-            const dictionary = createFailedToLoadDictionary(options.name, fileOrUri, new SpellingDictionaryLoadError(url.href, options, error, 'failed to load'), options);
-            const pending = Promise.resolve([dictionary, stat]);
-            return {
-                uri: url.href,
-                options,
-                ts: now,
-                stat,
-                dictionary,
-                pending,
-                loadingState: LoadingState.Loaded,
-                sig,
-            };
-        }
-    }
     getStat(uri) {
-        return this.cspellIO.getStat(this.cspellIO.toFileURL(uri)).catch(toError);
-    }
-    getStatSync(uri) {
-        try {
-            return this.cspellIO.getStatSync(this.cspellIO.toFileURL(uri));
-        }
-        catch (e) {
-            return toError(e);
-        }
+        return this.fs.stat(toFileURL(uri)).catch(toError);
     }
     isEqual(a, b) {
         if (!b)
@@ -181,30 +120,31 @@ export class DictionaryLoader {
         if (isError(a)) {
             return isError(b) && a.message === b.message && a.name === b.name;
         }
-        return !isError(b) && !this.cspellIO.compareStats(a, b);
+        return !isError(b) && !compareStats(a, b);
     }
     normalizeOptions(uri, options) {
         if (options.name)
             return options;
-        return { ...options, name: this.cspellIO.urlBasename(uri) };
+        return { ...options, name: urlBasename(uri) };
     }
     loadInlineDict(def) {
         return this.inlineDictionaryCache.get(def, (def) => createInlineSpellingDictionary(def, def.__source || 'memory'));
     }
     calcKey(def) {
         const path = def.path;
-        const loaderType = determineType(this.cspellIO.toFileURL(path), def);
+        const loaderType = determineType(toFileURL(path), def);
         const optValues = importantOptionKeys.map((k) => def[k]?.toString() || '');
         const parts = [path, loaderType].concat(optValues);
         return parts.join('|');
     }
 }
-function toReader(cspellIO) {
+function toReader(fs) {
+    async function readFile(url) {
+        return (await fs.readFile(url)).getText();
+    }
     return {
-        read: async (filename) => (await cspellIO.readFile(filename)).getText(),
-        readLines: async (filename) => toLines((await cspellIO.readFile(filename)).getText()),
-        readSync: (filename) => cspellIO.readFileSync(filename).getText(),
-        readLinesSync: (filename) => toLines(cspellIO.readFileSync(filename).getText()),
+        read: readFile,
+        readLines: async (filename) => toLines(await readFile(filename)),
     };
 }
 const importantOptionKeys = ['name', 'noSuggest', 'useCompounds', 'type'];
@@ -224,19 +164,10 @@ function load(reader, 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(reader, filename, options) {
     const lines = await reader.readLines(filename);
     return _legacyWordListSync(lines, filename, options);
 }
-function legacyWordListSync(reader, filename, options) {
-    const lines = reader.readLinesSync(filename);
-    return _legacyWordListSync(lines, filename, options);
-}
 function _legacyWordListSync(lines, filename, options) {
     const words = pipe(lines, 
     // Remove comments
@@ -249,10 +180,6 @@ async function wordsPerLineWordList(reader, filename, options) {
     const lines = await reader.readLines(filename);
     return _wordsPerLineWordList(lines, filename.toString(), options);
 }
-function wordsPerLineWordListSync(reader, filename, options) {
-    const lines = reader.readLinesSync(filename);
-    return _wordsPerLineWordList(lines, filename.toString(), options);
-}
 function _wordsPerLineWordList(lines, filename, options) {
     const words = pipe(lines, 
     // Remove comments
@@ -265,18 +192,10 @@ async function loadSimpleWordList(reader, filename, options) {
     const lines = await reader.readLines(filename);
     return createSpellingDictionary(lines, options.name, filename.href, options);
 }
-function loadSimpleWordListSync(reader, filename, options) {
-    const lines = reader.readLinesSync(filename);
-    return createSpellingDictionary(lines, options.name, filename.href, options);
-}
 async function loadTrie(reader, filename, options) {
     const content = await reader.read(filename);
     return createSpellingDictionaryFromTrieFile(content, options.name, filename.href, options);
 }
-function loadTrieSync(reader, filename, options) {
-    const content = reader.readSync(filename);
-    return createSpellingDictionaryFromTrieFile(content, options.name, filename.href, options);
-}
 function toLines(content) {
     return content.split(/\n|\r\n|\r/);
 }

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

@@ -1,11 +1,10 @@
 import type { SpellingDictionary } from 'cspell-dictionary';
-import type { CSpellIO } from 'cspell-io';
+import type { VFileSystem } from '../fileSystem.js';
 import type { DictionaryDefinitionInternal } from '../Models/CSpellSettingsInternalDef.js';
 import { DictionaryLoader } from './DictionaryController/index.js';
 export type { LoadOptions } from './DictionaryController/index.js';
-export declare function getDictionaryLoader(cspellIO?: CSpellIO): DictionaryLoader;
+export declare function getDictionaryLoader(vfs?: VFileSystem): DictionaryLoader;
 export declare function loadDictionary(def: DictionaryDefinitionInternal): Promise<SpellingDictionary>;
-export declare function 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.

package/dist/esm/SpellingDictionary/DictionaryLoader.js

@@ -1,17 +1,14 @@
-import { getCSpellIO } from '../fileSystem.js';
+import { getFileSystem } from '../fileSystem.js';
 import { DictionaryLoader } from './DictionaryController/index.js';
 let loader;
-export function getDictionaryLoader(cspellIO) {
+export function getDictionaryLoader(vfs) {
     if (loader)
         return loader;
-    return (loader = new DictionaryLoader(cspellIO || getCSpellIO()));
+    return (loader = new DictionaryLoader(vfs || getFileSystem()));
 }
 export function loadDictionary(def) {
     return getDictionaryLoader().loadDictionary(def);
 }
-export function loadDictionarySync(def) {
-    return getDictionaryLoader().loadDictionarySync(def);
-}
 /**
  * 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.

package/dist/esm/fileSystem.d.ts

@@ -1,8 +1,8 @@
-import type { CSpellIO, VFileSystemProvider } from 'cspell-io';
+import type { TextEncoding, VFileSystemProvider } from 'cspell-io';
 export type { VFileSystemProvider, VfsDirEntry, VirtualFS } from 'cspell-io';
-export { createTextFileResource, FSCapabilityFlags, VFileSystem } from 'cspell-io';
-export declare function getCSpellIO(): CSpellIO;
+export { FSCapabilityFlags, VFileSystem } from 'cspell-io';
 export declare function getVirtualFS(): import("cspell-io").VirtualFS;
 export declare function getFileSystem(): Required<import("cspell-io").VFileSystem>;
 export declare function registerCSpell(fsp: VFileSystemProvider): void;
+export declare function readTextFile(url: URL, encoding?: TextEncoding): Promise<string>;
 //# sourceMappingURL=fileSystem.d.ts.map

package/dist/esm/fileSystem.js

@@ -1,8 +1,5 @@
-import { getDefaultCSpellIO, getDefaultVirtualFs } from 'cspell-io';
-export { createTextFileResource, FSCapabilityFlags } from 'cspell-io';
-export function getCSpellIO() {
-    return getDefaultCSpellIO();
-}
+import { getDefaultVirtualFs } from 'cspell-io';
+export { FSCapabilityFlags } from 'cspell-io';
 export function getVirtualFS() {
     return getDefaultVirtualFs();
 }
@@ -13,4 +10,8 @@ export function registerCSpell(fsp) {
     const vfs = getVirtualFS();
     vfs.registerFileSystemProvider(fsp);
 }
+export async function readTextFile(url, encoding = 'utf8') {
+    const file = await getFileSystem().readFile(url, encoding);
+    return file.getText();
+}
 //# sourceMappingURL=fileSystem.js.map

package/dist/esm/textValidation/docValidator.js

@@ -6,7 +6,7 @@ import { updateTextDocument } from '../Models/TextDocument.js';
 import { createPerfTimer } from '../perf/index.js';
 import { finalizeSettings, loadConfig, mergeSettings, searchForConfig } from '../Settings/index.js';
 import { validateInDocumentSettings } from '../Settings/InDocSettings.js';
-import { getDictionaryInternal, getDictionaryInternalSync } from '../SpellingDictionary/index.js';
+import { getDictionaryInternal } from '../SpellingDictionary/index.js';
 import { calcSuggestionAdjustedToToMatchCase } from '../suggestions.js';
 import { catchPromiseError, toError } from '../util/errors.js';
 import { AutoCache } from '../util/simpleCache.js';
@@ -108,7 +108,7 @@ export class DocumentValidator {
         const timer = createPerfTimer('_updatePrep');
         const prep = this._preparations;
         const docSettings = await determineTextDocumentSettings(this._document, prep.config);
-        const dict = getDictionaryInternalSync(docSettings);
+        const dict = await getDictionaryInternal(docSettings);
         const shouldCheck = docSettings.enabled ?? true;
         const finalSettings = finalizeSettings(docSettings);
         const validateOptions = settingsToValidateOptions(finalSettings);

package/dist/esm/util/Uri.js

@@ -77,7 +77,7 @@ class UriImpl extends URI {
     }
     toString() {
         // if (this.scheme !== 'stdin') return super.toString(true);
-        const path = (this.path || '').split('/').map(encodeURIComponent).join('/').replace(/%3A/g, ':');
+        const path = encodeURI(this.path || '').replace(/[#?]/g, (c) => `%${c.charCodeAt(0).toString(16)}`);
         const base = `${this.scheme}://${this.authority || ''}${path}`;
         const query = (this.query && `?${this.query}`) || '';
         const fragment = (this.fragment && `#${this.fragment}`) || '';

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

@@ -1,4 +1,3 @@
-import type { TextEncoding } from 'cspell-io';
-export declare function readLines(filename: string, encoding?: TextEncoding): Promise<IterableIterator<string>>;
-export declare function readLinesSync(filename: string, encoding?: TextEncoding): string[];
+import { type TextEncoding } from 'cspell-io';
+export declare function readLines(url: URL | string, encoding?: TextEncoding): Promise<IterableIterator<string>>;
 //# sourceMappingURL=fileReader.d.ts.map

package/dist/esm/util/fileReader.js

@@ -1,16 +1,14 @@
-import { readFileText, readFileTextSync } from 'cspell-io';
+import { toFileURL } from 'cspell-io';
+import { readTextFile } from '../fileSystem.js';
 import { toIterableIterator } from './iterableIteratorLib.js';
-export async function readLines(filename, encoding = 'utf8') {
+export async function readLines(url, encoding = 'utf8') {
     try {
-        const content = await readFileText(filename, encoding);
+        url = toFileURL(url);
+        const content = await readTextFile(url, encoding);
         return toIterableIterator(content.split(/\r?\n/g));
     }
     catch (e) {
         return Promise.reject(e);
     }
 }
-export function readLinesSync(filename, encoding = 'utf8') {
-    const content = readFileTextSync(filename, encoding);
-    return content.split(/\r?\n/g);
-}
 //# sourceMappingURL=fileReader.js.map

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

@@ -30,6 +30,14 @@ export declare class FileResolver {
     resolveFile(filename: string | URL, relativeTo: string | URL): Promise<ResolveFileResult>;
     _resolveFile(filename: string, relativeTo: string | URL): Promise<ResolveFileResult>;
     private doesExist;
+    /**
+     * Check to see if it is a URL.
+     * Note: URLs are absolute!
+     * If relativeTo is a non-file URL, then it will try to resolve the filename relative to it.
+     * @param filename - url string
+     * @returns ResolveFileResult
+     */
+    tryUrlRel: (filename: string, relativeToURL: string | URL) => Promise<ResolveFileResult | undefined>;
     /**
      * Check to see if it is a URL.
      * Note: URLs are absolute!

package/dist/esm/util/resolveFile.js

@@ -45,7 +45,7 @@ export class FileResolver {
     async _resolveFile(filename, relativeTo) {
         filename = patchFilename(filename, this.templateReplacements);
         const steps = [
-            { filename, fn: this.tryUrl },
+            { filename, fn: this.tryUrlRel },
             { filename, fn: this.tryCreateRequire },
             { filename, fn: this.tryNodeRequireResolve },
             { filename, fn: this.tryImportResolve },
@@ -84,7 +84,7 @@ export class FileResolver {
      * @param filename - url string
      * @returns ResolveFileResult
      */
-    tryUrl = async (filename, relativeToURL) => {
+    tryUrlRel = async (filename, relativeToURL) => {
         if (isURLLike(filename)) {
             const fileURL = toURL(filename);
             return {
@@ -94,6 +94,26 @@ export class FileResolver {
                 method: 'tryUrl',
             };
         }
+        if (isRelative(filename) && isURLLike(relativeToURL) && !isDataURL(relativeToURL)) {
+            const relToURL = toURL(relativeToURL);
+            const url = resolveFileWithURL(filename, relToURL);
+            return {
+                filename: toFilePathOrHref(url),
+                relativeTo: toFilePathOrHref(relToURL),
+                found: await this.doesExist(url),
+                method: 'tryUrl',
+            };
+        }
+        return undefined;
+    };
+    /**
+     * Check to see if it is a URL.
+     * Note: URLs are absolute!
+     * If relativeTo is a non-file URL, then it will try to resolve the filename relative to it.
+     * @param filename - url string
+     * @returns ResolveFileResult
+     */
+    tryUrl = async (filename, relativeToURL) => {
         if (isURLLike(relativeToURL) && !isDataURL(relativeToURL)) {
             const relToURL = toURL(relativeToURL);
             const url = resolveFileWithURL(filename, relToURL);

package/dist/esm/wordListHelper.js

@@ -3,13 +3,15 @@ import { readLines } from './util/fileReader.js';
 import { concatIterables, toIterableIterator } from './util/iterableIteratorLib.js';
 import { logError } from './util/logger.js';
 import * as Text from './util/text.js';
+import { toFileUrl } from './util/url.js';
 const regExpWordsWithSpaces = /^\s*\p{L}+(?:\s+\p{L}+){0,3}$/u;
 /**
  * Reads words from a file. It will not throw and error.
  * @param filename the file to read
  */
 export function loadWordsNoError(filename) {
-    return readLines(filename).catch((e) => (logError(e), toIterableIterator([])));
+    const url = toFileUrl(filename);
+    return readLines(url).catch((e) => (logError(e), toIterableIterator([])));
 }
 export function splitLine(line) {
     return [...Text.extractWordsFromText(line)].map(({ text }) => text);

package/package.json

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

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

@@ -1,9 +0,0 @@
-import type { 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/esm/Settings/Controller/SettingsController.js

@@ -1,10 +0,0 @@
-/**
- * The settings controller manages requests to resolve configuration settings and files.
- */
-export class SettingsController {
-    cspellIO;
-    constructor(cspellIO) {
-        this.cspellIO = cspellIO;
-    }
-}
-//# sourceMappingURL=SettingsController.js.map