cspell-trie-lib 5.16.0 → 5.17.0-alpha.0

package/dist/lib/TrieNode.d.ts

@@ -1,3 +1,4 @@
+import type { PartialWithUndefined } from './types';
 export declare const FLAG_WORD = 1;
 export declare class ChildMap extends Map<string, TrieNode> {
 }

package/dist/lib/distance/distance.d.ts

@@ -1,6 +1,6 @@
-import type { SuggestionCostMapDef } from './suggestionCostsDef';
+import type { SuggestionCostMapDef } from '../models/suggestionCostsDef';
 import type { WeightMap } from './weightedMaps';
-export type { SuggestionCostMapDef } from './suggestionCostsDef';
+export type { SuggestionCostMapDef } from '../models/suggestionCostsDef';
 export type { WeightMap } from './weightedMaps';
 /**
  * Calculate the edit distance between any two words.

package/dist/lib/distance/distanceAStarWeighted.d.ts

@@ -5,4 +5,16 @@ import { WeightMap } from './weightedMaps';
  * Using basic weights, this algorithm has the same results as the Damerau-Levenshtein algorithm.
  */
 export declare function distanceAStarWeighted(wordA: string, wordB: string, map: WeightMap, cost?: number): number;
+export interface ExResult {
+    a: string;
+    b: string;
+    cost: number;
+    segments: {
+        a: string;
+        b: string;
+        c: number;
+        p: number;
+    }[];
+}
+export declare function distanceAStarWeightedEx(wordA: string, wordB: string, map: WeightMap, cost?: number): ExResult | undefined;
 //# sourceMappingURL=distanceAStarWeighted.d.ts.map

