cspell-lib 9.0.2 → 9.1.1

package/dist/lib/Models/CSpellSettingsInternalDef.d.ts

@@ -1,4 +1,4 @@
-import type { AdvancedCSpellSettingsWithSourceTrace, CSpellSettingsWithSourceTrace, DictionaryDefinition, DictionaryDefinitionAugmented, DictionaryDefinitionCustom, DictionaryDefinitionInline, DictionaryDefinitionPreferred, Parser } from '@cspell/cspell-types';
+import type { AdvancedCSpellSettingsWithSourceTrace, CSpellSettingsWithSourceTrace, DictionaryDefinition, DictionaryDefinitionAugmented, DictionaryDefinitionCustom, DictionaryDefinitionInline, DictionaryDefinitionPreferred, DictionaryDefinitionSimple, Parser } from '@cspell/cspell-types';
 import type { WeightMap } from 'cspell-trie-lib';
 import type { OptionalOrUndefined } from '../util/types.js';
 export declare const SymbolCSpellSettingsInternal: unique symbol;
@@ -13,11 +13,15 @@ export interface CSpellSettingsInternalFinalized extends CSpellSettingsInternal
     includeRegExpList: RegExp[];
 }
 type DictionaryDefinitionCustomUniqueFields = Omit<DictionaryDefinitionCustom, keyof DictionaryDefinitionPreferred>;
-export type DictionaryDefinitionInternal = DictionaryFileDefinitionInternal | DictionaryDefinitionInlineInternal;
+export type DictionaryDefinitionInternal = DictionaryFileDefinitionInternal | DictionaryDefinitionInlineInternal | DictionaryDefinitionSimpleInternal;
 export type DictionaryDefinitionInlineInternal = DictionaryDefinitionInline & {
     /** The path to the config file that contains this dictionary definition */
     readonly __source?: string | undefined;
 };
+export type DictionaryDefinitionSimpleInternal = DictionaryDefinitionSimple & {
+    /** The path to the config file that contains this dictionary definition */
+    readonly __source?: string | undefined;
+};
 export interface DictionaryFileDefinitionInternal extends Readonly<DictionaryDefinitionPreferred>, Readonly<Partial<DictionaryDefinitionCustomUniqueFields>>, Readonly<DictionaryDefinitionAugmented> {
     /**
      * Optional weight map used to improve suggestions.
@@ -36,5 +40,6 @@ export declare function cleanCSpellSettingsInternal(parts?: OptionalOrUndefined<
 export declare function createCSpellSettingsInternal(parts?: OptionalOrUndefined<Partial<CSpellSettingsInternal>>): CSpellSettingsInternal;
 export declare function isCSpellSettingsInternal(cs: CSpellSettingsInternal | CSpellSettingsWithSourceTrace | OptionalOrUndefined<CSpellSettingsInternal | CSpellSettingsWithSourceTrace>): cs is CSpellSettingsInternal;
 export declare function isDictionaryDefinitionInlineInternal(def: DictionaryDefinitionInternal | DictionaryDefinitionInline | DictionaryDefinition): def is DictionaryDefinitionInlineInternal;
+export declare function isDictionaryFileDefinitionInternal(def: DictionaryDefinitionInternal | DictionaryDefinitionInline | DictionaryDefinition): def is DictionaryFileDefinitionInternal;
 export {};
 //# sourceMappingURL=CSpellSettingsInternalDef.d.ts.map

package/dist/lib/Models/CSpellSettingsInternalDef.js

@@ -17,4 +17,7 @@ export function isDictionaryDefinitionInlineInternal(def) {
     const defInline = def;
     return !!(defInline.words || defInline.flagWords || defInline.ignoreWords || defInline.suggestWords);
 }
+export function isDictionaryFileDefinitionInternal(def) {
+    return !!(def.path || def.file);
+}
 //# sourceMappingURL=CSpellSettingsInternalDef.js.map

package/dist/lib/Models/ValidationResult.d.ts

@@ -1,5 +1,5 @@
 import type { Issue, TextOffset as TextOffsetRW } from '@cspell/cspell-types';
-export interface ValidationResult extends TextOffsetRW, Pick<Issue, 'message' | 'issueType'> {
+export interface ValidationResult extends TextOffsetRW, Pick<Issue, 'message' | 'issueType' | 'hasPreferredSuggestions' | 'hasSimpleSuggestions'> {
     line: TextOffsetRW;
     isFlagged?: boolean | undefined;
     isFound?: boolean | undefined;

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

@@ -5,6 +5,7 @@ import { AutoResolveCache } from '../../../util/AutoResolve.js';
 import { FileResolver } from '../../../util/resolveFile.js';
 import type { LoaderResult } from '../pnpLoader.js';
 import { ConfigSearch } from './configSearch.js';
+import { StopSearchAt } from './defaultConfigLoader.js';
 import { normalizeCacheSettings } from './normalizeRawSettings.js';
 import type { PnPSettingsOptional } from './PnPSettings.js';
 import type { CSpellSettingsI, CSpellSettingsWST } from './types.js';
@@ -27,6 +28,11 @@ interface ImportedConfigEntry {
     /** Set of all references used to catch circular references */
     referencedSet: Set<string>;
 }
