knip 6.25.0 → 6.27.0

package/dist/plugins/vitest/index.js

@@ -12,6 +12,7 @@ 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 benchmark = ['**/*.bench.?(c|m)[jt]s?(x)'];
 const findConfigDependencies = (localConfig, options, vitestRoot) => {
     const { configFileDir: dir } = options;
     const testConfig = localConfig.test;
@@ -29,6 +30,10 @@ const findConfigDependencies = (localConfig, options, vitestRoot) => {
     const setupFiles = [testConfig.setupFiles ?? []]
         .flat()
         .map(specifier => ({ ...toDeferResolve(specifier), dir: vitestRoot }));
+    const snapshotSerializers = (testConfig.snapshotSerializers ?? []).map(specifier => ({
+        ...toDeferResolve(specifier),
+        dir: vitestRoot,
+    }));
     const globalSetup = [testConfig.globalSetup ?? []].flat().map(specifier => ({ ...toDeferResolve(specifier), dir }));
     const workspaceDependencies = [];
     if (testConfig.workspace !== undefined) {
@@ -49,6 +54,7 @@ const findConfigDependencies = (localConfig, options, vitestRoot) => {
         ...reporters.map(id => toDependency(id)),
         ...coverage.map(id => toDependency(id)),
         ...setupFiles,
+        ...snapshotSerializers,
         ...globalSetup,
         ...workspaceDependencies,
         ...projectsDependencies,
@@ -109,6 +115,9 @@ export const resolveConfig = async (localConfig, options) => {
                         inputs.add(toConfig('vitest', projectFile, { containingFilePath: options.configFilePath }));
                     }
                 }
+                else if (typeof project.extends === 'string') {
+                    inputs.add(toConfig('vitest', project.extends, { containingFilePath: options.configFilePath }));
+                }
             }
         }
     }
@@ -132,6 +141,9 @@ export const resolveConfig = async (localConfig, options) => {
                 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)
@@ -149,6 +161,13 @@ export const resolveConfig = async (localConfig, options) => {
             if (packageName)
                 inputs.add(toDependency(packageName, { optional: true }));
         }
+        const ssrExternal = cfg.ssr?.external;
+        if (Array.isArray(ssrExternal)) {
+            for (const dependency of ssrExternal) {
+                if (typeof dependency === 'string')
+                    inputs.add(toDependency(dependency, { optional: true }));
+            }
+        }
         if (cfg.resolve?.extensions) {
             const customExtensions = cfg.resolve.extensions.filter(ext => ext.startsWith('.') && !DEFAULT_EXTENSIONS.has(ext));
             for (const ext of customExtensions) {

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

@@ -9,6 +9,9 @@ export type AliasOptions = readonly Alias[] | {
 interface VitestConfig {
     test: {
         include: string[];
+        benchmark?: {
+            include?: string[];
+        };
         coverage?: {
             enabled?: boolean;
             provider: string;
@@ -18,6 +21,7 @@ interface VitestConfig {
         globalSetup?: string | string[];
         reporters?: (string | [string, unknown] | unknown)[];
         setupFiles?: string | string[];
+        snapshotSerializers?: string[];
         workspace?: (ViteConfig & {
             test: VitestConfig['test'] & {
                 workspace: never;
@@ -32,6 +36,7 @@ interface VitestConfig {
     };
 }
 export interface ViteConfig extends VitestConfig {
+    extends?: string | true;
     root?: string;
     plugins?: unknown[];
     build?: {
@@ -44,6 +49,9 @@ export interface ViteConfig extends VitestConfig {
     optimizeDeps?: {
         include?: string[];
     };
+    ssr?: {
+        external?: (string | RegExp)[] | true;
+    };
     resolve?: {
         alias?: AliasOptions;
         dedupe?: string[];

package/dist/plugins/vue/index.js

@@ -1,7 +1,7 @@
 import { toDependency } from '../../util/input.js';
 import { hasDependency } from '../../util/plugin.js';
+import { vueAutoImportCompiler } from '../_vue/auto-import.js';
 import { findWebpackDependenciesFromConfig } from '../webpack/index.js';
-import compiler from './compiler.js';
 const title = 'Vue';
 const enablers = ['vue'];
 const isEnabled = ({ dependencies }) => hasDependency(dependencies, enablers);
@@ -28,9 +28,11 @@ const resolveConfig = async (config, options) => {
     }
     return inputs;
 };
+const sfcCompilers = ['vue', 'nuxt', 'unplugin-vue', '@vitejs/plugin-vue'];
 const registerCompilers = ({ registerCompiler, hasDependency }) => {
-    if (hasDependency('vue') || hasDependency('nuxt'))
-        registerCompiler({ extension: '.vue', compiler });
+    if (sfcCompilers.some(hasDependency)) {
+        registerCompiler({ extension: '.vue', compiler: vueAutoImportCompiler });
+    }
 };
 const plugin = {
     title,

package/dist/plugins/yarn/index.js

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

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

@@ -1,10 +1,8 @@
-import type { Dependencies } from '../../types/package-json.ts';
+import type { PackageExtensions } from '../../types/package-json.ts';
 export type YarnConfig = {
     plugins?: Array<string | {
         path?: string;
     }>;
     yarnPath?: string;
-    packageExtensions?: Record<string, {
-        peerDependencies?: Dependencies;
-    }>;
+    packageExtensions?: PackageExtensions;
 };

package/dist/run.js

@@ -12,7 +12,7 @@ import { debugLogObject } from './util/debug.js';
 import { flushGitignoreCache, initGitignoreCache } from './util/gitignore-cache.js';
 import { flushGlobCache, initGlobCache } from './util/glob-cache.js';
 import { getGitIgnoredHandler } from './util/glob-core.js';
-import { getModuleSourcePathHandler, getWorkspaceManifestHandler } from './util/to-source-path.js';
+import { getModuleSourcePathHandler, getWorkspacePackageTargetHandler } from './util/to-source-path.js';
 import { getSessionHandler } from './util/watch.js';
 export const run = async (options) => {
     debugLogObject('*', 'Unresolved configuration', options);
@@ -30,8 +30,8 @@ export const run = async (options) => {
     const workspaces = await chief.getWorkspaces();
     const isGitIgnored = await getGitIgnoredHandler(options, new Set(workspaces.map(w => w.dir)));
     const toSourceFilePath = getModuleSourcePathHandler(chief);
-    const findWorkspaceManifestImports = getWorkspaceManifestHandler(chief);
-    const principal = new ProjectPrincipal(options, toSourceFilePath, findWorkspaceManifestImports);
+    const findWorkspacePackageTarget = getWorkspacePackageTargetHandler(chief);
+    const principal = new ProjectPrincipal(options, toSourceFilePath, findWorkspacePackageTarget);
     collector.setWorkspaceFilter(chief.workspaceFilePathFilter);
     collector.setSelectedWorkspaces(chief.selectedWorkspaces);
     collector.setIgnoreIssues(chief.getIgnoreIssues());