cspell 9.1.3 → 9.1.5

package/dist/esm/util/cache/DiskCache.d.ts

@@ -1,63 +0,0 @@
-import type { LintFileResult } from '../../util/LintFileResult.js';
-import type { CSpellLintResultCache } from './CSpellLintResultCache.js';
-import type { FileDescriptor } from './fileEntryCache.js';
-export type CachedFileResult = Omit<LintFileResult, 'fileInfo' | 'elapsedTimeMs' | 'cached'>;
-/**
- * This is the data cached.
- * Property names are short to help keep the cache file size small.
- */
-interface CachedData {
-    /** meta version + suffix */
-    v?: string | undefined;
-    /** results */
-    r?: CachedFileResult | undefined;
-    /** dependencies */
-    d?: Dependency[] | undefined;
-}
-interface Dependency {
-    /** filename */
-    f: string;
-    /** hash of file contents */
-    h?: string | undefined;
-}
-interface CSpellCachedMetaData {
-    data?: CachedData;
-}
-type Meta = FileDescriptor['meta'];
-export type CSpellCacheMeta = (Meta & CSpellCachedMetaData) | undefined;
-/**
- * Caches cspell results on disk
- */
-export declare class DiskCache implements CSpellLintResultCache {
-    readonly useCheckSum: boolean;
-    readonly cspellVersion: string;
-    readonly useUniversalCache: boolean;
-    readonly cacheFileLocation: string;
-    private cacheDir;
-    private fileEntryCache;
-    private dependencyCache;
-    private dependencyCacheTree;
-    private objectCollection;
-    private ocCacheFileResult;
-    readonly version: string;
-    constructor(cacheFileLocation: string, useCheckSum: boolean, cspellVersion: string, useUniversalCache: boolean);
-    getCachedLintResults(filename: string): Promise<LintFileResult | undefined>;
-    setCachedLintResults({ fileInfo, elapsedTimeMs: _, cached: __, ...result }: LintFileResult, dependsUponFiles: string[]): void;
-    reconcile(): void;
-    reset(): void;
-    private normalizeResult;
-    private calcDependencyHashes;
-    private checkDependency;
-    private getDependency;
-    private getFileDep;
-    private checkDependencies;
-    private getHash;
-    private resolveFile;
-    private toRelFile;
-}
-declare function calcVersion(version: string): string;
-export declare const __testing__: {
-    calcVersion: typeof calcVersion;
-};
-export {};
-//# sourceMappingURL=DiskCache.d.ts.map

package/dist/esm/util/cache/DiskCache.js

