@nx/vite 24.0.0-beta.2 → 24.0.0-beta.4

package/dist/src/utils/dev-server-ready-check.js

@@ -0,0 +1,174 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseViteFlags = parseViteFlags;
+exports.getViteServerAddress = getViteServerAddress;
+exports.waitForViteServer = waitForViteServer;
+const internal_1 = require("@nx/devkit/internal");
+const net_1 = require("net");
+const path_1 = require("path");
+const executor_utils_1 = require("./executor-utils");
+// Vite's boolean options: the arg after one is positional, not its value
+const GLOBAL_BOOLEAN_OPTIONS = ['clearScreen', 'h', 'help', 'v', 'version'];
+const BOOLEAN_OPTIONS = {
+    serve: [
+        ...GLOBAL_BOOLEAN_OPTIONS,
+        'cors',
+        'strictPort',
+        'force',
+        'experimentalBundle',
+    ],
+    preview: [...GLOBAL_BOOLEAN_OPTIONS, 'strictPort'],
+};
+/**
+ * The flags `vite` and `vite preview` get from the target's options, in the
+ * order run-commands passes them: named options, `args`, then overrides.
+ */
+function parseViteFlags(options, command) {
+    const args = Array.isArray(options.args)
+        ? options.args.join(' ')
+        : typeof options.args === 'string'
+            ? options.args
+            : '';
+    const unparsed = Array.isArray(options.__unparsed__)
+        ? options.__unparsed__.map(String)
+        : [];
+    // run-commands skips a named option the overrides set, or that args set to
+    // another value, parsing both with nx's yargs-parser
+    const yargsParser = require(require.resolve('yargs-parser', {
+        paths: [(0, path_1.dirname)(require.resolve('nx/package.json'))],
+    }));
+    const overrides = yargsParser(unparsed, {
+        configuration: {
+            'parse-numbers': false,
+            'parse-positional-numbers': false,
+            'dot-notation': false,
+            'camel-case-expansion': false,
+        },
+    });
+    const fromArgs = args
+        ? yargsParser(args.replace(/(^"|"$)/g, ''), {
+            configuration: { 'camel-case-expansion': true },
+        })
+        : {};
+    const named = Object.keys(options)
+        .filter((k) => ['port', 'host', 'mode', 'm', 'config', 'c'].includes(k) &&
+        typeof options[k] !== 'object' &&
+        overrides[k] === undefined &&
+        (!Object.hasOwn(fromArgs, k) || fromArgs[k] === options[k]))
+        .map((k) => `--${k}=${options[k]}`);
+    const { values, positionals } = parseArgv([...named, ...(0, internal_1.splitShellArgs)(args), ...unparsed], BOOLEAN_OPTIONS[command]);
+    // Vite keeps the values of whichever spelling of an option comes first
+    const last = (...names) => values.get([...values.keys()].find((k) => names.includes(k)))?.at(-1);
+    const asString = (value) => typeof value === 'string' ? value : undefined;
+    return {
+        port: asString(last('port')),
+        host: last('host'),
+        mode: asString(last('m', 'mode')),
+        config: asString(last('c', 'config')),
+        root: positionals[0],
+    };
+}
+// A port of the mri parser Vite's CLI uses, keeping each option's values
+function parseArgv(argv, booleans) {
+    const values = new Map();
+    const positionals = [];
+    const add = (name, value) => values.set(name, [...(values.get(name) ?? []), value]);
+    for (let i = 0; i < argv.length; i++) {
+        const arg = argv[i];
+        if (arg === '--')
+            break;
+        const dashes = arg.match(/^-*/)[0].length;
+        if (dashes === 0) {
+            positionals.push(arg);
+            continue;
+        }
+        if (arg.startsWith('no-', dashes)) {
+            add(arg.slice(dashes + 3), false);
+            continue;
+        }
+        const eq = arg.indexOf('=', dashes + 1);
+        const name = arg.slice(dashes, eq === -1 ? undefined : eq);
+        const value = (eq === -1 ? '' : arg.slice(eq + 1)) ||
+            i + 1 === argv.length ||
+            argv[i + 1].startsWith('-') ||
+            argv[++i];
+        // `-abc` sets a, b and c, and the value goes to c
+        const names = dashes === 2 ? [name] : [...name];
+        names.forEach((n, j) => {
+            const v = j === names.length - 1 ? value : true;
+            if (typeof v === 'string' && booleans.includes(n)) {
+                if (v !== 'true' && v !== 'false')
+                    positionals.push(v);
+                add(n, v !== 'false');
+            }
+            else {
+                add(n, v);
+            }
+        });
+    }
+    return { values, positionals };
+}
+// Vite's default ports: https://vite.dev/config/server-options#server-port
+const DEFAULT_PORT = { serve: 5173, preview: 4173 };
+function getViteServerAddress(server, flags, command) {
+    const port = Number(flags.port ?? server?.port ?? DEFAULT_PORT[command]);
+    if (!Number.isInteger(port) || port <= 0)
+        return null;
+    const host = flags.host ?? server?.host;
+    // `true` and the wildcards listen on every address, loopback included
+    return typeof host === 'string' &&
+        !['localhost', '0.0.0.0', '::'].includes(host)
+        ? { port, host }
+        : { port };
+}
+/**
+ * The readyWhen of the inferred serve and preview targets when the config
+ * doesn't load the signal plugin. Runs in the env and with the options of the
+ * task, resolves the config the way `vite` does, and waits for the server's
+ * port.
+ */
+async function waitForViteServer(configPath, command) {
+    let options = {};
+    try {
+        options = JSON.parse(process.env.NX_TASK_OPTIONS ?? '{}');
+    }
+    catch { }
+    const flags = parseViteFlags(options, command);
+    process.chdir((0, path_1.resolve)(options.cwd ?? '.'));
+    const { resolveConfig } = await (0, executor_utils_1.loadViteDynamicImport)();
+    const inlineConfig = {
+        root: flags.root,
+        // With --root and no --config, Vite finds the config in the root, not in
+        // the task's cwd
+        configFile: flags.config ?? (flags.root ? undefined : configPath),
+        mode: flags.mode,
+    };
+    // The mode and NODE_ENV defaults of `vite` and `vite preview`
+    const config = command === 'preview'
+        ? await resolveConfig(inlineConfig, 'serve', 'production', 'production', true)
+        : await resolveConfig(inlineConfig, 'serve');
+    const address = getViteServerAddress(command === 'preview'
+        ? { ...config.preview, host: config.preview.host ?? config.server.host }
+        : config.server, flags, command);
+    if (address)
+        await waitForAddress(address);
+}
+async function waitForAddress({ port, host }) {
+    const hosts = host ? [host] : ['127.0.0.1', '::1'];
+    while (!(await Promise.any(hosts.map((h) => connects(port, h))).catch(() => false))) {
+        await new Promise((r) => setTimeout(r, 250));
+    }
+}
+function connects(port, host) {
+    return new Promise((resolve, reject) => {
+        const socket = (0, net_1.createConnection)({ port, host });
+        socket.once('connect', () => {
+            socket.destroy();
+            resolve(true);
+        });
+        socket.once('error', (e) => {
+            socket.destroy();
+            reject(e);
+        });
+    });
+}

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

