@nx/vitest 23.2.0-beta.4 → 23.2.0-beta.6

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.
@@ -188,7 +199,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');
@@ -241,7 +252,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: {
@@ -251,13 +264,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) {

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.js

@@ -8,10 +8,6 @@ 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 workspace_context_1 = require("nx/src/utils/workspace-context");
 const executor_utils_1 = require("../utils/executor-utils");
 /**
  * @deprecated The 'createDependencies' function is now a no-op. This functionality is included in 'createNodesV2'.
@@ -25,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);
@@ -144,7 +140,7 @@ async function buildVitestTargets(configFilePath, projectRoot, options, context,
         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 = {
@@ -479,7 +475,7 @@ async function globTestPathsRelativeToProjectRoot(test, workspaceRoot, projectRo
         if (!include.some((pattern) => !isNegatedPattern(pattern))) {
             return Promise.resolve([]);
         }
-        return (0, workspace_context_1.globWithWorkspaceContext)(workspaceRoot, include.map(anchor), 
+        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));

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,
@@ -94,7 +105,7 @@ 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'
@@ -164,7 +175,7 @@ ${options.inSourceTests
 ${imports.join(';\n')}${imports.length ? ';' : ''}
 
 export default defineConfig(() => ({
-  root: __dirname,
+  root: import.meta.dirname,
   ${printOptions(cacheDir, plugins.length ? `  plugins: [${plugins.join(', ')}],` : '', defineOption, testOption)}
 }));
 `.replace(/\s+(?=(\n|$))/gm, '\n')
@@ -173,7 +184,7 @@ import { defineConfig } from 'vite';
 ${imports.join(';\n')}${imports.length ? ';' : ''}
 
 export default defineConfig(() => ({
-  root: __dirname,
+  root: import.meta.dirname,
   ${printOptions(cacheDir, devServerOption, previewServerOption, `  plugins: [${plugins.join(', ')}],`, workerOption, buildOption, defineOption, testOption)}
 }));
 `.replace(/\s+(?=(\n|$))/gm, '\n');

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.4",
+  "version": "23.2.0-beta.6",
   "type": "commonjs",
   "files": [
     "dist",
@@ -73,13 +73,13 @@
     "tslib": "^2.3.0",
     "semver": "^7.6.3",
     "@phenomnomnominal/tsquery": "~6.2.0",
-    "@nx/js": "23.2.0-beta.4",
-    "@nx/devkit": "23.2.0-beta.4"
+    "@nx/devkit": "23.2.0-beta.6",
+    "@nx/js": "23.2.0-beta.6"
   },
   "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.4"
+    "@nx/eslint": "23.2.0-beta.6"
   },
   "peerDependenciesMeta": {
     "@nx/eslint": {
@@ -93,6 +93,6 @@
     }
   },
   "devDependencies": {
-    "nx": "23.2.0-beta.4"
+    "nx": "23.2.0-beta.6"
   }
 }