cspell-dictionary 8.18.0 → 8.19.0

package/dist/SpellingDictionary/SpellingDictionary.d.ts

@@ -1,6 +1,6 @@
 import type { DictionaryInformation, ReplaceMap } from '@cspell/cspell-types';
 import type { SuggestionCollector, SuggestionResult, WeightMap } from 'cspell-trie-lib';
-import type { SuggestOptions } from './SuggestOptions.js';
+import type { SuggestOptionsRO } from './SuggestOptions.js';
 export type { DictionaryDefinitionInline } from '@cspell/cspell-types';
 export interface SearchOptions {
     /**
@@ -14,7 +14,9 @@ export interface SearchOptions {
      */
     ignoreCase?: boolean | undefined;
 }
+export type SearchOptionsRO = Readonly<SearchOptions>;
 export type FindOptions = SearchOptions;
+export type FindOptionsRO = Readonly<FindOptions>;
 export interface Suggestion {
     word: string;
     isPreferred?: boolean | undefined;
@@ -31,6 +33,7 @@ export interface FindResult {
     noSuggest: boolean;
 }
 export type HasOptions = SearchOptions;
+export type HasOptionsRO = Readonly<HasOptions>;
 export type IgnoreCaseOption = boolean;
 export interface SpellingDictionaryOptions {
     repMap?: ReplaceMap;
@@ -42,6 +45,13 @@ export interface SpellingDictionaryOptions {
      * This is a NO Suggest dictionary used for words to be ignored.
      */
     noSuggest?: boolean | undefined;
+    /**
+     * Some dictionaries may contain flagged words that are not valid in the language. These are often
+     * words that are used in other languages or might be generated through compounding.
+     * This setting allows flagged words to be ignored when checking the dictionary.
+     * The effect is similar to the word not being in the dictionary.
+     */
+    ignoreForbiddenWords?: boolean | undefined;
     /**
      * Extra dictionary information used in improving suggestions
      * based upon locale.
@@ -67,6 +77,7 @@ export interface SpellingDictionaryOptions {
      */
     weightMap?: WeightMap | undefined;
 }
+export type SpellingDictionaryOptionsRO = Readonly<SpellingDictionaryOptions>;
 export interface DictionaryInfo {
     /** The name of the dictionary */
     readonly name: string;
@@ -78,9 +89,9 @@ export interface DictionaryInfo {
 export interface SpellingDictionary extends DictionaryInfo {
     readonly type: string;
     readonly containsNoSuggestWords: boolean;
-    has(word: string, options?: HasOptions): boolean;
+    has(word: string, options?: HasOptionsRO): boolean;
     /** A more detailed search for a word, might take longer than `has` */
-    find(word: string, options?: SearchOptions): FindResult | undefined;
+    find(word: string, options?: SearchOptionsRO): FindResult | undefined;
     /**
      * Checks if a word is forbidden.
      * @param word - word to check.
@@ -93,15 +104,15 @@ export interface SpellingDictionary extends DictionaryInfo {
      * @param word - word to check
      * @param options - options
      */
-    isNoSuggestWord(word: string, options: HasOptions): boolean;
+    isNoSuggestWord(word: string, options: HasOptionsRO): boolean;
     /**
      * Generate suggestions for a word
      * @param word - word
      * @param suggestOptions - options
      */
-    suggest(word: string, suggestOptions?: SuggestOptions): SuggestionResult[];
+    suggest(word: string, suggestOptions?: SuggestOptionsRO): SuggestionResult[];
     getPreferredSuggestions?: (word: string) => PreferredSuggestion[];
-    genSuggestions(collector: SuggestionCollector, suggestOptions: SuggestOptions): void;
+    genSuggestions(collector: SuggestionCollector, suggestOptions: SuggestOptionsRO): void;
     mapWord(word: string): string;
     /**
      * Generates all possible word combinations by applying `repMap`.

package/dist/SpellingDictionary/SpellingDictionaryCollection.d.ts

@@ -1,11 +1,11 @@
-import type { SearchOptions, SpellingDictionary } from './SpellingDictionary.js';
+import type { SearchOptionsRO, SpellingDictionary } from './SpellingDictionary.js';
 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 isWordInAnyDictionary(dicts: SpellingDictionary[], word: string, options: SearchOptionsRO): 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__: {

package/dist/SpellingDictionary/SpellingDictionaryFromTrie.d.ts

@@ -1,10 +1,11 @@
 import type { ITrie, SuggestionCollector, SuggestionResult } from 'cspell-trie-lib';
-import type { FindResult, HasOptions, SpellingDictionary, SpellingDictionaryOptions } from './SpellingDictionary.js';
+import type { FindResult, HasOptionsRO, SpellingDictionary, SpellingDictionaryOptionsRO } from './SpellingDictionary.js';
 import type { SuggestOptions } from './SuggestOptions.js';
 export declare class SpellingDictionaryFromTrie implements SpellingDictionary {
+    #private;
     readonly trie: ITrie;
     readonly name: string;
-    readonly options: SpellingDictionaryOptions;
+    readonly options: SpellingDictionaryOptionsRO;
     readonly source: string;
     private _size;
     readonly knownWords: Set<string>;
@@ -15,15 +16,15 @@ export declare class SpellingDictionaryFromTrie implements SpellingDictionary {
     readonly isDictionaryCaseSensitive: boolean;
     readonly containsNoSuggestWords: boolean;
     private weightMap;
-    constructor(trie: ITrie, name: string, options: SpellingDictionaryOptions, source?: string, size?: number);
+    constructor(trie: ITrie, name: string, options: SpellingDictionaryOptionsRO, source?: string, size?: number);
     get size(): number;
-    has(word: string, hasOptions?: HasOptions): boolean;
-    find(word: string, hasOptions?: HasOptions): FindResult | undefined;
+    has(word: string, hasOptions?: HasOptionsRO): boolean;
+    find(word: string, hasOptions?: HasOptionsRO): FindResult | undefined;
     private resolveOptions;
     private _find;
     private findAnyForm;
     private _findAnyForm;
-    isNoSuggestWord(word: string, options?: HasOptions): boolean;
+    isNoSuggestWord(word: string, options?: HasOptionsRO): boolean;
     isForbidden(word: string, _ignoreCaseAndAccents?: boolean): boolean;
     suggest(word: string, suggestOptions?: SuggestOptions): SuggestionResult[];
     private _suggest;
@@ -38,7 +39,7 @@ export declare class SpellingDictionaryFromTrie implements SpellingDictionary {
  * @param options - options.
  * @returns SpellingDictionary
  */
-export declare function createSpellingDictionaryFromTrieFile(data: string | Buffer, name: string, source: string, options: SpellingDictionaryOptions): SpellingDictionary;
+export declare function createSpellingDictionaryFromTrieFile(data: string | Buffer, name: string, source: string, options: SpellingDictionaryOptionsRO): SpellingDictionary;
 declare function outerWordForms(word: string, mapWord: (word: string) => string[]): Iterable<string>;
 export declare const __testing__: {
     outerWordForms: typeof outerWordForms;

package/dist/SpellingDictionary/SpellingDictionaryFromTrie.js

@@ -2,9 +2,7 @@ import { CompoundWordsMethod, decodeTrie, suggestionCollector } from 'cspell-tri
 import { clean } from '../util/clean.js';
 import { createMapper, createRepMapper } from '../util/repMap.js';
 import * as Defaults from './defaults.js';
-import { createWeightMapFromDictionaryInformation, defaultNumSuggestions, hasOptionToSearchOption, impersonateCollector, wordSearchForms, wordSuggestFormsArray, } from './SpellingDictionaryMethods.js';
-const findWordOptionsCaseSensitive = Object.freeze({ caseSensitive: true });
-const findWordOptionsNotCaseSensitive = Object.freeze({ caseSensitive: false });
+import { createWeightMapFromDictionaryInformation, defaultNumSuggestions, hasOptionToSearchOption, impersonateCollector, wordSearchForms, wordSuggestForms, } from './SpellingDictionaryMethods.js';
 export class SpellingDictionaryFromTrie {
     trie;
     name;
@@ -18,6 +16,9 @@ export class SpellingDictionaryFromTrie {
     type = 'SpellingDictionaryFromTrie';
     isDictionaryCaseSensitive;
     containsNoSuggestWords;
+    #ignoreForbiddenWords = false;
+    #findWordOptionsCaseSensitive = { caseSensitive: true };
+    #findWordOptionsNotCaseSensitive = { caseSensitive: false };
     weightMap;
     constructor(trie, name, options, source = 'from trie', size) {
         this.trie = trie;
@@ -30,6 +31,11 @@ export class SpellingDictionaryFromTrie {
         this.containsNoSuggestWords = options.noSuggest || false;
         this._size = size || 0;
         this.weightMap = options.weightMap || createWeightMapFromDictionaryInformation(options.dictionaryInformation);
+        this.#ignoreForbiddenWords = !!options.ignoreForbiddenWords;
+        if (this.#ignoreForbiddenWords) {
+            this.#findWordOptionsCaseSensitive.checkForbidden = true;
+            this.#findWordOptionsNotCaseSensitive.checkForbidden = true;
+        }
     }
     get size() {
         if (!this._size) {
@@ -50,12 +56,15 @@ export class SpellingDictionaryFromTrie {
     has(word, hasOptions) {
         const { useCompounds, ignoreCase } = this.resolveOptions(hasOptions);
         const r = this._find(word, useCompounds, ignoreCase);
-        return !!r && !r.forbidden && !!r.found;
+        return (r && !r.forbidden && !!r.found) || false;
     }
     find(word, hasOptions) {
         const { useCompounds, ignoreCase } = this.resolveOptions(hasOptions);
         const r = this._find(word, useCompounds, ignoreCase);
-        const { forbidden = this.isForbidden(word) } = r || {};
+        const { forbidden = this.#isForbidden(word) } = r || {};
+        if (this.#ignoreForbiddenWords && forbidden) {
+            return undefined;
+        }
         if (!r && !forbidden)
             return undefined;
         const { found = forbidden ? word : false } = r || {};
@@ -77,7 +86,9 @@ export class SpellingDictionaryFromTrie {
         return undefined;
     }
     _findAnyForm(mWord, useCompounds, ignoreCase) {
-        const opts = ignoreCase ? findWordOptionsNotCaseSensitive : findWordOptionsCaseSensitive;
+        const opts = ignoreCase
+            ? this.#findWordOptionsNotCaseSensitive
+            : this.#findWordOptionsCaseSensitive;
         const findResult = this.trie.findWord(mWord, opts);
         if (findResult.found !== false) {
             return findResult;
@@ -104,6 +115,9 @@ export class SpellingDictionaryFromTrie {
         return this.containsNoSuggestWords ? this.has(word, options) : false;
     }
     isForbidden(word, _ignoreCaseAndAccents) {
+        return this.#ignoreForbiddenWords ? false : this.#isForbidden(word, _ignoreCaseAndAccents);
+    }
+    #isForbidden(word, _ignoreCaseAndAccents) {
         return this.trie.isForbiddenWord(word);
     }
     suggest(word, suggestOptions = {}) {
@@ -131,7 +145,9 @@ export class SpellingDictionaryFromTrie {
             return;
         const _compoundMethod = suggestOptions.compoundMethod ??
             (this.options.useCompounds ? CompoundWordsMethod.JOIN_WORDS : CompoundWordsMethod.NONE);
-        wordSuggestFormsArray(collector.word).forEach((w) => this.trie.genSuggestions(impersonateCollector(collector, w), _compoundMethod));
+        for (const w of wordSuggestForms(collector.word)) {
+            this.trie.genSuggestions(impersonateCollector(collector, w), _compoundMethod);
+        }
     }
     getErrors() {
         return [];

package/dist/SpellingDictionary/SuggestOptions.d.ts

@@ -29,5 +29,6 @@ export interface SuggestOptions {
      */
     timeout?: number | undefined;
 }
+export type SuggestOptionsRO = Readonly<SuggestOptions>;
 export declare function createSuggestOptions(numSuggestions?: number, compoundMethod?: CompoundWordsMethod, numChanges?: number, ignoreCase?: boolean): SuggestOptions;
 //# sourceMappingURL=SuggestOptions.d.ts.map

package/package.json

@@ -4,7 +4,7 @@
     "access": "public",
     "provenance": true
   },
-  "version": "8.18.0",
+  "version": "8.19.0",
   "description": "A spelling dictionary library useful for checking words and getting suggestions.",
   "type": "module",
   "sideEffects": false,
@@ -54,14 +54,14 @@
     "node": ">=18"
   },
   "dependencies": {
-    "@cspell/cspell-pipe": "8.18.0",
-    "@cspell/cspell-types": "8.18.0",
-    "cspell-trie-lib": "8.18.0",
+    "@cspell/cspell-pipe": "8.19.0",
+    "@cspell/cspell-types": "8.19.0",
+    "cspell-trie-lib": "8.19.0",
     "fast-equals": "^5.2.2"
   },
   "devDependencies": {
     "gensequence": "^7.0.0",
     "lorem-ipsum": "^2.0.8"
   },
-  "gitHead": "6c7297918e9ff4f1c4fa1501d119d58bf4ce2237"
+  "gitHead": "ebfecabea342ba34ee368178f3864a7a194936d5"
 }