knip 5.29.2 → 5.30.0

package/dist/ConfigurationValidator.d.ts

@@ -2775,9 +2775,9 @@ export declare const ConfigurationValidator: z.ZodObject<z.objectUtil.extendShap
     ignoreExportsUsedInFile?: boolean | Partial<Record<"function" | "type" | "enum" | "class" | "interface" | "member", boolean>> | undefined;
     ignoreWorkspaces?: string[] | undefined;
     includeEntryExports?: boolean | undefined;
-    compilers?: Record<string, ((args_0: string, args_1: string, ...args: unknown[]) => string) | ((args_0: string, args_1: string, ...args: unknown[]) => Promise<string>)> | undefined;
-    syncCompilers?: Record<string, (args_0: string, args_1: string, ...args: unknown[]) => string> | undefined;
-    asyncCompilers?: Record<string, (args_0: string, args_1: string, ...args: unknown[]) => Promise<string>> | undefined;
+    compilers?: Record<string, ((args_0: string, args_1: string, ...args_2: unknown[]) => string) | ((args_0: string, args_1: string, ...args_2: unknown[]) => Promise<string>)> | undefined;
+    syncCompilers?: Record<string, (args_0: string, args_1: string, ...args_2: unknown[]) => string> | undefined;
+    asyncCompilers?: Record<string, (args_0: string, args_1: string, ...args_2: unknown[]) => Promise<string>> | undefined;
     astro?: string | boolean | string[] | {
         config?: string | string[] | undefined;
         entry?: string | string[] | undefined;
@@ -3552,9 +3552,9 @@ export declare const ConfigurationValidator: z.ZodObject<z.objectUtil.extendShap
     ignoreExportsUsedInFile?: boolean | Partial<Record<"function" | "type" | "enum" | "class" | "interface" | "member", boolean>> | undefined;
     ignoreWorkspaces?: string[] | undefined;
     includeEntryExports?: boolean | undefined;
-    compilers?: Record<string, ((args_0: string, args_1: string, ...args: unknown[]) => string) | ((args_0: string, args_1: string, ...args: unknown[]) => Promise<string>)> | undefined;
-    syncCompilers?: Record<string, (args_0: string, args_1: string, ...args: unknown[]) => string> | undefined;
-    asyncCompilers?: Record<string, (args_0: string, args_1: string, ...args: unknown[]) => Promise<string>> | undefined;
+    compilers?: Record<string, ((args_0: string, args_1: string, ...args_2: unknown[]) => string) | ((args_0: string, args_1: string, ...args_2: unknown[]) => Promise<string>)> | undefined;
+    syncCompilers?: Record<string, (args_0: string, args_1: string, ...args_2: unknown[]) => string> | undefined;
+    asyncCompilers?: Record<string, (args_0: string, args_1: string, ...args_2: unknown[]) => Promise<string>> | undefined;
     astro?: string | boolean | string[] | {
         config?: string | string[] | undefined;
         entry?: string | string[] | undefined;

package/dist/compilers/index.d.ts

@@ -17,7 +17,7 @@ export declare const partitionCompilers: (rawLocalConfig: RawConfiguration) => {
     ignoreExportsUsedInFile?: boolean | Partial<Record<"function" | "type" | "enum" | "class" | "interface" | "member", boolean>> | undefined;
     ignoreWorkspaces?: string[] | undefined;
     includeEntryExports?: boolean | undefined;
-    compilers?: Record<string, ((args_0: string, args_1: string, ...args: unknown[]) => string) | ((args_0: string, args_1: string, ...args: unknown[]) => Promise<string>)> | undefined;
+    compilers?: Record<string, ((args_0: string, args_1: string, ...args_2: unknown[]) => string) | ((args_0: string, args_1: string, ...args_2: unknown[]) => Promise<string>)> | undefined;
     astro?: string | boolean | string[] | {
         config?: string | string[] | undefined;
         entry?: string | string[] | undefined;

package/dist/index.js

@@ -11,8 +11,8 @@ import { getCompilerExtensions, getIncludedCompilers } from './compilers/index.j
 import { getFilteredScripts } from './manifest/helpers.js';
 import { debugLog, debugLogArray, debugLogObject } from './util/debug.js';
 import { getOrCreateFileNode, updateImportMap } from './util/dependency-graph.js';
+import { getGitIgnoredHandler } from './util/glob-core.js';
 import { _glob, negate } from './util/glob.js';
-import { getGitIgnoredHandler } from './util/globby.js';
 import { getReferencedDependencyHandler } from './util/handle-dependency.js';
 import { getHasStrictlyNsReferences, getType } from './util/has-strictly-ns-references.js';
 import { getIsIdentifierReferencedHandler } from './util/is-identifier-referenced.js';

package/dist/util/{globby.d.ts → glob-core.d.ts}

@@ -9,6 +9,19 @@ type GlobOptions = {
     readonly dir: string;
 } & FastGlobOptionsWithoutCwd;
 type FastGlobOptionsWithoutCwd = Pick<FastGlobOptions, 'onlyDirectories' | 'ignore' | 'absolute' | 'dot'>;
+export declare const convertGitignoreToPicomatchIgnorePatterns: (pattern: string) => {
+    negated: boolean;
+    patterns: string[];
+};
+export declare const parseAndConvertGitignorePatterns: (patterns: string, ancestor?: string) => {
+    negated: boolean;
+    patterns: string[];
+}[];
+export declare const findAndParseGitignores: (cwd: string) => Promise<{
+    gitignoreFiles: string[];
+    ignores: Set<string>;
+    unignores: string[];
+}>;
 export declare function globby(patterns: string | string[], options: GlobOptions): Promise<string[]>;
 export declare function getGitIgnoredHandler(options: Options): Promise<(path: string) => boolean>;
 export {};

package/dist/util/glob-core.js

@@ -0,0 +1,192 @@
+import { readFileSync } from 'node:fs';
+import { promisify } from 'node:util';
+import { walk as _walk } from '@nodelib/fs.walk';
+import fg, {} from 'fast-glob';
+import picomatch from 'picomatch';
+import { GLOBAL_IGNORE_PATTERNS, ROOT_WORKSPACE_NAME } from '../constants.js';
+import { timerify } from './Performance.js';
+import { debugLogObject } from './debug.js';
+import { isFile } from './fs.js';
+import { dirname, join, relative, toPosix } from './path.js';
+const walk = promisify(_walk);
+const _picomatch = timerify(picomatch);
+const cachedIgnores = new Map();
+export const convertGitignoreToPicomatchIgnorePatterns = (pattern) => {
+    const negated = pattern[0] === '!';
+    if (negated)
+        pattern = pattern.slice(1);
+    let extPattern;
+    if (pattern.endsWith('/'))
+        pattern = pattern.slice(0, -1);
+    if (pattern.startsWith('*/**/'))
+        pattern = pattern.slice(5);
+    if (pattern.startsWith('/'))
+        pattern = pattern.slice(1);
+    else if (!pattern.startsWith('**/'))
+        pattern = `**/${pattern}`;
+    if (pattern.endsWith('/*'))
+        extPattern = pattern;
+    else
+        extPattern = `${pattern}/**`;
+    return { negated, patterns: [pattern, extPattern] };
+};
+export const parseAndConvertGitignorePatterns = (patterns, ancestor) => {
+    const matchFrom = ancestor ? new RegExp(`^(!?/?)(${ancestor})`) : undefined;
+    return patterns
+        .split(/\r?\n/)
+        .filter(line => line.trim() && !line.startsWith('#'))
+        .flatMap(line => {
+        const pattern = line.replace(/(?<!\\)#.*/, '').trim();
+        if (ancestor && matchFrom) {
+            if (pattern.match(matchFrom))
+                return [pattern.replace(matchFrom, '$1')];
+            if (pattern.startsWith('/**/'))
+                return [pattern.slice(1)];
+            if (pattern.startsWith('!/**/'))
+                return [`!${pattern.slice(2)}`];
+            if (pattern.startsWith('/') || pattern.startsWith('!/'))
+                return [];
+        }
+        return [pattern];
+    })
+        .map(pattern => convertGitignoreToPicomatchIgnorePatterns(pattern));
+};
+const findAncestorGitignoreFiles = (cwd) => {
+    const gitignorePaths = [];
+    let dir = dirname(cwd);
+    let prev;
+    while (dir) {
+        const filePath = join(dir, '.gitignore');
+        if (isFile(filePath))
+            gitignorePaths.push(filePath);
+        dir = dirname((prev = dir));
+        if (prev === dir || dir === '.')
+            break;
+    }
+    return gitignorePaths;
+};
+export const findAndParseGitignores = async (cwd) => {
+    const init = ['.git', ...GLOBAL_IGNORE_PATTERNS];
+    const ignores = new Set(init);
+    const unignores = [];
+    const gitignoreFiles = [];
+    const pmOptions = { ignore: unignores };
+    const matchers = new Set(init.map(pattern => _picomatch(pattern, pmOptions)));
+    const matcher = (str) => {
+        for (const isMatch of matchers) {
+            const state = isMatch(str);
+            if (state)
+                return state;
+        }
+        return false;
+    };
+    const addFile = (filePath) => {
+        gitignoreFiles.push(relative(cwd, filePath));
+        const dir = dirname(toPosix(filePath));
+        const base = relative(cwd, dir);
+        const ancestor = base.startsWith('..') ? `${relative(dir, cwd)}/` : undefined;
+        const dirIgnores = new Set(base === '' ? init : []);
+        const dirUnignores = new Set();
+        const patterns = readFileSync(filePath, 'utf8');
+        for (const rule of parseAndConvertGitignorePatterns(patterns, ancestor)) {
+            const [pattern1, pattern2] = rule.patterns;
+            if (rule.negated) {
+                if (base === '' || base.startsWith('..')) {
+                    if (!unignores.includes(pattern2)) {
+                        unignores.push(...rule.patterns);
+                        dirUnignores.add(pattern1);
+                        dirUnignores.add(pattern2);
+                    }
+                }
+                else {
+                    if (!unignores.includes(pattern2.startsWith('**/') ? pattern2 : `**/${pattern2}`)) {
+                        const unignore = join(base, pattern1);
+                        const extraUnignore = join(base, pattern2);
+                        unignores.push(unignore, extraUnignore);
+                        dirUnignores.add(unignore);
+                        dirUnignores.add(extraUnignore);
+                    }
+                }
+            }
+            else {
+                if (base === '' || base.startsWith('..')) {
+                    ignores.add(pattern1);
+                    ignores.add(pattern2);
+                    dirIgnores.add(pattern1);
+                    dirIgnores.add(pattern2);
+                }
+                else {
+                    const ignore = join(base, pattern1);
+                    const extraIgnore = join(base, pattern2);
+                    ignores.add(ignore);
+                    ignores.add(extraIgnore);
+                    dirIgnores.add(ignore);
+                    dirIgnores.add(extraIgnore);
+                }
+            }
+        }
+        const cacheDir = ancestor ? cwd : dir;
+        const cacheForDir = cachedIgnores.get(cwd);
+        if (ancestor && cacheForDir) {
+            for (const pattern of dirIgnores)
+                cacheForDir?.ignores.add(pattern);
+            cacheForDir.unignores = Array.from(new Set([...cacheForDir.unignores, ...dirUnignores]));
+        }
+        else {
+            cachedIgnores.set(cacheDir, { ignores: dirIgnores, unignores: Array.from(dirUnignores) });
+        }
+        for (const pattern of dirIgnores)
+            matchers.add(_picomatch(pattern, pmOptions));
+    };
+    findAncestorGitignoreFiles(cwd).forEach(addFile);
+    if (isFile('.git/info/exclude'))
+        addFile('.git/info/exclude');
+    const entryFilter = (entry) => {
+        if (entry.dirent.isFile() && entry.name === '.gitignore') {
+            addFile(entry.path);
+            return true;
+        }
+        return false;
+    };
+    const deepFilter = (entry) => !matcher(relative(cwd, entry.path));
+    await walk(cwd, {
+        entryFilter: timerify(entryFilter),
+        deepFilter: timerify(deepFilter),
+    });
+    debugLogObject('*', 'Parsed gitignore files', { gitignoreFiles, ignores, unignores });
+    return { gitignoreFiles, ignores, unignores };
+};
+const _parseFindGitignores = timerify(findAndParseGitignores);
+export async function globby(patterns, options) {
+    if (Array.isArray(patterns) && patterns.length === 0)
+        return [];
+    const ignore = options.gitignore && Array.isArray(options.ignore) ? [...options.ignore] : [];
+    if (options.gitignore) {
+        let dir = options.dir;
+        let prev;
+        while (dir) {
+            const cacheForDir = cachedIgnores.get(dir);
+            if (cacheForDir) {
+                ignore.push(...cacheForDir.ignores);
+            }
+            dir = dirname((prev = dir));
+            if (prev === dir || dir === '.')
+                break;
+        }
+    }
+    else {
+        ignore.push(...GLOBAL_IGNORE_PATTERNS);
+    }
+    const fgOptions = Object.assign(options, { ignore });
+    debugLogObject(relative(options.cwd, options.dir) || ROOT_WORKSPACE_NAME, 'Glob options', { patterns, ...fgOptions });
+    return fg.glob(patterns, fgOptions);
+}
+export async function getGitIgnoredHandler(options) {
+    cachedIgnores.clear();
+    if (options.gitignore === false)
+        return () => false;
+    const gitignore = await _parseFindGitignores(options.cwd);
+    const matcher = _picomatch(Array.from(gitignore.ignores), { ignore: gitignore.unignores });
+    const isGitIgnored = (filePath) => matcher(relative(options.cwd, filePath));
+    return timerify(isGitIgnored);
+}

package/dist/util/glob.js

@@ -2,7 +2,7 @@ import fg from 'fast-glob';
 import { GLOBAL_IGNORE_PATTERNS } from '../constants.js';
 import { timerify } from './Performance.js';
 import { compact } from './array.js';
-import { globby } from './globby.js';
+import { globby } from './glob-core.js';
 import { join, relative } from './path.js';
 const prependDirToPatterns = (cwd, dir, patterns) => {
     const relativePath = relative(cwd, dir);

package/dist/version.d.ts

@@ -1 +1 @@
-export declare const version = "5.29.2";
+export declare const version = "5.30.0";

package/dist/version.js

@@ -1 +1 @@
-export const version = '5.29.2';
+export const version = '5.30.0';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "knip",
-  "version": "5.29.2",
+  "version": "5.30.0",
   "description": "Find unused files, dependencies and exports in your TypeScript and JavaScript projects",
   "homepage": "https://knip.dev",
   "repository": {

package/dist/util/globby.js

@@ -1,139 +0,0 @@
-import { readFileSync } from 'node:fs';
-import { promisify } from 'node:util';
-import { walk as _walk } from '@nodelib/fs.walk';
-import fg, {} from 'fast-glob';
-import picomatch from 'picomatch';
-import { GLOBAL_IGNORE_PATTERNS, ROOT_WORKSPACE_NAME } from '../constants.js';
-import { timerify } from './Performance.js';
-import { debugLogObject } from './debug.js';
-import { isFile } from './fs.js';
-import { dirname, join, relative, toPosix, toRelative } from './path.js';
-const walk = promisify(_walk);
-const _picomatch = timerify(picomatch);
-const cachedIgnores = new Map();
-function convertGitignoreToPicomatch(pattern) {
-    const negated = pattern[0] === '!';
-    if (negated) {
-        pattern = pattern.slice(1);
-    }
-    let extPattern;
-    if (pattern.startsWith('*/**/'))
-        pattern = pattern.slice(5);
-    if (pattern.startsWith('/'))
-        pattern = pattern.slice(1);
-    else if (!pattern.startsWith('**/'))
-        pattern = `**/${pattern}`;
-    if (pattern.endsWith('/*'))
-        extPattern = pattern;
-    else if (pattern.endsWith('/'))
-        extPattern = `${pattern}**`;
-    else
-        extPattern = `${pattern}/**`;
-    return { negated, patterns: [pattern, extPattern] };
-}
-function parseGitignoreFile(filePath) {
-    const file = readFileSync(filePath, 'utf8');
-    return file
-        .split(/\r?\n/)
-        .filter(line => line.trim() && !line.startsWith('#'))
-        .map(pattern => convertGitignoreToPicomatch(pattern.replace(/(?<!\\)#.*/, '').trim()));
-}
-async function parseFindGitignores(options) {
-    const ignores = ['.git', ...GLOBAL_IGNORE_PATTERNS];
-    const unignores = [];
-    const gitignoreFiles = [];
-    const pmOptions = { ignore: unignores };
-    const matchers = ignores.map(ignore => _picomatch(ignore, pmOptions));
-    const matcher = (str) => {
-        for (const isMatch of matchers) {
-            const state = isMatch(str);
-            if (state)
-                return state;
-        }
-        return false;
-    };
-    const addFile = (filePath) => {
-        gitignoreFiles.push(toRelative(filePath));
-        const dir = dirname(toPosix(filePath));
-        const base = relative(options.cwd, dir);
-        const dirIgnores = base === '' ? ['.git', ...GLOBAL_IGNORE_PATTERNS] : [];
-        const dirUnignores = [];
-        for (const rule of parseGitignoreFile(filePath)) {
-            const [p, ext] = rule.patterns;
-            if (rule.negated) {
-                if (base === '') {
-                    if (!unignores.includes(ext))
-                        dirUnignores.push(...rule.patterns);
-                }
-                else {
-                    if (!unignores.includes(ext.startsWith('**/') ? ext : `**/${ext}`)) {
-                        dirUnignores.push(join(base, p), join(base, ext));
-                    }
-                }
-            }
-            else {
-                if (base === '') {
-                    if (!ignores.includes(ext))
-                        dirIgnores.push(...rule.patterns);
-                }
-                else {
-                    if (!ignores.includes(ext.startsWith('**/') ? ext : `**/${ext}`)) {
-                        dirIgnores.push(join(base, p), join(base, ext));
-                    }
-                }
-            }
-        }
-        ignores.push(...dirIgnores);
-        unignores.push(...dirUnignores);
-        cachedIgnores.set(dir, { ignores: dirIgnores, unignores: dirUnignores });
-        matchers.push(...dirIgnores.map(ignore => _picomatch(ignore, pmOptions)));
-    };
-    if (isFile('.git/info/exclude'))
-        addFile('.git/info/exclude');
-    const entryFilter = (entry) => {
-        if (entry.dirent.isFile() && entry.name === '.gitignore') {
-            addFile(entry.path);
-            return true;
-        }
-        return false;
-    };
-    const deepFilter = (entry) => !matcher(relative(options.cwd, entry.path));
-    await walk(options.cwd, {
-        entryFilter: timerify(entryFilter),
-        deepFilter: timerify(deepFilter),
-    });
-    debugLogObject('*', 'Parsed gitignore files', { gitignoreFiles, ignores, unignores });
-    return { ignores, unignores };
-}
-const _parseFindGitignores = timerify(parseFindGitignores);
-export async function globby(patterns, options) {
-    if (Array.isArray(patterns) && patterns.length === 0)
-        return [];
-    const ignore = options.gitignore && Array.isArray(options.ignore) ? [...options.ignore] : [];
-    if (options.gitignore) {
-        let dir = options.dir;
-        while (dir !== options.cwd) {
-            const i = cachedIgnores.get(dir);
-            if (i) {
-                ignore.push(...i.ignores);
-                ignore.push(...i.unignores.map(e => `!${e}`));
-            }
-            dir = dirname(dir);
-        }
-        const i = cachedIgnores.get(options.cwd);
-        if (i)
-            ignore.push(...i.ignores);
-    }
-    const { dir, ...fastGlobOptions } = { ...options, ignore };
-    debugLogObject(relative(options.cwd, options.dir) || ROOT_WORKSPACE_NAME, 'Glob options', { patterns, ...options });
-    return fg.glob(patterns, fastGlobOptions);
-}
-export async function getGitIgnoredHandler(options) {
-    cachedIgnores.clear();
-    if (options.gitignore === false)
-        return () => false;
-    const gitignore = await _parseFindGitignores(options);
-    const matcher = _picomatch(gitignore.ignores, { ignore: gitignore.unignores });
-    const isGitIgnored = (filePath) => matcher(relative(options.cwd, filePath));
-    return timerify(isGitIgnored);
-}