cspell-dictionary 6.14.2 → 6.14.3

package/dist/SpellingDictionary/IgnoreWordsDictionary.js

@@ -35,7 +35,7 @@ class IgnoreWordsDictionary {
         this.source = source;
         this.containsNoSuggestWords = true;
         this.options = {};
-        this.type = 'forbidden';
+        this.type = 'ignore';
         this.isDictionaryCaseSensitive = true;
         this.dict = new Set(words);
         this.dictNonStrict = new Set((0, sync_1.pipe)(this.dict, (0, sync_1.opFilter)((w) => w.startsWith('~')), (0, sync_1.opMap)((w) => w.slice(1))));

package/dist/SpellingDictionary/SpellingDictionary.d.ts

@@ -35,7 +35,7 @@ export interface SuggestOptions {
      */
     timeout?: number;
 }
-export declare type FindOptions = SearchOptions;
+export type FindOptions = SearchOptions;
 export interface FindResult {
     /** the text found, otherwise `false` */
     found: string | false;
@@ -44,7 +44,7 @@ export interface FindResult {
     /** `true` if it is a no-suggest word. */
     noSuggest: boolean;
 }
-export declare type HasOptions = SearchOptions;
+export type HasOptions = SearchOptions;
 export interface SpellingDictionaryOptions {
     repMap?: ReplaceMap;
     /**

package/dist/SpellingDictionary/SpellingDictionaryMethods.d.ts

@@ -2,8 +2,8 @@ import { DictionaryInformation } from '@cspell/cspell-types';
 import { CompoundWordsMethod, SuggestionResult, WeightMap } from 'cspell-trie-lib';
 import { HasOptions, SearchOptions, SpellingDictionary, SuggestOptions } from './SpellingDictionary';
 export { impersonateCollector, suggestionCollector } from 'cspell-trie-lib';
-export declare type FilterSuggestionsPredicate = (word: SuggestionResult) => boolean;
-export declare type SuggestArgs = Parameters<SpellingDictionary['suggest']> | Parameters<(word: string, numSuggestions?: number, compoundMethod?: CompoundWordsMethod, numChanges?: number, ignoreCase?: boolean) => SuggestionResult[]>;
+export type FilterSuggestionsPredicate = (word: SuggestionResult) => boolean;
+export type SuggestArgs = Parameters<SpellingDictionary['suggest']> | Parameters<(word: string, numSuggestions?: number, compoundMethod?: CompoundWordsMethod, numChanges?: number, ignoreCase?: boolean) => SuggestionResult[]>;
 export declare const defaultNumSuggestions = 10;
 declare function wordSearchFormsArray(word: string, isDictionaryCaseSensitive: boolean, ignoreCase: boolean): string[];
 export declare function wordSearchForms(word: string, isDictionaryCaseSensitive: boolean, ignoreCase: boolean): Set<string>;

package/dist/SpellingDictionary/Typos/index.d.ts

@@ -0,0 +1,4 @@
+export type { TypoEntry, TyposDef } from './typos';
+export { parseTyposFile, parseTyposLine, processEntriesToTyposDef } from './typosParser';
+export { createTyposDef, extractAllSuggestions } from './util';
+//# sourceMappingURL=index.d.ts.map

package/dist/SpellingDictionary/Typos/index.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractAllSuggestions = exports.createTyposDef = exports.processEntriesToTyposDef = exports.parseTyposLine = exports.parseTyposFile = void 0;
+var typosParser_1 = require("./typosParser");
+Object.defineProperty(exports, "parseTyposFile", { enumerable: true, get: function () { return typosParser_1.parseTyposFile; } });
+Object.defineProperty(exports, "parseTyposLine", { enumerable: true, get: function () { return typosParser_1.parseTyposLine; } });
+Object.defineProperty(exports, "processEntriesToTyposDef", { enumerable: true, get: function () { return typosParser_1.processEntriesToTyposDef; } });
+var util_1 = require("./util");
+Object.defineProperty(exports, "createTyposDef", { enumerable: true, get: function () { return util_1.createTyposDef; } });
+Object.defineProperty(exports, "extractAllSuggestions", { enumerable: true, get: function () { return util_1.extractAllSuggestions; } });
+//# sourceMappingURL=index.js.map

package/dist/SpellingDictionary/Typos/typos.d.ts

@@ -0,0 +1,18 @@
+type NoSuggestion = null | undefined;
+type SingleSuggestion = string;
+type MultipleSuggestions = string[];
+export type TyposDefValue = MultipleSuggestions | SingleSuggestion | NoSuggestion;
+export type TyposDefKey = string;
+/**
+ * Typos Definition
+ *   key - the incorrect word
+ *   value - the suggestions.
+ */
+export type TyposDef = Record<TyposDefKey, TyposDefValue>;
+type TypoNoSuggestions = string;
+type TypoWithSuggestionsArray = [forbidWord: string, ...suggestions: string[]];
+type TypoWithSuggestionsObj = TyposDef;
+type TypoWithSuggestions = TypoWithSuggestionsArray | TypoWithSuggestionsObj;
+export type TypoEntry = TypoNoSuggestions | TypoWithSuggestions;
+export {};
+//# sourceMappingURL=typos.d.ts.map

package/dist/SpellingDictionary/Typos/typos.js

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

package/dist/SpellingDictionary/Typos/typosParser.d.ts

@@ -0,0 +1,17 @@
+import { TypoEntry, TyposDef } from './typos';
+export declare function createTyposDefFromEntries(entries: Iterable<TypoEntry>): TyposDef;
+export declare function sanitizeIntoTypoDef(dirtyDef: TyposDef | Record<string, unknown> | unknown): TyposDef | undefined;
+/**
+ * Used to process entries found in a `cspell.json` file.
+ * @param entries - entries to process
+ * @returns a TyposDef
+ */
+export declare function processEntriesToTyposDef(entries: TyposDef | readonly TypoEntry[] | Record<string, unknown>): TyposDef;
+/**
+ * Tries to parse an entry.
+ * @param line - any valid TypoEntry.
+ * @returns a valid TypoEntry
+ */
+export declare function parseTyposLine(line: TypoEntry): TypoEntry | undefined;
+export declare function parseTyposFile(content: string): TyposDef;
+//# sourceMappingURL=typosParser.d.ts.map

package/dist/SpellingDictionary/Typos/typosParser.js

@@ -0,0 +1,123 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseTyposFile = exports.parseTyposLine = exports.processEntriesToTyposDef = exports.sanitizeIntoTypoDef = exports.createTyposDefFromEntries = void 0;
+const assert_1 = __importDefault(require("assert"));
+const util_1 = require("./util");
+function assertString(v) {
+    (0, assert_1.default)(typeof v === 'string', 'A string was expected.');
+    return true;
+}
+const suggestionsSeparator = /[,]/;
+const typoSuggestionsSeparator = /:|->/;
+const typoEntrySeparator = /[\n;]/;
+const inlineComment = /#.*/gm;
+function createTyposDefFromEntries(entries) {
+    const def = Object.create(null);
+    for (const entry of entries) {
+        (0, util_1.appendToDef)(def, entry);
+    }
+    return def;
+}
+exports.createTyposDefFromEntries = createTyposDefFromEntries;
+function normalize(s) {
+    return s.normalize();
+}
+function trimAndFilter(lines) {
+    return lines
+        .map((s) => s.trim())
+        .filter((s) => !!s)
+        .map(normalize);
+}
+function cleanSugs(rawSugs) {
+    const sugs = trimAndFilter(rawSugs);
+    return sugs.length === 1 ? sugs[0] : sugs.length ? sugs : null;
+}
+function splitSuggestionsValue(value) {
+    return cleanSugs(value.split(suggestionsSeparator));
+}
+function sanitizeIntoTypoDef(dirtyDef) {
+    if (!dirtyDef || typeof dirtyDef !== 'object')
+        return undefined;
+    const def = (0, util_1.createTyposDef)();
+    for (const [rawKey, value] of Object.entries(dirtyDef)) {
+        const key = normalize(rawKey.trim());
+        if (!key)
+            continue;
+        if (typeof value === 'string') {
+            def[key] = splitSuggestionsValue(value);
+            continue;
+        }
+        if (Array.isArray(value)) {
+            const sugs = cleanSugs(value.filter(assertString));
+            def[key] = sugs;
+            continue;
+        }
+        (0, assert_1.default)(value === null || value === undefined, 'Unexpected suggestion type.');
+        def[key] = null;
+    }
+    return def;
+}
+exports.sanitizeIntoTypoDef = sanitizeIntoTypoDef;
+/**
+ * Used to process entries found in a `cspell.json` file.
+ * @param entries - entries to process
+ * @returns a TyposDef
+ */
+function processEntriesToTyposDef(entries) {
+    const def = Array.isArray(entries) ? reduceToTyposDef(entries) : entries;
+    const result = sanitizeIntoTypoDef(def);
+    (0, assert_1.default)(result);
+    return result;
+}
+exports.processEntriesToTyposDef = processEntriesToTyposDef;
+function reduceToTyposDef(entries) {
+    const def = (0, util_1.createTyposDef)();
+    for (const entry of entries) {
+        (0, util_1.appendToDef)(def, parseTyposLine(entry));
+    }
+    return def;
+}
+/**
+ * Tries to parse an entry.
+ * @param line - any valid TypoEntry.
+ * @returns a valid TypoEntry
+ */
+function parseTyposLine(line) {
+    if (!line)
+        return undefined;
+    if (typeof line === 'string') {
+        const def = (0, util_1.createTyposDef)();
+        for (const subEntry of splitIntoLines(line)) {
+            const [left, right] = splitEntry(subEntry);
+            const typo = left.trim();
+            if (!right)
+                return typo;
+            const sugs = splitSuggestionsValue(right);
+            def[typo] = sugs;
+        }
+        return def;
+    }
+    if (Array.isArray(line)) {
+        const [key, ...sugs] = line.filter(assertString).map((s) => s.trim());
+        if (!key)
+            return undefined;
+        return [key, ...sugs];
+    }
+    return sanitizeIntoTypoDef(line);
+}
+exports.parseTyposLine = parseTyposLine;
+function splitIntoLines(content) {
+    return trimAndFilter(normalize(content).split(typoEntrySeparator));
+}
+function splitEntry(line) {
+    return line.split(typoSuggestionsSeparator, 2);
+}
+function parseTyposFile(content) {
+    const lines = splitIntoLines(content.replace(inlineComment, ''));
+    return reduceToTyposDef(lines);
+}
+exports.parseTyposFile = parseTyposFile;
+//# sourceMappingURL=typosParser.js.map

package/dist/SpellingDictionary/Typos/util.d.ts

@@ -0,0 +1,12 @@
+import { TypoEntry, TyposDef, TyposDefKey, TyposDefValue } from './typos';
+/**
+ * Append an entry to a TyposDef.
+ * @param def - modified in place
+ * @param entry- entry to add.
+ * @returns def
+ */
+export declare function appendToDef(def: TyposDef, entry: TypoEntry | undefined): TyposDef;
+export declare function createTyposDef(entries?: Iterable<[TyposDefKey, TyposDefValue]>): TyposDef;
+export declare function extractAllSuggestions(typosDef: TyposDef): Set<string>;
+export declare function extractIgnoreValues(typosDef: TyposDef, ignorePrefix: string): Set<string>;
+//# sourceMappingURL=util.d.ts.map

package/dist/SpellingDictionary/Typos/util.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractIgnoreValues = exports.extractAllSuggestions = exports.createTyposDef = exports.appendToDef = void 0;
+const sync_1 = require("@cspell/cspell-pipe/sync");
+/**
+ * Append an entry to a TyposDef.
+ * @param def - modified in place
+ * @param entry- entry to add.
+ * @returns def
+ */
+function appendToDef(def, entry) {
+    if (!entry)
+        return def;
+    if (typeof entry === 'string') {
+        def[entry] = null;
+        return def;
+    }
+    if (Array.isArray(entry)) {
+        const [key, ...sugs] = entry.map((s) => s.trim());
+        if (!key)
+            return def;
+        const s = sugs.map((s) => s.trim()).filter((s) => !!s);
+        def[key] = !s.length ? null : s.length === 1 ? s[0] : s;
+        return def;
+    }
+    Object.assign(def, entry);
+    return def;
+}
+exports.appendToDef = appendToDef;
+function createTyposDef(entries) {
+    const def = Object.create(null);
+    if (!entries)
+        return def;
+    for (const [key, value] of entries) {
+        def[key] = value;
+    }
+    return def;
+}
+exports.createTyposDef = createTyposDef;
+function extractAllSuggestions(typosDef) {
+    const allSugs = (0, sync_1.pipe)(Object.values(typosDef), (0, sync_1.opFilter)(isDefined), (0, sync_1.opConcatMap)((v) => (Array.isArray(v) ? v : [v])));
+    return new Set(allSugs);
+}
+exports.extractAllSuggestions = extractAllSuggestions;
+function extractIgnoreValues(typosDef, ignorePrefix) {
+    const sugs = extractAllSuggestions(typosDef);
+    const pfxLen = ignorePrefix.length;
+    const ignoreKeys = Object.keys(typosDef)
+        .filter((k) => k.startsWith(ignorePrefix))
+        .map((k) => k.slice(pfxLen));
+    return (0, sync_1.reduce)(ignoreKeys, (sugs, word) => sugs.add(word), sugs);
+}
+exports.extractIgnoreValues = extractIgnoreValues;
+function isDefined(v) {
+    return v !== undefined && v !== null;
+}
+//# sourceMappingURL=util.js.map

package/dist/SpellingDictionary/TyposDictionary.d.ts

@@ -0,0 +1,12 @@
+import { SpellingDictionary } from './SpellingDictionary';
+import { type TypoEntry, type TyposDef } from './Typos';
+/**
+ * Create a dictionary where all words are to be forbidden.
+ * @param entries - list of Typos Entries
+ * @param name
+ * @param source
+ * @param options
+ * @returns
+ */
+export declare function createTyposDictionary(entries: string[] | TyposDef | readonly TypoEntry[], name: string, source: string): SpellingDictionary;
+//# sourceMappingURL=TyposDictionary.d.ts.map

package/dist/SpellingDictionary/TyposDictionary.js

@@ -0,0 +1,104 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createTyposDictionary = void 0;
+const sync_1 = require("@cspell/cspell-pipe/sync");
+const Typos_1 = require("./Typos");
+const util_1 = require("./Typos/util");
+const symIgnore = Symbol('ignored');
+class TyposDictionary {
+    constructor(name, source, typosDef, ignoreList) {
+        this.name = name;
+        this.source = source;
+        this.typosDef = typosDef;
+        this.containsNoSuggestWords = false;
+        this.options = {};
+        this.type = 'typos';
+        this.isDictionaryCaseSensitive = true;
+        this.size = Object.keys(typosDef).length;
+        this.ignoreWords = new Set((0, sync_1.pipe)((0, util_1.extractIgnoreValues)(typosDef, '!'), (0, sync_1.opAppend)(ignoreList || [])));
+    }
+    /**
+     * A Forbidden word list does not "have" valid words.
+     * Therefore it always returns false.
+     * @param _word - the word
+     * @param _options - options
+     * @returns always false
+     */
+    has(_word, _options) {
+        return false;
+    }
+    /** A more detailed search for a word, might take longer than `has` */
+    find(word, _options) {
+        const found = this._findForms(word);
+        return typeof found === 'string' ? { found, forbidden: true, noSuggest: false } : undefined;
+    }
+    _findForms(word) {
+        const f = this._find(word);
+        if (f !== false)
+            return f;
+        const lcWord = word.toLowerCase();
+        if (lcWord === word)
+            return false;
+        return this._find(lcWord);
+    }
+    _find(word) {
+        if (this.ignoreWords.has(word))
+            return symIgnore;
+        if (word in this.typosDef)
+            return word;
+        return false;
+    }
+    isForbidden(word) {
+        const found = this._findForms(word);
+        return typeof found === 'string';
+    }
+    isNoSuggestWord(_word, _options) {
+        return false;
+    }
+    suggest(word) {
+        return this._suggest(word) || this._suggest(word.toLowerCase()) || [];
+    }
+    _suggest(word) {
+        if (this.ignoreWords.has(word))
+            return [];
+        if (!(word in this.typosDef))
+            return undefined;
+        const sug = this.typosDef[word];
+        if (!sug)
+            return [];
+        if (typeof sug === 'string') {
+            return [
+                {
+                    word: sug,
+                    cost: 1,
+                    isPreferred: true,
+                },
+            ];
+        }
+        return sug.map((word, index) => ({ word, cost: index + 1 }));
+    }
+    genSuggestions(collector) {
+        const sugs = this.suggest(collector.word);
+        sugs.forEach((result) => collector.add(result));
+    }
+    mapWord(word) {
+        return word;
+    }
+    getErrors() {
+        return [];
+    }
+}
+/**
+ * Create a dictionary where all words are to be forbidden.
+ * @param entries - list of Typos Entries
+ * @param name
+ * @param source
+ * @param options
+ * @returns
+ */
+function createTyposDictionary(entries, name, source) {
+    const def = (0, Typos_1.processEntriesToTyposDef)(entries);
+    return new TyposDictionary(name, source, def);
+}
+exports.createTyposDictionary = createTyposDictionary;
+//# sourceMappingURL=TyposDictionary.js.map

package/dist/util/repMap.d.ts

@@ -1,5 +1,5 @@
 import type { CharacterSet, ReplaceMap } from '@cspell/cspell-types';
-export declare type ReplaceMapper = (src: string) => string;
+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 createMapperRegExp(repMap: ReplaceMap): RegExp;

package/dist/util/types.d.ts

@@ -1,7 +1,7 @@
 /**
  * Like Required, but keeps the Optional.
  */
-export declare type RemoveUndefined<T> = {
+export type RemoveUndefined<T> = {
     [P in keyof T]: Exclude<T[P], undefined>;
 };
 //# sourceMappingURL=types.d.ts.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cspell-dictionary",
-  "version": "6.14.2",
+  "version": "6.14.3",
   "description": "A spelling dictionary library useful for checking words and getting suggestions.",
   "main": "dist/index.js",
   "typings": "dist/index.d.ts",
@@ -38,16 +38,16 @@
     "node": ">=14"
   },
   "devDependencies": {
-    "@types/jest": "^29.2.2",
+    "@types/jest": "^29.2.3",
     "jest": "^29.3.1",
     "ts-jest": "^29.0.3"
   },
   "dependencies": {
-    "@cspell/cspell-pipe": "6.14.2",
-    "@cspell/cspell-types": "6.14.2",
-    "cspell-trie-lib": "6.14.2",
+    "@cspell/cspell-pipe": "6.14.3",
+    "@cspell/cspell-types": "6.14.3",
+    "cspell-trie-lib": "6.14.3",
     "fast-equals": "^4.0.3",
     "gensequence": "^4.0.2"
   },
-  "gitHead": "ea9692380357e9e890c20f15b1200cc1c6c3a2df"
+  "gitHead": "df0efdbb0dc7b084579130ba5fe97441c0ab67ca"
 }