cspell-dictionary 6.27.0 → 6.29.0

package/dist/esm/SpellingDictionary/FlagWordsDictionary.mjs

@@ -0,0 +1,134 @@
+import { opMap, pipe } from '@cspell/cspell-pipe/sync';
+import { buildTrieFast, parseDictionaryLines } from 'cspell-trie-lib';
+import { createAutoResolveWeakCache } from '../util/AutoResolve.mjs';
+import * as Defaults from './defaults.mjs';
+import { defaultOptions } from './SpellingDictionary.mjs';
+import { SpellingDictionaryFromTrie } from './SpellingDictionaryFromTrie.mjs';
+import { suggestArgsToSuggestOptions } from './SpellingDictionaryMethods.mjs';
+import { createTyposDictionary } from './TyposDictionary.mjs';
+class FlagWordsDictionaryTrie extends SpellingDictionaryFromTrie {
+    constructor(trie, name, source) {
+        super(trie, name, defaultOptions, source);
+        this.name = name;
+        this.source = source;
+        this.containsNoSuggestWords = false;
+        this.options = {};
+        this.isDictionaryCaseSensitive = true;
+    }
+    /**
+     * A Forbidden word list does not "have" valid words.
+     * Therefore it always returns false.
+     * @param _word - the word
+     * @param _options - options
+     * @returns always false
+     */
+    has(_word, _options) {
+        return false;
+    }
+    find(word, hasOptions) {
+        const f = super.find(word, hasOptions);
+        if (!f || !f.forbidden)
+            return undefined;
+        return f;
+    }
+    suggest() {
+        return [];
+    }
+    genSuggestions() {
+        return;
+    }
+}
+class FlagWordsDictionary {
+    constructor(name, source, dictTypos, dictTrie) {
+        this.name = name;
+        this.source = source;
+        this.dictTypos = dictTypos;
+        this.dictTrie = dictTrie;
+        this.containsNoSuggestWords = false;
+        this.options = {};
+        this.type = 'flag-words';
+        this.isDictionaryCaseSensitive = true;
+    }
+    /**
+     * A Forbidden word list does not "have" valid words.
+     * Therefore it always returns false.
+     * @param word - the word
+     * @param options - options
+     * @returns always false
+     */
+    has(word, options) {
+        return this.dictTypos.has(word, options) || this.dictTrie?.has(word, options) || false;
+    }
+    /** A more detailed search for a word, might take longer than `has` */
+    find(word, options) {
+        const findTypos = this.dictTypos.find(word, options);
+        if (findTypos)
+            return findTypos;
+        const ignoreCase = options?.ignoreCase ?? Defaults.ignoreCase;
+        if (this.dictTypos.isSuggestedWord(word, ignoreCase))
+            return undefined;
+        return this.dictTrie?.find(word, options);
+    }
+    isForbidden(word, ignoreCaseAndAccents = Defaults.isForbiddenIgnoreCaseAndAccents) {
+        const findResult = this.find(word, { ignoreCase: ignoreCaseAndAccents });
+        return findResult?.forbidden || false;
+    }
+    isNoSuggestWord(word, options) {
+        return this.dictTrie?.isNoSuggestWord(word, options) || this.dictTypos.isNoSuggestWord(word, options);
+    }
+    suggest(...args) {
+        const [word] = args;
+        const suggestOptions = suggestArgsToSuggestOptions(args);
+        return this.dictTypos.suggest(word, suggestOptions);
+    }
+    genSuggestions() {
+        return;
+    }
+    mapWord(word) {
+        return word;
+    }
+    get size() {
+        return this.dictTypos.size + (this.dictTrie?.size || 0);
+    }
+    getErrors() {
+        return [];
+    }
+}
+const createCache = createAutoResolveWeakCache();
+/**
+ * Create a dictionary where all words are to be forbidden.
+ * @param wordList - list of words
+ * @param name
+ * @param source
+ * @param options
+ * @returns SpellingDictionary
+ */
+export function createFlagWordsDictionary(wordList, name, source) {
+    return createCache.get(wordList, () => {
+        const testSpecialCharacters = /[~*+]/;
+        const { t: specialWords, f: typoWords } = bisect(parseDictionaryLines(wordList, { stripCaseAndAccents: false }), (line) => testSpecialCharacters.test(line));
+        const trieDict = specialWords.size ? buildTrieDict(specialWords, name, source) : undefined;
+        const typosDict = createTyposDictionary(typoWords, name, source);
+        if (!trieDict)
+            return typosDict;
+        return new FlagWordsDictionary(name, source, typosDict, trieDict);
+    });
+}
+const regExpCleanIgnore = /^(!!)+/;
+function buildTrieDict(words, name, source) {
+    const trie = buildTrieFast(pipe(words, opMap((w) => '!' + w), opMap((w) => w.replace(regExpCleanIgnore, ''))));
+    return new FlagWordsDictionaryTrie(trie, name, source);
+}
+function bisect(values, predicate) {
+    const t = new Set();
+    const f = new Set();
+    for (const v of values) {
+        if (predicate(v)) {
+            t.add(v);
+        }
+        else {
+            f.add(v);
+        }
+    }
+    return { t, f };
+}

