@nx/vite 23.0.0-beta.2 → 23.0.0-beta.21

package/{src → dist/src}/plugins/plugin.js

@@ -1,61 +1,16 @@
 "use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createNodesV2 = exports.createNodes = exports.createDependencies = void 0;
+const internal_1 = require("@nx/devkit/internal");
 const devkit_1 = require("@nx/devkit");
-const calculate_hash_for_create_nodes_1 = require("@nx/devkit/src/utils/calculate-hash-for-create-nodes");
-const get_named_inputs_1 = require("@nx/devkit/src/utils/get-named-inputs");
 const js_1 = require("@nx/js");
-const internal_1 = require("@nx/js/src/internal");
-const util_1 = require("@nx/js/src/plugins/typescript/util");
-const ts_solution_setup_1 = require("@nx/js/src/utils/typescript/ts-solution-setup");
+const internal_2 = require("@nx/js/internal");
 const node_fs_1 = require("node:fs");
 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");
 const picomatch = require("picomatch");
-function readTargetsCache(cachePath) {
-    return process.env.NX_CACHE_PROJECT_GRAPH !== 'false' && (0, node_fs_1.existsSync)(cachePath)
-        ? (0, devkit_1.readJsonFile)(cachePath)
-        : {};
-}
-function writeTargetsToCache(cachePath, results) {
-    (0, devkit_1.writeJsonFile)(cachePath, results);
-}
 /**
  * @deprecated The 'createDependencies' function is now a no-op. This functionality is included in 'createNodesV2'.
  */
@@ -63,15 +18,15 @@ const createDependencies = () => {
     return [];
 };
 exports.createDependencies = createDependencies;
