cspell-lib 8.3.0 → 8.3.2

package/dist/esm/SpellingDictionary/Dictionaries.d.ts

@@ -1,6 +1,17 @@
+import type { CSpellSettings } from '@cspell/cspell-types';
 import type { SpellingDictionary, SpellingDictionaryCollection } from 'cspell-dictionary';
 import type { CSpellSettingsInternal, DictionaryDefinitionInternal } from '../Models/CSpellSettingsInternalDef.js';
 export declare function loadDictionaryDefs(defsToLoad: DictionaryDefinitionInternal[]): Promise<SpellingDictionary>[];
 export declare function refreshDictionaryCache(maxAge?: number): Promise<void>;
 export declare function getDictionaryInternal(settings: CSpellSettingsInternal): Promise<SpellingDictionaryCollection>;
+export declare const specialDictionaryNames: {
+    readonly words: "[words]";
+    readonly userWords: "[userWords]";
+    readonly flagWords: "[flagWords]";
+    readonly ignoreWords: "[ignoreWords]";
+    readonly suggestWords: "[suggestWords]";
+};
+export type DictionaryNameFields = keyof typeof specialDictionaryNames;
+export declare const mapSpecialDictionaryNamesToSettings: Map<string, DictionaryNameFields>;
+export declare function getInlineConfigDictionaries(settings: CSpellSettings): SpellingDictionary[];
 //# sourceMappingURL=Dictionaries.d.ts.map

package/dist/esm/SpellingDictionary/Dictionaries.js

@@ -13,29 +13,40 @@ export async function getDictionaryInternal(settings) {
     const spellDictionaries = await Promise.all(loadDictionaryDefs(calcDictionaryDefsToLoad(settings)));
     return _getDictionaryInternal(settings, spellDictionaries);
 }
