cspell-lib 5.16.0 → 5.18.0

package/dist/util/simpleCache.d.ts

@@ -0,0 +1,44 @@
+export declare class SimpleWeakCache<K extends object, T> {
+    readonly size: number;
+    private L0;
+    private L1;
+    private L2;
+    private sizeL0;
+    constructor(size: number);
+    has(key: K): boolean;
+    get(key: K): T | undefined;
+    set(key: K, value: T): this | undefined;
+    private caches;
+    private rotate;
+}
+export declare class AutoWeakCache<K extends object, T> extends SimpleWeakCache<K, T> {
+    readonly factory: (key: K) => T;
+    constructor(factory: (key: K) => T, size: number);
+    get(key: K): T;
+}
+/**
+ * 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 declare class SimpleCache<K, T> {
+    readonly size: number;
+    private L0;
+    private L1;
+    private L2;
+    constructor(size: number);
+    has(key: K): boolean;
+    get(key: K): T | undefined;
+    set(key: K, value: T): this | undefined;
+    private caches;
+    private rotate;
+}
+export declare class AutoCache<K, T> extends SimpleCache<K, T> {
+    readonly factory: (key: K) => T;
+    constructor(factory: (key: K) => T, size: number);
+    get(key: K): T;
+}
+//# sourceMappingURL=simpleCache.d.ts.map

package/dist/util/simpleCache.js

@@ -0,0 +1,140 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AutoCache = exports.SimpleCache = exports.AutoWeakCache = exports.SimpleWeakCache = void 0;
+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()) {
+            if (c.has(key)) {
+                // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+                const v = c.get(key);
+                if (c !== this.L0) {
+                    this.set(key, v);
+                }
+                return v;
+            }
+        }
+        return undefined;
+    }
+    set(key, value) {
+        if (this.L0.has(key)) {
+            this.L0.set(key, value);
+            return this;
+        }
+        if (this.sizeL0 >= this.size) {
+            this.rotate();
+        }
+        this.sizeL0 += 1;
+        this.L0.set(key, value);
+    }
+    caches() {
+        return [this.L0, this.L1, this.L2];
+    }
+    rotate() {
+        this.L2 = this.L1;
+        this.L1 = this.L0;
+        this.L0 = new WeakMap();
+        this.sizeL0 = 0;
+    }
+}
+exports.SimpleWeakCache = SimpleWeakCache;
+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;
+    }
+}
+exports.AutoWeakCache = AutoWeakCache;
+/**
+ * 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.
+ */
+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()) {
+            if (c.has(key)) {
+                // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+                const v = c.get(key);
+                if (c !== this.L0) {
+                    this.set(key, v);
+                }
+                return v;
+            }
+        }
+        return undefined;
+    }
+    set(key, value) {
+        if (this.L0.has(key)) {
+            this.L0.set(key, value);
+            return this;
+        }
+        if (this.L0.size >= this.size) {
+            this.rotate();
+        }
+        this.L0.set(key, value);
+    }
+    caches() {
+        return [this.L0, this.L1, this.L2];
+    }
+    rotate() {
+        this.L2.clear();
+        this.L2 = this.L1;
+        this.L1 = this.L0;
+        this.L0 = new Map();
+    }
+}
+exports.SimpleCache = SimpleCache;
+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;
+    }
+}
+exports.AutoCache = AutoCache;
+//# sourceMappingURL=simpleCache.js.map

package/dist/util/types.d.ts

@@ -1,2 +1,50 @@
-export declare type FunctionArgs<T> = T extends (...args: infer U) => any ? U : any;
+/**
+ * Make all optional fields required.
+ */
+export declare type RequireOptional<T> = {
+    [K in keyof Required<T>]: T[K];
+};
+/**
+ * Make all properties in T optional and Possibly undefined
+ */
+export declare type PartialWithUndefined<T> = {
+    [P in keyof T]?: T[P] | undefined;
+};
+/**
+ * Make all fields mandatory
+ */
+export declare type Mandatory<T> = {
+    [P in keyof T]-?: Exclude<T[P], undefined>;
+};
+/**
+ * Union the fields
+ */
+export declare type UnionFields<T, U> = {
+    [K in keyof T | keyof U]: (K extends keyof T ? T[K] : undefined) | (K extends keyof U ? U[K] : undefined);
+};
+/**
+ * The keys of an object where the values cannot be undefined.
+ */
+export declare type RequiredKeys<T> = Exclude<{
+    [P in keyof T]: T[P] extends Exclude<T[P], undefined> ? P : never;
+}[keyof T], undefined>;
+/**
+ * The keys of an object where the values cannot be undefined.
+ */
+export declare type OptionalKeys<T> = Exclude<{
+    [P in keyof T]: T[P] extends Exclude<T[P], undefined> ? never : P;
+}[keyof T], undefined>;
+/**
+ * Extract the fields that cannot be `undefined`
+ */
+export declare type OnlyRequired<T> = {
+    [P in RequiredKeys<T>]: T[P];
+};
+/**
+ * Extract the fields that can be `undefined`
+ */
+export declare type OnlyOptional<T> = {
+    [P in keyof T as P extends OptionalKeys<T> ? P : never]: T[P];
+};
+export declare type MakeOptional<T> = OnlyRequired<T> & Partial<OnlyOptional<T>>;
 //# sourceMappingURL=types.d.ts.map

package/dist/util/types.js

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

package/dist/util/util.d.ts

@@ -13,4 +13,7 @@ export declare function clean<T>(src: T): T;
 export declare function scanMap<T>(accFn: (acc: T, value: T) => T, init?: T): (value: T) => T;
 export declare function scanMap<T, U>(accFn: (acc: U, value: T) => U, init: U): (value: T) => U;
 export declare function isDefined<T>(v: T | undefined): v is T;
