knip 6.13.0 → 6.14.0

package/dist/util/file-entry-cache.js

@@ -22,51 +22,39 @@ export class FileEntryCache {
         this.filePath = path.resolve(_path, cacheId);
         if (isFile(this.filePath))
             this.cache = create(this.filePath);
-        this.removeNotFoundFiles();
-    }
-    removeNotFoundFiles() {
-        for (const filePath of this.normalizedEntries.keys()) {
-            try {
-                fs.statSync(filePath);
-            }
-            catch (error) {
-                if (error.code === 'ENOENT')
-                    this.cache.delete(filePath);
-            }
-        }
     }
     getFileDescriptor(filePath) {
+        if (!isAbsolute(filePath))
+            filePath = resolve(filePath);
+        const existing = this.normalizedEntries.get(filePath);
+        if (existing)
+            return existing;
         let fstat;
         try {
-            if (!isAbsolute(filePath))
-                filePath = resolve(filePath);
             fstat = fs.statSync(filePath);
         }
         catch (error) {
             this.removeEntry(filePath);
             return { key: filePath, notFound: true, err: error };
         }
-        return this._getFileDescriptorUsingMtimeAndSize(filePath, fstat);
-    }
-    _getFileDescriptorUsingMtimeAndSize(filePath, fstat) {
         let meta = this.cache.get(filePath);
-        const cacheExists = Boolean(meta);
         const cSize = fstat.size;
         const cTime = fstat.mtime.getTime();
-        let isDifferentDate;
-        let isDifferentSize;
+        let changed = false;
         if (meta) {
-            isDifferentDate = cTime !== meta.mtime;
-            isDifferentSize = cSize !== meta.size;
+            if (cTime !== meta.mtime || cSize !== meta.size) {
+                changed = true;
+                meta.data = undefined;
+            }
+            meta.mtime = cTime;
+            meta.size = cSize;
         }
         else {
+            changed = true;
             meta = { size: cSize, mtime: cTime };
+            this.cache.set(filePath, meta);
         }
-        const fd = {
-            key: filePath,
-            changed: !cacheExists || isDifferentDate || isDifferentSize,
-            meta,
-        };
+        const fd = { key: filePath, changed, meta };
         this.normalizedEntries.set(filePath, fd);
         return fd;
     }
@@ -76,33 +64,7 @@ export class FileEntryCache {
         this.normalizedEntries.delete(entryName);
         this.cache.delete(entryName);
     }