@@ -1,214 +0,0 @@
-import assert from 'node:assert';
-import * as crypto from 'node:crypto';
-import * as fs from 'node:fs';
-import { dirname, isAbsolute as isAbsolutePath, relative as relativePath, resolve as resolvePath } from 'node:path';
-import { readFileInfo } from '../../util/fileHelper.js';
-import { createFromFile, normalizePath } from './fileEntryCache.js';
-import { ShallowObjectCollection } from './ObjectCollection.js';
-const cacheDataKeys = {
-    v: 'v',
-    r: 'r',
-    d: 'd',
-};
-/**
- * Meta Data Version is used to detect if the structure of the meta data has changed.
- * This is used in combination with the Suffix and the version of CSpell.
- */
-const META_DATA_BASE_VERSION = '1';
-const META_DATA_VERSION_SUFFIX = '-' + META_DATA_BASE_VERSION + '-' + Object.keys(cacheDataKeys).join('|');
-/**
- * Caches cspell results on disk
- */
-export class DiskCache {
-    useCheckSum;
-    cspellVersion;
-    useUniversalCache;
-    cacheFileLocation;
-    cacheDir;
-    fileEntryCache;
-    dependencyCache = new Map();
-    dependencyCacheTree = {};
-    objectCollection = new ShallowObjectCollection();
-    ocCacheFileResult = new ShallowObjectCollection();
-    version;
-    constructor(cacheFileLocation, useCheckSum, cspellVersion, useUniversalCache) {
-        this.useCheckSum = useCheckSum;
-        this.cspellVersion = cspellVersion;
-        this.useUniversalCache = useUniversalCache;
-        this.cacheFileLocation = resolvePath(cacheFileLocation);
-        this.cacheDir = dirname(this.cacheFileLocation);
-        this.fileEntryCache = createFromFile(this.cacheFileLocation, useCheckSum, useUniversalCache);
-        this.version = calcVersion(cspellVersion);
-    }
-    async getCachedLintResults(filename) {
-        filename = normalizePath(filename);
-        const fileDescriptor = this.fileEntryCache.getFileDescriptor(filename);
-        const meta = fileDescriptor.meta;
-        const data = meta?.data;
-        const result = data?.r;
-        const versionMatches = this.version === data?.v;
-        // Cached lint results are valid if and only if:
-        // 1. The file is present in the filesystem
-        // 2. The file has not changed since the time it was previously linted
-        // 3. The CSpell configuration has not changed since the time the file was previously linted
-        // If any of these are not true, we will not reuse the lint results.
-        if (fileDescriptor.notFound ||
-            fileDescriptor.changed ||
-            !meta ||
-            !result ||
-            !versionMatches ||
-            !this.checkDependencies(data.d)) {
-            return undefined;
-        }
-        const dd = { ...data };
-        if (dd.d) {
-            dd.d = setTreeEntry(this.dependencyCacheTree, dd.d);
-        }
-        dd.r = dd.r && this.normalizeResult(dd.r);
-        meta.data = this.objectCollection.get(dd);
-        // Skip reading empty files and files without lint error
-        const hasErrors = !!result && (result.errors > 0 || result.configErrors > 0 || result.issues.length > 0);
-        const cached = true;
-        const shouldReadFile = cached && hasErrors;
-        return {
-            ...result,
-            elapsedTimeMs: undefined,
-            fileInfo: shouldReadFile ? await readFileInfo(filename) : { filename },
-            cached,
-        };
-    }
-    setCachedLintResults({ fileInfo, elapsedTimeMs: _, cached: __, ...result }, dependsUponFiles) {
-        const fileDescriptor = this.fileEntryCache.getFileDescriptor(fileInfo.filename);
-        const meta = fileDescriptor.meta;
-        if (fileDescriptor.notFound || !meta) {
-            return;
-        }
-        const data = this.objectCollection.get({
-            v: this.version,
-            r: this.normalizeResult(result),
-            d: this.calcDependencyHashes(dependsUponFiles),
-        });
-        meta.data = data;
-    }
-    reconcile() {
-        this.fileEntryCache.reconcile();
-    }
-    reset() {
-        this.fileEntryCache.destroy();
-        this.dependencyCache.clear();
-        this.dependencyCacheTree = {};
-        this.objectCollection = new ShallowObjectCollection();
-        this.ocCacheFileResult = new ShallowObjectCollection();
-    }
-    normalizeResult(result) {
-        const { issues, processed, errors, configErrors, ...rest } = result;
-        if (!Object.keys(rest).length) {
-            return this.ocCacheFileResult.get(result);
-        }
-        return this.ocCacheFileResult.get({ issues, processed, errors, configErrors });
-    }
-    calcDependencyHashes(dependsUponFiles) {
-        dependsUponFiles.sort();
-        const c = getTreeEntry(this.dependencyCacheTree, dependsUponFiles);
-        if (c?.d) {
-            return c.d;
-        }
-        const dependencies = dependsUponFiles.map((f) => this.getDependency(f));
-        return setTreeEntry(this.dependencyCacheTree, dependencies);
-    }
-    checkDependency(dep) {
-        const depFile = this.resolveFile(dep.f);
-        const cDep = this.dependencyCache.get(depFile);
-        if (cDep && compDep(dep, cDep))
-            return true;
-        if (cDep)
-            return false;
-        const d = this.getFileDep(depFile);
-        if (compDep(dep, d)) {
-            this.dependencyCache.set(depFile, dep);
-            return true;
-        }
-        this.dependencyCache.set(depFile, d);
-        return false;
-    }
-    getDependency(file) {
-        const dep = this.dependencyCache.get(file);
-        if (dep)
-            return dep;
-        const d = this.getFileDep(file);
-        this.dependencyCache.set(file, d);
-        return d;
-    }
-    getFileDep(file) {
-        assert(isAbsolutePath(file), `Dependency must be absolute "${file}"`);
-        const f = this.toRelFile(file);
-        let h;
-        try {
-            const buffer = fs.readFileSync(file);
-            h = this.getHash(buffer);
-        }
-        catch {
-            return { f };
-        }
-        return { f, h };
-    }
-    checkDependencies(dependencies) {
-        if (!dependencies)
-            return false;
-        for (const dep of dependencies) {
-            if (!this.checkDependency(dep)) {
-                return false;
-            }
-        }
-        return true;
-    }
-    getHash(buffer) {
-        return crypto.createHash('md5').update(buffer).digest('hex');
-    }
-    resolveFile(file) {
-        return normalizePath(resolvePath(this.cacheDir, file));
-    }
-    toRelFile(file) {
-        return normalizePath(this.useUniversalCache ? relativePath(this.cacheDir, file) : file);
-    }
-}
-function getTreeEntry(tree, keys) {
-    let r = tree;
-    for (const k of keys) {
-        r = r.c?.get(k);
-        if (!r)
-            return r;
-    }
-    return r;
-}
-function setTreeEntry(tree, deps, update = false) {
-    let r = tree;
-    for (const d of deps) {
-        const k = d.f;
-        if (!r.c) {
-            r.c = new Map();
-        }
-        const cn = r.c.get(k);
-        const n = cn ?? {};
-        if (!cn) {
-            r.c.set(k, n);
-        }
-        r = n;
-    }
-    let d = r.d;
-    if (!d || (r.d && update)) {
-        r.d = deps;
-        d = deps;
-    }
-    return d;
-}
-function compDep(a, b) {
-    return a.f === b.f && a.h === b.h;
-}
-function calcVersion(version) {
-    return version + META_DATA_VERSION_SUFFIX;
-}
-export const __testing__ = {
-    calcVersion,
-};
-//# sourceMappingURL=DiskCache.js.map

