cspell-dictionary 6.28.0 → 6.29.1

package/dist/esm/util/simpleCache.mjs

@@ -0,0 +1,135 @@
+export class SimpleWeakCache {
+    constructor(size) {
+        this.size = size;
+        this.L0 = new WeakMap();
+        this.L1 = new WeakMap();
+        this.L2 = new WeakMap();
+        this.sizeL0 = 0;
+    }
+    has(key) {
+        for (const c of this.caches()) {
+            if (c.has(key))
+                return true;
+        }
+        return false;
+    }
+    get(key) {
+        for (const c of this.caches()) {
+            const entry = c.get(key);
+            if (entry) {
+                if (c !== this.L0) {
+                    this._set(key, entry);
+                }
+                return entry.v;
+            }
+        }
+        return undefined;
+    }
+    set(key, value) {
+        this._set(key, { v: value });
+    }
+    _set(key, entry) {
+        if (this.L0.has(key)) {
+            this.L0.set(key, entry);
+            return this;
+        }
+        if (this.sizeL0 >= this.size) {
+            this.rotate();
+        }
+        this.sizeL0 += 1;
+        this.L0.set(key, entry);
+    }
+    caches() {
+        return [this.L0, this.L1, this.L2];
+    }
+    rotate() {
+        this.L2 = this.L1;
+        this.L1 = this.L0;
+        this.L0 = new WeakMap();
+        this.sizeL0 = 0;
+    }
+}
+export class AutoWeakCache extends SimpleWeakCache {
+    constructor(factory, size) {
+        super(size);
+        this.factory = factory;
+    }
+    get(key) {
+        const v = super.get(key);
+        if (v !== undefined)
+            return v;
+        const val = this.factory(key);
+        this.set(key, val);
+        return val;
+    }
+}
+/**
+ * This will cache between `size` and 3 x `size` items.
+ * It has three stashes, L0, L1, and L2. Each can contain `size` items.
+ * When L0 is full, its items are given to L1 and L1's are given to L2, and L2 is empties.
+ *
+ * The stashes are searched in order, L0...L2. If an item is found in L1, or L2, it is
+ * promoted to L0.
+ */
+export class SimpleCache {
+    constructor(size) {
+        this.size = size;
+        this.L0 = new Map();
+        this.L1 = new Map();
+        this.L2 = new Map();
+    }
+    has(key) {
+        for (const c of this.caches()) {
+            if (c.has(key))
+                return true;
+        }
+        return false;
+    }
+    get(key) {
+        for (const c of this.caches()) {
+            const entry = c.get(key);
+            if (entry) {
+                if (c !== this.L0) {
+                    this._set(key, entry);
+                }
+                return entry.v;
+            }
+        }
+        return undefined;
+    }
+    set(key, value) {
+        this._set(key, { v: value });
+    }
+    _set(key, entry) {
+        if (this.L0.has(key)) {
+            this.L0.set(key, entry);
+            return this;
+        }
+        if (this.L0.size >= this.size) {
+            this.rotate();
+        }
+        this.L0.set(key, entry);
+    }
+    caches() {
+        return [this.L0, this.L1, this.L2];
+    }
+    rotate() {
+        this.L2 = this.L1;
+        this.L1 = this.L0;
+        this.L0 = new Map();
+    }
+}
+export class AutoCache extends SimpleCache {
+    constructor(factory, size) {
+        super(size);
+        this.factory = factory;
+    }
+    get(key) {
+        const v = super.get(key);
+        if (v !== undefined)
+            return v;
+        const val = this.factory(key);
+        this.set(key, val);
+        return val;
+    }
+}

package/dist/esm/util/text.d.mts

@@ -0,0 +1,10 @@
+export declare function isUpperCase(word: string): boolean;
+export declare function isLowerCase(word: string): boolean;
+export declare function isFirstCharacterUpper(word: string): boolean;
+export declare function isFirstCharacterLower(word: string): boolean;
+export declare function ucFirst(word: string): string;
+export declare function lcFirst(word: string): string;
+export declare function matchCase(example: string, word: string): string;
+export declare function removeAccents(text: string): string;
+export declare function removeUnboundAccents(text: string): string;
+//# sourceMappingURL=text.d.mts.map

package/dist/esm/util/text.mjs

@@ -0,0 +1,46 @@
+const regExFirstUpper = /^\p{Lu}\p{M}?\p{Ll}+$/u;
+const regExAllUpper = /^(?:\p{Lu}\p{M}?)+$/u;
+const regExAllLower = /^(?:\p{Ll}\p{M}?)+$/u;
+const regExAccents = /\p{M}/gu;
+export function isUpperCase(word) {
+    return !!word.match(regExAllUpper);
+}
+export function isLowerCase(word) {
+    return !!word.match(regExAllLower);
+}
+export function isFirstCharacterUpper(word) {
+    return isUpperCase(word.slice(0, 1));
+}
+export function isFirstCharacterLower(word) {
+    return isLowerCase(word.slice(0, 1));
+}
+export function ucFirst(word) {
+    return word.slice(0, 1).toUpperCase() + word.slice(1);
+}
+export function lcFirst(word) {
+    return word.slice(0, 1).toLowerCase() + word.slice(1);
+}
+export function matchCase(example, word) {
+    if (example.match(regExFirstUpper)) {
+        return word.slice(0, 1).toUpperCase() + word.slice(1).toLowerCase();
+    }
+    if (example.match(regExAllLower)) {
+        return word.toLowerCase();
+    }
+    if (example.match(regExAllUpper)) {
+        return word.toUpperCase();
+    }
+    if (isFirstCharacterUpper(example)) {
+        return ucFirst(word);
+    }
+    if (isFirstCharacterLower(example)) {
+        return lcFirst(word);
+    }
+    return word;
+}
+export function removeAccents(text) {
+    return text.normalize('NFD').replace(regExAccents, '');
+}
+export function removeUnboundAccents(text) {
+    return text.replace(regExAccents, '');
+}

