cspell-lib 9.4.0 → 9.6.1

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

@@ -1,8 +1,61 @@
+var __addDisposableResource = (this && this.__addDisposableResource) || function (env, value, async) {
+    if (value !== null && value !== void 0) {
+        if (typeof value !== "object" && typeof value !== "function") throw new TypeError("Object expected.");
+        var dispose, inner;
+        if (async) {
+            if (!Symbol.asyncDispose) throw new TypeError("Symbol.asyncDispose is not defined.");
+            dispose = value[Symbol.asyncDispose];
+        }
+        if (dispose === void 0) {
+            if (!Symbol.dispose) throw new TypeError("Symbol.dispose is not defined.");
+            dispose = value[Symbol.dispose];
+            if (async) inner = dispose;
+        }
+        if (typeof dispose !== "function") throw new TypeError("Object not disposable.");
+        if (inner) dispose = function() { try { inner.call(this); } catch (e) { return Promise.reject(e); } };
+        env.stack.push({ value: value, dispose: dispose, async: async });
+    }
+    else if (async) {
+        env.stack.push({ async: true });
+    }
+    return value;
+};
+var __disposeResources = (this && this.__disposeResources) || (function (SuppressedError) {
+    return function (env) {
+        function fail(e) {
+            env.error = env.hasError ? new SuppressedError(e, env.error, "An error was suppressed during disposal.") : e;
+            env.hasError = true;
+        }
+        var r, s = 0;
+        function next() {
+            while (r = env.stack.pop()) {
+                try {
+                    if (!r.async && s === 1) return s = 0, env.stack.push(r), Promise.resolve().then(next);
+                    if (r.dispose) {
+                        var result = r.dispose.call(r.value);
+                        if (r.async) return s |= 2, Promise.resolve(result).then(next, function(e) { fail(e); return next(); });
+                    }
+                    else s |= 1;
+                }
+                catch (e) {
+                    fail(e);
+                }
+            }
+            if (s === 1) return env.hasError ? Promise.reject(env.error) : Promise.resolve();
+            if (env.hasError) throw env.error;
+        }
+        return next();
+    };
+})(typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+    var e = new Error(message);
+    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+});
 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, isDictionaryFileDefinitionInternal, } from '../../Models/CSpellSettingsInternalDef.js';
+import { measurePerf } from '../../perf/index.js';
+import { isDictionaryDefinitionInlineInternal, isDictionaryFileDefinitionInternal } from '../../Settings/index.js';
 import { AutoResolveWeakCache, AutoResolveWeakWeakCache } from '../../util/AutoResolve.js';
 import { toError } from '../../util/errors.js';
 import { SimpleCache } from '../../util/simpleCache.js';
