cspell-lib 6.23.1 → 6.24.0

package/dist/Models/Suggestion.d.ts

@@ -1,5 +1,15 @@
 export interface ExtendedSuggestion {
+    /**
+     * The suggestion.
+     */
     word: string;
+    /**
+     * The word is preferred above others, except other "preferred" words.
+     */
     isPreferred?: boolean;
+    /**
+     * The suggested word adjusted to match the original case.
+     */
+    wordAdjustedToMatchCase?: string;
 }
 //# sourceMappingURL=Suggestion.d.ts.map

package/dist/Settings/LanguageSettings.d.ts

@@ -3,7 +3,15 @@ export type LanguageSettings = LanguageSetting[];
 export declare function getDefaultLanguageSettings(): LanguageSettings;
 export declare function normalizeLanguageId(langId: LanguageId | LanguageId[]): Set<LanguageId>;
 export declare function normalizeLocale(locale: LocaleId | LocaleId[]): Set<LocaleId>;
+export declare function normalizeLocaleIntl(locale: LocaleId | LocaleId[]): Set<LocaleId>;
 export declare function isLocaleInSet(locale: LocaleId | LocaleId[], setOfLocals: Set<LocaleId>): boolean;
+/**
+ * Test if a locale should be ok with Intl
+ * @param locale - locale string
+ * @param strict - case must match
+ * @returns true if it matches the standard 2 letter or 4 letter forms.
+ */
+export declare function isValidLocaleIntlFormat(locale: LocaleId | LocaleId[], strict?: boolean): boolean;
 export declare function calcSettingsForLanguage(languageSettings: LanguageSettings, languageId: LanguageId, locale: LocaleId): BaseSetting;
 export declare function calcUserSettingsForLanguage(settings: CSpellUserSettings, languageId: string): CSpellUserSettings;
 export declare function calcSettingsForLanguageId(baseSettings: CSpellUserSettings, languageId: LanguageId[] | LanguageId): CSpellUserSettings;

package/dist/Settings/LanguageSettings.js