package/dist/esm/util/cache/DummyCache.d.ts

@@ -1,11 +0,0 @@
-import type { CSpellLintResultCache } from './CSpellLintResultCache.js';
-/**
- * Dummy cache implementation that should be usd if caching option is disabled.
- */
-export declare class DummyCache implements CSpellLintResultCache {
-    getCachedLintResults(): Promise<undefined>;
-    setCachedLintResults(): void;
-    reconcile(): void;
-    reset(): void;
-}
-//# sourceMappingURL=DummyCache.d.ts.map

package/dist/esm/util/cache/DummyCache.js

@@ -1,18 +0,0 @@
-/**
- * Dummy cache implementation that should be usd if caching option is disabled.
- */
-export class DummyCache {
-    getCachedLintResults() {
-        return Promise.resolve(undefined);
-    }
-    setCachedLintResults() {
-        return;
-    }
-    reconcile() {
-        return;
-    }
-    reset() {
-        return;
-    }
-}
-//# sourceMappingURL=DummyCache.js.map

package/dist/esm/util/cache/ObjectCollection.d.ts

@@ -1,17 +0,0 @@
-export declare class ShallowObjectCollection<T extends object> {
-    private tree;
-    get(v: T): T;
-}
-export declare class Collection {
-    private col;
-    /**
-     * Add a plain object to the collection.
-     * The actual object used is returned.
-     * By adding the object to the collection, it is now owned by the collection.
-     * Do not add class objects.
-     * @param v any object or primitive
-     * @returns v or the matching object.
-     */
-    add<T>(v: T): T;
-}
-//# sourceMappingURL=ObjectCollection.d.ts.map

package/dist/esm/util/cache/ObjectCollection.js

