cspell-trie-lib 5.18.1 → 5.18.5

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

@@ -9,6 +9,7 @@ export interface ExResult {
     a: string;
     b: string;
     cost: number;
+    penalty: number;
     segments: {
         a: string;
         b: string;
@@ -16,5 +17,5 @@ export interface ExResult {
         p: number;
     }[];
 }
-export declare function distanceAStarWeightedEx(wordA: string, wordB: string, map: WeightMap, cost?: number): ExResult | undefined;
+export declare function distanceAStarWeightedEx(wordA: string, wordB: string, map: WeightMap, cost?: number): ExResult;
 //# sourceMappingURL=distanceAStarWeighted.d.ts.map

package/dist/lib/distance/distanceAStarWeighted.js

@@ -1,6 +1,10 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.distanceAStarWeightedEx = exports.distanceAStarWeighted = void 0;
+const assert_1 = __importDefault(require("assert"));
 const PairingHeap_1 = require("../utils/PairingHeap");
 /**
  * Calculate the edit distance between two words using an A* algorithm.
@@ -9,19 +13,20 @@ const PairingHeap_1 = require("../utils/PairingHeap");
  */
 function distanceAStarWeighted(wordA, wordB, map, cost = 100) {
     const best = _distanceAStarWeightedEx(wordA, wordB, map, cost);
-    return best ? best.c + best.p : -1;
+    const penalty = map.calcAdjustment(wordB);
+    return best.c + best.p + penalty;
 }
 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 penalty = map.calcAdjustment(wordB);
     const result = {
         a: aa,
         b: bb,
-        cost: best.c + best.p,
+        cost: best.c + best.p + penalty,
+        penalty,
         segments: [],
     };
     const segments = result.segments;
@@ -43,7 +48,7 @@ function _distanceAStarWeightedEx(wordA, wordB, map, cost = 100) {
     const b = '^' + wordB + '$';
     const aN = a.length;
     const bN = b.length;
-    const candidates = new PairingHeap_1.PairingHeap(compare);
+    const candidates = new CandidatePool(aN, bN);
     candidates.add({ ai: 0, bi: 0, c: 0, p: 0, f: undefined });
     /** Substitute / Replace */
     function opSub(n) {
@@ -86,7 +91,7 @@ function _distanceAStarWeightedEx(wordA, wordB, map, cost = 100) {
     }
     let best;
     // const bc2 = 2 * bc;
-    while ((best = candidates.dequeue())) {
+    while ((best = candidates.next())) {
         if (best.ai === aN && best.bi === bN)
             break;
         opSwap(best);
@@ -95,10 +100,46 @@ function _distanceAStarWeightedEx(wordA, wordB, map, cost = 100) {
         opMap(best);
         opSub(best);
     }
+    (0, assert_1.default)(best);
     return best;
 }
+class CandidatePool {
+    constructor(aN, bN) {
+        this.aN = aN;
+        this.bN = bN;
+        this.pool = new PairingHeap_1.PairingHeap(compare);
+        this.grid = [];
+    }
+    next() {
+        let n;
+        while ((n = this.pool.dequeue())) {
+            if (!n.d)
+                return n;
+        }
+        return undefined;
+    }
+    add(n) {
+        const i = idx(n.ai, n.bi, this.bN);
+        const g = this.grid[i];
+        if (!g) {
+            this.grid[i] = n;
+            this.pool.add(n);
+            return;
+        }
+        // Do not add if the existing node is better.
+        if (g.c <= n.c)
+            return;
+        // New node is better.
+        g.d = true;
+        this.grid[i] = n;
+        this.pool.add(n);
+    }
+}
+function idx(r, c, cols) {
+    return r * cols + c;
+}
 function compare(a, b) {
-    // Choose lowest cost or farthest Manhattan distance.
+    // lowest cost then progress
     return a.c - b.c || b.ai + b.bi - a.ai - a.bi;
 }
 //# sourceMappingURL=distanceAStarWeighted.js.map

package/dist/lib/distance/formatResultEx.js

@@ -23,7 +23,7 @@ function vizWidth(s) {
 function formatExResult(ex) {
     if (!ex)
         return '<undefined>';
-    const { cost, segments } = ex;
+    const { cost, segments, penalty } = ex;
     const asString = segments.map(({ a, b, c, p }) => ({
         a: `<${a}>`,
         b: `<${b}>`,
@@ -47,7 +47,8 @@ function formatExResult(ex) {
     const b = 'b: |' + parts.map(({ b, w }) => pR(b, w)).join('|') + '|';
     const c = 'c: |' + parts.map(({ c, w }) => pL(c, w)).join('|') + '|';
     const p = 'p: |' + parts.map(({ p, w }) => pL(p, w)).join('|') + '|';
-    return `<${ex.a.slice(1, -1)}> -> <${ex.b.slice(1, -1)}> (${cost})\n${[a, b, c, p].join('\n')}\n`;
+    const penaltyMsg = penalty ? `[+${penalty}]` : '';
+    return `<${ex.a.slice(1, -1)}> -> <${ex.b.slice(1, -1)}> (${cost - penalty}${penaltyMsg})\n${[a, b, c, p].join('\n')}\n`;
 }
 exports.formatExResult = formatExResult;
 function formattedDistance(wordA, wordB, weightMap, cost) {

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

@@ -45,12 +45,24 @@ export interface WeightMap {
     readonly insDel: TrieCost;
     readonly replace: TrieTrieCost;
     readonly swap: TrieTrieCost;
+    readonly adjustments: Map<string, PenaltyAdjustment>;
     calcInsDelCosts(pos: CostPosition): Iterable<CostPosition>;
     calcSwapCosts(pos: CostPosition): Iterable<CostPosition>;
     calcReplaceCosts(pos: CostPosition): Iterable<CostPosition>;
+    calcAdjustment(word: string): number;
+}
+export interface PenaltyAdjustment {
+    /** Penalty Identifier */
+    id: string;
+    /** RegExp Pattern to match */
+    regexp: RegExp;
+    /** Penalty to apply */
+    penalty: number;
 }
 export declare function createWeightMap(...defs: SuggestionCostMapDef[]): WeightMap;
 export declare function addDefToWeightMap(map: WeightMap, def: SuggestionCostMapDef, ...defs: SuggestionCostMapDef[]): WeightMap;
+export declare function addAdjustment(map: WeightMap, ...adjustments: PenaltyAdjustment[]): WeightMap;
+export declare function addAdjustment(map: WeightMap, adjustment: PenaltyAdjustment): WeightMap;
 export declare function addDefsToWeightMap(map: WeightMap, defs: SuggestionCostMapDef[]): WeightMap;
 export declare function splitMapSubstringsIterable(map: string): Iterable<string>;
 export declare function splitMapSubstrings(map: string): string[];
@@ -74,11 +86,13 @@ export declare function prettyPrintReplace(trie: TrieTrieCost, pfx?: string, ind
 export declare function prettyPrintSwap(trie: TrieTrieCost, pfx?: string, indent?: string): string;
 export declare function prettyPrintWeightMap(map: WeightMap): string;
 export declare function lookupReplaceCost(map: WeightMap, a: string, b: string): undefined | number;
+declare function normalizeDef(def: SuggestionCostMapDef): SuggestionCostMapDef;
 export declare const __testing__: {
-    splitMap: typeof splitMap;
-    splitMapSubstrings: typeof splitMapSubstrings;
     findTrieCostPrefixes: typeof findTrieCostPrefixes;
     findTrieTrieCostPrefixes: typeof findTrieTrieCostPrefixes;
+    normalizeDef: typeof normalizeDef;
+    splitMap: typeof splitMap;
+    splitMapSubstrings: typeof splitMapSubstrings;
 };
 export {};
 //# sourceMappingURL=weightedMaps.d.ts.map

package/dist/lib/distance/weightedMaps.js

@@ -1,6 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.__testing__ = exports.lookupReplaceCost = exports.prettyPrintWeightMap = exports.prettyPrintSwap = exports.prettyPrintReplace = exports.splitMapSubstrings = exports.splitMapSubstringsIterable = exports.addDefsToWeightMap = exports.addDefToWeightMap = exports.createWeightMap = void 0;
+exports.__testing__ = exports.lookupReplaceCost = exports.prettyPrintWeightMap = exports.prettyPrintSwap = exports.prettyPrintReplace = exports.splitMapSubstrings = exports.splitMapSubstringsIterable = exports.addDefsToWeightMap = exports.addAdjustment = exports.addDefToWeightMap = exports.createWeightMap = void 0;
+const suggestCollector_1 = require("../suggestions/suggestCollector");
+const matchPossibleWordSeparators = /[+∙•・●]/g;
 function createWeightMap(...defs) {
     const map = _createWeightMap();
     addDefsToWeightMap(map, defs);
@@ -11,13 +13,21 @@ function addDefToWeightMap(map, ...defs) {
     return addDefsToWeightMap(map, defs);
 }
 exports.addDefToWeightMap = addDefToWeightMap;
+function addAdjustment(map, ...adjustments) {
+    for (const adj of adjustments) {
+        map.adjustments.set(adj.id, adj);
+    }
+    return map;
+}
+exports.addAdjustment = addAdjustment;
 function addDefsToWeightMap(map, defs) {
     function addSet(set, def) {
         addSetToTrieCost(map.insDel, set, def.insDel, def.penalty);
         addSetToTrieTrieCost(map.replace, set, def.replace, def.penalty);
         addSetToTrieTrieCost(map.swap, set, def.swap, def.penalty);
     }
-    for (const def of defs) {
+    for (const _def of defs) {
+        const def = normalizeDef(_def);
         const mapSets = splitMap(def);
         mapSets.forEach((s) => addSet(s, def));
     }
@@ -178,6 +188,7 @@ class _WeightedMap {
         this.insDel = {};
         this.replace = {};
         this.swap = {};
+        this.adjustments = new Map();
     }
     *calcInsDelCosts(pos) {
         const { a, ai, b, bi, c, p } = pos;
@@ -212,6 +223,20 @@ class _WeightedMap {
             }
         }
     }
+    calcAdjustment(word) {
+        let penalty = 0;
+        for (const adj of this.adjustments.values()) {
+            if (adj.regexp.global) {
+                for (const _m of word.matchAll(adj.regexp)) {
+                    penalty += adj.penalty;
+                }
+            }
+            else if (adj.regexp.test(word)) {
+                penalty += adj.penalty;
+            }
+        }
+        return penalty;
+    }
 }
 function prettyPrintInsDel(trie, pfx = '', indent = '  ') {
     function* walk() {
@@ -262,10 +287,18 @@ function lookupReplaceCost(map, a, b) {
     return t === null || t === void 0 ? void 0 : t.c;
 }
 exports.lookupReplaceCost = lookupReplaceCost;
+function normalizeDef(def) {
+    const { map, ...rest } = def;
+    return { ...rest, map: normalizeMap(map) };
+}
+function normalizeMap(map) {
+    return map.replace(matchPossibleWordSeparators, suggestCollector_1.DEFAULT_COMPOUNDED_WORD_SEPARATOR);
+}
 exports.__testing__ = {
-    splitMap,
-    splitMapSubstrings,
     findTrieCostPrefixes,
     findTrieTrieCostPrefixes,
+    normalizeDef,
+    splitMap,
+    splitMapSubstrings,
 };
 //# sourceMappingURL=weightedMaps.js.map

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

@@ -1,4 +1,6 @@
 import type { DictionaryInformation } from '../models/DictionaryInformation';
 import type { SuggestionCostMapDef } from '../models/suggestionCostsDef';
+import { PenaltyAdjustment } from '../distance/weightedMaps';
 export declare function mapDictionaryInformation(dictInfo: DictionaryInformation): SuggestionCostMapDef[];
+export declare function mapDictionaryInformationToAdjustment(dictInfo: DictionaryInformation): PenaltyAdjustment[];
 //# sourceMappingURL=mapDictionaryInfo.d.ts.map

package/dist/lib/mappers/mapDictionaryInfo.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.mapDictionaryInformation = void 0;
+exports.mapDictionaryInformationToAdjustment = exports.mapDictionaryInformation = void 0;
 const cspell_pipe_1 = require("@cspell/cspell-pipe");
 const locale_1 = require("../models/locale");
 const util_1 = require("../utils/util");
@@ -52,4 +52,18 @@ function processAccents(accents, editCost) {
     const cs = toCharSets(accents, '\u0300-\u0341', editCost.accentCosts);
     return cs.map((cs) => (0, mapToSuggestionCostDef_1.parseAccents)(cs, editCost)).filter(util_1.isDefined);
 }
+function mapDictionaryInformationToAdjustment(dictInfo) {
+    if (!dictInfo.adjustments)
+        return [];
+    return dictInfo.adjustments.map(mapAdjustment);
+}
+exports.mapDictionaryInformationToAdjustment = mapDictionaryInformationToAdjustment;
+function mapAdjustment(adj) {
+    const { id, regexp, penalty } = adj;
+    return {
+        id: id,
+        regexp: new RegExp(regexp),
+        penalty,
+    };
+}
 //# sourceMappingURL=mapDictionaryInfo.js.map

package/dist/lib/mappers/mapDictionaryInfoToWeightMap.js

@@ -10,9 +10,29 @@ const defaultDefs = [
         penalty: 200,
     },
 ];
+const defaultAdjustments = [
+    {
+        id: 'compound-case-change',
+        regexp: /\p{Ll}∙\p{Lu}/gu,
+        penalty: 1000,
+    },
+    {
+        id: 'short-compounds-1',
+        regexp: /^[^∙]{0,2}(?=∙)|∙[^∙]{0,2}(?=∙|$)/gm,
+        penalty: 100,
+    },
+    {
+        id: 'short-compounds-3',
+        regexp: /^[^∙]{3}(?=∙)|∙[^∙]{3}(?=∙|$)/gm,
+        penalty: 50,
+    },
+];
 function mapDictionaryInformationToWeightMap(dictInfo) {
     const defs = (0, mapDictionaryInfo_1.mapDictionaryInformation)(dictInfo).concat(defaultDefs);
-    return (0, weightedMaps_1.createWeightMap)(...defs);
+    const adjustments = (0, mapDictionaryInfo_1.mapDictionaryInformationToAdjustment)(dictInfo);
+    const map = (0, weightedMaps_1.createWeightMap)(...defs);
+    (0, weightedMaps_1.addAdjustment)(map, ...defaultAdjustments, ...adjustments);
+    return map;
 }
 exports.mapDictionaryInformationToWeightMap = mapDictionaryInformationToWeightMap;
 exports.__testing__ = {};

package/dist/lib/suggestions/suggestCollector.js

@@ -13,7 +13,9 @@ const MAX_COST_SCALE = 0.5;
 // max allowed cost scale should be a bit over 50% to allow for suggestions to short words, but not too high to have too many suggestions.
 const MAX_ALLOWED_COST_SCALE = 1.03 * MAX_COST_SCALE;
 const collator = new Intl.Collator();
-const regexSeparator = new RegExp(`[${(0, util_1.regexQuote)(walker_1.JOIN_SEPARATOR + walker_1.WORD_SEPARATOR)}]`, 'g');
+// This is a bit broken, it was supposed to also include JOIN_SEPARATOR (`+`)
+// Add it back later.
+const regexSeparator = new RegExp(`[${(0, util_1.regexQuote)(walker_1.WORD_SEPARATOR)}]`, 'g');
 const wordLengthCost = [0, 50, 25, 5, 0];
 const EXTRA_WORD_COST = 5;
 exports.DEFAULT_COMPOUNDED_WORD_SEPARATOR = '∙';
@@ -66,9 +68,7 @@ function suggestionCollector(wordToMatch, options) {
         for (; i < sorted.length && sorted[i].cost <= maxCost; ++i) {
             /* empty */
         }
-        const deleted = [];
         for (; i < sorted.length; ++i) {
-            deleted.push(sorted[i]);
             sugs.delete(sorted[i].word);
         }
     }
@@ -150,8 +150,9 @@ function suggestionCollector(wordToMatch, options) {
         const sorted = values.sort(compSuggestionResults).map(cleanCompoundResult);
         let i = Math.min(sorted.length, numSuggestions) - 1;
         const limit = includeTies ? sorted.length : Math.min(sorted.length, numSuggestions);
-        const maxCost = sorted[i].cost;
-        for (++i; i < limit && sorted[i].cost === maxCost; ++i) {
+        const iCost = sorted[i].cost;
+        const maxCost = Math.min(iCost, weightMap ? changeLimit * BASE_COST - 1 : iCost);
+        for (i = 1; i < limit && sorted[i].cost <= maxCost; ++i) {
             // loop
         }
         sorted.length = i;

package/dist/lib/types.d.ts

@@ -66,4 +66,5 @@ export declare type RemoveUndefined<T> = {
  * Make all `undefined` optional and removes the `undefined`
  */
 export declare type UndefinedToOptional<T> = RemoveUndefined<MakeOptional<T>>;
+export declare type ArrayItem<T extends Array<unknown>> = T extends Array<infer R> ? R : never;
 //# sourceMappingURL=types.d.ts.map

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

@@ -0,0 +1,11 @@
+export declare class AutoCacheMap<T, U> extends Map<T, U> {
+    readonly autoFn: (v: T) => U;
+    constructor(autoFn: (v: T) => U);
+    get(v: T): U;
+}
+export declare class AutoCacheWeakMap<T extends object, U> extends WeakMap<T, U> {
+    readonly autoFn: (v: T) => U;
+    constructor(autoFn: (v: T) => U);
+    get(v: T): U;
+}
+//# sourceMappingURL=autoCacheMap.d.ts.map

package/dist/lib/utils/autoCacheMap.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AutoCacheWeakMap = exports.AutoCacheMap = void 0;
+class AutoCacheMap extends Map {
+    constructor(autoFn) {
+        super();
+        this.autoFn = autoFn;
+    }
+    get(v) {
+        const r = super.get(v);
+        if (r !== undefined)
+            return r;
+        const u = this.autoFn(v);
+        super.set(v, u);
+        return u;
+    }
+}
+exports.AutoCacheMap = AutoCacheMap;
+class AutoCacheWeakMap extends WeakMap {
+    constructor(autoFn) {
+        super();
+        this.autoFn = autoFn;
+    }
+    get(v) {
+        const r = super.get(v);
+        if (r !== undefined)
+            return r;
+        const u = this.autoFn(v);
+        super.set(v, u);
+        return u;
+    }
+}
+exports.AutoCacheWeakMap = AutoCacheWeakMap;
+//# sourceMappingURL=autoCacheMap.js.map

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

@@ -0,0 +1,6 @@
+export declare function memorizer<T, K>(fn: (...p: [...K[]]) => T): (...p: [...K[]]) => T;
+export declare function memorizer<T, K0, K1, K2, K3>(fn: (...p: [K0, K1, K2, K3]) => T): (...p: [K0, K1, K2, K3]) => T;
+export declare function memorizer<T, K0, K1, K2>(fn: (...p: [K0, K1, K2]) => T): (...p: [K0, K1, K2]) => T;
+export declare function memorizer<T, K0, K1>(fn: (...p: [K0, K1]) => T): (...p: [K0, K1]) => T;
+export declare function memorizer<T, K0>(fn: (...p: [K0]) => T): (...p: [K0]) => T;
+//# sourceMappingURL=memorizer.d.ts.map

package/dist/lib/utils/memorizer.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.memorizer = void 0;
+function memorizer(fn) {
+    const r = {};
+    function find(p) {
+        var _a;
+        let n = r;
+        for (const k of p) {
+            if (!n)
+                break;
+            n = (_a = n.c) === null || _a === void 0 ? void 0 : _a.get(k);
+        }
+        return n;
+    }
+    function set(p, v) {
+        var _a;
+        let n = r;
+        for (const k of p) {
+            const c = (_a = n.c) === null || _a === void 0 ? void 0 : _a.get(k);
+            if (c) {
+                n = c;
+                continue;
+            }
+            const r = {};
+            n.c = n.c || new Map();
+            n.c.set(k, r);
+            n = r;
+        }
+        n.v = v;
+    }
+    return (...p) => {
+        const f = find(p);
+        if (f && 'v' in f) {
+            return f.v;
+        }
+        const v = fn(...p);
+        set(p, v);
+        return v;
+    };
+}
+exports.memorizer = memorizer;
+//# sourceMappingURL=memorizer.js.map

package/dist/lib/utils/util.js

@@ -51,7 +51,7 @@ exports.replaceAll = replaceAll;
  * @returns text that can be used in a regexp.
  */
 function regexQuote(text) {
-    return text.replace(/[[\]\-+(){},|*.\\]/g, '\\$1');
+    return text.replace(/([[\]\-+(){},|*.\\])/g, '\\$1');
 }
 exports.regexQuote = regexQuote;
 /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cspell-trie-lib",
-  "version": "5.18.1",
+  "version": "5.18.5",
   "description": "Trie Data Structure to support cspell.",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -37,7 +37,7 @@
   },
   "homepage": "https://github.com/streetsidesoftware/cspell#readme",
   "dependencies": {
-    "@cspell/cspell-pipe": "^5.18.1",
+    "@cspell/cspell-pipe": "^5.18.5",
     "fs-extra": "^10.0.0",
     "gensequence": "^3.1.1"
   },
@@ -45,13 +45,13 @@
     "node": ">=12.13.0"
   },
   "devDependencies": {
-    "@cspell/cspell-types": "^5.18.1",
-    "@cspell/dict-en_us": "^2.1.4",
+    "@cspell/cspell-types": "^5.18.5",
+    "@cspell/dict-en_us": "^2.1.7",
     "@cspell/dict-es-es": "^2.1.0",
     "@types/fs-extra": "^9.0.13",
-    "@types/node": "^17.0.14",
-    "jest": "^27.4.7",
+    "@types/node": "^17.0.18",
+    "jest": "^27.5.1",
     "rimraf": "^3.0.2"
   },
-  "gitHead": "8b94979b57a7b1a11f8efbd5bc086d29d496f7be"
+  "gitHead": "bff6b01340bde5ca7a89860868e179592eaa7520"
 }