@nx/vite 17.0.4 → 17.0.6

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

@@ -1 +1 @@
-{"version":3,"sources":["../../../../../packages/vite/src/utils/executor-utils.ts"],"sourcesContent":["import { printDiagnostics, runTypeCheck } from '@nx/js';\nimport { join } from 'path';\nimport { ViteBuildExecutorOptions } from '../executors/build/schema';\nimport { ExecutorContext } from '@nx/devkit';\nimport { ViteDevServerExecutorOptions } from '../executors/dev-server/schema';\nimport {\n  calculateProjectBuildableDependencies,\n  createTmpTsConfig,\n} from '@nx/js/src/utils/buildable-libs-utils';\nimport { getProjectTsConfigPath } from './options-utils';\n\nexport async function validateTypes(opts: {\n  workspaceRoot: string;\n  projectRoot: string;\n  tsconfig: string;\n}): Promise<void> {\n  const result = await runTypeCheck({\n    workspaceRoot: opts.workspaceRoot,\n    tsConfigPath: join(opts.workspaceRoot, opts.tsconfig),\n    mode: 'noEmit',\n  });\n\n  await printDiagnostics(result.errors, result.warnings);\n\n  if (result.errors.length > 0) {\n    throw new Error('Found type errors. See above.');\n  }\n}\n\nexport function createBuildableTsConfig(\n  projectRoot: string,\n  options: ViteBuildExecutorOptions | ViteDevServerExecutorOptions,\n  context: ExecutorContext\n) {\n  const tsConfig = getProjectTsConfigPath(projectRoot);\n  options['buildLibsFromSource'] ??= true;\n\n  if (!options['buildLibsFromSource']) {\n    const { dependencies } = calculateProjectBuildableDependencies(\n      context.taskGraph,\n      context.projectGraph,\n      context.root,\n      context.projectName,\n      // When using incremental building and the serve target is called\n      // we need to get the deps for the 'build' target instead.\n      context.targetName === 'serve' ? 'build' : context.targetName,\n      context.configurationName\n    );\n    // This tsconfig is used via the Vite ts paths plugin.\n    // It can be also used by other user-defined Vite plugins (e.g. for creating type declaration files).\n    const tmpTsConfigPath = createTmpTsConfig(\n      tsConfig,\n      context.root,\n      projectRoot,\n      dependencies\n    );\n    process.env.NX_TSCONFIG_PATH = tmpTsConfigPath;\n  }\n}\n\nexport function loadViteDynamicImport() {\n  return Function('return import(\"vite\")')() as Promise<typeof import('vite')>;\n}\n\nexport function loadVitestDynamicImport() {\n  return Function('return import(\"vitest/node\")')() as Promise<\n    typeof import('vitest/node')\n  >;\n}\n"],"names":["validateTypes","createBuildableTsConfig","loadViteDynamicImport","loadVitestDynamicImport","opts","result","runTypeCheck","workspaceRoot","tsConfigPath","join","tsconfig","mode","printDiagnostics","errors","warnings","length","Error","projectRoot","options","context","tsConfig","getProjectTsConfigPath","dependencies","calculateProjectBuildableDependencies","taskGraph","projectGraph","root","projectName","targetName","configurationName","tmpTsConfigPath","createTmpTsConfig","process","env","NX_TSCONFIG_PATH","Function"],"mappings":";;;;;;;;IAWsBA,aAAa;eAAbA;;IAkBNC,uBAAuB;eAAvBA;;IA+BAC,qBAAqB;eAArBA;;IAIAC,uBAAuB;eAAvBA;;;oBAhE+B;sBAC1B;oCAOd;8BACgC;AAEhC,eAAeH,cAAcI,IAInC;IACC,MAAMC,SAAS,MAAMC,IAAAA,gBAAY,EAAC;QAChCC,eAAeH,KAAKG,aAAa;QACjCC,cAAcC,IAAAA,UAAI,EAACL,KAAKG,aAAa,EAAEH,KAAKM,QAAQ;QACpDC,MAAM;IACR;IAEA,MAAMC,IAAAA,oBAAgB,EAACP,OAAOQ,MAAM,EAAER,OAAOS,QAAQ;IAErD,IAAIT,OAAOQ,MAAM,CAACE,MAAM,GAAG,GAAG;QAC5B,MAAM,IAAIC,MAAM;IAClB;AACF;AAEO,SAASf,wBACdgB,WAAmB,EACnBC,OAAgE,EAChEC,OAAwB;QAGxBD,UAAQ;IADR,MAAME,WAAWC,IAAAA,oCAAsB,EAACJ;;IACxCC,MAAAA,WAAAA,QAAO,CAAC,uBAAA,sBAAsB,gBAA9BA,QAAO,CAAC,qBAAsB,GAAK;IAEnC,IAAI,CAACA,OAAO,CAAC,sBAAsB,EAAE;QACnC,MAAM,EAAEI,YAAY,EAAE,GAAGC,IAAAA,yDAAqC,EAC5DJ,QAAQK,SAAS,EACjBL,QAAQM,YAAY,EACpBN,QAAQO,IAAI,EACZP,QAAQQ,WAAW,EACnB,iEAAiE;QACjE,0DAA0D;QAC1DR,QAAQS,UAAU,KAAK,UAAU,UAAUT,QAAQS,UAAU,EAC7DT,QAAQU,iBAAiB;QAE3B,sDAAsD;QACtD,qGAAqG;QACrG,MAAMC,kBAAkBC,IAAAA,qCAAiB,EACvCX,UACAD,QAAQO,IAAI,EACZT,aACAK;QAEFU,QAAQC,GAAG,CAACC,gBAAgB,GAAGJ;IACjC;AACF;AAEO,SAAS5B;IACd,OAAOiC,SAAS;AAClB;AAEO,SAAShC;IACd,OAAOgC,SAAS;AAGlB"}
+{"version":3,"sources":["../../../../../packages/vite/src/utils/executor-utils.ts"],"sourcesContent":["import { printDiagnostics, runTypeCheck } from '@nx/js';\nimport { join, resolve } from 'path';\nimport { ViteBuildExecutorOptions } from '../executors/build/schema';\nimport { ExecutorContext } from '@nx/devkit';\nimport { ViteDevServerExecutorOptions } from '../executors/dev-server/schema';\nimport {\n  calculateProjectBuildableDependencies,\n  createTmpTsConfig,\n} from '@nx/js/src/utils/buildable-libs-utils';\n\nexport async function validateTypes(opts: {\n  workspaceRoot: string;\n  projectRoot: string;\n  tsconfig: string;\n}): Promise<void> {\n  const result = await runTypeCheck({\n    workspaceRoot: opts.workspaceRoot,\n    tsConfigPath: join(opts.workspaceRoot, opts.tsconfig),\n    mode: 'noEmit',\n  });\n\n  await printDiagnostics(result.errors, result.warnings);\n\n  if (result.errors.length > 0) {\n    throw new Error('Found type errors. See above.');\n  }\n}\n\nexport function createBuildableTsConfig(\n  projectRoot: string,\n  options: ViteBuildExecutorOptions | ViteDevServerExecutorOptions,\n  context: ExecutorContext\n) {\n  const tsConfig = resolve(projectRoot, 'tsconfig.json');\n  options.buildLibsFromSource ??= true;\n\n  if (!options.buildLibsFromSource) {\n    const { dependencies } = calculateProjectBuildableDependencies(\n      context.taskGraph,\n      context.projectGraph,\n      context.root,\n      context.projectName,\n      // When using incremental building and the serve target is called\n      // we need to get the deps for the 'build' target instead.\n      context.targetName === 'serve' ? 'build' : context.targetName,\n      context.configurationName\n    );\n    // this tsconfig is used via the vite ts paths plugin\n    createTmpTsConfig(tsConfig, context.root, projectRoot, dependencies);\n  }\n}\n"],"names":["validateTypes","createBuildableTsConfig","opts","result","runTypeCheck","workspaceRoot","tsConfigPath","join","tsconfig","mode","printDiagnostics","errors","warnings","length","Error","projectRoot","options","context","tsConfig","resolve","buildLibsFromSource","dependencies","calculateProjectBuildableDependencies","taskGraph","projectGraph","root","projectName","targetName","configurationName","createTmpTsConfig"],"mappings":";;;;;;;;IAUsBA,aAAa;eAAbA;;IAkBNC,uBAAuB;eAAvBA;;;oBA5B+B;sBACjB;oCAOvB;AAEA,eAAeD,cAAcE,IAInC;IACC,MAAMC,SAAS,MAAMC,IAAAA,gBAAY,EAAC;QAChCC,eAAeH,KAAKG,aAAa;QACjCC,cAAcC,IAAAA,UAAI,EAACL,KAAKG,aAAa,EAAEH,KAAKM,QAAQ;QACpDC,MAAM;IACR;IAEA,MAAMC,IAAAA,oBAAgB,EAACP,OAAOQ,MAAM,EAAER,OAAOS,QAAQ;IAErD,IAAIT,OAAOQ,MAAM,CAACE,MAAM,GAAG,GAAG;QAC5B,MAAM,IAAIC,MAAM;IAClB;AACF;AAEO,SAASb,wBACdc,WAAmB,EACnBC,OAAgE,EAChEC,OAAwB;QAGxBD;IADA,MAAME,WAAWC,IAAAA,aAAO,EAACJ,aAAa;;IACtCC,yBAAAA,WAAAA,SAAQI,sDAARJ,SAAQI,sBAAwB;IAEhC,IAAI,CAACJ,QAAQI,mBAAmB,EAAE;QAChC,MAAM,EAAEC,YAAY,EAAE,GAAGC,IAAAA,yDAAqC,EAC5DL,QAAQM,SAAS,EACjBN,QAAQO,YAAY,EACpBP,QAAQQ,IAAI,EACZR,QAAQS,WAAW,EACnB,iEAAiE;QACjE,0DAA0D;QAC1DT,QAAQU,UAAU,KAAK,UAAU,UAAUV,QAAQU,UAAU,EAC7DV,QAAQW,iBAAiB;QAE3B,qDAAqD;QACrDC,IAAAA,qCAAiB,EAACX,UAAUD,QAAQQ,IAAI,EAAEV,aAAaM;IACzD;AACF"}

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