package/dist/esm/SpellingDictionary/IgnoreWordsDictionary.d.mts

@@ -0,0 +1,11 @@
+import type { SpellingDictionary } from './SpellingDictionary.mjs';
+/**
+ * Create a dictionary where all words are to be ignored.
+ * Ignored words override forbidden words.
+ * @param wordList - list of words
+ * @param name - name of dictionary
+ * @param source - dictionary source
+ * @returns
+ */
+export declare function createIgnoreWordsDictionary(wordList: readonly string[], name: string, source: string): SpellingDictionary;
+//# sourceMappingURL=IgnoreWordsDictionary.d.mts.map

package/dist/esm/SpellingDictionary/IgnoreWordsDictionary.mjs

@@ -0,0 +1,96 @@
+import { opFilter, opMap, pipe } from '@cspell/cspell-pipe/sync';
+import { parseDictionaryLines } from 'cspell-trie-lib';
+import { createAutoResolveWeakCache } from '../util/AutoResolve.mjs';
+import { createSpellingDictionary } from './createSpellingDictionary.mjs';
+import * as Defaults from './defaults.mjs';
+const NormalizeForm = 'NFC';
+class IgnoreWordsDictionary {
+    constructor(name, source, words) {
+        this.name = name;
+        this.source = source;
+        this.containsNoSuggestWords = true;
+        this.options = {};
+        this.type = 'ignore';
+        this.isDictionaryCaseSensitive = true;
+        this.dict = new Set(words);
+        this.dictNonStrict = new Set(pipe(this.dict, opFilter((w) => w.startsWith('~')), opMap((w) => w.slice(1))));
+    }
+    /**
+     * A Forbidden word list does not "have" valid words.
+     * Therefore it always returns false.
+     * @param _word - the word
+     * @param _options - options
+     * @returns always false
+     */
+    has(word, options) {
+        const nWord = word.normalize(NormalizeForm);
+        if (this.dict.has(nWord))
+            return true;
+        const lcWord = nWord.toLowerCase();
+        if (this.dict.has(lcWord))
+            return true;
+        const ignoreCase = options?.ignoreCase ?? Defaults.ignoreCase;
+        return ignoreCase && (this.dictNonStrict.has(nWord) || this.dictNonStrict.has(lcWord));
+    }
+    /** A more detailed search for a word, might take longer than `has` */
+    find(word, options) {
+        const nWord = word.normalize(NormalizeForm);
+        if (this.dict.has(nWord))
+            return { found: nWord, forbidden: false, noSuggest: true };
+        const lcWord = nWord.toLowerCase();
+        if (this.dict.has(lcWord))
+            return { found: lcWord, forbidden: false, noSuggest: true };
+        const ignoreCase = options?.ignoreCase ?? Defaults.ignoreCase;
+        if (!ignoreCase)
+            return undefined;
+        if (this.dictNonStrict.has(nWord))
+            return { found: nWord, forbidden: false, noSuggest: true };
+        return (this.dictNonStrict.has(lcWord) && { found: lcWord, forbidden: false, noSuggest: true }) || undefined;
+    }
+    isForbidden(_word, _ignoreCase) {
+        return false;
+    }
+    isNoSuggestWord(word, options) {
+        return this.has(word, options);
+    }
+    suggest() {
+        return [];
+    }
+    genSuggestions() {
+        return;
+    }
+    mapWord(word) {
+        return word;
+    }
+    get size() {
+        return this.dict.size;
+    }
+    getErrors() {
+        return [];
+    }
+}
+const createCache = createAutoResolveWeakCache();
+/**
+ * Create a dictionary where all words are to be ignored.
+ * Ignored words override forbidden words.
+ * @param wordList - list of words
+ * @param name - name of dictionary
+ * @param source - dictionary source
+ * @returns
+ */
+export function createIgnoreWordsDictionary(wordList, name, source) {
+    return createCache.get(wordList, () => {
+        const testSpecialCharacters = /[*+]/;
+        const words = [...parseDictionaryLines(wordList, { stripCaseAndAccents: true })].map((w) => w.normalize(NormalizeForm));
+        const hasSpecial = words.findIndex((word) => testSpecialCharacters.test(word)) >= 0;
+        if (hasSpecial) {
+            return createSpellingDictionary(words, name, source, {
+                caseSensitive: true,
+                noSuggest: true,
+                weightMap: undefined,
+                supportNonStrictSearches: true,
+            });
+        }
+        return new IgnoreWordsDictionary(name, source, words);
+    });
+}

