knip 6.32.2 → 6.33.0

package/dist/plugins/vitest/index.js

@@ -6,15 +6,16 @@ import { isAbsolute, isInternal, join, toAbsolute } from '../../util/path.js';
 import { hasDependency } from '../../util/plugin.js';
 import { getIndexHtmlEntries } from '../vite/helpers.js';
 import { getAliasInputs, getEnvSpecifier, getExternalReporters } from './helpers.js';
+import { createVitestMockVisitor } from './visitors/mock.js';
 const title = 'Vitest';
 const enablers = ['vitest', 'vite-plus'];
 const isEnabled = ({ dependencies }) => hasDependency(dependencies, enablers);
 const config = ['vitest.config.{js,mjs,ts,cjs,mts,cts}', 'vitest.{workspace,projects}.{js,mjs,ts,cjs,mts,cts,json}'];
 const mocks = ['**/__mocks__/**/*.?(c|m)[jt]s?(x)'];
-const entry = ['**/*.{bench,test,test-d,spec,spec-d}.?(c|m)[jt]s?(x)', ...mocks];
+const testEntry = ['**/*.{bench,test,test-d,spec,spec-d}.?(c|m)[jt]s?(x)'];
+const entry = [...testEntry, ...mocks];
 const benchmark = ['**/*.bench.?(c|m)[jt]s?(x)'];
 const findConfigDependencies = (localConfig, options, vitestRoot) => {
-    const { configFileDir: dir } = options;
     const testConfig = localConfig.test;
     if (!testConfig)
         return [];
@@ -24,7 +25,9 @@ const findConfigDependencies = (localConfig, options, vitestRoot) => {
             ? [toDeferResolve(env)]
             : [toDependency(getEnvSpecifier(env))]
         : [];
-    const reporters = getExternalReporters(testConfig.reporters);
+    const reporters = getExternalReporters(testConfig.reporters).map(specifier => isInternal(specifier) || isAbsolute(specifier)
+        ? { ...toDeferResolve(specifier), dir: vitestRoot }
+        : toDependency(specifier));
     const hasCoverage = testConfig.coverage && (testConfig.coverage.enabled !== false || testConfig.coverage.provider);
     const coverage = hasCoverage ? [`@vitest/coverage-${testConfig.coverage?.provider ?? 'v8'}`] : [];
     const setupFiles = [testConfig.setupFiles ?? []]
@@ -34,7 +37,9 @@ const findConfigDependencies = (localConfig, options, vitestRoot) => {
         ...toDeferResolve(specifier),
         dir: vitestRoot,
     }));
