@nx/vitest 23.0.0-pr.35413.460eeef → 23.0.0-rc.0

package/{executors.d.ts → dist/executors.d.ts}

@@ -1,3 +1,2 @@
 export { VitestExecutorOptions } from './src/executors/test/schema';
 export { vitestExecutor } from './src/executors/test/vitest.impl';
-//# sourceMappingURL=executors.d.ts.map

package/{generators.d.ts → dist/generators.d.ts}

@@ -1,4 +1,3 @@
 export * from './src/generators/init/init';
 export { configurationGenerator } from './src/generators/configuration/configuration';
 export { VitestGeneratorSchema } from './src/generators/configuration/schema';
-//# sourceMappingURL=generators.d.ts.map

package/dist/index.d.ts

@@ -0,0 +1 @@
+export { createNodes, createNodesV2, VitestPluginOptions, } from './src/plugins/plugin';

package/{index.js → dist/index.js}

@@ -1,5 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createNodesV2 = void 0;
+exports.createNodesV2 = exports.createNodes = void 0;
 var plugin_1 = require("./src/plugins/plugin");
+Object.defineProperty(exports, "createNodes", { enumerable: true, get: function () { return plugin_1.createNodes; } });
 Object.defineProperty(exports, "createNodesV2", { enumerable: true, get: function () { return plugin_1.createNodesV2; } });

package/{src → dist/src}/executors/test/compat.d.ts

@@ -1,3 +1,2 @@
 declare const _default: any;
 export default _default;
-//# sourceMappingURL=compat.d.ts.map

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

@@ -17,4 +17,3 @@ export declare class NxReporter implements Reporter {
     onFinished(files: RunnerTestFile[], errors?: unknown[]): void;
     private _handleFinished;
 }
-//# sourceMappingURL=nx-reporter.d.ts.map

package/{src → dist/src}/executors/test/lib/utils.d.ts