@@ -1,127 +0,0 @@
-/* eslint-disable @typescript-eslint/no-explicit-any */
-const compare = Intl.Collator().compare;
-export class ShallowObjectCollection {
-    tree = {};
-    get(v) {
-        if (typeof v !== 'object' || v === null) {
-            return v;
-        }
-        const keys = Object.entries(v)
-            .filter((entry) => entry[1] !== undefined)
-            .sort((a, b) => compare(a[0], b[0]));
-        let t = this.tree;
-        for (const [key, obj] of keys) {
-            if (!t.c) {
-                t.c = new Map();
-            }
-            const c0 = t.c.get(key);
-            const cc = c0 || new Map();
-            if (!c0) {
-                t.c.set(key, cc);
-            }
-            const c1 = cc.get(obj);
-            const ccc = c1 || {};
-            if (!c1) {
-                cc.set(obj, ccc);
-            }
-            t = ccc;
-        }
-        if (t.v)
-            return t.v;
-        t.v = v;
-        return v;
-    }
-}
-export class Collection {
-    col = { contains: new Map() };
-    /**
-     * Add a plain object to the collection.
-     * The actual object used is returned.
-     * By adding the object to the collection, it is now owned by the collection.
-     * Do not add class objects.
-     * @param v any object or primitive
-     * @returns v or the matching object.
-     */
-    add(v) {
-        return addToCollection(this.col, v);
-    }
-}
-// const objectLike: TypeMask = {
-//     array: true,
-//     object: true,
-// };
-function addToCollection(root, v) {
-    const known = root.contains;
-    function addValToCol(c, v) {
-        const t = toValueType(v);
-        const val = c.v || Object.create(null);
-        const r = val[t] ?? v;
-        val[t] = r;
-        c.v = val;
-        return val[t];
-    }
-    function walk(col, path) {
-        path = path.filter((entry) => entry[1] !== undefined).sort((a, b) => compare(a[0], b[0]));
-        for (const [k, v] of path) {
-            const c = col.c || Object.create(null);
-            col.c = c;
-            const m = c[k] || new Map();
-            c[k] = m;
-            const has = m.get(v);
-            col = has || Object.create(null);
-            if (!has) {
-                m.set(v, col);
-            }
-        }
-        return col;
-    }
-    function normalizeObjectEntries(entries) {
-        for (const entry of entries) {
-            entry[1] = add(entry[1]);
-        }
-        return entries;
-    }
-    function normalizeToPath(v) {
-        if (typeof v !== 'object' || !v) {
-            return [['', v]];
-        }
-        const entries = normalizeObjectEntries(Object.entries(v));
-        const obj = v;
-        if (!Object.isFrozen(v)) {
-            for (const [k, v] of entries) {
-                obj[k] = v;
-            }
-            Object.freeze(obj);
-        }
-        return entries;
-    }
-    function add(v) {
-        const isObjectLike = typeof v === 'object' && !!v;
-        if (isObjectLike) {
-            const cached = known.get(v);
-            if (cached !== undefined) {
-                return cached;
-            }
-            known.set(v, v);
-        }
-        const path = normalizeToPath(v);
-        const c = walk(root, path);
-        const r = addValToCol(c, v);
-        if (isObjectLike) {
-            known.set(v, r);
-        }
-        return r;
-    }
-    return add(v);
-}
-function toValueType(v) {
-    const t = typeof v;
-    if (t !== 'object')
-        return t;
-    if (Array.isArray(v))
-        return 'array';
-    if (v === null)
-        return 'null';
-    return t;
-}
-//# sourceMappingURL=ObjectCollection.js.map

package/dist/esm/util/cache/createCache.d.ts

@@ -1,31 +0,0 @@
-import type { CacheSettings, CSpellSettings } from '@cspell/cspell-types';
-import type { CacheOptions } from './CacheOptions.js';
-import type { CSpellLintResultCache } from './CSpellLintResultCache.js';
-export declare const DEFAULT_CACHE_LOCATION = ".cspellcache";
-export interface CreateCacheSettings extends Required<CacheSettings> {
-    /**
-     * cspell version used to validate cache entries.
-     */
-    version: string;
-    /**
-     * When true, causes the cache to be reset, removing any entries
-     * or cache files.
-     */
-    reset?: true;
-}
-/**
- * Creates CSpellLintResultCache (disk cache if caching is enabled in config or dummy otherwise)
- */
-export declare function createCache(options: CreateCacheSettings): CSpellLintResultCache;
-export declare function calcCacheSettings(config: CSpellSettings, cacheOptions: CacheOptions, root: string): Promise<CreateCacheSettings>;
-/**
- * Normalizes the version and return only `major.minor + versionSuffix`
- * @param version The cspell semantic version.
- */
-declare function normalizeVersion(version: string): string;
-export declare const __testing__: {
-    normalizeVersion: typeof normalizeVersion;
-    versionSuffix: string;
-};
-export {};
-//# sourceMappingURL=createCache.d.ts.map