@@ -4,26 +4,29 @@ export type Target = 'build' | 'serve' | 'test' | 'preview';
 export type TargetFlags = Partial<Record<Target, boolean>>;
 export type UserProvidedTargetName = Partial<Record<Target, string>>;
 export type ValidFoundTargetName = Partial<Record<Target, string>>;
-export declare function findExistingJsBuildTargetInProject(targets: {
+export declare function findExistingTargetsInProject(targets: {
     [targetName: string]: TargetConfiguration;
-}): {
-    supported?: string;
-    unsupported?: string;
+}, userProvidedTargets?: UserProvidedTargetName): {
+    validFoundTargetName: ValidFoundTargetName;
+    projectContainsUnsupportedExecutor: boolean;
+    userProvidedTargetIsUnsupported: TargetFlags;
+    alreadyHasNxViteTargets: TargetFlags;
 };
 export declare function addOrChangeTestTarget(tree: Tree, options: ViteConfigurationGeneratorSchema, target: string): void;
-export declare function addBuildTarget(tree: Tree, options: ViteConfigurationGeneratorSchema, target: string): void;
-export declare function addServeTarget(tree: Tree, options: ViteConfigurationGeneratorSchema, target: string): void;
+export declare function addOrChangeBuildTarget(tree: Tree, options: ViteConfigurationGeneratorSchema, target: string): void;
+export declare function addOrChangeServeTarget(tree: Tree, options: ViteConfigurationGeneratorSchema, target: string): void;
 /**
  * Adds a target for the preview server.
  *
  * @param tree
  * @param options
  * @param serveTarget An existing serve target.
+ * @param previewTarget  The preview target to create.
  */
 export declare function addPreviewTarget(tree: Tree, options: ViteConfigurationGeneratorSchema, serveTarget: string): 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;
+export declare function moveAndEditIndexHtml(tree: Tree, options: ViteConfigurationGeneratorSchema, buildTarget: string): void;
 export interface ViteConfigFileOptions {
     project: string;
     includeLib?: boolean;
@@ -33,10 +36,9 @@ export interface ViteConfigFileOptions {
     rollupOptionsExternal?: string[];
     imports?: string[];
     plugins?: string[];
-    coverageProvider?: 'v8' | 'istanbul' | 'custom';
 }
-export declare function createOrEditViteConfig(tree: Tree, options: ViteConfigFileOptions, onlyVitest: boolean, projectAlreadyHasViteTargets?: TargetFlags, vitestFileName?: boolean): void;
+export declare function createOrEditViteConfig(tree: Tree, options: ViteConfigFileOptions, onlyVitest: boolean, projectAlreadyHasViteTargets?: TargetFlags): void;
 export declare function normalizeViteConfigFilePathWithTree(tree: Tree, projectRoot: string, configFile?: string): string;
 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>;
+export declare function handleUnknownExecutors(projectName: string): Promise<void>;

package/src/utils/generator-utils.js

@@ -6,17 +6,17 @@ function _export(target, all) {
     });
 }
 _export(exports, {
-    findExistingJsBuildTargetInProject: function() {
-        return findExistingJsBuildTargetInProject;
+    findExistingTargetsInProject: function() {
+        return findExistingTargetsInProject;
     },
     addOrChangeTestTarget: function() {
         return addOrChangeTestTarget;
     },
-    addBuildTarget: function() {
-        return addBuildTarget;
+    addOrChangeBuildTarget: function() {
+        return addOrChangeBuildTarget;
     },
-    addServeTarget: function() {
-        return addServeTarget;
+    addOrChangeServeTarget: function() {
+        return addOrChangeServeTarget;
     },
     addPreviewTarget: function() {
         return addPreviewTarget;
@@ -42,20 +42,42 @@ _export(exports, {
     handleUnsupportedUserProvidedTargets: function() {
         return handleUnsupportedUserProvidedTargets;
     },
-    handleUnknownConfiguration: function() {
-        return handleUnknownConfiguration;
+    handleUnknownExecutors: function() {
+        return handleUnknownExecutors;
     }
 });
+const _extends = require("@swc/helpers/_/_extends");
 const _devkit = require("@nx/devkit");
 const _viteconfigeditutils = require("./vite-config-edit-utils");
-const _addbuildtargetdefaults = require("@nx/devkit/src/generators/add-build-target-defaults");
-function findExistingJsBuildTargetInProject(targets) {
-    const output = {};
+function findExistingTargetsInProject(targets, userProvidedTargets) {
+    const output = {
+        validFoundTargetName: {},
+        projectContainsUnsupportedExecutor: false,
+        userProvidedTargetIsUnsupported: {},
+        alreadyHasNxViteTargets: {}
+    };
     const supportedExecutors = {
         build: [
+            '@nxext/vite:build',
             '@nx/js:babel',
             '@nx/js:swc',
-            '@nx/rollup:rollup'
+            '@nx/webpack:webpack',
+            '@nx/rollup:rollup',
+            '@nrwl/js:babel',
+            '@nrwl/js:swc',
+            '@nrwl/webpack:webpack',
+            '@nrwl/rollup:rollup',
+            '@nrwl/web:rollup'
+        ],
+        serve: [
+            '@nxext/vite:dev',
+            '@nx/webpack:dev-server',
+            '@nrwl/webpack:dev-server'
+        ],
+        test: [
+            '@nx/jest:jest',
+            '@nrwl/jest:jest',
+            '@nxext/vitest:vitest'
         ]
     };
     const unsupportedExecutors = [
@@ -70,6 +92,7 @@ function findExistingJsBuildTargetInProject(targets) {
         '@nx/react-native:build-android',
         '@nx/react-native:bundle',
         '@nx/next:build',
+        '@nx/next:server',
         '@nx/js:tsc',
         '@nrwl/angular:ng-packagr-lite',
         '@nrwl/angular:package',
@@ -82,29 +105,63 @@ function findExistingJsBuildTargetInProject(targets) {
         '@nrwl/react-native:build-android',
         '@nrwl/react-native:bundle',
         '@nrwl/next:build',
+        '@nrwl/next:server',
         '@nrwl/js:tsc',
         '@angular-devkit/build-angular:browser',
-        '@angular-devkit/build-angular:browser-esbuild',
-        '@angular-devkit/build-angular:application'
+        '@angular-devkit/build-angular:dev-server'
     ];
-    // We try to find the target that is using the supported executors
-    // for build since this is the one we will be converting
+    // First, we check if the user has provided a target
+    // If they have, we check if the executor the target is using is supported
+    // If it's not supported, then we set the unsupported flag to true for that target
+    function checkUserProvidedTarget(target) {
+        if (userProvidedTargets == null ? void 0 : userProvidedTargets[target]) {
+            var _targets_userProvidedTargets_target;
+            if (supportedExecutors[target].includes((_targets_userProvidedTargets_target = targets[userProvidedTargets[target]]) == null ? void 0 : _targets_userProvidedTargets_target.executor)) {
+                output.validFoundTargetName[target] = userProvidedTargets[target];
+            } else {
+                output.userProvidedTargetIsUnsupported[target] = true;
+            }
+        }
+    }
+    checkUserProvidedTarget('build');
+    checkUserProvidedTarget('serve');
+    checkUserProvidedTarget('test');
+    // Returns early when we have a build, serve, and test targets.
+    if (output.validFoundTargetName.build && output.validFoundTargetName.serve && output.validFoundTargetName.test) {
+        return output;
+    }
+    // We try to find the targets that are using the supported executors
+    // for build, serve and test, since these are the ones we will be converting
     for(const target in targets){
+        var _hasViteTargets, _hasViteTargets1, _hasViteTargets2, _hasViteTargets3, _output;
         const executorName = targets[target].executor;
-        if (supportedExecutors.build.includes(executorName)) {
-            output.supported = target;
-        } else if (unsupportedExecutors.includes(executorName)) {
-            output.unsupported = target;
+        const hasViteTargets = output.alreadyHasNxViteTargets;
+        (_hasViteTargets = hasViteTargets).build || (_hasViteTargets.build = executorName === '@nx/vite:build' || executorName === '@nrwl/vite:build');
+        (_hasViteTargets1 = hasViteTargets).serve || (_hasViteTargets1.serve = executorName === '@nx/vite:dev-server' || executorName === '@nrwl/vite:dev-server');
+        (_hasViteTargets2 = hasViteTargets).test || (_hasViteTargets2.test = executorName === '@nx/vite:test' || executorName === '@nrwl/vite:test');
+        (_hasViteTargets3 = hasViteTargets).preview || (_hasViteTargets3.preview = executorName === '@nx/vite:preview-server' || executorName === '@nrwl/vite:preview-server');
+        const foundTargets = output.validFoundTargetName;
+        if (!foundTargets.build && supportedExecutors.build.includes(executorName)) {
+            foundTargets.build = target;
+        }
+        if (!foundTargets.serve && supportedExecutors.serve.includes(executorName)) {
+            foundTargets.serve = target;
         }
+        if (!foundTargets.test && supportedExecutors.test.includes(executorName)) {
+            foundTargets.test = target;
+        }
+        (_output = output).projectContainsUnsupportedExecutor || (_output.projectContainsUnsupportedExecutor = unsupportedExecutors.includes(executorName));
     }
     return output;
 }
 function addOrChangeTestTarget(tree, options, target) {
     var _project;
     const project = (0, _devkit.readProjectConfiguration)(tree, options.project);
-    const reportsDirectory = (0, _devkit.joinPathFragments)((0, _devkit.offsetFromRoot)(project.root), 'coverage', project.root === '.' ? options.project : project.root);
+    const coveragePath = (0, _devkit.joinPathFragments)('coverage', project.root === '.' ? options.project : project.root);
     const testOptions = {
-        reportsDirectory
+        passWithNoTests: true,
+        // vitest runs in the project root so we have to offset to the workspaceRoot
+        reportsDirectory: (0, _devkit.joinPathFragments)((0, _devkit.offsetFromRoot)(project.root), coveragePath)
     };
     var _targets;
     (_targets = (_project = project).targets) != null ? _targets : _project.targets = {};
@@ -123,55 +180,82 @@ function addOrChangeTestTarget(tree, options, target) {
     }
     (0, _devkit.updateProjectConfiguration)(tree, options.project, project);
 }
-function addBuildTarget(tree, options, target) {
+function addOrChangeBuildTarget(tree, options, target) {
     var _project;
-    (0, _addbuildtargetdefaults.addBuildTargetDefaults)(tree, '@nx/vite:build');
     const project = (0, _devkit.readProjectConfiguration)(tree, options.project);
     const buildOptions = {
         outputPath: (0, _devkit.joinPathFragments)('dist', project.root != '.' ? project.root : options.project)
     };
     var _targets;
     (_targets = (_project = project).targets) != null ? _targets : _project.targets = {};
-    project.targets[target] = {
-        executor: '@nx/vite:build',
-        outputs: [
-            '{options.outputPath}'
-        ],
-        defaultConfiguration: 'production',
-        options: buildOptions,
-        configurations: {
-            development: {
-                mode: 'development'
-            },
-            production: {
-                mode: 'production'
-            }
+    if (project.targets[target]) {
+        var _project_targets_target_options;
+        buildOptions.fileReplacements = (_project_targets_target_options = project.targets[target].options) == null ? void 0 : _project_targets_target_options.fileReplacements;
+        if (project.targets[target].executor === '@nxext/vite:build') {
+            var _project_targets_target_options1, _project_targets_target_options2;
+            buildOptions.base = (_project_targets_target_options1 = project.targets[target].options) == null ? void 0 : _project_targets_target_options1.baseHref;
+            buildOptions.sourcemap = (_project_targets_target_options2 = project.targets[target].options) == null ? void 0 : _project_targets_target_options2.sourcemaps;
         }
-    };
+        project.targets[target].options = _extends._({}, buildOptions);
+        project.targets[target].executor = '@nx/vite:build';
+    } else {
+        project.targets[target] = {
+            executor: '@nx/vite:build',
+            outputs: [
+                '{options.outputPath}'
+            ],
+            defaultConfiguration: 'production',
+            options: buildOptions,
+            configurations: {
+                development: {
+                    mode: 'development'
+                },
+                production: {
+                    mode: 'production'
+                }
+            }
+        };
+    }
     (0, _devkit.updateProjectConfiguration)(tree, options.project, project);
 }
-function addServeTarget(tree, options, target) {
+function addOrChangeServeTarget(tree, options, target) {
     var _project;
     const project = (0, _devkit.readProjectConfiguration)(tree, options.project);
     var _targets;
     (_targets = (_project = project).targets) != null ? _targets : _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
+    if (project.targets[target]) {
+        var _project_targets_target_options, _project_targets_target_options1, _project_targets_target_options2;
+        const serveTarget = project.targets[target];
+        const serveOptions = {
+            buildTarget: `${options.project}:build`,
+            https: (_project_targets_target_options = project.targets[target].options) == null ? void 0 : _project_targets_target_options.https,
+            hmr: (_project_targets_target_options1 = project.targets[target].options) == null ? void 0 : _project_targets_target_options1.hmr,
+            open: (_project_targets_target_options2 = project.targets[target].options) == null ? void 0 : _project_targets_target_options2.open
+        };
+        if (serveTarget.executor === '@nxext/vite:dev') {
+            serveOptions.proxyConfig = project.targets[target].options.proxyConfig;
+        }
+        serveTarget.executor = '@nx/vite:dev-server';
+        serveTarget.options = serveOptions;
+    } else {
+        project.targets[target] = {
+            executor: '@nx/vite:dev-server',
+            defaultConfiguration: 'development',
+            options: {
+                buildTarget: `${options.project}:build`
             },
-            production: {
-                buildTarget: `${options.project}:build:production`,
-                hmr: false
+            configurations: {
+                development: {
+                    buildTarget: `${options.project}:build:development`,
+                    hmr: true
+                },
+                production: {
+                    buildTarget: `${options.project}:build:production`,
+                    hmr: false
+                }
             }
-        }
-    };
+        };
+    }
     (0, _devkit.updateProjectConfiguration)(tree, options.project, project);
 }
 function addPreviewTarget(tree, options, serveTarget) {
@@ -189,8 +273,8 @@ function addPreviewTarget(tree, options, serveTarget) {
         if (target.executor === '@nxext/vite:dev') {
             previewOptions.proxyConfig = target.options.proxyConfig;
         }
-        previewOptions['https'] = (_target_options = target.options) == null ? void 0 : _target_options.https;
-        previewOptions['open'] = (_target_options1 = target.options) == null ? void 0 : _target_options1.open;
+        previewOptions.https = (_target_options = target.options) == null ? void 0 : _target_options.https;
+        previewOptions.open = (_target_options1 = target.options) == null ? void 0 : _target_options1.open;
     }
     // Adds a preview target.
     project.targets.preview = {
@@ -211,26 +295,56 @@ function addPreviewTarget(tree, options, serveTarget) {
 function editTsConfig(tree, options) {
     const projectConfig = (0, _devkit.readProjectConfiguration)(tree, options.project);
     const config = (0, _devkit.readJson)(tree, `${projectConfig.root}/tsconfig.json`);
+    const commonCompilerOptions = {
+        target: 'ESNext',
+        useDefineForClassFields: true,
+        module: 'ESNext',
+        strict: true,
+        moduleResolution: 'Node',
+        resolveJsonModule: true,
+        isolatedModules: true,
+        types: [
+            'vite/client'
+        ],
+        noEmit: true
+    };
     switch(options.uiFramework){
         case 'react':
-            config.compilerOptions = {
-                jsx: 'react-jsx',
+            config.compilerOptions = _extends._({}, commonCompilerOptions, {
+                lib: [
+                    'DOM',
+                    'DOM.Iterable',
+                    'ESNext'
+                ],
                 allowJs: false,
                 esModuleInterop: false,
+                skipLibCheck: true,
                 allowSyntheticDefaultImports: true,
-                strict: true
-            };
+                forceConsistentCasingInFileNames: true,
+                jsx: 'react-jsx'
+            });
+            config.include = [
+                ...config.include,
+                'src'
+            ];
             break;
         case 'none':
-            config.compilerOptions = {
-                module: 'commonjs',
-                forceConsistentCasingInFileNames: true,
+            config.compilerOptions = _extends._({}, commonCompilerOptions, {
+                lib: [
+                    'ESNext',
+                    'DOM'
+                ],
+                skipLibCheck: true,
+                esModuleInterop: true,
                 strict: true,
-                noImplicitOverride: true,
-                noPropertyAccessFromIndexSignature: true,
-                noImplicitReturns: true,
-                noFallthroughCasesInSwitch: true
-            };
+                noUnusedLocals: true,
+                noUnusedParameters: true,
+                noImplicitReturns: true
+            });
+            config.include = [
+                ...config.include,
+                'src'
+            ];
             break;
         default:
             break;
@@ -243,10 +357,13 @@ function deleteWebpackConfig(tree, projectRoot, webpackConfigFilePath) {
         tree.delete(webpackConfigPath);
     }
 }
-function moveAndEditIndexHtml(tree, options) {
+function moveAndEditIndexHtml(tree, options, buildTarget) {
+    var _projectConfig_targets_buildTarget_options, _projectConfig_targets_buildTarget, _projectConfig_targets, _projectConfig_targets_buildTarget_options1, _projectConfig_targets_buildTarget1, _projectConfig_targets1;
     const projectConfig = (0, _devkit.readProjectConfiguration)(tree, options.project);
-    let indexHtmlPath = `${projectConfig.root}/src/index.html`;
-    let mainPath = `${projectConfig.root}/src/main.ts${options.uiFramework === 'react' ? 'x' : ''}`;
+    var _projectConfig_targets_buildTarget_options_index;
+    let indexHtmlPath = (_projectConfig_targets_buildTarget_options_index = (_projectConfig_targets = projectConfig.targets) == null ? void 0 : (_projectConfig_targets_buildTarget = _projectConfig_targets[buildTarget]) == null ? void 0 : (_projectConfig_targets_buildTarget_options = _projectConfig_targets_buildTarget.options) == null ? void 0 : _projectConfig_targets_buildTarget_options.index) != null ? _projectConfig_targets_buildTarget_options_index : `${projectConfig.root}/src/index.html`;
+    var _projectConfig_targets_buildTarget_options_main;
+    let mainPath = (_projectConfig_targets_buildTarget_options_main = (_projectConfig_targets1 = projectConfig.targets) == null ? void 0 : (_projectConfig_targets_buildTarget1 = _projectConfig_targets1[buildTarget]) == null ? void 0 : (_projectConfig_targets_buildTarget_options1 = _projectConfig_targets_buildTarget1.options) == null ? void 0 : _projectConfig_targets_buildTarget_options1.main) != null ? _projectConfig_targets_buildTarget_options_main : `${projectConfig.root}/src/main.ts${options.uiFramework === 'react' ? 'x' : ''}`;
     if (projectConfig.root !== '.') {
         mainPath = mainPath.replace(projectConfig.root, '');
     }
@@ -278,20 +395,14 @@ function moveAndEditIndexHtml(tree, options) {
       </html>`);
     }
 }
-function createOrEditViteConfig(tree, options, onlyVitest, projectAlreadyHasViteTargets, vitestFileName) {
-    const { root: projectRoot } = (0, _devkit.readProjectConfiguration)(tree, options.project);
-    const viteConfigPath = vitestFileName ? `${projectRoot}/vitest.config.ts` : `${projectRoot}/vite.config.ts`;
-    const buildOutDir = projectRoot === '.' ? `./dist/${options.project}` : `${(0, _devkit.offsetFromRoot)(projectRoot)}dist/${projectRoot}`;
+function createOrEditViteConfig(tree, options, onlyVitest, projectAlreadyHasViteTargets) {
+    const projectConfig = (0, _devkit.readProjectConfiguration)(tree, options.project);
+    const viteConfigPath = `${projectConfig.root}/vite.config.ts`;
     var _options_rollupOptionsExternal;
     const buildOption = onlyVitest ? '' : options.includeLib ? `
       // Configuration for building your library.
       // See: https://vitejs.dev/guide/build.html#library-mode
       build: {
-        outDir: '${buildOutDir}',
-        reportCompressedSize: true,
-        commonjsOptions: {
-          transformMixedEsModules: true,
-        },
         lib: {
           // Could also be a dictionary or array of multiple entry points.
           entry: 'src/index.ts',
@@ -304,16 +415,8 @@ function createOrEditViteConfig(tree, options, onlyVitest, projectAlreadyHasVite
         rollupOptions: {
           // External packages that should not be bundled into your library.
           external: [${(_options_rollupOptionsExternal = options.rollupOptionsExternal) != null ? _options_rollupOptionsExternal : ''}]
-        },
-      },` : `
-    build: {
-      outDir: '${buildOutDir}',
-      reportCompressedSize: true,
-      commonjsOptions: {
-        transformMixedEsModules: true,
-      },
-    },
-    `;
+        }
+      },` : ``;
     const imports = options.imports ? options.imports : [];
     if (!onlyVitest && options.includeLib) {
         imports.push(`import dts from 'vite-plugin-dts'`, `import * as path from 'path'`);
@@ -326,23 +429,17 @@ function createOrEditViteConfig(tree, options, onlyVitest, projectAlreadyHasVite
         `nxViteTsPaths()`
     ];
     if (!onlyVitest && options.includeLib) {
-        plugins.push(`dts({ entryRoot: 'src', tsconfigPath: path.join(__dirname, 'tsconfig.lib.json') })`);
+        plugins.push(`dts({ entryRoot: 'src', tsConfigFilePath: path.join(__dirname, 'tsconfig.lib.json'), skipDiagnostics: true })`);
     }
-    const reportsDirectory = projectRoot === '.' ? `./coverage/${options.project}` : `${(0, _devkit.offsetFromRoot)(projectRoot)}coverage/${projectRoot}`;
     var _options_testEnvironment;
     const testOption = options.includeVitest ? `test: {
     globals: true,
     cache: {
-      dir: '${(0, _devkit.offsetFromRoot)(projectRoot)}node_modules/.vitest'
+      dir: '${(0, _devkit.offsetFromRoot)(projectConfig.root)}node_modules/.vitest'
     },
     environment: '${(_options_testEnvironment = options.testEnvironment) != null ? _options_testEnvironment : 'jsdom'}',
     include: ['src/**/*.{test,spec}.{js,mjs,cjs,ts,mts,cts,jsx,tsx}'],
-    ${options.inSourceTests ? `includeSource: ['src/**/*.{js,mjs,cjs,ts,mts,cts,jsx,tsx}'],` : ''}
-    reporters: ['default'],
-    coverage: {
-      reportsDirectory: '${reportsDirectory}',
-      provider: ${options.coverageProvider ? `'${options.coverageProvider}'` : `'v8'`},
-    }
+    ${options.inSourceTests ? `includeSource: ['src/**/*.{js,mjs,cjs,ts,mts,cts,jsx,tsx}']` : ''}
   },` : '';
     const defineOption = options.inSourceTests ? `define: {
     'import.meta.vitest': undefined
@@ -362,9 +459,9 @@ function createOrEditViteConfig(tree, options, onlyVitest, projectAlreadyHasVite
     // worker: {
     //  plugins: [ nxViteTsPaths() ],
     // },`;
-    const cacheDir = `cacheDir: '${(0, _devkit.offsetFromRoot)(projectRoot)}node_modules/.vite/${projectRoot}',`;
+    const cacheDir = `cacheDir: '${(0, _devkit.offsetFromRoot)(projectConfig.root)}node_modules/.vite/${options.project}',`;
     if (tree.exists(viteConfigPath)) {
-        handleViteConfigFileExists(tree, viteConfigPath, options, buildOption, buildOutDir, imports, plugins, testOption, reportsDirectory, cacheDir, (0, _devkit.offsetFromRoot)(projectRoot), projectAlreadyHasViteTargets);
+        handleViteConfigFileExists(tree, viteConfigPath, options, buildOption, imports, plugins, testOption, cacheDir, (0, _devkit.offsetFromRoot)(projectConfig.root), projectAlreadyHasViteTargets);
         return;
     }
     viteConfigContent = `
@@ -374,7 +471,6 @@ function createOrEditViteConfig(tree, options, onlyVitest, projectAlreadyHasVite
       import { nxViteTsPaths } from '@nx/vite/plugins/nx-tsconfig-paths.plugin';
       
       export default defineConfig({
-        root: __dirname,
         ${cacheDir}
         ${devServerOption}
         ${previewServerOption}
@@ -438,32 +534,33 @@ async function handleUnsupportedUserProvidedTargetsErrors(userProvidedTargetName
       `);
     }
 }
-async function handleUnknownConfiguration(projectName) {
-    if (process.env.NX_INTERACTIVE === 'false') {
-        return;
-    }
+async function handleUnknownExecutors(projectName) {
     _devkit.logger.warn(`
-      We could not find any configuration in project ${projectName} that 
-      indicates whether we can definitely convert to Vite.
+      We could not find any targets in project ${projectName} that use executors which 
+      can be converted to the @nx/vite executors.
+
+      This either means that your project may not have a target 
+      for building, serving, or testing at all, or that your targets are 
+      using executors that are not known to Nx.
       
-      If you still want to convert your project to use Vite,
+      If you still want to convert your project to use the @nx/vite executors,
       please make sure to commit your changes before running this generator.
       `);
     const { Confirm } = require('enquirer');
     const prompt = new Confirm({
         name: 'question',
-        message: `Should Nx convert your project to use Vite?`,
+        message: `Should Nx convert your project to use the @nx/vite executors?`,
         initial: true
     });
     const shouldConvert = await prompt.run();
     if (!shouldConvert) {
         throw new Error(`
-      Nx could not verify that your project can be converted to use Vite.
+      Nx could not verify that the executors you are using can be converted to the @nx/vite executors.
       Please try again with a different project.
     `);
     }
 }
-function handleViteConfigFileExists(tree, viteConfigPath, options, buildOption, buildOutDir, imports, plugins, testOption, reportsDirectory, cacheDir, offsetFromRoot, projectAlreadyHasViteTargets) {
+function handleViteConfigFileExists(tree, viteConfigPath, options, buildOption, imports, plugins, testOption, cacheDir, offsetFromRoot, projectAlreadyHasViteTargets) {
     if ((projectAlreadyHasViteTargets == null ? void 0 : projectAlreadyHasViteTargets.build) && (projectAlreadyHasViteTargets == null ? void 0 : projectAlreadyHasViteTargets.test)) {
         return;
     }
@@ -471,7 +568,7 @@ function handleViteConfigFileExists(tree, viteConfigPath, options, buildOption,
         _devkit.logger.info(`vite.config.ts already exists for project ${options.project}.`);
     }
     var _options_rollupOptionsExternal;
-    const buildOptionObject = options.includeLib ? {
+    const buildOptionObject = {
         lib: {
             entry: 'src/index.ts',
             name: options.project,
@@ -483,20 +580,9 @@ function handleViteConfigFileExists(tree, viteConfigPath, options, buildOption,
         },
         rollupOptions: {
             external: (_options_rollupOptionsExternal = options.rollupOptionsExternal) != null ? _options_rollupOptionsExternal : []
-        },
-        outDir: buildOutDir,
-        reportCompressedSize: true,
-        commonjsOptions: {
-            transformMixedEsModules: true
-        }
-    } : {
-        outDir: buildOutDir,
-        reportCompressedSize: true,
-        commonjsOptions: {
-            transformMixedEsModules: true
         }
     };
-    var _options_testEnvironment, _options_coverageProvider;
+    var _options_testEnvironment;
     const testOptionObject = {
         globals: true,
         cache: {
@@ -505,14 +591,7 @@ function handleViteConfigFileExists(tree, viteConfigPath, options, buildOption,
         environment: (_options_testEnvironment = options.testEnvironment) != null ? _options_testEnvironment : 'jsdom',
         include: [
             'src/**/*.{test,spec}.{js,mjs,cjs,ts,mts,cts,jsx,tsx}'
-        ],
-        reporters: [
-            'default'
-        ],
-        coverage: {
-            reportsDirectory: reportsDirectory,
-            provider: `${(_options_coverageProvider = options.coverageProvider) != null ? _options_coverageProvider : 'v8'}`
-        }
+        ]
     };
     const changed = (0, _viteconfigeditutils.ensureViteConfigIsCorrect)(tree, viteConfigPath, buildOption, buildOptionObject, imports, plugins, testOption, testOptionObject, cacheDir, projectAlreadyHasViteTargets != null ? projectAlreadyHasViteTargets : {});
     if (!changed) {