@@ -1,3 +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/internal").E2EWebServerDetails>;
-export declare function getReactRouterE2EWebServerInfo(tree: Tree, projectName: string, configFilePath: string, isPluginBeingAdded: boolean, e2ePortOverride?: number, e2eCIPortOverride?: number): Promise<import("@nx/devkit/internal").E2EWebServerDetails>;
+export declare function getViteE2EWebServerInfo(tree: Tree, projectName: string, configFilePath: string, e2ePortOverride?: number, e2eCIPortOverride?: number): Promise<import("@nx/devkit/internal").E2EWebServerDetails>;
+export declare function getReactRouterE2EWebServerInfo(tree: Tree, projectName: string, configFilePath: string, e2ePortOverride?: number, e2eCIPortOverride?: number): Promise<import("@nx/devkit/internal").E2EWebServerDetails>;

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

@@ -4,7 +4,7 @@ exports.getViteE2EWebServerInfo = getViteE2EWebServerInfo;
 exports.getReactRouterE2EWebServerInfo = getReactRouterE2EWebServerInfo;
 const devkit_1 = require("@nx/devkit");
 const internal_1 = require("@nx/devkit/internal");
-async function getViteE2EWebServerInfo(tree, projectName, configFilePath, isPluginBeingAdded, e2ePortOverride, e2eCIPortOverride) {
+async function getViteE2EWebServerInfo(tree, projectName, configFilePath, e2ePortOverride, e2eCIPortOverride) {
     const nxJson = (0, devkit_1.readNxJson)(tree);
     let e2ePort = e2ePortOverride ?? 4200;
     const devPort = (0, internal_1.readTargetDefaultsForTarget)('dev', nxJson.targetDefaults)
@@ -25,9 +25,9 @@ async function getViteE2EWebServerInfo(tree, projectName, configFilePath, isPlug
         defaultE2EWebServerAddress: `http://localhost:${e2ePort}`,
         defaultE2ECiBaseUrl: `http://localhost:${e2eCIPortOverride ?? 4300}`,
         defaultE2EPort: e2ePort,
-    }, isPluginBeingAdded);
+    });
 }