package/dist/esm/SpellingDictionary/SpellingDictionary.d.mts

@@ -0,0 +1,150 @@
+import type { DictionaryInformation, ReplaceMap } from '@cspell/cspell-types';
+import type { CompoundWordsMethod, SuggestionCollector, SuggestionResult, WeightMap } from 'cspell-trie-lib';
+export type { DictionaryDefinitionInline } from '@cspell/cspell-types';
+export { CompoundWordsMethod, type SuggestionCollector, type SuggestionResult } from 'cspell-trie-lib';
+export interface SearchOptions {
+    /**
+     * Legacy compounds have been deprecated.
+     *
+     * @deprecated
+     */
+    useCompounds?: boolean | number | undefined;
+    /**
+     * Ignore Case and Accents
+     */
+    ignoreCase?: boolean | undefined;
+}
+export interface SuggestOptions {
+    /**
+     * Compounding Mode.
+     * `NONE` is the best option.
+     */
+    compoundMethod?: CompoundWordsMethod | undefined;
+    /**
+     * The limit on the number of suggestions to generate. If `allowTies` is true, it is possible
+     * for more suggestions to be generated.
+     */
+    numSuggestions?: number | undefined;
+    /**
+     * Max number of changes / edits to the word to get to a suggestion matching suggestion.
+     */
+    numChanges?: number | undefined;
+    /**
+     * Allow for case-ingestive checking.
+     */
+    ignoreCase?: boolean | undefined;
+    /**
+     * If multiple suggestions have the same edit / change "cost", then included them even if
+     * it causes more than `numSuggestions` to be returned.
+     * @default false
+     */
+    includeTies?: boolean | undefined;
+    /**
+     * Maximum amount of time to allow for generating suggestions.
+     */
+    timeout?: number | undefined;
+}
+export type FindOptions = SearchOptions;
+export interface FindResult {
+    /** the text found, otherwise `false` */
+    found: string | false;
+    /** `true` if it is considered a forbidden word. */
+    forbidden: boolean;
+    /** `true` if it is a no-suggest word. */
+    noSuggest: boolean;
+}
+export type HasOptions = SearchOptions;
+export type IgnoreCaseOption = boolean;
+export interface SpellingDictionaryOptions {
+    repMap?: ReplaceMap;
+    /**
+     * The dictionary is case aware.
+     */
+    caseSensitive?: boolean;
+    /**
+     * This is a NO Suggest dictionary used for words to be ignored.
+     */
+    noSuggest?: boolean;
+    /**
+     * Extra dictionary information used in improving suggestions
+     * based upon locale.
+     */
+    dictionaryInformation?: DictionaryInformation;
+    /**
+     * Strip Case and Accents to allow for case insensitive searches and
+     * words without accents.
+     *
+     * Note: this setting only applies to word lists. It has no-impact on trie
+     * dictionaries.
+     *
+     * @default true
+     */
+    supportNonStrictSearches?: boolean;
+    /**
+     * Turns on legacy word compounds.
+     * @deprecated
+     */
+    useCompounds?: boolean;
+    /**
+     * Optional WeightMap used to improve suggestions.
+     */
+    weightMap?: WeightMap | undefined;
+}
+export interface DictionaryInfo {
+    /** The name of the dictionary */
+    readonly name: string;
+    /** The source, filename or URI */
+    readonly source: string;
+    /** Options */
+    readonly options: SpellingDictionaryOptions;
+}
+export interface SpellingDictionary extends DictionaryInfo {
+    readonly type: string;
+    readonly containsNoSuggestWords: boolean;
+    has(word: string, options?: HasOptions): boolean;
+    /** A more detailed search for a word, might take longer than `has` */
+    find(word: string, options?: SearchOptions): FindResult | undefined;
+    /**
+     * Checks if a word is forbidden.
+     * @param word - word to check.
+     */
+    isForbidden(word: string, ignoreCaseAndAccents?: IgnoreCaseOption): boolean;
+    /**
+     * No Suggest words are considered correct but will not be listed when
+     * suggestions are generated.
+     * No Suggest words and "Ignored" words are equivalent. Ignored / no suggest words override forbidden words.
+     * @param word - word to check
+     * @param options - options
+     */
+    isNoSuggestWord(word: string, options: HasOptions): boolean;
+    /**
+     * Generate suggestions for a word.
+     * @param word - word
+     * @param numSuggestions - max number of suggestions to generate.
+     * @param compoundMethod - Default NONE.
+     * @param numChanges - Default 5
+     * @param ignoreCase - true
+     */
+    suggest(word: string, numSuggestions?: number, compoundMethod?: CompoundWordsMethod, numChanges?: number, ignoreCase?: boolean): SuggestionResult[];
+    /**
+     * Generate suggestions for a word
+     * @param word - word
+     * @param suggestOptions - options
+     */
+    suggest(word: string, suggestOptions: SuggestOptions): SuggestionResult[];
+    genSuggestions(collector: SuggestionCollector, suggestOptions: SuggestOptions): void;
+    mapWord(word: string): string;
+    /**
+     * Generates all possible word combinations by applying `repMap`.
+     * This acts a bit like brace expansions in globs.
+     * @param word - the word to map
+     * @returns array of adjusted words.
+     */
+    remapWord?: (word: string) => string[];
+    readonly size: number;
+    readonly isDictionaryCaseSensitive: boolean;
+    getErrors?(): Error[];
+}
+export type SuggestArgs = Parameters<SpellingDictionary['suggest']> | Parameters<(word: string, numSuggestions?: number, compoundMethod?: CompoundWordsMethod, numChanges?: number, ignoreCase?: boolean) => SuggestionResult[]>;
+export declare const defaultOptions: SpellingDictionaryOptions;
+//# sourceMappingURL=SpellingDictionary.d.mts.map