package/dist/lib/distance/distanceAStarWeighted.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.distanceAStarWeighted = void 0;
+exports.distanceAStarWeightedEx = exports.distanceAStarWeighted = void 0;
 const PairingHeap_1 = require("../utils/PairingHeap");
 /**
  * Calculate the edit distance between two words using an A* algorithm.
@@ -8,40 +8,70 @@ const PairingHeap_1 = require("../utils/PairingHeap");
  * Using basic weights, this algorithm has the same results as the Damerau-Levenshtein algorithm.
  */
 function distanceAStarWeighted(wordA, wordB, map, cost = 100) {
+    const best = _distanceAStarWeightedEx(wordA, wordB, map, cost);
+    return best ? best.c + best.p : -1;
+}
+exports.distanceAStarWeighted = distanceAStarWeighted;
+function distanceAStarWeightedEx(wordA, wordB, map, cost = 100) {
+    const best = _distanceAStarWeightedEx(wordA, wordB, map, cost);
+    if (!best)
+        return undefined;
+    const aa = '^' + wordA + '$';
+    const bb = '^' + wordB + '$';
+    const result = {
+        a: aa,
+        b: bb,
+        cost: best.c + best.p,
+        segments: [],
+    };
+    const segments = result.segments;
+    for (let n = best; n.f; n = n.f) {
+        const f = n.f;
+        const a = aa.slice(f.ai, n.ai);
+        const b = bb.slice(f.bi, n.bi);
+        const c = n.c - f.c;
+        const p = n.p - f.p;
+        segments.push({ a, b, c, p });
+    }
+    segments.reverse();
+    return result;
+}
+exports.distanceAStarWeightedEx = distanceAStarWeightedEx;
+function _distanceAStarWeightedEx(wordA, wordB, map, cost = 100) {
     // Add ^ and $ for begin/end detection.
     const a = '^' + wordA + '$';
     const b = '^' + wordB + '$';
     const aN = a.length;
     const bN = b.length;
     const candidates = new PairingHeap_1.PairingHeap(compare);
-    candidates.add({ ai: 0, bi: 0, c: 0, p: 0 });
+    candidates.add({ ai: 0, bi: 0, c: 0, p: 0, f: undefined });
     /** Substitute / Replace */
     function opSub(n) {
         const { ai, bi, c, p } = n;
         if (ai < aN && bi < bN) {
             const cc = a[ai] === b[bi] ? c : c + cost;
-            candidates.add({ ai: ai + 1, bi: bi + 1, c: cc, p });
+            candidates.add({ ai: ai + 1, bi: bi + 1, c: cc, p, f: n });
         }
     }
     /** Insert */
     function opIns(n) {
         const { ai, bi, c, p } = n;
         if (bi < bN) {
-            candidates.add({ ai: ai, bi: bi + 1, c: c + cost, p });
+            candidates.add({ ai: ai, bi: bi + 1, c: c + cost, p, f: n });
         }
     }
     /** Delete */
     function opDel(n) {
         const { ai, bi, c, p } = n;
         if (ai < aN) {
-            candidates.add({ ai: ai + 1, bi: bi, c: c + cost, p });
+            candidates.add({ ai: ai + 1, bi: bi, c: c + cost, p, f: n });
         }
     }
     /** Swap adjacent letters */
     function opSwap(n) {
         const { ai, bi, c, p } = n;
         if (a[ai] === b[bi + 1] && a[ai + 1] === b[bi]) {
-            candidates.add({ ai: ai + 2, bi: bi + 2, c: c + cost, p });
+            candidates.add({ ai: ai + 2, bi: bi + 2, c: c + cost, p, f: n });
         }
     }
     function opMap(n) {
@@ -50,7 +80,7 @@ function distanceAStarWeighted(wordA, wordB, map, cost = 100) {
         const costCalculations = [map.calcInsDelCosts(pos), map.calcSwapCosts(pos), map.calcReplaceCosts(pos)];
         costCalculations.forEach((iter) => {
             for (const nn of iter) {
-                candidates.add(nn);
+                candidates.add({ ...nn, f: n });
             }
         });
     }
@@ -65,10 +95,8 @@ function distanceAStarWeighted(wordA, wordB, map, cost = 100) {
         opMap(best);
         opSub(best);
     }
-    // istanbul ignore else
-    return best ? best.c + best.p : -1;
+    return best;
 }
-exports.distanceAStarWeighted = distanceAStarWeighted;
 function compare(a, b) {
     // Choose lowest cost or farthest Manhattan distance.
     return a.c - b.c || b.ai + b.bi - a.ai - a.bi;

package/dist/lib/distance/index.d.ts

@@ -1,4 +1,3 @@
 export { createWeightedMap, editDistance, editDistanceWeighted } from './distance';
 export type { WeightMap } from './distance';
-export type { SuggestionCostMapDef } from './suggestionCostsDef';
 //# sourceMappingURL=index.d.ts.map

package/dist/lib/distance/weightedMaps.d.ts

@@ -1,4 +1,4 @@
-import { SuggestionCostMapDef } from './suggestionCostsDef';
+import { SuggestionCostMapDef } from '../models/suggestionCostsDef';
 export declare type WeightedRepMapTrie = Record<string, WeightedRepTrieNode>;
 interface WeightedRepTrieNode {
     /** The nested Trie nodes */
@@ -51,12 +51,13 @@ export interface WeightMap {
 }
 export declare function createWeightMap(...defs: SuggestionCostMapDef[]): WeightMap;
 export declare function addDefToWeightMap(map: WeightMap, def: SuggestionCostMapDef, ...defs: SuggestionCostMapDef[]): WeightMap;
+export declare function splitMapSubstringsIterable(map: string): Iterable<string>;
+export declare function splitMapSubstrings(map: string): string[];
 /**
  * Splits a WeightedMapDef.map
  * @param map
  */
 declare function splitMap(def: Pick<SuggestionCostMapDef, 'map'>): string[][];
-declare function splitMapSubstrings(map: string): string[];
 interface MatchTrieCost {
     i: number;
     c: number;

package/dist/lib/distance/weightedMaps.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.__testing__ = exports.lookupReplaceCost = exports.prettyPrintWeightMap = exports.prettyPrintSwap = exports.prettyPrintReplace = exports.addDefToWeightMap = exports.createWeightMap = void 0;
+exports.__testing__ = exports.lookupReplaceCost = exports.prettyPrintWeightMap = exports.prettyPrintSwap = exports.prettyPrintReplace = exports.splitMapSubstrings = exports.splitMapSubstringsIterable = exports.addDefToWeightMap = exports.createWeightMap = void 0;
 function createWeightMap(...defs) {
     const map = _createWeightMap();
     _addDefToWeightMap(map, ...defs);
@@ -40,6 +40,32 @@ function highest(a, b) {
         return a;
     return a >= b ? a : b;
 }
+function* splitMapSubstringsIterable(map) {
+    let seq = '';
+    let mode = 0;
+    for (const char of map) {
+        if (mode && char === ')') {
+            yield seq;
+            mode = 0;
+            continue;
+        }
+        if (mode) {
+            seq += char;
+            continue;
+        }
+        if (char === '(') {
+            mode = 1;
+            seq = '';
+            continue;
+        }
+        yield char;
+    }
+}
+exports.splitMapSubstringsIterable = splitMapSubstringsIterable;
+function splitMapSubstrings(map) {
+    return [...splitMapSubstringsIterable(map)];
+}
+exports.splitMapSubstrings = splitMapSubstrings;
 /**
  * Splits a WeightedMapDef.map
  * @param map
@@ -49,23 +75,6 @@ function splitMap(def) {
     const sets = map.split('|');
     return sets.map(splitMapSubstrings).filter((s) => s.length > 0);
 }
-function splitMapSubstrings(map) {
-    const values = [];
-    const len = map.length;
-    for (let i = 0; i < len; ++i) {
-        const c = map[i];
-        if (c !== '(') {
-            values.push(c);
-            continue;
-        }
-        const s = i + 1;
-        while (map[++i] !== ')' && i < len) {
-            // empty
-        }
-        values.push(map.slice(s, i));
-    }
-    return values.map((s) => s.trim()).filter((s) => !!s);
-}
 function addToTrieCost(trie, str, cost, penalties) {
     if (!str)
         return;

package/dist/lib/find.d.ts

@@ -1,4 +1,5 @@
 import { TrieNode } from './TrieNode';
+import type { PartialWithUndefined } from './types';
 /**
  * No compounding allowed.
  */

package/dist/lib/find.js

@@ -1,9 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.__testing__ = exports.createFindOptions = exports.isForbiddenWord = exports.isEndOfWordNode = exports.findWordExact = exports.findCompoundNode = exports.findLegacyCompound = exports.findWordNode = exports.findWord = void 0;
-const TrieNode_1 = require("./TrieNode");
-const trie_util_1 = require("./trie-util");
 const constants_1 = require("./constants");
+const trie_util_1 = require("./trie-util");
+const TrieNode_1 = require("./TrieNode");
 const defaultLegacyMinCompoundLength = 3;
 const _defaultFindOptions = {
     matchCase: false,

package/dist/lib/index.d.ts

@@ -1,6 +1,7 @@
 export { consolidate } from './consolidate';
 export { createWeightedMap, editDistance, editDistanceWeighted } from './distance';
-export type { SuggestionCostMapDef, WeightMap } from './distance';
+export type { WeightMap } from './distance';
+export type { SuggestionCostMapDef } from './models/suggestionCostsDef';
 export type { FindFullResult } from './find';
 export { ExportOptions, importTrie, serializeTrie } from './io/importExport';
 export { parseDictionary, parseDictionaryLines } from './SimpleDictionaryParser';

package/dist/lib/mappers/mapDictionaryInfoToWeightMap.d.ts

@@ -0,0 +1,26 @@
+import { WeightMap } from '../distance/weightedMaps';
+import type { DictionaryInformation, HunspellCosts, HunspellInformation } from '../models/DictionaryInformation';
+import type { SuggestionCostMapDef } from '../models/suggestionCostsDef';
+declare type Costs = Required<HunspellCosts>;
+export declare function dictionaryInformationToWeightMap(dictInfo: DictionaryInformation): WeightMap;
+export declare function hunspellInformationToSuggestionCostDef(hunInfo: HunspellInformation): SuggestionCostMapDef[];
+declare function calcCosts(costs?: HunspellCosts): Costs;
+declare function affMap(line: string, costs: Costs): SuggestionCostMapDef | undefined;
+declare function affTry(line: string, costs: Costs): SuggestionCostMapDef | undefined;
+declare function affTryFirstCharacterReplace(line: string, costs: Costs): SuggestionCostMapDef | undefined;
+declare function affNoTry(line: string, costs: Costs): SuggestionCostMapDef | undefined;
+declare function affRepConv(line: string, costs: Costs): SuggestionCostMapDef | undefined;
+declare function affKey(line: string, costs: Costs): SuggestionCostMapDef | undefined;
+declare function split(map: string): Iterable<string>;
+export declare const __testing__: {
+    affKey: typeof affKey;
+    affMap: typeof affMap;
+    affNoTry: typeof affNoTry;
+    affRepConv: typeof affRepConv;
+    affTry: typeof affTry;
+    affTryFirstCharacterReplace: typeof affTryFirstCharacterReplace;
+    split: typeof split;
+    calcCosts: typeof calcCosts;
+};
+export {};
+//# sourceMappingURL=mapDictionaryInfoToWeightMap.d.ts.map

package/dist/lib/mappers/mapDictionaryInfoToWeightMap.js

@@ -0,0 +1,175 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.__testing__ = exports.hunspellInformationToSuggestionCostDef = exports.dictionaryInformationToWeightMap = void 0;
+const weightedMaps_1 = require("../distance/weightedMaps");
+const util_1 = require("../utils/util");
+function dictionaryInformationToWeightMap(dictInfo) {
+    const defsEC = dictInfo.suggestionEditCosts || [];
+    const defsHI = dictInfo.hunspellInformation
+        ? hunspellInformationToSuggestionCostDef(dictInfo.hunspellInformation)
+        : [];
+    return (0, weightedMaps_1.createWeightMap)(...defsEC, ...defsHI);
+}
+exports.dictionaryInformationToWeightMap = dictionaryInformationToWeightMap;
+function hunspellInformationToSuggestionCostDef(hunInfo) {
+    const defs = [];
+    const costs = calcCosts(hunInfo.costs);
+    function parseAff(aff, costs) {
+        // cspell:ignore OCONV
+        const regSupportedAff = /^(?:MAP|KEY|TRY|NO-TRY|ICONV|OCONV|REP)\s/;
+        const rejectAff = /^(?:MAP|KEY|TRY|ICONV|OCONV|REP)\s+\d+$/;
+        const lines = aff
+            .split('\n')
+            .map((a) => a.replace(/#.*/, ''))
+            .map((a) => a.trim())
+            .filter((a) => regSupportedAff.test(a))
+            .filter((a) => !rejectAff.test(a));
+        lines.forEach((line) => {
+            [affMap, affNoTry, affRepConv, affTry, affTryFirstCharacterReplace, affKey]
+                .map((fn) => fn(line, costs))
+                .filter(util_1.isDefined)
+                .forEach((def) => defs.push(def));
+        });
+    }
+    parseAff(hunInfo.aff, costs);
+    return defs;
+}
+exports.hunspellInformationToSuggestionCostDef = hunspellInformationToSuggestionCostDef;
+function calcCosts(costs = {}) {
+    const { firstLetterPenalty = 4, ioConvertCost = 30, keyboardCost = 94, mapCost = 25, replaceCosts = 75, tryCharCost = 95, } = costs;
+    const c = { tryCharCost, keyboardCost, mapCost, ioConvertCost, replaceCosts, firstLetterPenalty };
+    return c;
+}
+const regExpMap = /^(?:MAP)\s+(\S+)$/;
+function affMap(line, costs) {
+    const m = line.match(regExpMap);
+    if (!m)
+        return undefined;
+    const map = m[1];
+    const cost = costs.mapCost;
+    return {
+        map,
+        replace: cost,
+        swap: cost,
+    };
+}
+const regExpTry = /^(?:TRY)\s+(\S+)$/;
+function affTry(line, costs) {
+    const m = line.match(regExpTry);
+    if (!m)
+        return undefined;
+    const map = m[1];
+    const cost = costs.tryCharCost;
+    return {
+        map,
+        insDel: cost,
+        replace: cost,
+        swap: cost,
+    };
+}
+function affTryFirstCharacterReplace(line, costs) {
+    const m = line.match(regExpTry);
+    if (!m)
+        return undefined;
+    const map = [...split(m[1])].map((char) => `(^${char})`).join('');
+    const cost = costs.tryCharCost;
+    const penalty = costs.firstLetterPenalty;
+    return {
+        map,
+        replace: cost - penalty,
+        penalty,
+    };
+}
+const regExpNoTry = /^NO-TRY\s+(\S+)$/;
+function affNoTry(line, costs) {
+    const m = line.match(regExpNoTry);
+    if (!m)
+        return undefined;
+    const map = m[1];
+    return {
+        map,
+        insDel: Math.max(100 - costs.tryCharCost, 0),
+        penalty: 100 + costs.tryCharCost,
+    };
+}
+// cspell:ignore conv
+const regExpRepConv = /^(?:REP|(?:I|O)CONV)\s+(\S+)\s+(\S+)$/;
+function affRepConv(line, costs) {
+    const m = line.match(regExpRepConv);
+    if (!m)
+        return undefined;
+    const cost = line.startsWith('REP') ? costs.replaceCosts : costs.ioConvertCost;
+    const from = m[1];
+    let into = m[2];
+    into = into.replace(/^0$/, '');
+    if (from.startsWith('^') && !into.startsWith('^')) {
+        into = '^' + into;
+    }
+    if (from.endsWith('$') && !into.endsWith('$')) {
+        into = into + '$';
+    }
+    return {
+        map: `(${from})(${into})`,
+        replace: cost,
+    };
+}
+const regExpKey = /^(?:KEY)\s+(\S+)$/;
+function affKey(line, costs) {
+    const m = line.match(regExpKey);
+    if (!m)
+        return undefined;
+    const kbd = m[1];
+    const pairs = [...split(kbd)]
+        .map(reducer((p, v) => ({ a: p.b, b: v }), { a: '|', b: '|' }))
+        .filter((ab) => ab.a !== '|' && ab.b !== '|')
+        .map((ab) => ab.a + ab.b);
+    const map = pairs.join('|');
+    const cost = costs.keyboardCost;
+    return {
+        map,
+        replace: cost,
+        swap: cost,
+    };
+}
+function* split(map) {
+    let seq = '';
+    let mode = 0;
+    for (const char of map) {
+        if (mode && char === ')') {
+            yield seq;
+            mode = 0;
+            continue;
+        }
+        if (mode) {
+            seq += char;
+            continue;
+        }
+        if (char === '(') {
+            mode = 1;
+            seq = '';
+            continue;
+        }
+        yield char;
+    }
+}
+function reducer(fn, initialVal) {
+    let acc = initialVal;
+    return (val, i) => (acc = fn(acc, val, i));
+}
+// function pipe<T>(v: T, ...fns: ((v: T) => T)[]): T {
+//     for (const fn of fns) {
+//         v = fn(v);
+//     }
+//     return v;
+// }
+exports.__testing__ = {
+    affKey,
+    affMap,
+    affNoTry,
+    affRepConv,
+    affTry,
+    affTryFirstCharacterReplace,
+    split,
+    calcCosts,
+};
+//# sourceMappingURL=mapDictionaryInfoToWeightMap.js.map

package/dist/lib/models/DictionaryInformation.d.ts

@@ -0,0 +1,7 @@
+import type { DictionaryDefinitionAugmented } from '@cspell/cspell-types';
+export declare type DictionaryInformation = Exclude<DictionaryDefinitionAugmented['dictionaryInformation'], undefined>;
+export declare type SuggestionEditCosts = Exclude<DictionaryInformation['suggestionEditCosts'], undefined>;
+export declare type HunspellInformation = Exclude<DictionaryInformation['hunspellInformation'], undefined>;
+export declare type HunspellCosts = Exclude<HunspellInformation['costs'], undefined>;
+export declare type HunspellAff = HunspellInformation['aff'];
+//# sourceMappingURL=DictionaryInformation.d.ts.map

package/dist/lib/models/DictionaryInformation.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=DictionaryInformation.js.map

package/dist/lib/suggestions/suggestCollector.js

@@ -37,7 +37,7 @@ function suggestionCollector(wordToMatch, options) {
     let maxCost = BASE_COST * Math.min(wordToMatch.length * MAX_ALLOWED_COST_SCALE, changeLimit);
     let timeRemaining = timeout;
     function dropMax() {
-        if (sugs.size < 2) {
+        if (sugs.size < 2 || !numSuggestions) {
             sugs.clear();
             return;
         }

package/dist/lib/trie-util.d.ts

@@ -1,5 +1,6 @@
 import { Sequence } from 'gensequence';
-import { TrieNode, TrieRoot, PartialTrieOptions, TrieOptions } from './TrieNode';
+import { PartialTrieOptions, TrieNode, TrieOptions, TrieRoot } from './TrieNode';
+import type { Mandatory, PartialWithUndefined } from './types';
 import { YieldResult } from './walker';
 export declare function insert(text: string, node?: TrieNode): TrieNode;
 export declare function isWordTerminationNode(node: TrieNode): boolean;

package/dist/lib/trie-util.js

@@ -2,9 +2,9 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.clean = exports.isDefined = exports.normalizeWordForCaseInsensitive = exports.normalizeWordToLowercase = exports.normalizeWord = exports.trieNodeToRoot = exports.mergeDefaults = exports.isCircular = exports.countWords = exports.countNodes = exports.findNode = exports.has = exports.createTriFromList = exports.createTrieRoot = exports.mergeOptionalWithDefaults = exports.iteratorTrieWords = exports.iterateTrie = exports.walk = exports.orderTrie = exports.isWordTerminationNode = exports.insert = void 0;
 const gensequence_1 = require("gensequence");
+const constants_1 = require("./constants");
 const TrieNode_1 = require("./TrieNode");
 const walker_1 = require("./walker");
-const constants_1 = require("./constants");
 function insert(text, node = {}) {
     if (text.length) {
         const head = text[0];

package/dist/lib/types.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Make all properties in T optional and Possibly undefined
+ */
+export declare type PartialWithUndefined<T> = {
+    [P in keyof T]?: T[P] | undefined;
+};
+export declare type Mandatory<T> = {
+    [P in keyof T]-?: Exclude<T[P], undefined>;
+};
+//# sourceMappingURL=types.d.ts.map

package/dist/lib/types.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=types.js.map

package/dist/lib/utils/util.d.ts

@@ -0,0 +1,2 @@
+export declare function isDefined<T>(a: T | undefined): a is T;
+//# sourceMappingURL=util.d.ts.map

package/dist/lib/utils/util.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isDefined = void 0;
+function isDefined(a) {
+    return a !== undefined;
+}
+exports.isDefined = isDefined;
+//# sourceMappingURL=util.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cspell-trie-lib",
-  "version": "5.16.0",
+  "version": "5.17.0-alpha.0",
   "description": "Trie Data Structure to support cspell.",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -44,14 +44,14 @@
     "node": ">=12.13.0"
   },
   "devDependencies": {
-    "@cspell/cspell-types": "^5.16.0",
+    "@cspell/cspell-types": "^5.17.0-alpha.0",
     "@cspell/dict-en_us": "^2.1.4",
     "@cspell/dict-es-es": "^2.1.0",
     "@types/fs-extra": "^9.0.13",
-    "@types/node": "^17.0.10",
-    "hunspell-reader": "^5.16.0",
+    "@types/node": "^17.0.12",
+    "hunspell-reader": "^5.17.0-alpha.0",
     "jest": "^27.4.7",
     "rimraf": "^3.0.2"
   },
-  "gitHead": "c5d994f58bdb48c4d16f1708607b28c8a7b52a65"
+  "gitHead": "d884218703cac72186fd69e8ba1e9eb78558c7ca"
 }