cspell-dictionary 6.29.3 → 6.30.1

package/dist/cjs/SpellingDictionary/CachingDictionary.d.ts

@@ -1,5 +1,5 @@
 import type { CacheStats } from '../util/AutoCache.js';
-import type { SearchOptions, SpellingDictionary } from './SpellingDictionary.js';
+import type { PreferredSuggestion, SearchOptions, SpellingDictionary } from './SpellingDictionary.js';
 import type { SpellingDictionaryCollection } from './SpellingDictionaryCollection.js';
 interface CallStats {
     name: string;
@@ -7,6 +7,7 @@ interface CallStats {
     has: CacheStats;
     isNoSuggestWord: CacheStats;
     isForbidden: CacheStats;
+    getPreferredSuggestions: CacheStats;
 }
 /**
  * Caching Dictionary remembers method calls to increase performance.
@@ -18,6 +19,7 @@ export interface CachingDictionary {
     isNoSuggestWord(word: string): boolean;
     isForbidden(word: string): boolean;
     stats(): CallStats;
+    getPreferredSuggestions(word: string): PreferredSuggestion[] | undefined;
 }
 /**
  * create a caching dictionary

package/dist/cjs/SpellingDictionary/CachingDictionary.js

@@ -4,14 +4,16 @@ exports.createCachingDictionary = void 0;
 const AutoCache_js_1 = require("../util/AutoCache.js");
 const SpellingDictionaryMethods_js_1 = require("./SpellingDictionaryMethods.js");
 let dictionaryCounter = 0;
+const DefaultAutoCacheSize = 1000;
 class CachedDict {
     constructor(dict, options) {
         this.dict = dict;
         this.options = options;
         this.id = ++dictionaryCounter;
-        this.has = (0, AutoCache_js_1.autoCache)((word) => this.dict.has(word, this.options));
-        this.isNoSuggestWord = (0, AutoCache_js_1.autoCache)((word) => this.dict.isNoSuggestWord(word, this.options));
-        this.isForbidden = (0, AutoCache_js_1.autoCache)((word) => this.dict.isForbidden(word));
+        this.has = (0, AutoCache_js_1.autoCache)((word) => this.dict.has(word, this.options), DefaultAutoCacheSize);
+        this.isNoSuggestWord = (0, AutoCache_js_1.autoCache)((word) => this.dict.isNoSuggestWord(word, this.options), DefaultAutoCacheSize);
+        this.isForbidden = (0, AutoCache_js_1.autoCache)((word) => this.dict.isForbidden(word), DefaultAutoCacheSize);
+        this.getPreferredSuggestions = (0, AutoCache_js_1.autoCache)((word) => this.dict.getPreferredSuggestions?.(word), DefaultAutoCacheSize);
         this.name = dict.name;
         // console.log(`CachedDict for ${this.name}`);
     }
@@ -22,6 +24,7 @@ class CachedDict {
             has: (0, AutoCache_js_1.extractStats)(this.has),
             isNoSuggestWord: (0, AutoCache_js_1.extractStats)(this.isNoSuggestWord),
             isForbidden: (0, AutoCache_js_1.extractStats)(this.isForbidden),
+            getPreferredSuggestions: (0, AutoCache_js_1.extractStats)(this.getPreferredSuggestions),
         };
     }
 }

package/dist/cjs/SpellingDictionary/FlagWordsDictionary.js

@@ -107,6 +107,9 @@ class FlagWordsDictionary {
         const suggestOptions = (0, SpellingDictionaryMethods_js_1.suggestArgsToSuggestOptions)(args);
         return this.dictTypos.suggest(word, suggestOptions);
     }
+    getPreferredSuggestions(word) {
+        return this.dictTypos.getPreferredSuggestions(word);
+    }
     genSuggestions() {
         return;
     }

package/dist/cjs/SpellingDictionary/SpellingDictionary.d.ts

@@ -45,6 +45,13 @@ export interface SuggestOptions {
     timeout?: number | undefined;
 }
 export type FindOptions = SearchOptions;
+export interface Suggestion {
+    word: string;
+    isPreferred?: boolean | undefined;
+}
+export interface PreferredSuggestion extends Suggestion {
+    isPreferred: true;
+}
 export interface FindResult {
     /** the text found, otherwise `false` */
     found: string | false;
@@ -132,6 +139,7 @@ export interface SpellingDictionary extends DictionaryInfo {
      * @param suggestOptions - options
      */
     suggest(word: string, suggestOptions: SuggestOptions): SuggestionResult[];
+    getPreferredSuggestions?: (word: string) => PreferredSuggestion[];
     genSuggestions(collector: SuggestionCollector, suggestOptions: SuggestOptions): void;
     mapWord(word: string): string;
     /**

package/dist/cjs/SpellingDictionary/SpellingDictionaryCollection.js

@@ -88,11 +88,23 @@ class SpellingDictionaryCollectionImpl {
         };
         const collector = (0, SpellingDictionaryMethods_js_1.suggestionCollector)(word, collectorOptions);
         this.genSuggestions(collector, suggestOptions);
-        return collector.suggestions.map((r) => ({ ...r, word: r.word }));
+        return collector.suggestions;
     }
     get size() {
         return this.dictionaries.reduce((a, b) => a + b.size, 0);
     }
+    getPreferredSuggestions(word) {
+        const sugs = this.dictionaries.flatMap((dict) => dict.getPreferredSuggestions?.(word)).filter(util_js_1.isDefined);
+        if (sugs.length <= 1)
+            return sugs;
+        const unique = new Set();
+        return sugs.filter((sug) => {
+            if (unique.has(sug.word))
+                return false;
+            unique.add(sug.word);
+            return true;
+        });
+    }
     genSuggestions(collector, suggestOptions) {
         const _suggestOptions = { ...suggestOptions };
         const { compoundMethod = SpellingDictionary_js_1.CompoundWordsMethod.SEPARATE_WORDS } = suggestOptions;

package/dist/cjs/SpellingDictionary/SuggestDictionary.d.ts

@@ -1,6 +1,7 @@
-import type { IgnoreCaseOption, SpellingDictionary } from './SpellingDictionary.js';
+import type { IgnoreCaseOption, PreferredSuggestion, SpellingDictionary } from './SpellingDictionary.js';
 import { type TypoEntry, type TyposDef } from './Typos/index.js';
 export interface SuggestDictionary extends SpellingDictionary {
+    getPreferredSuggestions: (word: string) => PreferredSuggestion[];
     /**
      * Determine if the word can appear in a list of suggestions.
      * @param word - word

package/dist/cjs/SpellingDictionary/SuggestDictionary.js

@@ -76,7 +76,7 @@ class SuggestDictionaryImpl {
         return ignoreCaseAndAccents && (this.suggestions.has(lcWord) || this.suggestionsLower.has(lcWord));
     }
     suggest(word) {
-        return this._suggest(word) || this._suggest(word.toLowerCase()) || [];
+        return this.getPreferredSuggestions(word);
     }
     _suggest(word) {
         if (!(word in this.typosDef))
@@ -96,6 +96,9 @@ class SuggestDictionaryImpl {
         }
         return sug.map((word, index) => ({ word, cost: index + 1, isPreferred }));
     }
+    getPreferredSuggestions(word) {
+        return this._suggest(word) || this._suggest(word.toLowerCase()) || [];
+    }
     genSuggestions(collector) {
         const sugs = this.suggest(collector.word);
         sugs.forEach((result) => collector.add(result));

package/dist/cjs/SpellingDictionary/TyposDictionary.d.ts

@@ -1,6 +1,7 @@
-import type { IgnoreCaseOption, SpellingDictionary } from './SpellingDictionary.js';
+import type { IgnoreCaseOption, PreferredSuggestion, SpellingDictionary } from './SpellingDictionary.js';
 import { type TypoEntry, type TyposDef } from './Typos/index.js';
 export interface TyposDictionary extends SpellingDictionary {
+    getPreferredSuggestions: (word: string) => PreferredSuggestion[];
     isForbidden(word: string, ignoreCaseAndAccents?: IgnoreCaseOption): boolean;
     /**
      * Determine if the word can appear in a list of suggestions.

package/dist/cjs/SpellingDictionary/TyposDictionary.js

@@ -106,7 +106,7 @@ class TyposDictionaryImpl {
         return ignoreCaseAndAccents && (this.suggestions.has(lcWord) || this.suggestionsLower.has(lcWord));
     }
     suggest(word) {
-        return this._suggest(word) || this._suggest(word.toLowerCase()) || [];
+        return this.getPreferredSuggestions(word);
     }
     _suggest(word) {
         if (this.ignoreWords.has(word))
@@ -132,6 +132,9 @@ class TyposDictionaryImpl {
         const sugs = this.suggest(collector.word);
         sugs.forEach((result) => collector.add(result));
     }
+    getPreferredSuggestions(word) {
+        return this._suggest(word) || this._suggest(word.toLowerCase()) || [];
+    }
     mapWord(word) {
         return word;
     }

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

@@ -1,5 +1,5 @@
 import type { CacheStats } from '../util/AutoCache.mjs';
-import type { SearchOptions, SpellingDictionary } from './SpellingDictionary.mjs';
+import type { PreferredSuggestion, SearchOptions, SpellingDictionary } from './SpellingDictionary.mjs';
 import type { SpellingDictionaryCollection } from './SpellingDictionaryCollection.mjs';
 interface CallStats {
     name: string;
@@ -7,6 +7,7 @@ interface CallStats {
     has: CacheStats;
     isNoSuggestWord: CacheStats;
     isForbidden: CacheStats;
+    getPreferredSuggestions: CacheStats;
 }
 /**
  * Caching Dictionary remembers method calls to increase performance.
@@ -18,6 +19,7 @@ export interface CachingDictionary {
     isNoSuggestWord(word: string): boolean;
     isForbidden(word: string): boolean;
     stats(): CallStats;
+    getPreferredSuggestions(word: string): PreferredSuggestion[] | undefined;
 }
 /**
  * create a caching dictionary

package/dist/esm/SpellingDictionary/CachingDictionary.mjs

@@ -1,14 +1,16 @@
 import { autoCache, extractStats } from '../util/AutoCache.mjs';
 import { canonicalSearchOptions } from './SpellingDictionaryMethods.mjs';
 let dictionaryCounter = 0;
+const DefaultAutoCacheSize = 1000;
 class CachedDict {
     constructor(dict, options) {
         this.dict = dict;
         this.options = options;
         this.id = ++dictionaryCounter;
-        this.has = autoCache((word) => this.dict.has(word, this.options));
-        this.isNoSuggestWord = autoCache((word) => this.dict.isNoSuggestWord(word, this.options));
-        this.isForbidden = autoCache((word) => this.dict.isForbidden(word));
+        this.has = autoCache((word) => this.dict.has(word, this.options), DefaultAutoCacheSize);
+        this.isNoSuggestWord = autoCache((word) => this.dict.isNoSuggestWord(word, this.options), DefaultAutoCacheSize);
+        this.isForbidden = autoCache((word) => this.dict.isForbidden(word), DefaultAutoCacheSize);
+        this.getPreferredSuggestions = autoCache((word) => this.dict.getPreferredSuggestions?.(word), DefaultAutoCacheSize);
         this.name = dict.name;
         // console.log(`CachedDict for ${this.name}`);
     }
@@ -19,6 +21,7 @@ class CachedDict {
             has: extractStats(this.has),
             isNoSuggestWord: extractStats(this.isNoSuggestWord),
             isForbidden: extractStats(this.isForbidden),
+            getPreferredSuggestions: extractStats(this.getPreferredSuggestions),
         };
     }
 }

package/dist/esm/SpellingDictionary/FlagWordsDictionary.mjs

@@ -81,6 +81,9 @@ class FlagWordsDictionary {
         const suggestOptions = suggestArgsToSuggestOptions(args);
         return this.dictTypos.suggest(word, suggestOptions);
     }
+    getPreferredSuggestions(word) {
+        return this.dictTypos.getPreferredSuggestions(word);
+    }
     genSuggestions() {
         return;
     }

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

@@ -45,6 +45,13 @@ export interface SuggestOptions {
     timeout?: number | undefined;
 }
 export type FindOptions = SearchOptions;
+export interface Suggestion {
+    word: string;
+    isPreferred?: boolean | undefined;
+}
+export interface PreferredSuggestion extends Suggestion {
+    isPreferred: true;
+}
 export interface FindResult {
     /** the text found, otherwise `false` */
     found: string | false;
@@ -132,6 +139,7 @@ export interface SpellingDictionary extends DictionaryInfo {
      * @param suggestOptions - options
      */
     suggest(word: string, suggestOptions: SuggestOptions): SuggestionResult[];
+    getPreferredSuggestions?: (word: string) => PreferredSuggestion[];
     genSuggestions(collector: SuggestionCollector, suggestOptions: SuggestOptions): void;
     mapWord(word: string): string;
     /**

package/dist/esm/SpellingDictionary/SpellingDictionaryCollection.mjs

@@ -62,11 +62,23 @@ class SpellingDictionaryCollectionImpl {
         };
         const collector = suggestionCollector(word, collectorOptions);
         this.genSuggestions(collector, suggestOptions);
-        return collector.suggestions.map((r) => ({ ...r, word: r.word }));
+        return collector.suggestions;
     }
     get size() {
         return this.dictionaries.reduce((a, b) => a + b.size, 0);
     }
+    getPreferredSuggestions(word) {
+        const sugs = this.dictionaries.flatMap((dict) => dict.getPreferredSuggestions?.(word)).filter(isDefined);
+        if (sugs.length <= 1)
+            return sugs;
+        const unique = new Set();
+        return sugs.filter((sug) => {
+            if (unique.has(sug.word))
+                return false;
+            unique.add(sug.word);
+            return true;
+        });
+    }
     genSuggestions(collector, suggestOptions) {
         const _suggestOptions = { ...suggestOptions };
         const { compoundMethod = CompoundWordsMethod.SEPARATE_WORDS } = suggestOptions;

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

@@ -1,6 +1,7 @@
-import type { IgnoreCaseOption, SpellingDictionary } from './SpellingDictionary.mjs';
+import type { IgnoreCaseOption, PreferredSuggestion, SpellingDictionary } from './SpellingDictionary.mjs';
 import { type TypoEntry, type TyposDef } from './Typos/index.mjs';
 export interface SuggestDictionary extends SpellingDictionary {
+    getPreferredSuggestions: (word: string) => PreferredSuggestion[];
     /**
      * Determine if the word can appear in a list of suggestions.
      * @param word - word

package/dist/esm/SpellingDictionary/SuggestDictionary.mjs

@@ -50,7 +50,7 @@ class SuggestDictionaryImpl {
         return ignoreCaseAndAccents && (this.suggestions.has(lcWord) || this.suggestionsLower.has(lcWord));
     }
     suggest(word) {
-        return this._suggest(word) || this._suggest(word.toLowerCase()) || [];
+        return this.getPreferredSuggestions(word);
     }
     _suggest(word) {
         if (!(word in this.typosDef))
@@ -70,6 +70,9 @@ class SuggestDictionaryImpl {
         }
         return sug.map((word, index) => ({ word, cost: index + 1, isPreferred }));
     }
+    getPreferredSuggestions(word) {
+        return this._suggest(word) || this._suggest(word.toLowerCase()) || [];
+    }
     genSuggestions(collector) {
         const sugs = this.suggest(collector.word);
         sugs.forEach((result) => collector.add(result));

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

@@ -1,6 +1,7 @@
-import type { IgnoreCaseOption, SpellingDictionary } from './SpellingDictionary.mjs';
+import type { IgnoreCaseOption, PreferredSuggestion, SpellingDictionary } from './SpellingDictionary.mjs';
 import { type TypoEntry, type TyposDef } from './Typos/index.mjs';
 export interface TyposDictionary extends SpellingDictionary {
+    getPreferredSuggestions: (word: string) => PreferredSuggestion[];
     isForbidden(word: string, ignoreCaseAndAccents?: IgnoreCaseOption): boolean;
     /**
      * Determine if the word can appear in a list of suggestions.

package/dist/esm/SpellingDictionary/TyposDictionary.mjs

@@ -80,7 +80,7 @@ class TyposDictionaryImpl {
         return ignoreCaseAndAccents && (this.suggestions.has(lcWord) || this.suggestionsLower.has(lcWord));
     }
     suggest(word) {
-        return this._suggest(word) || this._suggest(word.toLowerCase()) || [];
+        return this.getPreferredSuggestions(word);
     }
     _suggest(word) {
         if (this.ignoreWords.has(word))
@@ -106,6 +106,9 @@ class TyposDictionaryImpl {
         const sugs = this.suggest(collector.word);
         sugs.forEach((result) => collector.add(result));
     }
+    getPreferredSuggestions(word) {
+        return this._suggest(word) || this._suggest(word.toLowerCase()) || [];
+    }
     mapWord(word) {
         return word;
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cspell-dictionary",
-  "version": "6.29.3",
+  "version": "6.30.1",
   "description": "A spelling dictionary library useful for checking words and getting suggestions.",
   "type": "commonjs",
   "main": "dist/cjs/index.js",
@@ -52,11 +52,11 @@
     "node": ">=14"
   },
   "dependencies": {
-    "@cspell/cspell-pipe": "6.29.3",
-    "@cspell/cspell-types": "6.29.3",
-    "cspell-trie-lib": "6.29.3",
+    "@cspell/cspell-pipe": "6.30.1",
+    "@cspell/cspell-types": "6.30.1",
+    "cspell-trie-lib": "6.30.1",
     "fast-equals": "^4.0.3",
     "gensequence": "^5.0.2"
   },
-  "gitHead": "a46e27dd5e9d52d83f0bfdbeeafcda58ca516fc1"
+  "gitHead": "3352b82591cd0cb27e5cd04dea93773e98a606df"
 }