-const viteVitestConfigGlob = '**/{vite,vitest}.config.{js,ts,mjs,mts,cjs,cts}';
+const viteConfigGlob = '**/vite.config.{js,ts,mjs,mts,cjs,cts}';
 exports.createNodes = [
-    viteVitestConfigGlob,
+    viteConfigGlob,
     async (configFilePaths, options, context) => {
         const optionsHash = (0, file_hasher_1.hashObject)(options);
         const normalizedOptions = normalizeOptions(options);
         const cachePath = (0, node_path_1.join)(cache_directory_1.workspaceDataDirectory, `vite-${optionsHash}.hash`);
-        const targetsCache = readTargetsCache(cachePath);
-        const isUsingTsSolutionSetup = (0, ts_solution_setup_1.isUsingTsSolutionSetup)();
+        const targetsCache = new internal_1.PluginCache(cachePath);
+        const isUsingTsSolutionSetup = (0, internal_2.isUsingTsSolutionSetup)();
         const { roots: projectRoots, configFiles: validConfigFiles } = configFilePaths.reduce((acc, configFile) => {
             const potentialRoot = (0, node_path_1.dirname)(configFile);
             if (checkIfConfigFileShouldBeProject(potentialRoot, context)) {
@@ -87,7 +42,7 @@ exports.createNodes = [
         const pmc = (0, devkit_1.getPackageManagerCommand)(detectedPackageManager);
         const lockfile = (0, js_1.getLockFileName)(detectedPackageManager);
         const tsconfigChainsByProjectRoot = collectTsconfigInputsByProjectRoot(projectRoots, context.workspaceRoot);
-        const hashes = await (0, calculate_hash_for_create_nodes_1.calculateHashesForCreateNodes)(projectRoots, { ...normalizedOptions, isUsingTsSolutionSetup }, context, projectRoots.map((root) => [
+        const hashes = await (0, internal_1.calculateHashesForCreateNodes)(projectRoots, { ...normalizedOptions, isUsingTsSolutionSetup }, context, projectRoots.map((root) => [
             lockfile,
             ...(tsconfigChainsByProjectRoot.get(root) ?? []),
         ]));
@@ -103,13 +58,11 @@ exports.createNodes = [
                         parts[1] === 'config' &&
                         parts.length > 2);
                 });
-                // results from vitest.config.js will be different from results of vite.config.js
-                // but the hash will be the same because it is based on the files under the project root.
-                // Adding the config file path to the hash ensures that the final hash value is different
-                // for different config files.
                 const hash = hashes[idx] + configFile;
-                const { projectType, metadata, targets } = (targetsCache[hash] ??=
-                    await buildViteTargets(configFile, projectRoot, normalizedOptions, tsConfigFiles, hasReactRouterConfig, isUsingTsSolutionSetup, context, pmc, tsconfigChainsByProjectRoot.get(projectRoot) ?? []));
+                if (!targetsCache.has(hash)) {
+                    targetsCache.set(hash, await buildViteTargets(configFile, projectRoot, normalizedOptions, tsConfigFiles, hasReactRouterConfig, isUsingTsSolutionSetup, context, pmc, tsconfigChainsByProjectRoot.get(projectRoot) ?? []));
+                }
+                const { projectType, metadata, targets } = targetsCache.get(hash);
                 const project = {
                     root: projectRoot,
                     targets,
@@ -128,7 +81,7 @@ exports.createNodes = [
             }, validConfigFiles, options, context);
         }
         finally {
-            writeTargetsToCache(cachePath, targetsCache);
+            targetsCache.writeToDisk();
         }
     },
 ];
@@ -156,115 +109,23 @@ async function buildViteTargets(configFilePath, projectRoot, options, tsConfigFi
     catch {
         // Plugin not installed or not needed, ignore
     }
-    // Workaround for race condition with vitest/node on Node 24+
-    // When multiple vitest.config files are processed in parallel, Node can throw:
-    // Error [ERR_INTERNAL_ASSERTION]: Cannot require() ES Module vitest/dist/node.js
-    // because it is not yet fully loaded.
-    // See: https://github.com/nrwl/nx/issues/34028
-    try {
-        const importVitestNode = () => new Function('return import("vitest/node")')();
-        await importVitestNode();
-    }
-    catch {
-        // vitest/node not available or not needed, ignore
-    }
     const { resolveConfig } = await (0, executor_utils_1.loadViteDynamicImport)();
     const viteBuildConfig = await resolveConfig({
         configFile: absoluteConfigFilePath,
         mode: 'development',
         root: projectRoot,
     }, 'build');
-    let metadata = {};
-    const { buildOutputs, testOutputs, hasTest, isBuildable, hasServeConfig } = getOutputs(viteBuildConfig, projectRoot, context.workspaceRoot);
-    const namedInputs = (0, get_named_inputs_1.getNamedInputs)(projectRoot, context);
+    const metadata = {};
+    const { buildOutputs, isBuildable, hasServeConfig } = getOutputs(viteBuildConfig, projectRoot, context.workspaceRoot);
+    const namedInputs = (0, internal_1.getNamedInputs)(projectRoot, 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;
-        targets[options.testTargetName] = await testTarget(namedInputs, testOutputs, projectRoot, pmc, isTypecheckEnabled, tsconfigInputs);
-        if (options.ciTargetName) {
-            const groupName = options.ciGroupName ?? (0, plugins_1.deriveGroupNameFromTarget)(options.ciTargetName);
-            const targetGroup = [];
-            const dependsOn = [];
-            metadata = {
-                targetGroups: {
-                    [groupName]: targetGroup,
-                },
-            };
-            const projectRootRelativeTestPaths = await getTestPathsRelativeToProjectRoot(projectRoot, context.workspaceRoot);
-            for (const relativePath of projectRootRelativeTestPaths) {
-                if (relativePath.includes('../')) {
-                    throw new Error('@nx/vite/plugin 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' +
-                        `\n\n${JSON.stringify({
-                            projectRoot,
-                            relativePath,
-                            projectRootRelativeTestPaths,
-                            context,
-                        }, null, 2)}`);
-                }
-                const targetName = `${options.ciTargetName}--${relativePath}`;
-                dependsOn.push(targetName);
-                targets[targetName] = {
-                    // It does not make sense to run atomized tests in watch mode as they are intended to be run in CI
-                    command: `vitest run ${relativePath}`,
-                    cache: targets[options.testTargetName].cache,
-                    inputs: targets[options.testTargetName].inputs,
-                    outputs: targets[options.testTargetName].outputs,
-                    options: {
-                        cwd: projectRoot,
-                        env: targets[options.testTargetName].options.env,
-                    },
-                    metadata: {
-                        technologies: ['vitest'],
-                        description: `Run Vitest Tests in ${relativePath}`,
-                        help: {
-                            command: `${pmc.exec} vitest --help`,
-                            example: {
-                                options: {
-                                    coverage: true,
-                                },
-                            },
-                        },
-                    },
-                };
-                targetGroup.push(targetName);
-            }
-            if (targetGroup.length > 0) {
-                targets[options.ciTargetName] = {
-                    executor: 'nx:noop',
-                    cache: true,
-                    inputs: targets[options.testTargetName].inputs,
-                    outputs: targets[options.testTargetName].outputs,
-                    dependsOn,
-                    metadata: {
-                        technologies: ['vitest'],
-                        description: 'Run Vitest Tests in CI',
-                        nonAtomizedTarget: options.testTargetName,
-                        help: {
-                            command: `${pmc.exec} vitest --help`,
-                            example: {
-                                options: {
-                                    coverage: true,
-                                },
-                            },
-                        },
-                    },
-                };
-                targetGroup.unshift(options.ciTargetName);
-            }
-        }
-    }
     if (hasReactRouterConfig) {
         // If we have a react-router config, we can skip the rest of the targets
         return { targets, metadata: {}, projectType: 'application' };
     }
-    // If file is not vitest.config and buildable, create targets for build, serve, preview and serve-static
     const hasRemixPlugin = viteBuildConfig.plugins &&
         viteBuildConfig.plugins.some((p) => p.name === 'remix');
-    if (!configFilePath.includes('vitest.config') &&
-        !hasRemixPlugin &&
-        isBuildable) {
+    if (!hasRemixPlugin && isBuildable) {
         targets[options.buildTargetName] = await buildTarget(options.buildTargetName, namedInputs, buildOutputs, projectRoot, isUsingTsSolutionSetup, pmc);
         // If running in library mode, then there is nothing to serve.
         if (!viteBuildConfig.build?.lib || hasServeConfig) {
@@ -328,7 +189,7 @@ async function buildViteTargets(configFilePath, projectRoot, options, tsConfigFi
             ];
         }
     }
-    (0, util_1.addBuildAndWatchDepsTargets)(context.workspaceRoot, projectRoot, targets, options, pmc);
+    (0, internal_2.addBuildAndWatchDepsTargets)(context.workspaceRoot, projectRoot, targets, options, pmc);
     return {
         targets,
         metadata,
@@ -417,42 +278,6 @@ function previewTarget(projectRoot, buildTargetName, pmc) {
     };
     return targetConfig;
 }
-async function testTarget(namedInputs, outputs, projectRoot, pmc, isTypecheckEnabled, tsconfigInputs) {
-    const depOutputsGlob = isTypecheckEnabled ? '**/*.{js,d.ts}' : '**/*.js';
-    return {
-        command: `vitest`,
-        options: { cwd: (0, devkit_1.joinPathFragments)(projectRoot) },
-        cache: true,
-        inputs: [
-            ...('production' in namedInputs
-                ? ['default', '^production']
-                : ['default', '^default']),
-            ...tsconfigInputs.map((f) => ({
-                json: `{workspaceRoot}/${f}`,
-                fields: ['compilerOptions'],
-            })),
-            {
-                externalDependencies: ['vitest'],
-            },
-            { env: 'CI' },
-            { dependentTasksOutputFiles: depOutputsGlob, transitive: true },
-        ],
-        outputs,
-        metadata: {
-            technologies: ['vite'],
-            description: `Run Vite tests`,
-            help: {
-                command: `${pmc.exec} vitest --help`,
-                example: {
-                    options: {
-                        bail: 1,
-                        coverage: true,
-                    },
-                },
-            },
-        },
-    };
-}
 function serveStaticTarget(options, isUsingTsSolutionSetup) {
     const targetConfig = {
         continuous: true,
@@ -471,8 +296,8 @@ function getOutputs(viteBuildConfig, projectRoot, workspaceRoot) {
     // TODO(jack): Remove this cast when @nx/vite switches to moduleResolution:
     // "nodenext". Vite 8's rolldown types are ESM-only (.d.mts) and not
     // resolvable under moduleResolution: "node", which breaks rolldownOptions
-    // and vitest's test augmentation on ResolvedConfig.
-    const { build, test, server } = viteBuildConfig;
+    // on ResolvedConfig.
+    const { build, server } = viteBuildConfig;
     const buildOutputPath = normalizeOutputPath(build?.outDir, projectRoot, workspaceRoot, 'dist');
     const isBuildable = Boolean(build?.lib ||
         viteBuildConfig?.builder?.buildApp ||
@@ -480,11 +305,8 @@ function getOutputs(viteBuildConfig, projectRoot, workspaceRoot) {
         build?.rolldownOptions?.input || // Vite >=8
         (0, node_fs_1.existsSync)((0, node_path_1.join)(workspaceRoot, projectRoot, 'index.html')));
     const hasServeConfig = Boolean(server?.host || server?.port);
-    const reportsDirectoryPath = normalizeOutputPath(test?.coverage?.reportsDirectory, projectRoot, workspaceRoot, 'coverage');
     return {
         buildOutputs: [buildOutputPath],
-        testOutputs: [reportsDirectoryPath],
-        hasTest: !!test,
         isBuildable,
         hasServeConfig,
     };
@@ -518,7 +340,6 @@ function normalizeOptions(options) {
     options.serveTargetName ??= 'serve';
     options.devTargetName ??= 'dev';
     options.previewTargetName ??= 'preview';
-    options.testTargetName ??= 'test';
     options.serveStaticTargetName ??= 'serve-static';
     options.typecheckTargetName ??= 'typecheck';
     return options;
@@ -565,7 +386,7 @@ function collectTsconfigInputsByProjectRoot(projectRoots, workspaceRoot) {
         // Walk the project tsconfig's extends chain
         const projectTsconfig = (0, node_path_1.join)(workspaceRoot, projectRoot, 'tsconfig.json');
         if ((0, node_fs_1.existsSync)(projectTsconfig)) {
-            (0, internal_1.walkTsconfigExtendsChain)(projectTsconfig, (absPath) => {
+            (0, internal_2.walkTsconfigExtendsChain)(projectTsconfig, (absPath) => {
                 collect(absPath);
                 return 'continue';
             }, { jsonCache });
@@ -576,7 +397,7 @@ function collectTsconfigInputsByProjectRoot(projectRoots, workspaceRoot) {
         while (dir && dir !== '.') {
             const ancestorTsconfig = (0, node_path_1.join)(workspaceRoot, dir, 'tsconfig.json');
             if ((0, node_fs_1.existsSync)(ancestorTsconfig)) {
-                (0, internal_1.walkTsconfigExtendsChain)(ancestorTsconfig, (absPath) => {
+                (0, internal_2.walkTsconfigExtendsChain)(ancestorTsconfig, (absPath) => {
                     collect(absPath);
                     return 'continue';
                 }, { jsonCache });
@@ -589,7 +410,7 @@ function collectTsconfigInputsByProjectRoot(projectRoots, workspaceRoot) {
         // Check the workspace root itself (dirname loop above stops at '.')
         const rootTsconfig = (0, node_path_1.join)(workspaceRoot, 'tsconfig.json');
         if ((0, node_fs_1.existsSync)(rootTsconfig)) {
-            (0, internal_1.walkTsconfigExtendsChain)(rootTsconfig, (absPath) => {
+            (0, internal_2.walkTsconfigExtendsChain)(rootTsconfig, (absPath) => {
                 collect(absPath);
                 return 'continue';
             }, { jsonCache });
@@ -609,17 +430,3 @@ function checkIfConfigFileShouldBeProject(projectRoot, context) {
     }
     return true;
 }
-async function getTestPathsRelativeToProjectRoot(projectRoot, workspaceRoot) {
-    const fullProjectRoot = (0, node_path_1.join)(workspaceRoot, projectRoot);
-    const { createVitest } = await Promise.resolve().then(() => __importStar(require('vitest/node')));
-    const vitest = await createVitest('test', {
-        root: fullProjectRoot,
-        dir: fullProjectRoot,
-        filesOnly: true,
-        watch: false,
-    });
-    const relevantTestSpecifications = await vitest.getRelevantTestSpecifications();
-    return relevantTestSpecifications
-        .filter((ts) => projectRoot === '.' ? true : ts.moduleId.startsWith(fullProjectRoot))
-        .map((ts) => (0, devkit_1.normalizePath)((0, node_path_1.relative)(projectRoot, ts.moduleId)));
-}

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

@@ -0,0 +1,7 @@
+export declare const VITE_BUILD_EXECUTOR_DEPRECATION_MESSAGE = "The `@nx/vite:build` executor is deprecated and will be removed in Nx v24. Run `nx g @nx/vite:convert-to-inferred` to migrate to the `@nx/vite/plugin` inferred targets. See https://nx.dev/docs/guides/tasks--caching/convert-to-inferred for details.";
+export declare const VITE_DEV_SERVER_EXECUTOR_DEPRECATION_MESSAGE = "The `@nx/vite:dev-server` executor is deprecated and will be removed in Nx v24. Run `nx g @nx/vite:convert-to-inferred` to migrate to the `@nx/vite/plugin` inferred targets. See https://nx.dev/docs/guides/tasks--caching/convert-to-inferred for details.";
+export declare const VITE_PREVIEW_SERVER_EXECUTOR_DEPRECATION_MESSAGE = "The `@nx/vite:preview-server` executor is deprecated and will be removed in Nx v24. Run `nx g @nx/vite:convert-to-inferred` to migrate to the `@nx/vite/plugin` inferred targets. See https://nx.dev/docs/guides/tasks--caching/convert-to-inferred for details.";
+export declare function warnViteBuildExecutorDeprecation(): void;
+export declare function warnViteDevServerExecutorDeprecation(): void;
+export declare function warnVitePreviewServerExecutorDeprecation(): void;
+export declare function warnViteExecutorGenerating(): void;

package/dist/src/utils/deprecation.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VITE_PREVIEW_SERVER_EXECUTOR_DEPRECATION_MESSAGE = exports.VITE_DEV_SERVER_EXECUTOR_DEPRECATION_MESSAGE = exports.VITE_BUILD_EXECUTOR_DEPRECATION_MESSAGE = void 0;
+exports.warnViteBuildExecutorDeprecation = warnViteBuildExecutorDeprecation;
+exports.warnViteDevServerExecutorDeprecation = warnViteDevServerExecutorDeprecation;
+exports.warnVitePreviewServerExecutorDeprecation = warnVitePreviewServerExecutorDeprecation;
+exports.warnViteExecutorGenerating = warnViteExecutorGenerating;
+const devkit_1 = require("@nx/devkit");
+// TODO(v24): Remove the @nx/vite:build, @nx/vite:dev-server, and
+// @nx/vite:preview-server executors. The inferred plugin (@nx/vite/plugin)
+// and the convert-to-inferred generator stay supported. (`@nx/vite:test`
+// is being deprecated in a separate change for the test-runner batch.)
+exports.VITE_BUILD_EXECUTOR_DEPRECATION_MESSAGE = 'The `@nx/vite:build` executor is deprecated and will be removed in Nx v24. Run `nx g @nx/vite:convert-to-inferred` to migrate to the `@nx/vite/plugin` inferred targets. See https://nx.dev/docs/guides/tasks--caching/convert-to-inferred for details.';
+exports.VITE_DEV_SERVER_EXECUTOR_DEPRECATION_MESSAGE = 'The `@nx/vite:dev-server` executor is deprecated and will be removed in Nx v24. Run `nx g @nx/vite:convert-to-inferred` to migrate to the `@nx/vite/plugin` inferred targets. See https://nx.dev/docs/guides/tasks--caching/convert-to-inferred for details.';
+exports.VITE_PREVIEW_SERVER_EXECUTOR_DEPRECATION_MESSAGE = 'The `@nx/vite:preview-server` executor is deprecated and will be removed in Nx v24. Run `nx g @nx/vite:convert-to-inferred` to migrate to the `@nx/vite/plugin` inferred targets. See https://nx.dev/docs/guides/tasks--caching/convert-to-inferred for details.';
+function warnViteBuildExecutorDeprecation() {
+    devkit_1.logger.warn(exports.VITE_BUILD_EXECUTOR_DEPRECATION_MESSAGE);
+}
+function warnViteDevServerExecutorDeprecation() {
+    devkit_1.logger.warn(exports.VITE_DEV_SERVER_EXECUTOR_DEPRECATION_MESSAGE);
+}
+function warnVitePreviewServerExecutorDeprecation() {
+    devkit_1.logger.warn(exports.VITE_PREVIEW_SERVER_EXECUTOR_DEPRECATION_MESSAGE);
+}
+// Fired when the @nx/vite:configuration generator is about to generate
+// targets that use the deprecated executors — i.e. when @nx/vite/plugin
+// isn't registered in nx.json. Surfaces the deprecation at generation time
+// rather than only when the user later runs the generated targets.
+function warnViteExecutorGenerating() {
+    devkit_1.logger.warn('Generating targets that use the deprecated `@nx/vite:build`, `@nx/vite:dev-server`, and `@nx/vite:preview-server` executors. These executors will be removed in Nx v24. Run `nx g @nx/vite:convert-to-inferred` next to migrate these targets to the `@nx/vite/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/{src → dist/src}/utils/detect-ui-framework.d.ts

@@ -1,2 +1 @@
 export declare function detectUiFramework(project: string): Promise<'angular' | 'react' | 'none'>;
-//# sourceMappingURL=detect-ui-framework.d.ts.map

package/{src → dist/src}/utils/e2e-web-server-info-utils.d.ts

@@ -1,4 +1,3 @@
 import { type Tree } from '@nx/devkit';
-export declare function getViteE2EWebServerInfo(tree: Tree, projectName: string, configFilePath: string, isPluginBeingAdded: boolean, e2ePortOverride?: number, e2eCIPortOverride?: number): Promise<import("@nx/devkit/src/generators/e2e-web-server-info-utils").E2EWebServerDetails>;
-export declare function getReactRouterE2EWebServerInfo(tree: Tree, projectName: string, configFilePath: string, isPluginBeingAdded: boolean, e2ePortOverride?: number, e2eCIPortOverride?: number): Promise<import("@nx/devkit/src/generators/e2e-web-server-info-utils").E2EWebServerDetails>;
-//# sourceMappingURL=e2e-web-server-info-utils.d.ts.map
+export declare function getViteE2EWebServerInfo(tree: Tree, projectName: string, configFilePath: string, isPluginBeingAdded: boolean, e2ePortOverride?: number, e2eCIPortOverride?: number): Promise<import("@nx/devkit/internal").E2EWebServerDetails>;
+export declare function getReactRouterE2EWebServerInfo(tree: Tree, projectName: string, configFilePath: string, isPluginBeingAdded: boolean, e2ePortOverride?: number, e2eCIPortOverride?: number): Promise<import("@nx/devkit/internal").E2EWebServerDetails>;

package/{src → dist/src}/utils/e2e-web-server-info-utils.js

@@ -3,19 +3,18 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.getViteE2EWebServerInfo = getViteE2EWebServerInfo;
 exports.getReactRouterE2EWebServerInfo = getReactRouterE2EWebServerInfo;
 const devkit_1 = require("@nx/devkit");
-const e2e_web_server_info_utils_1 = require("@nx/devkit/src/generators/e2e-web-server-info-utils");
+const internal_1 = require("@nx/devkit/internal");
 async function getViteE2EWebServerInfo(tree, projectName, configFilePath, isPluginBeingAdded, e2ePortOverride, e2eCIPortOverride) {
     const nxJson = (0, devkit_1.readNxJson)(tree);
     let e2ePort = e2ePortOverride ?? 4200;
-    if ((nxJson.targetDefaults?.['dev'] &&
-        nxJson.targetDefaults?.['dev'].options?.port) ||
-        (nxJson.targetDefaults?.['serve'] &&
-            nxJson.targetDefaults?.['serve'].options?.port)) {
-        e2ePort =
-            nxJson.targetDefaults?.['dev'].options?.port ??
-                nxJson.targetDefaults?.['serve'].options?.port;
+    const devPort = (0, internal_1.readTargetDefaultsForTarget)('dev', nxJson.targetDefaults)
+        ?.options?.port;
+    const servePort = (0, internal_1.readTargetDefaultsForTarget)('serve', nxJson.targetDefaults)
+        ?.options?.port;
+    if (devPort || servePort) {
+        e2ePort = devPort ?? servePort;
     }
-    return (0, e2e_web_server_info_utils_1.getE2EWebServerInfo)(tree, projectName, {
+    return (0, internal_1.getE2EWebServerInfo)(tree, projectName, {
         plugin: '@nx/vite/plugin',
         serveTargetName: 'devTargetName',
         serveStaticTargetName: 'previewTargetName',
@@ -30,7 +29,7 @@ async function getViteE2EWebServerInfo(tree, projectName, configFilePath, isPlug
 }
 async function getReactRouterE2EWebServerInfo(tree, projectName, configFilePath, isPluginBeingAdded, e2ePortOverride, e2eCIPortOverride) {
     const e2ePort = e2ePortOverride ?? parseInt(process.env.PORT) ?? 4200;
-    return await (0, e2e_web_server_info_utils_1.getE2EWebServerInfo)(tree, projectName, {
+    return await (0, internal_1.getE2EWebServerInfo)(tree, projectName, {
         plugin: '@nx/react/router-plugin',
         serveTargetName: 'devTargetName',
         serveStaticTargetName: 'devTargetName',

package/{src → dist/src}/utils/ensure-dependencies.d.ts

@@ -3,7 +3,5 @@ export type EnsureDependenciesOptions = {
     uiFramework: 'angular' | 'react' | 'none';
     compiler?: 'babel' | 'swc';
     includeLib?: boolean;
-    testEnvironment?: 'node' | 'jsdom' | 'happy-dom' | 'edge-runtime' | string;
 };
 export declare function ensureDependencies(host: Tree, schema: EnsureDependenciesOptions): GeneratorCallback;
-//# sourceMappingURL=ensure-dependencies.d.ts.map

package/{src → dist/src}/utils/ensure-dependencies.js

@@ -6,22 +6,6 @@ const semver_1 = require("semver");
 const versions_1 = require("./versions");
 function ensureDependencies(host, schema) {
     const devDependencies = {};
-    if (schema.testEnvironment === 'jsdom') {
-        devDependencies['jsdom'] = versions_1.jsdomVersion;
-    }
-    else if (schema.testEnvironment === 'happy-dom') {
-        devDependencies['happy-dom'] = versions_1.happyDomVersion;
-    }
-    else if (schema.testEnvironment === 'edge-runtime') {
-        devDependencies['@edge-runtime/vm'] = versions_1.edgeRuntimeVmVersion;
-    }
-    else if (schema.testEnvironment !== 'node' && schema.testEnvironment) {
-        devkit_1.logger.info(`A custom environment was provided: ${schema.testEnvironment}. You need to install it manually.`);
-    }
-    if (schema.uiFramework === 'angular') {
-        devDependencies['@analogjs/vitest-angular'] = versions_1.analogVitestAngular;
-        devDependencies['@analogjs/vite-plugin-angular'] = versions_1.analogVitestAngular;
-    }
     if (schema.uiFramework === 'react') {
         if (schema.compiler === 'swc') {
             devDependencies['@vitejs/plugin-react-swc'] = versions_1.vitePluginReactSwcVersion;

package/{src → dist/src}/utils/executor-utils.d.ts

@@ -9,5 +9,3 @@ export declare function createBuildableTsConfig(projectRoot: string, options: {
     buildLibsFromSource?: boolean;
 }, context: ExecutorContext): string;
 export declare function loadViteDynamicImport(): Promise<typeof import("vite")>;
-export declare function loadVitestDynamicImport(): Promise<typeof import("vitest/node")>;
-//# sourceMappingURL=executor-utils.d.ts.map

package/{src → dist/src}/utils/executor-utils.js

@@ -3,9 +3,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.validateTypes = validateTypes;
 exports.createBuildableTsConfig = createBuildableTsConfig;
 exports.loadViteDynamicImport = loadViteDynamicImport;
-exports.loadVitestDynamicImport = loadVitestDynamicImport;
 const devkit_1 = require("@nx/devkit");
-const buildable_libs_utils_1 = require("@nx/js/src/utils/buildable-libs-utils");
+const internal_1 = require("@nx/js/internal");
 const options_utils_1 = require("./options-utils");
 const node_child_process_1 = require("node:child_process");
 const js_1 = require("@nx/js");
@@ -37,13 +36,13 @@ function createBuildableTsConfig(projectRoot, options, context) {
     const tsConfig = options.tsConfig ?? (0, options_utils_1.getProjectTsConfigPath)(projectRoot);
     options['buildLibsFromSource'] ??= true;
     if (!options['buildLibsFromSource']) {
-        const { dependencies } = (0, buildable_libs_utils_1.calculateProjectBuildableDependencies)(context.taskGraph, context.projectGraph, context.root, context.projectName, 
+        const { dependencies } = (0, internal_1.calculateProjectBuildableDependencies)(context.taskGraph, context.projectGraph, context.root, context.projectName, 
         // When using incremental building and the serve target is called
         // we need to get the deps for the 'build' target instead.
         context.targetName === 'serve' ? 'build' : context.targetName, context.configurationName);
         // This tsconfig is used via the Vite ts paths plugin.
         // It can be also used by other user-defined Vite plugins (e.g. for creating type declaration files).
-        const tmpTsConfigPath = (0, buildable_libs_utils_1.createTmpTsConfig)(tsConfig, context.root, projectRoot, dependencies);
+        const tmpTsConfigPath = (0, internal_1.createTmpTsConfig)(tsConfig, context.root, projectRoot, dependencies);
         process.env.NX_TSCONFIG_PATH = tmpTsConfigPath;
         return tmpTsConfigPath;
     }
@@ -52,6 +51,3 @@ function createBuildableTsConfig(projectRoot, options, context) {
 function loadViteDynamicImport() {
     return Function('return import("vite")')();
 }
-function loadVitestDynamicImport() {
-    return Function('return import("vitest/node")')();
-}

package/{src → dist/src}/utils/find-vite-config.d.ts

@@ -1,4 +1,3 @@
 import { Tree } from '@nx/devkit';
 export declare function findViteConfig(tree: Tree, searchRoot: string): string;
 export declare function findWebpackConfig(tree: Tree, searchRoot: string): string;
-//# sourceMappingURL=find-vite-config.d.ts.map

package/{src → dist/src}/utils/generator-utils.d.ts

@@ -1,6 +1,5 @@
 import { TargetConfiguration, Tree } from '@nx/devkit';
 import { ViteConfigurationGeneratorSchema } from '../generators/configuration/schema';
-import { VitestGeneratorSchema } from '../generators/vitest/schema';
 export type Target = 'build' | 'serve' | 'test' | 'preview';
 export type TargetFlags = Partial<Record<Target, boolean>>;
 export type UserProvidedTargetName = Partial<Record<Target, string>>;
@@ -11,7 +10,6 @@ export declare function findExistingJsBuildTargetInProject(targets: {
     supported?: string;
     unsupported?: string;
 };
-export declare function addOrChangeTestTarget(tree: Tree, options: VitestGeneratorSchema, hasPlugin: boolean): void;
 export declare function addBuildTarget(tree: Tree, options: ViteConfigurationGeneratorSchema, target: string): void;
 export declare function addServeTarget(tree: Tree, options: ViteConfigurationGeneratorSchema, target: string): void;
 /**
@@ -31,7 +29,7 @@ export interface ViteConfigFileOptions {
     includeVitest?: boolean;
     inSourceTests?: boolean;
     testEnvironment?: 'node' | 'jsdom' | 'happy-dom' | 'edge-runtime' | string;
-    rollupOptionsExternal?: string[];
+    rolldownOptionsExternal?: string[];
     imports?: string[];
     plugins?: string[];
     coverageProvider?: 'v8' | 'istanbul' | 'custom';
@@ -45,4 +43,3 @@ export declare function normalizeViteConfigFilePathWithTree(tree: Tree, projectR
 export declare function getViteConfigPathForProject(tree: Tree, projectName: string, target?: string): string;
 export declare function handleUnsupportedUserProvidedTargets(userProvidedTargetIsUnsupported: TargetFlags, userProvidedTargetName: UserProvidedTargetName, validFoundTargetName: ValidFoundTargetName): Promise<void>;
 export declare function handleUnknownConfiguration(projectName: string): Promise<void>;
-//# sourceMappingURL=generator-utils.d.ts.map