@nx/vitest 24.0.0-beta.1 → 24.0.0-beta.3

package/dist/executors.d.ts

@@ -1,2 +1 @@
 export { VitestExecutorOptions } from './src/executors/test/schema';
-export { vitestExecutor } from './src/executors/test/vitest.impl';

package/dist/executors.js

@@ -1,5 +1,2 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.vitestExecutor = void 0;
-var vitest_impl_1 = require("./src/executors/test/vitest.impl");
-Object.defineProperty(exports, "vitestExecutor", { enumerable: true, get: function () { return vitest_impl_1.vitestExecutor; } });

package/dist/internal.d.ts

@@ -5,3 +5,4 @@
  */
 export declare const oxlintPlugins: string[];
 export { createOrEditViteConfig, ViteConfigFileOptions, } from './src/utils/generator-utils';
+export { convertToInferred as convertVitestToInferred } from './src/generators/convert-to-inferred/convert-to-inferred';

package/dist/internal.js

@@ -5,7 +5,7 @@
 // internal consumers and may change without semver protection. Mirrors
 // `@nx/devkit/internal`.
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createOrEditViteConfig = exports.oxlintPlugins = void 0;
+exports.convertVitestToInferred = exports.createOrEditViteConfig = exports.oxlintPlugins = void 0;
 /**
  * The Oxlint plugins a Vitest-tested project needs. Declared here so the linter
  * does not have to know what a test runner requires; `@nx/js`'s
@@ -14,3 +14,5 @@ exports.createOrEditViteConfig = exports.oxlintPlugins = void 0;
 exports.oxlintPlugins = ['vitest'];
 var generator_utils_1 = require("./src/utils/generator-utils");
 Object.defineProperty(exports, "createOrEditViteConfig", { enumerable: true, get: function () { return generator_utils_1.createOrEditViteConfig; } });
+var convert_to_inferred_1 = require("./src/generators/convert-to-inferred/convert-to-inferred");
+Object.defineProperty(exports, "convertVitestToInferred", { enumerable: true, get: function () { return convert_to_inferred_1.convertToInferred; } });

package/dist/src/generators/configuration/configuration.js

@@ -50,7 +50,7 @@ function shouldUseVitestConfig(tree, projectRoot, uiFramework) {
  * @param hasPlugin some frameworks (e.g. Nuxt) provide their own plugin. Their generators handle the plugin detection.
  */
 function configurationGenerator(tree, schema, hasPlugin = false) {
-    return configurationGeneratorInternal(tree, { addPlugin: false, ...schema }, hasPlugin);
+    return configurationGeneratorInternal(tree, schema, hasPlugin);
 }
 async function configurationGeneratorInternal(tree, schema, hasPlugin = false) {
     (0, assert_supported_vitest_version_1.assertSupportedVitestVersion)(tree);
@@ -76,7 +76,6 @@ async function configurationGeneratorInternal(tree, schema, hasPlugin = false) {
     }
     const initTask = await (0, init_1.default)(tree, {
         skipFormat: true,
-        addPlugin: schema.addPlugin,
         projectRoot: root,
         viteVersion: schema.viteVersion,
         skipPackageJson: schema.skipPackageJson,
@@ -194,9 +193,9 @@ getTestBed().initTestEnvironment(
         (0, internal_1.upsertTargetDefault)(tree, nxJson, { target: testTarget, dependsOn });
         (0, devkit_1.updateNxJson)(tree, nxJson);
     }
-    const devDependencies = await getCoverageProviderDependency(tree, schema.coverageProvider);
-    devDependencies['@types/node'] = internal_2.typesNodeVersion;
     if (!schema.skipPackageJson) {
+        const devDependencies = await getCoverageProviderDependency(tree, schema.coverageProvider);
+        devDependencies['@types/node'] = internal_2.typesNodeVersion;
         const installDependenciesTask = (0, devkit_1.addDependenciesToPackageJson)(tree, {}, devDependencies, undefined, true);
         tasks.push(installDependenciesTask);
     }

package/dist/src/generators/configuration/schema.d.ts

@@ -8,7 +8,6 @@ export interface VitestGeneratorSchema {
   skipFormat?: boolean;
   skipPackageJson?: boolean;
   testEnvironment?: 'node' | 'jsdom' | 'happy-dom' | 'edge-runtime' | string;
-  addPlugin?: boolean;
   runtimeTsconfigFileName?: string;
   compiler?: 'babel' | 'swc'; // default: babel
   passWithNoTests?: boolean;

package/dist/src/generators/init/init.js

@@ -47,34 +47,14 @@ function updateNxJsonSettings(tree) {
         productionFileSet.push('!{projectRoot}/**/?(*.)+(spec|test).[jt]s?(x)?(.snap)', '!{projectRoot}/tsconfig.spec.json');
         nxJson.namedInputs.production = Array.from(new Set(productionFileSet));
     }
-    const hasPlugin = nxJson.plugins?.some((p) => typeof p === 'string' ? p === '@nx/vitest' : p.plugin === '@nx/vitest');
-    if (!hasPlugin) {
-        const existing = (0, internal_1.findTargetDefault)(nxJson.targetDefaults, {
-            executor: '@nx/vitest:test',
-        });
-        (0, internal_1.upsertTargetDefault)(tree, nxJson, {
-            executor: '@nx/vitest:test',
-            cache: existing?.cache ?? true,
-            inputs: existing?.inputs ?? [
-                'default',
-                productionFileSet ? '^production' : '^default',
-            ],
-        });
-    }
     (0, devkit_1.updateNxJson)(tree, nxJson);
 }
 async function initGenerator(tree, schema) {
     (0, assert_supported_vitest_version_1.assertSupportedVitestVersion)(tree);
-    const nxJson = (0, devkit_1.readNxJson)(tree);
-    const addPluginDefault = process.env.NX_ADD_PLUGINS !== 'false' &&
-        nxJson.useInferencePlugins !== false;
-    schema.addPlugin ??= addPluginDefault;
-    if (schema.addPlugin) {
-        await (0, internal_1.addPlugin)(tree, await (0, devkit_1.createProjectGraphAsync)(), '@nx/vitest', plugin_1.createNodesV2, {
-            testTargetName: ['test', 'vitest:test', 'vitest-test'],
-            ciTargetName: ['test-ci', 'vitest:test-ci', 'vitest-test-ci'],
-        }, schema.updatePackageScripts);
-    }
+    await (0, internal_1.addPlugin)(tree, await (0, devkit_1.createProjectGraphAsync)(), '@nx/vitest', plugin_1.createNodesV2, {
+        testTargetName: ['test', 'vitest:test', 'vitest-test'],
+        ciTargetName: ['test-ci', 'vitest:test-ci', 'vitest-test-ci'],
+    }, schema.updatePackageScripts);
     updateNxJsonSettings(tree);
     await (0, ignore_vitest_temp_files_1.ignoreVitestTempFiles)(tree, schema.projectRoot);
     const tasks = [];

package/dist/src/generators/init/schema.d.ts

@@ -1,5 +1,4 @@
 export interface InitGeneratorSchema {
-  addPlugin?: boolean;
   rootProject?: boolean;
   keepExistingVersions?: boolean;
   projectRoot?: string;

package/dist/src/generators/init/schema.json

@@ -5,11 +5,6 @@
   "type": "object",
   "description": "Vitest init generator.",
   "properties": {
-    "addPlugin": {
-      "type": "boolean",
-      "x-priority": "internal",
-      "description": "Add plugin to nx.json. Defaults to true for new workspaces."
-    },
     "rootProject": {
       "type": "boolean",
       "x-priority": "internal"

package/dist/src/migrations/update-24-0-0/finish-inferred-conversion.md

@@ -0,0 +1,12 @@
+# Replace removed @nx/vitest executors with inferred tasks
+
+Nx 24 removed `@nx/vitest:test` (including old `@nrwl` aliases).
+
+Before changing anything, check for leftover work: a project target, a package.json target or a `targetDefaults` entry still uses a removed executor, or the advisory context reports a conversion error. If none applies, make no changes and stop. Treat each advisory-context item as pending work.
+
+1. Inspect all affected projects and workspace defaults. Repair config-loading errors first. Do not restore executor registrations or install older Nx packages.
+2. Preserve Vitest config paths, environments, setup files, coverage and watch/CI behavior.
+3. Register `@nx/vitest` with options/includes that preserve custom target names and mixed inferred/explicit projects. Replace remaining removed-executor targets, including those in package.json and filtered targetDefaults. Transfer their behavior before removing obsolete defaults. Preserve configurations, dependencies, cache inputs/outputs and environment behavior. Do not silently delete unsupported options or unrelated targets. Migrate old @nrwl aliases too.
+4. Run project graph creation with the daemon and graph cache disabled (`NX_DAEMON=false NX_CACHE_PROJECT_GRAPH=false`), using the workspace package manager. Inspect resolved project targets and verify each migrated entrypoint exists and is inferred (a thin alias to an inferred target is acceptable). Resolve graph errors before completing this migration, even if task validation was skipped. Configs must load for subsequent migrations.
+5. By default run relevant real builds/tests with task cache disabled, including alternate configurations. Honor an existing preference to skip expensive task validation; otherwise offer that option when validation is slow. Skipping expensive tasks never skips conversion or the graph check. Report each skipped task as unverified. Never weaken assertions or change application behavior to make checks pass.
+6. Report converted projects, graph validation, task results and any skipped checks. Unconverted targets or a broken graph mean the migration is incomplete. Investigate task failures and distinguish missing environment prerequisites from conversion regressions; do not claim a working workspace with unresolved regressions.

package/dist/src/migrations/update-24-0-0/remove-deprecated-executors.d.ts

@@ -0,0 +1,6 @@
+import type { Tree } from '@nx/devkit';
+export default function update(tree: Tree): Promise<{
+    nextSteps?: string[];
+    agentContext?: string[];
+    skipAgentic?: boolean;
+}>;

package/dist/src/migrations/update-24-0-0/remove-deprecated-executors.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = update;
+const internal_1 = require("@nx/devkit/internal");
+function update(tree) {
+    return (0, internal_1.migrateRemovedExecutors)(tree, ['@nx/vitest:test', '@nrwl/vitest:test'], async (tree, options) => {
+        const { convertToInferred } = require('../../generators/convert-to-inferred/convert-to-inferred');
+        return convertToInferred(tree, options);
+    });
+}

package/dist/src/migrations/update-24-0-0/remove-deprecated-executors.md

@@ -0,0 +1,52 @@
+#### Convert `@nx/vitest:test` targets to inferred tasks
+
+Nx 24 removes the `@nx/vitest:test` executor. The migration registers `@nx/vitest` in `nx.json` and converts the targets that use those executors to inferred tasks. Options the plugin does not infer stay on the target. A target with nothing left to override is removed from project configuration. When several projects share the same remaining options, those options move to a `targetDefaults` entry scoped to the plugin. `targetDefaults` entries keyed by a removed executor are removed once no target uses that executor.
+
+The migration lists the targets the converter cannot convert safely. In agentic runs, an AI prompt finishes them and validates the project graph.
+
+#### Sample code changes
+
+##### Before
+
+```json title="myapp/project.json"
+{
+  "name": "myapp",
+  "targets": {
+    "test": {
+      "executor": "@nx/vitest:test",
+      "options": {
+        "configFile": "myapp/vite.config.ts"
+      }
+    }
+  }
+}
+```
+
+##### After
+
+```json title="myapp/project.json"
+{
+  "name": "myapp",
+  "targets": {
+    "test": {
+      "options": {
+        "config": "./vite.config.ts"
+      }
+    }
+  }
+}
+```
+
+```json title="nx.json"
+{
+  "plugins": [
+    {
+      "plugin": "@nx/vitest",
+      "options": {
+        "testMode": "watch",
+        "testTargetName": "test"
+      }
+    }
+  ]
+}
+```

package/dist/src/utils/executor-utils.d.ts

@@ -1,3 +1,2 @@
 export declare function loadViteDynamicImport(): Promise<typeof import('vite')>;
-export declare function loadVitestDynamicImport(): Promise<typeof import('vitest/node')>;
 export declare function loadVitestConfigDynamicImport(): Promise<typeof import('vitest/config')>;

package/dist/src/utils/executor-utils.js

@@ -1,14 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.loadViteDynamicImport = loadViteDynamicImport;
-exports.loadVitestDynamicImport = loadVitestDynamicImport;
 exports.loadVitestConfigDynamicImport = loadVitestConfigDynamicImport;
 function loadViteDynamicImport() {
     return Function('return import("vite")')();
 }
-function loadVitestDynamicImport() {
-    return Function('return import("vitest/node")')();
-}
 function loadVitestConfigDynamicImport() {
     return Function('return import("vitest/config")')();
 }

package/dist/src/utils/generator-utils.d.ts

@@ -10,7 +10,6 @@ export interface VitestGeneratorSchema {
     testTarget?: string;
     skipFormat?: boolean;
     testEnvironment?: 'node' | 'jsdom' | 'happy-dom' | 'edge-runtime' | string;
-    addPlugin?: boolean;
     runtimeTsconfigFileName?: string;
     compiler?: 'babel' | 'swc';
     projectType?: 'application' | 'library';

package/dist/src/utils/generator-utils.js

@@ -5,13 +5,13 @@ exports.createOrEditViteConfig = createOrEditViteConfig;
 const devkit_1 = require("@nx/devkit");
 const internal_1 = require("@nx/js/internal");
 const vite_config_edit_utils_1 = require("./vite-config-edit-utils");
-const deprecation_1 = require("./deprecation");
+const version_utils_1 = require("./version-utils");
 const versions_1 = require("./versions");
 function addOrChangeTestTarget(tree, options, hasPlugin) {
     const nxJson = (0, devkit_1.readNxJson)(tree);
     const target = options.testTarget ?? 'test';
-    // The plugin only infers the target names it is registered for, so a request
-    // for any other name still needs an explicit target.
+    // The plugin only infers the target names it is registered for, so any other
+    // name gets its own project-scoped plugin registration below.
     hasPlugin ||=
         nxJson.plugins?.some((p) => {
             if (typeof p === 'string') {
@@ -28,23 +28,16 @@ function addOrChangeTestTarget(tree, options, hasPlugin) {
         return;
     }
     const project = (0, devkit_1.readProjectConfiguration)(tree, options.project);
-    const reportsDirectory = (0, devkit_1.joinPathFragments)('coverage', project.root === '.' ? options.project : project.root);
-    const testOptions = {
-        reportsDirectory,
-    };
-    project.targets ??= {};
-    if (project.targets[target]) {
+    if (project.targets?.[target]) {
         throw new Error(`Target "${target}" already exists in the project.`);
     }
-    else {
-        (0, deprecation_1.warnVitestExecutorGenerating)();
-        project.targets[target] = {
-            executor: '@nx/vitest:test',
-            outputs: ['{options.reportsDirectory}'],
-            options: testOptions,
-        };
-    }
-    (0, devkit_1.updateProjectConfiguration)(tree, options.project, project);
+    nxJson.plugins ??= [];
+    nxJson.plugins.push({
+        plugin: '@nx/vitest',
+        include: [project.root === '.' ? '**/*' : `${project.root}/**/*`],
+        options: { testTargetName: target },
+    });
+    (0, devkit_1.updateNxJson)(tree, nxJson);
 }
 // Escape a value for emission inside a single-quoted source literal.
 function escapeLiteral(value) {
@@ -102,15 +95,29 @@ function createOrEditViteConfig(tree, options, onlyVitest, extraOptions = {}) {
   },`;
     const imports = options.imports ? [...options.imports] : [];
     const plugins = options.plugins ? [...options.plugins] : [];
+    const needsPaths = !isTsSolutionSetup && !extraOptions.skipNxPlugins;
+    const useNativePaths = needsPaths && ((0, version_utils_1.getInstalledViteMajorVersion)(tree) ?? 8) >= 8;
+    const dependencies = {};
+    if (needsPaths && !useNativePaths) {
+        imports.push(`import tsconfigPaths from 'vite-tsconfig-paths'`);
+        plugins.push('tsconfigPaths({ loose: true })');
+        dependencies['vite-tsconfig-paths'] = versions_1.viteTsconfigPathsVersion;
+    }
     if (!onlyVitest && options.includeLib && !isTsSolutionSetup) {
-        imports.push(`import dts from 'vite-plugin-dts'`, `import * as path from 'path'`);
+        plugins.push(`import('vite-plugin-static-copy').then(({ viteStaticCopy }) => viteStaticCopy({
+      targets: [
+        { src: '*.md', dest: '.' },
+        { src: 'package.json', dest: '.', overwrite: false },
+      ],
+      silent: true,
+    }))`);
+        dependencies['vite-plugin-static-copy'] = versions_1.viteStaticCopyVersion;
     }
-    if (!isTsSolutionSetup && !extraOptions.skipNxPlugins) {
-        imports.push(`import { nxViteTsPaths } from '@nx/vite/plugins/nx-tsconfig-paths.plugin'`, `import { nxCopyAssetsPlugin } from '@nx/vite/plugins/nx-copy-assets.plugin'`);
-        plugins.push(`nxViteTsPaths()`, `nxCopyAssetsPlugin(['*.md'])`);
-        if (!extraOptions.skipPackageJson) {
-            (0, devkit_1.addDependenciesToPackageJson)(tree, {}, { '@nx/vite': versions_1.nxVersion });
-        }
+    if (!extraOptions.skipPackageJson && Object.keys(dependencies).length) {
+        (0, devkit_1.addDependenciesToPackageJson)(tree, {}, dependencies, undefined, true);
+    }
+    if (!onlyVitest && options.includeLib && !isTsSolutionSetup) {
+        imports.push(`import dts from 'vite-plugin-dts'`, `import * as path from 'path'`);
     }
     if (!onlyVitest && options.includeLib) {
         plugins.push(`dts({ entryRoot: 'src', tsconfigPath: path.join(import.meta.dirname, 'tsconfig.lib.json')${!isTsSolutionSetup ? ', pathsToAliases: false' : ''} })`);
@@ -169,23 +176,28 @@ ${options.inSourceTests
     port: ${options.previewPort ?? 4300},
     host: 'localhost',
   },`;
-    const workerOption = isTsSolutionSetup
-        ? `  // Uncomment this if you are using workers.
+    const workerOption = `  // Uncomment this if you are using workers.
   // worker: {
   //  plugins: [],
-  // },`
-        : `  // Uncomment this if you are using workers.
-  // worker: {
-  //   plugins: () => [ nxViteTsPaths() ],
   // },`;
     const aliasEntries = Object.entries(options.resolveAlias ?? {});
-    const resolveOption = aliasEntries.length
-        ? `  resolve: {
-    alias: {
+    // Path-based workspace libraries need Vite's native tsconfig paths
+    // resolution, which is off by default. Workspaces on project references
+    // resolve through package.json instead.
+    const resolveTsconfigPaths = useNativePaths;
+    const resolveEntries = [
+        resolveTsconfigPaths ? `    tsconfigPaths: true,` : '',
+        aliasEntries.length
+            ? `    alias: {
 ${aliasEntries
-            .map(([alias, target]) => `      '${escapeLiteral(alias)}': join(import.meta.dirname, '${escapeLiteral(target)}'),`)
-            .join('\n')}
-    },
+                .map(([alias, target]) => `      '${escapeLiteral(alias)}': join(import.meta.dirname, '${escapeLiteral(target)}'),`)
+                .join('\n')}
+    },`
+            : '',
+    ].filter(Boolean);
+    const resolveOption = resolveEntries.length
+        ? `  resolve: {
+${resolveEntries.join('\n')}
   },`
         : '';
     const cacheDir = `cacheDir: '${normalizedJoinPaths((0, devkit_1.offsetFromRoot)(projectRoot), 'node_modules', '.vite', projectRoot === '.' ? options.project : projectRoot)}',`;
@@ -193,7 +205,7 @@ ${aliasEntries
         if (aliasEntries.length) {
             devkit_1.logger.warn(`${viteConfigPath} already exists; the requested resolve.alias entries were not added to it.`);
         }
-        handleViteConfigFileExists(tree, viteConfigPath, options, buildOption, buildOutDir, imports, plugins, testOption, reportsDirectory, cacheDir, projectRoot, (0, devkit_1.offsetFromRoot)(projectRoot), extraOptions.projectAlreadyHasViteTargets);
+        handleViteConfigFileExists(tree, viteConfigPath, options, buildOption, buildOutDir, imports, plugins, testOption, reportsDirectory, cacheDir, projectRoot, (0, devkit_1.offsetFromRoot)(projectRoot), extraOptions.projectAlreadyHasViteTargets, resolveTsconfigPaths);
         return;
     }
     if (aliasEntries.length) {
@@ -205,7 +217,7 @@ ${imports.join(';\n')}${imports.length ? ';' : ''}
 
 export default defineConfig(() => ({
   root: import.meta.dirname,
-  ${printOptions(cacheDir, plugins.length ? `  plugins: [${plugins.join(', ')}],` : '', resolveOption, defineOption, testOption)}
+  ${printOptions(cacheDir, resolveOption, plugins.length ? `  plugins: [${plugins.join(', ')}],` : '', defineOption, testOption)}
 }));
 `.replace(/\s+(?=(\n|$))/gm, '\n')
         : `/// <reference types='vitest' />
@@ -214,7 +226,7 @@ ${imports.join(';\n')}${imports.length ? ';' : ''}
 
 export default defineConfig(() => ({
   root: import.meta.dirname,
-  ${printOptions(cacheDir, devServerOption, previewServerOption, `  plugins: [${plugins.join(', ')}],`, resolveOption, workerOption, buildOption, defineOption, testOption)}
+  ${printOptions(cacheDir, devServerOption, previewServerOption, resolveOption, plugins.length ? `  plugins: [${plugins.join(', ')}],` : '', workerOption, buildOption, defineOption, testOption)}
 }));
 `.replace(/\s+(?=(\n|$))/gm, '\n');
     tree.write(viteConfigPath, viteConfigContent);
@@ -222,7 +234,7 @@ export default defineConfig(() => ({
 function printOptions(...options) {
     return options.filter(Boolean).join('\n');
 }
-function handleViteConfigFileExists(tree, viteConfigPath, options, buildOption, buildOutDir, imports, plugins, testOption, reportsDirectory, cacheDir, projectRoot, offsetFromRoot, projectAlreadyHasViteTargets) {
+function handleViteConfigFileExists(tree, viteConfigPath, options, buildOption, buildOutDir, imports, plugins, testOption, reportsDirectory, cacheDir, projectRoot, offsetFromRoot, projectAlreadyHasViteTargets, resolveTsconfigPaths) {
     if (projectAlreadyHasViteTargets?.build &&
         projectAlreadyHasViteTargets?.test) {
         return;
@@ -267,7 +279,7 @@ function handleViteConfigFileExists(tree, viteConfigPath, options, buildOption,
             provider: `'${options.coverageProvider ?? 'v8'}'`,
         },
     };
-    const changed = (0, vite_config_edit_utils_1.ensureViteConfigIsCorrect)(tree, viteConfigPath, buildOption, buildOptionObject, imports, plugins, testOption, testOptionObject, cacheDir, projectAlreadyHasViteTargets ?? {});
+    const changed = (0, vite_config_edit_utils_1.ensureViteConfigIsCorrect)(tree, viteConfigPath, buildOption, buildOptionObject, imports, plugins, testOption, testOptionObject, cacheDir, projectAlreadyHasViteTargets ?? {}, resolveTsconfigPaths);
     if (!changed) {
         devkit_1.logger.warn(`Make sure the following setting exists in your Vite configuration file (${viteConfigPath}):
 

package/dist/src/utils/versions.d.ts

@@ -30,4 +30,6 @@ type VitestVersions = {
 export declare function versions(tree: Tree, options?: VersionSelectionOptions): VitestVersions;
 export declare function getInstalledVitestVersion(tree?: Tree): string | null;
 export declare function getInstalledVitestMajorVersion(tree?: Tree): number | null;
+export declare const viteTsconfigPathsVersion = "~4.3.2";
+export declare const viteStaticCopyVersion = "^3.3.0";
 export {};

package/dist/src/utils/versions.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.analogVitestAngular = exports.jitiVersion = exports.edgeRuntimeVmVersion = exports.happyDomVersion = exports.ajvVersion = exports.vitePluginDtsVersion = exports.jsdomVersion = exports.vitePluginReactSwcVersion = exports.vitePluginReactV4Version = exports.vitePluginReactVersion = exports.viteV5Version = exports.viteV6Version = exports.viteV7Version = exports.viteVersion = exports.vitestCoverageIstanbulVersion = exports.vitestCoverageV8Version = exports.vitestVersion = exports.minSupportedVitestVersion = exports.nxVersion = void 0;
+exports.viteStaticCopyVersion = exports.viteTsconfigPathsVersion = exports.analogVitestAngular = exports.jitiVersion = exports.edgeRuntimeVmVersion = exports.happyDomVersion = exports.ajvVersion = exports.vitePluginDtsVersion = exports.jsdomVersion = exports.vitePluginReactSwcVersion = exports.vitePluginReactV4Version = exports.vitePluginReactVersion = exports.viteV5Version = exports.viteV6Version = exports.viteV7Version = exports.viteVersion = exports.vitestCoverageIstanbulVersion = exports.vitestCoverageV8Version = exports.vitestVersion = exports.minSupportedVitestVersion = exports.nxVersion = void 0;
 exports.versions = versions;
 exports.getInstalledVitestVersion = getInstalledVitestVersion;
 exports.getInstalledVitestMajorVersion = getInstalledVitestMajorVersion;
@@ -77,13 +77,45 @@ function versions(tree, options) {
     return (supported ?? VITEST_COMPAT[0]).versions;
 }
 /**
- * `@analogjs/vitest-angular` at the version Nx installs, and `@angular/build`,
- * both peer vitest 4. A workspace carrying either cannot take vitest 5.
+ * Packages that peer vitest, with the first version whose peer range takes
+ * vitest 5. Older versions peer vitest 4 and below.
  */
+const VITEST_PEERS = {
+    '@angular/build': '22.2.0',
+    '@analogjs/vitest-angular': '2.8.0',
+};
 function highestMajorTheWorkspacePeersAllow(tree) {
-    return (0, devkit_1.getDependencyVersionFromPackageJson)(tree, '@analogjs/vitest-angular') || (0, devkit_1.getDependencyVersionFromPackageJson)(tree, '@angular/build')
-        ? 4
-        : 5;
+    let cap = VITEST_COMPAT[0].major;
+    for (const [peer, firstVitestV5Version] of Object.entries(VITEST_PEERS)) {
+        if ((0, devkit_1.getDependencyVersionFromPackageJson)(tree, peer)) {
+            cap = Math.min(cap, highestVitestMajorAllowedBy(tree, peer, firstVitestV5Version));
+        }
+    }
+    return cap;
+}
+function highestVitestMajorAllowedBy(tree, peer, firstVitestV5Version) {
+    const installedPeerRange = readInstalledPeerVitestRange(tree, peer);
+    if (installedPeerRange) {
+        const allowed = VITEST_COMPAT.find((compat) => (0, semver_1.intersects)(`^${compat.major}.0.0`, installedPeerRange));
+        if (allowed) {
+            return allowed.major;
+        }
+    }
+    const declaredVersion = (0, internal_1.getDeclaredPackageVersion)(tree, peer);
+    return declaredVersion && (0, semver_1.gte)(declaredVersion, firstVitestV5Version) ? 5 : 4;
+}
+function readInstalledPeerVitestRange(tree, peer) {
+    const packageJsonPath = `node_modules/${peer}/package.json`;
+    if (!tree.exists(packageJsonPath)) {
+        return null;
+    }
+    try {
+        const range = (0, devkit_1.readJson)(tree, packageJsonPath).peerDependencies?.vitest;
+        return typeof range === 'string' && (0, semver_1.validRange)(range) ? range : null;
+    }
+    catch {
+        return null;
+    }
 }
 function getInstalledVitestVersion(tree) {
     if (!tree) {
@@ -102,3 +134,5 @@ function getInstalledVitestMajorVersion(tree) {
     const installedVitestVersion = getInstalledVitestVersion(tree);
     return installedVitestVersion ? (0, semver_1.major)(installedVitestVersion) : null;
 }
+exports.viteTsconfigPathsVersion = '~4.3.2';
+exports.viteStaticCopyVersion = '^3.3.0';

package/dist/src/utils/vite-config-edit-utils.d.ts

@@ -1,3 +1,9 @@
 import { Tree } from '@nx/devkit';
 import { TargetFlags } from './generator-utils';
-export declare function ensureViteConfigIsCorrect(tree: Tree, path: string, buildConfigString: string, buildConfigObject: {}, imports: string[], plugins: string[], testConfigString: string, testConfigObject: {}, cacheDir: string, projectAlreadyHasViteTargets?: TargetFlags): boolean;
+export declare function ensureViteConfigIsCorrect(tree: Tree, path: string, buildConfigString: string, buildConfigObject: {}, imports: string[], plugins: string[], testConfigString: string, testConfigObject: {}, cacheDir: string, projectAlreadyHasViteTargets?: TargetFlags, resolveTsconfigPaths?: boolean): boolean;
+/**
+ * Enables Vite's native `resolve.tsconfigPaths`, which replaced the removed
+ * `nxViteTsPaths` plugin. Returns the file unchanged when it is already set or
+ * when the config's shape hides the object we would have to edit.
+ */
+export declare function addTsconfigPathsResolution(appFileContent: string): string;

package/dist/src/utils/vite-config-edit-utils.js

@@ -1,9 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ensureViteConfigIsCorrect = ensureViteConfigIsCorrect;
+exports.addTsconfigPathsResolution = addTsconfigPathsResolution;
 const devkit_1 = require("@nx/devkit");
 const js_1 = require("@nx/js");
-function ensureViteConfigIsCorrect(tree, path, buildConfigString, buildConfigObject, imports, plugins, testConfigString, testConfigObject, cacheDir, projectAlreadyHasViteTargets) {
+function ensureViteConfigIsCorrect(tree, path, buildConfigString, buildConfigObject, imports, plugins, testConfigString, testConfigObject, cacheDir, projectAlreadyHasViteTargets, resolveTsconfigPaths) {
     const fileContent = tree.read(path, 'utf-8');
     let updatedContent = undefined;
     if (!projectAlreadyHasViteTargets?.test && testConfigString?.length) {
@@ -18,6 +19,9 @@ function ensureViteConfigIsCorrect(tree, path, buildConfigString, buildConfigObj
     if (cacheDir?.length) {
         updatedContent = handleCacheDirNode(updatedContent ?? fileContent, cacheDir);
     }
+    if (resolveTsconfigPaths) {
+        updatedContent = addTsconfigPathsResolution(updatedContent ?? fileContent);
+    }
     if (updatedContent) {
         tree.write(path, updatedContent);
         return true;
@@ -301,6 +305,91 @@ function filterImport(appFileContent, imports) {
         return !importsArrayExisting?.includes(importString);
     });
 }
+/**
+ * Enables Vite's native `resolve.tsconfigPaths`, which replaced the removed
+ * `nxViteTsPaths` plugin. Returns the file unchanged when it is already set or
+ * when the config's shape hides the object we would have to edit.
+ */
+function addTsconfigPathsResolution(appFileContent) {
+    const { tsquery } = require('@phenomnomnominal/tsquery');
+    const tsModule = require('typescript');
+    const file = tsquery.ast(appFileContent);
+    const config = findConfigObject(tsModule, tsquery, file);
+    if (!config || config.properties.some(tsModule.isSpreadAssignment))
+        return appFileContent;
+    const existingResolve = config.properties.find((prop) => tsModule.isPropertyAssignment(prop) &&
+        stripQuotes(prop.name.getText()) === 'resolve');
+    if (existingResolve) {
+        const target = existingResolve.initializer;
+        if (!tsModule.isObjectLiteralExpression(target) ||
+            target.properties.some(tsModule.isSpreadAssignment))
+            return appFileContent;
+        if (target.properties.some((prop) => prop.name && stripQuotes(prop.name.getText()) === 'tsconfigPaths')) {
+            return appFileContent;
+        }
+        return (0, devkit_1.applyChangesToString)(appFileContent, [
+            {
+                type: devkit_1.ChangeType.Insert,
+                index: target.getStart() + 1,
+                text: `\n    tsconfigPaths: true,`,
+            },
+        ]);
+    }
+    return (0, devkit_1.applyChangesToString)(appFileContent, [
+        {
+            type: devkit_1.ChangeType.Insert,
+            index: config.getStart() + 1,
+            text: `\n  resolve: {\n    tsconfigPaths: true,\n  },`,
+        },
+    ]);
+}
+/**
+ * The object literal a Vite config ultimately exports. Handles `defineConfig`
+ * called with an object or with a factory, and a bare default export. Returns
+ * undefined when the config is assembled somewhere we cannot follow.
+ */
+function findConfigObject(tsModule, tsquery, file) {
+    const exportAssignment = tsquery.query(file, 'ExportAssignment')[0];
+    if (exportAssignment) {
+        return unwrapConfigExpression(tsModule, exportAssignment.expression);
+    }
+    const moduleExports = tsquery.query(file, 'BinaryExpression').find((node) => node.left.getText() === 'module.exports' &&
+        node.operatorToken.kind === tsModule.SyntaxKind.EqualsToken);
+    return moduleExports
+        ? unwrapConfigExpression(tsModule, moduleExports.right)
+        : undefined;
+}
+function unwrapConfigExpression(tsModule, node) {
+    if (!node)
+        return undefined;
+    if (tsModule.isParenthesizedExpression(node)) {
+        return unwrapConfigExpression(tsModule, node.expression);
+    }
+    if (tsModule.isObjectLiteralExpression(node))
+        return node;
+    if (tsModule.isCallExpression(node) &&
+        node.expression.getText() === 'defineConfig') {
+        return unwrapConfigExpression(tsModule, node.arguments[0]);
+    }
+    if (tsModule.isArrowFunction(node) || tsModule.isFunctionExpression(node)) {
+        if (!tsModule.isBlock(node.body)) {
+            return unwrapConfigExpression(tsModule, node.body);
+        }
+        // Only a single, unconditional return is safe to edit.
+        if (node.body.statements.some((statement) => !tsModule.isReturnStatement(statement) &&
+            !tsModule.isVariableStatement(statement) &&
+            !tsModule.isExpressionStatement(statement)))
+            return undefined;
+        const returns = node.body.statements.filter(tsModule.isReturnStatement);
+        return returns.length === 1
+            ? unwrapConfigExpression(tsModule, returns[0].expression)
+            : undefined;
+    }
+    return undefined;
+}
+function stripQuotes(text) {
+    return text.replace(/^['"`]|['"`]$/g, '');
+}
 function handleCacheDirNode(appFileContent, cacheDir) {
     const { tsquery } = require('@phenomnomnominal/tsquery');
     const file = tsquery.ast(appFileContent);

package/executors.json

@@ -1,10 +1,4 @@
 {
   "$schema": "https://json-schema.org/schema",
-  "executors": {
-    "test": {
-      "implementation": "./dist/src/executors/test/vitest.impl",
-      "schema": "./dist/src/executors/test/schema.json",
-      "description": "Test using Vitest"
-    }
-  }
+  "executors": {}
 }

package/migrations.json

@@ -43,6 +43,13 @@
       "description": "Migrate workspaces past breaking changes for Vitest 5.",
       "implementation": "./dist/src/migrations/update-23-3-0/migrate-to-vitest-5",
       "prompt": "./dist/src/migrations/update-23-3-0/ai-instructions-for-vitest-5.md"
+    },
+    "remove-deprecated-executors": {
+      "version": "24.0.0-beta.3",
+      "description": "Converts targets using the removed `@nx/vitest` executors to inferred tasks; an AI prompt finishes the targets the converter cannot convert safely and validates the project graph.",
+      "implementation": "./dist/src/migrations/update-24-0-0/remove-deprecated-executors",
+      "prompt": "./dist/src/migrations/update-24-0-0/finish-inferred-conversion.md",
+      "documentation": "./dist/src/migrations/update-24-0-0/remove-deprecated-executors.md"
     }
   },
   "packageJsonUpdates": {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@nx/vitest",
   "description": "The Nx Plugin for Vitest to enable fast unit testing with Vitest.",
-  "version": "24.0.0-beta.1",
+  "version": "24.0.0-beta.3",
   "type": "commonjs",
   "files": [
     "dist",
@@ -78,14 +78,14 @@
   "executors": "./executors.json",
   "generators": "./generators.json",
   "dependencies": {
-    "@nx/devkit": "24.0.0-beta.1",
-    "@nx/js": "24.0.0-beta.1",
+    "@nx/devkit": "24.0.0-beta.3",
+    "@nx/js": "24.0.0-beta.3",
     "tslib": "^2.3.0",
     "semver": "^7.6.3",
     "@phenomnomnominal/tsquery": "~6.2.0"
   },
   "peerDependencies": {
-    "@nx/eslint": "24.0.0-beta.1",
+    "@nx/eslint": "24.0.0-beta.3",
     "vitest": "^3.0.0 || ^4.0.0 || ^5.0.0",
     "vite": "^5.0.0 || ^6.0.0 || ^7.0.0 || ^8.0.0"
   },
@@ -101,6 +101,6 @@
     }
   },
   "devDependencies": {
-    "nx": "24.0.0-beta.1"
+    "nx": "24.0.0-beta.3"
   }
 }

package/dist/src/executors/test/compat.d.ts

@@ -1,2 +0,0 @@
-declare const _default: any;
-export default _default;

package/dist/src/executors/test/compat.js

@@ -1,6 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const tslib_1 = require("tslib");
-const devkit_1 = require("@nx/devkit");
-const vitest_impl_1 = tslib_1.__importDefault(require("./vitest.impl"));
-exports.default = (0, devkit_1.convertNxExecutor)(vitest_impl_1.default);

package/dist/src/executors/test/lib/nx-reporter.d.ts

@@ -1,18 +0,0 @@
-import type { Reporter, RunnerTestFile } from 'vitest/node';
-export declare class NxReporter implements Reporter {
-    private watch;
-    deferred: {
-        promise: Promise<boolean>;
-        resolve: (val: boolean) => void;
-    };
-    constructor(watch: boolean);
-    [Symbol.asyncIterator](): AsyncGenerator<{
-        hasErrors: boolean;
-    }, void, unknown>;
-    private setupDeferred;
-    /** Vitest ≥ 0.29 */
-    onTestRunEnd(files: any[], errors?: any): void;
-    /** Vitest ≤ 0.28 */
-    onFinished(files: RunnerTestFile[], errors?: unknown[]): void;
-    private _handleFinished;
-}

package/dist/src/executors/test/lib/nx-reporter.js

@@ -1,39 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.NxReporter = void 0;
-class NxReporter {
-    constructor(watch) {
-        this.watch = watch;
-        this.setupDeferred();
-    }
-    async *[Symbol.asyncIterator]() {
-        do {
-            const hasErrors = await this.deferred.promise;
-            yield { hasErrors };
-            this.setupDeferred();
-        } while (this.watch);
-    }
-    setupDeferred() {
-        let resolve;
-        this.deferred = {
-            promise: new Promise((res) => {
-                resolve = res;
-            }),
-            resolve,
-        };
-    }
-    /** Vitest ≥ 0.29 */
-    onTestRunEnd(files, errors) {
-        this._handleFinished(files, errors);
-    }
-    /** Vitest ≤ 0.28 */
-    onFinished(files, errors) {
-        this._handleFinished(files, errors);
-    }
-    // --- private ----------------------------------------------------------
-    _handleFinished(files, errors) {
-        const hasErrors = files.some((f) => f.result?.state === 'fail') || errors?.length > 0;
-        this.deferred.resolve(hasErrors);
-    }
-}
-exports.NxReporter = NxReporter;

package/dist/src/executors/test/lib/utils.d.ts

@@ -1,11 +0,0 @@
-import { ExecutorContext } from '@nx/devkit';
-import { VitestExecutorOptions } from '../schema';
-export declare function getOptions(options: VitestExecutorOptions, context: ExecutorContext, projectRoot: string): Promise<Record<string, any>>;
-/**
- * Nx's resolveNxTokensInOptions strips {workspaceRoot}/ from option values,
- * leaving a workspace-root-relative path. However, vitest resolves
- * reportsDirectory relative to the project root. This function converts
- * the path to absolute so vitest resolves it correctly.
- */
-export declare function resolveReportsDirectory(reportsDirectory: string): string;
-export declare function getOptionsAsArgv(obj: Record<string, any>): string[];

package/dist/src/executors/test/lib/utils.js

@@ -1,120 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getOptions = getOptions;
-exports.resolveReportsDirectory = resolveReportsDirectory;
-exports.getOptionsAsArgv = getOptionsAsArgv;
-const devkit_1 = require("@nx/devkit");
-const options_utils_1 = require("../../../utils/options-utils");
-const path_1 = require("path");
-const executor_utils_1 = require("../../../utils/executor-utils");
-const internal_1 = require("@nx/devkit/internal");
-async function getOptions(options, context, projectRoot) {
-    // Allows ESM to be required in CJS modules. Vite will be published as ESM in the future.
-    const { loadConfigFromFile } = await (0, executor_utils_1.loadViteDynamicImport)();
-    const viteConfigPath = (0, options_utils_1.normalizeViteConfigFilePath)(context.root, projectRoot, options.configFile);
-    if (!viteConfigPath) {
-        throw new Error((0, devkit_1.stripIndents) `
-        Unable to load test config from config file ${viteConfigPath}.
-        
-        Please make sure that vitest is configured correctly, 
-        or use the @nx/vitest:configuration generator to configure it for you.
-        You can read more here: https://nx.dev/nx-api/vitest/generators/configuration
-        `);
-    }
-    // Vitest derives the Vite config mode as `options.mode || runMode`, where
-    // runMode defaults to 'test' (or 'benchmark'). Resolve it once and reuse it
-    // for both this pre-load and the value forwarded to vitest below, so the
-    // config file resolves its mode-based branches identically on both loads.
-    const mode = options.mode ?? options.runMode ?? 'test';
-    const resolved = await loadConfigFromFile({
-        mode,
-        command: 'serve',
-    }, viteConfigPath);
-    if (!resolved?.config?.['test']) {
-        devkit_1.logger.warn((0, devkit_1.stripIndents) `Unable to load test config from config file ${resolved?.path ?? viteConfigPath}
-  Some settings may not be applied as expected.
-  You can manually set the config in the project, ${context.projectName}, configuration.
-        `);
-    }
-    const root = projectRoot === '.'
-        ? process.cwd()
-        : (0, path_1.relative)(context.cwd, (0, devkit_1.joinPathFragments)(context.root, projectRoot));
-    const { parseCLI } = await (0, executor_utils_1.loadVitestDynamicImport)();
-    // Use parseCLI for Vitest-specific normalization/validation
-    const { options: { watch, ...normalizedExtraArgs }, } = parseCLI(['vitest', ...getOptionsAsArgv(options)]);
-    // Filter out options that are handled specially or are parseCLI artifacts
-    const { 
-    // Handled specially by executor
-    testFiles: _testFiles, configFile: _configFile, mode: _mode, runMode: _runMode, reportsDirectory, coverage, reporter, reporters, 
-    // parseCLI artifacts
-    '--': _dashdash, color: _color, w: _w, 
-    // Pass through any additional Vitest options
-    ...passThroughOptions } = normalizedExtraArgs;
-    // Vitest keeps the UI/browser server alive only in watch mode and has no
-    // --ui -> watch link, so a run-once `nx test --ui` tears the UI down right
-    // after the run. When --ui is requested from an interactive, non-CI terminal,
-    // default watch on so the UI stays open; bare runs and CI stay run-once so
-    // `nx run-many`/`affected` don't hang. An explicit CLI --watch/--no-watch or a
-    // config `test.watch` still takes precedence.
-    const uiRequested = passThroughOptions.ui === true;
-    const watchForUi = uiRequested && !!process.stdin.isTTY && !(0, internal_1.isCI)();
-    return {
-        watch: watch ??
-            resolved?.config?.['test']?.watch ??
-            watchForUi,
-        // Pass through any additional Vitest options
-        ...passThroughOptions,
-        // This should not be needed as it's going to be set in vite.config.ts
-        // but leaving it here in case someone did not migrate correctly
-        root: resolved?.config?.root ?? root,
-        config: viteConfigPath,
-        // Forward the resolved mode so vitest reloads the config file with it;
-        // otherwise it falls back to its run-mode default and drops mode-based
-        // settings the pre-load above resolved (e.g. outputFile, coverage.reporter).
-        mode,
-        // Vitest's resolveConfig processes reporters in two steps:
-        // 1. options.reporters (plural) sets resolved.reporters
-        // 2. resolved.reporter (singular, from config) overwrites resolved.reporters
-        // Setting reporter to [] prevents config's reporter from overriding NxReporter
-        // (which is pushed onto reporters in vitest.impl.ts).
-        reporter: [],
-        reporters: reporter ??
-            reporters ??
-            // reporter (singular) has higher priority in vitest but is not declared in InlineConfig
-            resolved?.config?.['test']?.reporter ??
-            resolved?.config?.['test']?.reporters,
-        coverage: {
-            ...(coverage ?? {}),
-            ...(reportsDirectory && {
-                reportsDirectory: resolveReportsDirectory(reportsDirectory),
-            }),
-        },
-    };
-}
-/**
- * Nx's resolveNxTokensInOptions strips {workspaceRoot}/ from option values,
- * leaving a workspace-root-relative path. However, vitest resolves
- * reportsDirectory relative to the project root. This function converts
- * the path to absolute so vitest resolves it correctly.
- */
-function resolveReportsDirectory(reportsDirectory) {
-    if ((0, path_1.isAbsolute)(reportsDirectory)) {
-        return reportsDirectory;
-    }
-    return (0, path_1.resolve)(devkit_1.workspaceRoot, reportsDirectory);
-}
-function getOptionsAsArgv(obj) {
-    const argv = [];
-    for (const [key, value] of Object.entries(obj)) {
-        if (Array.isArray(value)) {
-            value.forEach((item) => argv.push(`--${key}=${item}`));
-        }
-        else if (typeof value === 'object' && value !== null) {
-            argv.push(`--${key}='${JSON.stringify(value)}'`);
-        }
-        else {
-            argv.push(`--${key}=${value}`);
-        }
-    }
-    return argv;
-}

package/dist/src/executors/test/schema.json

@@ -1,42 +0,0 @@
-{
-  "$schema": "https://json-schema.org/schema",
-  "version": 2,
-  "cli": "nx",
-  "title": "Vitest executor",
-  "description": "Test using Vitest.",
-  "type": "object",
-  "x-deprecated": "The `@nx/vitest:test` executor is deprecated and will be removed in Nx v24. Run `nx g @nx/vitest:convert-to-inferred` to migrate to the `@nx/vitest/plugin` inferred plugin. See https://nx.dev/docs/guides/tasks--caching/convert-to-inferred for details.",
-  "properties": {
-    "configFile": {
-      "type": "string",
-      "description": "The path to the local vitest config, relative to the workspace root.",
-      "x-completion-type": "file",
-      "x-completion-glob": "@(vitest|vite).config@(.js|.ts)",
-      "aliases": ["config"]
-    },
-    "reportsDirectory": {
-      "type": "string",
-      "description": "Directory to write coverage report to."
-    },
-    "mode": {
-      "type": "string",
-      "description": "Vite mode for loading configuration."
-    },
-    "runMode": {
-      "type": "string",
-      "description": "Vitest execution mode.",
-      "enum": ["test", "benchmark"],
-      "default": "test"
-    },
-    "testFiles": {
-      "aliases": ["testFile"],
-      "type": "array",
-      "items": { "type": "string" }
-    },
-    "watch": {
-      "description": "Watch files for changes and rerun tests related to changed files.",
-      "type": "boolean"
-    }
-  },
-  "required": []
-}

package/dist/src/executors/test/vitest.impl.d.ts

@@ -1,6 +0,0 @@
-import { ExecutorContext } from '@nx/devkit';
-import { VitestExecutorOptions } from './schema';
-export declare function vitestExecutor(options: VitestExecutorOptions, context: ExecutorContext): AsyncGenerator<never, {
-    success: boolean;
-}, unknown>;
-export default vitestExecutor;

package/dist/src/executors/test/vitest.impl.js

@@ -1,63 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.vitestExecutor = vitestExecutor;
-const devkit_1 = require("@nx/devkit");
-const path_1 = require("path");
-const internal_1 = require("@nx/js/internal");
-const nx_reporter_1 = require("./lib/nx-reporter");
-const utils_1 = require("./lib/utils");
-const executor_utils_1 = require("../../utils/executor-utils");
-const deprecation_1 = require("../../utils/deprecation");
-async function* vitestExecutor(options, context) {
-    (0, deprecation_1.warnVitestTestExecutorDeprecation)();
-    const projectRoot = context.projectsConfigurations.projects[context.projectName].root;
-    (0, internal_1.registerTsConfigPaths)((0, path_1.resolve)(devkit_1.workspaceRoot, projectRoot, 'tsconfig.json'));
-    process.env.VITE_CJS_IGNORE_WARNING = 'true';
-    // Allows ESM to be required in CJS modules. Vite will be published as ESM in the future.
-    const { startVitest } = await (0, executor_utils_1.loadVitestDynamicImport)();
-    const resolvedOptions = (await (0, utils_1.getOptions)(options, context, projectRoot)) ?? {};
-    const watch = resolvedOptions['watch'] === true;
-    const nxReporter = new nx_reporter_1.NxReporter(watch);
-    if (resolvedOptions['reporters'] === undefined) {
-        resolvedOptions['reporters'] = [];
-    }
-    else if (typeof resolvedOptions['reporters'] === 'string') {
-        resolvedOptions['reporters'] = [resolvedOptions['reporters']];
-    }
-    resolvedOptions['reporters'].push(nxReporter);
-    const cliFilters = options.testFiles ?? [];
-    const ctx = await startVitest(options.runMode ?? 'test', cliFilters, resolvedOptions, {
-        mode: options.mode ?? 'test',
-    });
-    let hasErrors = false;
-    const processExit = () => {
-        ctx.exit();
-        if (hasErrors) {
-            process.exit(1);
-        }
-        else {
-            process.exit(0);
-        }
-    };
-    if (watch) {
-        process.on('SIGINT', processExit);
-        process.on('SIGTERM', processExit);
-        process.on('exit', processExit);
-    }
-    // vitest sets the exitCode in case of exception without notifying reporters
-    if (process.exitCode === undefined ||
-        (watch && ctx.state.getFiles().length > 0)) {
-        for await (const report of nxReporter) {
-            // vitest sets the exitCode = 1 when code coverage isn't met
-            hasErrors =
-                report.hasErrors || (process.exitCode && process.exitCode !== 0);
-        }
-    }
-    else {
-        hasErrors = process.exitCode !== 0;
-    }
-    return {
-        success: !hasErrors,
-    };
-}
-exports.default = vitestExecutor;

package/dist/src/utils/deprecation.d.ts

@@ -1,3 +0,0 @@
-export declare const VITEST_TEST_EXECUTOR_DEPRECATION_MESSAGE = "The `@nx/vitest:test` executor is deprecated and will be removed in Nx v24. Run `nx g @nx/vitest:convert-to-inferred` to migrate to the `@nx/vitest/plugin` inferred targets. See https://nx.dev/docs/guides/tasks--caching/convert-to-inferred for details.";
-export declare function warnVitestTestExecutorDeprecation(): void;
-export declare function warnVitestExecutorGenerating(): void;

package/dist/src/utils/deprecation.js

@@ -1,19 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.VITEST_TEST_EXECUTOR_DEPRECATION_MESSAGE = void 0;
-exports.warnVitestTestExecutorDeprecation = warnVitestTestExecutorDeprecation;
-exports.warnVitestExecutorGenerating = warnVitestExecutorGenerating;
-const devkit_1 = require("@nx/devkit");
-// TODO(v24): Remove the @nx/vitest:test executor. The inferred plugin
-// (@nx/vitest/plugin) and the convert-to-inferred generator stay supported.
-exports.VITEST_TEST_EXECUTOR_DEPRECATION_MESSAGE = 'The `@nx/vitest:test` executor is deprecated and will be removed in Nx v24. Run `nx g @nx/vitest:convert-to-inferred` to migrate to the `@nx/vitest/plugin` inferred targets. See https://nx.dev/docs/guides/tasks--caching/convert-to-inferred for details.';
-function warnVitestTestExecutorDeprecation() {
-    devkit_1.logger.warn(exports.VITEST_TEST_EXECUTOR_DEPRECATION_MESSAGE);
-}
-// Fired when the @nx/vitest:configuration generator is about to generate a
-// target that uses the deprecated executor — i.e. when @nx/vitest/plugin
-// isn't registered in nx.json. Surfaces the deprecation at generation time
-// rather than only when the user later runs the generated target.
-function warnVitestExecutorGenerating() {
-    devkit_1.logger.warn('Generating a target that uses the deprecated `@nx/vitest:test` executor. This executor will be removed in Nx v24. Run `nx g @nx/vitest:convert-to-inferred` next to migrate this target to the `@nx/vitest/plugin` inferred plugin and prevent future generators from emitting executor targets. See https://nx.dev/docs/guides/tasks--caching/convert-to-inferred for details.');
-}

package/dist/src/utils/options-utils.d.ts

@@ -1,7 +0,0 @@
-import { ExecutorContext } from '@nx/devkit';
-/**
- * Returns the path to the vite config file or undefined when not found.
- */
-export declare function normalizeViteConfigFilePath(contextRoot: string, projectRoot: string, configFile?: string): string | undefined;
-export declare function getProjectTsConfigPath(projectRoot: string): string | undefined;
-export declare function getNxTargetOptions(target: string, context: ExecutorContext): any;

package/dist/src/utils/options-utils.js

@@ -1,41 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.normalizeViteConfigFilePath = normalizeViteConfigFilePath;
-exports.getProjectTsConfigPath = getProjectTsConfigPath;
-exports.getNxTargetOptions = getNxTargetOptions;
-const devkit_1 = require("@nx/devkit");
-const fs_1 = require("fs");
-/**
- * Returns the path to the vite config file or undefined when not found.
- */
-function normalizeViteConfigFilePath(contextRoot, projectRoot, configFile) {
-    if (configFile) {
-        const normalized = (0, devkit_1.joinPathFragments)(contextRoot, configFile);
-        if (!(0, fs_1.existsSync)(normalized)) {
-            throw new Error(`Could not find vite config at provided path "${normalized}".`);
-        }
-        return normalized;
-    }
-    const allowsExt = ['js', 'mjs', 'ts', 'cjs', 'mts', 'cts'];
-    for (const ext of allowsExt) {
-        if ((0, fs_1.existsSync)((0, devkit_1.joinPathFragments)(contextRoot, projectRoot, `vite.config.${ext}`))) {
-            return (0, devkit_1.joinPathFragments)(contextRoot, projectRoot, `vite.config.${ext}`);
-        }
-        else if ((0, fs_1.existsSync)((0, devkit_1.joinPathFragments)(contextRoot, projectRoot, `vitest.config.${ext}`))) {
-            return (0, devkit_1.joinPathFragments)(contextRoot, projectRoot, `vitest.config.${ext}`);
-        }
-    }
-}
-function getProjectTsConfigPath(projectRoot) {
-    return (0, fs_1.existsSync)((0, devkit_1.joinPathFragments)(devkit_1.workspaceRoot, projectRoot, 'tsconfig.app.json'))
-        ? (0, devkit_1.joinPathFragments)(projectRoot, 'tsconfig.app.json')
-        : (0, fs_1.existsSync)((0, devkit_1.joinPathFragments)(devkit_1.workspaceRoot, projectRoot, 'tsconfig.lib.json'))
-            ? (0, devkit_1.joinPathFragments)(projectRoot, 'tsconfig.lib.json')
-            : (0, fs_1.existsSync)((0, devkit_1.joinPathFragments)(devkit_1.workspaceRoot, projectRoot, 'tsconfig.json'))
-                ? (0, devkit_1.joinPathFragments)(projectRoot, 'tsconfig.json')
-                : undefined;
-}
-function getNxTargetOptions(target, context) {
-    const targetObj = (0, devkit_1.parseTargetString)(target, context);
-    return (0, devkit_1.readTargetOptions)(targetObj, context);
-}