package/dist/esm/SpellingDictionary/SpellingDictionary.mjs

@@ -0,0 +1,4 @@
+export { CompoundWordsMethod } from 'cspell-trie-lib';
+export const defaultOptions = Object.freeze({
+    weightMap: undefined,
+});

package/dist/esm/SpellingDictionary/SpellingDictionaryCollection.d.mts

@@ -0,0 +1,16 @@
+import type { SearchOptions, SpellingDictionary } from './SpellingDictionary.mjs';
+export interface SpellingDictionaryCollection extends SpellingDictionary {
+    readonly type: 'SpellingDictionaryCollection';
+    readonly dictionaries: SpellingDictionary[];
+    getErrors(): Error[];
+}
+export declare function createCollection(dictionaries: SpellingDictionary[], name: string, source?: string): SpellingDictionaryCollection;
+declare function isWordInAnyDictionary(dicts: SpellingDictionary[], word: string, options: SearchOptions): SpellingDictionary | undefined;
+declare function isWordForbiddenInAnyDictionary(dicts: SpellingDictionary[], word: string, ignoreCase: boolean | undefined): SpellingDictionary | undefined;
+export declare function isSpellingDictionaryCollection(dict: SpellingDictionary): dict is SpellingDictionaryCollection;
+export declare const __testing__: {
+    isWordInAnyDictionary: typeof isWordInAnyDictionary;
+    isWordForbiddenInAnyDictionary: typeof isWordForbiddenInAnyDictionary;
+};
+export {};
+//# sourceMappingURL=SpellingDictionaryCollection.d.mts.map

