knip 2.41.0 → 2.41.2

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/vite/index.js

@@ -4,7 +4,7 @@ import { findVitestDependencies } from '../vitest/index.js';
 export const NAME = 'Vite';
 export const ENABLERS = ['vite'];
 export const isEnabled = ({ dependencies }) => hasDependency(dependencies, ENABLERS);
-export const CONFIG_FILE_PATTERNS = ['vite.config.{js,ts}'];
+export const CONFIG_FILE_PATTERNS = ['vite.config.{js,mjs,ts,cjs,mts,cts}'];
 const findViteDependencies = async (configFilePath, options) => {
     const localConfig = await load(configFilePath);
     if (!localConfig)

package/dist/plugins/vitest/index.js

@@ -1,5 +1,5 @@
 import { compact } from '../../util/array.js';
-import { dirname, join } from '../../util/path.js';
+import { dirname, join, relative } from '../../util/path.js';
 import { timerify } from '../../util/Performance.js';
 import { hasDependency, load, tryResolve } from '../../util/plugin.js';
 import { toEntryPattern } from '../../util/protocols.js';
@@ -9,6 +9,13 @@ 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 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;
@@ -18,9 +25,8 @@ const findConfigDependencies = (configFilePath, 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 toPath = (v) => tryResolve(join(dirname(configFilePath), v), configFilePath) ?? v;
-    const setupFiles = (testConfig.setupFiles ? [testConfig.setupFiles].flat() : []).map(toPath);
-    const globalSetup = (testConfig.globalSetup ? [testConfig.globalSetup].flat() : []).map(toPath);
+    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 (configFilePath, localConfig, options) => {

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(path: 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,18 @@ export const parseJSON = async (filePath, contents) => {
 export const parseYAML = async (contents) => {
     return yaml.load(contents);
 };
+export function isTypeModule(path) {
+    while (path && path !== '.' && path !== '/') {
+        path = dirname(path);
+        try {
+            const pkg = readFileSync(join(path, 'package.json'), 'utf-8');
+            try {
+                return JSON.parse(pkg).type === 'module';
+            }
+            catch { }
+            break;
+        }
+        catch { }
+    }
+    return false;
+}

package/dist/util/loader.js

@@ -1,9 +1,10 @@
 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';
+import { jitiCJS, jitiESM } from './register.js';
 export const FAKE_PATH = '__FAKE__';
 const load = async (filePath) => {
     if (filePath === FAKE_PATH)
@@ -20,12 +21,17 @@ 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;
         }
-        return await jiti(filePath);
+        if (isTypeModule(filePath)) {
+            return await jitiESM(filePath);
+        }
+        else {
+            return await jitiCJS(filePath);
+        }
     }
     catch (error) {
         throw new LoaderError(`Error loading ${filePath}`, { cause: error });

package/dist/util/register.d.ts

@@ -1 +1,2 @@
-export declare const jiti: any;
+export declare const jitiCJS: any;
+export declare const jitiESM: any;

package/dist/util/register.js

@@ -1,14 +1,10 @@
-import module from 'node:module';
-import createJITI from 'jiti';
-import { IGNORED_FILE_EXTENSIONS, DEFAULT_EXTENSIONS } from '../constants.js';
-const _extensions = module.Module._extensions;
-export const jiti = createJITI(process.cwd(), { interopDefault: true, extensions: DEFAULT_EXTENSIONS });
-if (!('.ts' in _extensions)) {
-    jiti.register();
-}
-const exportFilePath = (module, filePath) => {
-    module.exports = filePath;
+import createJITI, {} from 'jiti';
+import { DEFAULT_EXTENSIONS } from '../constants.js';
+const options = {
+    interopDefault: true,
+    extensions: DEFAULT_EXTENSIONS,
+    esmResolve: false,
 };
-IGNORED_FILE_EXTENSIONS.forEach(ext => {
-    _extensions[ext] = exportFilePath;
-});
+const createLoader = (options) => createJITI(process.cwd(), options);
+export const jitiCJS = createLoader(options);
+export const jitiESM = createLoader({ ...options, esmResolve: true });

package/dist/util/require.js

@@ -5,11 +5,11 @@ 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';
+import { jitiCJS } from './register.js';
 const createRequire = (path) => nodeCreateRequire(pathToFileURL(path ?? cwd));
 const require = createRequire();
 export const _require = timerify(require);
-const resolve = (specifier) => toPosix(jiti.resolve(specifier));
+const resolve = (specifier) => toPosix(jitiCJS.resolve(specifier));
 const tryResolve = (specifier, from) => {
     try {
         return resolve(specifier);

package/dist/version.d.ts

@@ -1 +1 @@
-export declare const version = "2.41.0";
+export declare const version = "2.41.2";

package/dist/version.js

@@ -1 +1 @@
-export const version = '2.41.0';
+export const version = '2.41.2';

package/package.json

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