@nx/vitest 23.2.0-beta.0 → 23.2.0-beta.10

package/dist/internal.d.ts

@@ -0,0 +1,7 @@
+/**
+ * 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
+ * `addLintingToProject` reads it through `ensurePackage`.
+ */
+export declare const oxlintPlugins: string[];
+export { createOrEditViteConfig, ViteConfigFileOptions, } from './src/utils/generator-utils';

package/dist/internal.js

@@ -0,0 +1,16 @@
+"use strict";
+// Semi-private surface for first-party Nx packages.
+//
+// External plugins should NOT import from here — this entry is curated for
+// internal consumers and may change without semver protection. Mirrors
+// `@nx/devkit/internal`.
+Object.defineProperty(exports, "__esModule", { value: true });
+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
+ * `addLintingToProject` reads it through `ensurePackage`.
+ */
+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; } });

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

@@ -7,7 +7,7 @@ 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 devkit_internals_1 = require("nx/src/devkit-internals");
+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)();
@@ -57,7 +57,7 @@ async function getOptions(options, context, projectRoot) {
     // `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, devkit_internals_1.isCI)();
+    const watchForUi = uiRequested && !!process.stdin.isTTY && !(0, internal_1.isCI)();
     return {
         watch: watch ??
             resolved?.config?.['test']?.watch ??

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

@@ -17,6 +17,17 @@ const versions_1 = require("../../utils/versions");
 const assert_supported_vitest_version_1 = require("../../utils/assert-supported-vitest-version");
 const semver_1 = require("semver");
 let ts;
+// Must match `vitestWorkspaceFiles` in ../../plugins/plugin.ts, or the guards
+// here and inference disagree about what counts as an existing workspace file.
+const WORKSPACE_FILE_EXTENSIONS = [
+    'ts',
+    'mts',
+    'cts',
+    'js',
+    'mjs',
+    'cjs',
+    'json',
+];
 /**
  * Determines whether to use vitest.config.mts instead of vite.config.mts.
  * Returns true for new non-framework projects that don't already have a vite.config.
@@ -121,6 +132,7 @@ getTestBed().initTestEnvironment(
                 imports: [`import angular from '@analogjs/vite-plugin-angular'`],
                 plugins: ['angular()'],
                 setupFile: relativeTestSetupPath,
+                passWithNoTests: schema.passWithNoTests,
                 useEsmExtension: true,
             }, true, { skipPackageJson: schema.skipPackageJson });
         }
@@ -141,7 +153,10 @@ getTestBed().initTestEnvironment(
                         : `import react from '@vitejs/plugin-react'`,
                 ],
                 plugins: ['react()'],
-                coverageProvider: schema.coverageProvider,
+                coverageProvider: schema.coverageProvider === 'none'
+                    ? undefined
+                    : schema.coverageProvider,
+                passWithNoTests: schema.passWithNoTests,
                 useEsmExtension: true,
             }, true, { skipPackageJson: schema.skipPackageJson });
         }
@@ -186,7 +201,7 @@ getTestBed().initTestEnvironment(
         const projectGlobs = `'**/vite.config.{mjs,js,ts,mts}', '**/vitest.config.{mjs,js,ts,mts}'`;
         const vitestMajorVersion = (0, versions_1.getInstalledVitestMajorVersion)(tree);
         if (vitestMajorVersion === null || vitestMajorVersion >= 4) {
-            const hasWorkspaceFile = ['ts', 'js', 'json'].some((ext) => tree.exists(`vitest.workspace.${ext}`) ||
+            const hasWorkspaceFile = WORKSPACE_FILE_EXTENSIONS.some((ext) => tree.exists(`vitest.workspace.${ext}`) ||
                 tree.exists(`vitest.projects.${ext}`));
             const rootVitestConfig = findRootConfig(tree, 'vitest.config');
             const rootViteConfig = findRootConfig(tree, 'vite.config');
@@ -239,7 +254,9 @@ getTestBed().initTestEnvironment(
                 // root vite.config added later; exclude both so neither is resolved as
                 // an extra project that, carrying no `include`, re-runs every spec via
                 // the default glob.
-                tree.write('vitest.config.ts', `import { defineConfig } from 'vitest/config';
+                // `.mts` keeps it ESM whatever the root package.json `type` is; a
+                // CommonJS-loaded config trips Vite's `configLoader: 'native'` warning.
+                tree.write('vitest.config.mts', `import { defineConfig } from 'vitest/config';
 
 export default defineConfig({
   test: {
@@ -249,13 +266,9 @@ export default defineConfig({
 `);
             }
         }
-        else if (!tree.exists(`vitest.workspace.ts`) &&
-            !tree.exists(`vitest.workspace.js`) &&
-            !tree.exists(`vitest.workspace.json`) &&
-            !tree.exists(`vitest.projects.ts`) &&
-            !tree.exists(`vitest.projects.js`) &&
-            !tree.exists(`vitest.projects.json`)) {
-            tree.write('vitest.workspace.ts', `export default [${projectGlobs}];`);
+        else if (!WORKSPACE_FILE_EXTENSIONS.some((ext) => tree.exists(`vitest.workspace.${ext}`) ||
+            tree.exists(`vitest.projects.${ext}`))) {
+            tree.write('vitest.workspace.mts', `export default [${projectGlobs}];`);
         }
     }
     if (!schema.skipFormat) {
@@ -373,6 +386,8 @@ function getCoverageProviderDependency(tree, coverageProvider) {
             return {
                 '@vitest/coverage-istanbul': vitestCoverageIstanbulVersion,
             };
+        case 'none':
+            return {};
         default:
             return {
                 '@vitest/coverage-v8': vitestCoverageV8Version,

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

@@ -1,7 +1,7 @@
 export interface VitestGeneratorSchema {
   project: string;
   uiFramework?: 'angular' | 'react' | 'vue' | 'none';
-  coverageProvider: 'v8' | 'istanbul' | 'custom';
+  coverageProvider: 'v8' | 'istanbul' | 'custom' | 'none';
   inSourceTests?: boolean;
   skipViteConfig?: boolean;
   testTarget?: string;
@@ -11,6 +11,7 @@ export interface VitestGeneratorSchema {
   addPlugin?: boolean;
   runtimeTsconfigFileName?: string;
   compiler?: 'babel' | 'swc'; // default: babel
+  passWithNoTests?: boolean;
   // internal options
   projectType?: 'application' | 'library';
   viteVersion?: 5 | 6 | 7 | 8;

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

@@ -30,7 +30,7 @@
     },
     "coverageProvider": {
       "type": "string",
-      "enum": ["v8", "istanbul", "custom"],
+      "enum": ["v8", "istanbul", "custom", "none"],
       "default": "v8",
       "description": "Coverage provider to use."
     },
@@ -66,6 +66,12 @@
       "description": "Do not add dependencies to `package.json`.",
       "x-priority": "internal"
     },
+    "passWithNoTests": {
+      "type": "boolean",
+      "default": false,
+      "description": "Exit with a zero status when the project has no test files.",
+      "x-priority": "internal"
+    },
     "zoneless": {
       "type": "boolean",
       "description": "Whether the Angular project is zoneless. When not provided, it is auto-detected from the project configuration.",

package/dist/src/migrations/update-23-2-0/use-import-meta-dirname.d.ts

@@ -0,0 +1,3 @@
+import { type Tree } from '@nx/devkit';
+export default function useImportMetaDirname(tree: Tree): Promise<void>;
+export declare function rewriteDirname(source: string): string;

package/dist/src/migrations/update-23-2-0/use-import-meta-dirname.js

@@ -0,0 +1,108 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = useImportMetaDirname;
+exports.rewriteDirname = rewriteDirname;
+const devkit_1 = require("@nx/devkit");
+// Only ESM-only extensions. A `.ts`/`.js` config can still be loaded as CJS,
+// where `import.meta` is a syntax error.
+const CONFIG_FILE_PATTERN = /(^|\/)(vite|vitest)\.config\.(mts|mjs)$/;
+let ts;
+async function useImportMetaDirname(tree) {
+    let touchedCount = 0;
+    (0, devkit_1.visitNotIgnoredFiles)(tree, '.', (filePath) => {
+        if (!CONFIG_FILE_PATTERN.test(filePath)) {
+            return;
+        }
+        const original = tree.read(filePath, 'utf-8');
+        if (!original?.includes('__dirname')) {
+            return;
+        }
+        const updated = rewriteDirname(original);
+        if (updated !== original) {
+            tree.write(filePath, updated);
+            touchedCount += 1;
+        }
+    });
+    if (touchedCount > 0) {
+        devkit_1.logger.info(`Replaced \`__dirname\` with \`import.meta.dirname\` in ${touchedCount} Vite config file(s).`);
+    }
+    await (0, devkit_1.formatFiles)(tree);
+}
+function rewriteDirname(source) {
+    ts ??= (0, devkit_1.ensurePackage)('typescript', '*');
+    const sourceFile = ts.createSourceFile('tmp.mts', source, ts.ScriptTarget.Latest, 
+    /* setParentNodes */ true, ts.ScriptKind.TS);
+    // A config TypeScript can only error-recover on may not mean what its AST
+    // says, so leave it for a human rather than rewrite it blind.
+    if (sourceFile.parseDiagnostics?.length) {
+        return source;
+    }
+    const references = [];
+    let bailOut = false;
+    const visit = (node) => {
+        if (ts.isIdentifier(node) && node.text === '__dirname') {
+            const kind = classify(node);
+            if (kind === 'bail') {
+                bailOut = true;
+            }
+            else if (kind === 'reference') {
+                references.push(node);
+            }
+        }
+        ts.forEachChild(node, visit);
+    };
+    visit(sourceFile);
+    if (bailOut || references.length === 0) {
+        return source;
+    }
+    let updated = source;
+    for (const node of references.reverse()) {
+        const start = node.getStart(sourceFile);
+        updated =
+            updated.slice(0, start) +
+                'import.meta.dirname' +
+                updated.slice(node.getEnd());
+    }
+    return updated;
+}
+/**
+ * `bail` abandons the whole file: something binds `__dirname` in scope, so the
+ * identifier no longer means the CJS global, or it is a shorthand property
+ * where key and value are one token. `skip` leaves a single identifier alone.
+ *
+ * The name-position test is inverted on purpose - anything sitting in a
+ * parent's `name` or `propertyName` slot is excluded by default, so node kinds
+ * nobody enumerated (class fields, accessors, enum members) cannot be rewritten
+ * into invalid syntax.
+ */
+function classify(node) {
+    const parent = node.parent;
+    if (!parent) {
+        return 'reference';
+    }
+    if (ts.isShorthandPropertyAssignment(parent)) {
+        return 'bail';
+    }
+    if (bindsDirname(parent, node)) {
+        return 'bail';
+    }
+    if (parent.name === node || parent.propertyName === node) {
+        return 'skip';
+    }
+    return 'reference';
+}
+/** Declarations that put a new `__dirname` in scope, shadowing the global. */
+function bindsDirname(parent, node) {
+    if (parent.name !== node) {
+        return false;
+    }
+    return (ts.isVariableDeclaration(parent) ||
+        ts.isParameter(parent) ||
+        ts.isBindingElement(parent) ||
+        ts.isFunctionDeclaration(parent) ||
+        ts.isClassDeclaration(parent) ||
+        ts.isImportClause(parent) ||
+        ts.isImportSpecifier(parent) ||
+        ts.isNamespaceImport(parent) ||
+        ts.isExportSpecifier(parent));
+}

package/dist/src/migrations/update-23-2-0/use-import-meta-dirname.md

@@ -0,0 +1,36 @@
+#### Replace `__dirname` with `import.meta.dirname` in Vite config files
+
+Vite 8 warns when a config uses features that its `configLoader: 'native'` mode cannot support, and `__dirname` is one of them:
+
+```
+(!) Your Vite config uses features that are unsupported by `configLoader: 'native'`, which is planned to become the default in a future major version of Vite:
+  - `__dirname` (packages/utils/vitest.config.mts:4:9). Use `import.meta.dirname` instead
+```
+
+This migration rewrites `__dirname` to `import.meta.dirname` in every `vite.config.mts`, `vite.config.mjs`, `vitest.config.mts`, and `vitest.config.mjs` file in your workspace.
+
+#### Sample Code Changes
+
+##### Before
+
+```ts
+export default defineConfig(() => ({
+  root: __dirname,
+}));
+```
+
+##### After
+
+```ts
+export default defineConfig(() => ({
+  root: import.meta.dirname,
+}));
+```
+
+#### What is not rewritten
+
+`.ts` and `.js` configs are left alone, since those extensions can still be loaded as CommonJS, where `import.meta` is a syntax error. Configs that declare their own `__dirname` (usually `const __dirname = path.dirname(fileURLToPath(import.meta.url))`) are also left alone - that idiom already works under the native config loader.
+
+No migration renames an existing config to `.mts`, because other tooling may reference it by path. So a workspace whose config is `.ts` keeps the companion warning about ESM syntax in a CommonJS-loaded file. Rename it yourself, or set `"type": "module"` in the closest `package.json`, to clear that one. Newly generated configs use `.mts` and are unaffected.
+
+One generated case does put `import.meta.dirname` in a `.ts` config: `@nx/nuxt` falls back to `.ts` on workspaces still using eslintrc, because the legacy `@nuxt/eslint-config` cannot parse `.mts`. Vite's default config loader bundles that file, so it works today, but the file is not loadable under `configLoader: 'native'` - its own `import` statements already make it so.

package/dist/src/plugins/plugin.d.ts

@@ -15,6 +15,27 @@ export interface VitestPluginOptions {
      * - 'run': Tests run once and exit
      */
     testMode?: 'watch' | 'run';
+    /**
+     * How atomized test files (the `ciTargetName` targets) are discovered.
+     * - 'glob' (default): enumerate specs with a glob that mirrors Vitest's own
+     *   resolution instead of booting Vitest per project. Booting Vitest starts a
+     *   Vite dev server and runs the config's plugin hooks, so the glob is faster
+     *   during graph creation. The glob reads the Nx workspace file index, so
+     *   files ignored by `.gitignore`/`.nxignore` are never enumerated even when
+     *   Vitest itself would run them.
+     * - 'vitest': always enumerate through Vitest.
+     *
+     * Configs a glob cannot reproduce faithfully still boot Vitest automatically
+     * even under 'glob': `test.projects`/`test.workspace` (inline or an
+     * auto-loaded `vitest.workspace.*`/`vitest.projects.*` sibling file), plugins
+     * with a `configureVitest` hook, `test.changed`/`test.related`, enabled
+     * browser `instances` that set their own include/exclude/includeSource/dir,
+     * and `include`, `exclude`, `includeSource`, or `typecheck` include/exclude
+     * patterns the workspace glob reads differently (absolute paths, a trailing
+     * `/`, or an `!(...)` extglob, each optionally negated).
+     * @default 'glob'
+     */
+    discoverTestFiles?: 'glob' | 'vitest';
 }
 /**
  * @deprecated The 'createDependencies' function is now a no-op. This functionality is included in 'createNodesV2'.

package/dist/src/plugins/plugin.js

@@ -6,10 +6,8 @@ const devkit_1 = require("@nx/devkit");
 const js_1 = require("@nx/js");
 const internal_2 = require("@nx/js/internal");
 const node_fs_1 = require("node:fs");
+const promises_1 = require("node:fs/promises");
 const node_path_1 = require("node:path");
-const file_hasher_1 = require("nx/src/hasher/file-hasher");
-const cache_directory_1 = require("nx/src/utils/cache-directory");
-const plugins_1 = require("nx/src/utils/plugins");
 const executor_utils_1 = require("../utils/executor-utils");
 /**
  * @deprecated The 'createDependencies' function is now a no-op. This functionality is included in 'createNodesV2'.
@@ -23,9 +21,9 @@ exports.createNodes = [
     vitestConfigGlob,
     async (configFilePaths, options, context) => {
         const pmc = (0, devkit_1.getPackageManagerCommand)((0, devkit_1.detectPackageManager)(context.workspaceRoot));
-        const optionsHash = (0, file_hasher_1.hashObject)(options);
+        const optionsHash = (0, internal_1.hashObject)(options);
         const normalizedOptions = normalizeOptions(options);
-        const cachePath = (0, node_path_1.join)(cache_directory_1.workspaceDataDirectory, `vitest-${optionsHash}.hash`);
+        const cachePath = (0, node_path_1.join)(internal_1.workspaceDataDirectory, `vitest-${optionsHash}.hash`);
         const targetsCache = new internal_1.PluginCache(cachePath);
         const { roots: projectRoots, configFiles: validConfigFiles } = configFilePaths.reduce((acc, configFile) => {
             const potentialRoot = (0, node_path_1.dirname)(configFile);
@@ -129,9 +127,7 @@ async function buildVitestTargets(configFilePath, projectRoot, options, context,
     // entirely so it does not register a project rooted at the workspace root (which
     // would, for example, make `nx format` treat the whole workspace as one project).
     const isWorkspaceRoot = projectRoot === '.';
-    // TODO(jack): Remove this cast when @nx/vitest switches to moduleResolution:
-    // "nodenext". Vite 8's rolldown types break vitest's test augmentation.
-    const hasProjectsProperty = Array.isArray(viteBuildConfig?.test?.projects);
+    const hasProjectsProperty = Array.isArray(viteBuildConfig.test?.projects);
     if (isWorkspaceRoot && hasProjectsProperty) {
         return null;
     }
@@ -141,11 +137,10 @@ async function buildVitestTargets(configFilePath, projectRoot, options, context,
     const targets = {};
     // if file is vitest.config or vite.config has definition for test, create targets for test and/or atomized tests
     if (configFilePath.includes('vitest.config') || hasTest) {
-        const isTypecheckEnabled = !!viteBuildConfig?.test?.typecheck
-            ?.enabled;
+        const isTypecheckEnabled = !!viteBuildConfig.test?.typecheck?.enabled;
         targets[options.testTargetName] = await testTarget(namedInputs, testOutputs, projectRoot, options.testMode, pmc, isTypecheckEnabled, tsconfigInputs);
         if (options.ciTargetName) {
-            const groupName = options.ciGroupName ?? (0, plugins_1.deriveGroupNameFromTarget)(options.ciTargetName);
+            const groupName = options.ciGroupName ?? (0, internal_1.deriveGroupNameFromTarget)(options.ciTargetName);
             const targetGroup = [];
             const dependsOn = [];
             metadata = {
@@ -153,7 +148,24 @@ async function buildVitestTargets(configFilePath, projectRoot, options, context,
                     [groupName]: targetGroup,
                 },
             };
-            const projectRootRelativeTestPaths = await getTestPathsRelativeToProjectRoot(projectRoot, context.workspaceRoot);
+            // Not normalizing in normalizeOptions since it also affects the options
+            // computed for convert-to-inferred.
+            const useGlobDiscovery = (options.discoverTestFiles ?? 'glob') !== 'vitest';
+            // Both discovery paths read the serve-resolved config: Vitest runs tests
+            // through a Vite server (the `serve` command), so `apply: 'serve'`
+            // plugins and command-sensitive `test` options (include/exclude and
+            // `dir`) are absent from the build resolution used above for outputs.
+            // Resolve under `mode: 'test'` to match Vitest, which defaults the Vite
+            // mode to 'test'; a config that branches on `command`/`mode` would
+            // otherwise enumerate a different spec set here than at test time.
+            const viteServeConfig = await resolveConfig({
+                configFile: absoluteConfigFilePath,
+                mode: 'test',
+            }, 'serve');
+            const projectRootRelativeTestPaths = await getTestPathsRelativeToProjectRoot(projectRoot, context.workspaceRoot, 
+            // Only the glob path reads this config; the opt-out path forces the
+            // runtime by receiving no config, and takes `test.dir` separately.
+            useGlobDiscovery ? viteServeConfig : undefined, viteServeConfig.test?.dir);
             for (const relativePath of projectRootRelativeTestPaths) {
                 if (relativePath.includes('../')) {
                     throw new Error('@nx/vitest attempted to run tests outside of the project root. This is not supported and should not happen. Please open an issue at https://github.com/nrwl/nx/issues/new/choose with the following information:\n\n' +
@@ -403,12 +415,205 @@ function checkIfConfigFileShouldBeProject(projectRoot, context) {
     }
     return true;
 }
-async function getTestPathsRelativeToProjectRoot(projectRoot, workspaceRoot) {
+async function getTestPathsRelativeToProjectRoot(projectRoot, workspaceRoot, viteConfig, 
+// Serve-resolved `test.dir` (the command Vitest runs under). Only used on the
+// opt-out path below, which receives no `viteConfig` to read it from.
+optOutTestDir) {
     const fullProjectRoot = (0, node_path_1.join)(workspaceRoot, projectRoot);
+    // `viteConfig` is resolved only when glob discovery is requested; its absence
+    // means the runtime path was selected (`discoverTestFiles: 'vitest'`).
+    if (viteConfig) {
+        const test = viteConfig.test ?? {};
+        if (!configRequiresVitestRuntime(test, viteConfig, fullProjectRoot)) {
+            return globTestPathsRelativeToProjectRoot(test, workspaceRoot, projectRoot, fullProjectRoot);
+        }
+        return getTestPathsViaVitestRuntime(fullProjectRoot, projectRoot, test.dir);
+    }
+    return getTestPathsViaVitestRuntime(fullProjectRoot, projectRoot, optOutTestDir);
+}
+/**
+ * The directory Vitest enumerates from: `test.dir` when set, else the project
+ * root. Vitest resolves a relative `test.dir` against the working directory,
+ * which for both the `test` and atomized targets is the project root.
+ */
+function resolveTestDir(fullProjectRoot, testDir) {
+    return testDir ? (0, node_path_1.resolve)(fullProjectRoot, testDir) : fullProjectRoot;
+}
+/**
+ * Enumerates a project's test files by mirroring Vitest's own resolution with
+ * a glob. Vitest globs `test.include` and `test.includeSource` (both skipped
+ * when typecheck is enabled with `only`, the latter also kept only when the
+ * file contains an in-source test) plus `test.typecheck.include` (when
+ * typecheck is enabled), each minus the relevant `exclude`, from `test.dir`
+ * when set and the project root otherwise. Defaults come from the installed
+ * Vitest so they track the user's version. Globbing goes through the Nx
+ * workspace context (the daemon-cached file index), so files ignored by
+ * `.gitignore`/`.nxignore` are never candidates. Callers must first confirm the
+ * config is reproducible with a glob via `configRequiresVitestRuntime`.
+ */
+async function globTestPathsRelativeToProjectRoot(test, workspaceRoot, projectRoot, fullProjectRoot) {
+    const { configDefaults } = await (0, executor_utils_1.loadVitestConfigDynamicImport)();
+    const exclude = test.exclude ?? configDefaults.exclude;
+    const typecheck = test.typecheck;
+    const typecheckOnly = !!(typecheck?.enabled && typecheck?.only);
+    // The workspace context matches workspace-relative paths, while the config's
+    // patterns are relative to the directory Vitest enumerates from; anchor them
+    // to it.
+    const scanRoot = test.dir
+        ? (0, devkit_1.normalizePath)((0, node_path_1.relative)(workspaceRoot, resolveTestDir(fullProjectRoot, test.dir)))
+        : projectRoot;
+    // The workspace context only reads `!` at index 0, so a negated pattern has
+    // to be re-prefixed rather than anchored as-is.
+    const anchor = (pattern) => isNegatedPattern(pattern)
+        ? `!${(0, devkit_1.joinPathFragments)(scanRoot, pattern.slice(1))}`
+        : (0, devkit_1.joinPathFragments)(scanRoot, pattern);
+    const globProjectFiles = (include, ignore) => {
+        // The workspace context treats an all-negated (or empty) include set as
+        // "match everything" (it inverts to the exclude set), while Vitest
+        // enumerates nothing. Match Vitest: without a positive entry there is
+        // nothing to enumerate.
+        if (!include.some((pattern) => !isNegatedPattern(pattern))) {
+            return Promise.resolve([]);
+        }
+        return (0, internal_1.globWithWorkspaceContext)(workspaceRoot, include.map(anchor), 
+        // Vitest discards a negated `exclude` entry; forwarding it would turn the
+        // exclude set into an allowlist.
+        ignore.filter((pattern) => !isNegatedPattern(pattern)).map(anchor));
+    };
+    // Regular and type tests are independent walks; run them together.
+    const globJobs = [];
+    // Typecheck enabled with `only` makes Vitest run only type tests, so skip
+    // regular tests.
+    if (!typecheckOnly) {
+        const include = test.include ?? configDefaults.include;
+        globJobs.push(globProjectFiles(include, exclude));
+    }
+    if (typecheck?.enabled) {
+        const include = typecheck.include ?? configDefaults.typecheck.include;
+        const ignore = typecheck.exclude ?? configDefaults.typecheck.exclude;
+        globJobs.push(globProjectFiles(include, ignore));
+    }
+    const matches = new Set();
+    for (const files of await Promise.all(globJobs)) {
+        for (const file of files)
+            matches.add(file);
+    }
+    // In-source tests: only files that actually contain a test are included.
+    // Typecheck enabled with `only` makes Vitest run only type tests, so skip
+    // these too.
+    if (!typecheckOnly && test.includeSource?.length) {
+        const sourceFiles = await globProjectFiles(test.includeSource, exclude);
+        // The candidate set can be the whole `src` tree, so read in bounded
+        // batches; an unbounded Promise.all over every file risks EMFILE.
+        const readConcurrency = 25;
+        for (let i = 0; i < sourceFiles.length; i += readConcurrency) {
+            const inSourceMatches = await Promise.all(sourceFiles.slice(i, i + readConcurrency).map(async (file) => {
+                // Vitest tolerates unreadable in-source candidates and skips them;
+                // match that so a permission error or TOCTOU race can't abort graph
+                // creation.
+                try {
+                    const content = await (0, promises_1.readFile)((0, node_path_1.join)(workspaceRoot, file), 'utf-8');
+                    return content.includes('import.meta.vitest') ? file : null;
+                }
+                catch {
+                    return null;
+                }
+            }));
+            for (const file of inSourceMatches) {
+                if (file)
+                    matches.add(file);
+            }
+        }
+    }
+    // The workspace context returns workspace-relative paths, so re-relativize
+    // them to the project root. An `include` pattern (`../lib2/**`) or an
+    // out-of-project `test.dir` can land outside the project root, so drop what
+    // does, matching the runtime path.
+    return [...matches]
+        .map((file) => (0, devkit_1.normalizePath)((0, node_path_1.relative)(projectRoot, file)))
+        .filter((file) => !file.startsWith('../'))
+        .sort();
+}
+// Vitest reads a leading `!` as a negation, except when it opens an extglob
+// (`!(...)`), which the runtime gate routes away before discovery reaches here.
+function isNegatedPattern(pattern) {
+    return pattern.startsWith('!') && !pattern.startsWith('!(');
+}
+/**
+ * Whether the workspace context resolves a pattern differently than Vitest.
+ * Anchoring rewrites an absolute pattern into a project-relative one that
+ * enumerates the wrong location; a trailing `/` becomes a recursive directory
+ * match where Vitest (globbing with `expandDirectories: false`) matches
+ * nothing; and `!(...)` converts to an include plus literal exclusions that
+ * reproduces Vitest's extglob only for some shapes. A leading `!` is stripped
+ * first so a negated form of any of these still routes to the runtime.
+ */
+function patternRequiresVitestRuntime(pattern) {
+    const bare = isNegatedPattern(pattern) ? pattern.slice(1) : pattern;
+    return (0, node_path_1.isAbsolute)(bare) || bare.endsWith('/') || bare.includes('!(');
+}
+// Sibling files Vitest 3 auto-loads to define sub-projects even when the config
+// object declares none. Removed in Vitest 4 in favor of inline `test.projects`.
+const vitestWorkspaceFiles = ['vitest.workspace', 'vitest.projects'].flatMap((name) => ['ts', 'mts', 'cts', 'js', 'mjs', 'cjs', 'json'].map((ext) => `${name}.${ext}`));
+/**
+ * Whether a config's test discovery cannot be faithfully reproduced with a
+ * glob, so enumeration must go through Vitest itself.
+ */
+function configRequiresVitestRuntime(
+// `workspace` (removed in Vitest 4) and the CLI-only `changed`/`related`
+// filters are not part of the config-file `InlineConfig` type.
+test, viteConfig, projectDir) {
+    // Multi-project configs resolve include/exclude per sub-project.
+    if (Array.isArray(test?.projects) || test?.workspace)
+        return true;
+    // Vitest 3 auto-loads a `vitest.workspace.*`/`vitest.projects.*` sibling file
+    // to define sub-projects even when the config object declares none; the glob
+    // resolves only the single config, so it cannot reproduce that.
+    if (vitestWorkspaceFiles.some((file) => (0, node_fs_1.existsSync)((0, node_path_1.join)(projectDir, file)))) {
+        return true;
+    }
+    // Vitest filters specs by VCS/graph state, which a glob cannot know.
+    if (test?.changed || test?.related)
+        return true;
+    // Vitest's own defaults carry none of these shapes, so only a config that
+    // spells one out reaches the runtime for this reason.
+    const configuredPatterns = [
+        test?.include,
+        test?.exclude,
+        test?.includeSource,
+        test?.typecheck?.include,
+        test?.typecheck?.exclude,
+    ]
+        .filter(Array.isArray)
+        .flat();
+    if (configuredPatterns.some(patternRequiresVitestRuntime))
+        return true;
+    // Browser mode: an instance can override include/exclude/includeSource, and
+    // `dir` (the base directory Vitest scans), so a top-level glob enumerates a
+    // different spec set than the instance would. Vitest ignores `instances`
+    // while browser mode is off, and the atomized target runs `vitest run <file>`
+    // without a browser flag, so the resolved `enabled` matches the run.
+    const browserInstances = test?.browser?.instances ?? [];
+    if (test?.browser?.enabled &&
+        browserInstances.some((instance) => instance &&
+            (instance.include?.length ||
+                instance.exclude?.length ||
+                instance.includeSource?.length ||
+                instance.dir))) {
+        return true;
+    }
+    // A plugin can inject or reshape projects through this Vitest-only hook.
+    const plugins = viteConfig?.plugins ?? [];
+    return plugins.some((plugin) => plugin && typeof plugin === 'object' && 'configureVitest' in plugin);
+}
+async function getTestPathsViaVitestRuntime(fullProjectRoot, projectRoot, testDir) {
     const { createVitest } = await import('vitest/node');
     const vitest = await createVitest('test', {
         root: fullProjectRoot,
-        dir: fullProjectRoot,
+        // `dir` defaults to `root`, and a relative `test.dir` would resolve against
+        // the working directory, which during graph creation is the workspace root
+        // rather than the project root.
+        dir: resolveTestDir(fullProjectRoot, testDir),
         filesOnly: true,
         watch: false,
     });

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

@@ -1,2 +1,3 @@
-export declare function loadViteDynamicImport(): Promise<any>;
+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

@@ -2,12 +2,13 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.loadViteDynamicImport = loadViteDynamicImport;
 exports.loadVitestDynamicImport = loadVitestDynamicImport;
-// TODO(jack): Remove this cast when @nx/vitest switches to moduleResolution:
-// "nodenext". Vite 8 ships ESM-only type declarations (.d.mts) not resolvable
-// under moduleResolution: "node".
+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

@@ -4,7 +4,7 @@ export type TargetFlags = Partial<Record<Target, boolean>>;
 export interface VitestGeneratorSchema {
     project: string;
     uiFramework?: 'angular' | 'react' | 'vue' | 'none';
-    coverageProvider: 'v8' | 'istanbul' | 'custom';
+    coverageProvider: 'v8' | 'istanbul' | 'custom' | 'none';
     inSourceTests?: boolean;
     skipViteConfig?: boolean;
     testTarget?: string;
@@ -22,10 +22,18 @@ export interface ViteConfigFileOptions {
     includeVitest?: boolean;
     inSourceTests?: boolean;
     testEnvironment?: 'node' | 'jsdom' | 'happy-dom' | 'edge-runtime' | string;
+    testInclude?: string[];
+    /**
+     * Aliases to emit under `resolve.alias`, as alias -> project-relative path.
+     * Only applies when a new config file is written; an existing config is left
+     * untouched.
+     */
+    resolveAlias?: Record<string, string>;
     rolldownOptionsExternal?: string[];
     imports?: string[];
     plugins?: string[];
-    coverageProvider?: 'v8' | 'istanbul' | 'custom';
+    coverageProvider?: 'v8' | 'istanbul' | 'custom' | 'none';
+    passWithNoTests?: boolean;
     setupFile?: string;
     useEsmExtension?: boolean;
     port?: number;
@@ -35,4 +43,5 @@ export declare function createOrEditViteConfig(tree: Tree, options: ViteConfigFi
     projectAlreadyHasViteTargets?: TargetFlags;
     skipPackageJson?: boolean;
     vitestFileName?: boolean;
+    skipNxPlugins?: boolean;
 }): void;

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

@@ -9,14 +9,25 @@ const deprecation_1 = require("./deprecation");
 const versions_1 = require("./versions");
 function addOrChangeTestTarget(tree, options, hasPlugin) {
     const nxJson = (0, devkit_1.readNxJson)(tree);
-    hasPlugin = nxJson.plugins?.some((p) => typeof p === 'string'
-        ? p === '@nx/vitest'
-        : p.plugin === '@nx/vitest' || hasPlugin);
+    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.
+    hasPlugin ||=
+        nxJson.plugins?.some((p) => {
+            if (typeof p === 'string') {
+                return p === '@nx/vitest' && target === 'test';
+            }
+            if (p.plugin !== '@nx/vitest') {
+                return false;
+            }
+            const pluginOptions = p.options;
+            return ((pluginOptions?.testTargetName ?? 'test') === target ||
+                pluginOptions?.ciTargetName === target);
+        }) ?? false;
     if (hasPlugin) {
         return;
     }
     const project = (0, devkit_1.readProjectConfiguration)(tree, options.project);
-    const target = options.testTarget ?? 'test';
     const reportsDirectory = (0, devkit_1.joinPathFragments)('coverage', project.root === '.' ? options.project : project.root);
     const testOptions = {
         reportsDirectory,
@@ -35,6 +46,14 @@ function addOrChangeTestTarget(tree, options, hasPlugin) {
     }
     (0, devkit_1.updateProjectConfiguration)(tree, options.project, project);
 }
+// Escape a value for emission inside a single-quoted source literal.
+function escapeLiteral(value) {
+    return value
+        .replace(/\\/g, '\\\\')
+        .replace(/'/g, "\\'")
+        .replace(/\n/g, '\\n')
+        .replace(/\r/g, '\\r');
+}
 function createOrEditViteConfig(tree, options, onlyVitest, extraOptions = {}) {
     const { root: projectRoot } = (0, devkit_1.readProjectConfiguration)(tree, options.project);
     const extension = options.useEsmExtension ? 'mts' : 'ts';
@@ -86,7 +105,7 @@ function createOrEditViteConfig(tree, options, onlyVitest, extraOptions = {}) {
     if (!onlyVitest && options.includeLib && !isTsSolutionSetup) {
         imports.push(`import dts from 'vite-plugin-dts'`, `import * as path from 'path'`);
     }
-    if (!isTsSolutionSetup) {
+    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) {
@@ -94,31 +113,39 @@ function createOrEditViteConfig(tree, options, onlyVitest, extraOptions = {}) {
         }
     }
     if (!onlyVitest && options.includeLib) {
-        plugins.push(`dts({ entryRoot: 'src', tsconfigPath: path.join(__dirname, 'tsconfig.lib.json')${!isTsSolutionSetup ? ', pathsToAliases: false' : ''} })`);
+        plugins.push(`dts({ entryRoot: 'src', tsconfigPath: path.join(import.meta.dirname, 'tsconfig.lib.json')${!isTsSolutionSetup ? ', pathsToAliases: false' : ''} })`);
     }
     const reportsDirectory = isTsSolutionSetup
         ? './test-output/vitest/coverage'
         : projectRoot === '.'
             ? `./coverage/${options.project}`
             : `${(0, devkit_1.offsetFromRoot)(projectRoot)}coverage/${projectRoot}`;
+    const testInclude = options.testInclude ?? [
+        '{src,tests}/**/*.{test,spec}.{js,mjs,cjs,ts,mts,cts,jsx,tsx}',
+    ];
     const testOption = options.includeVitest
         ? `  test: {
     name: '${options.project}',
     watch: false,
     globals: true,
     environment: '${options.testEnvironment ?? 'jsdom'}',
-    include: ['{src,tests}/**/*.{test,spec}.{js,mjs,cjs,ts,mts,cts,jsx,tsx}'],
+    include: [${testInclude
+            .map((pattern) => `'${escapeLiteral(pattern)}'`)
+            .join(', ')}],
+${options.passWithNoTests ? `    passWithNoTests: true,\n` : ''}\
 ${options.setupFile ? `    setupFiles: ['${options.setupFile}'],\n` : ''}\
 ${options.inSourceTests
             ? `    includeSource: ['src/**/*.{js,mjs,cjs,ts,mts,cts,jsx,tsx}'],\n`
             : ''}\
-    reporters: ['default'],
+    reporters: ['default']${options.coverageProvider !== 'none'
+            ? `,
     coverage: {
       reportsDirectory: '${reportsDirectory}',
       provider: ${options.coverageProvider
-            ? `'${options.coverageProvider}' as const`
-            : `'v8' as const`},
-    }
+                ? `'${options.coverageProvider}' as const`
+                : `'v8' as const`},
+    }`
+            : ''}
   },`
         : '';
     const defineOption = options.inSourceTests
@@ -151,19 +178,34 @@ ${options.inSourceTests
   // worker: {
   //   plugins: () => [ nxViteTsPaths() ],
   // },`;
+    const aliasEntries = Object.entries(options.resolveAlias ?? {});
+    const resolveOption = aliasEntries.length
+        ? `  resolve: {
+    alias: {
+${aliasEntries
+            .map(([alias, target]) => `      '${escapeLiteral(alias)}': join(import.meta.dirname, '${escapeLiteral(target)}'),`)
+            .join('\n')}
+    },
+  },`
+        : '';
     const cacheDir = `cacheDir: '${normalizedJoinPaths((0, devkit_1.offsetFromRoot)(projectRoot), 'node_modules', '.vite', projectRoot === '.' ? options.project : projectRoot)}',`;
     if (tree.exists(viteConfigPath)) {
+        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);
         return;
     }
-    // When using vitest.config, use vitest/config import and skip vite-specific options
+    if (aliasEntries.length) {
+        imports.push(`import { join } from 'node:path'`);
+    }
     const viteConfigContent = extraOptions.vitestFileName
         ? `import { defineConfig } from 'vitest/config';
 ${imports.join(';\n')}${imports.length ? ';' : ''}
 
 export default defineConfig(() => ({
-  root: __dirname,
-  ${printOptions(cacheDir, plugins.length ? `  plugins: [${plugins.join(', ')}],` : '', defineOption, testOption)}
+  root: import.meta.dirname,
+  ${printOptions(cacheDir, plugins.length ? `  plugins: [${plugins.join(', ')}],` : '', resolveOption, defineOption, testOption)}
 }));
 `.replace(/\s+(?=(\n|$))/gm, '\n')
         : `/// <reference types='vitest' />
@@ -171,8 +213,8 @@ import { defineConfig } from 'vite';
 ${imports.join(';\n')}${imports.length ? ';' : ''}
 
 export default defineConfig(() => ({
-  root: __dirname,
-  ${printOptions(cacheDir, devServerOption, previewServerOption, `  plugins: [${plugins.join(', ')}],`, workerOption, buildOption, defineOption, testOption)}
+  root: import.meta.dirname,
+  ${printOptions(cacheDir, devServerOption, previewServerOption, `  plugins: [${plugins.join(', ')}],`, resolveOption, workerOption, buildOption, defineOption, testOption)}
 }));
 `.replace(/\s+(?=(\n|$))/gm, '\n');
     tree.write(viteConfigPath, viteConfigContent);
@@ -215,7 +257,10 @@ function handleViteConfigFileExists(tree, viteConfigPath, options, buildOption,
     const testOptionObject = {
         globals: true,
         environment: options.testEnvironment ?? 'jsdom',
-        include: ['src/**/*.{test,spec}.{js,mjs,cjs,ts,mts,cts,jsx,tsx}'],
+        include: options.testInclude ?? [
+            'src/**/*.{test,spec}.{js,mjs,cjs,ts,mts,cts,jsx,tsx}',
+        ],
+        ...(options.passWithNoTests ? { passWithNoTests: true } : {}),
         reporters: ['default'],
         coverage: {
             reportsDirectory: reportsDirectory,

package/dist/src/utils/ignore-vitest-temp-files.d.ts

@@ -1,4 +1,3 @@
 import { type Tree } from '@nx/devkit';
 export declare function ignoreVitestTempFiles(tree: Tree, projectRoot?: string | undefined): Promise<void>;
 export declare function addVitestTempFilesToGitIgnore(tree: Tree): void;
-export declare function isEslintInstalled(tree: Tree): boolean;

package/dist/src/utils/ignore-vitest-temp-files.js

@@ -2,8 +2,8 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ignoreVitestTempFiles = ignoreVitestTempFiles;
 exports.addVitestTempFilesToGitIgnore = addVitestTempFilesToGitIgnore;
-exports.isEslintInstalled = isEslintInstalled;
 const devkit_1 = require("@nx/devkit");
+const internal_1 = require("@nx/js/internal");
 const versions_1 = require("./versions");
 async function ignoreVitestTempFiles(tree, projectRoot) {
     addVitestTempFilesToGitIgnore(tree);
@@ -20,7 +20,9 @@ function addVitestTempFilesToGitIgnore(tree) {
     tree.write('.gitignore', gitIgnoreContents);
 }
 async function ignoreVitestTempFilesInEslintConfig(tree, projectRoot) {
-    if (!isEslintInstalled(tree)) {
+    // Checked before `ensurePackage` so an Oxlint workspace does not install
+    // `@nx/eslint` only for `isEslintConfigSupported` to send it straight back.
+    if (!(0, internal_1.detectLinters)(tree).includes('eslint')) {
         return;
     }
     (0, devkit_1.ensurePackage)('@nx/eslint', versions_1.nxVersion);
@@ -45,15 +47,3 @@ async function ignoreVitestTempFilesInEslintConfig(tree, projectRoot) {
     const directory = isUsingFlatConfig ? '' : (projectRoot ?? '');
     addIgnoresToLintConfig(tree, directory, ['**/vitest.config.*.timestamp*']);
 }
-function isEslintInstalled(tree) {
-    try {
-        require('eslint');
-        return true;
-    }
-    catch { }
-    // it might not be installed yet, but it might be in the tree pending install
-    const { devDependencies, dependencies } = tree.exists('package.json')
-        ? (0, devkit_1.readJson)(tree, 'package.json')
-        : {};
-    return !!devDependencies?.['eslint'] || !!dependencies?.['eslint'];
-}

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

@@ -1,3 +1,3 @@
-import type { Tree } from 'nx/src/generators/tree';
+import { type Tree } from '@nx/devkit';
 export declare function getInstalledViteVersion(tree: Tree): string;
 export declare function getInstalledViteMajorVersion(tree: Tree): 5 | 6 | 7 | 8 | undefined;

package/migrations.json

@@ -28,6 +28,12 @@
       "description": "Rename imports of `createNodesV2` from `@nx/vitest` to the canonical `createNodes` export.",
       "implementation": "./dist/src/migrations/update-23-0-0/migrate-create-nodes-v2-to-create-nodes",
       "documentation": "./dist/src/migrations/update-23-0-0/migrate-create-nodes-v2-to-create-nodes.md"
+    },
+    "update-23-2-0-use-import-meta-dirname": {
+      "version": "23.2.0-beta.6",
+      "description": "Replace `__dirname` with `import.meta.dirname` in `vite.config.mts`/`vitest.config.mts` files so they work with Vite's `configLoader: 'native'`.",
+      "implementation": "./dist/src/migrations/update-23-2-0/use-import-meta-dirname",
+      "documentation": "./dist/src/migrations/update-23-2-0/use-import-meta-dirname.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": "23.2.0-beta.0",
+  "version": "23.2.0-beta.10",
   "type": "commonjs",
   "files": [
     "dist",
@@ -37,6 +37,9 @@
       "generators": [
         "dist/generators.d.ts"
       ],
+      "internal": [
+        "dist/internal.d.ts"
+      ],
       "executors": [
         "dist/executors.d.ts"
       ]
@@ -57,6 +60,11 @@
       "types": "./dist/generators.d.ts",
       "default": "./dist/generators.js"
     },
+    "./internal": {
+      "@nx/nx-source": "./internal.ts",
+      "types": "./dist/internal.d.ts",
+      "default": "./dist/internal.js"
+    },
     "./executors": {
       "@nx/nx-source": "./executors.ts",
       "types": "./dist/executors.d.ts",
@@ -73,13 +81,13 @@
     "tslib": "^2.3.0",
     "semver": "^7.6.3",
     "@phenomnomnominal/tsquery": "~6.2.0",
-    "@nx/devkit": "23.2.0-beta.0",
-    "@nx/js": "23.2.0-beta.0"
+    "@nx/devkit": "23.2.0-beta.10",
+    "@nx/js": "23.2.0-beta.10"
   },
   "peerDependencies": {
     "vitest": "^3.0.0 || ^4.0.0",
     "vite": "^5.0.0 || ^6.0.0 || ^7.0.0 || ^8.0.0",
-    "@nx/eslint": "23.2.0-beta.0"
+    "@nx/eslint": "23.2.0-beta.10"
   },
   "peerDependenciesMeta": {
     "@nx/eslint": {
@@ -93,6 +101,6 @@
     }
   },
   "devDependencies": {
-    "nx": "23.2.0-beta.0"
+    "nx": "23.2.0-beta.10"
   }
 }