package/dist/esm/util/textMappers.d.mts

@@ -0,0 +1,3 @@
+export declare function mapperNormalizeNFC(words: Iterable<string>): Iterable<string>;
+export declare function mapperRemoveCaseAndAccents(words: Iterable<string>): Iterable<string>;
+//# sourceMappingURL=textMappers.d.mts.map

package/dist/esm/util/textMappers.mjs

@@ -0,0 +1,15 @@
+import { removeAccents } from './text.mjs';
+export function* mapperNormalizeNFC(words) {
+    for (const word of words) {
+        yield word.normalize('NFC');
+    }
+}
+export function* mapperRemoveCaseAndAccents(words) {
+    for (const word of words) {
+        const lc = word.toLowerCase();
+        yield lc;
+        const woAccents = removeAccents(lc);
+        if (lc !== woAccents)
+            yield woAccents;
+    }
+}

package/dist/esm/util/types.d.mts

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

package/dist/esm/util/types.mjs

@@ -0,0 +1 @@
+export {};

package/dist/esm/util/util.d.mts

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

package/dist/esm/util/util.mjs

@@ -0,0 +1,3 @@
+export function isDefined(v) {
+    return v !== undefined;
+}

package/package.json

@@ -1,25 +1,39 @@
 {
   "name": "cspell-dictionary",
-  "version": "6.28.0",
+  "version": "6.29.1",
   "description": "A spelling dictionary library useful for checking words and getting suggestions.",
-  "main": "dist/index.js",
-  "typings": "dist/index.d.ts",
+  "type": "commonjs",
+  "main": "dist/cjs/index.js",
+  "types": "dist/cjs/index.d.ts",
+  "module": "dist/esm/index.mjs",
+  "exports": {
+    ".": {
+      "import": "./dist/esm/index.mjs",
+      "require": "./dist/cjs/index.js"
+    }
+  },
   "files": [
     "dist",
+    "!dist/esm/**/*.js",
+    "!dist/esm/**/*.ts",
     "!**/*.tsbuildInfo",
     "!**/__mocks__",
+    "!**/test/**",
     "!**/*.test.*",
     "!**/*.spec.*",
     "!**/*.map"
   ],
   "scripts": {
-    "build": "tsc -p .",
-    "watch": "tsc -p . -w",
-    "clean": "shx rm -rf dist temp coverage .tsbuildinfo",
+    "clean": "shx rm -rf dist coverage .tsbuildinfo",
+    "build": "tsc -b . && ts2mjs dist/esm",
+    "build:esm": "tsc -p tsconfig.esm.json",
     "clean-build": "pnpm run clean && pnpm run build",
-    "coverage": "jest --coverage",
-    "test-watch": "jest --watch",
-    "test": "jest"
+    "coverage": "pnpm coverage:vitest && pnpm coverage:fix",
+    "coverage:vitest": "vitest run --coverage",
+    "coverage:fix": "nyc report --temp-dir \"$(pwd)/coverage\" --reporter lcov --report-dir \"$(pwd)/coverage\" --cwd ../..",
+    "test:watch": "vitest",
+    "test": "vitest run",
+    "watch": "tsc -b . -w"
   },
   "repository": {
     "type": "git",
@@ -37,17 +51,12 @@
   "engines": {
     "node": ">=14"
   },
-  "devDependencies": {
-    "@types/jest": "^29.4.0",
-    "jest": "^29.4.3",
-    "ts-jest": "^29.0.5"
-  },
   "dependencies": {
-    "@cspell/cspell-pipe": "6.28.0",
-    "@cspell/cspell-types": "6.28.0",
-    "cspell-trie-lib": "6.28.0",
+    "@cspell/cspell-pipe": "6.29.1",
+    "@cspell/cspell-types": "6.29.1",
+    "cspell-trie-lib": "6.29.1",
     "fast-equals": "^4.0.3",
     "gensequence": "^5.0.2"
   },
-  "gitHead": "1c314413e76908e5fbf61fd2555726112b177c0e"
+  "gitHead": "e524c611f3529b22a7e8ae3449a5c9a01332d44f"
 }

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

@@ -1,4 +0,0 @@
-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/createInlineSpellingDictionary.js

@@ -1,25 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createInlineSpellingDictionary = void 0;
-const AutoResolve_1 = require("../util/AutoResolve");
-const util_1 = require("../util/util");
-const createSpellingDictionary_1 = require("./createSpellingDictionary");
-const FlagWordsDictionary_1 = require("./FlagWordsDictionary");
-const IgnoreWordsDictionary_1 = require("./IgnoreWordsDictionary");
-const SpellingDictionaryCollection_1 = require("./SpellingDictionaryCollection");
-const SuggestDictionary_1 = require("./SuggestDictionary");
-const cache = (0, AutoResolve_1.createAutoResolveWeakCache)();
-function createInlineSpellingDictionary(inlineDict, source) {
-    return cache.get(inlineDict, () => {
-        const { words, flagWords, ignoreWords, suggestWords, name } = inlineDict;
-        const dictSources = [
-            words && (0, createSpellingDictionary_1.createSpellingDictionary)(words, name + '-words', source, inlineDict),
-            flagWords && (0, FlagWordsDictionary_1.createFlagWordsDictionary)(flagWords, name + '-flag-words', 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, source);
-    });
-}
-exports.createInlineSpellingDictionary = createInlineSpellingDictionary;
-//# sourceMappingURL=createInlineSpellingDictionary.js.map