@@ -23,7 +23,7 @@ var __importStar = (this && this.__importStar) || function (mod) {
     return result;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.calcSettingsForLanguageId = exports.calcUserSettingsForLanguage = exports.calcSettingsForLanguage = exports.isLocaleInSet = exports.normalizeLocale = exports.normalizeLanguageId = exports.getDefaultLanguageSettings = void 0;
+exports.calcSettingsForLanguageId = exports.calcUserSettingsForLanguage = exports.calcSettingsForLanguage = exports.isValidLocaleIntlFormat = exports.isLocaleInSet = exports.normalizeLocaleIntl = exports.normalizeLocale = exports.normalizeLanguageId = exports.getDefaultLanguageSettings = void 0;
 const Memorizer_1 = require("../util/Memorizer");
 const util_1 = require("../util/util");
 const SpellSettings = __importStar(require("./CSpellSettingsServer"));
@@ -62,11 +62,34 @@ function normalizeLocale(locale) {
     return _normalizeLocale(locale);
 }
 exports.normalizeLocale = normalizeLocale;
+function normalizeLocaleIntl(locale) {
+    const values = [...normalizeLocale(locale)].map((locale) => locale.replace(/^([a-z]{2})-?([a-z]{2})$/, (_, lang, locale) => locale ? `${lang}-${locale.toUpperCase()}` : lang));
+    return new Set(values);
+}
+exports.normalizeLocaleIntl = normalizeLocaleIntl;
 function isLocaleInSet(locale, setOfLocals) {
     const locales = normalizeLocale(locale);
     return (0, util_1.doSetsIntersect)(locales, setOfLocals);
 }
 exports.isLocaleInSet = isLocaleInSet;
+const regExpValidIntlLocaleStrict = /^[a-z]{2}(-[A-Z]{2})?$/;
+const regExpValidIntlLocale = new RegExp(regExpValidIntlLocaleStrict, 'i');
+/**
+ * Test if a locale should be ok with Intl
+ * @param locale - locale string
+ * @param strict - case must match
+ * @returns true if it matches the standard 2 letter or 4 letter forms.
+ */
+function isValidLocaleIntlFormat(locale, strict = false) {
+    if (typeof locale === 'string')
+        return strict ? regExpValidIntlLocaleStrict.test(locale) : regExpValidIntlLocale.test(locale);
+    for (const item of locale) {
+        if (!isValidLocaleIntlFormat(item, strict))
+            return false;
+    }
+    return locale.length > 0;
+}
+exports.isValidLocaleIntlFormat = isValidLocaleIntlFormat;
 function calcSettingsForLanguage(languageSettings, languageId, locale) {
     languageId = languageId.toLowerCase();
     const allowedLocals = normalizeLocale(locale);

package/dist/suggestions.d.ts

@@ -1,7 +1,16 @@
 import type { CSpellSettings, LocaleId } from '@cspell/cspell-types';
 import type { LanguageId } from './LanguageIds';
-import type { SuggestionResult } from './SpellingDictionary';
-interface SuggestedWordBase extends SuggestionResult {
+import type { SpellingDictionaryCollection, SuggestionResult, SuggestOptions } from './SpellingDictionary';
+export interface WordSuggestion extends SuggestionResult {
+    /**
+     * The suggested word adjusted to match the original case.
+     */
+    wordAdjustedToMatchCase?: string;
+}
+interface SuggestedWordBase extends WordSuggestion {
+    /**
+     * dictionary names
+     */
     dictionaries: string[];
 }
 export interface SuggestedWord extends SuggestedWordBase {
@@ -12,7 +21,8 @@ export interface SuggestionsForWordResult {
     word: string;
     suggestions: SuggestedWord[];
 }
-export interface SuggestionOptions {
+type FromSuggestOptions = Pick<SuggestOptions, 'numChanges' | 'numSuggestions' | 'includeTies'>;
+export interface SuggestionOptions extends FromSuggestOptions {
     /**
      * languageId to use when determining file type.
      */
@@ -34,18 +44,18 @@ export interface SuggestionOptions {
      * The number of suggestions to make.
      * @default 8
      */
-    numSuggestions?: number;
+    numSuggestions?: number | undefined;
     /**
      * Max number of changes / edits to the word to get to a suggestion matching suggestion.
      * @default 4
      */
-    numChanges?: number;
+    numChanges?: number | undefined;
     /**
      * If multiple suggestions have the same edit / change "cost", then included them even if
      * it causes more than `numSuggestions` to be returned.
      * @default true
      */
-    includeTies?: boolean;
+    includeTies?: boolean | undefined;
     /**
      * By default we want to use the default configuration, but there are cases
      * where someone might not want that.
@@ -55,6 +65,7 @@ export interface SuggestionOptions {
 }
 export declare function suggestionsForWords(words: Iterable<string> | AsyncIterable<string>, options?: SuggestionOptions, settings?: CSpellSettings): AsyncIterable<SuggestionsForWordResult>;
 export declare function suggestionsForWord(word: string, options?: SuggestionOptions, settings?: CSpellSettings): Promise<SuggestionsForWordResult>;
+export declare function calcSuggestionAdjustedToToMatchCase<T extends SuggestionResult>(originalWord: string, sugs: T[], locale: string | string[] | undefined, ignoreCase: boolean, dict: SpellingDictionaryCollection): (T & WordSuggestion)[];
 export declare class SuggestionError extends Error {
     readonly code: string;
     constructor(message: string, code: string);

package/dist/suggestions.js

@@ -22,21 +22,37 @@ var __importStar = (this && this.__importStar) || function (mod) {
     __setModuleDefault(result, mod);
     return result;
 };
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.SuggestionError = exports.suggestionsForWord = exports.suggestionsForWords = void 0;
+exports.SuggestionError = exports.calcSuggestionAdjustedToToMatchCase = exports.suggestionsForWord = exports.suggestionsForWords = void 0;
+const assert_1 = __importDefault(require("assert"));
 const Settings_1 = require("./Settings");
 const LanguageSettings_1 = require("./Settings/LanguageSettings");
 const SpellingDictionary_1 = require("./SpellingDictionary");
+const AutoResolve_1 = require("./util/AutoResolve");
+const memorizeLastCall_1 = require("./util/memorizeLastCall");
 const util = __importStar(require("./util/util"));
-async function* suggestionsForWords(words, options, settings = {}) {
+const emptySuggestionOptions = Object.freeze({});
+const emptyCSpellSettings = Object.freeze({});
+async function* suggestionsForWords(words, options, settings) {
     for await (const word of words) {
         yield await suggestionsForWord(word, options, settings);
     }
 }
 exports.suggestionsForWords = suggestionsForWords;
-async function suggestionsForWord(word, options, settings = {}) {
-    const { languageId, locale: language, strict = true, numChanges = 4, numSuggestions = 8, includeTies = true, includeDefaultConfig = true, dictionaries, } = options || {};
-    const ignoreCase = !strict;
+const memorizeSuggestions = (0, memorizeLastCall_1.memorizeLastCall)(cacheSuggestionsForWord);
+function cacheSuggestionsForWord(options, settings) {
+    const cache = (0, AutoResolve_1.createAutoResolveCache)();
+    return (word) => cache.get(word, (word) => _suggestionsForWord(word, options, settings));
+}
+function suggestionsForWord(word, options = emptySuggestionOptions, settings = emptyCSpellSettings) {
+    return memorizeSuggestions(options, settings)(word);
+}
+exports.suggestionsForWord = suggestionsForWord;
+async function _suggestionsForWord(word, options, settings) {
+    const { languageId, locale: language, includeDefaultConfig = true, dictionaries } = options;
     async function determineDictionaries(config) {
         const withLocale = (0, Settings_1.mergeSettings)(config, util.clean({
             language: language || config.language,
@@ -59,12 +75,23 @@ async function suggestionsForWord(word, options, settings = {}) {
         ? (0, Settings_1.mergeSettings)((0, Settings_1.getDefaultSettings)(settings.loadDefaultConfiguration ?? true), (0, Settings_1.getGlobalSettings)(), settings)
         : settings;
     const { dictionaryCollection, allDictionaryCollection } = await determineDictionaries(config);
+    return _suggestionsForWordSync(word, options, settings, dictionaryCollection, allDictionaryCollection);
+}
+function _suggestionsForWordSync(word, options, settings, dictionaryCollection, allDictionaryCollection) {
+    const extendsDictionaryCollection = allDictionaryCollection || dictionaryCollection;
+    const { locale: language, strict = true, numChanges = 4, numSuggestions = 8, includeTies = true, includeDefaultConfig = true, } = options;
+    const ignoreCase = !strict;
+    const config = includeDefaultConfig
+        ? (0, Settings_1.mergeSettings)((0, Settings_1.getDefaultSettings)(settings.loadDefaultConfiguration ?? true), (0, Settings_1.getGlobalSettings)(), settings)
+        : settings;
     const opts = { ignoreCase, numChanges, numSuggestions, includeTies };
-    const suggestionsByDictionary = dictionaryCollection.dictionaries.map((dict) => dict.suggest(word, opts).map((r) => ({ ...r, dictName: dict.name })));
-    const combined = combine(util.flatten(suggestionsByDictionary).sort((a, b) => a.cost - b.cost || (a.word <= b.word ? -1 : 1)));
-    const findOpts = {};
-    const allSugs = combined.map((sug) => {
-        const found = allDictionaryCollection.find(sug.word, findOpts);
+    const suggestionsByDictionary = dictionaryCollection.dictionaries.flatMap((dict) => dict.suggest(word, opts).map((r) => ({ ...r, dictName: dict.name })));
+    const locale = adjustLocale(language || config.language || undefined);
+    const collator = Intl.Collator(locale);
+    const combined = limitResults(combine(suggestionsByDictionary.sort((a, b) => a.cost - b.cost || collator.compare(a.word, b.word))), numSuggestions, includeTies);
+    const sugsAdjusted = calcSuggestionAdjustedToToMatchCase(word, combined, locale, ignoreCase, extendsDictionaryCollection);
+    const allSugs = sugsAdjusted.map((sug) => {
+        const found = extendsDictionaryCollection.find(sug.word);
         return {
             ...sug,
             forbidden: found?.forbidden || false,
@@ -76,7 +103,6 @@ async function suggestionsForWord(word, options, settings = {}) {
         suggestions: limitResults(allSugs, numSuggestions, includeTies),
     };
 }
-exports.suggestionsForWord = suggestionsForWord;
 function combine(suggestions) {
     const words = new Map();
     for (const sug of suggestions) {
@@ -89,6 +115,34 @@ function combine(suggestions) {
     }
     return [...words.values()];
 }
+function adjustLocale(locale) {
+    if (!locale)
+        return undefined;
+    const locales = [...(0, LanguageSettings_1.normalizeLocaleIntl)(locale)].filter((locale) => (0, LanguageSettings_1.isValidLocaleIntlFormat)(locale));
+    if (!locales.length)
+        return undefined;
+    if (locales.length === 1)
+        return locales[0];
+    return locales;
+}
+function calcSuggestionAdjustedToToMatchCase(originalWord, sugs, locale, ignoreCase, dict) {
+    locale = adjustLocale(locale);
+    const knownSugs = new Set(sugs.map((sug) => sug.word));
+    const matchStyle = { ...analyzeCase(originalWord), locale, ignoreCase };
+    /* Add adjusted words */
+    return sugs.map((sug) => {
+        const alt = matchCase(sug.word, !!sug.isPreferred, matchStyle);
+        if (alt === sug.word || knownSugs.has(alt))
+            return sug;
+        const found = dict.find(alt);
+        if (!found || !found.forbidden || !found.noSuggest) {
+            knownSugs.add(alt);
+            return { ...sug, wordAdjustedToMatchCase: alt };
+        }
+        return sug;
+    });
+}
+exports.calcSuggestionAdjustedToToMatchCase = calcSuggestionAdjustedToToMatchCase;
 function limitResults(suggestions, numSuggestions, includeTies) {
     let cost = suggestions[0]?.cost;
     let i = 0;
@@ -110,6 +164,49 @@ function validateDictionaries(settings, dictionaries) {
         }
     }
 }
+function matchCase(word, isPreferred, style) {
+    const locale = style.locale;
+    if (style.isMixedCaps) {
+        /**
+         * Do not try matching mixed caps.
+         */
+        return word;
+    }
+    if (hasCaps(word)) {
+        if (style.isAllCaps)
+            return word.toLocaleUpperCase(locale);
+        if (!style.ignoreCase || style.hasCaps || isPreferred)
+            return word;
+        if (isTitleCase(word) || isAllCaps(word))
+            return word.toLocaleLowerCase(locale);
+        return word;
+    }
+    if (!style.hasCaps)
+        return word;
+    if (style.isAllCaps)
+        return word.toLocaleUpperCase(locale);
+    (0, assert_1.default)(style.isTitleCase);
+    return word.replace(/^\p{L}/u, (firstLetter) => firstLetter.toLocaleUpperCase(locale));
+}
+const regExpHasCaps = /\p{Lu}/u;
+const regExpIsAllCaps = /^[\P{L}\p{Lu}]+$/u;
+const regExpIsTitleCase = /^\p{Lu}[\P{L}\p{Ll}]+$/u;
+function analyzeCase(word) {
+    const hasCaps = regExpHasCaps.test(word);
+    const isAllCaps = hasCaps && regExpIsAllCaps.test(word);
+    const isTitleCase = hasCaps && !isAllCaps && regExpIsTitleCase.test(word);
+    const isMixedCaps = hasCaps && !isAllCaps && !isTitleCase;
+    return { hasCaps, isAllCaps, isMixedCaps, isTitleCase };
+}
+function hasCaps(word) {
+    return regExpHasCaps.test(word);
+}
+function isTitleCase(word) {
+    return regExpIsTitleCase.test(word);
+}
+function isAllCaps(word) {
+    return regExpIsAllCaps.test(word);
+}
 class SuggestionError extends Error {
     constructor(message, code) {
         super(message);

package/dist/textValidation/ValidateTextOptions.d.ts

@@ -0,0 +1,15 @@
+export interface ValidateTextOptions {
+    /**
+     * Generate suggestions where there are spelling issues.
+     */
+    generateSuggestions?: boolean;
+    /**
+     * The number of suggestions to generate. The higher the number the longer it takes.
+     */
+    numSuggestions?: number;
+    /**
+     * Verify that the in-document directives are correct.
+     */
+    validateDirectives?: boolean;
+}
+//# sourceMappingURL=ValidateTextOptions.d.ts.map

package/dist/textValidation/ValidateTextOptions.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=ValidateTextOptions.js.map

package/dist/textValidation/docValidator.d.ts

@@ -6,8 +6,8 @@ import type { SpellingDictionaryCollection } from '../SpellingDictionary';
 import type { MatchRange } from '../util/TextRange';
 import type { TextValidator } from './lineValidatorFactory';
 import type { SimpleRange } from './parsedText';
+import type { ValidateTextOptions } from './ValidateTextOptions';
 import type { ValidationOptions } from './ValidationTypes';
-import type { ValidateTextOptions } from './validator';
 export interface DocumentValidatorOptions extends ValidateTextOptions {
     /**
      * Optional path to a configuration file.
@@ -25,7 +25,6 @@ export interface DocumentValidatorOptions extends ValidateTextOptions {
     noConfigSearch?: boolean;
 }
 export declare class DocumentValidator {
-    readonly options: DocumentValidatorOptions;
     readonly settings: CSpellUserSettings;
     private _document;
     private _ready;
@@ -34,6 +33,7 @@ export declare class DocumentValidator {
     private _preparations;
     private _preparationTime;
     private _suggestions;
+    readonly options: DocumentValidatorOptions;
     /**
      * @param doc - Document to validate
      * @param config - configuration to use (not finalized).

package/dist/textValidation/docValidator.js

@@ -13,16 +13,16 @@ const Settings_1 = require("../Settings");
 const configLoader_1 = require("../Settings/Controller/configLoader");
 const InDocSettings_1 = require("../Settings/InDocSettings");
 const SpellingDictionary_1 = require("../SpellingDictionary");
+const suggestions_1 = require("../suggestions");
 const errors_1 = require("../util/errors");
 const simpleCache_1 = require("../util/simpleCache");
 const timer_1 = require("../util/timer");
-const util_1 = require("../util/util");
 const defaultConstants_1 = require("./defaultConstants");
 const determineTextDocumentSettings_1 = require("./determineTextDocumentSettings");
 const lineValidatorFactory_1 = require("./lineValidatorFactory");
 const parsedText_1 = require("./parsedText");
+const settingsToValidateOptions_1 = require("./settingsToValidateOptions");
 const textValidator_1 = require("./textValidator");
-const validator_1 = require("./validator");
 const ERROR_NOT_PREPARED = 'Validator Must be prepared before calling this function.';
 class DocumentValidator {
     /**
@@ -30,13 +30,17 @@ class DocumentValidator {
      * @param config - configuration to use (not finalized).
      */
     constructor(doc, options, settings) {
-        this.options = options;
         this.settings = settings;
         this._ready = false;
         this.errors = [];
         this._preparationTime = -1;
         this._suggestions = new simpleCache_1.AutoCache((text) => this.genSuggestions(text), 1000);
         this._document = doc;
+        this.options = { ...options };
+        const numSuggestions = this.options.numSuggestions ?? settings.numSuggestions;
+        if (numSuggestions !== undefined) {
+            this.options.numSuggestions = numSuggestions;
+        }
         // console.error(`DocumentValidator: ${doc.uri}`);
     }
     get ready() {
@@ -73,7 +77,7 @@ class DocumentValidator {
         const uri = this._document.uri;
         const shouldCheck = !matcher.match(uri.fsPath) && (docSettings.enabled ?? true);
         const finalSettings = (0, Settings_1.finalizeSettings)(docSettings);
-        const validateOptions = (0, validator_1.settingsToValidateOptions)(finalSettings);
+        const validateOptions = (0, settingsToValidateOptions_1.settingsToValidateOptions)(finalSettings);
         const includeRanges = (0, textValidator_1.calcTextInclusionRanges)(this._document.text, validateOptions);
         const segmenter = (0, parsedText_1.createMappedTextSegmenter)(includeRanges);
         const textValidator = (0, lineValidatorFactory_1.textValidatorFactory)(dict, validateOptions);
@@ -121,7 +125,7 @@ class DocumentValidator {
         const uri = this._document.uri;
         const shouldCheck = !matcher.match(uri.fsPath) && (docSettings.enabled ?? true);
         const finalSettings = (0, Settings_1.finalizeSettings)(docSettings);
-        const validateOptions = (0, validator_1.settingsToValidateOptions)(finalSettings);
+        const validateOptions = (0, settingsToValidateOptions_1.settingsToValidateOptions)(finalSettings);
         const includeRanges = (0, textValidator_1.calcTextInclusionRanges)(this._document.text, validateOptions);
         const segmenter = (0, parsedText_1.createMappedTextSegmenter)(includeRanges);
         const textValidator = (0, lineValidatorFactory_1.textValidatorFactory)(dict, validateOptions);
@@ -149,7 +153,7 @@ class DocumentValidator {
         const dict = (0, SpellingDictionary_1.getDictionaryInternalSync)(docSettings);
         const shouldCheck = docSettings.enabled ?? true;
         const finalSettings = (0, Settings_1.finalizeSettings)(docSettings);
-        const validateOptions = (0, validator_1.settingsToValidateOptions)(finalSettings);
+        const validateOptions = (0, settingsToValidateOptions_1.settingsToValidateOptions)(finalSettings);
         const includeRanges = (0, textValidator_1.calcTextInclusionRanges)(this._document.text, validateOptions);
         const segmenter = (0, parsedText_1.createMappedTextSegmenter)(includeRanges);
         const textValidator = (0, lineValidatorFactory_1.textValidatorFactory)(dict, validateOptions);
@@ -320,17 +324,18 @@ class DocumentValidator {
         (0, assert_1.default)(this._preparations, ERROR_NOT_PREPARED);
         const settings = this._preparations.docSettings;
         const dict = this._preparations.dictionary;
-        const sugOptions = (0, util_1.clean)({
+        const sugOptions = {
             compoundMethod: 0,
             numSuggestions: this.options.numSuggestions,
             includeTies: false,
             ignoreCase: !(settings.caseSensitive ?? false),
             timeout: settings.suggestionsTimeout,
             numChanges: settings.suggestionNumChanges,
-        });
-        return dict
-            .suggest(text, sugOptions)
-            .map(({ word, isPreferred }) => (isPreferred ? { word, isPreferred } : { word }));
+        };
+        const locale = this._preparations.config.language;
+        const rawSuggestions = dict.suggest(text, sugOptions);
+        const sugsWithAlt = (0, suggestions_1.calcSuggestionAdjustedToToMatchCase)(text, rawSuggestions, locale, sugOptions.ignoreCase, dict);
+        return sugsWithAlt.map(sanitizeSuggestion);
     }
     getFinalizedDocSettings() {
         (0, assert_1.default)(this._ready);
@@ -356,6 +361,16 @@ class DocumentValidator {
     }
 }
 exports.DocumentValidator = DocumentValidator;
+function sanitizeSuggestion(sug) {
+    const { word, isPreferred, wordAdjustedToMatchCase } = sug;
+    if (isPreferred && wordAdjustedToMatchCase)
+        return { word, wordAdjustedToMatchCase, isPreferred };
+    if (isPreferred)
+        return { word, isPreferred };
+    if (wordAdjustedToMatchCase)
+        return { word, wordAdjustedToMatchCase };
+    return { word };
+}
 async function searchForDocumentConfig(document, defaultConfig, pnpSettings) {
     const { uri } = document;
     if (uri.scheme !== 'file')

package/dist/textValidation/index.d.ts

@@ -6,7 +6,7 @@ export type { DocumentValidatorOptions } from './docValidator';
 export { DocumentValidator } from './docValidator';
 export type { Offset, SimpleRange } from './parsedText';
 export { calcTextInclusionRanges } from './textValidator';
+export type { ValidateTextOptions } from './ValidateTextOptions';
 export type { CheckOptions, IncludeExcludeOptions, ValidationOptions } from './ValidationTypes';
-export type { ValidateTextOptions } from './validator';
 export { validateText } from './validator';
 //# sourceMappingURL=index.d.ts.map

package/dist/textValidation/settingsToValidateOptions.d.ts

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

package/dist/textValidation/settingsToValidateOptions.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.settingsToValidateOptions = void 0;
+function settingsToValidateOptions(settings) {
+    const opt = {
+        ...settings,
+        ignoreCase: !(settings.caseSensitive ?? false),
+    };
+    return opt;
+}
+exports.settingsToValidateOptions = settingsToValidateOptions;
+//# sourceMappingURL=settingsToValidateOptions.js.map

package/dist/textValidation/validator.d.ts

@@ -1,26 +1,10 @@
 import type { CSpellUserSettings } from '@cspell/cspell-types';
-import type { CSpellSettingsInternalFinalized } from '../Models/CSpellSettingsInternalDef';
 import type { ValidationIssue } from '../Models/ValidationIssue';
-import type { ValidationOptions } from './ValidationTypes';
+import type { ValidateTextOptions } from './ValidateTextOptions';
 export declare const diagSource = "cSpell Checker";
-export interface ValidateTextOptions {
-    /**
-     * Generate suggestions where there are spelling issues.
-     */
-    generateSuggestions?: boolean;
-    /**
-     * The number of suggestions to generate. The higher the number the longer it takes.
-     */
-    numSuggestions?: number;
-    /**
-     * Verify that the in-document directives are correct.
-     */
-    validateDirectives?: boolean;
-}
 /**
  * @deprecated
  * @deprecationMessage Use spellCheckDocument
  */
 export declare function validateText(text: string, settings: CSpellUserSettings, options?: ValidateTextOptions): Promise<ValidationIssue[]>;
-export declare function settingsToValidateOptions(settings: CSpellSettingsInternalFinalized): ValidationOptions;
 //# sourceMappingURL=validator.d.ts.map

package/dist/textValidation/validator.js

@@ -23,13 +23,13 @@ var __importStar = (this && this.__importStar) || function (mod) {
     return result;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.settingsToValidateOptions = exports.validateText = exports.diagSource = void 0;
+exports.validateText = exports.diagSource = void 0;
 const cspell_types_1 = require("@cspell/cspell-types");
 const TextDocument_1 = require("../Models/TextDocument");
 const Settings = __importStar(require("../Settings"));
 const InDocSettings_1 = require("../Settings/InDocSettings");
 const SpellingDictionary_1 = require("../SpellingDictionary");
-const util_1 = require("../util/util");
+const settingsToValidateOptions_1 = require("./settingsToValidateOptions");
 const textValidator_1 = require("./textValidator");
 exports.diagSource = 'cSpell Checker';
 /**
@@ -39,7 +39,7 @@ exports.diagSource = 'cSpell Checker';
 async function validateText(text, settings, options = {}) {
     const finalSettings = Settings.finalizeSettings(settings);
     const dict = await (0, SpellingDictionary_1.getDictionaryInternal)(finalSettings);
-    const spellingIssues = [...(0, textValidator_1.validateText)(text, dict, settingsToValidateOptions(finalSettings))];
+    const spellingIssues = [...(0, textValidator_1.validateText)(text, dict, (0, settingsToValidateOptions_1.settingsToValidateOptions)(finalSettings))];
     const validationIssues = options.validateDirectives || finalSettings.validateDirectives
         ? (0, InDocSettings_1.validateInDocumentSettings)(text, settings)
         : [];
@@ -47,14 +47,14 @@ async function validateText(text, settings, options = {}) {
     if (!options.generateSuggestions) {
         return issues;
     }
-    const sugOptions = (0, util_1.clean)({
+    const sugOptions = {
         numSuggestions: options.numSuggestions,
         compoundMethod: SpellingDictionary_1.CompoundWordsMethod.NONE,
         includeTies: false,
         ignoreCase: !(settings.caseSensitive ?? false),
         timeout: settings.suggestionsTimeout,
         numChanges: settings.suggestionNumChanges,
-    });
+    };
     const withSugs = issues.map((t) => {
         const text = t.text;
         const suggestionsEx = dict
@@ -83,12 +83,4 @@ function mapValidationIssues(text, valIssues) {
     }
     return issues.map(toValidationIssue);
 }
-function settingsToValidateOptions(settings) {
-    const opt = {
-        ...settings,
-        ignoreCase: !(settings.caseSensitive ?? false),
-    };
-    return opt;
-}
-exports.settingsToValidateOptions = settingsToValidateOptions;
 //# sourceMappingURL=validator.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cspell-lib",
-  "version": "6.23.1",
+  "version": "6.24.0",
   "description": "A library of useful functions used across various cspell tools.",
   "main": "dist/index.js",
   "typings": "dist/index.d.ts",
@@ -48,19 +48,19 @@
   },
   "homepage": "https://github.com/streetsidesoftware/cspell#readme",
   "dependencies": {
-    "@cspell/cspell-bundled-dicts": "6.23.1",
-    "@cspell/cspell-pipe": "6.23.1",
-    "@cspell/cspell-types": "6.23.1",
-    "@cspell/strong-weak-map": "6.23.1",
+    "@cspell/cspell-bundled-dicts": "6.24.0",
+    "@cspell/cspell-pipe": "6.24.0",
+    "@cspell/cspell-types": "6.24.0",
+    "@cspell/strong-weak-map": "6.24.0",
     "clear-module": "^4.1.2",
     "comment-json": "^4.2.3",
     "configstore": "^5.0.1",
     "cosmiconfig": "^8.0.0",
-    "cspell-dictionary": "6.23.1",
-    "cspell-glob": "6.23.1",
-    "cspell-grammar": "6.23.1",
-    "cspell-io": "6.23.1",
-    "cspell-trie-lib": "6.23.1",
+    "cspell-dictionary": "6.24.0",
+    "cspell-glob": "6.24.0",
+    "cspell-grammar": "6.24.0",
+    "cspell-io": "6.24.0",
+    "cspell-trie-lib": "6.24.0",
     "fast-equals": "^4.0.3",
     "find-up": "^5.0.0",
     "gensequence": "^4.0.3",
@@ -92,5 +92,5 @@
     "rollup-plugin-dts": "^5.1.1",
     "ts-jest": "^29.0.5"
   },
-  "gitHead": "dace8b0625beb2766565f47bc813dc0a45480dc0"
+  "gitHead": "0d1e8bf9426cd0bfb814df4f61da12d8aee57ddd"
 }