package/dist/esm/util/cache/createCache.js

@@ -1,69 +0,0 @@
-import assert from 'node:assert';
-import { stat } from 'node:fs/promises';
-import path from 'node:path';
-import { isErrorLike } from '../errors.js';
-import { DiskCache } from './DiskCache.js';
-import { DummyCache } from './DummyCache.js';
-// cspell:word cspellcache
-export const DEFAULT_CACHE_LOCATION = '.cspellcache';
-const versionSuffix = '';
-/**
- * Creates CSpellLintResultCache (disk cache if caching is enabled in config or dummy otherwise)
- */
-export function createCache(options) {
-    const { useCache, cacheLocation, cacheStrategy, reset } = options;
-    const location = path.resolve(cacheLocation);
-    const useChecksum = cacheStrategy === 'content';
-    const version = normalizeVersion(options.version);
-    const useUniversal = options.cacheFormat === 'universal';
-    const cache = useCache ? new DiskCache(location, useChecksum, version, useUniversal) : new DummyCache();
-    reset && cache.reset();
-    return cache;
-}
-export async function calcCacheSettings(config, cacheOptions, root) {
-    const cs = config.cache ?? {};
-    const useCache = cacheOptions.cache ?? cs.useCache ?? false;
-    const cacheLocation = await resolveCacheLocation(path.resolve(root, cacheOptions.cacheLocation ?? cs.cacheLocation ?? DEFAULT_CACHE_LOCATION));
-    const cacheStrategy = cacheOptions.cacheStrategy ?? cs.cacheStrategy ?? 'content';
-    const cacheFormat = cacheOptions.cacheFormat ?? cs.cacheFormat ?? 'universal';
-    const optionals = {};
-    if (cacheOptions.cacheReset) {
-        optionals.reset = true;
-    }
-    return {
-        ...optionals,
-        useCache,
-        cacheLocation,
-        cacheStrategy,
-        version: cacheOptions.version,
-        cacheFormat,
-    };
-}
-async function resolveCacheLocation(cacheLocation) {
-    try {
-        const s = await stat(cacheLocation);
-        if (s.isFile())
-            return cacheLocation;
-        return path.join(cacheLocation, DEFAULT_CACHE_LOCATION);
-    }
-    catch (err) {
-        if (isErrorLike(err) && err.code === 'ENOENT') {
-            return cacheLocation;
-        }
-        throw err;
-    }
-}
-/**
- * Normalizes the version and return only `major.minor + versionSuffix`
- * @param version The cspell semantic version.
- */
-function normalizeVersion(version) {
-    const parts = version.split('.').slice(0, 2);
-    assert(parts.length === 2);
-    return parts.join('.') + versionSuffix;
-}
-export const __testing__ = {
-    normalizeVersion,
-    versionSuffix,
-};
-//# sourceMappingURL=createCache.js.map

package/dist/esm/util/cache/file-entry-cache.d.mts

@@ -1,4 +0,0 @@
-import type { FileEntryCache } from 'file-entry-cache';
-export type { FileDescriptor, FileEntryCache } from 'file-entry-cache';
-export declare function createFromFile(pathToCache: string, useChecksum?: boolean): FileEntryCache;
-//# sourceMappingURL=file-entry-cache.d.mts.map

package/dist/esm/util/cache/file-entry-cache.mjs

@@ -1,5 +0,0 @@
-import fileEntryCache from 'file-entry-cache';
-export function createFromFile(pathToCache, useChecksum) {
-    return fileEntryCache.createFromFile(pathToCache, useChecksum);
-}
-//# sourceMappingURL=file-entry-cache.mjs.map

package/dist/esm/util/cache/fileEntryCache.d.ts

@@ -1,9 +0,0 @@
-/**
- * This is a wrapper for 'file-entry-cache'
- */
-export type { FileDescriptor } from './file-entry-cache.mjs';
-import type { FileEntryCache as FecFileEntryCache } from './file-entry-cache.mjs';
-export type FileEntryCache = FecFileEntryCache;
-export declare function createFromFile(pathToCache: string, useCheckSum: boolean, useRelative: boolean): FileEntryCache;
-export declare function normalizePath(filePath: string): string;
-//# sourceMappingURL=fileEntryCache.d.ts.map

