knip 2.40.2 → 2.41.1

package/README.md

@@ -304,6 +304,7 @@ Knip contains a growing list of plugins:
 - [Stylelint][plugin-stylelint]
 - [Svelte][plugin-svelte]
 - [Tailwind][plugin-tailwind]
+- [tsup][plugin-tsup]
 - [TypeDoc][plugin-typedoc]
 - [TypeScript][plugin-typescript]
 - [Vite][plugin-vite]
@@ -956,6 +957,7 @@ Special thanks to the wonderful people who have contributed to this project:
 [plugin-stylelint]: ./src/plugins/stylelint
 [plugin-svelte]: ./src/plugins/svelte
 [plugin-tailwind]: ./src/plugins/tailwind
+[plugin-tsup]: ./src/plugins/tsup
 [plugin-typedoc]: ./src/plugins/typedoc
 [plugin-typescript]: ./src/plugins/typescript
 [plugin-vite]: ./src/plugins/vite

package/dist/ConfigurationValidator.d.ts

@@ -528,6 +528,19 @@ export declare const ConfigurationValidator: z.ZodObject<{
             entry?: string | string[] | undefined;
             project?: string | string[] | undefined;
         }>]>>;
+        tsup: z.ZodOptional<z.ZodUnion<[z.ZodBoolean, z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">]>, z.ZodObject<{
+            config: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">]>>;
+            entry: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">]>>;
+            project: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">]>>;
+        }, "strip", z.ZodTypeAny, {
+            config?: string | string[] | undefined;
+            entry?: string | string[] | undefined;
+            project?: string | string[] | undefined;
+        }, {
+            config?: string | string[] | undefined;
+            entry?: string | string[] | undefined;
+            project?: string | string[] | undefined;
+        }>]>>;
         typedoc: z.ZodOptional<z.ZodUnion<[z.ZodBoolean, z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">]>, z.ZodObject<{
             config: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">]>>;
             entry: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">]>>;
@@ -790,6 +803,11 @@ export declare const ConfigurationValidator: z.ZodObject<{
             entry?: string | string[] | undefined;
             project?: string | string[] | undefined;
         } | undefined;
+        tsup?: string | boolean | string[] | {
+            config?: string | string[] | undefined;
+            entry?: string | string[] | undefined;
+            project?: string | string[] | undefined;
+        } | undefined;
         typedoc?: string | boolean | string[] | {
             config?: string | string[] | undefined;
             entry?: string | string[] | undefined;
@@ -1012,6 +1030,11 @@ export declare const ConfigurationValidator: z.ZodObject<{
             entry?: string | string[] | undefined;
             project?: string | string[] | undefined;
         } | undefined;
+        tsup?: string | boolean | string[] | {
+            config?: string | string[] | undefined;
+            entry?: string | string[] | undefined;
+            project?: string | string[] | undefined;
+        } | undefined;
         typedoc?: string | boolean | string[] | {
             config?: string | string[] | undefined;
             entry?: string | string[] | undefined;
@@ -1532,6 +1555,19 @@ export declare const ConfigurationValidator: z.ZodObject<{
         entry?: string | string[] | undefined;
         project?: string | string[] | undefined;
     }>]>>;
+    tsup: z.ZodOptional<z.ZodUnion<[z.ZodBoolean, z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">]>, z.ZodObject<{
+        config: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">]>>;
+        entry: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">]>>;
+        project: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">]>>;
+    }, "strip", z.ZodTypeAny, {
+        config?: string | string[] | undefined;
+        entry?: string | string[] | undefined;
+        project?: string | string[] | undefined;
+    }, {
+        config?: string | string[] | undefined;
+        entry?: string | string[] | undefined;
+        project?: string | string[] | undefined;
+    }>]>>;
     typedoc: z.ZodOptional<z.ZodUnion<[z.ZodBoolean, z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">]>, z.ZodObject<{
         config: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">]>>;
         entry: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">]>>;
@@ -1809,6 +1845,11 @@ export declare const ConfigurationValidator: z.ZodObject<{
             entry?: string | string[] | undefined;
             project?: string | string[] | undefined;
         } | undefined;
+        tsup?: string | boolean | string[] | {
+            config?: string | string[] | undefined;
+            entry?: string | string[] | undefined;
+            project?: string | string[] | undefined;
+        } | undefined;
         typedoc?: string | boolean | string[] | {
             config?: string | string[] | undefined;
             entry?: string | string[] | undefined;
@@ -2025,6 +2066,11 @@ export declare const ConfigurationValidator: z.ZodObject<{
         entry?: string | string[] | undefined;
         project?: string | string[] | undefined;
     } | undefined;
+    tsup?: string | boolean | string[] | {
+        config?: string | string[] | undefined;
+        entry?: string | string[] | undefined;
+        project?: string | string[] | undefined;
+    } | undefined;
     typedoc?: string | boolean | string[] | {
         config?: string | string[] | undefined;
         entry?: string | string[] | undefined;
@@ -2262,6 +2308,11 @@ export declare const ConfigurationValidator: z.ZodObject<{
             entry?: string | string[] | undefined;
             project?: string | string[] | undefined;
         } | undefined;
+        tsup?: string | boolean | string[] | {
+            config?: string | string[] | undefined;
+            entry?: string | string[] | undefined;
+            project?: string | string[] | undefined;
+        } | undefined;
         typedoc?: string | boolean | string[] | {
             config?: string | string[] | undefined;
             entry?: string | string[] | undefined;
@@ -2478,6 +2529,11 @@ export declare const ConfigurationValidator: z.ZodObject<{
         entry?: string | string[] | undefined;
         project?: string | string[] | undefined;
     } | undefined;
+    tsup?: string | boolean | string[] | {
+        config?: string | string[] | undefined;
+        entry?: string | string[] | undefined;
+        project?: string | string[] | undefined;
+    } | undefined;
     typedoc?: string | boolean | string[] | {
         config?: string | string[] | undefined;
         entry?: string | string[] | undefined;

package/dist/ConfigurationValidator.js

@@ -98,6 +98,7 @@ const pluginsSchema = z.object({
     stryker: pluginSchema,
     stylelint: pluginSchema,
     tailwind: pluginSchema,
+    tsup: pluginSchema,
     typedoc: pluginSchema,
     typescript: pluginSchema,
     vite: pluginSchema,

package/dist/PrincipalFactory.d.ts

@@ -1,6 +1,7 @@
 import ts from 'typescript';
 import { ProjectPrincipal } from './ProjectPrincipal.js';
 import type { SyncCompilers, AsyncCompilers } from './types/compilers.js';
+import type { GlobbyFilterFunction } from 'globby';
 type Paths = ts.CompilerOptions['paths'];
 type Principal = {
     principal: ProjectPrincipal;
@@ -9,16 +10,17 @@ type Principal = {
     pkgNames: Set<string>;
 };
 type Principals = Set<Principal>;
-type Options = {
+export type PrincipalOptions = {
     cwd: string;
     compilerOptions: ts.CompilerOptions;
     paths: Paths;
     compilers: [SyncCompilers, AsyncCompilers];
     pkgName: string;
+    isGitIgnored: GlobbyFilterFunction;
 };
 export declare class PrincipalFactory {
     principals: Principals;
-    getPrincipal(options: Options): ProjectPrincipal;
+    getPrincipal(options: PrincipalOptions): ProjectPrincipal;
     private findReusablePrincipal;
     private linkPrincipal;
     private addNewPrincipal;

package/dist/PrincipalFactory.js

@@ -1,12 +1,16 @@
 import ts from 'typescript';
 import { ProjectPrincipal } from './ProjectPrincipal.js';
 import { toAbsolute } from './util/path.js';
+const mapToAbsolutePaths = (paths, cwd) => Object.keys(paths).reduce((result, key) => {
+    result[key] = paths[key].map(entry => toAbsolute(entry, cwd));
+    return result;
+}, {});
 const mergePaths = (cwd, compilerOptions, paths = {}) => {
-    const overridePaths = Object.keys(paths).reduce((overridePaths, key) => {
-        overridePaths[key] = paths[key].map(entry => toAbsolute(entry, cwd));
-        return overridePaths;
-    }, {});
-    compilerOptions.paths = { ...compilerOptions.paths, ...overridePaths };
+    const compilerPaths = !compilerOptions.baseUrl && compilerOptions.paths
+        ? mapToAbsolutePaths(compilerOptions.paths, cwd)
+        : compilerOptions.paths;
+    const extraPaths = mapToAbsolutePaths(paths, cwd);
+    compilerOptions.paths = { ...compilerPaths, ...extraPaths };
     return compilerOptions;
 };
 export class PrincipalFactory {

package/dist/ProjectPrincipal.d.ts

@@ -1,19 +1,15 @@
-import { isGitIgnoredSync } from 'globby';
 import ts from 'typescript';
 import { createCustomModuleResolver } from './typescript/resolveModuleNames.js';
 import { SourceFileManager } from './typescript/SourceFileManager.js';
+import type { PrincipalOptions } from './PrincipalFactory.js';
 import type { SyncCompilers, AsyncCompilers } from './types/compilers.js';
 import type { ExportItem, ExportItemMember } from './types/exports.js';
-type ProjectPrincipalOptions = {
-    compilerOptions: ts.CompilerOptions;
-    cwd: string;
-    compilers: [SyncCompilers, AsyncCompilers];
-};
+import type { GlobbyFilterFunction } from 'globby';
 export declare class ProjectPrincipal {
     entryPaths: Set<string>;
     projectPaths: Set<string>;
     skipExportsAnalysis: Set<string>;
-    isGitIgnored: ReturnType<typeof isGitIgnoredSync>;
+    isGitIgnored: GlobbyFilterFunction;
     cwd: string;
     compilerOptions: ts.CompilerOptions;
     extensions: Set<string>;
@@ -26,7 +22,7 @@ export declare class ProjectPrincipal {
         lsFindReferences: ts.LanguageService['findReferences'];
         program?: ts.Program;
     };
-    constructor({ compilerOptions, cwd, compilers }: ProjectPrincipalOptions);
+    constructor({ compilerOptions, cwd, compilers, isGitIgnored }: PrincipalOptions);
     private createProgram;
     private hasAcceptedExtension;
     addEntryPath(filePath: string, options?: {
@@ -67,4 +63,3 @@ export declare class ProjectPrincipal {
         col: number;
     };
 }
-export {};

package/dist/ProjectPrincipal.js

@@ -1,4 +1,3 @@
-import { isGitIgnoredSync } from 'globby';
 import ts from 'typescript';
 import { DEFAULT_EXTENSIONS } from './constants.js';
 import { IGNORED_FILE_EXTENSIONS } from './constants.js';
@@ -35,9 +34,9 @@ export class ProjectPrincipal {
     syncCompilers;
     asyncCompilers;
     backend;
-    constructor({ compilerOptions, cwd, compilers }) {
+    constructor({ compilerOptions, cwd, compilers, isGitIgnored }) {
         this.cwd = cwd;
-        this.isGitIgnored = isGitIgnoredSync({ cwd });
+        this.isGitIgnored = isGitIgnored;
         this.compilerOptions = {
             ...compilerOptions,
             ...baseCompilerOptions,
@@ -126,7 +125,9 @@ export class ProjectPrincipal {
                     external.add(sanitizedSpecifier);
                 }
                 else {
-                    this.addEntryPath(resolvedModule.resolvedFileName, { skipExportsAnalysis: true });
+                    const isIgnored = this.isGitIgnored(resolvedModule.resolvedFileName);
+                    if (!isIgnored)
+                        this.addEntryPath(resolvedModule.resolvedFileName, { skipExportsAnalysis: true });
                 }
             }
             else {

package/dist/WorkspaceWorker.d.ts

@@ -52,7 +52,7 @@ export declare class WorkspaceWorker {
         installedBinaries: InstalledBinaries;
         referencedDependencies: ReferencedDependencies;
         hasTypesIncluded: Set<string>;
-        enabledPlugins: ("astro" | "angular" | "ava" | "babel" | "capacitor" | "changesets" | "commitizen" | "commitlint" | "cspell" | "cypress" | "eslint" | "gatsby" | "husky" | "jest" | "lefthook" | "markdownlint" | "mocha" | "next" | "nx" | "nyc" | "playwright" | "postcss" | "prettier" | "remark" | "remix" | "rollup" | "sentry" | "storybook" | "stryker" | "stylelint" | "tailwind" | "typedoc" | "typescript" | "vite" | "vitest" | "webpack" | "drizzle" | "githubActions" | "graphqlCodegen" | "lintStaged" | "nodeTestRunner" | "npmPackageJsonLint" | "playwrightCt" | "releaseIt" | "semanticRelease" | "svelte")[];
+        enabledPlugins: ("astro" | "angular" | "ava" | "babel" | "capacitor" | "changesets" | "commitizen" | "commitlint" | "cspell" | "cypress" | "eslint" | "gatsby" | "husky" | "jest" | "lefthook" | "markdownlint" | "mocha" | "next" | "nx" | "nyc" | "playwright" | "postcss" | "prettier" | "remark" | "remix" | "rollup" | "sentry" | "storybook" | "stryker" | "stylelint" | "tailwind" | "tsup" | "typedoc" | "typescript" | "vite" | "vitest" | "webpack" | "drizzle" | "githubActions" | "graphqlCodegen" | "lintStaged" | "nodeTestRunner" | "npmPackageJsonLint" | "playwrightCt" | "releaseIt" | "semanticRelease" | "svelte")[];
         entryFilePatterns: string[];
         productionEntryFilePatterns: string[];
     }>;

package/dist/binaries/resolvers/fallback.js

@@ -12,7 +12,6 @@ const argFilters = {
     execa: withPositional,
     'ts-node': withPositional,
     zx: withPositional,
-    tsx: parsed => parsed._.filter(p => p !== 'watch'),
     default: withoutPositional,
 };
 const spawningBinaries = ['cross-env', 'retry-cli'];

package/dist/binaries/resolvers/index.d.ts

@@ -6,4 +6,5 @@ export * as npx from './npx.js';
 export * as nx from './nx.js';
 export * as pnpm from './pnpm.js';
 export * as rollup from './rollup.js';
+export * as tsx from './tsx.js';
 export * as yarn from './yarn.js';

package/dist/binaries/resolvers/index.js

@@ -6,4 +6,5 @@ export * as npx from './npx.js';
 export * as nx from './nx.js';
 export * as pnpm from './pnpm.js';
 export * as rollup from './rollup.js';
+export * as tsx from './tsx.js';
 export * as yarn from './yarn.js';

package/dist/binaries/resolvers/node.js

@@ -4,7 +4,7 @@ import { tryResolveFilePath, tryResolveSpecifiers } from '../util.js';
 export const resolve = (binary, args, { cwd }) => {
     const parsed = parseArgs(args, {
         string: ['r'],
-        alias: { require: ['r', 'loader', 'experimental-loader', 'test-reporter'] },
+        alias: { require: ['r', 'loader', 'experimental-loader', 'test-reporter', 'watch'] },
     });
     return compact([tryResolveFilePath(cwd, parsed._[0]), ...tryResolveSpecifiers(cwd, [parsed.require].flat())]);
 };

package/dist/binaries/resolvers/tsx.d.ts

@@ -0,0 +1,2 @@
+import type { Resolver } from '../types.js';
+export declare const resolve: Resolver;

package/dist/binaries/resolvers/tsx.js

@@ -0,0 +1,6 @@
+import { toBinary } from '../../util/protocols.js';
+import { resolve as resolveNode } from './node.js';
+export const resolve = (binary, args, options) => {
+    args = args.map(a => (a === 'watch' ? '--watch' : a));
+    return [toBinary(binary), ...resolveNode(binary, args, options)];
+};

package/dist/index.js

@@ -1,3 +1,4 @@
+import { isGitIgnoredSync } from 'globby';
 import micromatch from 'micromatch';
 import { _getDependenciesFromScripts } from './binaries/index.js';
 import { ConfigurationChief } from './ConfigurationChief.js';
@@ -21,6 +22,7 @@ export const main = async (unresolvedConfiguration) => {
     const deputy = new DependencyDeputy({ isStrict });
     const factory = new PrincipalFactory();
     const streamer = new ConsoleStreamer({ isEnabled: isShowProgress });
+    const isGitIgnored = gitignore ? isGitIgnoredSync({ cwd }) : () => false;
     streamer.cast('Reading workspace configuration(s)...');
     await chief.init();
     const compilers = chief.getCompilers();
@@ -41,7 +43,7 @@ export const main = async (unresolvedConfiguration) => {
         if (isInternal(specifier)) {
             const filePath = principal.resolveModule(specifier, containingFilePath)?.resolvedFileName;
             if (filePath) {
-                const ignorePatterns = workspace.config.ignore.map(pattern => join(dirname(containingFilePath), pattern));
+                const ignorePatterns = workspace.config.ignore.map(pattern => join(workspace.dir, pattern));
                 const isIgnored = micromatch.isMatch(filePath, ignorePatterns);
                 if (!isIgnored)
                     principal.addEntryPath(filePath);
@@ -85,7 +87,7 @@ export const main = async (unresolvedConfiguration) => {
         streamer.cast(`Analyzing workspace ${name}...`);
         deputy.addWorkspace({ name, dir, manifestPath, manifest, ignoreDependencies, ignoreBinaries });
         const { compilerOptions, definitionPaths } = await loadTSConfig(join(dir, tsConfigFile ?? 'tsconfig.json'));
-        const principal = factory.getPrincipal({ cwd: dir, paths, compilerOptions, compilers, pkgName });
+        const principal = factory.getPrincipal({ cwd: dir, paths, compilerOptions, compilers, pkgName, isGitIgnored });
         const worker = new WorkspaceWorker({
             name,
             dir,
@@ -102,7 +104,7 @@ export const main = async (unresolvedConfiguration) => {
         principal.addEntryPaths(definitionPaths);
         debugLogArray(name, `Definition paths`, definitionPaths);
         const sharedGlobOptions = { cwd, workingDir: dir, gitignore, ignore: worker.getIgnorePatterns() };
-        const entryPathsFromManifest = await getEntryPathFromManifest(cwd, dir, manifest);
+        const entryPathsFromManifest = await getEntryPathFromManifest(manifest, sharedGlobOptions);
         debugLogArray(name, 'Entry paths in package.json', entryPathsFromManifest);
         principal.addEntryPaths(entryPathsFromManifest);
         const dependencies = await worker.findAllDependencies();

package/dist/plugins/eslint/helpers.d.ts

@@ -4,6 +4,4 @@ type GetDependenciesDeep = (configFilePath: string, options: {
     manifest: PackageJsonWithPlugins;
 }, dependencies?: Set<string>) => Promise<Set<string>>;
 export declare const getDependenciesDeep: GetDependenciesDeep;
-export declare const resolvePluginSpecifier: (specifier: string) => string;
-export declare const resolveExtendSpecifier: (specifier: string) => string | undefined;
 export {};

package/dist/plugins/eslint/helpers.js

@@ -1,4 +1,5 @@
 import { compact } from '../../util/array.js';
+import { getPackageNameFromModuleSpecifier } from '../../util/modules.js';
 import { isInternal, dirname, toAbsolute } from '../../util/path.js';
 import { load } from '../../util/plugin.js';
 import { _resolve } from '../../util/require.js';
@@ -54,15 +55,17 @@ const resolveSpecifier = (namespace, rawSpecifier) => {
     const specifier = rawSpecifier.replace(/(^plugin:|:.+$)/, '');
     if (isQualifiedSpecifier(specifier))
         return specifier;
-    if (!specifier.startsWith('@'))
-        return `${namespace}-${specifier}`;
+    if (!specifier.startsWith('@')) {
+        const id = rawSpecifier.startsWith('plugin:') ? getPackageNameFromModuleSpecifier(specifier) : specifier;
+        return `${namespace}-${id}`;
+    }
     const [scope, name, ...rest] = specifier.split('/');
     if (rawSpecifier.startsWith('plugin:') && rest.length === 0)
-        return [scope, namespace, name].join('/');
+        return [scope, namespace].join('/');
     return [scope, name ? `${namespace}-${name}` : namespace, ...rest].join('/');
 };
-export const resolvePluginSpecifier = (specifier) => resolveSpecifier('eslint-plugin', specifier);
-export const resolveExtendSpecifier = (specifier) => {
+const resolvePluginSpecifier = (specifier) => resolveSpecifier('eslint-plugin', specifier);
+const resolveExtendSpecifier = (specifier) => {
     if (isInternal(specifier))
         return;
     if (/^next(\/.+)?$/.test(specifier))

package/dist/plugins/index.d.ts

@@ -39,6 +39,7 @@ export * as stryker from './stryker/index.js';
 export * as stylelint from './stylelint/index.js';
 export * as svelte from './svelte/index.js';
 export * as tailwind from './tailwind/index.js';
+export * as tsup from './tsup/index.js';
 export * as typedoc from './typedoc/index.js';
 export * as typescript from './typescript/index.js';
 export * as vite from './vite/index.js';

package/dist/plugins/index.js

@@ -39,6 +39,7 @@ export * as stryker from './stryker/index.js';
 export * as stylelint from './stylelint/index.js';
 export * as svelte from './svelte/index.js';
 export * as tailwind from './tailwind/index.js';
+export * as tsup from './tsup/index.js';
 export * as typedoc from './typedoc/index.js';
 export * as typescript from './typescript/index.js';
 export * as vite from './vite/index.js';

package/dist/plugins/node-test-runner/index.js

@@ -8,10 +8,10 @@ export const isEnabled = ({ manifest }) => {
         .some(s => manifest.scripts && /node (.*)--test/.test(manifest.scripts[s]));
 };
 export const ENTRY_FILE_PATTERNS = [
-    '**/test.{js,cjs,mjs}',
-    '**/test-*.{js,cjs,mjs}',
-    '**/*{.,-,_}test.{js,cjs,mjs}',
-    '**/test/**/*.{js,cjs,mjs}',
+    '**/*{.,-,_}test.?(c|m)js',
+    '**/test-*.?(c|m)js',
+    '**/test.?(c|m)js',
+    '**/test/**/*.?(c|m)js',
 ];
 const findNodeTestRunnerDependencies = async (configFilePath, options) => {
     return (options.config?.entry ?? ENTRY_FILE_PATTERNS).map(toEntryPattern);

package/dist/plugins/tsup/index.d.ts

@@ -0,0 +1,6 @@
+import type { IsPluginEnabledCallback, GenericPluginCallback } from '../../types/plugins.js';
+export declare const NAME = "tsup";
+export declare const ENABLERS: string[];
+export declare const isEnabled: IsPluginEnabledCallback;
+export declare const CONFIG_FILE_PATTERNS: string[];
+export declare const findDependencies: GenericPluginCallback;

package/dist/plugins/tsup/index.js

@@ -0,0 +1,23 @@
+import { timerify } from '../../util/Performance.js';
+import { hasDependency, load } from '../../util/plugin.js';
+import { toEntryPattern } from '../../util/protocols.js';
+export const NAME = 'tsup';
+export const ENABLERS = ['tsup'];
+export const isEnabled = ({ dependencies }) => hasDependency(dependencies, ENABLERS);
+export const CONFIG_FILE_PATTERNS = ['tsup.config.js'];
+const findTsupDependencies = async (configFilePath) => {
+    let localConfig = await load(configFilePath);
+    if (typeof localConfig === 'function')
+        localConfig = await localConfig({});
+    if (!localConfig)
+        return [];
+    const entryPatterns = [localConfig].flat().flatMap(config => {
+        if (!config.entry)
+            return [];
+        if (Array.isArray(config.entry))
+            return config.entry.map(toEntryPattern);
+        return Object.values(config.entry).map(toEntryPattern);
+    });
+    return entryPatterns;
+};
+export const findDependencies = timerify(findTsupDependencies);

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

@@ -0,0 +1,7 @@
+type Entry = string[] | Record<string, string>;
+type Options = {
+    entry?: Entry;
+};
+type MaybePromise<T> = T | Promise<T>;
+export type TsupConfig = Options | Options[] | ((overrideOptions: Options) => MaybePromise<Options | Options[]>);
+export {};

package/dist/plugins/tsup/types.js

@@ -0,0 +1 @@
+export {};

package/dist/plugins/vite/index.js

@@ -9,6 +9,6 @@ const findViteDependencies = async (configFilePath, options) => {
     const localConfig = await load(configFilePath);
     if (!localConfig)
         return [];
-    return findVitestDependencies(localConfig, options);
+    return findVitestDependencies(configFilePath, localConfig, options);
 };
 export const findDependencies = timerify(findViteDependencies);

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

@@ -5,5 +5,5 @@ export declare const ENABLERS: string[];
 export declare const isEnabled: IsPluginEnabledCallback;
 export declare const CONFIG_FILE_PATTERNS: string[];
 export declare const ENTRY_FILE_PATTERNS: string[];
-export declare const findVitestDependencies: (localConfig: ViteConfigOrFn, options: GenericPluginCallbackOptions) => Promise<any[]>;
+export declare const findVitestDependencies: (configFilePath: string, localConfig: ViteConfigOrFn, options: GenericPluginCallbackOptions) => Promise<any[]>;
 export declare const findDependencies: GenericPluginCallback;

package/dist/plugins/vitest/index.js

@@ -1,6 +1,7 @@
 import { compact } from '../../util/array.js';
+import { dirname, join, relative } from '../../util/path.js';
 import { timerify } from '../../util/Performance.js';
-import { hasDependency, load } from '../../util/plugin.js';
+import { hasDependency, load, tryResolve } from '../../util/plugin.js';
 import { toEntryPattern } from '../../util/protocols.js';
 import { getEnvPackageName, getExternalReporters } from './helpers.js';
 export const NAME = 'Vitest';
@@ -8,7 +9,14 @@ export const ENABLERS = ['vitest'];
 export const isEnabled = ({ dependencies }) => hasDependency(dependencies, ENABLERS);
 export const CONFIG_FILE_PATTERNS = ['vitest.config.ts', 'vitest.{workspace,projects}.{ts,js,json}'];
 export const ENTRY_FILE_PATTERNS = ['**/*.{test,spec}.?(c|m)[jt]s?(x)'];
-const findConfigDependencies = (localConfig, options) => {
+const resolveEntry = (containingFilePath, specifier) => {
+    const dir = dirname(containingFilePath);
+    const resolvedPath = tryResolve(join(dir, specifier), containingFilePath);
+    if (resolvedPath)
+        return toEntryPattern(relative(dir, resolvedPath));
+    return specifier;
+};
+const findConfigDependencies = (configFilePath, localConfig, options) => {
     const { isProduction, config } = options;
     const testConfig = localConfig.test;
     const entryPatterns = (config?.entry ?? testConfig?.include ?? ENTRY_FILE_PATTERNS).map(toEntryPattern);
@@ -17,11 +25,11 @@ const findConfigDependencies = (localConfig, options) => {
     const environments = testConfig.environment ? [getEnvPackageName(testConfig.environment)] : [];
     const reporters = getExternalReporters(testConfig.reporters);
     const coverage = testConfig.coverage ? [`@vitest/coverage-${testConfig.coverage.provider ?? 'v8'}`] : [];
-    const setupFiles = testConfig.setupFiles ? [testConfig.setupFiles].flat() : [];
-    const globalSetup = testConfig.globalSetup ? [testConfig.globalSetup].flat() : [];
+    const setupFiles = [testConfig.setupFiles ?? []].flat().map(v => resolveEntry(configFilePath, v));
+    const globalSetup = [testConfig.globalSetup ?? []].flat().map(v => resolveEntry(configFilePath, v));
     return [...entryPatterns, ...environments, ...reporters, ...coverage, ...setupFiles, ...globalSetup];
 };
-export const findVitestDependencies = async (localConfig, options) => {
+export const findVitestDependencies = async (configFilePath, localConfig, options) => {
     if (!localConfig)
         return [];
     if (typeof localConfig === 'function') {
@@ -29,21 +37,21 @@ export const findVitestDependencies = async (localConfig, options) => {
         for (const command of ['dev', 'serve', 'build']) {
             for (const mode of ['development', 'production']) {
                 const config = await localConfig({ command, mode, ssrBuild: undefined });
-                findConfigDependencies(config, options).forEach(dependency => dependencies.add(dependency));
+                findConfigDependencies(configFilePath, config, options).forEach(dependency => dependencies.add(dependency));
             }
         }
         return Array.from(dependencies);
     }
     if (!localConfig.test)
         return [];
-    return findConfigDependencies(localConfig, options);
+    return findConfigDependencies(configFilePath, localConfig, options);
 };
 const findVitestWorkspaceDependencies = async (configFilePath, options) => {
     const localConfig = await load(configFilePath);
     const dependencies = new Set();
     for (const config of [localConfig].flat()) {
         if (config && typeof config !== 'string') {
-            (await findVitestDependencies(config, options)).forEach(dependency => dependencies.add(dependency));
+            (await findVitestDependencies(configFilePath, config, options)).forEach(dependency => dependencies.add(dependency));
         }
     }
     return compact(dependencies);

package/dist/typescript/ast-helpers.js

@@ -97,8 +97,11 @@ export const isInModuleBlock = (node) => {
 };
 export const getJSDocTags = (node) => {
     const tags = new Set();
-    const declaration = ts.isExportSpecifier(node) || ts.isBindingElement(node) ? node.parent.parent : node;
-    for (const tagNode of ts.getJSDocTags(declaration)) {
+    let tagNodes = ts.getJSDocTags(node);
+    if (ts.isExportSpecifier(node) || ts.isBindingElement(node)) {
+        tagNodes = [...tagNodes, ...ts.getJSDocTags(node.parent.parent)];
+    }
+    for (const tagNode of tagNodes) {
         const match = tagNode.getText()?.match(/@\S+/);
         if (match)
             tags.add(match[0]);

package/dist/typescript/visitors/exports/moduleExportsAccessExpression.js

@@ -3,42 +3,37 @@ import { SymbolType } from '../../../types/issues.js';
 import { stripQuotes } from '../../ast-helpers.js';
 import { isJS } from '../helpers.js';
 import { exportVisitor as visit } from '../index.js';
+const isModuleExportsAccess = (node) => ts.isIdentifier(node.expression) && node.expression.escapedText === 'module' && node.name.escapedText === 'exports';
 export default visit(isJS, node => {
     if (ts.isExpressionStatement(node)) {
         if (ts.isBinaryExpression(node.expression)) {
-            if (ts.isPropertyAccessExpression(node.expression.left) &&
-                ts.isPropertyAccessExpression(node.expression.left.expression) &&
-                ts.isIdentifier(node.expression.left.expression.expression) &&
-                node.expression.left.expression.expression.escapedText === 'module' &&
-                node.expression.left.expression.name.escapedText === 'exports') {
-                const identifier = node.expression.left.name.getText();
-                const pos = node.expression.left.name.pos;
-                return { node, identifier, type: SymbolType.UNKNOWN, pos };
+            if (ts.isPropertyAccessExpression(node.expression.left)) {
+                if (ts.isPropertyAccessExpression(node.expression.left.expression) &&
+                    isModuleExportsAccess(node.expression.left.expression)) {
+                    const identifier = node.expression.left.name.getText();
+                    const pos = node.expression.left.name.pos;
+                    return { node, identifier, type: SymbolType.UNKNOWN, pos };
+                }
+                else if (isModuleExportsAccess(node.expression.left)) {
+                    const expr = node.expression.right;
+                    if (ts.isObjectLiteralExpression(expr) && expr.properties.every(ts.isShorthandPropertyAssignment)) {
+                        return expr.properties.map(node => {
+                            return { node, identifier: node.getText(), type: SymbolType.UNKNOWN, pos: node.pos };
+                        });
+                    }
+                    else {
+                        return { node, identifier: 'default', type: SymbolType.UNKNOWN, pos: expr.pos };
+                    }
+                }
             }
             else if (ts.isElementAccessExpression(node.expression.left) &&
                 ts.isPropertyAccessExpression(node.expression.left.expression) &&
                 ts.isIdentifier(node.expression.left.expression.name) &&
-                ts.isIdentifier(node.expression.left.expression.expression) &&
-                node.expression.left.expression.expression.escapedText === 'module' &&
-                node.expression.left.expression.name.escapedText === 'exports') {
+                isModuleExportsAccess(node.expression.left.expression)) {
                 const identifier = stripQuotes(node.expression.left.argumentExpression.getText());
                 const pos = node.expression.left.argumentExpression.pos;
                 return { node, identifier, type: SymbolType.UNKNOWN, pos };
             }
-            else if (ts.isPropertyAccessExpression(node.expression.left) &&
-                ts.isIdentifier(node.expression.left.expression) &&
-                node.expression.left.expression.escapedText === 'module' &&
-                node.expression.left.name.escapedText === 'exports') {
-                const expr = node.expression.right;
-                if (ts.isObjectLiteralExpression(expr) && expr.properties.every(ts.isShorthandPropertyAssignment)) {
-                    return expr.properties.map(node => {
-                        return { node, identifier: node.getText(), type: SymbolType.UNKNOWN, pos: node.pos };
-                    });
-                }
-                else {
-                    return { node, identifier: 'default', type: SymbolType.UNKNOWN, pos: expr.pos };
-                }
-            }
         }
     }
 });

package/dist/util/compilers.d.ts

@@ -212,6 +212,11 @@ export declare const partitionCompilers: (rawLocalConfig: RawConfiguration) => {
             entry?: string | string[] | undefined;
             project?: string | string[] | undefined;
         } | undefined;
+        tsup?: string | boolean | string[] | {
+            config?: string | string[] | undefined;
+            entry?: string | string[] | undefined;
+            project?: string | string[] | undefined;
+        } | undefined;
         typedoc?: string | boolean | string[] | {
             config?: string | string[] | undefined;
             entry?: string | string[] | undefined;
@@ -428,6 +433,11 @@ export declare const partitionCompilers: (rawLocalConfig: RawConfiguration) => {
         entry?: string | string[] | undefined;
         project?: string | string[] | undefined;
     } | undefined;
+    tsup?: string | boolean | string[] | {
+        config?: string | string[] | undefined;
+        entry?: string | string[] | undefined;
+        project?: string | string[] | undefined;
+    } | undefined;
     typedoc?: string | boolean | string[] | {
         config?: string | string[] | undefined;
         entry?: string | string[] | undefined;

package/dist/util/fs.d.ts

@@ -5,3 +5,4 @@ export declare const loadJSON: (filePath: string) => Promise<any>;
 export declare const loadYAML: (filePath: string) => Promise<unknown>;
 export declare const parseJSON: (filePath: string, contents: string) => Promise<any>;
 export declare const parseYAML: (contents: string) => Promise<unknown>;
+export declare function isTypeModule(filePath: string): boolean;

package/dist/util/fs.js

@@ -1,9 +1,9 @@
-import { statSync } from 'node:fs';
+import { readFileSync, statSync } from 'node:fs';
 import { readFile } from 'node:fs/promises';
 import yaml from 'js-yaml';
 import stripJsonComments from 'strip-json-comments';
 import { LoaderError } from './errors.js';
-import { join } from './path.js';
+import { dirname, join } from './path.js';
 export const isFile = (filePath) => {
     const stat = statSync(filePath, { throwIfNoEntry: false });
     return stat !== undefined && stat.isFile();
@@ -40,3 +40,25 @@ export const parseJSON = async (filePath, contents) => {
 export const parseYAML = async (contents) => {
     return yaml.load(contents);
 };
+export function isTypeModule(filePath) {
+    if (!filePath.endsWith('.js'))
+        return false;
+    try {
+        let currentDir = dirname(filePath);
+        while (true) {
+            const packagePath = join(currentDir, 'package.json');
+            try {
+                const data = JSON.parse(readFileSync(packagePath, 'utf-8'));
+                return data.type === 'module';
+            }
+            catch { }
+            const parentDir = dirname(currentDir);
+            if (parentDir === currentDir)
+                return false;
+            currentDir = parentDir;
+        }
+    }
+    catch (error) {
+        return false;
+    }
+}

package/dist/util/glob.js

@@ -24,7 +24,7 @@ const glob = async ({ cwd, workingDir = cwd, patterns, ignore = [], gitignore =
     if (globPatterns[0].startsWith('!'))
         return [];
     const ignorePatterns = compact([...ignore, ...GLOBAL_IGNORE_PATTERNS]);
-    debugLogObject(relativePath || ROOT_WORKSPACE_NAME, `Glob options`, { cwd, globPatterns, ignorePatterns });
+    debugLogObject(relativePath || ROOT_WORKSPACE_NAME, `Glob options`, { cwd, globPatterns, ignorePatterns, gitignore });
     return globby(globPatterns, {
         cwd,
         ignore: ignorePatterns,

package/dist/util/loader.js

@@ -1,6 +1,7 @@
 import { pathToFileURL } from 'node:url';
 import { LoaderError } from './errors.js';
 import { loadJSON, loadYAML, loadFile, parseJSON, parseYAML } from './fs.js';
+import { isTypeModule } from './fs.js';
 import { extname } from './path.js';
 import { timerify } from './Performance.js';
 import { jiti } from './register.js';
@@ -20,7 +21,7 @@ const load = async (filePath) => {
         if (ext === '.yaml' || ext === '.yml') {
             return loadYAML(filePath);
         }
-        if (ext === '.mjs') {
+        if (ext === '.mjs' || (ext === '.js' && isTypeModule(filePath))) {
             const fileUrl = pathToFileURL(filePath);
             const imported = await import(fileUrl.href);
             return imported.default ?? imported;

package/dist/util/modules.d.ts

@@ -6,5 +6,10 @@ export declare const isMaybePackageName: (specifier: string) => boolean;
 export declare const isDefinitelyTyped: (packageName: string) => boolean;
 export declare const getDefinitelyTypedFor: (packageName: string) => string;
 export declare const getPackageFromDefinitelyTyped: (typedDependency: string) => string;
-export declare const getEntryPathFromManifest: (cwd: string, dir: string, manifest: PackageJson) => Promise<string[]>;
+export declare const getEntryPathFromManifest: (manifest: PackageJson, sharedGlobOptions: {
+    cwd: string;
+    workingDir: string;
+    gitignore: boolean;
+    ignore: string[];
+}) => Promise<string[]>;
 export declare const sanitizeSpecifier: (specifier: string) => string;

package/dist/util/modules.js

@@ -35,7 +35,7 @@ export const getPackageFromDefinitelyTyped = (typedDependency) => {
     }
     return typedDependency;
 };
-export const getEntryPathFromManifest = (cwd, dir, manifest) => {
+export const getEntryPathFromManifest = (manifest, sharedGlobOptions) => {
     const { main, bin, exports } = manifest;
     const entryPaths = new Set();
     if (typeof main === 'string')
@@ -49,7 +49,7 @@ export const getEntryPathFromManifest = (cwd, dir, manifest) => {
     if (exports) {
         getStringValues(exports).forEach(item => entryPaths.add(item));
     }
-    return _glob({ cwd, workingDir: dir, patterns: Array.from(entryPaths) });
+    return _glob({ ...sharedGlobOptions, patterns: Array.from(entryPaths) });
 };
 export const sanitizeSpecifier = (specifier) => {
     if (specifier.startsWith('node:'))

package/dist/util/plugin.d.ts

@@ -1,4 +1,5 @@
 export { _load as load, _loadFile as loadFile } from './loader.js';
+export { _tryResolve as tryResolve } from './require.js';
 import type { RawPluginConfiguration } from '../types/config.js';
 export declare const toCamelCase: (name: string) => string;
 export declare const hasDependency: (dependencies: Set<string>, values: (string | RegExp)[]) => boolean;

package/dist/util/plugin.js

@@ -1,4 +1,5 @@
 export { _load as load, _loadFile as loadFile } from './loader.js';
+export { _tryResolve as tryResolve } from './require.js';
 import { arrayify } from './array.js';
 export const toCamelCase = (name) => name.toLowerCase().replace(/(-[a-z])/g, group => group.toUpperCase().replace('-', ''));
 export const hasDependency = (dependencies, values) => values.some(value => {

package/dist/util/require.js

@@ -1,12 +1,15 @@
 import { createRequire as nodeCreateRequire } from 'node:module';
 import { pathToFileURL } from 'node:url';
+import createJITI from 'jiti';
 import { debugLog } from './debug.js';
 import { getPackageNameFromModuleSpecifier } from './modules.js';
 import { cwd, toPosix, join } from './path.js';
 import { timerify } from './Performance.js';
+import { jiti } from './register.js';
 const createRequire = (path) => nodeCreateRequire(pathToFileURL(path ?? cwd));
 const require = createRequire();
-const resolve = (specifier) => toPosix(require.resolve(specifier));
+export const _require = timerify(require);
+const resolve = (specifier) => toPosix(jiti.resolve(specifier));
 const tryResolve = (specifier, from) => {
     try {
         return resolve(specifier);
@@ -17,8 +20,8 @@ const tryResolve = (specifier, from) => {
 };
 const resolveSpecifier = (dir, specifier) => {
     try {
-        const require = createRequire(join(dir, 'package.json'));
-        return toPosix(require.resolve(specifier));
+        const jiti = createJITI(dir);
+        return toPosix(jiti.resolve(specifier));
     }
     catch {
         const packageName = getPackageNameFromModuleSpecifier(specifier);
@@ -28,7 +31,6 @@ const resolveSpecifier = (dir, specifier) => {
         }
     }
 };
-export const _require = timerify(require);
 export const _resolve = timerify(resolve);
 export const _tryResolve = timerify(tryResolve);
 export const _resolveSpecifier = timerify(resolveSpecifier);

package/dist/version.d.ts

@@ -1 +1 @@
-export declare const version = "2.40.2";
+export declare const version = "2.41.1";

package/dist/version.js

@@ -1 +1 @@
-export const version = '2.40.2';
+export const version = '2.41.1';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "knip",
-  "version": "2.40.2",
+  "version": "2.41.1",
   "description": "Find unused files, dependencies and exports in your TypeScript and JavaScript projects",
   "homepage": "https://github.com/webpro/knip",
   "repository": "github:webpro/knip",

package/schema.json

@@ -384,6 +384,10 @@
           "title": "tailwind plugin configuration (https://github.com/webpro/knip/blob/main/src/plugins/tailwind/README.md)",
           "$ref": "#/definitions/plugin"
         },
+        "tsup": {
+          "title": "tsup plugin configuration (https://github.com/webpro/knip/blob/main/src/plugins/tsup/README.md)",
+          "$ref": "#/definitions/plugin"
+        },
         "typedoc": {
           "title": "typedoc plugin configuration (https://github.com/webpro/knip/blob/main/src/plugins/typedoc/README.md)",
           "$ref": "#/definitions/plugin"