cspell-dictionary 6.26.3 → 6.28.0

package/dist/SpellingDictionary/SpellingDictionary.d.ts

@@ -134,6 +134,13 @@ export interface SpellingDictionary extends DictionaryInfo {
     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[];

package/dist/SpellingDictionary/SpellingDictionaryCollection.d.ts

@@ -4,7 +4,7 @@ export interface SpellingDictionaryCollection extends SpellingDictionary {
     readonly dictionaries: SpellingDictionary[];
     getErrors(): Error[];
 }
-export declare function createCollection(dictionaries: SpellingDictionary[], name: string): SpellingDictionaryCollection;
+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;

package/dist/SpellingDictionary/SpellingDictionaryCollection.js

@@ -34,7 +34,7 @@ function identityString(w) {
     return w;
 }
 class SpellingDictionaryCollectionImpl {
-    constructor(dictionaries, name) {
+    constructor(dictionaries, name, source) {
         this.dictionaries = dictionaries;
         this.name = name;
         this.options = { weightMap: undefined };
@@ -46,7 +46,7 @@ class SpellingDictionaryCollectionImpl {
             return !!isNoSuggestWordInAnyDictionary(this.dictionaries, word, options || {});
         };
         this.dictionaries = this.dictionaries.sort((a, b) => b.size - a.size);
-        this.source = dictionaries.map((d) => d.name).join(', ');
+        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);
     }
@@ -106,8 +106,8 @@ class SpellingDictionaryCollectionImpl {
         return isWordForbiddenInAnyDictionary(this.dictionaries, word, ignoreCase);
     }
 }
-function createCollection(dictionaries, name) {
-    return new SpellingDictionaryCollectionImpl(dictionaries, name);
+function createCollection(dictionaries, name, source) {
+    return new SpellingDictionaryCollectionImpl(dictionaries, name, source);
 }
 exports.createCollection = createCollection;
 function isWordInAnyDictionary(dicts, word, options) {

package/dist/SpellingDictionary/SpellingDictionaryFromTrie.d.ts

@@ -11,6 +11,7 @@ export declare class SpellingDictionaryFromTrie implements SpellingDictionary {
     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;
@@ -41,7 +42,7 @@ export declare class SpellingDictionaryFromTrie implements SpellingDictionary {
  * @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>;
+declare function outerWordForms(word: string, mapWord: (word: string) => string[]): Set<string>;
 export declare const __testing__: {
     outerWordForms: typeof outerWordForms;
 };

package/dist/SpellingDictionary/SpellingDictionaryFromTrie.js

@@ -48,6 +48,7 @@ class SpellingDictionaryFromTrie {
             return this.trie.isForbiddenWord(word);
         });
         this.mapWord = (0, repMap_1.createMapper)(options.repMap, options.dictionaryInformation?.ignore);
+        this.remapWord = (0, repMap_1.createRepMapper)(options.repMap, options.dictionaryInformation?.ignore);
         this.isDictionaryCaseSensitive = options.caseSensitive ?? !trie.isLegacy;
         this.containsNoSuggestWords = options.noSuggest || false;
         this._size = size || 0;
@@ -89,7 +90,7 @@ class SpellingDictionaryFromTrie {
         return { useCompounds, ignoreCase };
     }
     findAnyForm(word, useCompounds, ignoreCase) {
-        const outerForms = outerWordForms(word, this.mapWord);
+        const outerForms = outerWordForms(word, this.remapWord ? this.remapWord : (word) => [this.mapWord(word)]);
         for (const form of outerForms) {
             const r = this._findAnyForm(form, useCompounds, ignoreCase);
             if (r)
@@ -193,7 +194,7 @@ function findCache(fn, size = 2000) {
     return find;
 }
 function outerWordForms(word, mapWord) {
-    const forms = (0, sync_1.pipe)([word], (0, sync_1.opConcatMap)((word) => [word, word.normalize('NFC'), word.normalize('NFD')]), (0, sync_1.opConcatMap)((word) => [word, mapWord(word)]));
+    const forms = (0, sync_1.pipe)([word], (0, sync_1.opConcatMap)((word) => [word, word.normalize('NFC'), word.normalize('NFD')]), (0, sync_1.opConcatMap)((word) => [word, ...mapWord(word)]));
     return new Set(forms);
 }
 exports.__testing__ = { outerWordForms };

package/dist/SpellingDictionary/createInlineSpellingDictionary.js

@@ -18,7 +18,7 @@ function createInlineSpellingDictionary(inlineDict, source) {
             ignoreWords && (0, IgnoreWordsDictionary_1.createIgnoreWordsDictionary)(ignoreWords, name + '-ignore-words', source),
             suggestWords && (0, SuggestDictionary_1.createSuggestDictionary)(suggestWords, name + '-suggest', source),
         ].filter(util_1.isDefined);
-        return (0, SpellingDictionaryCollection_1.createCollection)(dictSources, name);
+        return (0, SpellingDictionaryCollection_1.createCollection)(dictSources, name, source);
     });
 }
 exports.createInlineSpellingDictionary = createInlineSpellingDictionary;

package/dist/util/repMap.d.ts

@@ -1,11 +1,27 @@
 import type { CharacterSet, ReplaceMap } from '@cspell/cspell-types';
 export type ReplaceMapper = (src: string) => string;
 export declare function createMapper(repMap: ReplaceMap | undefined, ignoreCharset?: string): ReplaceMapper;
-declare function charsetToRepMap(charset: CharacterSet | undefined, replaceWith?: string): ReplaceMap | undefined;
+declare function charsetToRepMapRegEx(charset: CharacterSet | undefined, replaceWith?: string): ReplaceMap | undefined;
 declare function createMapperRegExp(repMap: ReplaceMap): RegExp;
+interface RepTrieNode {
+    rep?: string[];
+    children?: Record<string, RepTrieNode>;
+}
+interface Edit {
+    b: number;
+    e: number;
+    r: string;
+}
+export declare function createRepMapper(repMap: ReplaceMap | undefined, ignoreCharset?: string): (word: string) => string[];
+declare function applyEdits(word: string, edits: Edit[]): string[];
+declare function calcAllEdits(root: RepTrieNode, word: string): Edit[];
+declare function createTrie(repMap: ReplaceMap | undefined, ignoreCharset?: string): RepTrieNode;
 export declare const __testing__: {
-    charsetToRepMap: typeof charsetToRepMap;
+    charsetToRepMap: typeof charsetToRepMapRegEx;
     createMapperRegExp: typeof createMapperRegExp;
+    createTrie: typeof createTrie;
+    calcAllEdits: typeof calcAllEdits;
+    applyEdits: typeof applyEdits;
 };
 export {};
 //# sourceMappingURL=repMap.d.ts.map

package/dist/util/repMap.js

@@ -1,12 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.__testing__ = exports.createMapper = void 0;
+exports.__testing__ = exports.createRepMapper = exports.createMapper = void 0;
+const cspell_trie_lib_1 = require("cspell-trie-lib");
 const regexHelper_1 = require("./regexHelper");
+const util_1 = require("./util");
 function createMapper(repMap, ignoreCharset) {
     if (!repMap && !ignoreCharset)
         return (a) => a;
     repMap = repMap || [];
-    const charsetMap = charsetToRepMap(ignoreCharset);
+    const charsetMap = charsetToRepMapRegEx(ignoreCharset);
     if (charsetMap) {
         repMap = repMap.concat(charsetMap);
     }
@@ -25,7 +27,7 @@ function createMapper(repMap, ignoreCharset) {
     };
 }
 exports.createMapper = createMapper;
-function charsetToRepMap(charset, replaceWith = '') {
+function charsetToRepMapRegEx(charset, replaceWith = '') {
     if (!charset)
         return undefined;
     return charset
@@ -33,6 +35,17 @@ function charsetToRepMap(charset, replaceWith = '') {
         .map((chars) => `[${chars.replace(/[\][\\]/g, '\\$&')}]`)
         .map((map) => [map, replaceWith]);
 }
+function charsetToRepMap(charset, replaceWith = '') {
+    if (!charset)
+        return undefined;
+    return charset
+        .split('|')
+        .flatMap((chars) => [...(0, cspell_trie_lib_1.expandCharacterSet)(chars)])
+        .map((char) => [char, replaceWith]);
+}
+function expandReplaceMap(repMap) {
+    return repMap.flatMap(([from, replaceWith]) => from.split('|').map((w) => [w, replaceWith]));
+}
 function createMapperRegExp(repMap) {
     const filteredMap = repMap.filter(([match, _]) => !!match);
     if (!filteredMap.length) {
@@ -58,8 +71,88 @@ function createMapperRegExp(repMap) {
     const regEx = new RegExp(regExStr, 'g');
     return regEx;
 }
+function createRepMapper(repMap, ignoreCharset) {
+    if (!repMap && !ignoreCharset)
+        return (word) => [word];
+    const trie = createTrie(repMap, ignoreCharset);
+    // const root = createTrie(repMap, ignoreCharset);
+    return (word) => {
+        const edits = calcAllEdits(trie, word);
+        return applyEdits(word, edits);
+    };
+}
+exports.createRepMapper = createRepMapper;
+function applyEdits(word, edits) {
+    if (!edits.length)
+        return [word];
+    // Prepare
+    const letterEdits = [];
+    for (let i = 0; i < word.length; ++i) {
+        letterEdits[i] = { edits: [{ b: i, e: i + 1, r: word[i] }], suffixes: [] };
+    }
+    letterEdits[word.length] = { edits: [], suffixes: [''] };
+    // Add edits
+    for (const edit of edits) {
+        const le = letterEdits[edit.b];
+        le.edits.push(edit);
+    }
+    // Apply edits in reverse
+    for (let i = word.length - 1; i >= 0; --i) {
+        const le = letterEdits[i];
+        const sfx = le.suffixes;
+        for (const edit of le.edits) {
+            const pfx = edit.r;
+            const nSfx = letterEdits[edit.e].suffixes;
+            for (const s of nSfx) {
+                sfx.push(pfx + s);
+            }
+        }
+    }
+    const results = new Set(letterEdits[0].suffixes);
+    return [...results];
+}
+function calcAllEdits(root, word) {
+    const edits = [];
+    function walk(node, b, e) {
+        if (node.rep) {
+            node.rep.forEach((r) => edits.push({ b, e, r }));
+        }
+        if (e === word.length || !node.children)
+            return;
+        const n = node.children[word[e]];
+        if (!n)
+            return;
+        walk(n, b, e + 1);
+    }
+    for (let i = 0; i < word.length; ++i) {
+        walk(root, i, i);
+    }
+    return edits;
+}
+function createTrie(repMap, ignoreCharset) {
+    const combined = [repMap, charsetToRepMap(ignoreCharset)].filter(util_1.isDefined).flatMap((a) => a);
+    const expanded = expandReplaceMap(combined);
+    const trieRoot = Object.create(null);
+    expanded.forEach(([match, replaceWith]) => addToTrie(trieRoot, match, replaceWith));
+    return trieRoot;
+}
+function addToTrie(node, match, replaceWith) {
+    while (match) {
+        const children = node.children || (node.children = Object.create(null));
+        const k = match[0];
+        const childNode = children[k] || (children[k] = Object.create(null));
+        node = childNode;
+        match = match.slice(1);
+    }
+    const s = new Set(node.rep || []);
+    s.add(replaceWith);
+    node.rep = [...s];
+}
 exports.__testing__ = {
-    charsetToRepMap,
+    charsetToRepMap: charsetToRepMapRegEx,
     createMapperRegExp,
+    createTrie,
+    calcAllEdits,
+    applyEdits,
 };
 //# sourceMappingURL=repMap.js.map

package/package.json

@@ -1,11 +1,12 @@
 {
   "name": "cspell-dictionary",
-  "version": "6.26.3",
+  "version": "6.28.0",
   "description": "A spelling dictionary library useful for checking words and getting suggestions.",
   "main": "dist/index.js",
   "typings": "dist/index.d.ts",
   "files": [
     "dist",
+    "!**/*.tsbuildInfo",
     "!**/__mocks__",
     "!**/*.test.*",
     "!**/*.spec.*",
@@ -13,7 +14,6 @@
   ],
   "scripts": {
     "build": "tsc -p .",
-    "build-dev": "tsc -p tsconfig.dev.json",
     "watch": "tsc -p . -w",
     "clean": "shx rm -rf dist temp coverage .tsbuildinfo",
     "clean-build": "pnpm run clean && pnpm run build",
@@ -43,11 +43,11 @@
     "ts-jest": "^29.0.5"
   },
   "dependencies": {
-    "@cspell/cspell-pipe": "6.26.3",
-    "@cspell/cspell-types": "6.26.3",
-    "cspell-trie-lib": "6.26.3",
+    "@cspell/cspell-pipe": "6.28.0",
+    "@cspell/cspell-types": "6.28.0",
+    "cspell-trie-lib": "6.28.0",
     "fast-equals": "^4.0.3",
-    "gensequence": "^4.0.3"
+    "gensequence": "^5.0.2"
   },
-  "gitHead": "b8c6e0a31c58ad61b4814f92dccfe3df4999ff81"
+  "gitHead": "1c314413e76908e5fbf61fd2555726112b177c0e"
 }