@nx/vite 18.1.0-beta.0 → 18.1.0-beta.2

package/src/utils/find-vite-config.js

@@ -0,0 +1,46 @@
+"use strict";
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    findViteConfig: function() {
+        return findViteConfig;
+    },
+    findWebpackConfig: function() {
+        return findWebpackConfig;
+    }
+});
+const _devkit = require("@nx/devkit");
+function findViteConfig(tree, searchRoot) {
+    const allowsExt = [
+        'js',
+        'mjs',
+        'ts',
+        'cjs',
+        'mts',
+        'cts'
+    ];
+    for (const ext of allowsExt){
+        if (tree.exists((0, _devkit.joinPathFragments)(searchRoot, `vite.config.${ext}`))) {
+            return (0, _devkit.joinPathFragments)(searchRoot, `vite.config.${ext}`);
+        }
+    }
+}
+function findWebpackConfig(tree, searchRoot) {
+    const allowsExt = [
+        'js',
+        'ts',
+        'mjs',
+        'cjs'
+    ];
+    for (const ext of allowsExt){
+        if (tree.exists((0, _devkit.joinPathFragments)(searchRoot, `webpack.config.${ext}`))) {
+            return (0, _devkit.joinPathFragments)(searchRoot, `webpack.config.${ext}`);
+        }
+    }
+}
+
+//# sourceMappingURL=find-vite-config.js.map

package/src/utils/find-vite-config.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../packages/vite/src/utils/find-vite-config.ts"],"sourcesContent":["import { Tree, joinPathFragments } from '@nx/devkit';\n\nexport function findViteConfig(tree: Tree, searchRoot: string) {\n  const allowsExt = ['js', 'mjs', 'ts', 'cjs', 'mts', 'cts'];\n\n  for (const ext of allowsExt) {\n    if (tree.exists(joinPathFragments(searchRoot, `vite.config.${ext}`))) {\n      return joinPathFragments(searchRoot, `vite.config.${ext}`);\n    }\n  }\n}\n\nexport function findWebpackConfig(tree: Tree, searchRoot: string) {\n  const allowsExt = ['js', 'ts', 'mjs', 'cjs'];\n\n  for (const ext of allowsExt) {\n    if (tree.exists(joinPathFragments(searchRoot, `webpack.config.${ext}`))) {\n      return joinPathFragments(searchRoot, `webpack.config.${ext}`);\n    }\n  }\n}\n"],"names":["findViteConfig","findWebpackConfig","tree","searchRoot","allowsExt","ext","exists","joinPathFragments"],"mappings":";;;;;;;;IAEgBA,cAAc;eAAdA;;IAUAC,iBAAiB;eAAjBA;;;wBAZwB;AAEjC,SAASD,eAAeE,IAAU,EAAEC,UAAkB;IAC3D,MAAMC,YAAY;QAAC;QAAM;QAAO;QAAM;QAAO;QAAO;KAAM;IAE1D,KAAK,MAAMC,OAAOD,UAAW;QAC3B,IAAIF,KAAKI,MAAM,CAACC,IAAAA,yBAAiB,EAACJ,YAAY,CAAC,YAAY,EAAEE,IAAI,CAAC,IAAI;YACpE,OAAOE,IAAAA,yBAAiB,EAACJ,YAAY,CAAC,YAAY,EAAEE,IAAI,CAAC;QAC3D;IACF;AACF;AAEO,SAASJ,kBAAkBC,IAAU,EAAEC,UAAkB;IAC9D,MAAMC,YAAY;QAAC;QAAM;QAAM;QAAO;KAAM;IAE5C,KAAK,MAAMC,OAAOD,UAAW;QAC3B,IAAIF,KAAKI,MAAM,CAACC,IAAAA,yBAAiB,EAACJ,YAAY,CAAC,eAAe,EAAEE,IAAI,CAAC,IAAI;YACvE,OAAOE,IAAAA,yBAAiB,EAACJ,YAAY,CAAC,eAAe,EAAEE,IAAI,CAAC;QAC9D;IACF;AACF"}

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