+export interface SearchForConfigFileOptions {
+    stopSearchAt?: StopSearchAt;
+}
+export interface SearchForConfigOptions extends SearchForConfigFileOptions, PnPSettingsOptional {
+}
 interface CacheMergeConfigFileWithImports {
     pnpSettings: PnPSettingsOptional | undefined;
     referencedBy: string[] | undefined;
@@ -45,10 +51,10 @@ export interface IConfigLoader {
     /**
      * This is an alias for `searchForConfigFile` and `mergeConfigFileWithImports`.
      * @param searchFrom the directory / file URL to start searching from.
-     * @param pnpSettings - related to Using Yarn PNP.
+     * @param options - Optional settings including stop location and Yarn PnP configuration.
      * @returns the resulting settings
      */
-    searchForConfig(searchFrom: URL | string | undefined, pnpSettings?: PnPSettingsOptional): Promise<CSpellSettingsI | undefined>;
+    searchForConfig(searchFrom: URL | string | undefined, options?: SearchForConfigOptions): Promise<CSpellSettingsI | undefined>;
     resolveConfigFileLocation(filenameOrURL: string | URL, relativeTo?: string | URL): Promise<URL | undefined>;
     getGlobalSettingsAsync(): Promise<CSpellSettingsI>;
     /**
@@ -89,6 +95,7 @@ export interface IConfigLoader {
     setIsTrusted(isTrusted: boolean): void;
 }
 export declare class ConfigLoader implements IConfigLoader {
+    #private;
     readonly fs: VFileSystem;
     readonly templateVariables: Record<string, string>;
     onReady: Promise<void>;
@@ -108,20 +115,21 @@ export declare class ConfigLoader implements IConfigLoader {
     protected globalSettings: CSpellSettingsI | undefined;
     protected cspellConfigFileReaderWriter: CSpellConfigFileReaderWriter;
     protected configSearch: ConfigSearch;
+    protected stopSearchAtCache: WeakMap<SearchForConfigFileOptions, URL[] | undefined>;
     protected toDispose: {
         dispose: () => void;
     }[];
     readSettingsAsync(filename: string | URL, relativeTo?: string | URL, pnpSettings?: PnPSettingsOptional): Promise<CSpellSettingsI>;
     readConfigFile(filenameOrURL: string | URL, relativeTo?: string | URL): Promise<CSpellConfigFile | Error>;
-    searchForConfigFileLocation(searchFrom: URL | string | undefined): Promise<URL | undefined>;
-    searchForConfigFile(searchFrom: URL | string | undefined): Promise<CSpellConfigFile | undefined>;
+    searchForConfigFileLocation(searchFrom: URL | string | undefined, stopSearchAt?: URL[] | undefined): Promise<URL | undefined>;
+    searchForConfigFile(searchFrom: URL | string | undefined, stopSearchAt?: URL[]): Promise<CSpellConfigFile | undefined>;
     /**
      *
      * @param searchFrom the directory / file URL to start searching from.
-     * @param pnpSettings - related to Using Yarn PNP.
+     * @param options - Optional settings including stop location and Yarn PnP configuration.
      * @returns the resulting settings
      */
-    searchForConfig(searchFrom: URL | string | undefined, pnpSettings?: PnPSettingsOptional): Promise<CSpellSettingsI | undefined>;
+    searchForConfig(searchFrom: URL | string | undefined, options?: SearchForConfigOptions): Promise<CSpellSettingsI | undefined>;
     getGlobalSettings(): CSpellSettingsI;
     getGlobalSettingsAsync(): Promise<CSpellSettingsI>;
     clearCachedSettingsFiles(): void;

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

@@ -67,6 +67,7 @@ export class ConfigLoader {
     globalSettings;
     cspellConfigFileReaderWriter;
     configSearch;
+    stopSearchAtCache = new WeakMap();
     toDispose = [];
     async readSettingsAsync(filename, relativeTo, pnpSettings) {
         await this.onReady;
@@ -99,18 +100,12 @@ export class ConfigLoader {
             }
         });
     }
-    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
-            (await isDirectory(this.fs, url))) {
-            return this.configSearch.searchForConfig(addTrailingSlash(url));
-        }
-        return this.configSearch.searchForConfig(url);
+    async searchForConfigFileLocation(searchFrom, stopSearchAt) {
+        const searchFromURL = (await this.#normalizeDirURL(searchFrom)) || cwdURL();
+        return this.configSearch.searchForConfig(searchFromURL, stopSearchAt);
     }
-    async searchForConfigFile(searchFrom) {
-        const location = await this.searchForConfigFileLocation(searchFrom);
+    async searchForConfigFile(searchFrom, stopSearchAt) {
+        const location = await this.searchForConfigFileLocation(searchFrom, stopSearchAt);
         if (!location)
             return undefined;
         const file = await this.readConfigFile(location);
@@ -119,14 +114,15 @@ export class ConfigLoader {
     /**
      *
      * @param searchFrom the directory / file URL to start searching from.
-     * @param pnpSettings - related to Using Yarn PNP.
+     * @param options - Optional settings including stop location and Yarn PnP configuration.
      * @returns the resulting settings
      */
-    async searchForConfig(searchFrom, pnpSettings = defaultPnPSettings) {
-        const configFile = await this.searchForConfigFile(searchFrom);
+    async searchForConfig(searchFrom, options) {
+        const stopAt = await this.#extractStopSearchAtURLs(options);
+        const configFile = await this.searchForConfigFile(searchFrom, stopAt);
         if (!configFile)
             return undefined;
-        return this.mergeConfigFileWithImports(configFile, pnpSettings);
+        return this.mergeConfigFileWithImports(configFile, options);
     }
     getGlobalSettings() {
         assert(this.globalSettings, 'Global settings not loaded');
@@ -386,6 +382,33 @@ export class ConfigLoader {
         this.configSearch = new ConfigSearch(searchPlaces, isTrusted ? trustedSearch : unTrustedSearch, this.fs);
         this.cspellConfigFileReaderWriter.setUntrustedExtensions(isTrusted ? [] : defaultJsExtensions);
     }
+    async #extractStopSearchAtURLs(options) {
+        if (!options?.stopSearchAt)
+            return undefined;
+        if (this.stopSearchAtCache.has(options)) {
+            return this.stopSearchAtCache.get(options);
+        }
+        const rawStops = Array.isArray(options.stopSearchAt) ? options.stopSearchAt : [options.stopSearchAt];
+        const stopURLs = await Promise.all(rawStops.map((s) => this.#normalizeDirURL(s)));
+        this.stopSearchAtCache.set(options, stopURLs);
+        return stopURLs;
+    }
+    async #normalizeDirURL(input) {
+        if (!input)
+            return undefined;
+        const url = toFileURL(input, cwdURL());
+        if (url.pathname.endsWith('/'))
+            return url;
+        if (input instanceof URL)
+            return new URL('.', url);
+        if (typeof input === 'string' &&
+            !isUrlLike(input) &&
+            url.protocol === 'file:' &&
+            (await isDirectory(this.fs, url))) {
+            return addTrailingSlash(url);
+        }
+        return new URL('.', url);
+    }
 }
 class ConfigLoaderInternal extends ConfigLoader {
     constructor(vfs) {

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

@@ -7,7 +7,7 @@ export declare class ConfigSearch {
      * @param fs - The file system to use.
      */
     constructor(searchPlaces: readonly string[], allowedExtensionsByProtocol: Map<string, readonly string[]>, fs: VFileSystem);
-    searchForConfig(searchFromURL: URL): Promise<URL | undefined>;
+    searchForConfig(searchFromURL: URL, stopSearchAtURL?: URL[]): Promise<URL | undefined>;
     clearCache(): void;
 }
 /**

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

@@ -19,15 +19,18 @@ export class ConfigSearch {
     constructor(searchPlaces, allowedExtensionsByProtocol, fs) {
         this.#scanner = new DirConfigScanner(searchPlaces, allowedExtensionsByProtocol, fs);
     }
-    searchForConfig(searchFromURL) {
-        const dirUrl = searchFromURL.pathname.endsWith('/') ? searchFromURL : new URL('.', searchFromURL);
-        return this.#findUp(dirUrl);
+    async searchForConfig(searchFromURL, stopSearchAtURL) {
+        const dirUrl = searchFromURL.pathname.endsWith('/') ? searchFromURL : new URL('./', searchFromURL);
+        const stopDirUrls = stopSearchAtURL
+            ? stopSearchAtURL.map((url) => (url.pathname.endsWith('/') ? url : new URL('./', url)))
+            : undefined;
+        return this.#findUp(dirUrl, stopDirUrls);
     }
     clearCache() {
         this.#searchCache.clear();
         this.#scanner.clearCache();
     }
-    #findUp(fromDir) {
+    #findUp(fromDir, stopDirUrls) {
         const searchDirCache = this.#searchCache;
         const cached = searchDirCache.get(fromDir.href);
         if (cached) {
@@ -39,7 +42,7 @@ export class ConfigSearch {
             visit(dir);
             return this.#scanner.scanDirForConfigFile(dir);
         };
-        result = findUpFromUrl(predicate, fromDir, { type: 'file' });
+        result = findUpFromUrl(predicate, fromDir, { type: 'file', ...(stopDirUrls && { stopAt: stopDirUrls }) });
         searchDirCache.set(fromDir.href, result);
         visited.forEach((dir) => searchDirCache.set(dir.href, result));
         return result;

package/dist/lib/Settings/Controller/configLoader/defaultConfigLoader.d.ts

@@ -1,16 +1,17 @@
 import type { CSpellSettings } from '@cspell/cspell-types';
 import type { CSpellConfigFile, ICSpellConfigFile } from 'cspell-config-lib';
-import type { IConfigLoader } from './configLoader.js';
+import type { IConfigLoader, SearchForConfigOptions } from './configLoader.js';
 import type { PnPSettingsOptional } from './PnPSettings.js';
 import type { CSpellSettingsI, CSpellSettingsWST } from './types.js';
 export type { CSpellConfigFile, ICSpellConfigFile } from 'cspell-config-lib';
+export type StopSearchAt = URL | string | (URL | string)[] | undefined;
 /**
  *
  * @param searchFrom the directory / file to start searching from.
- * @param pnpSettings - related to Using Yarn PNP.
+ * @param options - Optional settings including stop location and Yarn PnP configuration.
  * @returns the resulting settings
  */
-export declare function searchForConfig(searchFrom: URL | string | undefined, pnpSettings?: PnPSettingsOptional): Promise<CSpellSettingsI | undefined>;
+export declare function searchForConfig(searchFrom: URL | string | undefined, options?: SearchForConfigOptions): Promise<CSpellSettingsI | undefined>;
 /**
  * Load a CSpell configuration files.
  * @param file - path or package reference to load.

package/dist/lib/Settings/Controller/configLoader/defaultConfigLoader.js

@@ -2,16 +2,15 @@ import { toError } from '../../../util/errors.js';
 import { toFileUrl } from '../../../util/url.js';
 import { getDefaultConfigLoaderInternal } from './configLoader.js';
 import { configErrorToRawSettings, configToRawSettings } from './configToRawSettings.js';
-import { defaultPnPSettings } from './PnPSettings.js';
 const gcl = getDefaultConfigLoaderInternal;
 /**
  *
  * @param searchFrom the directory / file to start searching from.
- * @param pnpSettings - related to Using Yarn PNP.
+ * @param options - Optional settings including stop location and Yarn PnP configuration.
  * @returns the resulting settings
  */
-export function searchForConfig(searchFrom, pnpSettings = defaultPnPSettings) {
-    return gcl().searchForConfig(searchFrom, pnpSettings);
+export function searchForConfig(searchFrom, options) {
+    return gcl().searchForConfig(searchFrom, options);
 }
 /**
  * Load a CSpell configuration files.

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

@@ -29,6 +29,7 @@ export declare function normalizeDictionaryDefs(settings: NormalizeDictionaryDef
         ignoreWords?: string[];
         suggestWords?: string[];
         parser?: import("@cspell/cspell-types").ParserName;
+        unknownWords?: import("@cspell/cspell-types").UnknownWordsChoices | undefined;
     }>[] | undefined;
 }>;
 type NormalizeOverrides = Pick<CSpellUserSettings, 'globRoot' | 'overrides'>;

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

@@ -26,6 +26,7 @@ export declare class DictionaryLoader {
     private isEqual;
     private normalizeOptions;
     private loadInlineDict;
+    private loadSimpleDict;
     private calcKey;
 }
 //# sourceMappingURL=DictionaryLoader.d.ts.map

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

@@ -2,7 +2,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 { isDictionaryDefinitionInlineInternal, isDictionaryFileDefinitionInternal, } from '../../Models/CSpellSettingsInternalDef.js';
 import { AutoResolveWeakCache, AutoResolveWeakWeakCache } from '../../util/AutoResolve.js';
 import { toError } from '../../util/errors.js';
 import { SimpleCache } from '../../util/simpleCache.js';
@@ -37,14 +37,17 @@ export class DictionaryLoader {
         if (isDictionaryDefinitionInlineInternal(def)) {
             return Promise.resolve(this.loadInlineDict(def));
         }
-        const { key, entry } = this.getCacheEntry(def);
-        if (entry) {
-            return entry.pending.then(([dictionary]) => dictionary);
+        if (isDictionaryFileDefinitionInternal(def)) {
+            const { key, entry } = this.getCacheEntry(def);
+            if (entry) {
+                return entry.pending.then(([dictionary]) => dictionary);
+            }
+            const loadedEntry = this.loadEntry(def.path, def);
+            this.setCacheEntry(key, loadedEntry, def);
+            this.keepAliveCache.set(def, loadedEntry);
+            return loadedEntry.pending.then(([dictionary]) => dictionary);
         }
-        const loadedEntry = this.loadEntry(def.path, def);
-        this.setCacheEntry(key, loadedEntry, def);
-        this.keepAliveCache.set(def, loadedEntry);
-        return loadedEntry.pending.then(([dictionary]) => dictionary);
+        return Promise.resolve(this.loadSimpleDict(def));
     }
     /**
      * Check to see if any of the cached dictionaries have changed. If one has changed, reload it.
@@ -138,6 +141,9 @@ export class DictionaryLoader {
     loadInlineDict(def) {
         return this.inlineDictionaryCache.get(def, (def) => createInlineSpellingDictionary(def, def.__source || 'memory'));
     }
+    loadSimpleDict(def) {
+        return createInlineSpellingDictionary({ name: def.name, words: [] }, def.__source || 'memory');
+    }
     calcKey(def) {
         const path = def.path;
         const loaderType = determineType(toFileURL(path), def);

package/dist/lib/spellCheckFile.d.ts

@@ -3,7 +3,7 @@ import { ICSpellConfigFile } from 'cspell-config-lib';
 import type { Document, DocumentWithText } from './Document/index.js';
 import type { Uri } from './util/IUri.js';
 import type { ValidateTextOptions, ValidationIssue } from './validator.js';
-export interface SpellCheckFileOptions extends ValidateTextOptions {
+export interface SpellCheckFileOptions extends ValidateTextOptions, Pick<CSpellUserSettings, 'unknownWords'> {
     /**
      * Optional path to a configuration file.
      * If given, it will be used instead of searching for a configuration file.

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

@@ -1,9 +1,8 @@
-import type { MappedText, TextOffset as TextOffsetRW } from '@cspell/cspell-types';
-import type { ExtendedSuggestion } from '../Models/Suggestion.js';
+import type { Issue, MappedText, ReportingConfiguration, TextOffset as TextOffsetRW } from '@cspell/cspell-types';
 import type { ValidationIssue } from '../Models/ValidationIssue.js';
 export type { TextOffset as TextOffsetRW } from '@cspell/cspell-types';
 export type TextOffsetRO = Readonly<TextOffsetRW>;
-export interface ValidationOptions extends IncludeExcludeOptions {
+export interface ValidationOptions extends IncludeExcludeOptions, ReportingConfiguration {
     maxNumberOfProblems?: number;
     maxDuplicateProblems?: number;
     minWordLength?: number;
@@ -35,10 +34,8 @@ export interface LineSegment {
     /** A segment of text from the line, the offset is relative to the beginning of the document. */
     segment: TextOffsetRO;
 }
-export interface MappedTextValidationResult extends MappedText {
-    isFlagged?: boolean | undefined;
+export interface MappedTextValidationResult extends MappedText, Pick<Issue, 'hasSimpleSuggestions' | 'hasPreferredSuggestions' | 'isFlagged' | 'suggestionsEx'> {
     isFound?: boolean | undefined;
-    suggestionsEx?: ExtendedSuggestion[] | undefined;
 }
 export type TextValidatorFn = (text: MappedText) => Iterable<MappedTextValidationResult>;
 //# sourceMappingURL=ValidationTypes.d.ts.map

package/dist/lib/textValidation/docValidator.js

@@ -174,14 +174,24 @@ export class DocumentValidator {
         const document = this._document;
         let line = undefined;
         function mapToIssue(issue) {
-            const { range, text, isFlagged, isFound, suggestionsEx } = issue;
+            const { range, text, isFlagged, isFound, suggestionsEx, hasPreferredSuggestions, hasSimpleSuggestions } = issue;
             const offset = range[0];
             const length = range[1] - range[0];
             assert(!line || line.offset <= offset);
             if (!line || line.offset + line.text.length <= offset) {
                 line = document.lineAt(offset);
             }
-            return { text, offset, line, length, isFlagged, isFound, suggestionsEx };
+            return {
+                text,
+                offset,
+                line,
+                length,
+                isFlagged,
+                isFound,
+                suggestionsEx,
+                hasPreferredSuggestions,
+                hasSimpleSuggestions,
+            };
         }
         const issues = [...pipeSync(segmenter(parsedText), opConcatMap(textValidator.validate), opMap(mapToIssue))];
         if (!this.options.generateSuggestions) {

package/dist/lib/textValidation/lineValidatorFactory.js

@@ -1,8 +1,9 @@
 import assert from 'node:assert';
 import { opConcatMap, opFilter, pipe } from '@cspell/cspell-pipe/sync';
-import { defaultCSpellSettings } from '@cspell/cspell-types';
+import { defaultCSpellSettings, unknownWordsChoices } from '@cspell/cspell-types';
 import { createCachingDictionary } from 'cspell-dictionary';
 import * as RxPat from '../Settings/RegExpPatterns.js';
+import { autoResolve } from '../util/AutoResolve.js';
 import { extractPossibleWordsFromTextOffset, extractText, extractWordsFromTextOffset, splitWordWithOffset, } from '../util/text.js';
 import { regExpCamelCaseWordBreaksWithEnglishSuffix } from '../util/textRegex.js';
 import { split } from '../util/wordSplitter.js';
@@ -12,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, } = options;
+    const { minWordLength = defaultMinWordLength, flagWords = [], allowCompoundWords = false, ignoreCase = true, ignoreRandomStrings = defaultCSpellSettings.ignoreRandomStrings, minRandomLength = defaultCSpellSettings.minRandomLength, unknownWords = unknownWordsChoices.ReportAll, } = options;
     const hasWordOptions = {
         ignoreCase,
         useCompounds: allowCompoundWords || undefined, // let the dictionaries decide on useCompounds if allow is false
@@ -61,8 +62,23 @@ export function lineValidatorFactory(sDict, options) {
     function isWordIgnored(word) {
         return calcIgnored(getWordInfo(word));
     }
-    function getSuggestions(word) {
-        return dictCol.getPreferredSuggestions(word);
+    const cacheGetPreferredSuggestions = new Map();
+    function getPreferredSuggestions(word) {
+        return autoResolve(cacheGetPreferredSuggestions, word, () => dictCol.getPreferredSuggestions(word));
+    }
+    const cacheHasSimpleSuggestions = new Map();
+    function hasSimpleSuggestions(word) {
+        return autoResolve(cacheHasSimpleSuggestions, word, () => {
+            const sugs = dictCol.suggest(word, {
+                numSuggestions: 1,
+                compoundMethod: 0,
+                includeTies: false,
+                ignoreCase,
+                timeout: 100,
+                numChanges: 1.8, // Only consider very simple changes (1 edit distance plus case changes)
+            });
+            return !!sugs.length;
+        });
     }
     function isWordFlagged(wo) {
         return calcFlagged(getWordInfo(wo.text));
@@ -72,10 +88,17 @@ export function lineValidatorFactory(sDict, options) {
         return word;
     }
     function annotateIssue(issue) {
-        const sugs = getSuggestions(issue.text);
-        if (sugs && sugs.length) {
-            issue.suggestionsEx = sugs;
+        const sugs = getPreferredSuggestions(issue.text);
+        if (!sugs?.length) {
+            issue.hasPreferredSuggestions = sugs !== undefined ? false : undefined;
+            if (unknownWords === unknownWordsChoices.ReportSimple) {
+                issue.hasSimpleSuggestions = hasSimpleSuggestions(issue.text);
+            }
+            return issue;
         }
+        issue.suggestionsEx = sugs;
+        issue.hasPreferredSuggestions = true;
+        issue.hasSimpleSuggestions = true;
         return issue;
     }
     const isFlaggedOrMinLength = (wo) => wo.text.length >= minWordLength || !!wo.isFlagged;
@@ -274,14 +297,14 @@ export function lineValidatorFactory(sDict, options) {
             if (!mismatches.length)
                 return mismatches;
             const hexSequences = !ignoreRandomStrings
-                ? []
+                ? undefined
                 : extractHexSequences(possibleWord.text, MIN_HEX_SEQUENCE_LENGTH)
                     .filter(
                 // Only consider hex sequences that are all upper case or all lower case and contain a `-` or a digit.
                 (w) => (w.text === w.text.toLowerCase() || w.text === w.text.toUpperCase()) &&
                     /[\d-]/.test(w.text))
                     .map((w) => ((w.offset += possibleWord.offset), w));
-            if (hexSequences.length) {
+            if (hexSequences?.length) {
                 mismatches = filterExcludedTextOffsets(mismatches, hexSequences);
             }
             if (mismatches.length) {
@@ -330,10 +353,10 @@ export function textValidatorFactory(dict, options) {
         const segment = { text, offset: 0 };
         const lineSegment = { line: segment, segment };
         function mapBackToOriginSimple(vr) {
-            const { text, offset, isFlagged, isFound, suggestionsEx } = vr;
+            const { text, offset, isFlagged, isFound, suggestionsEx, hasPreferredSuggestions, hasSimpleSuggestions } = vr;
             const r = mapRangeBackToOriginalPos([offset, offset + text.length], map);
             const range = [r[0] + srcOffset, r[1] + srcOffset];
-            return { text, range, isFlagged, isFound, suggestionsEx };
+            return { text, range, isFlagged, isFound, suggestionsEx, hasPreferredSuggestions, hasSimpleSuggestions };
         }
         return [...lineValidatorFn(lineSegment)].map(mapBackToOriginSimple);
     }
@@ -343,7 +366,7 @@ export function textValidatorFactory(dict, options) {
     };
 }
 function filterExcludedTextOffsets(issues, excluded) {
-    if (!excluded.length)
+    if (!excluded?.length)
         return issues;
     const keep = [];
     let i = 0;

package/dist/lib/textValidation/settingsToValidateOptions.js

@@ -4,6 +4,7 @@ export function settingsToValidateOptions(settings) {
         ignoreCase: !(settings.caseSensitive ?? false),
         ignoreRandomStrings: settings.ignoreRandomStrings,
         minRandomLength: settings.minRandomLength,
+        unknownWords: settings.unknownWords || 'report-all',
     };
     return opt;
 }

package/dist/lib/util/findUpFromUrl.d.ts

@@ -3,7 +3,7 @@ type EntryType = 'file' | 'directory' | '!file' | '!directory';
 export type FindUpFileSystem = Pick<VFileSystem, 'findUp'>;
 export interface FindUpURLOptions {
     type?: EntryType;
-    stopAt?: URL;
+    stopAt?: URL | URL[];
     fs?: FindUpFileSystem;
 }
 export type FindUpPredicate = (dir: URL) => URL | undefined | Promise<URL | undefined>;

package/package.json

@@ -4,7 +4,7 @@
     "access": "public",
     "provenance": true
   },
-  "version": "9.0.2",
+  "version": "9.1.1",
   "description": "A library of useful functions used across various cspell tools.",
   "type": "module",
   "sideEffects": false,
@@ -64,22 +64,22 @@
   },
   "homepage": "https://github.com/streetsidesoftware/cspell/tree/main/packages/cspell-lib#readme",
   "dependencies": {
-    "@cspell/cspell-bundled-dicts": "9.0.2",
-    "@cspell/cspell-pipe": "9.0.2",
-    "@cspell/cspell-resolver": "9.0.2",
-    "@cspell/cspell-types": "9.0.2",
-    "@cspell/dynamic-import": "9.0.2",
-    "@cspell/filetypes": "9.0.2",
-    "@cspell/strong-weak-map": "9.0.2",
-    "@cspell/url": "9.0.2",
+    "@cspell/cspell-bundled-dicts": "9.1.1",
+    "@cspell/cspell-pipe": "9.1.1",
+    "@cspell/cspell-resolver": "9.1.1",
+    "@cspell/cspell-types": "9.1.1",
+    "@cspell/dynamic-import": "9.1.1",
+    "@cspell/filetypes": "9.1.1",
+    "@cspell/strong-weak-map": "9.1.1",
+    "@cspell/url": "9.1.1",
     "clear-module": "^4.1.2",
     "comment-json": "^4.2.5",
-    "cspell-config-lib": "9.0.2",
-    "cspell-dictionary": "9.0.2",
-    "cspell-glob": "9.0.2",
-    "cspell-grammar": "9.0.2",
-    "cspell-io": "9.0.2",
-    "cspell-trie-lib": "9.0.2",
+    "cspell-config-lib": "9.1.1",
+    "cspell-dictionary": "9.1.1",
+    "cspell-glob": "9.1.1",
+    "cspell-grammar": "9.1.1",
+    "cspell-io": "9.1.1",
+    "cspell-trie-lib": "9.1.1",
     "env-paths": "^3.0.0",
     "fast-equals": "^5.2.2",
     "gensequence": "^7.0.0",
@@ -108,5 +108,5 @@
     "lorem-ipsum": "^2.0.8",
     "perf-insight": "^1.2.0"
   },
-  "gitHead": "39dbd9ab9b8943a023d9eda7f65f81e822f939b5"
+  "gitHead": "40c6e1a331f38a0c008aacf2cb527270752c35ad"
 }