package/dist/esm/SpellingDictionary/SpellingDictionaryCollection.mjs

@@ -0,0 +1,111 @@
+import { CASE_INSENSITIVE_PREFIX } from 'cspell-trie-lib';
+import { genSequence } from 'gensequence';
+import { isDefined } from '../util/util.mjs';
+import * as Defaults from './defaults.mjs';
+import { CompoundWordsMethod } from './SpellingDictionary.mjs';
+import { defaultNumSuggestions, hasOptionToSearchOption, suggestArgsToSuggestOptions, suggestionCollector, } from './SpellingDictionaryMethods.mjs';
+function identityString(w) {
+    return w;
+}
+class SpellingDictionaryCollectionImpl {
+    constructor(dictionaries, name, source) {
+        this.dictionaries = dictionaries;
+        this.name = name;
+        this.options = { weightMap: undefined };
+        this.mapWord = identityString;
+        this.type = 'SpellingDictionaryCollection';
+        this._isNoSuggestWord = (word, options) => {
+            if (!this.containsNoSuggestWords)
+                return false;
+            return !!isNoSuggestWordInAnyDictionary(this.dictionaries, word, options || {});
+        };
+        this.dictionaries = this.dictionaries.sort((a, b) => b.size - a.size);
+        this.source = source || dictionaries.map((d) => d.name).join(', ');
+        this.isDictionaryCaseSensitive = this.dictionaries.reduce((a, b) => a || b.isDictionaryCaseSensitive, false);
+        this.containsNoSuggestWords = this.dictionaries.reduce((a, b) => a || b.containsNoSuggestWords, false);
+    }
+    has(word, hasOptions) {
+        const options = hasOptionToSearchOption(hasOptions);
+        return !!isWordInAnyDictionary(this.dictionaries, word, options) && !this.isForbidden(word);
+    }
+    find(word, hasOptions) {
+        const options = hasOptionToSearchOption(hasOptions);
+        return findInAnyDictionary(this.dictionaries, word, options);
+    }
+    isNoSuggestWord(word, options) {
+        return this._isNoSuggestWord(word, options);
+    }
+    isForbidden(word, ignoreCaseAndAccents) {
+        const ignoreCase = ignoreCaseAndAccents ?? Defaults.isForbiddenIgnoreCaseAndAccents;
+        return !!this._isForbiddenInDict(word, ignoreCase) && !this.isNoSuggestWord(word, { ignoreCase });
+    }
+    suggest(...args) {
+        const [word] = args;
+        const suggestOptions = suggestArgsToSuggestOptions(args);
+        return this._suggest(word, suggestOptions);
+    }
+    _suggest(word, suggestOptions) {
+        const { numSuggestions = defaultNumSuggestions, numChanges, ignoreCase, includeTies, timeout } = suggestOptions;
+        const prefixNoCase = CASE_INSENSITIVE_PREFIX;
+        const filter = (word, _cost) => {
+            return ((ignoreCase || word[0] !== prefixNoCase) &&
+                !this.isForbidden(word) &&
+                !this.isNoSuggestWord(word, suggestOptions));
+        };
+        const collectorOptions = {
+            numSuggestions,
+            filter,
+            changeLimit: numChanges,
+            includeTies,
+            ignoreCase,
+            timeout,
+        };
+        const collector = suggestionCollector(word, collectorOptions);
+        this.genSuggestions(collector, suggestOptions);
+        return collector.suggestions.map((r) => ({ ...r, word: r.word }));
+    }
+    get size() {
+        return this.dictionaries.reduce((a, b) => a + b.size, 0);
+    }
+    genSuggestions(collector, suggestOptions) {
+        const _suggestOptions = { ...suggestOptions };
+        const { compoundMethod = CompoundWordsMethod.SEPARATE_WORDS } = suggestOptions;
+        _suggestOptions.compoundMethod = this.options.useCompounds ? CompoundWordsMethod.JOIN_WORDS : compoundMethod;
+        this.dictionaries.forEach((dict) => dict.genSuggestions(collector, _suggestOptions));
+    }
+    getErrors() {
+        return this.dictionaries.reduce((errors, dict) => errors.concat(dict.getErrors?.() || []), []);
+    }
+    _isForbiddenInDict(word, ignoreCase) {
+        return isWordForbiddenInAnyDictionary(this.dictionaries, word, ignoreCase);
+    }
+}
+export function createCollection(dictionaries, name, source) {
+    return new SpellingDictionaryCollectionImpl(dictionaries, name, source);
+}
+function isWordInAnyDictionary(dicts, word, options) {
+    return genSequence(dicts).first((dict) => dict.has(word, options));
+}
+function findInAnyDictionary(dicts, word, options) {
+    const found = dicts.map((dict) => dict.find(word, options)).filter(isDefined);
+    if (!found.length)
+        return undefined;
+    return found.reduce((a, b) => ({
+        found: a.forbidden ? a.found : b.forbidden ? b.found : a.found || b.found,
+        forbidden: a.forbidden || b.forbidden,
+        noSuggest: a.noSuggest || b.noSuggest,
+    }));
+}
+function isNoSuggestWordInAnyDictionary(dicts, word, options) {
+    return genSequence(dicts).first((dict) => dict.isNoSuggestWord(word, options));
+}
+function isWordForbiddenInAnyDictionary(dicts, word, ignoreCase) {
+    return genSequence(dicts).first((dict) => dict.isForbidden(word, ignoreCase));
+}
+export function isSpellingDictionaryCollection(dict) {
+    return dict instanceof SpellingDictionaryCollectionImpl;
+}
+export const __testing__ = {
+    isWordInAnyDictionary,
+    isWordForbiddenInAnyDictionary,
+};