-async function getReactRouterE2EWebServerInfo(tree, projectName, configFilePath, isPluginBeingAdded, e2ePortOverride, e2eCIPortOverride) {
+async function getReactRouterE2EWebServerInfo(tree, projectName, configFilePath, e2ePortOverride, e2eCIPortOverride) {
     const e2ePort = e2ePortOverride ?? parseInt(process.env.PORT) ?? 4200;
     return await (0, internal_1.getE2EWebServerInfo)(tree, projectName, {
         plugin: '@nx/react/router-plugin',
@@ -40,5 +40,5 @@ async function getReactRouterE2EWebServerInfo(tree, projectName, configFilePath,
         defaultE2EWebServerAddress: `http://localhost:${e2ePort}`,
         defaultE2ECiBaseUrl: `http://localhost:${e2eCIPortOverride ?? 4200}`,
         defaultE2EPort: e2ePort,
-    }, isPluginBeingAdded);
+    });
 }

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

@@ -1,11 +1 @@
-import { ExecutorContext } from '@nx/devkit';
-export declare function validateTypes(opts: {
-    workspaceRoot: string;
-    tsconfig: string;
-    isVueProject?: boolean;
-}): Promise<void>;
-export declare function createBuildableTsConfig(projectRoot: string, options: {
-    tsConfig?: string;
-    buildLibsFromSource?: boolean;
-}, context: ExecutorContext): string;
 export declare function loadViteDynamicImport(): Promise<typeof import('vite')>;

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

@@ -1,57 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.validateTypes = validateTypes;
-exports.createBuildableTsConfig = createBuildableTsConfig;
 exports.loadViteDynamicImport = loadViteDynamicImport;
-const devkit_1 = require("@nx/devkit");
-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");
-const path_1 = require("path");
-async function validateTypes(opts) {
-    if (!opts.isVueProject) {
-        const result = await (0, js_1.runTypeCheck)({
-            workspaceRoot: opts.workspaceRoot,
-            tsConfigPath: opts.tsconfig.startsWith(opts.workspaceRoot)
-                ? opts.tsconfig
-                : (0, path_1.join)(opts.workspaceRoot, opts.tsconfig),
-            mode: 'noEmit',
-            // TS 6 defaults rootDir to the tsconfig dir, so from-source workspace
-            // libs (outside the project) trip TS6059. rootDir is emit-only and this
-            // is noEmit, so widen it to the workspace root to clear the false error.
-            rootDir: opts.workspaceRoot,
-        });
-        await (0, js_1.printDiagnostics)(result.errors, result.warnings);
-        if (result.errors.length > 0) {
-            throw new Error('Found type errors. See above.');
-        }
-    }
-    else {
-        const pm = (0, devkit_1.getPackageManagerCommand)();
-        const cp = (0, node_child_process_1.execSync)(`${pm.exec} vue-tsc --noEmit -p ${opts.tsconfig} --composite false`, {
-            cwd: opts.workspaceRoot,
-            stdio: 'inherit',
-            windowsHide: true,
-        });
-    }
-}
-function createBuildableTsConfig(projectRoot, options, context) {
-    const tsConfig = options.tsConfig ?? (0, options_utils_1.getProjectTsConfigPath)(projectRoot);
-    options['buildLibsFromSource'] ??= true;
-    if (!options['buildLibsFromSource']) {
-        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, internal_1.createTmpTsConfig)(tsConfig, context.root, projectRoot, dependencies);
-        process.env.NX_TSCONFIG_PATH = tmpTsConfigPath;
-        return tmpTsConfigPath;
-    }
-    return tsConfig;
-}
 function loadViteDynamicImport() {
     return Function('return import("vite")')();
 }

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