@@ -42,7 +95,7 @@ export class DictionaryLoader {
             if (entry) {
                 return entry.pending.then(([dictionary]) => dictionary);
             }
-            const loadedEntry = this.loadEntry(def.path, def);
+            const loadedEntry = this.loadEntry(def.btrie || def.path, def);
             this.setCacheEntry(key, loadedEntry, def);
             this.keepAliveCache.set(def, loadedEntry);
             return loadedEntry.pending.then(([dictionary]) => dictionary);
@@ -98,8 +151,8 @@ export class DictionaryLoader {
     loadEntry(fileOrUri, options, now = Date.now()) {
         const url = toFileURL(fileOrUri);
         options = this.normalizeOptions(url, 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 pDictionary = load(this.reader, url, options).catch((e) => createFailedToLoadDictionary(options.name, fileOrUri, new SpellingDictionaryLoadError(url.href, options, e, 'failed to load'), options));
+        const pStat = this.getStat(url);
         const pending = Promise.all([pDictionary, pStat]);
         const sig = now + Math.random();
         const entry = {
@@ -153,12 +206,19 @@ export class DictionaryLoader {
     }
 }
 function toReader(fs) {
-    async function readFile(url) {
-        return (await fs.readFile(url)).getText();
+    function readResource(url) {
+        return fs.readFile(url);
+    }
+    async function readText(url) {
+        return (await readResource(url)).getText();
+    }
+    async function read(url) {
+        return (await readResource(url)).getBytes();
     }
     return {
-        read: readFile,
-        readLines: async (filename) => toLines(await readFile(filename)),
+        read,
+        readText,
+        readLines: async (filename) => toLines(await readText(filename)),
     };
 }
 const importantOptionKeys = ['name', 'noSuggest', 'useCompounds', 'type'];
@@ -170,45 +230,72 @@ function determineType(uri, opts) {
     const t = (opts.type && opts.type in loaders && opts.type) || 'S';
     const defLoaderType = t;
     const defType = uri.pathname.endsWith('.trie.gz') ? 'T' : defLoaderType;
-    const regTrieTest = /\.trie\b/i;
+    const regTrieTest = /\.b?trie\b/i;
     return regTrieTest.test(uri.pathname) ? 'T' : defType;
 }
-function load(reader, uri, options) {
+async function load(reader, uri, options) {
     const type = determineType(uri, options);
     const loader = loaders[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(lines, filename, options) {
-    const words = pipe(lines, 
-    // Remove comments
-    opMap((line) => line.replaceAll(/#.*/g, '')), 
-    // Split on everything else
-    opConcatMap((line) => line.split(/[^\w\p{L}\p{M}'’]+/gu)), opFilter((word) => !!word));
-    return createSpellingDictionary(words, options.name, filename.toString(), options);
+    const env_1 = { stack: [], error: void 0, hasError: false };
+    try {
+        const lines = await reader.readLines(filename);
+        const _ = __addDisposableResource(env_1, measurePerf('legacyWords'), false);
+        const words = pipe(lines, 
+        // Remove comments
+        opMap((line) => line.replaceAll(/#.*/g, '')), 
+        // Split on everything else
+        opConcatMap((line) => line.split(/[^\w\p{L}\p{M}'’]+/gu)), opFilter((word) => !!word));
+        return createSpellingDictionary(words, options.name, filename.toString(), options, true);
+    }
+    catch (e_1) {
+        env_1.error = e_1;
+        env_1.hasError = true;
+    }
+    finally {
+        __disposeResources(env_1);
+    }
 }
 async function wordsPerLineWordList(reader, filename, options) {
     const lines = await reader.readLines(filename);
-    return _wordsPerLineWordList(lines, filename.toString(), options);
-}
-function _wordsPerLineWordList(lines, filename, options) {
     const words = pipe(lines, 
     // Remove comments
     opMap((line) => line.replaceAll(/#.*/g, '')), 
     // Split on everything else
     opConcatMap((line) => line.split(/\s+/gu)), opFilter((word) => !!word));
-    return createSpellingDictionary(words, options.name, filename, options);
+    return createSpellingDictionary(words, options.name, filename.href, options, true);
 }
 async function loadSimpleWordList(reader, filename, options) {
-    const lines = await reader.readLines(filename);
-    return createSpellingDictionary(lines, options.name, filename.href, options);
+    const env_2 = { stack: [], error: void 0, hasError: false };
+    try {
+        const lines = await reader.readLines(filename);
+        const _ = __addDisposableResource(env_2, measurePerf('loadSimpleWordList'), false);
+        return createSpellingDictionary(lines, options.name, filename.href, options);
+    }
+    catch (e_2) {
+        env_2.error = e_2;
+        env_2.hasError = true;
+    }
+    finally {
+        __disposeResources(env_2);
+    }
 }
 async function loadTrie(reader, filename, options) {
-    const content = await reader.read(filename);
-    return createSpellingDictionaryFromTrieFile(content, options.name, filename.href, options);
+    const env_3 = { stack: [], error: void 0, hasError: false };
+    try {
+        const content = await reader.read(filename);
+        const _ = __addDisposableResource(env_3, measurePerf('loadTrie'), false);
+        return createSpellingDictionaryFromTrieFile(content, options.name, filename.href, options);
+    }
+    catch (e_3) {
+        env_3.error = e_3;
+        env_3.hasError = true;
+    }
+    finally {
+        __disposeResources(env_3);
+    }
 }
 function toLines(content) {
     return content.split(/\n|\r\n|\r/);

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

@@ -1,6 +1,6 @@
 import type { SpellingDictionary } from 'cspell-dictionary';
 import type { VFileSystem } from '../fileSystem.js';
-import type { DictionaryDefinitionInternal } from '../Models/CSpellSettingsInternalDef.js';
+import type { DictionaryDefinitionInternal } from '../Settings/index.js';
 import { DictionaryLoader } from './DictionaryController/index.js';
 export type { LoadOptions } from './DictionaryController/index.js';
 export declare function getDictionaryLoader(vfs?: VFileSystem): DictionaryLoader;

package/dist/lib/index.d.ts

@@ -13,11 +13,11 @@ export { createTextDocument, updateTextDocument } from './Models/TextDocument.js
 export type { PerfTimer } from './perf/index.js';
 export { createPerfTimer } from './perf/index.js';
 export type { ConfigurationDependencies, CSpellConfigFile, ICSpellConfigFile, ImportFileRefWithError, } from './Settings/index.js';
-export { calcOverrideSettings, checkFilenameMatchesGlob, createConfigLoader, currentSettingsFileVersion, defaultConfigFilenames, defaultFileName, ENV_CSPELL_GLOB_ROOT, extractDependencies, extractImportErrors, finalizeSettings, getCachedFileSize, getDefaultBundledSettingsAsync, getDefaultConfigLoader, getDefaultSettings, getGlobalSettings, getGlobalSettingsAsync, getSources, ImportError, loadConfig, loadPnP, mergeInDocSettings, mergeSettings, readConfigFile, readRawSettings, readSettings, readSettingsFiles, resolveConfigFileImports, searchForConfig, sectionCSpell, } from './Settings/index.js';
+export { calcOverrideSettings, checkFilenameMatchesGlob, createConfigLoader, currentSettingsFileVersion, defaultConfigFilenames, defaultFileName, ENV_CSPELL_GLOB_ROOT, extractDependencies, extractImportErrors, finalizeSettings, getCachedFileSize, getDefaultBundledSettingsAsync, getDefaultConfigLoader, getDefaultSettings, getGlobalSettings, getGlobalSettingsAsync, getSources, ImportError, loadConfig, loadPnP, mergeInDocSettings, mergeSettings, readConfigFile, readRawSettings, readSettings, readSettingsFiles, resolveConfigFileImports, searchForConfig, sectionCSpell, toCSpellSettingsWithOutSourceTrace, } from './Settings/index.js';
 export { defaultFileName as defaultSettingsFilename } from './Settings/index.js';
 export * as Link from './Settings/index.link.js';
 export { combineTextAndLanguageSettings, combineTextAndLanguageSettings as constructSettingsForText, } from './Settings/TextDocumentSettings.js';
-export { determineFinalDocumentSettings, type DetermineFinalDocumentSettingsResult, spellCheckDocument, spellCheckFile, type SpellCheckFileOptions, type SpellCheckFilePerf, type SpellCheckFileResult, } from './spellCheckFile.js';
+export { determineFinalDocumentSettings, type DetermineFinalDocumentSettingsResult, spellCheckDocument, spellCheckDocumentRPC, spellCheckFile, type SpellCheckFileOptions, type SpellCheckFilePerf, type SpellCheckFileResult, } from './spellCheckFile.js';
 export { CompoundWordsMethod, createSpellingDictionary, createCollection as createSpellingDictionaryCollection, isSpellingDictionaryLoadError, refreshDictionaryCache, type SpellingDictionary, type SpellingDictionaryCollection, SpellingDictionaryLoadError, type SuggestionCollector, type SuggestionResult, type SuggestOptions, } from './SpellingDictionary/index.js';
 export type { SuggestedWord, SuggestionOptions, SuggestionsForWordResult } from './suggestions.js';
 export { SuggestionError, suggestionsForWord, suggestionsForWords } from './suggestions.js';

package/dist/lib/index.js

@@ -7,11 +7,11 @@ export { getLanguagesForBasename as getLanguageIdsForBaseFilename, getLanguagesF
 export { getDictionary } from './getDictionary.js';
 export { createTextDocument, updateTextDocument } from './Models/TextDocument.js';
 export { createPerfTimer } from './perf/index.js';
-export { calcOverrideSettings, checkFilenameMatchesGlob, createConfigLoader, currentSettingsFileVersion, defaultConfigFilenames, defaultFileName, ENV_CSPELL_GLOB_ROOT, extractDependencies, extractImportErrors, finalizeSettings, getCachedFileSize, getDefaultBundledSettingsAsync, getDefaultConfigLoader, getDefaultSettings, getGlobalSettings, getGlobalSettingsAsync, getSources, ImportError, loadConfig, loadPnP, mergeInDocSettings, mergeSettings, readConfigFile, readRawSettings, readSettings, readSettingsFiles, resolveConfigFileImports, searchForConfig, sectionCSpell, } from './Settings/index.js';
+export { calcOverrideSettings, checkFilenameMatchesGlob, createConfigLoader, currentSettingsFileVersion, defaultConfigFilenames, defaultFileName, ENV_CSPELL_GLOB_ROOT, extractDependencies, extractImportErrors, finalizeSettings, getCachedFileSize, getDefaultBundledSettingsAsync, getDefaultConfigLoader, getDefaultSettings, getGlobalSettings, getGlobalSettingsAsync, getSources, ImportError, loadConfig, loadPnP, mergeInDocSettings, mergeSettings, readConfigFile, readRawSettings, readSettings, readSettingsFiles, resolveConfigFileImports, searchForConfig, sectionCSpell, toCSpellSettingsWithOutSourceTrace, } from './Settings/index.js';
 export { defaultFileName as defaultSettingsFilename } from './Settings/index.js';
 export * as Link from './Settings/index.link.js';
 export { combineTextAndLanguageSettings, combineTextAndLanguageSettings as constructSettingsForText, } from './Settings/TextDocumentSettings.js';
-export { determineFinalDocumentSettings, spellCheckDocument, spellCheckFile, } from './spellCheckFile.js';
+export { determineFinalDocumentSettings, spellCheckDocument, spellCheckDocumentRPC, spellCheckFile, } from './spellCheckFile.js';
 export { CompoundWordsMethod, createSpellingDictionary, createCollection as createSpellingDictionaryCollection, isSpellingDictionaryLoadError, refreshDictionaryCache, SpellingDictionaryLoadError, } from './SpellingDictionary/index.js';
 export { SuggestionError, suggestionsForWord, suggestionsForWords } from './suggestions.js';
 export { DocumentValidator, shouldCheckDocument } from './textValidation/index.js';

package/dist/lib/perf/index.d.ts

@@ -1,3 +1,4 @@
 export type { PerfTimer } from './timer.js';
 export { createPerfTimer } from './timer.js';
+export { measurePerf } from '@cspell/cspell-performance-monitor';
 //# sourceMappingURL=index.d.ts.map

package/dist/lib/perf/index.js

@@ -1,2 +1,3 @@
 export { createPerfTimer } from './timer.js';
+export { measurePerf } from '@cspell/cspell-performance-monitor';
 //# sourceMappingURL=index.js.map

package/dist/lib/spellCheckFile.d.ts

@@ -1,6 +1,7 @@
 import type { CSpellSettingsWithSourceTrace, CSpellUserSettings } from '@cspell/cspell-types';
-import { ICSpellConfigFile } from 'cspell-config-lib';
+import type { ICSpellConfigFile } from 'cspell-config-lib';
 import type { Document, DocumentWithText } from './Document/index.js';
+import type { ImportFileRefWithError } from './Settings/index.js';
 import type { Uri } from './util/IUri.js';
 import type { ValidateTextOptions, ValidationIssue } from './validator.js';
 export interface SpellCheckFileOptions extends ValidateTextOptions, Pick<CSpellUserSettings, 'unknownWords'> {
@@ -38,6 +39,8 @@ export interface SpellCheckFileResult {
     issues: ValidationIssue[];
     checked: boolean;
     errors: Error[] | undefined;
+    configErrors?: ImportFileRefWithError[] | undefined;
+    dictionaryErrors?: Map<string, Error[]> | undefined;
     perf?: SpellCheckFilePerf;
 }
 /**
@@ -54,6 +57,13 @@ export declare function spellCheckFile(file: string | Uri | URL, options: SpellC
  * @param settings - default settings to use.
  */
 export declare function spellCheckDocument(document: Document | DocumentWithText, options: SpellCheckFileOptions, settingsOrConfigFile: CSpellUserSettings | ICSpellConfigFile): Promise<SpellCheckFileResult>;
+/**
+ * Spell Check a Document.
+ * @param document - document to be checked. If `document.text` is `undefined` the file will be loaded
+ * @param options - options to control checking
+ * @param settings - default settings to use.
+ */
+export declare function spellCheckDocumentRPC(document: Document | DocumentWithText, options: SpellCheckFileOptions, settingsOrConfigFile: CSpellUserSettings | ICSpellConfigFile): Promise<SpellCheckFileResult>;
 export interface DetermineFinalDocumentSettingsResult {
     document: DocumentWithText;
     settings: CSpellSettingsWithSourceTrace;

package/dist/lib/spellCheckFile.js

@@ -3,9 +3,11 @@ import { isBinaryDoc } from './Document/isBinaryDoc.js';
 import { documentToTextDocument, resolveDocument } from './Document/resolveDocument.js';
 import { createTextDocument } from './Models/TextDocument.js';
 import { createPerfTimer } from './perf/index.js';
+import { cloneSettingsForExport } from './Settings/sanitizeSettings.js';
 import { determineTextDocumentSettings } from './textValidation/determineTextDocumentSettings.js';
 import { DocumentValidator } from './textValidation/index.js';
 import { isError } from './util/errors.js';
+import { memoizeLastCall } from './util/memoizeLastCall.js';
 import { toUri } from './util/Uri.js';
 /**
  * Spell Check a file
@@ -73,6 +75,21 @@ export async function spellCheckDocument(document, options, settingsOrConfigFile
         };
     }
 }
+const memoizedCloneSettingsForExport = memoizeLastCall(cloneSettingsForExport);
+function sanitizeSettingsForExport(settings) {
+    return settings ? memoizedCloneSettingsForExport(settings) : {};
+}
+/**
+ * Spell Check a Document.
+ * @param document - document to be checked. If `document.text` is `undefined` the file will be loaded
+ * @param options - options to control checking
+ * @param settings - default settings to use.
+ */
+export async function spellCheckDocumentRPC(document, options, settingsOrConfigFile) {
+    const result = { ...(await spellCheckDocument(document, options, settingsOrConfigFile)) };
+    result.settingsUsed = sanitizeSettingsForExport(result.settingsUsed);
+    return result;
+}
 async function spellCheckFullDocument(document, options, settingsOrConfigFile) {
     // if (options.skipValidation) {
     //     return {
@@ -95,17 +112,18 @@ async function spellCheckFullDocument(document, options, settingsOrConfigFile) {
     Object.assign(perf, Object.fromEntries(Object.entries(docValidator.perfTiming).map(([k, v]) => ['_' + k, v])));
     const prep = docValidator._getPreparations();
     if (docValidator.errors.length) {
+        const settingsUsed = prep?.localConfig ||
+            (satisfiesCSpellConfigFile(settingsOrConfigFile) ? settingsOrConfigFile.settings : settingsOrConfigFile);
         return {
             document,
             options,
-            settingsUsed: prep?.localConfig ||
-                (satisfiesCSpellConfigFile(settingsOrConfigFile)
-                    ? settingsOrConfigFile.settings
-                    : settingsOrConfigFile),
+            settingsUsed,
             localConfigFilepath: prep?.localConfigFilepath,
             issues: [],
             checked: false,
             errors: docValidator.errors,
+            configErrors: docValidator.getConfigErrors(),
+            dictionaryErrors: docValidator.getDictionaryErrors(),
             perf,
         };
     }
@@ -121,6 +139,8 @@ async function spellCheckFullDocument(document, options, settingsOrConfigFile) {
         issues,
         checked: docValidator.shouldCheckDocument(),
         errors: undefined,
+        configErrors: docValidator.getConfigErrors(),
+        dictionaryErrors: docValidator.getDictionaryErrors(),
         perf,
     };
     timer.end();

package/dist/lib/suggestions.d.ts

@@ -1,5 +1,5 @@
 import type { CSpellSettings, LocaleId } from '@cspell/cspell-types';
-import { ICSpellConfigFile } from 'cspell-config-lib';
+import type { ICSpellConfigFile } from 'cspell-config-lib';
 import type { LanguageId } from './fileTypes.js';
 import type { SpellingDictionaryCollection, SuggestionResult, SuggestOptions } from './SpellingDictionary/index.js';
 export interface WordSuggestion extends SuggestionResult {

package/dist/lib/suggestions.js

@@ -4,7 +4,7 @@ import { finalizeSettings, getDefaultSettings, getGlobalSettingsAsync, mergeSett
 import { calcSettingsForLanguageId, isValidLocaleIntlFormat, normalizeLocaleIntl, } from './Settings/LanguageSettings.js';
 import { getDictionaryInternal, refreshDictionaryCache } from './SpellingDictionary/index.js';
 import { createAutoResolveCache } from './util/AutoResolve.js';
-import { memorizeLastCall } from './util/memorizeLastCall.js';
+import { memoizeLastCall } from './util/memoizeLastCall.js';
 import * as util from './util/util.js';
 const emptySuggestionOptions = Object.freeze({});
 const emptyCSpellSettings = Object.freeze({});
@@ -14,14 +14,14 @@ export async function* suggestionsForWords(words, options, settings) {
         yield await suggestionsForWord(word, options, cspellSettings);
     }
 }
-const memorizeSuggestions = memorizeLastCall(cacheSuggestionsForWord);
+const memoizeSuggestions = memoizeLastCall(cacheSuggestionsForWord);
 function cacheSuggestionsForWord(options, settings) {
     const cache = createAutoResolveCache();
     return (word) => cache.get(word, (word) => _suggestionsForWord(word, options, settings));
 }
 export async function suggestionsForWord(word, options = emptySuggestionOptions, settings = emptyCSpellSettings) {
     const cspellSettings = satisfiesCSpellConfigFile(settings) ? await resolveConfigFileImports(settings) : settings;
-    return memorizeSuggestions(options, cspellSettings)(word);
+    return memoizeSuggestions(options, cspellSettings)(word);
 }
 async function _suggestionsForWord(word, options, settings) {
     const { languageId, locale: language, includeDefaultConfig = true, dictionaries } = options;

package/dist/lib/textValidation/cleanValidationIssue.d.ts

@@ -0,0 +1,3 @@
+import type { ValidationIssue } from '../Models/ValidationIssue.js';
+export declare function cleanValidationIssue(issue: ValidationIssue): ValidationIssue;
+//# sourceMappingURL=cleanValidationIssue.d.ts.map

package/dist/lib/textValidation/cleanValidationIssue.js

@@ -0,0 +1,21 @@
+import { cloneInto, copy0, copy1 } from '../util/clone.js';
+export function cleanValidationIssue(issue) {
+    const cleanIssue = {};
+    cloneInto(issue, cleanIssue, ValidationIssueHandlers);
+    return cleanIssue;
+}
+const ValidationIssueHandlers = {
+    text: copy0,
+    offset: copy0,
+    message: copy0,
+    line: copy1,
+    length: copy0,
+    issueType: copy0,
+    hasPreferredSuggestions: copy0,
+    hasSimpleSuggestions: copy0,
+    isFlagged: copy0,
+    isFound: copy0,
+    suggestions: copy1,
+    suggestionsEx: copy1,
+};
+//# sourceMappingURL=cleanValidationIssue.js.map

package/dist/lib/textValidation/determineTextDocumentSettings.d.ts

@@ -1,6 +1,6 @@
 import type { CSpellUserSettings } from '@cspell/cspell-types';
-import type { CSpellSettingsInternal } from '../Models/CSpellSettingsInternalDef.js';
 import type { TextDocument, TextDocumentRef } from '../Models/TextDocument.js';
+import type { CSpellSettingsInternal } from '../Settings/index.js';
 /**
  * Combines all relevant setting values into a final configuration to be used for spell checking.
  * It applies any overrides and appropriate language settings by taking into account the document type (languageId)

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

@@ -1,15 +1,16 @@
 import type { CSpellUserSettings, MappedText, ParsedText } from '@cspell/cspell-types';
-import { ICSpellConfigFile } from 'cspell-config-lib';
-import type { CSpellSettingsInternal, CSpellSettingsInternalFinalized } from '../Models/CSpellSettingsInternalDef.js';
+import type { ICSpellConfigFile } from 'cspell-config-lib';
 import type { ExtendedSuggestion } from '../Models/Suggestion.js';
 import type { TextDocument, TextDocumentRef } from '../Models/TextDocument.js';
 import type { ValidationIssue } from '../Models/ValidationIssue.js';
+import type { ImportFileRefWithError } from '../Settings/index.js';
+import type { CSpellSettingsInternal, CSpellSettingsInternalFinalized } from '../Settings/index.js';
 import type { SpellingDictionaryCollection } from '../SpellingDictionary/index.js';
 import type { WordSuggestion } from '../suggestions.js';
 import type { MatchRange } from '../util/TextRange.js';
 import type { TextValidator } from './lineValidatorFactory.js';
 import type { SimpleRange } from './parsedText.js';
-import { TraceResult } from './traceWord.js';
+import type { TraceResult } from './traceWord.js';
 import type { ValidateTextOptions } from './ValidateTextOptions.js';
 import type { ValidationOptions } from './ValidationTypes.js';
 export interface DocumentValidatorOptions extends ValidateTextOptions {
@@ -101,6 +102,8 @@ export declare class DocumentValidator {
     private genSuggestions;
     private adjustSuggestions;
     getFinalizedDocSettings(): CSpellSettingsInternal;
+    getConfigErrors(): ImportFileRefWithError[] | undefined;
+    getDictionaryErrors(): Map<string, Error[]> | undefined;
     /**
      * Returns true if the final result of the configuration calculation results
      * in the document being enabled. Note: in some cases, checking the document

package/dist/lib/textValidation/docValidator.js

@@ -5,14 +5,15 @@ import { toFilePathOrHref, toFileURL } from '@cspell/url';
 import { satisfiesCSpellConfigFile } from 'cspell-config-lib';
 import { getGlobMatcherForExcluding } from '../globs/getGlobMatcher.js';
 import { documentUriToURL, updateTextDocument } from '../Models/TextDocument.js';
-import { createPerfTimer } from '../perf/index.js';
-import { finalizeSettings, loadConfig, mergeSettings, resolveConfigFileImports, resolveSettingsImports, searchForConfig, } from '../Settings/index.js';
+import { createPerfTimer, measurePerf } from '../perf/index.js';
+import { extractImportErrors, finalizeSettings, loadConfig, mergeSettings, resolveConfigFileImports, resolveSettingsImports, searchForConfig, } from '../Settings/index.js';
 import { validateInDocumentSettings } from '../Settings/InDocSettings.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';
 import { uriToFilePath } from '../util/Uri.js';
+import { cleanValidationIssue } from './cleanValidationIssue.js';
 import { defaultMaxDuplicateProblems, defaultMaxNumberOfProblems } from './defaultConstants.js';
 import { determineTextDocumentSettings } from './determineTextDocumentSettings.js';
 import { textValidatorFactory } from './lineValidatorFactory.js';
@@ -82,13 +83,14 @@ export class DocumentValidator {
                 ? timePromise(this.perfTiming, '__searchForDocumentConfig', searchForDocumentConfig(this._document, settings, settings))
                 : undefined;
         if (pLocalConfig) {
-            timePromise(this.perfTiming, '_loadConfig', pLocalConfig);
+            timePromise(this.perfTiming, '_loadConfig', pLocalConfig).catch(() => undefined);
         }
         const localConfig = (await catchPromiseError(pLocalConfig, (e) => this.addPossibleError(e))) || {};
-        this.addPossibleError(localConfig?.__importRef?.error);
+        extractImportErrors(localConfig).forEach((e) => this.addPossibleError(e.error));
         const config = mergeSettings(settings, localConfig);
         const docSettings = await timePromise(this.perfTiming, '_determineTextDocumentSettings', determineTextDocumentSettings(this._document, config));
         const dict = await timePromise(this.perfTiming, '_getDictionaryInternal', getDictionaryInternal(docSettings));
+        const stopMeasure = measurePerf('DocumentValidator._prepareAsync');
         const recGlobMatcherTime = recordPerfTime(this.perfTiming, '_GlobMatcher');
         const matcher = getGlobMatcherForExcluding(localConfig?.ignorePaths);
         const uri = this._document.uri;
@@ -120,6 +122,7 @@ export class DocumentValidator {
         this._ready = true;
         this._preparationTime = timer.elapsed;
         this.perfTiming.prepTime = this._preparationTime;
+        stopMeasure();
     }
     async _updatePrep() {
         assert(this._preparations, ERROR_NOT_PREPARED);
@@ -127,6 +130,7 @@ export class DocumentValidator {
         const prep = this._preparations;
         const docSettings = await determineTextDocumentSettings(this._document, prep.config);
         const dict = await getDictionaryInternal(docSettings);
+        const stopMeasure = measurePerf('DocumentValidator._updatePrep');
         const shouldCheck = docSettings.enabled ?? true;
         const finalSettings = finalizeSettings(docSettings);
         const validateOptions = settingsToValidateOptions(finalSettings);
@@ -144,6 +148,7 @@ export class DocumentValidator {
             textValidator,
         };
         this._preparationTime = timer.elapsed;
+        stopMeasure();
     }
     /**
      * The amount of time in ms to prepare for validation.
@@ -241,7 +246,9 @@ export class DocumentValidator {
             const spellingIssues = forceCheck || this.shouldCheckDocument() ? [...this._checkParsedText(this._parse())] : [];
             const directiveIssues = this.checkDocumentDirectives();
             // console.log('Stats: %o', this._preparations.textValidator.lineValidator.dict.stats());
-            const allIssues = [...spellingIssues, ...directiveIssues].sort((a, b) => a.offset - b.offset);
+            const allIssues = [...spellingIssues, ...directiveIssues]
+                .map(cleanValidationIssue)
+                .sort((a, b) => a.offset - b.offset);
             return allIssues;
         }
         finally {
@@ -297,6 +304,7 @@ export class DocumentValidator {
         const { maxNumberOfProblems = defaultMaxNumberOfProblems, maxDuplicateProblems = defaultMaxDuplicateProblems } = this._preparations.validateOptions;
         let numProblems = 0;
         const mapOfProblems = new Map();
+        const stopMeasure = measurePerf('DocumentValidator._checkParsedText');
         for (const pText of parsedTexts) {
             for (const issue of this.check(pText)) {
                 const { text } = issue;
@@ -309,6 +317,7 @@ export class DocumentValidator {
                     return;
             }
         }
+        stopMeasure();
     }
     addPossibleError(error) {
         if (!error)
@@ -354,6 +363,20 @@ export class DocumentValidator {
         assert(this._preparations, ERROR_NOT_PREPARED);
         return this._preparations.docSettings;
     }
+    getConfigErrors() {
+        const settings = this.getFinalizedDocSettings();
+        const errors = extractImportErrors(settings);
+        return errors.length ? errors : undefined;
+    }
+    getDictionaryErrors() {
+        assert(this._ready);
+        assert(this._preparations, ERROR_NOT_PREPARED);
+        const { dictionary } = this._preparations;
+        const errors = dictionary.dictionaries
+            .map((dict) => [dict.name, dict.getErrors?.()])
+            .filter((entry) => (entry[1] && entry[1].length > 0) || false);
+        return errors.length ? new Map(errors) : undefined;
+    }
     /**
      * Returns true if the final result of the configuration calculation results
      * in the document being enabled. Note: in some cases, checking the document
@@ -422,7 +445,7 @@ export async function shouldCheckDocument(doc, options, settings) {
                 ? searchForDocumentConfig(doc, settings, settings)
                 : undefined;
         const localConfig = (await catchPromiseError(pLocalConfig, addPossibleError)) || {};
-        addPossibleError(localConfig?.__importRef?.error);
+        extractImportErrors(localConfig).forEach((e) => addPossibleError(e.error));
         const config = mergeSettings(settings, localConfig);
         const matcher = getGlobMatcherForExcluding(localConfig?.ignorePaths);
         // eslint-disable-next-line unicorn/prefer-regexp-test

package/dist/lib/textValidation/isRandomString.d.ts

@@ -1,4 +1,4 @@
-import { TextOffset } from '@cspell/cspell-types';
+import type { TextOffset } from '@cspell/cspell-types';
 /**
  * Try to detect if a string is a random string of characters or is it camel case / snake case words.
  * @param s - string to check

package/dist/lib/textValidation/lineValidatorFactory.js

@@ -13,7 +13,7 @@ import { isWordValidWithEscapeRetry } from './isWordValid.js';
 import { mapRangeBackToOriginalPos } from './parsedText.js';
 const MIN_HEX_SEQUENCE_LENGTH = 8;
 export function lineValidatorFactory(sDict, options) {
-    const { minWordLength = defaultMinWordLength, flagWords = [], allowCompoundWords = false, ignoreCase = true, ignoreRandomStrings = defaultCSpellSettings.ignoreRandomStrings, minRandomLength = defaultCSpellSettings.minRandomLength, unknownWords = unknownWordsChoices.ReportAll, } = options;
+    const { minWordLength = defaultMinWordLength, flagWords = [], allowCompoundWords = false, ignoreCase = true, ignoreRandomStrings = defaultCSpellSettings.ignoreRandomStrings, minRandomLength = defaultCSpellSettings.minRandomLength, unknownWords = unknownWordsChoices.ReportAll, numSuggestions, } = options;
     const hasWordOptions = {
         ignoreCase,
         useCompounds: allowCompoundWords || undefined, // let the dictionaries decide on useCompounds if allow is false
@@ -67,17 +67,21 @@ export function lineValidatorFactory(sDict, options) {
         return autoResolve(cacheGetPreferredSuggestions, word, () => dictCol.getPreferredSuggestions(word));
     }
     const cacheHasSimpleSuggestions = new Map();
-    function hasSimpleSuggestions(word) {
+    function getSimpleSuggestions(word) {
+        const numSug = numSuggestions ?? 5;
         return autoResolve(cacheHasSimpleSuggestions, word, () => {
             const sugs = dictCol.suggest(word, {
                 numSuggestions: 1,
                 compoundMethod: 0,
-                includeTies: false,
+                includeTies: true, // We want the top suggestions even if there are ties
                 ignoreCase,
                 timeout: 100,
                 numChanges: 1.8, // Only consider very simple changes (1 edit distance plus case changes)
             });
-            return !!sugs.length;
+            if (sugs.length > numSug) {
+                sugs.length = numSug;
+            }
+            return sugs;
         });
     }
     function isWordFlagged(wo) {
@@ -92,7 +96,11 @@ export function lineValidatorFactory(sDict, options) {
         if (!sugs?.length) {
             issue.hasPreferredSuggestions = sugs !== undefined ? false : undefined;
             if (unknownWords === unknownWordsChoices.ReportSimple) {
-                issue.hasSimpleSuggestions = hasSimpleSuggestions(issue.text);
+                const sug = getSimpleSuggestions(issue.text);
+                issue.hasSimpleSuggestions = !!sug.length;
+                if (sug.length) {
+                    issue.suggestionsEx = sug.map((s) => ({ ...s, isPreferred: !!s.isPreferred }));
+                }
             }
             return issue;
         }

package/dist/lib/textValidation/settingsToValidateOptions.d.ts

@@ -1,4 +1,4 @@
-import type { CSpellSettingsInternalFinalized } from '../Models/CSpellSettingsInternalDef.js';
+import type { CSpellSettingsInternalFinalized } from '../Settings/index.js';
 import type { ValidationOptions } from './ValidationTypes.js';
 export declare function settingsToValidateOptions(settings: CSpellSettingsInternalFinalized): ValidationOptions;
 //# sourceMappingURL=settingsToValidateOptions.d.ts.map

package/dist/lib/textValidation/traceWord.d.ts

@@ -31,6 +31,7 @@ export interface TraceResult extends Array<DictionaryTraceResult> {
 }
 export interface TraceOptions extends Pick<CSpellSettingsWithSourceTrace, 'source' | 'allowCompoundWords'> {
     ignoreCase?: boolean;
+    compoundSeparator?: string | undefined;
 }
 export declare function traceWord(word: string, dictCollection: SpellingDictionaryCollection, config: TraceOptions): TraceResult;
 export {};