-function _getDictionaryInternal(settings, spellDictionaries) {
+export const specialDictionaryNames = {
+    words: '[words]',
+    userWords: '[userWords]',
+    flagWords: '[flagWords]',
+    ignoreWords: '[ignoreWords]',
+    suggestWords: '[suggestWords]',
+};
+export const mapSpecialDictionaryNamesToSettings = new Map(Object.entries(specialDictionaryNames).map(([k, v]) => [v, k]));
+export function getInlineConfigDictionaries(settings) {
     const { words = emptyWords, userWords = emptyWords, flagWords = emptyWords, ignoreWords = emptyWords, suggestWords = emptyWords, } = settings;
-    const settingsWordsDictionary = createSpellingDictionary(words, '[words]', 'From Settings `words`', {
+    const settingsWordsDictionary = createSpellingDictionary(words, specialDictionaryNames.words, 'From Settings `words`', {
         caseSensitive: true,
         weightMap: undefined,
     });
     const settingsUserWordsDictionary = userWords.length
-        ? createSpellingDictionary(userWords, '[userWords]', 'From Settings `userWords`', {
+        ? createSpellingDictionary(userWords, specialDictionaryNames.userWords, 'From Settings `userWords`', {
             caseSensitive: true,
             weightMap: undefined,
         })
         : undefined;
-    const ignoreWordsDictionary = createIgnoreWordsDictionary(ignoreWords, '[ignoreWords]', 'From Settings `ignoreWords`');
-    const flagWordsDictionary = createForbiddenWordsDictionary(flagWords, '[flagWords]', 'From Settings `flagWords`');
+    const ignoreWordsDictionary = createIgnoreWordsDictionary(ignoreWords, specialDictionaryNames.ignoreWords, 'From Settings `ignoreWords`');
+    const flagWordsDictionary = createForbiddenWordsDictionary(flagWords, specialDictionaryNames.flagWords, 'From Settings `flagWords`');
     const suggestWordsDictionary = createSuggestDictionary(suggestWords, '[suggestWords]', 'From Settings `suggestWords`');
     const dictionaries = [
-        ...spellDictionaries,
         settingsWordsDictionary,
         settingsUserWordsDictionary,
         ignoreWordsDictionary,
         flagWordsDictionary,
         suggestWordsDictionary,
     ].filter(isDefined);
+    return dictionaries;
+}
+function _getDictionaryInternal(settings, spellDictionaries) {
+    const dictionaries = [...spellDictionaries, ...getInlineConfigDictionaries(settings)];
     return createCollection(dictionaries, 'dictionary collection');
 }
 //# sourceMappingURL=Dictionaries.js.map

package/dist/esm/index.d.ts

@@ -16,7 +16,7 @@ export { CompoundWordsMethod, createSpellingDictionary, createCollection as crea
 export type { SuggestedWord, SuggestionOptions, SuggestionsForWordResult } from './suggestions.js';
 export { SuggestionError, suggestionsForWord, suggestionsForWords } from './suggestions.js';
 export { DocumentValidator, DocumentValidatorOptions, shouldCheckDocument } from './textValidation/index.js';
-export type { TraceOptions, TraceResult } from './trace.js';
+export type { TraceOptions, TraceResult, TraceWordResult } from './trace.js';
 export { traceWords, traceWordsAsync } from './trace.js';
 export { getLogger, Logger, setLogger } from './util/logger.js';
 export { resolveFile } from './util/resolveFile.js';

package/dist/esm/textValidation/ValidationTypes.d.ts

@@ -1,6 +1,7 @@
 import type { MappedText, TextOffset as TextOffsetRW } from '@cspell/cspell-types';
 import type { ExtendedSuggestion } from '../Models/Suggestion.js';
 import type { ValidationIssue } from '../Models/ValidationIssue.js';
+export type { TextOffset as TextOffsetRW } from '@cspell/cspell-types';
 export type TextOffsetRO = Readonly<TextOffsetRW>;
 export interface ValidationOptions extends IncludeExcludeOptions {
     maxNumberOfProblems?: number;

package/dist/esm/textValidation/docValidator.d.ts

@@ -77,16 +77,7 @@ export declare class DocumentValidator {
      * @returns MatchRanges of text to include.
      */
     getCheckedTextRanges(): MatchRange[];
-    traceWord(word: string): {
-        word: string;
-        found: boolean;
-        foundWord: string | undefined;
-        forbidden: boolean;
-        noSuggest: boolean;
-        dictName: string;
-        dictSource: string;
-        errors: Error[] | undefined;
-    }[];
+    traceWord(word: string): import("./traceWord.js").TraceResult;
     private defaultParser;
     private _checkParsedText;
     private addPossibleError;

package/dist/esm/textValidation/docValidator.js

@@ -11,13 +11,13 @@ import { calcSuggestionAdjustedToToMatchCase } from '../suggestions.js';
 import { catchPromiseError, toError } from '../util/errors.js';
 import { AutoCache } from '../util/simpleCache.js';
 import { uriToFilePath } from '../util/Uri.js';
-import { toFilePathOrHref } from '../util/url.js';
 import { defaultMaxDuplicateProblems, defaultMaxNumberOfProblems } from './defaultConstants.js';
 import { determineTextDocumentSettings } from './determineTextDocumentSettings.js';
 import { textValidatorFactory } from './lineValidatorFactory.js';
 import { createMappedTextSegmenter } from './parsedText.js';
 import { settingsToValidateOptions } from './settingsToValidateOptions.js';
 import { calcTextInclusionRanges } from './textValidator.js';
+import { traceWord } from './traceWord.js';
 const ERROR_NOT_PREPARED = 'Validator Must be prepared before calling this function.';
 export class DocumentValidator {
     settings;
@@ -248,25 +248,7 @@ export class DocumentValidator {
     }
     traceWord(word) {
         assert(this._preparations, ERROR_NOT_PREPARED);
-        const dictCollection = this._preparations.dictionary;
-        const config = this._preparations.config;
-        const opts = {
-            ignoreCase: true,
-            allowCompoundWords: config.allowCompoundWords || false,
-        };
-        const trace = dictCollection.dictionaries
-            .map((dict) => ({ dict, findResult: dict.find(word, opts) }))
-            .map(({ dict, findResult }) => ({
-            word,
-            found: !!findResult?.found,
-            foundWord: findResult?.found || undefined,
-            forbidden: findResult?.forbidden || false,
-            noSuggest: findResult?.noSuggest || false,
-            dictName: dict.name,
-            dictSource: toFilePathOrHref(dict.source),
-            errors: normalizeErrors(dict.getErrors?.()),
-        }));
-        return trace;
+        return traceWord(word, this._preparations.dictionary, this._preparations.config);
     }
     defaultParser() {
         return pipeSync(this.document.getLines(), opMap((line) => {
@@ -409,7 +391,4 @@ function recordPerfTime(timings, name) {
 function timePromise(timings, name, p) {
     return p.finally(recordPerfTime(timings, name));
 }
-function normalizeErrors(errors) {
-    return errors?.length ? errors : undefined;
-}
 //# sourceMappingURL=docValidator.js.map

package/dist/esm/textValidation/lineValidatorFactory.js

@@ -88,7 +88,7 @@ export function lineValidatorFactory(sDict, options) {
                 };
                 return [vr];
             }
-            const mismatches = toArray(pipe(Text.extractWordsFromTextOffset(possibleWord), opFilter(filterAlreadyChecked), opMap((wo) => ({ ...wo, line: lineSegment.line })), opMap(annotateIsFlagged), opFilter(rememberFilter((wo) => wo.text.length >= minWordLength || !!wo.isFlagged)), opConcatMap(checkFullWord)));
+            const mismatches = toArray(pipe(Text.extractWordsFromTextOffset(possibleWord), opFilter((wo) => filterAlreadyChecked(wo)), opMap((wo) => ((wo.line = lineSegment.line), wo)), opMap(annotateIsFlagged), opFilter(rememberFilter((wo) => wo.text.length >= minWordLength || !!wo.isFlagged)), opConcatMap(checkFullWord)));
             if (mismatches.length) {
                 // Try the more expensive word splitter
                 const splitResult = split(lineSegment.segment, possibleWord.offset, splitterIsValid);

package/dist/esm/textValidation/traceWord.d.ts

@@ -0,0 +1,27 @@
+import type { CSpellSettingsWithSourceTrace } from '@cspell/cspell-types';
+import type { SpellingDictionaryCollection } from '../SpellingDictionary/index.js';
+type Href = string;
+export interface DictionaryTraceResult {
+    word: string;
+    found: boolean;
+    foundWord: string | undefined;
+    forbidden: boolean;
+    noSuggest: boolean;
+    dictName: string;
+    dictSource: string;
+    configSource: Href | undefined;
+    errors: Error[] | undefined;
+}
+export interface WordSplits {
+    word: string;
+    found: boolean;
+}
+export interface TraceResult extends Array<DictionaryTraceResult> {
+    splits?: readonly WordSplits[];
+}
+export interface TraceOptions extends Pick<CSpellSettingsWithSourceTrace, 'source' | 'allowCompoundWords'> {
+    ignoreCase?: boolean;
+}
+export declare function traceWord(word: string, dictCollection: SpellingDictionaryCollection, config: TraceOptions): TraceResult;
+export {};
+//# sourceMappingURL=traceWord.d.ts.map

package/dist/esm/textValidation/traceWord.js

@@ -0,0 +1,106 @@
+import { getSources } from '../Settings/index.js';
+import { createCollection, getInlineConfigDictionaries, mapSpecialDictionaryNamesToSettings, } from '../SpellingDictionary/index.js';
+import { toFileUrl } from '../util/url.js';
+import { uniqueFn } from '../util/util.js';
+import { split } from '../util/wordSplitter.js';
+export function traceWord(word, dictCollection, config) {
+    const opts = {
+        ignoreCase: true,
+        useCompounds: config.allowCompoundWords || false,
+    };
+    const splits = split({ text: word, offset: 0 }, 0, checkWord);
+    const wfSplits = splits.words.map((s) => ({ word: s.text, found: s.isFound }));
+    const unique = uniqueFn((w) => w.word + '|' + w.found);
+    const wsFound = { word, found: dictCollection.has(word, opts) };
+    const wordSplits = wfSplits.find((s) => s.word === word) ? wfSplits : [wsFound, ...wfSplits];
+    const traces = wordSplits
+        .filter(unique)
+        .map((s) => s.word)
+        .flatMap((word) => dictCollection.dictionaries.map((dict) => ({ dict, word })))
+        .map(({ dict, word }) => ({ dict, findResult: dict.find(word, opts), word }))
+        .flatMap((r) => unpackDictionaryFindResult(r, config));
+    const r = new CTraceResult(...traces);
+    r.splits = wordSplits;
+    return r;
+    function checkWord(wo) {
+        return dictCollection.has(wo.text, opts);
+    }
+}
+/**
+ * Map FindInDictResult to DictionaryTraceResult
+ * If the word was found in a dictionary based upon a config field setting, then find the source config.
+ * @param found - a word found in a dictionary
+ * @param config - the trace config
+ * @returns DictionaryTraceResult[]
+ */
+function unpackDictionaryFindResult(found, config) {
+    const { word, dict, findResult } = found;
+    const baseResult = {
+        word,
+        found: !!findResult?.found,
+        foundWord: findResult?.found || undefined,
+        forbidden: findResult?.forbidden || false,
+        noSuggest: findResult?.noSuggest || false,
+        dictName: dict.name,
+        dictSource: dict.source,
+        configSource: undefined,
+        errors: normalizeErrors(dict.getErrors?.()),
+    };
+    const configFieldName = mapSpecialDictionaryNamesToSettings.get(dict.name);
+    if (!findResult?.found || !configFieldName || !config.source) {
+        return [baseResult];
+    }
+    const opts = {
+        ignoreCase: true,
+        useCompounds: config.allowCompoundWords || false,
+    };
+    const sources = getSources(config);
+    const results = [];
+    for (const src of sources) {
+        if (!src[configFieldName] ||
+            !Array.isArray(src[configFieldName]) ||
+            !src[configFieldName]?.length ||
+            !src.source?.filename) {
+            continue;
+        }
+        // We found a possible config, build a dictionary result for it.
+        const configSource = toFileUrl(src.source.filename).href;
+        const cfg = { [configFieldName]: src[configFieldName] };
+        const cfgDict = createCollection(getInlineConfigDictionaries(cfg), dict.name, configSource);
+        const findResult = cfgDict.find(word, opts);
+        if (!findResult?.found)
+            continue;
+        const result = {
+            word,
+            found: !!findResult?.found,
+            foundWord: findResult?.found || undefined,
+            forbidden: findResult?.forbidden || false,
+            noSuggest: findResult?.noSuggest || false,
+            dictName: dict.name,
+            dictSource: configSource,
+            configSource,
+            errors: normalizeErrors(dict.getErrors?.()),
+        };
+        results.push(result);
+        // console.log('unpackDictFindResult %o', {
+        //     id: src.id,
+        //     name: src.name,
+        //     filename: src.source?.filename,
+        //     configFieldName,
+        //     findResult,
+        //     cfg,
+        //     result,
+        // });
+    }
+    return results.length ? results : [baseResult];
+}
+function normalizeErrors(errors) {
+    return errors?.length ? errors : undefined;
+}
+class CTraceResult extends Array {
+    splits = [];
+    constructor(...items) {
+        super(...items);
+    }
+}
+//# sourceMappingURL=traceWord.js.map

package/dist/esm/trace.d.ts

@@ -1,5 +1,6 @@
 import type { CSpellSettings, LocaleId } from '@cspell/cspell-types';
 import type { LanguageId } from './LanguageIds.js';
+import type { WordSplits } from './textValidation/traceWord.js';
 export interface TraceResult {
     word: string;
     found: boolean;
@@ -18,6 +19,9 @@ export interface TraceOptions {
     ignoreCase?: boolean;
     allowCompoundWords?: boolean;
 }
+export interface TraceWordResult extends Array<TraceResult> {
+    splits: readonly WordSplits[];
+}
 export declare function traceWords(words: string[], settings: CSpellSettings, options: TraceOptions | undefined): Promise<TraceResult[]>;
-export declare function traceWordsAsync(words: Iterable<string> | AsyncIterable<string>, settings: CSpellSettings, options: TraceOptions | undefined): AsyncIterableIterator<TraceResult[]>;
+export declare function traceWordsAsync(words: Iterable<string> | AsyncIterable<string>, settings: CSpellSettings, options: TraceOptions | undefined): AsyncIterableIterator<TraceWordResult>;
 //# sourceMappingURL=trace.d.ts.map

package/dist/esm/trace.js

@@ -3,6 +3,7 @@ import { toInternalSettings } from './Settings/CSpellSettingsServer.js';
 import { finalizeSettings, mergeSettings } from './Settings/index.js';
 import { calcSettingsForLanguageId } from './Settings/LanguageSettings.js';
 import { getDictionaryInternal, refreshDictionaryCache } from './SpellingDictionary/index.js';
+import { traceWord } from './textValidation/traceWord.js';
 import { toFilePathOrHref } from './util/url.js';
 import * as util from './util/util.js';
 export async function traceWords(words, settings, options) {
@@ -37,33 +38,27 @@ export async function* traceWordsAsync(words, settings, options) {
     await refreshDictionaryCache();
     const { config, dicts, activeDictionaries } = await finalize(settings);
     const setOfActiveDicts = new Set(activeDictionaries);
-    const opts = util.clean({ ignoreCase, useCompounds: config.allowCompoundWords });
-    function normalizeErrors(errors) {
-        if (!errors?.length)
-            return undefined;
-        return errors;
-    }
     function processWord(word) {
-        return dicts.dictionaries
-            .map((dict) => ({ dict, findResult: dict.find(word, opts) }))
-            .map(({ dict, findResult }) => ({
-            word,
-            found: !!findResult?.found,
-            foundWord: findResult?.found || undefined,
-            forbidden: findResult?.forbidden || false,
-            noSuggest: findResult?.noSuggest || false,
-            dictName: dict.name,
-            dictSource: dictSourceToFilename(dict.source),
-            dictActive: setOfActiveDicts.has(dict.name),
-            configSource: config.name || '',
-            errors: normalizeErrors(dict.getErrors?.()),
+        const results = traceWord(word, dicts, { ...config, ignoreCase });
+        const r = results.map((r) => ({
+            ...r,
+            dictActive: setOfActiveDicts.has(r.dictName),
+            dictSource: toFilePathOrHref(r.dictSource),
+            configSource: r.configSource || config.name || '',
+            splits: results.splits,
         }));
+        const tr = new CTraceResult(...r);
+        results.splits && tr.splits.push(...results.splits);
+        return tr;
     }
     for await (const word of words) {
         yield processWord(word);
     }
 }
-function dictSourceToFilename(source) {
-    return toFilePathOrHref(source);
+class CTraceResult extends Array {
+    splits = [];
+    constructor(...items) {
+        super(...items);
+    }
 }
 //# sourceMappingURL=trace.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cspell-lib",
-  "version": "8.3.0",
+  "version": "8.3.2",
   "description": "A library of useful functions used across various cspell tools.",
   "type": "module",
   "sideEffects": false,
@@ -57,21 +57,21 @@
   },
   "homepage": "https://github.com/streetsidesoftware/cspell#readme",
   "dependencies": {
-    "@cspell/cspell-bundled-dicts": "8.3.0",
-    "@cspell/cspell-pipe": "8.3.0",
-    "@cspell/cspell-resolver": "8.3.0",
-    "@cspell/cspell-types": "8.3.0",
-    "@cspell/dynamic-import": "8.3.0",
-    "@cspell/strong-weak-map": "8.3.0",
+    "@cspell/cspell-bundled-dicts": "8.3.2",
+    "@cspell/cspell-pipe": "8.3.2",
+    "@cspell/cspell-resolver": "8.3.2",
+    "@cspell/cspell-types": "8.3.2",
+    "@cspell/dynamic-import": "8.3.2",
+    "@cspell/strong-weak-map": "8.3.2",
     "clear-module": "^4.1.2",
     "comment-json": "^4.2.3",
     "configstore": "^6.0.0",
-    "cspell-config-lib": "8.3.0",
-    "cspell-dictionary": "8.3.0",
-    "cspell-glob": "8.3.0",
-    "cspell-grammar": "8.3.0",
-    "cspell-io": "8.3.0",
-    "cspell-trie-lib": "8.3.0",
+    "cspell-config-lib": "8.3.2",
+    "cspell-dictionary": "8.3.2",
+    "cspell-glob": "8.3.2",
+    "cspell-grammar": "8.3.2",
+    "cspell-io": "8.3.2",
+    "cspell-trie-lib": "8.3.2",
     "fast-equals": "^5.0.1",
     "gensequence": "^6.0.0",
     "import-fresh": "^3.3.0",
@@ -95,5 +95,5 @@
     "cspell-dict-nl-nl": "^1.1.2",
     "lorem-ipsum": "^2.0.8"
   },
-  "gitHead": "019c7ccd326b7fc9e106069ddf6008d5079bbd12"
+  "gitHead": "98f622b2b12529f2d1ccf0f3a57991e4c08b3e3a"
 }