@@ -10,16 +10,7 @@ export declare function findExistingJsBuildTargetInProject(targets: {
     supported?: string;
     unsupported?: string;
 };
-export declare function addBuildTarget(tree: Tree, options: ViteConfigurationGeneratorSchema, target: string): void;
-export declare function addServeTarget(tree: Tree, options: ViteConfigurationGeneratorSchema, target: string): void;
-/**
- * Adds a target for the preview server.
- *
- * @param tree
- * @param options
- * @param serveTarget An existing serve target.
- */
-export declare function addPreviewTarget(tree: Tree, options: ViteConfigurationGeneratorSchema, serveTarget: string): void;
+export declare function assertNoRemovedExecutorTargets(projectName: string, targets: Record<string, TargetConfiguration> | undefined): void;
 export declare function editTsConfig(tree: Tree, options: ViteConfigurationGeneratorSchema): void;
 export declare function deleteWebpackConfig(tree: Tree, projectRoot: string, webpackConfigFilePath?: string): void;
 export declare function moveAndEditIndexHtml(tree: Tree, options: ViteConfigurationGeneratorSchema): void;

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

@@ -1,9 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.findExistingJsBuildTargetInProject = findExistingJsBuildTargetInProject;
-exports.addBuildTarget = addBuildTarget;
-exports.addServeTarget = addServeTarget;
-exports.addPreviewTarget = addPreviewTarget;
+exports.assertNoRemovedExecutorTargets = assertNoRemovedExecutorTargets;
 exports.editTsConfig = editTsConfig;
 exports.deleteWebpackConfig = deleteWebpackConfig;
 exports.moveAndEditIndexHtml = moveAndEditIndexHtml;
@@ -16,10 +14,12 @@ const internal_1 = require("@nx/devkit/internal");
 const devkit_1 = require("@nx/devkit");
 const internal_2 = require("@nx/js/internal");
 const vite_config_edit_utils_1 = require("./vite-config-edit-utils");
+const version_utils_1 = require("./version-utils");
+const versions_1 = require("./versions");
 function findExistingJsBuildTargetInProject(targets) {
     const output = {};
     const supportedExecutors = {
-        build: ['@nx/js:babel', '@nx/js:swc', '@nx/rollup:rollup'],
+        build: ['@nx/js:swc'],
     };
     const unsupportedExecutors = [
         '@nx/angular:ng-packagr-lite',
@@ -63,92 +63,23 @@ function findExistingJsBuildTargetInProject(targets) {
     }
     return output;
 }
-function addBuildTarget(tree, options, target) {
-    (0, internal_1.addBuildTargetDefaults)(tree, '@nx/vite:build');
-    const project = (0, devkit_1.readProjectConfiguration)(tree, options.project);
-    const isTsSolutionSetup = (0, internal_2.isUsingTsSolutionSetup)(tree);
-    const buildOptions = {
-        outputPath: isTsSolutionSetup
-            ? (0, devkit_1.joinPathFragments)(project.root, 'dist')
-            : (0, devkit_1.joinPathFragments)('dist', project.root != '.' ? project.root : options.project),
-    };
-    project.targets ??= {};
-    project.targets[target] = {
-        executor: '@nx/vite:build',
-        outputs: ['{options.outputPath}'],
-        defaultConfiguration: 'production',
-        options: buildOptions,
-        configurations: {
-            development: {
-                mode: 'development',
-            },
-            production: {
-                mode: 'production',
-            },
-        },
-    };
-    (0, devkit_1.updateProjectConfiguration)(tree, options.project, project);
-}
-function addServeTarget(tree, options, target) {
-    const project = (0, devkit_1.readProjectConfiguration)(tree, options.project);
-    project.targets ??= {};
-    project.targets[target] = {
-        executor: '@nx/vite:dev-server',
-        defaultConfiguration: 'development',
-        options: {
-            buildTarget: `${options.project}:build`,
-        },
-        configurations: {
-            development: {
-                buildTarget: `${options.project}:build:development`,
-                hmr: true,
-            },
-            production: {
-                buildTarget: `${options.project}:build:production`,
-                hmr: false,
-            },
-        },
-    };
-    (0, devkit_1.updateProjectConfiguration)(tree, options.project, project);
-}
-/**
- * Adds a target for the preview server.
- *
- * @param tree
- * @param options
- * @param serveTarget An existing serve target.
- */
-function addPreviewTarget(tree, options, serveTarget) {
-    const project = (0, devkit_1.readProjectConfiguration)(tree, options.project);
-    const previewOptions = {
-        buildTarget: `${options.project}:build`,
-    };
-    project.targets ??= {};
-    // Update the options from the passed serve target.
-    if (project.targets[serveTarget]) {
-        const target = project.targets[serveTarget];
-        if (target.executor === '@nxext/vite:dev') {
-            previewOptions.proxyConfig = target.options.proxyConfig;
-        }
-        previewOptions['https'] = target.options?.https;
-        previewOptions['open'] = target.options?.open;
+// A leftover target on one of these can't run, and it shadows the inferred
+// target with the same name, so converting around it leaves a broken project.
+const removedConvertibleExecutors = [
+    '@nx/rollup:rollup',
+    '@nx/vite:build',
+    '@nx/vite:dev-server',
+    '@nx/vite:preview-server',
+    '@nx/webpack:dev-server',
+    '@nx/webpack:webpack',
+];
+function assertNoRemovedExecutorTargets(projectName, targets) {
+    const removedTargets = Object.entries(targets ?? {})
+        .filter(([, target]) => removedConvertibleExecutors.includes(target.executor))
+        .map(([targetName, target]) => `${targetName} (${target.executor})`);
+    if (removedTargets.length) {
+        throw new Error(`The project ${projectName} has targets using removed executors: ${removedTargets.join(', ')}. Convert them to inferred targets first, for example with "nx g @nx/workspace:infer-targets --project=${projectName}".`);
     }
-    // Adds a preview target.
-    project.targets.preview = {
-        dependsOn: ['build'],
-        executor: '@nx/vite:preview-server',
-        defaultConfiguration: 'development',
-        options: previewOptions,
-        configurations: {
-            development: {
-                buildTarget: `${options.project}:build:development`,
-            },
-            production: {
-                buildTarget: `${options.project}:build:production`,
-            },
-        },
-    };
-    (0, devkit_1.updateProjectConfiguration)(tree, options.project, project);
 }
 function editTsConfig(tree, options) {
     const projectConfig = (0, devkit_1.readProjectConfiguration)(tree, options.project);
@@ -285,18 +216,38 @@ function createOrEditViteConfig(tree, options, onlyVitest, projectAlreadyHasVite
   },`;
     const imports = options.imports ? [...options.imports] : [];
     const plugins = options.plugins ? [...options.plugins] : [];
+    const needsPaths = !isTsSolutionSetup;
+    const useNativePaths = needsPaths && ((0, version_utils_1.getInstalledViteMajorVersion)(tree) ?? 8) >= 8;
+    const dependencies = {};
+    if (needsPaths && !useNativePaths) {
+        imports.push(`import tsconfigPaths from 'vite-tsconfig-paths'`);
+        plugins.push('tsconfigPaths({ loose: true })');
+        dependencies['vite-tsconfig-paths'] = versions_1.viteTsconfigPathsVersion;
+    }
+    if (!onlyVitest && options.includeLib && !isTsSolutionSetup) {
+        plugins.push(`import('vite-plugin-static-copy').then(({ viteStaticCopy }) => viteStaticCopy({
+      targets: [
+        { src: '*.md', dest: '.' },
+        { src: 'package.json', dest: '.', overwrite: false },
+      ],
+      silent: true,
+    }))`);
+        dependencies['vite-plugin-static-copy'] = versions_1.viteStaticCopyVersion;
+    }
+    if (Object.keys(dependencies).length) {
+        (0, devkit_1.addDependenciesToPackageJson)(tree, {}, dependencies, undefined, true);
+    }
     if (!onlyVitest && options.includeLib) {
         imports.push(`import dts from 'vite-plugin-dts'`, `import * as path from 'path'`);
     }
-    if (!isTsSolutionSetup) {
-        // TODO(v24): drop this branch; emit `tsconfigPaths()` from
-        // `vite-tsconfig-paths` instead of the deprecated nx helpers.
-        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 (!onlyVitest && options.includeLib) {
         plugins.push(`dts({ entryRoot: 'src', tsconfigPath: path.join(import.meta.dirname, 'tsconfig.lib.json')${!isTsSolutionSetup ? ', pathsToAliases: false' : ''} })`);
     }
+    // Lets the inferred serve and preview targets know when the server is up
+    if (!onlyVitest && !options.includeLib) {
+        imports.push(`import { nxReadySignal } from '@nx/vite/plugins/nx-ready-signal.plugin'`);
+        plugins.push('nxReadySignal()');
+    }
     const reportsDirectory = isTsSolutionSetup
         ? './test-output/vitest/coverage'
         : projectRoot === '.'
@@ -343,18 +294,21 @@ ${options.inSourceTests
     port: ${options.previewPort ?? 4300},
     host: 'localhost',
   },`;
-    const workerOption = isTsSolutionSetup
-        ? `  // Uncomment this if you are using workers.
+    const workerOption = `  // Uncomment this if you are using workers.
   // worker: {
   //  plugins: [],
-  // },`
-        : `  // Uncomment this if you are using workers.
-  // worker: {
-  //   plugins: () => [ nxViteTsPaths() ],
   // },`;
+    // Path-based workspace libraries need Vite's native tsconfig paths
+    // resolution, which is off by default. Workspaces on project references
+    // resolve through package.json instead.
+    const resolveOption = !useNativePaths
+        ? ''
+        : `  resolve: {
+    tsconfigPaths: true,
+  },`;
     const cacheDir = `cacheDir: '${normalizedJoinPaths((0, devkit_1.offsetFromRoot)(projectRoot), 'node_modules', '.vite', projectRoot === '.' ? options.project : projectRoot)}',`;
     if (tree.exists(viteConfigPath)) {
-        handleViteConfigFileExists(tree, viteConfigPath, options, buildOption, buildOutDir, imports, plugins, testOption, reportsDirectory, cacheDir, projectRoot, (0, devkit_1.offsetFromRoot)(projectRoot), projectAlreadyHasViteTargets);
+        handleViteConfigFileExists(tree, viteConfigPath, options, buildOption, buildOutDir, imports, plugins, testOption, reportsDirectory, cacheDir, projectRoot, (0, devkit_1.offsetFromRoot)(projectRoot), projectAlreadyHasViteTargets, useNativePaths);
         return;
     }
     const viteConfigContent = `/// <reference types='vitest' />
@@ -363,7 +317,7 @@ ${imports.join(';\n')}${imports.length ? ';' : ''}
 
 export default defineConfig(() => ({
   root: import.meta.dirname,
-  ${printOptions(cacheDir, devServerOption, previewServerOption, `  plugins: [${plugins.join(', ')}],`, workerOption, buildOption, defineOption, testOption)}
+  ${printOptions(cacheDir, devServerOption, previewServerOption, resolveOption, plugins.length ? `  plugins: [${plugins.join(', ')}],` : '', workerOption, buildOption, defineOption, testOption)}
 }));
 `.replace(/\s+(?=(\n|$))/gm, '\n');
     tree.write(viteConfigPath, viteConfigContent);
@@ -383,16 +337,10 @@ function normalizeViteConfigFilePathWithTree(tree, projectRoot, configFile) {
                     : undefined;
 }
 function getViteConfigPathForProject(tree, projectName, target) {
-    let viteConfigPath;
     const { targets, root } = (0, devkit_1.readProjectConfiguration)(tree, projectName);
-    if (target) {
-        viteConfigPath = targets?.[target]?.options?.configFile;
-    }
-    else {
-        const config = Object.values(targets).find((config) => config.executor === '@nrwl/nx:build' ||
-            config.executor === '@nrwl/vite:build');
-        viteConfigPath = config?.options?.configFile;
-    }
+    const viteConfigPath = target
+        ? targets?.[target]?.options?.configFile
+        : undefined;
     return normalizeViteConfigFilePathWithTree(tree, root, viteConfigPath);
 }
 async function handleUnsupportedUserProvidedTargets(userProvidedTargetIsUnsupported, userProvidedTargetName, validFoundTargetName) {
@@ -447,7 +395,7 @@ async function handleUnknownConfiguration(projectName) {
     `);
     }
 }
-function handleViteConfigFileExists(tree, viteConfigPath, options, buildOption, buildOutDir, imports, plugins, testOption, reportsDirectory, cacheDir, projectRoot, offsetFromRoot, projectAlreadyHasViteTargets) {
+function handleViteConfigFileExists(tree, viteConfigPath, options, buildOption, buildOutDir, imports, plugins, testOption, reportsDirectory, cacheDir, projectRoot, offsetFromRoot, projectAlreadyHasViteTargets, resolveTsconfigPaths) {
     if (projectAlreadyHasViteTargets?.build &&
         projectAlreadyHasViteTargets?.test) {
         return;
@@ -489,7 +437,7 @@ function handleViteConfigFileExists(tree, viteConfigPath, options, buildOption,
             provider: `'${options.coverageProvider ?? 'v8'}'`,
         },
     };
-    const changed = (0, vite_config_edit_utils_1.ensureViteConfigIsCorrect)(tree, viteConfigPath, buildOption, buildOptionObject, imports, plugins, testOption, testOptionObject, cacheDir, projectAlreadyHasViteTargets ?? {});
+    const changed = (0, vite_config_edit_utils_1.ensureViteConfigIsCorrect)(tree, viteConfigPath, buildOption, buildOptionObject, imports, plugins, testOption, testOptionObject, cacheDir, projectAlreadyHasViteTargets ?? {}, resolveTsconfigPaths);
     if (!changed) {
         devkit_1.logger.warn(`Make sure the following setting exists in your Vite configuration file (${viteConfigPath}):
         

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

@@ -1,17 +1 @@
-import { ExecutorContext } from '@nx/devkit';
-import { ViteDevServerExecutorOptions } from '../executors/dev-server/schema';
-/**
- * Returns the path to the vite config file or undefined when not found.
- */
-export declare function normalizeViteConfigFilePath(contextRoot: string, projectRoot: string, configFile?: string): string | undefined;
 export declare function getProjectTsConfigPath(projectRoot: string): string | undefined;
-/**
- * Returns the path to the proxy configuration file or undefined when not found.
- */
-export declare function getViteServerProxyConfigPath(nxProxyConfig: string | undefined, context: ExecutorContext): string | undefined;
-/**
- * Builds the options for the vite dev server.
- */
-export declare function getViteServerOptions(options: ViteDevServerExecutorOptions, context: ExecutorContext): Promise<Record<string, unknown>>;
-export declare function getProxyConfig(context: ExecutorContext, proxyConfig?: string): Record<string, string | unknown> | undefined;
-export declare function getNxTargetOptions(target: string, context: ExecutorContext): any;

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

@@ -1,32 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.normalizeViteConfigFilePath = normalizeViteConfigFilePath;
 exports.getProjectTsConfigPath = getProjectTsConfigPath;
-exports.getViteServerProxyConfigPath = getViteServerProxyConfigPath;
-exports.getViteServerOptions = getViteServerOptions;
-exports.getProxyConfig = getProxyConfig;
-exports.getNxTargetOptions = getNxTargetOptions;
 const devkit_1 = require("@nx/devkit");
 const fs_1 = require("fs");
-const executor_utils_1 = require("./executor-utils");
-/**
- * Returns the path to the vite config file or undefined when not found.
- */
-function normalizeViteConfigFilePath(contextRoot, projectRoot, configFile) {
-    if (configFile) {
-        const normalized = (0, devkit_1.joinPathFragments)(contextRoot, configFile);
-        if (!(0, fs_1.existsSync)(normalized)) {
-            throw new Error(`Could not find vite config at provided path "${normalized}".`);
-        }
-        return normalized;
-    }
-    const allowsExt = ['js', 'mjs', 'ts', 'cjs', 'mts', 'cts'];
-    for (const ext of allowsExt) {
-        if ((0, fs_1.existsSync)((0, devkit_1.joinPathFragments)(contextRoot, projectRoot, `vite.config.${ext}`))) {
-            return (0, devkit_1.joinPathFragments)(contextRoot, projectRoot, `vite.config.${ext}`);
-        }
-    }
-}
 function getProjectTsConfigPath(projectRoot) {
     return (0, fs_1.existsSync)((0, devkit_1.joinPathFragments)(devkit_1.workspaceRoot, projectRoot, 'tsconfig.app.json'))
         ? (0, devkit_1.joinPathFragments)(projectRoot, 'tsconfig.app.json')
@@ -36,52 +12,3 @@ function getProjectTsConfigPath(projectRoot) {
                 ? (0, devkit_1.joinPathFragments)(projectRoot, 'tsconfig.json')
                 : undefined;
 }
-/**
- * Returns the path to the proxy configuration file or undefined when not found.
- */
-function getViteServerProxyConfigPath(nxProxyConfig, context) {
-    if (nxProxyConfig) {
-        const projectRoot = context.projectsConfigurations.projects[context.projectName].root;
-        const proxyConfigPath = nxProxyConfig
-            ? (0, devkit_1.joinPathFragments)(context.root, nxProxyConfig)
-            : (0, devkit_1.joinPathFragments)(projectRoot, 'proxy.conf.json');
-        if ((0, fs_1.existsSync)(proxyConfigPath)) {
-            return proxyConfigPath;
-        }
-    }
-}
-/**
- * Builds the options for the vite dev server.
- */
-async function getViteServerOptions(options, context) {
-    // returns vite ServerOptions
-    // Allows ESM to be required in CJS modules. Vite will be published as ESM in the future.
-    const { searchForWorkspaceRoot } = await (0, executor_utils_1.loadViteDynamicImport)();
-    const projectRoot = context.projectsConfigurations.projects[context.projectName].root;
-    const serverOptions = {
-        fs: {
-            allow: [
-                searchForWorkspaceRoot((0, devkit_1.joinPathFragments)(projectRoot)),
-                (0, devkit_1.joinPathFragments)(context.root, 'node_modules/vite'),
-            ],
-        },
-    };
-    const proxyConfigPath = getViteServerProxyConfigPath(options.proxyConfig, context);
-    if (proxyConfigPath) {
-        devkit_1.logger.info(`Loading proxy configuration from: ${proxyConfigPath}`);
-        serverOptions.proxy = require(proxyConfigPath);
-    }
-    return serverOptions;
-}
-function getProxyConfig(context, proxyConfig) {
-    const proxyConfigPath = getViteServerProxyConfigPath(proxyConfig, context);
-    if (proxyConfigPath) {
-        devkit_1.logger.info(`Loading proxy configuration from: ${proxyConfigPath}`);
-        return require(proxyConfigPath);
-    }
-    return;
-}
-function getNxTargetOptions(target, context) {
-    const targetObj = (0, devkit_1.parseTargetString)(target, context);
-    return (0, devkit_1.readTargetOptions)(targetObj, context);
-}

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

@@ -10,3 +10,5 @@ export declare const vitePluginReactSwcVersion = "^4.3.0";
 export declare const vitePluginDtsVersion = "~4.5.0";
 export declare const ajvVersion = "^8.0.0";
 export declare const jitiVersion = "2.4.2";
+export declare const viteTsconfigPathsVersion = "~4.3.2";
+export declare const viteStaticCopyVersion = "^3.3.0";