@@ -9,4 +9,3 @@ export declare function getOptions(options: VitestExecutorOptions, context: Exec
  */
 export declare function resolveReportsDirectory(reportsDirectory: string): string;
 export declare function getOptionsAsArgv(obj: Record<string, any>): string[];
-//# sourceMappingURL=utils.d.ts.map

package/{src → dist/src}/executors/test/schema.json

@@ -5,6 +5,7 @@
   "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",

package/{src → dist/src}/executors/test/vitest.impl.d.ts

@@ -4,4 +4,3 @@ export declare function vitestExecutor(options: VitestExecutorOptions, context:
     success: boolean;
 }, unknown>;
 export default vitestExecutor;
-//# sourceMappingURL=vitest.impl.d.ts.map

package/{src → dist/src}/executors/test/vitest.impl.js

@@ -3,11 +3,13 @@ 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/src/internal");
+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';

package/{src → dist/src}/generators/configuration/configuration.d.ts

@@ -6,4 +6,3 @@ import { VitestGeneratorSchema } from './schema';
 export declare function configurationGenerator(tree: Tree, schema: VitestGeneratorSchema, hasPlugin?: boolean): Promise<GeneratorCallback>;
 export declare function configurationGeneratorInternal(tree: Tree, schema: VitestGeneratorSchema, hasPlugin?: boolean): Promise<GeneratorCallback>;
 export default configurationGenerator;
-//# sourceMappingURL=configuration.d.ts.map

package/{src → dist/src}/generators/configuration/configuration.js

@@ -4,15 +4,17 @@ exports.configurationGenerator = configurationGenerator;
 exports.configurationGeneratorInternal = configurationGeneratorInternal;
 const tslib_1 = require("tslib");
 const devkit_1 = require("@nx/devkit");
+const internal_1 = require("@nx/devkit/internal");
 const js_1 = require("@nx/js");
-const ts_solution_setup_1 = require("@nx/js/src/utils/typescript/ts-solution-setup");
-const versions_1 = require("@nx/js/src/utils/versions");
+const internal_2 = require("@nx/js/internal");
 const path_1 = require("path");
 const ensure_dependencies_1 = require("../../utils/ensure-dependencies");
 const generator_utils_1 = require("../../utils/generator-utils");
 const init_1 = tslib_1.__importDefault(require("../init/init"));
 const detect_ui_framework_1 = require("../../utils/detect-ui-framework");
 const version_utils_1 = require("../../utils/version-utils");
+const versions_1 = require("../../utils/versions");
+const assert_supported_vitest_version_1 = require("../../utils/assert-supported-vitest-version");
 const semver_1 = require("semver");
 /**
  * Determines whether to use vitest.config.mts instead of vite.config.mts.
@@ -39,6 +41,7 @@ function configurationGenerator(tree, schema, hasPlugin = false) {
     return configurationGeneratorInternal(tree, { addPlugin: false, ...schema }, hasPlugin);
 }
 async function configurationGeneratorInternal(tree, schema, hasPlugin = false) {
+    (0, assert_supported_vitest_version_1.assertSupportedVitestVersion)(tree);
     // Setting default to jsdom since it is the most common use case (React, Web).
     // The @nx/js:lib generator specifically sets this to node to be more generic.
     schema.testEnvironment ??= 'jsdom';
@@ -123,10 +126,10 @@ getTestBed().initTestEnvironment(
         else if (uiFramework === 'react') {
             (0, generator_utils_1.createOrEditViteConfig)(tree, {
                 project: schema.project,
-                includeLib: (0, ts_solution_setup_1.getProjectType)(tree, root, projectType) === 'library',
+                includeLib: (0, internal_2.getProjectType)(tree, root, projectType) === 'library',
                 includeVitest: true,
                 inSourceTests: schema.inSourceTests,
-                rollupOptionsExternal: [
+                rolldownOptionsExternal: [
                     "'react'",
                     "'react-dom'",
                     "'react/jsx-runtime'",
@@ -146,7 +149,7 @@ getTestBed().initTestEnvironment(
             (0, generator_utils_1.createOrEditViteConfig)(tree, {
                 ...schema,
                 includeVitest: true,
-                includeLib: (0, ts_solution_setup_1.getProjectType)(tree, root, projectType) === 'library',
+                includeLib: (0, internal_2.getProjectType)(tree, root, projectType) === 'library',
                 useEsmExtension: true,
             }, true, {
                 vitestFileName: useVitestConfig,
@@ -154,22 +157,21 @@ getTestBed().initTestEnvironment(
             });
         }
     }
-    const isTsSolutionSetup = (0, ts_solution_setup_1.isUsingTsSolutionSetup)(tree);
+    const isTsSolutionSetup = (0, internal_2.isUsingTsSolutionSetup)(tree);
     createFiles(tree, schema, root, isTsSolutionSetup);
     updateTsConfig(tree, schema, root, projectType);
     if (isTsSolutionSetup) {
         // in the TS solution setup, the test target depends on the build outputs
         // so we need to setup the task pipeline accordingly
-        const nxJson = (0, devkit_1.readNxJson)(tree);
+        const nxJson = (0, devkit_1.readNxJson)(tree) ?? {};
         const testTarget = schema.testTarget ?? 'test';
-        nxJson.targetDefaults ??= {};
-        nxJson.targetDefaults[testTarget] ??= {};
-        nxJson.targetDefaults[testTarget].dependsOn ??= [];
-        nxJson.targetDefaults[testTarget].dependsOn = Array.from(new Set([...nxJson.targetDefaults[testTarget].dependsOn, '^build']));
+        const existing = findTestDefault(nxJson.targetDefaults, testTarget);
+        const dependsOn = Array.from(new Set([...(existing?.dependsOn ?? []), '^build']));
+        (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'] = versions_1.typesNodeVersion;
+    devDependencies['@types/node'] = internal_2.typesNodeVersion;
     if (!schema.skipPackageJson) {
         const installDependenciesTask = (0, devkit_1.addDependenciesToPackageJson)(tree, {}, devDependencies, undefined, true);
         tasks.push(installDependenciesTask);
@@ -231,7 +233,7 @@ function updateTsConfig(tree, options, projectRoot, projectType) {
             return json;
         });
     }
-    let runtimeTsconfigPath = (0, devkit_1.joinPathFragments)(projectRoot, (0, ts_solution_setup_1.getProjectType)(tree, projectRoot, projectType) === 'application'
+    let runtimeTsconfigPath = (0, devkit_1.joinPathFragments)(projectRoot, (0, internal_2.getProjectType)(tree, projectRoot, projectType) === 'application'
         ? 'tsconfig.app.json'
         : 'tsconfig.lib.json');
     if (options.runtimeTsconfigFileName) {
@@ -288,20 +290,20 @@ function createFiles(tree, options, projectRoot, isTsSolutionSetup) {
             : `${rootOffset}dist/out-tsc`,
     });
 }
-async function getCoverageProviderDependency(tree, coverageProvider) {
-    const { vitestCoverageV8, vitestCoverageIstanbul } = await (0, version_utils_1.getVitestDependenciesVersionsToInstall)(tree);
+function getCoverageProviderDependency(tree, coverageProvider) {
+    const { vitestCoverageV8Version, vitestCoverageIstanbulVersion } = (0, versions_1.versions)(tree);
     switch (coverageProvider) {
         case 'v8':
             return {
-                '@vitest/coverage-v8': vitestCoverageV8,
+                '@vitest/coverage-v8': vitestCoverageV8Version,
             };
         case 'istanbul':
             return {
-                '@vitest/coverage-istanbul': vitestCoverageIstanbul,
+                '@vitest/coverage-istanbul': vitestCoverageIstanbulVersion,
             };
         default:
             return {
-                '@vitest/coverage-v8': vitestCoverageV8,
+                '@vitest/coverage-v8': vitestCoverageV8Version,
             };
     }
 }
@@ -354,4 +356,14 @@ function findBuildTarget(project) {
     }
     return project.targets?.build ?? null;
 }
+function findTestDefault(td, target) {
+    if (!td)
+        return undefined;
+    if (Array.isArray(td)) {
+        return td.find((e) => e.target === target &&
+            e.projects === undefined &&
+            e.plugin === undefined);
+    }
+    return td[target];
+}
 exports.default = configurationGenerator;

package/dist/src/generators/convert-to-inferred/convert-to-inferred.d.ts

@@ -0,0 +1,7 @@
+import { type Tree } from '@nx/devkit';
+interface Schema {
+    project?: string;
+    skipFormat?: boolean;
+}
+export declare function convertToInferred(tree: Tree, options: Schema): Promise<void>;
+export default convertToInferred;

package/dist/src/generators/convert-to-inferred/convert-to-inferred.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.convertToInferred = convertToInferred;
+const devkit_1 = require("@nx/devkit");
+const internal_1 = require("@nx/devkit/internal");
+const plugin_1 = require("../../plugins/plugin");
+const test_post_target_transformer_1 = require("./lib/test-post-target-transformer");
+const assert_supported_vitest_version_1 = require("../../utils/assert-supported-vitest-version");
+async function convertToInferred(tree, options) {
+    (0, assert_supported_vitest_version_1.assertSupportedVitestVersion)(tree);
+    const projectGraph = await (0, devkit_1.createProjectGraphAsync)();
+    const migratedProjects = await (0, internal_1.migrateProjectExecutorsToPlugin)(tree, projectGraph, '@nx/vitest', plugin_1.createNodesV2, { testTargetName: 'test' }, [
+        {
+            executors: ['@nx/vitest:test'],
+            postTargetTransformer: test_post_target_transformer_1.testPostTargetTransformer,
+            targetPluginOptionMapper: (target) => ({ testTargetName: target }),
+        },
+    ], options.project);
+    if (migratedProjects.size === 0) {
+        throw new internal_1.NoTargetsToMigrateError();
+    }
+    if (!options.skipFormat) {
+        await (0, devkit_1.formatFiles)(tree);
+    }
+}
+exports.default = convertToInferred;

package/dist/src/generators/convert-to-inferred/lib/test-post-target-transformer.d.ts

@@ -0,0 +1,5 @@
+import { type TargetConfiguration, type Tree } from '@nx/devkit';
+export declare function testPostTargetTransformer(target: TargetConfiguration, tree: Tree, projectDetails: {
+    projectName: string;
+    root: string;
+}, inferredTargetConfiguration: TargetConfiguration): TargetConfiguration<any>;

package/dist/src/generators/convert-to-inferred/lib/test-post-target-transformer.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.testPostTargetTransformer = testPostTargetTransformer;
+const internal_1 = require("@nx/devkit/internal");
+const utils_1 = require("./utils");
+function testPostTargetTransformer(target, tree, projectDetails, inferredTargetConfiguration) {
+    if (target.options) {
+        removePropertiesFromTargetOptions(target.options, projectDetails.root);
+    }
+    if (target.configurations) {
+        for (const configurationName in target.configurations) {
+            const configuration = target.configurations[configurationName];
+            removePropertiesFromTargetOptions(configuration, projectDetails.root);
+        }
+        if (Object.keys(target.configurations).length === 0) {
+            if ('defaultConfiguration' in target) {
+                delete target.defaultConfiguration;
+            }
+            delete target.configurations;
+        }
+        if ('defaultConfiguration' in target &&
+            !target.configurations[target.defaultConfiguration]) {
+            delete target.defaultConfiguration;
+        }
+    }
+    if (target.outputs) {
+        (0, internal_1.processTargetOutputs)(target, [{ newName: 'coverage.reportsDirectory', oldName: 'reportsDirectory' }], inferredTargetConfiguration, {
+            projectName: projectDetails.projectName,
+            projectRoot: projectDetails.root,
+        });
+    }
+    if (target.inputs &&
+        target.inputs.every((i) => i === 'default' || i === '^production')) {
+        delete target.inputs;
+    }
+    return target;
+}
+function removePropertiesFromTargetOptions(targetOptions, projectRoot) {
+    if ('configFile' in targetOptions) {
+        targetOptions.config = (0, utils_1.toProjectRelativePath)(targetOptions.configFile, projectRoot);
+        delete targetOptions.configFile;
+    }
+    if ('reportsDirectory' in targetOptions) {
+        if (targetOptions.reportsDirectory.startsWith('../')) {
+            targetOptions.reportsDirectory = targetOptions.reportsDirectory.replace(/(\.\.\/)+/, '');
+        }
+        targetOptions['coverage.reportsDirectory'] = (0, utils_1.toProjectRelativePath)(targetOptions.reportsDirectory, projectRoot);
+        delete targetOptions.reportsDirectory;
+    }
+    if ('testFiles' in targetOptions) {
+        targetOptions.testNamePattern = `"/(${targetOptions.testFiles
+            .map((f) => f.replace('.', '\\.'))
+            .join('|')})/"`;
+        delete targetOptions.testFiles;
+    }
+}

package/dist/src/generators/convert-to-inferred/lib/utils.d.ts

@@ -0,0 +1 @@
+export declare function toProjectRelativePath(path: string, projectRoot: string): string;

package/dist/src/generators/convert-to-inferred/lib/utils.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toProjectRelativePath = toProjectRelativePath;
+const posix_1 = require("path/posix");
+const devkit_1 = require("@nx/devkit");
+function toProjectRelativePath(path, projectRoot) {
+    if (projectRoot === '.') {
+        return path.startsWith('.') ? path : `./${path}`;
+    }
+    const relativePath = (0, posix_1.relative)((0, posix_1.resolve)(devkit_1.workspaceRoot, projectRoot), (0, posix_1.resolve)(devkit_1.workspaceRoot, path));
+    return relativePath.startsWith('.') ? relativePath : `./${relativePath}`;
+}

package/dist/src/generators/convert-to-inferred/schema.json

@@ -0,0 +1,19 @@
+{
+  "$schema": "https://json-schema.org/schema",
+  "$id": "NxVitestConvertToInferred",
+  "description": "Convert existing vitest project(s) using `@nx/vitest:test` executors to use the `@nx/vitest` inferred plugin. Defaults to migrating all projects. Pass '--project' to migrate only one target.",
+  "title": "Convert vitest project from executor to inferred plugin",
+  "type": "object",
+  "properties": {
+    "project": {
+      "type": "string",
+      "description": "The project to convert from using the `@nx/vitest:test` executor to use the `@nx/vitest` inferred plugin.",
+      "x-priority": "important"
+    },
+    "skipFormat": {
+      "type": "boolean",
+      "description": "Whether to format files at the end of the migration.",
+      "default": false
+    }
+  }
+}

package/{src → dist/src}/generators/init/init.d.ts

@@ -4,4 +4,3 @@ export declare function updateDependencies(tree: Tree, schema: InitGeneratorSche
 export declare function updateNxJsonSettings(tree: Tree): void;
 export declare function initGenerator(tree: Tree, schema: InitGeneratorSchema): Promise<GeneratorCallback>;
 export default initGenerator;
-//# sourceMappingURL=init.d.ts.map

package/{src → dist/src}/generators/init/init.js

@@ -3,12 +3,13 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.updateDependencies = updateDependencies;
 exports.updateNxJsonSettings = updateNxJsonSettings;
 exports.initGenerator = initGenerator;
+const internal_1 = require("@nx/devkit/internal");
 const devkit_1 = require("@nx/devkit");
-const add_plugin_1 = require("@nx/devkit/src/utils/add-plugin");
 const versions_1 = require("../../utils/versions");
 const plugin_1 = require("../../plugins/plugin");
 const version_utils_1 = require("../../utils/version-utils");
 const ignore_vitest_temp_files_1 = require("../../utils/ignore-vitest-temp-files");
+const assert_supported_vitest_version_1 = require("../../utils/assert-supported-vitest-version");
 function updateDependencies(tree, schema) {
     // Determine which vite version to install:
     // 1. Explicit viteVersion flag takes priority
@@ -26,10 +27,10 @@ function updateDependencies(tree, schema) {
         '@nx/vitest': versions_1.nxVersion,
         vitest: versions_1.vitestVersion,
         vite: viteVersionToUse,
-    }, undefined, schema.keepExistingVersions);
+    }, undefined, schema.keepExistingVersions ?? true);
 }
 function updateNxJsonSettings(tree) {
-    const nxJson = (0, devkit_1.readNxJson)(tree);
+    const nxJson = (0, devkit_1.readNxJson)(tree) ?? {};
     const productionFileSet = nxJson.namedInputs?.production;
     if (productionFileSet) {
         productionFileSet.push('!{projectRoot}/**/?(*.)+(spec|test).[jt]s?(x)?(.snap)', '!{projectRoot}/tsconfig.spec.json');
@@ -37,23 +38,29 @@ function updateNxJsonSettings(tree) {
     }
     const hasPlugin = nxJson.plugins?.some((p) => typeof p === 'string' ? p === '@nx/vitest' : p.plugin === '@nx/vitest');
     if (!hasPlugin) {
-        nxJson.targetDefaults ??= {};
-        nxJson.targetDefaults['@nx/vitest:test'] ??= {};
-        nxJson.targetDefaults['@nx/vitest:test'].cache ??= true;
-        nxJson.targetDefaults['@nx/vitest:test'].inputs ??= [
-            'default',
-            productionFileSet ? '^production' : '^default',
-        ];
+        const existing = (0, internal_1.normalizeTargetDefaults)(nxJson.targetDefaults).find((e) => e.executor === '@nx/vitest:test' &&
+            e.target === undefined &&
+            e.projects === undefined &&
+            e.plugin === undefined);
+        (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, add_plugin_1.addPlugin)(tree, await (0, devkit_1.createProjectGraphAsync)(), '@nx/vitest', plugin_1.createNodesV2, {
+        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);

package/{src → dist/src}/generators/init/schema.json

@@ -18,7 +18,7 @@
       "type": "boolean",
       "x-priority": "internal",
       "description": "Keep existing dependencies versions",
-      "default": false
+      "default": true
     },
     "updatePackageScripts": {
       "type": "boolean",

package/{src → dist/src}/migrations/update-22-6-0/prefix-reports-directory-with-project-root.d.ts

@@ -7,4 +7,3 @@ import { type Tree } from '@nx/devkit';
  * {projectRoot}/ to existing naked paths so the resolved location stays the same.
  */
 export default function prefixReportsDirectoryWithProjectRoot(tree: Tree): void;
-//# sourceMappingURL=prefix-reports-directory-with-project-root.d.ts.map

package/{src → dist/src}/migrations/update-22-6-0/prefix-reports-directory-with-project-root.js

@@ -1,8 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.default = prefixReportsDirectoryWithProjectRoot;
+const internal_1 = require("@nx/devkit/internal");
 const devkit_1 = require("@nx/devkit");
-const executor_options_utils_1 = require("@nx/devkit/src/generators/executor-options-utils");
 const path_1 = require("path");
 /**
  * Migrates reportsDirectory option for @nx/vitest:test and @nx/vite:test executors.
@@ -18,7 +18,7 @@ function prefixReportsDirectoryWithProjectRoot(tree) {
 function migrateProjectConfigurations(tree) {
     const projectsToUpdate = new Map();
     for (const executorName of ['@nx/vitest:test', '@nx/vite:test']) {
-        (0, executor_options_utils_1.forEachExecutorOptions)(tree, executorName, (options, projectName, targetName, configuration) => {
+        (0, internal_1.forEachExecutorOptions)(tree, executorName, (options, projectName, targetName, configuration) => {
             if (needsMigration(options.reportsDirectory)) {
                 if (!projectsToUpdate.has(projectName)) {
                     projectsToUpdate.set(projectName, new Map());

package/dist/src/migrations/update-22-6-0/prefix-reports-directory-with-project-root.md

@@ -0,0 +1,35 @@
+#### Prefix `reportsDirectory` with `{projectRoot}`
+
+The `reportsDirectory` option for `@nx/vitest:test` (and `@nx/vite:test`) is now resolved relative to the workspace root instead of the project root. This migration prepends `{projectRoot}/` to existing `reportsDirectory` values so the resolved path remains the same.
+
+#### Sample Code Changes
+
+##### Before
+
+```json title="project.json"
+{
+  "targets": {
+    "test": {
+      "executor": "@nx/vitest:test",
+      "options": {
+        "reportsDirectory": "coverage/libs/my-lib"
+      }
+    }
+  }
+}
+```
+
+##### After
+
+```json title="project.json" {6}
+{
+  "targets": {
+    "test": {
+      "executor": "@nx/vitest:test",
+      "options": {
+        "reportsDirectory": "{projectRoot}/coverage/libs/my-lib"
+      }
+    }
+  }
+}
+```

package/dist/src/migrations/update-23-0-0/migrate-create-nodes-v2-to-create-nodes.d.ts

@@ -0,0 +1,9 @@
+import { type Tree } from '@nx/devkit';
+export default function migrateCreateNodesV2ToCreateNodes(tree: Tree): Promise<void>;
+/**
+ * Rewrites named imports and re-exports of `createNodesV2` to `createNodes`
+ * when they come from one of the given module specifiers. Only the named
+ * bindings are touched — the module specifier, the `import`/`export` keyword,
+ * any `type` modifier, and any default import are left untouched.
+ */
+export declare function rewriteCreateNodesV2Imports(source: string, specifiers: ReadonlySet<string>): string;