knip 6.42.1 → 6.44.0

package/dist/plugins/tailwind/compiler.js

@@ -1,8 +1,12 @@
 import { getUrlSpecifier } from '../../compilers/shared.js';
 import { hasUrlScheme } from '../../util/url.js';
-const directiveMatcher = /"(?:\\(?:\r\n|[\s\S]|$)|[^"\\\r\n\f])*(?:"|[\r\n\f]|$)|'(?:\\(?:\r\n|[\s\S]|$)|[^'\\\r\n\f])*(?:'|[\r\n\f]|$)|\/\*[\s\S]*?(?:\*\/|$)|@(?:(?:import|config|plugin)\s+['"]([^'"]+)['"]|import\s+url\(\s*(?:['"]([^'"]+)['"]|([^'")\s]+))\s*\))[^;]*;|url\(\s*(?:["']([^"'\r\n]*)["']|([^'")\s]+))\s*\)/g;
+const directiveMatcher = /"(?:\\(?:\r\n|[\s\S]|$)|[^"\\\r\n\f])*(?:"|[\r\n\f]|$)|'(?:\\(?:\r\n|[\s\S]|$)|[^'\\\r\n\f])*(?:'|[\r\n\f]|$)|\/\*[\s\S]*?(?:\*\/|$)|@(?:(?:import|config|plugin|reference)\s+['"]([^'"]+)['"]|import\s+url\(\s*(?:['"]([^'"]+)['"]|([^'")\s]+))\s*\))(?:\s*\{|[^;]*;)|url\(\s*(?:["']([^"'\r\n]*)["']|([^'")\s]+))\s*\)/g;
 const compiler = (text) => {
-    if (!text.includes('@import') && !text.includes('@config') && !text.includes('@plugin') && !text.includes('url('))
+    if (!text.includes('@import') &&
+        !text.includes('@config') &&
+        !text.includes('@plugin') &&
+        !text.includes('@reference') &&
+        !text.includes('url('))
         return '';
     const imports = [];
     let match;

package/dist/plugins/tanstack-router/index.js

@@ -14,12 +14,13 @@ const enablers = [
 ];
 const isEnabled = ({ dependencies }) => hasDependency(dependencies, enablers);
 const config = ['tsr.config.json'];
-const production = ['src/routeTree.gen.{ts,js}', 'src/{router,start,client,server}.{js,jsx,ts,tsx}'];
+const routerEntries = ['src/{router,start,client,server}.{js,jsx,ts,tsx}'];
+const production = ['src/routeTree.gen.{ts,js}', ...routerEntries];
 const resolveConfig = async (localConfig, options) => {
     const { configFileDir } = options;
     const generatedRouteTree = localConfig.generatedRouteTree ?? './src/routeTree.gen.ts';
     const routeTreePath = toAbsolute(generatedRouteTree, configFileDir);
-    return [toProductionEntry(routeTreePath)];
+    return [toProductionEntry(routeTreePath), ...routerEntries.map(id => toProductionEntry(id))];
 };
 const plugin = {
     title,

package/dist/plugins/taskfile/index.js

@@ -1,6 +1,5 @@
 import { isFile } from '../../util/fs.js';
 import { toConfig } from '../../util/input.js';
-import { join, relative } from '../../util/path.js';
 const title = 'Taskfile';
 const enablers = 'This plugin is enabled when a Taskfile is found (Taskfile.yml, taskfile.yml, Taskfile.yaml, taskfile.yaml, etc.).';
 const isRootOnly = true;
@@ -78,7 +77,7 @@ const extractScriptsFromTask = (task) => {
 const resolveConfig = async (localConfig, options) => {
     if (!localConfig || !options.configFilePath)
         return [];
-    const { getInputsFromScripts, isProduction, configFileDir } = options;
+    const { getInputsFromScripts, isProduction, configFileDir, cwd } = options;
     const inputs = [];
     if (localConfig.includes && typeof localConfig.includes === 'object') {
         for (const includeValue of Object.values(localConfig.includes)) {
@@ -87,10 +86,8 @@ const resolveConfig = async (localConfig, options) => {
                 : includeValue && typeof includeValue === 'object' && 'taskfile' in includeValue
                     ? includeValue.taskfile
                     : undefined;
-            if (includePath) {
-                const resolvedPath = join(configFileDir, includePath);
-                inputs.push(toConfig('taskfile', relative(configFileDir, resolvedPath)));
-            }
+            if (includePath)
+                inputs.push(toConfig('taskfile', includePath));
         }
     }
     if (localConfig.tasks && typeof localConfig.tasks === 'object') {
@@ -99,7 +96,7 @@ const resolveConfig = async (localConfig, options) => {
                 for (const input of getInputsFromScripts([script], { optionalBinaries: true })) {
                     if (isProduction)
                         Object.assign(input, { optional: true });
-                    inputs.push({ ...input, dir: configFileDir });
+                    inputs.push({ ...input, dir: input.type === 'entry' ? cwd : configFileDir });
                 }
             }
         }

package/dist/plugins/textlint/helpers.js

@@ -1,5 +1,5 @@
 import { toDependency, toDeferResolveEntry } from '../../util/input.js';
-import { isInternal, toAbsolute } from '../../util/path.js';
+import { isInternal } from '../../util/path.js';
 const RULE_PREFIX = 'textlint-rule-';
 const PRESET_PREFIX = 'textlint-rule-preset-';
 const FILTER_RULE_PREFIX = 'textlint-filter-rule-';
@@ -29,7 +29,7 @@ const toPresetDependency = (key, manifest) => {
     return toPackageDependency(PRESET_PREFIX, name, candidates, manifest);
 };
 const toModuleDependency = (prefix, key, manifest) => toPackageDependency(prefix, key, [createFullPackageName(prefix, key), key], manifest);
-const toLocalEntry = (key, cwd) => toDeferResolveEntry(toAbsolute(key, cwd));
+const toLocalEntry = (key, cwd) => toDeferResolveEntry(key, { dir: cwd });
 export const toRuleDependency = (key, manifest, cwd) => {
     if (isInternal(key))
         return toLocalEntry(key, cwd);

package/dist/plugins/travis/index.js

@@ -1,7 +1,7 @@
-import { _glob } from '../../util/glob.js';
+import { isFile } from '../../util/fs.js';
 const title = 'Travis CI';
 const enablers = 'This plugin is enabled when a `.travis.yml` file is found in the root folder.';
-const isEnabled = async ({ cwd }) => (await _glob({ cwd, patterns: ['.travis.yml'] })).length > 0;
+const isEnabled = ({ cwd }) => isFile(cwd, '.travis.yml');
 const isRootOnly = true;
 const config = ['.travis.yml'];
 const resolveConfig = async (config, options) => {

package/dist/plugins/typescript/index.js

@@ -1,6 +1,6 @@
 import { compact } from '../../util/array.js';
 import { toConfig, toDeferResolve, toDependency, toProductionDependency } from '../../util/input.js';
-import { join } from '../../util/path.js';
+import { join, toAbsolute } from '../../util/path.js';
 import { hasDependency } from '../../util/plugin.js';
 import { contentMapperResolvers } from './content-mappers.js';
 const title = 'TypeScript';
@@ -22,13 +22,15 @@ export const resolveConfig = (localConfig, options) => {
     const extend = localConfig.extends
         ? [localConfig.extends].flat().map(specifier => toConfig(options.pluginName, specifier))
         : [];
-    const references = localConfig.references
-        ?.filter(reference => reference.path.endsWith('.json'))
-        .map(reference => toConfig(options.pluginName, reference.path)) ?? [];
+    const references = localConfig.references?.map(({ path }) => toConfig(options.pluginName, path.endsWith('.json') ? path : toAbsolute(join(path, 'tsconfig.json'), options.configFileDir))) ?? [];
     const contentMappers = resolveContentMappers(localConfig);
     if (!(compilerOptions && localConfig))
         return compact([...contentMappers, ...extend, ...references]);
-    const jsx = (compilerOptions?.jsxImportSource ? [compilerOptions.jsxImportSource] : []).map(toProductionDependency);
+    const jsx = (compilerOptions?.jsxImportSource ? [compilerOptions.jsxImportSource] : []).map(id => ({
+        ...toProductionDependency(id),
+        dir: options.cwd,
+        alsoReferenceOwner: true,
+    }));
     const types = compilerOptions.types ?? [];
     const plugins = Array.isArray(compilerOptions?.plugins)
         ? compilerOptions.plugins.map(plugin => (typeof plugin === 'object' && 'name' in plugin ? plugin.name : ''))
@@ -38,8 +40,8 @@ export const resolveConfig = (localConfig, options) => {
         ...contentMappers,
         ...extend,
         ...references,
-        ...types.map(id => toDeferResolve(id, { isTypeOnly: true, dir: options.cwd })),
-        ...[...plugins, ...importHelpers].map(id => toDeferResolve(id)),
+        ...types.map(id => toDeferResolve(id, { isTypeOnly: true, dir: options.cwd, alsoReferenceOwner: true })),
+        ...[...plugins, ...importHelpers].map(id => toDeferResolve(id, { dir: options.cwd, alsoReferenceOwner: true })),
         ...jsx,
     ]);
 };

package/dist/plugins/unocss/index.js

@@ -3,11 +3,11 @@ import { toUnconfig } from '../../util/plugin-config.js';
 const title = 'UnoCSS';
 const enablers = ['unocss'];
 const isEnabled = ({ dependencies }) => hasDependency(dependencies, enablers);
-const config = [...toUnconfig('uno.config'), ...toUnconfig('unocss.config')];
+const entry = [...toUnconfig('uno.config'), ...toUnconfig('unocss.config')];
 const plugin = {
     title,
     enablers,
     isEnabled,
-    config,
+    entry,
 };
 export default plugin;

package/dist/plugins/vite-plugin-pwa/index.js

@@ -1,17 +1,14 @@
-import { join } from '../../util/path.js';
 import { hasDependency } from '../../util/plugin.js';
-import { defaultFilename, defaultSrcDir, resolveFromAST } from './resolveFromAST.js';
+import { resolveFromAST } from './resolveFromAST.js';
 const title = 'vite-plugin-pwa';
 const enablers = ['vite-plugin-pwa', '@vite-pwa/nuxt'];
 const isEnabled = ({ dependencies }) => hasDependency(dependencies, enablers);
 const config = ['vite.config.{js,mjs,ts,cjs,mts,cts}', 'nuxt.config.{js,cjs,mjs,ts,cts,mts}'];
-const production = [join(defaultSrcDir, defaultFilename)];
 const plugin = {
     title,
     enablers,
     isEnabled,
     config,
-    production,
     resolveFromAST,
 };
 export default plugin;

package/dist/plugins/vite-plugin-pwa/resolveFromAST.d.ts

@@ -1,4 +1,2 @@
 import type { ResolveFromAST } from '../../types/config.ts';
-export declare const defaultSrcDir = "public";
-export declare const defaultFilename = "sw.js";
 export declare const resolveFromAST: ResolveFromAST;

package/dist/plugins/vite-plugin-pwa/resolveFromAST.js

@@ -2,8 +2,8 @@ import { Visitor } from 'oxc-parser';
 import { findImportedCalls, findProperty, getFirstPropertyValue, getPropertyValues, } from '../../typescript/ast-helpers.js';
 import { toProductionEntry } from '../../util/input.js';
 import { join } from '../../util/path.js';
-export const defaultSrcDir = 'public';
-export const defaultFilename = 'sw.js';
+const defaultSrcDir = 'public';
+const defaultFilename = 'sw.js';
 const isNuxtConfig = (configFileName) => configFileName.startsWith('nuxt.config.');
 const getInjectManifestEntry = (options, configFileDir) => {
     if (!getPropertyValues(options, 'strategies').has('injectManifest'))

package/dist/plugins/vite-pwa-assets-generator/index.js

@@ -2,11 +2,11 @@ import { hasDependency } from '../../util/plugin.js';
 const title = '@vite-pwa/assets-generator';
 const enablers = ['@vite-pwa/assets-generator'];
 const isEnabled = ({ dependencies }) => hasDependency(dependencies, enablers);
-const config = ['pwa-assets.config.{js,cjs,mjs,ts,cts,mts}'];
+const entry = ['pwa-assets.config.{js,cjs,mjs,ts,cts,mts}'];
 const plugin = {
     title,
     enablers,
     isEnabled,
-    config,
+    entry,
 };
 export default plugin;

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

@@ -1,5 +1,5 @@
 import { type Input } from '../../util/input.ts';
 import type { AliasOptions, ViteConfig } from './types.ts';
-export declare const getEnvSpecifier: (env: string) => string;
+export declare const toEnvDependency: (env: string) => Input;
 export declare const getAliasInputs: (aliasOptions: AliasOptions, cwd: string) => Input[];
 export declare const getExternalReporters: (reporters?: ViteConfig['test']['reporters']) => string[];

package/dist/plugins/vitest/helpers.js

@@ -1,5 +1,5 @@
-import { toAlias } from '../../util/input.js';
-import { join, toPosix } from '../../util/path.js';
+import { toAlias, toDependency } from '../../util/input.js';
+import { join } from '../../util/path.js';
 const environments = {
     node: null,
     jsdom: null,
@@ -11,11 +11,12 @@ const envPackageNames = {
     'happy-dom': 'happy-dom',
     'edge-runtime': '@edge-runtime/vm',
 };
-export const getEnvSpecifier = (env) => {
+const getEnvSpecifier = (env) => {
     if (env in envPackageNames)
         return envPackageNames[env];
     return `vitest-environment-${env}`;
 };
+export const toEnvDependency = (env) => toDependency(getEnvSpecifier(env), env === 'nuxt' ? { optional: true } : undefined);
 const builtInReporters = [
     'agent',
     'basic',
@@ -34,18 +35,24 @@ const builtInReporters = [
     'verbose',
 ];
 const addStar = (value) => (value.endsWith('*') ? value : join(value, '*').replace(/\/\*\*$/, '/*'));
+const getAliasEntries = (aliasOptions) => {
+    if (!Array.isArray(aliasOptions))
+        return Object.entries(aliasOptions);
+    const entries = [];
+    for (const { find, replacement } of aliasOptions)
+        if (typeof find === 'string')
+            entries.push([find, replacement]);
+    return entries;
+};
 export const getAliasInputs = (aliasOptions, cwd) => {
     const inputs = [];
-    for (const [alias, value] of Object.entries(aliasOptions)) {
+    for (const [alias, value] of getAliasEntries(aliasOptions)) {
         if (!value)
             continue;
-        const prefixes = [value]
-            .flat()
-            .filter((value) => typeof value === 'string')
-            .map(prefix => (toPosix(prefix).startsWith(cwd) ? prefix : join(cwd, prefix)));
+        const prefixes = [value].flat().filter((value) => typeof value === 'string');
         if (alias.length > 1)
-            inputs.push(toAlias(alias, prefixes));
-        inputs.push(toAlias(addStar(alias), prefixes.map(addStar)));
+            inputs.push(toAlias(alias, prefixes, { dir: cwd }));
+        inputs.push(toAlias(addStar(alias), prefixes.map(addStar), { dir: cwd }));
     }
     return inputs;
 };

package/dist/plugins/vitest/index.js

@@ -1,32 +1,32 @@
 import { DEFAULT_EXTENSIONS } from '../../constants.js';
 import { filterTransitiveDependencies } from '../../util/filter-transitive-dependencies.js';
-import { _glob } from '../../util/glob.js';
+import { findFileWithExtensions } from '../../util/fs.js';
+import { _dirGlob, _glob } from '../../util/glob.js';
 import { toConfig, toDeferResolve, toDependency, toEntry, toProductionEntry } from '../../util/input.js';
 import { getPackageNameFromModuleSpecifier } from '../../util/modules.js';
-import { isAbsolute, isInternal, join, toAbsolute, toPosix } from '../../util/path.js';
+import { basename, isAbsolute, isInternal, join, toAbsolute, toPosix } from '../../util/path.js';
 import { hasDependency } from '../../util/plugin.js';
 import { resolveExtendedConfig } from '../oxlint/index.js';
 import { getHtmlScriptEntries, getIndexHtmlEntries } from '../vite/helpers.js';
-import { getAliasInputs, getEnvSpecifier, getExternalReporters } from './helpers.js';
+import { getAliasInputs, getExternalReporters, toEnvDependency } from './helpers.js';
 import { createVitestMockVisitor } from './visitors/mock.js';
 const title = 'Vitest';
 const enablers = ['vitest', 'vite-plus'];
 const isEnabled = ({ dependencies }) => hasDependency(dependencies, enablers);
+const configExtensions = ['.ts', '.mts', '.cts', '.js', '.mjs', '.cjs'];
+const projectConfigFile = /^vite(?:st)?(?:\.[\w-]+)?\.config\./;
 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 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 isProjectConfig = (project) => typeof project === 'object' && !(project instanceof Promise);
 const findConfigDependencies = (localConfig, options, vitestRoot) => {
     const testConfig = localConfig.test;
     if (!testConfig)
         return [];
     const env = testConfig.environment;
-    const environments = env && env !== 'node'
-        ? isInternal(env) || isAbsolute(env)
-            ? [toDeferResolve(env)]
-            : [toDependency(getEnvSpecifier(env))]
-        : [];
+    const environments = env && env !== 'node' ? (isInternal(env) || isAbsolute(env) ? [toDeferResolve(env)] : [toEnvDependency(env)]) : [];
     const reporters = getExternalReporters(testConfig.reporters).map(specifier => isInternal(specifier) || isAbsolute(specifier)
         ? { ...toDeferResolve(specifier), dir: vitestRoot }
         : toDependency(specifier));
@@ -51,7 +51,7 @@ const findConfigDependencies = (localConfig, options, vitestRoot) => {
     const projectsDependencies = [];
     if (testConfig.projects !== undefined) {
         for (const projectConfig of testConfig.projects) {
-            if (typeof projectConfig !== 'string') {
+            if (isProjectConfig(projectConfig)) {
                 projectsDependencies.push(...findConfigDependencies(projectConfig, options, vitestRoot));
             }
         }
@@ -79,30 +79,31 @@ const getConfigs = async (localConfig) => {
             if (typeof config === 'function') {
                 for (const command of ['serve', 'build']) {
                     for (const mode of ['development', 'production']) {
-                        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);
-                                    }
-                                }
-                            }
+                        for (const isSsrBuild of command === 'build' ? [undefined, false, true] : [undefined]) {
+                            const cfg = await config({ command, mode, isSsrBuild, ssrBuild: isSsrBuild });
+                            configs.push(cfg, ...(await getProjectConfigs(cfg, command === 'serve' && mode === 'development')));
                         }
                     }
                 }
             }
             else {
-                configs.push(config);
-                if (config.test?.projects) {
-                    for (const project of config.test.projects) {
-                        if (typeof project !== 'string') {
-                            configs.push(project);
-                        }
-                    }
-                }
+                configs.push(config, ...(await getProjectConfigs(config)));
+            }
+        }
+    }
+    return configs;
+};
+const projectEnv = { command: 'serve', mode: 'test', isPreview: false, isSsrBuild: false };
+const getProjectConfigs = async (config, isCallFunctions = true) => {
+    const configs = [];
+    if (config.test?.projects) {
+        for (const project of config.test.projects) {
+            if (typeof project === 'function') {
+                if (isCallFunctions)
+                    configs.push(await project(projectEnv));
             }
+            else if (typeof project !== 'string')
+                configs.push(await project);
         }
     }
     return configs;
@@ -112,23 +113,30 @@ export const resolveConfig = async (localConfig, options) => {
     const lintInputs = [];
     inputs.add(toEntry(join(options.cwd, 'src/vite-env.d.ts')));
     const configs = await getConfigs(localConfig);
+    const patterns = new Set();
     for (const cfg of configs) {
-        if (cfg.test?.projects) {
-            for (const project of cfg.test.projects) {
-                if (typeof project === 'string') {
-                    const projectFiles = await _glob({
-                        cwd: options.cwd,
-                        patterns: [project],
-                        gitignore: false,
-                    });
-                    for (const projectFile of projectFiles) {
-                        inputs.add(toConfig('vitest', projectFile));
-                    }
-                }
-                else if (typeof project.extends === 'string') {
-                    inputs.add(toConfig('vitest', project.extends));
-                }
-            }
+        for (const project of cfg.test?.projects ?? []) {
+            if (typeof project === 'string')
+                patterns.add(project);
+            else if (isProjectConfig(project) && typeof project.extends === 'string')
+                inputs.add(toConfig('vitest', project.extends));
+        }
+    }
+    if (patterns.size > 0) {
+        const [files, dirs] = await Promise.all([
+            _glob({ cwd: options.cwd, patterns: [...patterns], gitignore: false }),
+            _dirGlob({ cwd: options.cwd, patterns: [...patterns], gitignore: false }),
+        ]);
+        for (const file of files) {
+            if (projectConfigFile.test(basename(file)))
+                inputs.add(toConfig('vitest', file));
+        }
+        for (const dir of dirs) {
+            const projectRoot = toAbsolute(dir, options.cwd);
+            const configFile = findFileWithExtensions(join(projectRoot, 'vitest.config'), configExtensions) ??
+                findFileWithExtensions(join(projectRoot, 'vite.config'), configExtensions);
+            if (configFile)
+                inputs.add(toConfig('vitest', configFile));
         }
     }
     const addAliases = (aliasOptions) => {
@@ -210,7 +218,7 @@ export const resolveConfig = async (localConfig, options) => {
         }
         const _entry = cfg.build?.lib?.entry ?? [];
         const entries = typeof _entry === 'string' ? [_entry] : Array.isArray(_entry) ? _entry : Object.values(_entry).flat();
-        const deps = entries.map(specifier => join(viteRoot, specifier)).map(id => toEntry(id));
+        const deps = entries.map(specifier => toAbsolute(specifier, viteRoot)).map(id => toEntry(id));
         for (const dependency of deps)
             inputs.add(dependency);
     }
@@ -239,7 +247,7 @@ const args = {
             }
         }
         if (parsed['environment'] && parsed['environment'] !== 'node') {
-            inputs.push(toDependency(getEnvSpecifier(parsed['environment'])));
+            inputs.push(toEnvDependency(parsed['environment']));
         }
         if (typeof parsed['typecheck'] === 'object' && parsed['typecheck'].checker) {
             inputs.push(toDependency(parsed['typecheck'].checker === 'tsc' ? 'typescript' : parsed['typecheck'].checker));

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

@@ -29,11 +29,7 @@ interface VitestConfig {
                 workspace: never;
             };
         })[];
-        projects?: (string | (ViteConfig & {
-            test: VitestConfig['test'] & {
-                projects: never;
-            };
-        }))[];
+        projects?: (string | VitestProject)[];
         alias?: AliasOptions;
     };
 }
@@ -73,12 +69,20 @@ export interface ViteConfig extends VitestConfig {
     };
 }
 export type COMMAND = 'serve' | 'build';
-export type MODE = 'development' | 'production';
-interface Options {
+export type MODE = 'development' | 'production' | 'test';
+export interface Options {
     command: COMMAND;
     mode: MODE;
+    isSsrBuild?: boolean | undefined;
     ssrBuild?: boolean | undefined;
+    isPreview?: boolean | undefined;
 }
 export type ViteConfigOrFn = ViteConfig | ((options: Options) => ViteConfig) | ((options: Options) => Promise<ViteConfig>);
+export type VitestProjectConfig = ViteConfig & {
+    test: VitestConfig['test'] & {
+        projects: never;
+    };
+};
+export type VitestProject = VitestProjectConfig | Promise<VitestProjectConfig> | ((options: Options) => VitestProjectConfig | Promise<VitestProjectConfig>);
 export type VitestWorkspaceConfig = (string | ViteConfig)[];
 export {};

package/dist/plugins/webpack/index.js

@@ -1,5 +1,5 @@
 import { toAlias, toDeferResolve, toDeferResolveEntry, toDeferResolveProductionEntry, toDependency, } from '../../util/input.js';
-import { extname, isInternal, join, toAbsolute } from '../../util/path.js';
+import { extname, isInternal, join } from '../../util/path.js';
 import { hasDependency } from '../../util/plugin.js';
 import { getDependenciesFromConfig } from '../babel/index.js';
 import { createRequireContextVisitor } from './visitors/requireContext.js';
@@ -44,6 +44,8 @@ const resolveRuleSetDependencies = (rule) => {
         const d = getDependenciesFromConfig(rule.options).map(d => d.specifier);
         return [useItem, ...d];
     }
+    if (typeof useItem === 'string' && useItem && rule.options && rule.use == null)
+        useItem = { loader: useItem, options: rule.options };
     return [useItem].flat().flatMap((item) => {
         if (!item)
             return [];
@@ -149,7 +151,7 @@ export const findWebpackDependenciesFromConfig = async (config, options) => {
                         if (alias.length > 1)
                             inputs.add(toAlias(alias, prefixes));
                         for (const prefix of prefixes) {
-                            inputs.add(toAlias(addStar(alias), [addStar(toAbsolute(prefix, options.configFileDir))]));
+                            inputs.add(toAlias(addStar(alias), [addStar(prefix)], { dir: options.configFileDir }));
                         }
                     }
                 }

package/dist/plugins/yarn/index.js

@@ -22,10 +22,8 @@ const resolveConfig = config => {
     if (config.packageExtensions) {
         for (const extension of Object.values(config.packageExtensions)) {
             if (extension.peerDependencies) {
-                for (const dep of Object.keys(extension.peerDependencies)) {
-                    const optional = extension.peerDependenciesMeta?.[dep]?.optional === true;
-                    inputs.push(optional ? toDependency(dep, { optional: true }) : toDependency(dep));
-                }
+                for (const dep of Object.keys(extension.peerDependencies))
+                    inputs.push(toDependency(dep, { optional: true }));
             }
         }
     }

package/dist/reporters/codeclimate.d.ts

@@ -1,3 +1,3 @@
-import type { ReporterOptions } from '../types/issues.ts';
+import type { InternalReporterOptions } from '../types/issues.ts';
 export default _default;
-declare function _default({ report, issues, cwd }: ReporterOptions): Promise<void>;
+declare function _default({ report, issues, cwd, write }: InternalReporterOptions): Promise<void>;

package/dist/reporters/codeclimate.js

@@ -1,7 +1,7 @@
 import { createHash } from 'node:crypto';
 import { toRelative } from '../util/path.js';
 import { flattenIssues, getIssueDescription, getIssuePrefix, getIssueTypeTitle } from './util/util.js';
-export default async ({ report, issues, cwd }) => {
+export default async ({ report, issues, cwd, write }) => {
     const entries = [];
     for (const [type, isReportType] of Object.entries(report)) {
         if (!isReportType) {
@@ -33,9 +33,7 @@ export default async ({ report, issues, cwd }) => {
             }
         }
     }
-    const output = JSON.stringify(entries);
-    process.stdout._handle?.setBlocking?.(true);
-    process.stdout.write(`${output}\n`);
+    write(JSON.stringify(entries));
 };
 function convertSeverity(severity) {
     switch (severity) {

package/dist/reporters/codeowners.d.ts

@@ -1,3 +1,3 @@
-import type { ReporterOptions } from '../types/issues.ts';
+import type { InternalReporterOptions } from '../types/issues.ts';
 export default _default;
-declare function _default({ report, issues, isShowProgress, options, cwd }: ReporterOptions): void;
+declare function _default({ report, issues, isShowProgress, options, cwd, write }: InternalReporterOptions): void;

package/dist/reporters/codeowners.js

@@ -1,13 +1,12 @@
 import { createOwnershipEngine } from '../util/codeowners.js';
 import { relative, resolve } from '../util/path.js';
 import { getColoredTitle, getIssueLine, getIssueTypeTitle } from './util/util.js';
-const logIssueRecord = (issues, cwd) => {
+const getIssueRecordLines = (issues, cwd) => {
     const sortedByFilePath = issues.sort((a, b) => (a.owner < b.owner ? -1 : 1));
-    for (const { filePath, symbols, owner, parentSymbol } of sortedByFilePath) {
-        console.log(getIssueLine({ owner, filePath, symbols, parentSymbol }, cwd));
-    }
+    return sortedByFilePath.map(({ filePath, symbols, owner, parentSymbol }) => getIssueLine({ owner, filePath, symbols, parentSymbol }, cwd));
 };
-export default ({ report, issues, isShowProgress, options, cwd }) => {
+export default ({ report, issues, isShowProgress, options, cwd, write }) => {
+    const lines = [];
     let opts = {};
     try {
         opts = options ? JSON.parse(options) : opts;
@@ -36,14 +35,15 @@ export default ({ report, issues, isShowProgress, options, cwd }) => {
             });
             if (issuesForType.length > 0) {
                 if (totalIssues)
-                    console.log();
-                title && console.log(getColoredTitle(title, issuesForType.length));
-                logIssueRecord(issuesForType, cwd);
+                    lines.push('');
+                title && lines.push(getColoredTitle(title, issuesForType.length));
+                lines.push(...getIssueRecordLines(issuesForType, cwd));
             }
             totalIssues = totalIssues + issuesForType.length;
         }
     }
     if (totalIssues === 0 && isShowProgress) {
-        console.log('✂️  Excellent, Knip found no issues.');
+        lines.push('✂️  Excellent, Knip found no issues.');
     }
+    write(lines.join('\n'));
 };

package/dist/reporters/compact.d.ts

@@ -1,3 +1,3 @@
-import type { ReporterOptions } from '../types/issues.ts';
+import type { InternalReporterOptions } from '../types/issues.ts';
 export default _default;
-declare function _default({ report, issues, isShowProgress, cwd }: ReporterOptions): void;
+declare function _default({ report, issues, isShowProgress, cwd, write }: InternalReporterOptions): void;

package/dist/reporters/compact.js

@@ -1,10 +1,10 @@
 import { flattenIssues, getColoredTitle, getIssueLine, getIssueTypeTitle } from './util/util.js';
-const logIssueRecord = (issues, cwd) => {
+const getIssueRecordLines = (issues, cwd) => {
     const sortedByFilePath = issues.sort((a, b) => (a.filePath > b.filePath ? 1 : -1));
-    for (const issue of sortedByFilePath)
-        console.log(getIssueLine(issue, cwd));
+    return sortedByFilePath.map(issue => getIssueLine(issue, cwd));
 };
-export default ({ report, issues, isShowProgress, cwd }) => {
+export default ({ report, issues, isShowProgress, cwd, write }) => {
+    const lines = [];
     let totalIssues = 0;
     for (const [reportType, isReportType] of Object.entries(report)) {
         if (isReportType) {
@@ -18,13 +18,14 @@ export default ({ report, issues, isShowProgress, cwd }) => {
                     return { ...items[0], symbols: items };
                 });
             if (issuesForType.length > 0) {
-                title && console.log(getColoredTitle(title, issuesForType.length));
-                logIssueRecord(issuesForType, cwd);
+                title && lines.push(getColoredTitle(title, issuesForType.length));
+                lines.push(...getIssueRecordLines(issuesForType, cwd));
             }
             totalIssues = totalIssues + issuesForType.length;
         }
     }
     if (totalIssues === 0 && isShowProgress) {
-        console.log('✂️  Excellent, Knip found no issues.');
+        lines.push('✂️  Excellent, Knip found no issues.');
     }
+    write(lines.join('\n'));
 };

package/dist/reporters/cycles.d.ts

@@ -1,3 +1,3 @@
-import type { ReporterOptions } from '../types/issues.ts';
+import type { InternalReporterOptions } from '../types/issues.ts';
 export default _default;
-declare function _default({ cwd, issues, isShowProgress }: ReporterOptions): void;
+declare function _default({ cwd, issues, isShowProgress, write }: InternalReporterOptions): void;