+export declare function flattenIterable<T>(values: Iterable<Iterable<T>> | T[][]): Iterable<T>;
+export declare function flatten<T>(values: Iterable<Iterable<T>> | T[][]): T[];
+export declare function asyncIterableToArray<T>(iter: Iterable<T> | AsyncIterable<T>): Promise<Awaited<T>[]>;
 //# sourceMappingURL=util.d.ts.map

package/dist/util/util.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isDefined = exports.scanMap = exports.clean = exports.unique = exports.uniqueFilterFnGenerator = exports.uniqueFn = void 0;
+exports.asyncIterableToArray = exports.flatten = exports.flattenIterable = exports.isDefined = exports.scanMap = exports.clean = exports.unique = exports.uniqueFilterFnGenerator = exports.uniqueFn = void 0;
 // alias for uniqueFilterFnGenerator
 exports.uniqueFn = uniqueFilterFnGenerator;
 function uniqueFilterFnGenerator(extractFn) {
@@ -50,4 +50,22 @@ function isDefined(v) {
     return v !== undefined;
 }
 exports.isDefined = isDefined;
+function* flattenIterable(values) {
+    for (const v of values) {
+        yield* v;
+    }
+}
+exports.flattenIterable = flattenIterable;
+function flatten(values) {
+    return [...flattenIterable(values)];
+}
+exports.flatten = flatten;
+async function asyncIterableToArray(iter) {
+    const acc = [];
+    for await (const t of iter) {
+        acc.push(t);
+    }
+    return acc;
+}
+exports.asyncIterableToArray = asyncIterableToArray;
 //# sourceMappingURL=util.js.map

package/dist/validator.js

@@ -21,13 +21,12 @@ var __importStar = (this && this.__importStar) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.checkText = exports.IncludeExcludeFlag = exports.settingsToValidateOptions = exports.validateText = exports.diagSource = void 0;
 const Settings = __importStar(require("./Settings"));
-const Dictionary = __importStar(require("./SpellingDictionary"));
 const SpellingDictionary_1 = require("./SpellingDictionary");
 const TV = __importStar(require("./textValidator"));
 exports.diagSource = 'cSpell Checker';
 async function validateText(text, settings, options = {}) {
     const finalSettings = Settings.finalizeSettings(settings);
-    const dict = await Dictionary.getDictionary(finalSettings);
+    const dict = await (0, SpellingDictionary_1.getDictionaryInternal)(finalSettings);
     const issues = [...TV.validateText(text, dict, settingsToValidateOptions(finalSettings))];
     if (!options.generateSuggestions) {
         return issues;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cspell-lib",
-  "version": "5.16.0",
+  "version": "5.18.0",
   "description": "A library of useful functions used across various cspell tools.",
   "main": "dist/index.js",
   "typings": "dist/index.d.ts",
@@ -14,8 +14,9 @@
   ],
   "scripts": {
     "clean": "rimraf dist temp coverage .tsbuildinfo",
-    "build": "npm run compile",
+    "build": "npm run compile && npm run build-api",
     "build-dev": "tsc -p tsconfig.dev.json",
+    "build-api": "rollup -c api/rollup.config.mjs",
     "clean-build": "npm run clean && npm run build",
     "compile": "tsc -p .",
     "watch": "tsc --watch -p .",
@@ -47,15 +48,16 @@
   },
   "homepage": "https://github.com/streetsidesoftware/cspell#readme",
   "dependencies": {
-    "@cspell/cspell-bundled-dicts": "^5.16.0",
-    "@cspell/cspell-types": "^5.16.0",
+    "@cspell/cspell-bundled-dicts": "^5.18.0",
+    "@cspell/cspell-types": "^5.18.0",
     "clear-module": "^4.1.2",
     "comment-json": "^4.1.1",
     "configstore": "^5.0.1",
     "cosmiconfig": "^7.0.1",
-    "cspell-glob": "^5.16.0",
-    "cspell-io": "^5.16.0",
-    "cspell-trie-lib": "^5.16.0",
+    "cspell-glob": "^5.18.0",
+    "cspell-io": "^5.18.0",
+    "cspell-trie-lib": "^5.18.0",
+    "fast-equals": "^2.0.4",
     "find-up": "^5.0.0",
     "fs-extra": "^10.0.0",
     "gensequence": "^3.1.1",
@@ -70,7 +72,7 @@
   "devDependencies": {
     "@cspell/dict-cpp": "^1.1.40",
     "@cspell/dict-csharp": "^1.0.11",
-    "@cspell/dict-css": "^1.0.12",
+    "@cspell/dict-css": "^1.0.13",
     "@cspell/dict-fa-ir": "^1.0.17",
     "@cspell/dict-fr-fr": "^2.0.1",
     "@cspell/dict-html": "^1.1.9",
@@ -79,12 +81,14 @@
     "@types/configstore": "^5.0.1",
     "@types/fs-extra": "^9.0.13",
     "@types/jest": "^27.4.0",
-    "@types/node": "^17.0.10",
+    "@types/node": "^17.0.13",
     "cspell-dict-nl-nl": "^1.1.2",
     "jest": "^27.4.7",
     "lorem-ipsum": "^2.0.4",
     "rimraf": "^3.0.2",
+    "rollup": "^2.66.1",
+    "rollup-plugin-dts": "^4.1.0",
     "ts-jest": "^27.1.3"
   },
-  "gitHead": "c5d994f58bdb48c4d16f1708607b28c8a7b52a65"
+  "gitHead": "ef4c46dfb6f2938724afb5332ea2fdf9b67d99e4"
 }