package/dist/esm/SpellingDictionary/SpellingDictionaryFromTrie.d.mts

@@ -0,0 +1,50 @@
+import type { SuggestionCollector, SuggestionResult } from 'cspell-trie-lib';
+import { CompoundWordsMethod, Trie } from 'cspell-trie-lib';
+import type { FindResult, HasOptions, SpellingDictionary, SpellingDictionaryOptions, SuggestOptions } from './SpellingDictionary.mjs';
+export declare class SpellingDictionaryFromTrie implements SpellingDictionary {
+    readonly trie: Trie;
+    readonly name: string;
+    readonly options: SpellingDictionaryOptions;
+    readonly source: string;
+    static readonly cachedWordsLimit = 50000;
+    private _size;
+    readonly knownWords: Set<string>;
+    readonly unknownWords: Set<string>;
+    readonly mapWord: (word: string) => string;
+    readonly remapWord: (word: string) => string[];
+    readonly type = "SpellingDictionaryFromTrie";
+    readonly isDictionaryCaseSensitive: boolean;
+    readonly containsNoSuggestWords: boolean;
+    private weightMap;
+    constructor(trie: Trie, name: string, options: SpellingDictionaryOptions, source?: string, size?: number);
+    get size(): number;
+    has(word: string, hasOptions?: HasOptions): boolean;
+    find(word: string, hasOptions?: HasOptions): FindResult | undefined;
+    private resolveOptions;
+    private _find;
+    private findAnyForm;
+    private _findAnyForm;
+    isNoSuggestWord(word: string, options?: HasOptions): boolean;
+    isForbidden(word: string, _ignoreCaseAndAccents?: boolean): boolean;
+    private _isForbidden;
+    suggest(word: string, numSuggestions?: number, compoundMethod?: CompoundWordsMethod, numChanges?: number, ignoreCase?: boolean): SuggestionResult[];
+    suggest(word: string, suggestOptions: SuggestOptions): SuggestionResult[];
+    private _suggest;
+    genSuggestions(collector: SuggestionCollector, suggestOptions: SuggestOptions): void;
+    getErrors(): Error[];
+}
+/**
+ * Create a dictionary from a trie file.
+ * @param data - contents of a trie file.
+ * @param name - name of dictionary
+ * @param source - filename or uri
+ * @param options - options.
+ * @returns SpellingDictionary
+ */
+export declare function createSpellingDictionaryFromTrieFile(data: Iterable<string> | string, name: string, source: string, options: SpellingDictionaryOptions): SpellingDictionary;
+declare function outerWordForms(word: string, mapWord: (word: string) => string[]): Set<string>;
+export declare const __testing__: {
+    outerWordForms: typeof outerWordForms;
+};
+export {};
+//# sourceMappingURL=SpellingDictionaryFromTrie.d.mts.map