cspell-lib 5.18.5 → 5.19.0

package/dist/Settings/link.js

@@ -1,7 +1,11 @@
 "use strict";
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
-    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
 }) : (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
     o[k2] = m[k];
@@ -22,6 +26,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.__testing__ = exports.removePathsFromGlobalImports = exports.addPathsToGlobalImports = exports.listGlobalImports = void 0;
 const fs = __importStar(require("fs"));
 const Path = __importStar(require("path"));
+const util_1 = require("../util/util");
 const configLoader_1 = require("./configLoader");
 const GlobalSettings_1 = require("./GlobalSettings");
 function listGlobalImports() {
@@ -129,12 +134,12 @@ function resolveSettings(filename) {
     const ref = settings.__importRef;
     const resolvedToFilename = ref === null || ref === void 0 ? void 0 : ref.filename;
     const error = ((_a = ref === null || ref === void 0 ? void 0 : ref.error) === null || _a === void 0 ? void 0 : _a.message) || (!resolvedToFilename && 'File not Found') || undefined;
-    return {
+    return (0, util_1.clean)({
         filename,
         resolvedToFilename,
         error,
         settings,
-    };
+    });
 }
 function normalizeImports(imports) {
     return typeof imports === 'string' ? [imports] : imports || [];

package/dist/SpellingDictionary/Dictionaries.d.ts

@@ -2,6 +2,8 @@ import { CSpellSettingsInternal, DictionaryDefinitionInternal } from '../Models/
 import { SpellingDictionary } from './SpellingDictionary';
 import { SpellingDictionaryCollection } from './SpellingDictionaryCollection';
 export declare function loadDictionaryDefs(defsToLoad: DictionaryDefinitionInternal[]): Promise<SpellingDictionary>[];
+export declare function loadDictionaryDefsSync(defsToLoad: DictionaryDefinitionInternal[]): SpellingDictionary[];
 export declare function refreshDictionaryCache(maxAge?: number): Promise<void>;
 export declare function getDictionaryInternal(settings: CSpellSettingsInternal): Promise<SpellingDictionaryCollection>;
+export declare function getDictionaryInternalSync(settings: CSpellSettingsInternal): SpellingDictionaryCollection;
 //# sourceMappingURL=Dictionaries.d.ts.map

package/dist/SpellingDictionary/Dictionaries.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getDictionaryInternal = exports.refreshDictionaryCache = exports.loadDictionaryDefs = void 0;
+exports.getDictionaryInternalSync = exports.getDictionaryInternal = exports.refreshDictionaryCache = exports.loadDictionaryDefsSync = exports.loadDictionaryDefs = void 0;
 const DictionarySettings_1 = require("../Settings/DictionarySettings");
 const util_1 = require("../util/util");
 const createSpellingDictionary_1 = require("./createSpellingDictionary");
@@ -10,14 +10,27 @@ function loadDictionaryDefs(defsToLoad) {
     return defsToLoad.map((def) => (0, DictionaryLoader_1.loadDictionary)(def.path, def));
 }
 exports.loadDictionaryDefs = loadDictionaryDefs;
+function loadDictionaryDefsSync(defsToLoad) {
+    return defsToLoad.map((def) => (0, DictionaryLoader_1.loadDictionarySync)(def.path, def));
+}
+exports.loadDictionaryDefsSync = loadDictionaryDefsSync;
 function refreshDictionaryCache(maxAge) {
     return (0, DictionaryLoader_1.refreshCacheEntries)(maxAge);
 }
 exports.refreshDictionaryCache = refreshDictionaryCache;
 const emptyWords = Object.freeze([]);
-function getDictionaryInternal(settings) {
+async function getDictionaryInternal(settings) {
+    const spellDictionaries = await Promise.all(loadDictionaryDefs((0, DictionarySettings_1.calcDictionaryDefsToLoad)(settings)));
+    return _getDictionaryInternal(settings, spellDictionaries);
+}
+exports.getDictionaryInternal = getDictionaryInternal;
+function getDictionaryInternalSync(settings) {
+    const spellDictionaries = loadDictionaryDefsSync((0, DictionarySettings_1.calcDictionaryDefsToLoad)(settings));
+    return _getDictionaryInternal(settings, spellDictionaries);
+}
+exports.getDictionaryInternalSync = getDictionaryInternalSync;
+function _getDictionaryInternal(settings, spellDictionaries) {
     const { words = emptyWords, userWords = emptyWords, flagWords = emptyWords, ignoreWords = emptyWords } = settings;
-    const spellDictionaries = loadDictionaryDefs((0, DictionarySettings_1.calcDictionaryDefsToLoad)(settings));
     const settingsWordsDictionary = (0, createSpellingDictionary_1.createSpellingDictionary)(words, '[words]', 'From Settings `words`', {
         caseSensitive: true,
         weightMap: undefined,
@@ -43,7 +56,6 @@ function getDictionaryInternal(settings) {
         ignoreWordsDictionary,
         flagWordsDictionary,
     ].filter(util_1.isDefined);
-    return (0, SpellingDictionaryCollection_1.createCollectionP)(dictionaries, 'dictionary collection');
+    return (0, SpellingDictionaryCollection_1.createCollection)(dictionaries, 'dictionary collection');
 }
-exports.getDictionaryInternal = getDictionaryInternal;
 //# sourceMappingURL=Dictionaries.js.map

package/dist/SpellingDictionary/DictionaryLoader.d.ts

@@ -1,15 +1,23 @@
 import { DictionaryDefinitionInternal } from '../Models/CSpellSettingsInternalDef';
 import { SpellingDictionary } from './SpellingDictionary';
 export declare type LoadOptions = DictionaryDefinitionInternal;
+declare enum LoadingState {
+    Loaded = 0,
+    Loading = 1
+}
 interface CacheEntry {
     uri: string;
     options: LoadOptions;
     ts: number;
-    state: Promise<Stats | Error>;
-    dictionary: Promise<SpellingDictionary>;
+    stat: Stats | Error | undefined;
+    dictionary: SpellingDictionary | undefined;
+    pending: Promise<readonly [SpellingDictionary, Stats | Error]>;
+    loadingState: LoadingState;
+    sig: number;
 }
 export declare type LoaderType = keyof Loaders;
 export declare type Loader = (filename: string, options: LoadOptions) => Promise<SpellingDictionary>;
+export declare type LoaderSync = (filename: string, options: LoadOptions) => SpellingDictionary;
 export interface Loaders {
     S: Loader;
     C: Loader;
@@ -17,7 +25,15 @@ export interface Loaders {
     W: Loader;
     default: Loader;
 }
+export interface SyncLoaders {
+    S: LoaderSync;
+    C: LoaderSync;
+    T: LoaderSync;
+    W: LoaderSync;
+    default: LoaderSync;
+}
 export declare function loadDictionary(uri: string, options: DictionaryDefinitionInternal): Promise<SpellingDictionary>;
+export declare function loadDictionarySync(uri: string, options: DictionaryDefinitionInternal): SpellingDictionary;
 /**
  * Check to see if any of the cached dictionaries have changed. If one has changed, reload it.
  * @param maxAge - Only check the dictionary if it has been at least `maxAge` ms since the last check.
@@ -64,5 +80,8 @@ interface StatsBase<T> {
     birthtime: Date;
 }
 export declare type Stats = StatsBase<number>;
+export declare const __testing__: {
+    debugLog: string[];
+};
 export {};
 //# sourceMappingURL=DictionaryLoader.d.ts.map

package/dist/SpellingDictionary/DictionaryLoader.js

@@ -1,7 +1,11 @@
 "use strict";
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
-    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
 }) : (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
     o[k2] = m[k];
@@ -19,10 +23,12 @@ var __importStar = (this && this.__importStar) || function (mod) {
     return result;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.testing = exports.refreshCacheEntries = exports.loadDictionary = void 0;
-const fs_extra_1 = require("fs-extra");
+exports.__testing__ = exports.testing = exports.refreshCacheEntries = exports.loadDictionarySync = exports.loadDictionary = void 0;
+const fs_1 = require("fs");
 const gensequence_1 = require("gensequence");
 const path = __importStar(require("path"));
+const util_1 = require("util");
+const errors_1 = require("../util/errors");
 const fileReader_1 = require("../util/fileReader");
 const createSpellingDictionary_1 = require("./createSpellingDictionary");
 const SpellingDictionaryError_1 = require("./SpellingDictionaryError");
@@ -35,19 +41,63 @@ const loaders = {
     T: loadTrie,
     default: loadSimpleWordList,
 };
+const loadersSync = {
+    S: loadSimpleWordListSync,
+    C: legacyWordListSync,
+    W: wordsPerLineWordListSync,
+    T: loadTrieSync,
+    default: loadSimpleWordListSync,
+};
+var LoadingState;
+(function (LoadingState) {
+    LoadingState[LoadingState["Loaded"] = 0] = "Loaded";
+    LoadingState[LoadingState["Loading"] = 1] = "Loading";
+})(LoadingState || (LoadingState = {}));
+const debugLog = [];
+const debugMode = false;
+function __log(msg) {
+    debugMode && debugLog.push(msg);
+}
 const dictionaryCache = new Map();
 function loadDictionary(uri, options) {
     const key = calcKey(uri, options);
     const entry = dictionaryCache.get(key);
     if (entry) {
-        return entry.dictionary;
+        return entry.pending.then(([dictionary]) => dictionary);
     }
     const loadedEntry = loadEntry(uri, options);
     dictionaryCache.set(key, loadedEntry);
-    return loadedEntry.dictionary;
+    return loadedEntry.pending.then(([dictionary]) => dictionary);
 }
 exports.loadDictionary = loadDictionary;
-const importantOptionKeys = ['name', 'noSuggest', 'useCompounds'];
+function loadDictionarySync(uri, options) {
+    const key = calcKey(uri, options);
+    const entry = dictionaryCache.get(key);
+    if ((entry === null || entry === void 0 ? void 0 : entry.dictionary) && entry.loadingState === LoadingState.Loaded) {
+        // if (entry.options.name === 'temp') {
+        //     __log(
+        //         `Cache Found ${entry.options.name}; ts: ${entry.sig.toFixed(2)}; file: ${path.relative(
+        //             process.cwd(),
+        //             entry.uri
+        //         )}`
+        //     );
+        // }
+        return entry.dictionary;
+    }
+    // if (options.name === 'temp') {
+    //     __log(
+    //         `Cache Miss ${options.name}; ts: ${entry?.sig.toFixed(2) || Date.now()}; file: ${path.relative(
+    //             process.cwd(),
+    //             uri
+    //         )}`
+    //     );
+    // }
+    const loadedEntry = loadEntrySync(uri, options);
+    dictionaryCache.set(key, loadedEntry);
+    return loadedEntry.dictionary;
+}
+exports.loadDictionarySync = loadDictionarySync;
+const importantOptionKeys = ['name', 'noSuggest', 'useCompounds', 'type'];
 function calcKey(uri, options) {
     const loaderType = determineType(uri, options);
     const optValues = importantOptionKeys.map((k) => { var _a; return ((_a = options[k]) === null || _a === void 0 ? void 0 : _a.toString()) || ''; });
@@ -60,21 +110,39 @@ function calcKey(uri, options) {
  * @param now - optional timestamp representing now. (Mostly used in testing)
  */
 async function refreshCacheEntries(maxAge = MAX_AGE, now = Date.now()) {
-    await Promise.all([...dictionaryCache].map(([, entry]) => refreshEntry(entry, maxAge, now)));
+    await Promise.all([...dictionaryCache.values()].map((entry) => refreshEntry(entry, maxAge, now)));
 }
 exports.refreshCacheEntries = refreshCacheEntries;
 async function refreshEntry(entry, maxAge, now) {
     if (now - entry.ts >= maxAge) {
+        const sig = now + Math.random();
         // Write to the ts, so the next one will not do it.
+        entry.sig = sig;
         entry.ts = now;
-        const pStat = (0, fs_extra_1.stat)(entry.uri).catch((e) => e);
-        const [state, oldState] = await Promise.all([pStat, entry.state]);
-        if (entry.ts === now && !isEqual(state, oldState)) {
+        const pStat = getStat(entry.uri);
+        const [newStat] = await Promise.all([pStat, entry.pending]);
+        const hasChanged = !isEqual(newStat, entry.stat);
+        const sigMatches = entry.sig === sig;
+        // if (entry.options.name === 'temp') {
+        //     const processedAt = Date.now();
+        //     __log(
+        //         `Refresh ${entry.options.name}; sig: ${sig.toFixed(
+        //             2
+        //         )} at ${processedAt}; Sig Matches: ${sigMatches.toString()}; changed: ${hasChanged.toString()}; file: ${path.relative(
+        //             process.cwd(),
+        //             entry.uri
+        //         )}`
+        //     );
+        // }
+        if (sigMatches && hasChanged) {
+            entry.loadingState = LoadingState.Loading;
             dictionaryCache.set(calcKey(entry.uri, entry.options), loadEntry(entry.uri, entry.options));
         }
     }
 }
 function isEqual(a, b) {
+    if (!b)
+        return false;
     if (isError(a)) {
         return isError(b) && a.message === b.message && a.name === b.name;
     }
@@ -82,22 +150,69 @@ function isEqual(a, b) {
 }
 function isError(e) {
     const err = e;
-    return !!(err.name && err.message);
+    return !!err.message;
 }
 function loadEntry(uri, options, now = Date.now()) {
-    const dictionary = load(uri, options).catch((e) => (0, createSpellingDictionary_1.createFailedToLoadDictionary)(new SpellingDictionaryError_1.SpellingDictionaryLoadError(uri, options, e, 'failed to load')));
-    return {
+    const pDictionary = load(uri, options).catch((e) => (0, createSpellingDictionary_1.createFailedToLoadDictionary)(new SpellingDictionaryError_1.SpellingDictionaryLoadError(uri, options, e, 'failed to load')));
+    const pStat = getStat(uri);
+    const pending = Promise.all([pDictionary, pStat]);
+    const sig = now + Math.random();
+    const entry = {
         uri,
         options,
         ts: now,
-        state: (0, fs_extra_1.stat)(uri).catch((e) => e),
-        dictionary,
+        stat: undefined,
+        dictionary: undefined,
+        pending,
+        loadingState: LoadingState.Loading,
+        sig,
     };
+    // eslint-disable-next-line promise/catch-or-return
+    pending.then(([dictionary, stat]) => {
+        entry.stat = stat;
+        entry.dictionary = dictionary;
+        entry.loadingState = LoadingState.Loaded;
+        return;
+    });
+    return entry;
+}
+function loadEntrySync(uri, options, now = Date.now()) {
+    const stat = getStatSync(uri);
+    const sig = now + Math.random();
+    try {
+        const dictionary = loadSync(uri, options);
+        const pending = Promise.resolve([dictionary, stat]);
+        return {
+            uri,
+            options,
+            ts: now,
+            stat,
+            dictionary,
+            pending,
+            loadingState: LoadingState.Loaded,
+            sig,
+        };
+    }
+    catch (e) {
+        const error = e instanceof Error ? e : new Error((0, util_1.format)(e));
+        const dictionary = (0, createSpellingDictionary_1.createFailedToLoadDictionary)(new SpellingDictionaryError_1.SpellingDictionaryLoadError(uri, options, error, 'failed to load'));
+        const pending = Promise.resolve([dictionary, stat]);
+        return {
+            uri,
+            options,
+            ts: now,
+            stat,
+            dictionary,
+            pending,
+            loadingState: LoadingState.Loaded,
+            sig,
+        };
+    }
 }
 function determineType(uri, opts) {
     const t = (opts.type && opts.type in loaders && opts.type) || 'S';
     const defLoaderType = t;
-    const defType = uri.endsWith('.trie.gz') ? 'T' : uri.endsWith('.txt.gz') ? defLoaderType : defLoaderType;
+    const defType = uri.endsWith('.trie.gz') ? 'T' : defLoaderType;
     const regTrieTest = /\.trie\b/i;
     return regTrieTest.test(uri) ? 'T' : defType;
 }
@@ -106,8 +221,20 @@ function load(uri, options) {
     const loader = loaders[type] || loaders.default;
     return loader(uri, options);
 }
+function loadSync(uri, options) {
+    const type = determineType(uri, options);
+    const loader = loadersSync[type] || loaders.default;
+    return loader(uri, options);
+}
 async function legacyWordList(filename, options) {
     const lines = await (0, fileReader_1.readLines)(filename);
+    return _legacyWordListSync(lines, filename, options);
+}
+function legacyWordListSync(filename, options) {
+    const lines = (0, fileReader_1.readLinesSync)(filename);
+    return _legacyWordListSync(lines, filename, options);
+}
+function _legacyWordListSync(lines, filename, options) {
     const words = (0, gensequence_1.genSequence)(lines)
         // Remove comments
         .map((line) => line.replace(/#.*/g, ''))
@@ -118,6 +245,13 @@ async function legacyWordList(filename, options) {
 }
 async function wordsPerLineWordList(filename, options) {
     const lines = await (0, fileReader_1.readLines)(filename);
+    return _wordsPerLineWordList(lines, filename, options);
+}
+function wordsPerLineWordListSync(filename, options) {
+    const lines = (0, fileReader_1.readLinesSync)(filename);
+    return _wordsPerLineWordList(lines, filename, options);
+}
+function _wordsPerLineWordList(lines, filename, options) {
     const words = (0, gensequence_1.genSequence)(lines)
         // Remove comments
         .map((line) => line.replace(/#.*/g, ''))
@@ -130,10 +264,18 @@ async function loadSimpleWordList(filename, options) {
     const lines = await (0, fileReader_1.readLines)(filename);
     return (0, createSpellingDictionary_1.createSpellingDictionary)(lines, determineName(filename, options), filename, options);
 }
+function loadSimpleWordListSync(filename, options) {
+    const lines = (0, fileReader_1.readLinesSync)(filename);
+    return (0, createSpellingDictionary_1.createSpellingDictionary)(lines, determineName(filename, options), filename, options);
+}
 async function loadTrie(filename, options) {
     const lines = await (0, fileReader_1.readLines)(filename);
     return (0, SpellingDictionaryFromTrie_1.createSpellingDictionaryTrie)(lines, determineName(filename, options), filename, options);
 }
+function loadTrieSync(filename, options) {
+    const lines = (0, fileReader_1.readLinesSync)(filename);
+    return (0, SpellingDictionaryFromTrie_1.createSpellingDictionaryTrie)(lines, determineName(filename, options), filename, options);
+}
 function determineName(filename, options) {
     return options.name || path.basename(filename);
 }
@@ -143,4 +285,25 @@ exports.testing = {
     loadEntry,
     load,
 };
+function toError(e) {
+    if ((0, errors_1.isErrnoException)(e))
+        return e;
+    if (e instanceof Error)
+        return e;
+    return new Error((0, util_1.format)(e));
+}
+function getStat(uri) {
+    return fs_1.promises.stat(uri).catch((e) => toError(e));
+}
+function getStatSync(uri) {
+    try {
+        return (0, fs_1.statSync)(uri);
+    }
+    catch (e) {
+        return toError(e);
+    }
+}
+exports.__testing__ = {
+    debugLog,
+};
 //# sourceMappingURL=DictionaryLoader.js.map

package/dist/SpellingDictionary/SpellingDictionaryCollection.d.ts

@@ -26,7 +26,6 @@ export declare class SpellingDictionaryCollection implements SpellingDictionary
 export declare function createCollection(dictionaries: SpellingDictionary[], name: string): SpellingDictionaryCollection;
 declare function isWordInAnyDictionary(dicts: SpellingDictionary[], word: string, options: SearchOptions): SpellingDictionary | undefined;
 declare function isWordForbiddenInAnyDictionary(dicts: SpellingDictionary[], word: string): SpellingDictionary | undefined;
-export declare function createCollectionP(dicts: (Promise<SpellingDictionary> | SpellingDictionary)[], name: string): Promise<SpellingDictionaryCollection>;
 export declare const __testing__: {
     isWordInAnyDictionary: typeof isWordInAnyDictionary;
     isWordForbiddenInAnyDictionary: typeof isWordForbiddenInAnyDictionary;

package/dist/SpellingDictionary/SpellingDictionaryCollection.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.__testing__ = exports.createCollectionP = exports.createCollection = exports.SpellingDictionaryCollection = void 0;
+exports.__testing__ = exports.createCollection = exports.SpellingDictionaryCollection = void 0;
 const cspell_trie_lib_1 = require("cspell-trie-lib");
 const gensequence_1 = require("gensequence");
 const Settings_1 = require("../Settings");
@@ -54,23 +54,21 @@ class SpellingDictionaryCollection {
         return this._suggest(word, suggestOptions);
     }
     _suggest(word, suggestOptions) {
-        const _suggestOptions = { ...suggestOptions };
-        const { numSuggestions = (0, Settings_1.getDefaultSettings)().numSuggestions || SpellingDictionaryMethods_1.defaultNumSuggestions, numChanges, compoundMethod, ignoreCase, includeTies, timeout, } = suggestOptions;
-        _suggestOptions.compoundMethod = this.options.useCompounds ? SpellingDictionary_1.CompoundWordsMethod.JOIN_WORDS : compoundMethod;
+        const { numSuggestions = (0, Settings_1.getDefaultSettings)().numSuggestions || SpellingDictionaryMethods_1.defaultNumSuggestions, numChanges, ignoreCase, includeTies, timeout, } = suggestOptions;
         const prefixNoCase = cspell_trie_lib_1.CASE_INSENSITIVE_PREFIX;
         const filter = (word, _cost) => {
             return ((ignoreCase || word[0] !== prefixNoCase) &&
                 !this.isForbidden(word) &&
                 !this.isNoSuggestWord(word, suggestOptions));
         };
-        const collector = (0, SpellingDictionaryMethods_1.suggestionCollector)(word, {
+        const collector = (0, SpellingDictionaryMethods_1.suggestionCollector)(word, (0, util_1.clean)({
             numSuggestions,
             filter,
             changeLimit: numChanges,
             includeTies,
             ignoreCase,
             timeout,
-        });
+        }));
         this.genSuggestions(collector, suggestOptions);
         return collector.suggestions.map((r) => ({ ...r, word: r.word }));
     }
@@ -111,10 +109,6 @@ function isNoSuggestWordInAnyDictionary(dicts, word, options) {
 function isWordForbiddenInAnyDictionary(dicts, word) {
     return (0, gensequence_1.genSequence)(dicts).first((dict) => dict.isForbidden(word));
 }
-function createCollectionP(dicts, name) {
-    return Promise.all(dicts).then((dicts) => new SpellingDictionaryCollection(dicts, name));
-}
-exports.createCollectionP = createCollectionP;
 exports.__testing__ = {
     isWordInAnyDictionary,
     isWordForbiddenInAnyDictionary,

package/dist/SpellingDictionary/SpellingDictionaryFromTrie.d.ts

@@ -30,5 +30,5 @@ export declare class SpellingDictionaryFromTrie implements SpellingDictionary {
     genSuggestions(collector: SuggestionCollector, suggestOptions: SuggestOptions): void;
     getErrors(): Error[];
 }
-export declare function createSpellingDictionaryTrie(data: Iterable<string>, name: string, source: string, options: SpellingDictionaryOptions): Promise<SpellingDictionary>;
+export declare function createSpellingDictionaryTrie(data: Iterable<string>, name: string, source: string, options: SpellingDictionaryOptions): SpellingDictionary;
 //# sourceMappingURL=SpellingDictionaryFromTrie.d.ts.map

package/dist/SpellingDictionary/SpellingDictionaryFromTrie.js

@@ -5,6 +5,7 @@ const cspell_trie_lib_1 = require("cspell-trie-lib");
 const Settings_1 = require("../Settings");
 const Memorizer_1 = require("../util/Memorizer");
 const repMap_1 = require("../util/repMap");
+const util_1 = require("../util/util");
 const SpellingDictionaryMethods_1 = require("./SpellingDictionaryMethods");
 class SpellingDictionaryFromTrie {
     constructor(trie, name, options, source = 'from trie', size) {
@@ -100,7 +101,7 @@ class SpellingDictionaryFromTrie {
         function filter(_word) {
             return true;
         }
-        const collector = (0, cspell_trie_lib_1.suggestionCollector)(word, {
+        const collector = (0, cspell_trie_lib_1.suggestionCollector)(word, (0, util_1.clean)({
             numSuggestions,
             filter,
             changeLimit: numChanges,
@@ -108,7 +109,7 @@ class SpellingDictionaryFromTrie {
             ignoreCase,
             timeout,
             weightMap: this.weightMap,
-        });
+        }));
         this.genSuggestions(collector, suggestOptions);
         return collector.suggestions.map((r) => ({ ...r, word: r.word }));
     }
@@ -125,7 +126,7 @@ class SpellingDictionaryFromTrie {
 }
 exports.SpellingDictionaryFromTrie = SpellingDictionaryFromTrie;
 SpellingDictionaryFromTrie.cachedWordsLimit = 50000;
-async function createSpellingDictionaryTrie(data, name, source, options) {
+function createSpellingDictionaryTrie(data, name, source, options) {
     const trieNode = (0, cspell_trie_lib_1.importTrie)(data);
     const trie = new cspell_trie_lib_1.Trie(trieNode);
     return new SpellingDictionaryFromTrie(trie, name, options, source);

package/dist/SpellingDictionary/SpellingDictionaryMethods.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.__testMethods = exports.createWeightMapFromDictionaryInformation = exports.suggestArgsToSuggestOptions = exports.hasOptionToSearchOption = exports.wordDictionaryFormsCollector = exports.wordSuggestForms = exports.wordSuggestFormsArray = exports.wordSearchForms = exports.wordSearchFormsArray = exports.defaultNumSuggestions = exports.suggestionCollector = exports.impersonateCollector = void 0;
 const cspell_trie_lib_1 = require("cspell-trie-lib");
+const trie_util_1 = require("cspell-trie-lib/dist/lib/trie-util");
 const gensequence_1 = require("gensequence");
 const text_1 = require("../util/text");
 var cspell_trie_lib_2 = require("cspell-trie-lib");
@@ -89,14 +90,14 @@ function suggestArgsToSuggestOptions(args) {
     const [_word, options, compoundMethod, numChanges, ignoreCase] = args;
     const suggestOptions = typeof options === 'object'
         ? options
-        : {
+        : (0, trie_util_1.clean)({
             numSuggestions: options,
             compoundMethod,
             numChanges,
             ignoreCase,
             includeTies: undefined,
             timeout: undefined,
-        };
+        });
     return suggestOptions;
 }
 exports.suggestArgsToSuggestOptions = suggestArgsToSuggestOptions;

package/dist/SpellingDictionary/index.js

@@ -1,7 +1,11 @@
 "use strict";
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
-    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
 }) : (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
     o[k2] = m[k];

package/dist/index.d.ts

@@ -1,21 +1,24 @@
-import * as ExclusionHelper from './exclusionHelper';
 import { CSpellUserSettings } from '@cspell/cspell-types';
+import * as ExclusionHelper from './exclusionHelper';
 import * as Link from './Settings/index.link';
 import { SpellingDictionaryCollection } from './SpellingDictionary';
 import * as Text from './util/text';
+export * from '@cspell/cspell-types';
 export * from 'cspell-io';
 export { ExcludeFilesGlobMap, ExclusionFunction } from './exclusionHelper';
 export { getLanguagesForExt } from './LanguageIds';
+export { createTextDocument } from './Models/TextDocument';
+export type { CreateTextDocumentParams, TextDocument, TextDocumentLine } from './Models/TextDocument';
 export * from './Settings';
-export * from '@cspell/cspell-types';
 export { defaultFileName as defaultSettingsFilename } from './Settings';
 export { combineTextAndLanguageSettings, combineTextAndLanguageSettings as constructSettingsForText, } from './Settings/TextDocumentSettings';
 export { determineFinalDocumentSettings, DetermineFinalDocumentSettingsResult, Document, fileToDocument, isBinaryFile, spellCheckDocument, spellCheckFile, SpellCheckFileOptions, SpellCheckFileResult, } from './spellCheckFile';
 export { CompoundWordsMethod, createSpellingDictionary, isSpellingDictionaryLoadError, refreshDictionaryCache, SpellingDictionary, SpellingDictionaryCollection, SpellingDictionaryLoadError, SuggestionCollector, SuggestionResult, SuggestOptions, } from './SpellingDictionary';
+export { SuggestionError, suggestionsForWord, suggestionsForWords } from './suggestions';
+export type { SuggestedWord, SuggestionOptions, SuggestionsForWordResult } from './suggestions';
+export { DocumentValidator, DocumentValidatorOptions } from './textValidation';
 export { traceWords, traceWordsAsync } from './trace';
 export type { TraceOptions, TraceResult } from './trace';
-export { suggestionsForWord, suggestionsForWords, SuggestionError } from './suggestions';
-export type { SuggestedWord, SuggestionOptions, SuggestionsForWordResult } from './suggestions';
 export { getLogger, Logger, setLogger } from './util/logger';
 export { resolveFile } from './util/resolveFile';
 export { checkText, CheckTextInfo, IncludeExcludeFlag, IncludeExcludeOptions, TextInfoItem, validateText, ValidationIssue, } from './validator';