@@ -4,29 +4,26 @@ 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 findExistingTargetsInProject(targets: {
+export declare function findExistingJsBuildTargetInProject(targets: {
     [targetName: string]: TargetConfiguration;
-}, userProvidedTargets?: UserProvidedTargetName): {
-    validFoundTargetName: ValidFoundTargetName;
-    projectContainsUnsupportedExecutor: boolean;
-    userProvidedTargetIsUnsupported: TargetFlags;
-    alreadyHasNxViteTargets: TargetFlags;
+}): {
+    supported?: string;
+    unsupported?: string;
 };
 export declare function addOrChangeTestTarget(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;
+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.
- * @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, buildTarget: string): void;
+export declare function moveAndEditIndexHtml(tree: Tree, options: ViteConfigurationGeneratorSchema): void;
 export interface ViteConfigFileOptions {
     project: string;
     includeLib?: boolean;
@@ -42,4 +39,4 @@ export declare function createOrEditViteConfig(tree: Tree, options: ViteConfigFi
 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 handleUnknownExecutors(projectName: string): Promise<void>;
+export declare function handleUnknownConfiguration(projectName: string): Promise<void>;

package/src/utils/generator-utils.js

@@ -6,17 +6,17 @@ function _export(target, all) {
     });
 }
 _export(exports, {
-    findExistingTargetsInProject: function() {
-        return findExistingTargetsInProject;
+    findExistingJsBuildTargetInProject: function() {
+        return findExistingJsBuildTargetInProject;
     },
     addOrChangeTestTarget: function() {
         return addOrChangeTestTarget;
     },
-    addOrChangeBuildTarget: function() {
-        return addOrChangeBuildTarget;
+    addBuildTarget: function() {
+        return addBuildTarget;
     },
-    addOrChangeServeTarget: function() {
-        return addOrChangeServeTarget;
+    addServeTarget: function() {
+        return addServeTarget;
     },
     addPreviewTarget: function() {
         return addPreviewTarget;
@@ -42,43 +42,20 @@ _export(exports, {
     handleUnsupportedUserProvidedTargets: function() {
         return handleUnsupportedUserProvidedTargets;
     },
-    handleUnknownExecutors: function() {
-        return handleUnknownExecutors;
+    handleUnknownConfiguration: function() {
+        return handleUnknownConfiguration;
     }
 });
-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 findExistingTargetsInProject(targets, userProvidedTargets) {
-    const output = {
-        validFoundTargetName: {},
-        projectContainsUnsupportedExecutor: false,
-        userProvidedTargetIsUnsupported: {},
-        alreadyHasNxViteTargets: {}
-    };
+function findExistingJsBuildTargetInProject(targets) {
+    const output = {};
     const supportedExecutors = {
         build: [
-            '@nxext/vite:build',
             '@nx/js:babel',
             '@nx/js:swc',
-            '@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'
+            '@nx/rollup:rollup'
         ]
     };
     const unsupportedExecutors = [
@@ -93,7 +70,6 @@ function findExistingTargetsInProject(targets, userProvidedTargets) {
         '@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',
@@ -106,52 +82,20 @@ function findExistingTargetsInProject(targets, userProvidedTargets) {
         '@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:dev-server'
+        '@angular-devkit/build-angular:browser-esbuild',
+        '@angular-devkit/build-angular:application'
     ];
-    // 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
+    // We try to find the target that is using the supported executors
+    // for build since this is the one we will be converting
     for(const target in targets){
-        var _hasViteTargets, _hasViteTargets1, _hasViteTargets2, _hasViteTargets3, _output;
         const executorName = targets[target].executor;
-        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;
+        if (supportedExecutors.build.includes(executorName)) {
+            output.supported = target;
+        } else if (unsupportedExecutors.includes(executorName)) {
+            output.unsupported = target;
         }
-        (_output = output).projectContainsUnsupportedExecutor || (_output.projectContainsUnsupportedExecutor = unsupportedExecutors.includes(executorName));
     }
     return output;
 }
@@ -179,7 +123,7 @@ function addOrChangeTestTarget(tree, options, target) {
     }
     (0, _devkit.updateProjectConfiguration)(tree, options.project, project);
 }
-function addOrChangeBuildTarget(tree, options, target) {
+function addBuildTarget(tree, options, target) {
     var _project;
     (0, _addbuildtargetdefaults.addBuildTargetDefaults)(tree, '@nx/vite:build');
     const project = (0, _devkit.readProjectConfiguration)(tree, options.project);
@@ -188,68 +132,46 @@ function addOrChangeBuildTarget(tree, options, target) {
     };
     var _targets;
     (_targets = (_project = project).targets) != null ? _targets : _project.targets = {};
-    if (project.targets[target]) {
-        if (project.targets[target].executor === '@nxext/vite:build') {
-            var _project_targets_target_options, _project_targets_target_options1;
-            buildOptions['base'] = (_project_targets_target_options = project.targets[target].options) == null ? void 0 : _project_targets_target_options.baseHref;
-            buildOptions['sourcemap'] = (_project_targets_target_options1 = project.targets[target].options) == null ? void 0 : _project_targets_target_options1.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'
-                }
+    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 addOrChangeServeTarget(tree, options, target) {
+function addServeTarget(tree, options, target) {
     var _project;
     const project = (0, _devkit.readProjectConfiguration)(tree, options.project);
     var _targets;
     (_targets = (_project = project).targets) != null ? _targets : _project.targets = {};
-    if (project.targets[target]) {
-        const serveTarget = project.targets[target];
-        const serveOptions = {
+    project.targets[target] = {
+        executor: '@nx/vite:dev-server',
+        defaultConfiguration: 'development',
+        options: {
             buildTarget: `${options.project}:build`
-        };
-        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`
+        },
+        configurations: {
+            development: {
+                buildTarget: `${options.project}:build:development`,
+                hmr: true
             },
-            configurations: {
-                development: {
-                    buildTarget: `${options.project}:build:development`,
-                    hmr: true
-                },
-                production: {
-                    buildTarget: `${options.project}:build:production`,
-                    hmr: false
-                }
+            production: {
+                buildTarget: `${options.project}:build:production`,
+                hmr: false
             }
-        };
-    }
+        }
+    };
     (0, _devkit.updateProjectConfiguration)(tree, options.project, project);
 }
 function addPreviewTarget(tree, options, serveTarget) {
@@ -289,56 +211,26 @@ 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 = _extends._({}, commonCompilerOptions, {
-                lib: [
-                    'DOM',
-                    'DOM.Iterable',
-                    'ESNext'
-                ],
+            config.compilerOptions = {
+                jsx: 'react-jsx',
                 allowJs: false,
                 esModuleInterop: false,
-                skipLibCheck: true,
                 allowSyntheticDefaultImports: true,
-                forceConsistentCasingInFileNames: true,
-                jsx: 'react-jsx'
-            });
-            config.include = [
-                ...config.include,
-                'src'
-            ];
+                strict: true
+            };
             break;
         case 'none':
-            config.compilerOptions = _extends._({}, commonCompilerOptions, {
-                lib: [
-                    'ESNext',
-                    'DOM'
-                ],
-                skipLibCheck: true,
-                esModuleInterop: true,
+            config.compilerOptions = {
+                module: 'commonjs',
+                forceConsistentCasingInFileNames: true,
                 strict: true,
-                noUnusedLocals: true,
-                noUnusedParameters: true,
-                noImplicitReturns: true
-            });
-            config.include = [
-                ...config.include,
-                'src'
-            ];
+                noImplicitOverride: true,
+                noPropertyAccessFromIndexSignature: true,
+                noImplicitReturns: true,
+                noFallthroughCasesInSwitch: true
+            };
             break;
         default:
             break;
@@ -351,13 +243,10 @@ function deleteWebpackConfig(tree, projectRoot, webpackConfigFilePath) {
         tree.delete(webpackConfigPath);
     }
 }
-function moveAndEditIndexHtml(tree, options, buildTarget) {
-    var _projectConfig_targets_buildTarget_options, _projectConfig_targets_buildTarget, _projectConfig_targets, _projectConfig_targets_buildTarget_options1, _projectConfig_targets_buildTarget1, _projectConfig_targets1;
+function moveAndEditIndexHtml(tree, options) {
     const projectConfig = (0, _devkit.readProjectConfiguration)(tree, options.project);
-    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' : ''}`;
+    let indexHtmlPath = `${projectConfig.root}/src/index.html`;
+    let mainPath = `${projectConfig.root}/src/main.ts${options.uiFramework === 'react' ? 'x' : ''}`;
     if (projectConfig.root !== '.') {
         mainPath = mainPath.replace(projectConfig.root, '');
     }
@@ -549,31 +438,27 @@ async function handleUnsupportedUserProvidedTargetsErrors(userProvidedTargetName
       `);
     }
 }
-async function handleUnknownExecutors(projectName) {
+async function handleUnknownConfiguration(projectName) {
     if (process.env.NX_INTERACTIVE === 'false') {
         return;
     }
     _devkit.logger.warn(`
-      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.
+      We could not find any configuration in project ${projectName} that 
+      indicates whether we can definitely convert to Vite.
       
-      If you still want to convert your project to use the @nx/vite executors,
+      If you still want to convert your project to use Vite,
       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 the @nx/vite executors?`,
+        message: `Should Nx convert your project to use Vite?`,
         initial: true
     });
     const shouldConvert = await prompt.run();
     if (!shouldConvert) {
         throw new Error(`
-      Nx could not verify that the executors you are using can be converted to the @nx/vite executors.
+      Nx could not verify that your project can be converted to use Vite.
       Please try again with a different project.
     `);
     }