package/dist/esm/util/cache/fileEntryCache.js

@@ -1,79 +0,0 @@
-/**
- * This is a wrapper for 'file-entry-cache'
- */
-import { mkdirSync } from 'node:fs';
-import * as path from 'node:path';
-import { isMainThread } from 'node:worker_threads';
-import * as fec from './file-entry-cache.mjs';
-export function createFromFile(pathToCache, useCheckSum, useRelative) {
-    const absPathToCache = path.resolve(pathToCache);
-    const relDir = path.dirname(absPathToCache);
-    mkdirSync(relDir, { recursive: true });
-    const create = wrap(() => fec.createFromFile(absPathToCache, useCheckSum));
-    const feCache = create();
-    const cacheWrapper = {
-        get cache() {
-            return feCache.cache;
-        },
-        getHash(buffer) {
-            return feCache.getHash(buffer);
-        },
-        hasFileChanged: wrap((cwd, file) => {
-            // console.log(file);
-            return feCache.hasFileChanged(resolveFile(cwd, file));
-        }),
-        analyzeFiles: wrap((cwd, files) => {
-            return feCache.analyzeFiles(resolveFiles(cwd, files));
-        }),
-        getFileDescriptor: wrap((cwd, file) => {
-            return feCache.getFileDescriptor(resolveFile(cwd, file));
-        }),
-        getUpdatedFiles: wrap((cwd, files) => {
-            return feCache.getUpdatedFiles(resolveFiles(cwd, files));
-        }),
-        normalizeEntries: wrap((cwd, files) => {
-            return feCache.normalizeEntries(resolveFiles(cwd, files));
-        }),
-        removeEntry: wrap((cwd, file) => {
-            // console.log(file);
-            return feCache.removeEntry(resolveFile(cwd, file));
-        }),
-        deleteCacheFile() {
-            feCache.deleteCacheFile();
-        },
-        destroy() {
-            feCache.destroy();
-        },
-        reconcile: wrap((_cwd, noPrune) => {
-            feCache.reconcile(noPrune);
-        }),
-    };
-    return cacheWrapper;
-    function resolveFile(cwd, file) {
-        if (!useRelative)
-            return normalizePath(file);
-        const r = path.relative(relDir, path.resolve(cwd, file));
-        return normalizePath(r);
-    }
-    function resolveFiles(cwd, files) {
-        return files?.map((file) => resolveFile(cwd, file));
-    }
-    function wrap(fn) {
-        return (...params) => {
-            const cwd = process.cwd();
-            try {
-                isMainThread && process.chdir(relDir);
-                return fn(cwd, ...params);
-            }
-            finally {
-                isMainThread && process.chdir(cwd);
-            }
-        };
-    }
-}
-export function normalizePath(filePath) {
-    if (path.sep === '/')
-        return filePath;
-    return filePath.split(path.sep).join('/');
-}
-//# sourceMappingURL=fileEntryCache.js.map

package/dist/esm/util/cache/index.d.ts

@@ -1,4 +0,0 @@
-export type { CacheOptions } from './CacheOptions.js';
-export { calcCacheSettings, createCache, type CreateCacheSettings, DEFAULT_CACHE_LOCATION } from './createCache.js';
-export type { CSpellLintResultCache } from './CSpellLintResultCache.js';
-//# sourceMappingURL=index.d.ts.map

package/dist/esm/util/cache/index.js

@@ -1,2 +0,0 @@
-export { calcCacheSettings, createCache, DEFAULT_CACHE_LOCATION } from './createCache.js';
-//# sourceMappingURL=index.js.map

package/dist/esm/util/canUseColor.d.ts

@@ -1,2 +0,0 @@
-export declare function canUseColor(colorOption: boolean | undefined): boolean | undefined;
-//# sourceMappingURL=canUseColor.d.ts.map

package/dist/esm/util/canUseColor.js

@@ -1,10 +0,0 @@
-export function canUseColor(colorOption) {
-    if (colorOption !== undefined)
-        return colorOption;
-    if (!('NO_COLOR' in process.env))
-        return undefined;
-    if (!process.env['NO_COLOR'] || process.env['NO_COLOR'] === 'false')
-        return undefined;
-    return false;
-}
-//# sourceMappingURL=canUseColor.js.map