knip 6.40.0 → 6.41.0

package/dist/util/glob-core.js

@@ -1,8 +1,6 @@
 import { createHash } from 'node:crypto';
-import { readFileSync } from 'node:fs';
-import { basename } from 'node:path';
-import { fdir } from 'fdir';
-import { glob as tinyGlob } from 'tinyglobby';
+import { readdir, readFileSync } from 'node:fs';
+import { escapePath, glob as tinyGlob } from 'tinyglobby';
 import picomatch from 'picomatch';
 import { GLOBAL_IGNORE_PATTERNS } from '../constants.js';
 import { compact, partition } from './array.js';
@@ -14,6 +12,15 @@ import { expandIgnorePatterns, parseAndConvertGitignorePatterns } from './parse-
 import { dirname, isAbsolute, join, relative, toAbsolute, toPosix } from './path.js';
 const cachedGitIgnores = new Map();
 const cachedGlobIgnores = new Map();
+let gitignoreWorkspaceDirs;
+const isInNestedWorkspace = (gitignoreDir, dir) => {
+    if (!gitignoreWorkspaceDirs)
+        return false;
+    for (let d = gitignoreDir; d.length > dir.length; d = dirname(d))
+        if (gitignoreWorkspaceDirs.has(d))
+            return true;
+    return false;
+};
 let gitignoreReconciler;
 let gitignoreMatcher = (_filePath) => false;
 export const isGitIgnored = (filePath) => gitignoreMatcher(filePath);