-    const globalSetup = [testConfig.globalSetup ?? []].flat().map(specifier => ({ ...toDeferResolve(specifier), dir }));
+    const globalSetup = [testConfig.globalSetup ?? []]
+        .flat()
+        .map(specifier => ({ ...toDeferResolve(specifier), dir: vitestRoot }));
     const workspaceDependencies = [];
     if (testConfig.workspace !== undefined) {
         for (const workspaceConfig of testConfig.workspace) {
@@ -51,7 +56,7 @@ const findConfigDependencies = (localConfig, options, vitestRoot) => {
     }
     return [
         ...environments,
-        ...reporters.map(id => toDependency(id)),
+        ...reporters,
         ...coverage.map(id => toDependency(id)),
         ...setupFiles,
         ...snapshotSerializers,
@@ -72,12 +77,14 @@ const getConfigs = async (localConfig) => {
             if (typeof config === 'function') {
                 for (const command of ['serve', 'build']) {
                     for (const mode of ['development', 'production']) {
-                        const cfg = await config({ command, mode, ssrBuild: undefined });
-                        configs.push(cfg);
-                        if (cfg.test?.projects) {
-                            for (const project of cfg.test.projects) {
-                                if (typeof project !== 'string') {
-                                    configs.push(project);
+                        for (const ssrBuild of command === 'build' ? [undefined, false, true] : [undefined]) {
+                            const cfg = await config({ command, mode, ssrBuild });
+                            configs.push(cfg);
+                            if (cfg.test?.projects) {
+                                for (const project of cfg.test.projects) {
+                                    if (typeof project !== 'string') {
+                                        configs.push(project);
+                                    }
                                 }
                             }
                         }
@@ -133,22 +140,23 @@ export const resolveConfig = async (localConfig, options) => {
             for (const entry of await getIndexHtmlEntries(viteRoot))
                 inputs.add(entry);
         }
-        const dir = toAbsolute(cfg.test?.root ?? '.', options.cwd);
+        const vitestRoot = toAbsolute(cfg.test?.root ?? '.', options.cwd);
+        const dir = cfg.test?.dir ? toAbsolute(cfg.test.dir, vitestRoot) : vitestRoot;
         if (cfg.test) {
             if (cfg.test?.include) {
                 for (const dependency of cfg.test.include)
                     dependency[0] !== '!' && inputs.add(toEntry(join(dir, dependency)));
-                if (!options.config.entry)
-                    for (const dependency of mocks)
-                        inputs.add(toEntry(join(dir, dependency)));
                 const benchmarkInclude = cfg.test.benchmark?.include ?? benchmark;
                 for (const dependency of benchmarkInclude)
                     dependency[0] !== '!' && inputs.add(toEntry(join(dir, dependency)));
             }
             else {
-                for (const dependency of options.config.entry ?? entry)
+                for (const dependency of options.config.entry ?? testEntry)
                     inputs.add(toEntry(join(dir, dependency)));
             }
+            if (!options.config.entry)
+                for (const dependency of mocks)
+                    inputs.add(toEntry(join(vitestRoot, dependency)));
             if (cfg.test.alias)
                 addAliases(cfg.test.alias);
         }
@@ -174,12 +182,11 @@ export const resolveConfig = async (localConfig, options) => {
                 inputs.add(toEntry(`src/**/*${ext}`));
             }
         }
-        for (const dependency of findConfigDependencies(cfg, options, dir))
+        for (const dependency of findConfigDependencies(cfg, options, vitestRoot))
             inputs.add(dependency);
         const _entry = cfg.build?.lib?.entry ?? [];
-        const deps = (typeof _entry === 'string' ? [_entry] : Object.values(_entry))
-            .map(specifier => join(dir, specifier))
-            .map(id => toEntry(id));
+        const entries = typeof _entry === 'string' ? [_entry] : Array.isArray(_entry) ? _entry : Object.values(_entry).flat();
+        const deps = entries.map(specifier => join(vitestRoot, specifier)).map(id => toEntry(id));
         for (const dependency of deps)
             inputs.add(dependency);
     }
@@ -211,6 +218,9 @@ const args = {
         return inputs;
     },
 };
+const registerVisitors = ({ ctx, registerVisitor }) => {
+    registerVisitor(createVitestMockVisitor(ctx));
+};
 const plugin = {
     title,
     enablers,
@@ -219,5 +229,6 @@ const plugin = {
     entry,
     resolveConfig,
     args,
+    registerVisitors,
 };
 export default plugin;

package/dist/plugins/vitest/types.d.ts

@@ -17,6 +17,7 @@ interface VitestConfig {
             provider: string;
         };
         root?: string;
+        dir?: string;
         environment?: string;
         globalSetup?: string | string[];
         reporters?: (string | [string, unknown] | unknown)[];
@@ -42,7 +43,7 @@ export interface ViteConfig extends VitestConfig {
     build?: {
         lib?: {
             entry: string | string[] | {
-                [entryAlias: string]: string;
+                [entryAlias: string]: string | string[];
             };
         };
     };

package/dist/plugins/vitest/visitors/mock.d.ts

@@ -0,0 +1,2 @@
+import type { PluginVisitorContext, PluginVisitorObject } from '../../../types/config.ts';
+export declare function createVitestMockVisitor(ctx: PluginVisitorContext): PluginVisitorObject;

package/dist/plugins/vitest/visitors/mock.js

@@ -0,0 +1,50 @@
+import { IMPORT_FLAGS } from '../../../constants.js';
+import { getStringValue, isStringLiteral } from '../../../typescript/ast-nodes.js';
+import { isShadowed } from '../../../typescript/visitors/walk.js';
+export function createVitestMockVisitor(ctx) {
+    const viNames = new Set();
+    return {
+        Program(node) {
+            viNames.clear();
+            for (const statement of node.body) {
+                if (statement.type !== 'ImportDeclaration' ||
+                    !isStringLiteral(statement.source) ||
+                    getStringValue(statement.source) !== 'vitest')
+                    continue;
+                for (const specifier of statement.specifiers ?? []) {
+                    if (specifier.type === 'ImportSpecifier' &&
+                        specifier.imported.type === 'Identifier' &&
+                        specifier.imported.name === 'vi') {
+                        viNames.add(specifier.local.name);
+                    }
+                }
+            }
+        },
+        CallExpression(node) {
+            const argument = node.arguments[0];
+            const factory = node.arguments[1];
+            const factoryBody = factory?.type === 'ArrowFunctionExpression' &&
+                factory.body.type === 'ParenthesizedExpression' &&
+                factory.body.expression.type === 'ObjectExpression'
+                ? factory.body.expression
+                : undefined;
+            if (argument?.type !== 'ImportExpression' ||
+                !isStringLiteral(argument.source) ||
+                factory?.type !== 'ArrowFunctionExpression' ||
+                !factoryBody ||
+                factory.async ||
+                factory.params.length > 0 ||
+                factoryBody.properties.some(property => property.type === 'SpreadElement') ||
+                node.callee.type !== 'MemberExpression' ||
+                node.callee.computed ||
+                node.callee.object.type !== 'Identifier' ||
+                !viNames.has(node.callee.object.name) ||
+                isShadowed(node.callee.object.name, node.callee.object.start) ||
+                node.callee.property.type !== 'Identifier' ||
+                node.callee.property.name !== 'mock')
+                return;
+            ctx.markImportExpressionHandled(argument.start);
+            ctx.addImport(getStringValue(argument.source), argument.source.start, IMPORT_FLAGS.SIDE_EFFECTS);
+        },
+    };
+}

package/dist/plugins/webdriver-io/index.js

@@ -3,7 +3,7 @@ import { hasDependency } from '../../util/plugin.js';
 const title = 'WebdriverIO';
 const enablers = ['@wdio/cli'];
 const isEnabled = ({ dependencies }) => hasDependency(dependencies, enablers);
-const config = ['wdio.conf.{js,ts}'];
+const config = ['wdio.conf.{js,cjs,mjs,ts,cts,mts}'];
 const resolveConfig = async (config) => {
     const cfg = config?.config;
     if (!cfg)

package/dist/plugins/webpack/index.js

@@ -105,20 +105,21 @@ export const findWebpackDependenciesFromConfig = async (config, options) => {
                     }
                 }
             }
-            if (typeof opts.entry === 'string')
-                entries.push(opts.entry);
-            else if (Array.isArray(opts.entry))
-                entries.push(...opts.entry);
-            else if (typeof opts.entry === 'object') {
-                for (const entry of Object.values(opts.entry)) {
-                    if (typeof entry === 'string')
-                        entries.push(entry);
-                    else if (Array.isArray(entry))
-                        entries.push(...entry);
-                    else if (typeof entry === 'function')
-                        entries.push(entry());
-                    else if (entry && typeof entry === 'object' && 'filename' in entry)
-                        entries.push(entry['filename']);
+            const entry = typeof opts.entry === 'function' ? await opts.entry() : opts.entry;
+            if (typeof entry === 'string')
+                entries.push(entry);
+            else if (Array.isArray(entry))
+                entries.push(...entry);
+            else if (typeof entry === 'object') {
+                for (const item of Object.values(entry)) {
+                    if (typeof item === 'string')
+                        entries.push(item);
+                    else if (Array.isArray(item))
+                        entries.push(...item);
+                    else if (typeof item === 'function')
+                        entries.push(item());
+                    else if (item && typeof item === 'object' && 'import' in item)
+                        entries.push(...[item.import].flat());
                 }
             }
             if (entries.length === 0 && opts.context)

package/dist/types/config.d.ts

@@ -138,6 +138,7 @@ export type PluginVisitorContext = {
     sourceText: string;
     addScript: (script: string) => void;
     addImport: (specifier: string, pos: number, modifiers: number) => void;
+    markImportExpressionHandled: (pos: number) => void;
     addImportGlob: (patterns: string[], options?: {
         base?: string;
         filter?: RegExp;

package/dist/types/tsconfig-json.d.ts

@@ -8,7 +8,13 @@ export interface TsConfigJson {
         }>;
         [key: string]: unknown;
     };
+    contentMappers?: {
+        package: string;
+    }[];
     references?: Array<{
         path: string;
     }>;
 }
+export interface ContentMapperManifest {
+    exec?: string[];
+}

package/dist/typescript/get-imports-and-exports.js

@@ -25,6 +25,7 @@ const getImportsAndExports = (filePath, sourceText, resolveModule, options, igno
     const specifierExportNames = new Set();
     const scripts = new Set();
     const importGlobs = [];
+    const handledImportExpressions = new Set();
     const importAliases = new Map();
     const addImportAlias = (aliasName, id, importFilePath) => {
         const aliases = importAliases.get(aliasName);
@@ -278,6 +279,7 @@ const getImportsAndExports = (filePath, sourceText, resolveModule, options, igno
         pluginCtx.sourceText = sourceText;
         pluginCtx.addScript = (s) => scripts.add(s);
         pluginCtx.addImport = (spec, pos, mod) => addImport(spec, undefined, undefined, undefined, pos, mod);
+        pluginCtx.markImportExpressionHandled = (pos) => handledImportExpressions.add(pos);
         pluginCtx.addImportGlob = (patterns, opts) => importGlobs.push({ patterns, base: opts?.base, filter: opts?.filter });
         pluginCtx.markExportRegistered = (name) => registeredCustomElements.add(name);
     }
@@ -311,6 +313,7 @@ const getImportsAndExports = (filePath, sourceText, resolveModule, options, igno
         resolveModule,
         programFiles,
         entryFiles,
+        handledImportExpressions,
         visitor,
         getJSDocTags,
     });

package/dist/typescript/visitors/calls.js

@@ -202,7 +202,7 @@ export function handleCallExpression(node, s) {
                             addValue(internalImport.import, OPAQUE, s.filePath);
                         else {
                             internalImport.refs.add(arg.name);
-                            (internalImport.enumerated ??= new Set()).add(arg.name);
+                            (internalImport.enumerated ??= new Set()).add(_import.importedName);
                         }
                     }
                 }

package/dist/typescript/visitors/members.js

@@ -2,6 +2,12 @@ import { OPAQUE } from '../../constants.js';
 import { addValue } from '../../util/module-graph.js';
 import { getStringValue, isStringLiteral } from '../ast-nodes.js';
 import { isShadowed } from './walk.js';
+function markWholeObjectRead(internalImport, id) {
+    (internalImport.enumerated ??= new Set()).add(id);
+}
+function isNumericKey(value) {
+    return value != null && Number.isFinite(Number(value)) && String(Number(value)) === value;
+}
 export function handleMemberExpression(node, s) {
     if (node.object.type === 'MemberExpression' && node.object.object.type === 'MemberExpression') {
         s.chainedMemberExprs.add(node.object);
@@ -18,12 +24,21 @@ export function handleMemberExpression(node, s) {
                     memberName = node.property.name;
                 }
                 else if (node.computed && isStringLiteral(node.property)) {
-                    memberName = getStringValue(node.property);
+                    const value = getStringValue(node.property);
+                    if (!_import.isNamespace && isNumericKey(value)) {
+                        markWholeObjectRead(internalImport, _import.importedName);
+                        return;
+                    }
+                    memberName = value;
                 }
                 else if (node.computed && _import.isNamespace) {
                     addValue(internalImport.import, OPAQUE, s.filePath);
                     return;
                 }
+                else if (node.computed) {
+                    markWholeObjectRead(internalImport, _import.importedName);
+                    return;
+                }
                 if (memberName) {
                     if (_import.isDynamicImport) {
                         addValue(internalImport.import, memberName, s.filePath);
@@ -44,18 +59,51 @@ export function handleMemberExpression(node, s) {
         if (aliases) {
             s.accessedAliases.add(localName);
             let memberName;
+            let isWholeRead = false;
             if (node.computed === false && node.property.type === 'Identifier') {
                 memberName = node.property.name;
             }
             else if (node.computed && isStringLiteral(node.property)) {
-                memberName = getStringValue(node.property);
+                const value = getStringValue(node.property);
+                if (isNumericKey(value))
+                    isWholeRead = true;
+                else
+                    memberName = value;
             }
-            if (memberName) {
-                for (const alias of aliases) {
-                    const internalImport = s.internal.get(alias.filePath);
-                    if (internalImport) {
-                        s.addNsMemberRefs(internalImport, alias.id, memberName);
-                    }
+            else if (node.computed) {
+                isWholeRead = true;
+            }
+            for (const alias of aliases) {
+                const internalImport = s.internal.get(alias.filePath);
+                if (!internalImport)
+                    continue;
+                if (isWholeRead) {
+                    const origin = s.localImportMap.get(alias.id);
+                    markWholeObjectRead(internalImport, origin?.importedName ?? alias.id);
+                }
+                else if (memberName) {
+                    s.addNsMemberRefs(internalImport, alias.id, memberName);
+                }
+            }
+        }
+    }
+    if (node.computed &&
+        node.object.type === 'MemberExpression' &&
+        !node.object.computed &&
+        node.object.object.type === 'Identifier' &&
+        node.object.property.type === 'Identifier') {
+        const rootName = node.object.object.name;
+        if (!isShadowed(rootName, node.object.object.start)) {
+            const _import = s.localImportMap.get(rootName);
+            if (_import?.isNamespace) {
+                const internalImport = s.internal.get(_import.filePath);
+                if (internalImport) {
+                    const mid = node.object.property.name;
+                    const value = isStringLiteral(node.property) ? getStringValue(node.property) : undefined;
+                    if (value !== undefined && !isNumericKey(value))
+                        s.addNsMemberRefs(internalImport, rootName, `${mid}.${value}`);
+                    else
+                        markWholeObjectRead(internalImport, mid);
                 }
             }
         }

package/dist/typescript/visitors/walk.d.ts

@@ -43,6 +43,7 @@ interface WalkContext {
     resolveModule: ResolveModule;
     programFiles: Set<string>;
     entryFiles: Set<string>;
+    handledImportExpressions: Set<number>;
     visitor: Visitor;
     getJSDocTags: (nodeStart: number) => Set<string>;
 }

package/dist/typescript/visitors/walk.js

@@ -726,7 +726,6 @@ function walkAST(program, sourceText, filePath, hasModuleSyntax, ctx) {
         sourceText,
         isJS,
         isModuleFile: isExternalModule(program, hasModuleSyntax),
-        handledImportExpressions: new Set(),
         bareExprRefs: new Set(),
         accessedAliases: new Set(),
         nsContainers: new Map(),

package/dist/util/glob-core.js

@@ -91,9 +91,14 @@ export const findAndParseGitignores = async (cwd, workspaceDirs) => {
         }
         return deepFilterMatcher;
     };
+    const seenGitignoreFiles = new Set();
     const addFile = (filePath, baseDir) => {
+        const absPath = toPosix(filePath);
+        if (seenGitignoreFiles.has(absPath))
+            return;
+        seenGitignoreFiles.add(absPath);
         gitignoreFiles.push(relative(cwd, filePath));
-        const dir = baseDir ?? dirname(toPosix(filePath));
+        const dir = baseDir ?? dirname(absPath);
         const base = relative(cwd, dir);
         const ancestor = base.startsWith('..') ? `${relative(dir, cwd)}/` : undefined;
         const ignoresForDir = new Set(base === '' ? GLOBAL_IGNORE_PATTERNS : []);
@@ -154,6 +159,9 @@ export const findAndParseGitignores = async (cwd, workspaceDirs) => {
         if (isFile(excludePath))
             addFile(excludePath, cwd);
     }
+    const rootGitignorePath = join(cwd, '.gitignore');
+    if (isFile(rootGitignorePath))
+        addFile(rootGitignorePath);
     let isRelevantDir;
     if (workspaceDirs && workspaceDirs.size > 0) {
         const relevantAncestors = new Set();

package/dist/util/load-config.js

@@ -13,12 +13,17 @@ const unwrapFunction = async (maybeFunction, options) => {
     }
     return maybeFunction;
 };
+const isObject = (value) => typeof value === 'object' && value !== null && !Array.isArray(value);
 export async function loadResolvedConfigFile(configPath, options) {
     const loadedValue = await _load(configPath);
+    let config;
     try {
-        return await unwrapFunction(loadedValue, options);
+        config = await unwrapFunction(loadedValue, options);
     }
     catch (_error) {
         throw new ConfigurationError(`Error running the function from ${configPath}`);
     }
+    if (!isObject(config))
+        throw new ConfigurationError(`Expected an object as configuration from ${configPath}`);
+    return config;
 }

package/dist/util/resolve.d.ts

@@ -1,4 +1,5 @@
 export declare const extensionAlias: Record<string, string[]>;
+export declare const resolvePackageManifestPath: (packageName: string, baseDir: string) => string | undefined;
 export declare const _resolveModuleSync: (specifier: string, basePath: string) => string | undefined;
 declare const resolveDeclarationSync: (specifier: string, containingFile: string) => {
     path: string;

package/dist/util/resolve.js

@@ -23,6 +23,17 @@ const declarationResolver = new ResolverFactory({
     nodePath: false,
 });
 resolverInstances.push(declarationResolver);
+const packageManifestResolver = new ResolverFactory({
+    extensions: ['.json'],
+    exportsFields: [],
+    nodePath: false,
+});
+resolverInstances.push(packageManifestResolver);
+export const resolvePackageManifestPath = (packageName, baseDir) => {
+    const resolved = packageManifestResolver.sync(baseDir, `${packageName}/package.json`);
+    if (resolved.path)
+        return toPosix(resolved.path);
+};
 const createSyncModuleResolver = (extensions, tsConfigFile) => {
     const baseOptions = {
         extensions,

package/dist/util/scripts.d.ts

@@ -3,5 +3,6 @@ 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 getScriptCommands: (script: string) => ScriptCommand[];

package/dist/util/scripts.js

@@ -1,6 +1,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 function* walkCommands(node) {
     switch (node.type) {
         case 'Command':

package/dist/version.d.ts

@@ -1 +1 @@
-export declare const version = "6.32.2";
+export declare const version = "6.33.0";

package/dist/version.js

@@ -1 +1 @@
-export const version = '6.32.2';
+export const version = '6.33.0';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "knip",
-  "version": "6.32.2",
+  "version": "6.33.0",
   "description": "Find and fix unused dependencies, exports and files in your TypeScript and JavaScript projects",
   "keywords": [
     "analysis",
@@ -71,6 +71,10 @@
       "types": "./dist/types.d.ts",
       "default": "./dist/index.js"
     },
+    "./config": {
+      "types": "./dist/config.d.ts",
+      "default": "./dist/config.js"
+    },
     "./session": {
       "types": "./dist/session/index.d.ts",
       "default": "./dist/session/index.js"
@@ -78,27 +82,27 @@
   },
   "dependencies": {
     "fdir": "^6.5.0",
-    "formatly": "^0.3.0",
-    "get-tsconfig": "4.14.1",
+    "formatly": "^0.7.0",
+    "get-tsconfig": "4.14.3",
     "jiti": "^2.7.0",
-    "oxc-parser": "^0.143.0",
+    "oxc-parser": "^0.147.0",
     "oxc-resolver": "11.24.2",
-    "picomatch": "^4.0.5",
-    "smol-toml": "^1.7.1",
+    "picomatch": "^4.0.7",
+    "smol-toml": "^1.8.0",
     "strip-json-comments": "5.0.3",
     "tinyglobby": "^0.2.17",
-    "unbash": "^4.0.9",
+    "unbash": "^4.0.10",
     "yaml": "^2.9.0",
     "zod": "^4.4.3"
   },
   "devDependencies": {
     "@jest/types": "^30.4.1",
-    "@types/bun": "^1.3.14",
+    "@types/bun": "^1.4.0",
     "@types/picomatch": "^4.0.3",
     "@types/webpack": "^5.28.5",
     "codeclimate-types": "^0.3.1",
     "prettier": "^3.9.6",
-    "tsx": "^4.23.11",
+    "tsx": "^4.23.12",
     "typescript": "7.0.2"
   },
   "engines": {