-    _getMetaForFileUsingMtimeAndSize(cacheEntry) {
-        const stat = fs.statSync(cacheEntry.key);
-        const meta = Object.assign(cacheEntry.meta ?? {}, {
-            size: stat.size,
-            mtime: stat.mtime.getTime(),
-        });
-        return meta;
-    }
     reconcile() {
-        for (const [entryName, cacheEntry] of this.normalizedEntries) {
-            try {
-                const stat = fs.statSync(entryName);
-                const meta = Object.assign(cacheEntry.meta ?? {}, {
-                    size: stat.size,
-                    mtime: stat.mtime.getTime(),
-                });
-                this.cache.set(entryName, meta);
-            }
-            catch (error) {
-                if (error.code === 'ENOENT') {
-                    this.normalizedEntries.delete(entryName);
-                    this.cache.delete(entryName);
-                }
-                else
-                    throw error;
-            }
-        }
         try {
             const dir = dirname(this.filePath);
             if (!isDirectory(dir))

package/dist/util/gitignore-cache.d.ts

@@ -0,0 +1,12 @@
+import type { Gitignores } from './glob-core.ts';
+export interface CachedGitignoreResult {
+    ignores: Set<string>;
+    unignores: Set<string>;
+    gitignoreFiles: string[];
+    perDirIgnores: Map<string, Gitignores>;
+}
+export declare const initGitignoreCache: (cacheLocation: string) => void;
+export declare const isGitignoreCacheEnabled: () => boolean;
+export declare const flushGitignoreCache: () => void;
+export declare const getCachedGitignore: (cwd: string, workspaceDirs?: Set<string>) => CachedGitignoreResult | undefined;
+export declare const setCachedGitignore: (cwd: string, workspaceDirs: Set<string> | undefined, gitignoreFiles: string[], ignores: Set<string>, unignores: Set<string>, perDirIgnores: Map<string, Gitignores>) => void;

package/dist/util/gitignore-cache.js

@@ -0,0 +1,77 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { createDiskCache } from './disk-cache.js';
+const store = createDiskCache('gitignore');
+export const initGitignoreCache = store.init;
+export const isGitignoreCacheEnabled = store.isEnabled;
+export const flushGitignoreCache = store.flush;
+const workspaceDirsKey = (workspaceDirs) => {
+    if (!workspaceDirs || workspaceDirs.size === 0)
+        return '';
+    return [...workspaceDirs].sort().join('\0');
+};
+const validateEntry = (entry, wsKey, cwd) => {
+    if (entry.workspaceDirsKey !== wsKey)
+        return false;
+    const files = entry.gitignoreFiles;
+    const mtimes = entry.mtimes;
+    for (let i = 0; i < files.length; i++) {
+        const abs = path.isAbsolute(files[i]) ? files[i] : path.resolve(cwd, files[i]);
+        try {
+            if (fs.statSync(abs).mtimeMs !== mtimes[i])
+                return false;
+        }
+        catch {
+            return false;
+        }
+    }
+    return true;
+};
+export const getCachedGitignore = (cwd, workspaceDirs) => {
+    const entry = store.get(cwd);
+    if (!entry)
+        return undefined;
+    const wsKey = workspaceDirsKey(workspaceDirs);
+    if (!validateEntry(entry, wsKey, cwd)) {
+        store.delete(cwd);
+        return undefined;
+    }
+    const perDirIgnores = new Map();
+    for (const dir in entry.perDirIgnores) {
+        const data = entry.perDirIgnores[dir];
+        perDirIgnores.set(dir, { ignores: new Set(data.ignores), unignores: new Set(data.unignores) });
+    }
+    return {
+        ignores: new Set(entry.ignores),
+        unignores: new Set(entry.unignores),
+        gitignoreFiles: entry.gitignoreFiles,
+        perDirIgnores,
+    };
+};
+export const setCachedGitignore = (cwd, workspaceDirs, gitignoreFiles, ignores, unignores, perDirIgnores) => {
+    if (!store.isEnabled())
+        return;
+    const mtimes = [];
+    const validFiles = [];
+    for (const file of gitignoreFiles) {
+        const abs = path.isAbsolute(file) ? file : path.resolve(cwd, file);
+        try {
+            mtimes.push(fs.statSync(abs).mtimeMs);
+            validFiles.push(file);
+        }
+        catch {
+        }
+    }
+    const perDir = {};
+    for (const [dir, data] of perDirIgnores) {
+        perDir[dir] = { ignores: [...data.ignores], unignores: [...data.unignores] };
+    }
+    store.set(cwd, {
+        gitignoreFiles: validFiles,
+        mtimes,
+        ignores: [...ignores],
+        unignores: [...unignores],
+        perDirIgnores: perDir,
+        workspaceDirsKey: workspaceDirsKey(workspaceDirs),
+    });
+};

package/dist/util/glob-cache.d.ts

@@ -1,5 +1,7 @@
 export declare const initGlobCache: (cacheLocation: string) => void;
 export declare const isGlobCacheEnabled: () => boolean;
+export declare const flushGlobCache: () => void;
+export declare const clearGlobCache: () => void;
 export declare const computeGlobCacheKey: (input: {
     patterns: string[];
     cwd: string;
@@ -8,5 +10,3 @@ export declare const computeGlobCacheKey: (input: {
 }) => string;
 export declare const getCachedGlob: (key: string) => string[] | undefined;
 export declare const setCachedGlob: (key: string, paths: string[], baseDir: string) => void;
-export declare const clearGlobCache: () => void;
-export declare const flushGlobCache: () => void;

package/dist/util/glob-cache.js

@@ -1,31 +1,12 @@
 import { createHash } from 'node:crypto';
 import fs from 'node:fs';
-import path from 'node:path';
-import { deserialize, serialize } from 'node:v8';
-import { version } from '../version.js';
-import { debugLog } from './debug.js';
-import { isDirectory, isFile } from './fs.js';
+import { createDiskCache } from './disk-cache.js';
 import { dirname } from './path.js';
-const CACHE_FILENAME = `glob-${version}.cache`;
-let cacheFilePath;
-let cache;
-let isDirty = false;
-export const initGlobCache = (cacheLocation) => {
-    cacheFilePath = path.resolve(cacheLocation, CACHE_FILENAME);
-    if (isFile(cacheFilePath)) {
-        try {
-            cache = deserialize(fs.readFileSync(cacheFilePath));
-        }
-        catch {
-            debugLog('*', `Error reading glob cache from ${cacheFilePath}`);
-            cache = new Map();
-        }
-    }
-    else {
-        cache = new Map();
-    }
-};
-export const isGlobCacheEnabled = () => cache !== undefined;
+const store = createDiskCache('glob');
+export const initGlobCache = store.init;
+export const isGlobCacheEnabled = store.isEnabled;
+export const flushGlobCache = store.flush;
+export const clearGlobCache = store.clear;
 export const computeGlobCacheKey = (input) => {
     const h = createHash('sha1');
     h.update(input.cwd);
@@ -54,14 +35,11 @@ const validateEntry = (entry) => {
     return true;
 };
 export const getCachedGlob = (key) => {
-    if (!cache)
-        return undefined;
-    const entry = cache.get(key);
+    const entry = store.get(key);
     if (!entry)
         return undefined;
     if (!validateEntry(entry)) {
-        cache.delete(key);
-        isDirty = true;
+        store.delete(key);
         return undefined;
     }
     return entry.paths;
@@ -94,31 +72,5 @@ const captureDirMtimes = (paths, baseDir) => {
     return result;
 };
 export const setCachedGlob = (key, paths, baseDir) => {
-    if (!cache)
-        return;
-    cache.set(key, {
-        paths,
-        dirMtimes: captureDirMtimes(paths, baseDir),
-    });
-    isDirty = true;
-};
-export const clearGlobCache = () => {
-    if (cache) {
-        cache.clear();
-        isDirty = true;
-    }
-};
-export const flushGlobCache = () => {
-    if (!cache || !cacheFilePath || !isDirty)
-        return;
-    try {
-        const dir = dirname(cacheFilePath);
-        if (!isDirectory(dir))
-            fs.mkdirSync(dir, { recursive: true });
-        fs.writeFileSync(cacheFilePath, serialize(cache));
-        isDirty = false;
-    }
-    catch {
-        debugLog('*', `Error writing glob cache to ${cacheFilePath}`);
-    }
+    store.set(key, { paths, dirMtimes: captureDirMtimes(paths, baseDir) });
 };

package/dist/util/glob-core.d.ts

@@ -9,6 +9,10 @@ interface GlobOptions extends TinyGlobOptions {
     dir: string;
     label?: string;
 }
+export type Gitignores = {
+    ignores: Set<string>;
+    unignores: Set<string>;
+};
 export declare const findAndParseGitignores: (cwd: string, workspaceDirs?: Set<string>) => Promise<{
     gitignoreFiles: string[];
     ignores: Set<string>;

package/dist/util/glob-core.js

@@ -7,6 +7,7 @@ import { GLOBAL_IGNORE_PATTERNS } from '../constants.js';
 import { compact, partition } from './array.js';
 import { debugLogObject } from './debug.js';
 import { isDirectory, isFile } from './fs.js';
+import { getCachedGitignore, isGitignoreCacheEnabled, setCachedGitignore } from './gitignore-cache.js';
 import { timerify } from './Performance.js';
 import { expandIgnorePatterns, parseAndConvertGitignorePatterns } from './parse-and-convert-gitignores.js';
 import { dirname, join, relative, toPosix } from './path.js';
@@ -44,6 +45,15 @@ const findAncestorGitignoreFiles = (cwd) => {
     return gitignorePaths;
 };
 export const findAndParseGitignores = async (cwd, workspaceDirs) => {
+    if (isGitignoreCacheEnabled()) {
+        const cached = getCachedGitignore(cwd, workspaceDirs);
+        if (cached) {
+            for (const [dir, data] of cached.perDirIgnores)
+                cachedGitIgnores.set(dir, data);
+            debugLogObject('*', 'Parsed gitignore files (cached)', { gitignoreFiles: cached.gitignoreFiles });
+            return { gitignoreFiles: cached.gitignoreFiles, ignores: cached.ignores, unignores: cached.unignores };
+        }
+    }
     const ignores = new Set(GLOBAL_IGNORE_PATTERNS);
     const unignores = new Set();
     const gitignoreFiles = [];
@@ -171,7 +181,7 @@ export const findAndParseGitignores = async (cwd, workspaceDirs) => {
             .crawl(cwd)
             .withPromise();
     };
-    await timerify(walkGitignores)();
+    await walkGitignores();
     if (unignores.size > 0) {
         const unignorePaths = new Set();
         for (const u of unignores) {
@@ -197,6 +207,9 @@ export const findAndParseGitignores = async (cwd, workspaceDirs) => {
         }
     }
     debugLogObject('*', 'Parsed gitignore files', { gitignoreFiles });
+    if (isGitignoreCacheEnabled()) {
+        setCachedGitignore(cwd, workspaceDirs, gitignoreFiles, ignores, unignores, cachedGitIgnores);
+    }
     return { gitignoreFiles, ignores, unignores };
 };
 const _parseFindGitignores = timerify(findAndParseGitignores);

package/dist/util/glob.js

@@ -42,12 +42,18 @@ const defaultGlob = async ({ cwd, dir = cwd, patterns, gitignore = true, label }
     return paths;
 };
 const syncGlob = ({ cwd, patterns }) => {
-    return globSync(patterns, {
-        cwd,
-        absolute: true,
-        followSymbolicLinks: false,
-        expandDirectories: false,
-    });
+    const cacheEnabled = isGlobCacheEnabled();
+    const patternList = Array.isArray(patterns) ? patterns : [patterns];
+    const cacheKey = cacheEnabled ? computeGlobCacheKey({ patterns: patternList, cwd, dir: cwd, gitignore: false }) : '';
+    if (cacheEnabled) {
+        const cached = getCachedGlob(cacheKey);
+        if (cached)
+            return cached;
+    }
+    const paths = globSync(patterns, { cwd, absolute: true, followSymbolicLinks: false, expandDirectories: false });
+    if (cacheEnabled && paths.length > 0)
+        setCachedGlob(cacheKey, paths, cwd);
+    return paths;
 };
 const dirGlob = async ({ cwd, patterns, gitignore = true }) => glob(patterns, {
     cwd,

package/dist/util/module-graph.js

@@ -61,33 +61,37 @@ export const createImports = () => ({
     reExportNs: new Map(),
 });
 export const addValue = (map, id, value) => {
-    if (map.has(id))
-        map.get(id)?.add(value);
+    const existing = map.get(id);
+    if (existing)
+        existing.add(value);
     else
         map.set(id, new Set([value]));
 };
 export const addNsValue = (map, id, ns, value) => {
-    if (map.has(id)) {
-        if (map.get(id)?.has(ns))
-            map.get(id)?.get(ns)?.add(value);
-        else
-            map.get(id)?.set(ns, new Set([value]));
-    }
-    else {
+    const inner = map.get(id);
+    if (!inner) {
         map.set(id, new Map([[ns, new Set([value])]]));
+        return;
     }
+    const set = inner.get(ns);
+    if (set)
+        set.add(value);
+    else
+        inner.set(ns, new Set([value]));
 };
 const addValues = (map, id, values) => {
-    if (map.has(id))
+    const existing = map.get(id);
+    if (existing)
         for (const v of values)
-            map.get(id)?.add(v);
+            existing.add(v);
     else
         map.set(id, values);
 };
 const addNsValues = (map, id, value) => {
-    if (map.has(id))
+    const existing = map.get(id);
+    if (existing)
         for (const [ns, v] of value)
-            addValues(map.get(id), ns, v);
+            addValues(existing, ns, v);
     else
         map.set(id, value);
 };

package/dist/version.d.ts

@@ -1 +1 @@
-export declare const version = "6.13.0";
+export declare const version = "6.14.0";

package/dist/version.js

@@ -1 +1 @@
-export const version = '6.13.0';
+export const version = '6.14.0';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "knip",
-  "version": "6.13.0",
+  "version": "6.14.0",
   "description": "Find and fix unused dependencies, exports and files in your TypeScript and JavaScript projects",
   "keywords": [
     "analysis",