@@ -76,22 +83,20 @@ export const findAndParseGitignores = async (cwd, workspaceDirs) => {
     const ignores = new Set(GLOBAL_IGNORE_PATTERNS);
     const unignores = new Set();
     const gitignoreFiles = [];
-    let deepFilterMatcher;
-    let prevUnignoreSize = unignores.size;
-    let unignoresArray = [];
-    const pendingIgnores = [];
-    const getMatcher = () => {
-        if (!deepFilterMatcher) {
-            unignoresArray = Array.from(unignores);
-            deepFilterMatcher = picomatch(Array.from(ignores), { ignore: unignoresArray });
-            pendingIgnores.length = 0;
-        }
-        else if (pendingIgnores.length > 0) {
-            const prev = deepFilterMatcher;
-            const incr = picomatch(pendingIgnores.splice(0), { ignore: unignoresArray });
-            deepFilterMatcher = (path) => prev(path) || incr(path);
-        }
-        return deepFilterMatcher;
+    let isIgnored = (_path) => false;
+    let isUnignored = (_path) => false;
+    const pendingIgnores = Array.from(ignores);
+    const pendingUnignores = [];
+    const extend = (matcher, pending) => {
+        if (pending.length === 0)
+            return matcher;
+        const incr = picomatch(pending.splice(0));
+        return (path) => matcher(path) || incr(path);
+    };
+    const isExcluded = (path) => {
+        isIgnored = extend(isIgnored, pendingIgnores);
+        isUnignored = extend(isUnignored, pendingUnignores);
+        return isIgnored(path) && !isUnignored(path);
     };
     const seenGitignoreFiles = new Set();
     const addFile = (filePath, baseDir) => {
@@ -108,6 +113,7 @@ export const findAndParseGitignores = async (cwd, workspaceDirs) => {
         const prevIgnoreSize = ignores.size;
         const patterns = readFileSync(filePath, 'utf8');
         const isRoot = base === '' || base.startsWith('..');
+        const escapedBase = escapePath(base);
         for (const { negated, pattern } of parseAndConvertGitignorePatterns(patterns, ancestor)) {
             if (negated) {
                 if (isRoot) {
@@ -117,7 +123,7 @@ export const findAndParseGitignores = async (cwd, workspaceDirs) => {
                     }
                 }
                 else if (!unignores.has(pattern)) {
-                    const unignore = join(base, pattern);
+                    const unignore = join(escapedBase, pattern);
                     unignores.add(unignore);
                     unignoresForDir.add(unignore);
                 }
@@ -127,7 +133,7 @@ export const findAndParseGitignores = async (cwd, workspaceDirs) => {
                 ignoresForDir.add(pattern);
             }
             else if (!unignores.has(pattern)) {
-                const ignore = join(base, pattern);
+                const ignore = join(escapedBase, pattern);
                 ignores.add(ignore);
                 ignoresForDir.add(ignore);
             }
@@ -143,11 +149,9 @@ export const findAndParseGitignores = async (cwd, workspaceDirs) => {
         else {
             cachedGitIgnores.set(cacheDir, { ignores: ignoresForDir, unignores: unignoresForDir });
         }
-        if (unignores.size !== prevUnignoreSize) {
-            deepFilterMatcher = undefined;
-            prevUnignoreSize = unignores.size;
-        }
-        else if (ignores.size !== prevIgnoreSize) {
+        for (const p of unignoresForDir)
+            pendingUnignores.push(p);
+        if (ignores.size !== prevIgnoreSize) {
             for (const p of ignoresForDir)
                 if (!GLOBAL_IGNORE_PATTERNS.includes(p))
                     pendingIgnores.push(p);
@@ -168,15 +172,16 @@ export const findAndParseGitignores = async (cwd, workspaceDirs) => {
     const rootGitignorePath = join(cwd, '.gitignore');
     if (isFile(rootGitignorePath))
         addFile(rootGitignorePath);
+    const root = cwd.length > 1 && cwd.endsWith('/') ? cwd.slice(0, -1) : cwd;
     let isRelevantDir;
     if (workspaceDirs && workspaceDirs.size > 0) {
         const relevantAncestors = new Set();
         const nonRootDirs = new Set();
         for (const wsDir of workspaceDirs) {
-            if (wsDir !== cwd)
+            if (wsDir !== root)
                 nonRootDirs.add(wsDir);
             let dir = wsDir;
-            while (dir.length >= cwd.length) {
+            while (dir.length >= root.length) {
                 relevantAncestors.add(dir);
                 const parent = dirname(dir);
                 if (parent === dir)
@@ -195,24 +200,32 @@ export const findAndParseGitignores = async (cwd, workspaceDirs) => {
             };
         }
     }
-    const cwdPrefixLen = cwd.length + 1;
-    const walkGitignores = async () => {
-        await new fdir()
-            .withFullPaths()
-            .exclude((_dirName, dirPath) => {
-            const absPath = toPosix(dirPath.slice(0, -1));
-            return (isRelevantDir && !isRelevantDir(absPath)) || getMatcher()(absPath.slice(cwdPrefixLen));
-        })
-            .filter((filePath, isDir) => {
-            if (isDir || basename(filePath) !== '.gitignore')
-                return false;
-            addFile(filePath);
-            return true;
-        })
-            .crawl(cwd)
-            .withPromise();
-    };
-    await walkGitignores();
+    const rootPrefixLen = root.length + 1;
+    await new Promise(resolve => {
+        let pending = 0;
+        const walk = (dir) => {
+            pending++;
+            readdir(dir, { withFileTypes: true }, (error, entries) => {
+                if (!error) {
+                    for (const entry of entries) {
+                        if (entry.name === '.gitignore' && (entry.isFile() || entry.isSymbolicLink()))
+                            addFile(`${dir}/.gitignore`);
+                    }
+                    for (const entry of entries) {
+                        if (!entry.isDirectory())
+                            continue;
+                        const absPath = `${dir}/${entry.name}`;
+                        if ((isRelevantDir && !isRelevantDir(absPath)) || isExcluded(absPath.slice(rootPrefixLen)))
+                            continue;
+                        walk(absPath);
+                    }
+                }
+                if (--pending === 0)
+                    resolve();
+            });
+        };
+        walk(root);
+    });
     if (unignores.size > 0) {
         const unignorePaths = new Set();
         for (const u of unignores) {
@@ -269,6 +282,14 @@ export async function glob(_patterns, options) {
             if (prev === dir || dir === '.')
                 break;
         }
+        if (!gitignoreReconciler) {
+            const prefix = `${options.dir}/`;
+            for (const [gitignoreDir, cacheForDir] of cachedGitIgnores) {
+                if (gitignoreDir.startsWith(prefix) && !isInNestedWorkspace(gitignoreDir, options.dir)) {
+                    _ignore.push(...cacheForDir.ignores);
+                }
+            }
+        }
         cachedGlobIgnores.set(options.dir, compact(_ignore));
     }
     const ignorePatterns = (cachedIgnores ?? _ignore).concat(negatedPatterns.map(pattern => pattern.slice(1)));
@@ -301,6 +322,8 @@ export function reconcileGitignoredPaths(paths, cwd) {
 }
 export async function getGitIgnoredHandler(options, workspaceDirs) {
     cachedGitIgnores.clear();
+    cachedGlobIgnores.clear();
+    gitignoreWorkspaceDirs = workspaceDirs;
     gitignoreReconciler = undefined;
     gitignoreMatcher = () => false;
     gitignoreFingerprint = '';

package/dist/util/glob.js

@@ -4,8 +4,18 @@ import { computeGlobCacheKey, createDirTracker, getCachedGlob, isGlobCacheEnable
 import { getGitignoreFingerprint, glob, reconcileGitignoredPaths } from './glob-core.js';
 import { timerify } from './Performance.js';
 import { isAbsolute, join, relative } from './path.js';
-const prepend = (pattern, relativePath) => isAbsolute(pattern.replace(/^!/, '')) ? pattern : prependDirToPattern(relativePath, pattern);
-const prependDirToPatterns = (cwd, dir, patterns) => compact([patterns].flat().map(p => removeProductionSuffix(prepend(p, relative(cwd, dir))))).sort(negatedLast);
+const prepend = (pattern, cwd, relativePath) => {
+    const isNegated = pattern.startsWith('!');
+    const id = isNegated ? pattern.slice(1) : pattern;
+    if (id && !isAbsolute(id) && !relativePath)
+        return pattern;
+    const globPattern = isAbsolute(id) ? relative(cwd, id) : join(relativePath, id);
+    return isNegated ? `!${globPattern}` : globPattern;
+};
+const prependDirToPatterns = (cwd, dir, patterns) => {
+    const relativePath = dir === cwd ? '' : relative(cwd, dir);
+    return compact(patterns.map(p => removeProductionSuffix(prepend(p, cwd, relativePath)))).sort(negatedLast);
+};
 export const removeProductionSuffix = (pattern) => pattern.replace(/!$/, '');
 const negatedLast = (pattern) => (pattern.startsWith('!') ? 1 : -1);
 export const prependDirToPattern = (dir, pattern) => {
@@ -48,7 +58,7 @@ const defaultGlob = async ({ cwd, dir = cwd, patterns, gitignore = true, label }
 };
 const syncGlob = ({ cwd, patterns }) => {
     const cacheEnabled = isGlobCacheEnabled();
-    const patternList = Array.isArray(patterns) ? patterns : [patterns];
+    const patternList = [patterns].flat().map(pattern => prepend(pattern, cwd, ''));
     const cacheKey = cacheEnabled
         ? computeGlobCacheKey({ patterns: patternList, cwd, dir: cwd, gitignore: false, gitignoreFingerprint: '' })
         : '';
@@ -58,7 +68,7 @@ const syncGlob = ({ cwd, patterns }) => {
             return cached;
     }
     const tracker = cacheEnabled ? createDirTracker() : undefined;
-    const paths = globSync(patterns, {
+    const paths = globSync(patternList, {
         cwd,
         absolute: true,
         followSymbolicLinks: false,
@@ -69,12 +79,7 @@ const syncGlob = ({ cwd, patterns }) => {
         setCachedGlob(cacheKey, paths, cwd, tracker?.dirs);
     return paths;
 };
-const dirGlob = async ({ cwd, patterns, gitignore = true }) => glob(patterns, {
-    cwd,
-    dir: cwd,
-    onlyDirectories: true,
-    gitignore,
-});
+const dirGlob = async ({ cwd, patterns, gitignore = true }) => glob(patterns.map(pattern => prepend(pattern, cwd, '')), { cwd, dir: cwd, onlyDirectories: true, gitignore });
 export const _glob = timerify(defaultGlob);
 export const _syncGlob = timerify(syncGlob);
 export const _dirGlob = timerify(dirGlob);

package/dist/util/load-tsconfig.d.ts

@@ -9,5 +9,5 @@ interface TSConfigInfo {
     sourceMapPairs: SourceMap[];
     paths: Record<string, string[]> | undefined;
 }
-export declare const loadTSConfig: (tsConfigFilePath: string) => Promise<TSConfigInfo>;
+export declare const loadTSConfig: (tsConfigFilePath: string, isUseTscFiles?: boolean, visited?: Set<string>) => Promise<TSConfigInfo>;
 export {};

package/dist/util/load-tsconfig.js

@@ -2,19 +2,19 @@ import { parseTsconfig } from 'get-tsconfig';
 import { compact } from './array.js';
 import { isFile } from './fs.js';
 import { _syncGlob } from './glob.js';
-import { dirname, isAbsolute, join, toAbsolute, toPosix } from './path.js';
+import { dirname, isAbsolute, join, relative, toAbsolute, toPosix } from './path.js';
 const hasGlobChar = (p) => p.includes('*') || p.includes('?');
 const hasExtension = (p) => {
     const last = p.lastIndexOf('/');
     const base = last >= 0 ? p.slice(last + 1) : p;
     return base !== '.' && base !== '..' && base.includes('.');
 };
-const resolvePatterns = (patterns, dir, expandDirs = false) => {
+const toRelativePatterns = (patterns, dir) => {
     if (!patterns)
         return undefined;
     return patterns.map(p => {
-        const resolved = isAbsolute(p) ? p : join(dir, p);
-        return expandDirs && !hasGlobChar(p) && !hasExtension(p) ? join(resolved, '**/*') : resolved;
+        const pattern = isAbsolute(p) ? relative(dir, p) : p;
+        return hasGlobChar(p) || hasExtension(p) ? pattern : join(pattern, '**/*');
     });
 };
 const getImplicitBaseUrl = (compilerOptions) => {
@@ -54,11 +54,11 @@ const expandFileNames = (dir, compilerOptions, include, exclude, files) => {
         for (const file of files)
             result.push(file);
     }
-    const effectiveExclude = [...(exclude ?? []), join(dir, 'node_modules/**')];
+    const effectiveExclude = [...(exclude ?? []), 'node_modules/**'];
     if (compilerOptions.outDir) {
-        effectiveExclude.push(join(compilerOptions.outDir, '**'));
+        effectiveExclude.push(join(relative(dir, compilerOptions.outDir), '**'));
     }
-    const effectiveInclude = include ?? (files ? undefined : DEFAULT_INCLUDE.map(p => join(dir, p)));
+    const effectiveInclude = include ?? (files ? undefined : DEFAULT_INCLUDE);
     if (effectiveInclude) {
         const negated = effectiveExclude.map(p => `!${p}`);
         const globbed = _syncGlob({ patterns: [...effectiveInclude, ...negated], cwd: dir });
@@ -108,7 +108,7 @@ const EMPTY = {
     sourceMapPairs: [],
     paths: undefined,
 };
-export const loadTSConfig = async (tsConfigFilePath) => {
+export const loadTSConfig = async (tsConfigFilePath, isUseTscFiles = false, visited = new Set([tsConfigFilePath])) => {
     if (!isFile(tsConfigFilePath))
         return { isFile: false, ...EMPTY };
     try {
@@ -127,10 +127,20 @@ export const loadTSConfig = async (tsConfigFilePath) => {
         if (config.references?.length) {
             walkReferences(compilerOptions, config.references, dir, new Set([tsConfigFilePath]), sourceMapPairs, tsconfigPaths);
         }
-        const include = resolvePatterns(config.include, dir, true);
-        const exclude = resolvePatterns(config.exclude, dir, true);
-        const files = resolvePatterns(config.files, dir);
+        const include = toRelativePatterns(config.include, dir);
+        const exclude = toRelativePatterns(config.exclude, dir);
+        const files = config.files?.map(p => toAbsolute(p, dir));
         const fileNames = expandFileNames(dir, compilerOptions, include, exclude, files);
+        if (isUseTscFiles && config.references) {
+            for (const ref of config.references) {
+                const refPath = resolveReference(ref.path, dir);
+                if (!refPath?.startsWith(`${dir}/`) || visited.has(refPath))
+                    continue;
+                visited.add(refPath);
+                for (const filePath of (await loadTSConfig(refPath, true, visited)).fileNames)
+                    fileNames.push(filePath);
+            }
+        }
         const paths = Object.keys(tsconfigPaths).length > 0 ? tsconfigPaths : undefined;
         return { isFile: true, compilerOptions, fileNames, include, exclude, sourceMapPairs, paths };
     }

package/dist/util/module-graph.js

@@ -87,13 +87,18 @@ const addValues = (map, id, values) => {
         for (const v of values)
             existing.add(v);
     else
-        map.set(id, values);
+        map.set(id, new Set(values));
 };
 const addNsValues = (map, id, value) => {
     const existing = map.get(id);
-    if (existing)
+    if (existing) {
         for (const [ns, v] of value)
             addValues(existing, ns, v);
-    else
-        map.set(id, value);
+    }
+    else {
+        const copy = new Map();
+        for (const [ns, v] of value)
+            copy.set(ns, new Set(v));
+        map.set(id, copy);
+    }
 };

package/dist/util/scripts.d.ts

@@ -1,8 +1,9 @@
-import { type Command, type Node } from 'unbash';
+import { type Command, type SyntaxNode, type Word } from 'unbash';
 export interface ScriptCommand {
     binary: string;
     args: string[];
 }
 export declare const toShellCommand: (argv: string[]) => string;
-export declare function walkCommands(node: Node): Generator<Command>;
+export declare const getCommandWords: (node: Pick<Command, 'args'>) => Word[];
+export declare function walkCommands(node: SyntaxNode): Generator<Command>;
 export declare const getScriptCommands: (script: string) => ScriptCommand[];

package/dist/util/scripts.js

@@ -2,6 +2,7 @@ import { parse } from 'unbash';
 import { extractBinary } from './modules.js';
 const spawningBinaries = new Set(['c8', 'cross-env', 'retry-cli']);
 export const toShellCommand = (argv) => argv.map(arg => `'${arg.replaceAll("'", `'\\''`)}'`).join(' ');
+export const getCommandWords = (node) => node.args.filter((arg) => arg.type === 'Word');
 export function* walkCommands(node) {
     switch (node.type) {
         case 'Command':
@@ -42,7 +43,11 @@ export function* walkCommands(node) {
             yield* walkCommands(node.body);
             break;
         case 'Statement':
-            yield* walkCommands(node.command);
+        case 'Redirected':
+        case 'Time':
+        case 'Negation':
+            if (node.command)
+                yield* walkCommands(node.command);
             break;
     }
 }
@@ -65,15 +70,16 @@ export const getScriptCommands = (script) => {
             if (!text)
                 continue;
             const binary = extractBinary(text);
+            const words = getCommandWords(node);
             if (spawningBinaries.has(binary)) {
-                const rest = node.suffix
+                const rest = words
                     .filter(word => word.text !== '--')
                     .map(word => word.text)
                     .join(' ');
                 out.push(...getScriptCommands(rest));
             }
             else
-                out.push({ binary, args: node.suffix.map(word => word.value) });
+                out.push({ binary, args: words.map(word => word.value) });
         }
     }
     return out;

package/dist/util/to-source-path.js

@@ -104,7 +104,7 @@ export const getToSourcePathsHandler = (chief) => {
             const absSpecifier = isAbsolute(id) ? id : prependDirToPattern(dir, id);
             const ws = chief.findWorkspaceByFilePath(absSpecifier);
             const mapped = ws?.sourceMaps && rewritePattern(ws.sourceMaps, absSpecifier, extensions);
-            patterns.add(negation + (mapped ?? absSpecifier));
+            patterns.add(negation + (mapped ?? id));
         }
         const filePaths = await _glob({ patterns: Array.from(patterns), cwd: chief.cwd, dir, label });
         debugLogArray(toRelative(dir, chief.cwd), 'Source mapping (package.json)', filePaths);

package/dist/version.d.ts

@@ -1 +1 @@
-export declare const version = "6.40.0";
+export declare const version = "6.41.0";

package/dist/version.js

@@ -1 +1 @@
-export const version = '6.40.0';
+export const version = '6.41.0';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "knip",
-  "version": "6.40.0",
+  "version": "6.41.0",
   "description": "Find and fix unused dependencies, exports and files in your TypeScript and JavaScript projects",
   "keywords": [
     "analysis",
@@ -81,29 +81,28 @@
     }
   },
   "dependencies": {
-    "fdir": "^6.5.0",
-    "formatly": "^0.7.0",
+    "formatly": "^0.11.4",
     "get-tsconfig": "4.14.3",
     "jiti": "^2.7.0",
-    "oxc-parser": "^0.150.0",
+    "oxc-parser": "^0.153.0",
     "oxc-resolver": "11.24.2",
     "picomatch": "^4.0.7",
-    "smol-toml": "^1.8.0",
+    "smol-toml": "^1.9.0",
     "strip-json-comments": "5.0.3",
     "tinyglobby": "^0.2.17",
-    "unbash": "^4.0.11",
+    "unbash": "^5.0.0",
     "yaml": "^2.9.1",
-    "zod": "^4.4.3"
+    "zod": "^4.6.5"
   },
   "devDependencies": {
     "@jest/types": "^30.5.1",
     "@types/bun": "^1.4.2",
     "@types/picomatch": "^4.0.3",
     "codeclimate-types": "^0.3.1",
-    "prettier": "^3.9.6",
-    "tsx": "^4.23.13",
+    "prettier": "^3.9.9",
+    "tsx": "^4.23.15",
     "typescript": "7.0.2",
-    "webpack": "^5.111.0"
+    "webpack": "^5.111.1"
   },
   "engines": {
     "node": "^20.19.0 || >=22.12.0"

package/schema.json

@@ -562,6 +562,10 @@
           "title": "Expo plugin configuration (https://knip.dev/reference/plugins/expo)",
           "$ref": "#/definitions/plugin"
         },
+        "expo-router": {
+          "title": "Expo Router plugin configuration (https://knip.dev/reference/plugins/expo-router)",
+          "$ref": "#/definitions/plugin"
+        },
         "expressive-code": {
           "title": "expressive-code plugin configuration (https://knip.dev/reference/plugins/expressive-code)",
           "$ref": "#/definitions/plugin"
@@ -570,6 +574,10 @@
           "title": "fast plugin configuration (https://knip.dev/reference/plugins/fast)",
           "$ref": "#/definitions/plugin"
         },
+        "flue": {
+          "title": "flue plugin configuration (https://knip.dev/reference/plugins/flue)",
+          "$ref": "#/definitions/plugin"
+        },
         "fumadocs": {
           "title": "fumadocs plugin configuration (https://knip.dev/reference/plugins/fumadocs)",
           "$ref": "#/definitions/plugin"