@nx/vite 21.0.0-beta.1 → 21.0.0-beta.3

package/migrations.json

@@ -34,9 +34,50 @@
       "version": "20.3.0-beta.2",
       "description": "Add gitignore entry for temporary vitest config files.",
       "implementation": "./src/migrations/update-20-3-0/add-vitest-temp-files-to-git-ignore"
+    },
+    "update-20-5-0-install-jiti": {
+      "version": "20.5.0-beta.2",
+      "description": "Install jiti as a devDependency to allow vite to parse TS postcss files.",
+      "implementation": "./src/migrations/update-20-5-0/install-jiti"
+    },
+    "update-20-5-0-update-resolve-conditions": {
+      "version": "20.5.0-beta.3",
+      "description": "Update resolve.conditions to include defaults that are no longer provided by Vite.",
+      "implementation": "./src/migrations/update-20-5-0/update-resolve-conditions"
+    },
+    "eslint-ignore-vite-temp-files": {
+      "version": "20.5.0-beta.3",
+      "description": "Add vite config temporary files to the ESLint configuration ignore patterns if ESLint is used.",
+      "implementation": "./src/migrations/update-20-5-0/eslint-ignore-vite-temp-files"
     }
   },
   "packageJsonUpdates": {
+    "20.7.1": {
+      "version": "20.7.1-beta.0",
+      "packages": {
+        "@analogjs/vite-plugin-angular": {
+          "version": "~1.14.1",
+          "alwaysAddToPackageJson": false
+        },
+        "@analogjs/vitest-angular": {
+          "version": "~1.14.1",
+          "alwaysAddToPackageJson": false
+        }
+      }
+    },
+    "20.5.0": {
+      "version": "20.5.0-beta.3",
+      "packages": {
+        "vite": {
+          "version": "^6.0.0",
+          "alwaysAddToPackageJson": false
+        },
+        "vite-plugin-dts": {
+          "version": "~4.5.0",
+          "alwaysAddToPackageJson": false
+        }
+      }
+    },
     "18.1.0": {
       "version": "18.1.0-beta.1",
       "packages": {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nx/vite",
-  "version": "21.0.0-beta.1",
+  "version": "21.0.0-beta.3",
   "private": false,
   "description": "The Nx Plugin for building and testing applications using Vite",
   "repository": {
@@ -30,17 +30,18 @@
     "migrations": "./migrations.json"
   },
   "dependencies": {
-    "@nx/devkit": "21.0.0-beta.1",
+    "@nx/devkit": "21.0.0-beta.3",
     "@phenomnomnominal/tsquery": "~5.0.1",
     "@swc/helpers": "~0.5.0",
     "enquirer": "~2.3.6",
-    "@nx/js": "21.0.0-beta.1",
+    "@nx/js": "21.0.0-beta.3",
     "tsconfig-paths": "^4.1.2",
-    "minimatch": "9.0.3"
+    "minimatch": "9.0.3",
+    "semver": "^7.6.3"
   },
   "peerDependencies": {
-    "vite": "^5.0.0",
-    "vitest": "^1.3.1 || ^2.0.0"
+    "vite": "^5.0.0 || ^6.0.0",
+    "vitest": "^1.3.1 || ^2.0.0 || ^3.0.0"
   },
   "publishConfig": {
     "access": "public"

package/plugins/nx-copy-assets.plugin.js

@@ -13,6 +13,7 @@ function nxCopyAssetsPlugin(_assets) {
     let config;
     let handler;
     let dispose;
+    if (global.NX_GRAPH_CREATION) return;
     return {
         name: 'nx-copy-assets-plugin',
         configResolved (_config) {
@@ -32,10 +33,10 @@ function nxCopyAssetsPlugin(_assets) {
             handler = new _copyassetshandler.CopyAssetsHandler({
                 rootDir: _devkit.workspaceRoot,
                 projectDir: config.root,
-                outputDir: (0, _nodepath.join)(config.root, config.build.outDir),
+                outputDir: config.build.outDir.startsWith(config.root) ? config.build.outDir : (0, _nodepath.join)(config.root, config.build.outDir),
                 assets
             });
-            if (this.meta.watchMode) {
+            if (this.meta.watchMode && (0, _devkit.isDaemonEnabled)()) {
                 dispose = await handler.watchAndProcessOnAssetChange();
             }
         },

package/plugins/nx-copy-assets.plugin.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../../packages/vite/plugins/nx-copy-assets.plugin.ts"],"sourcesContent":["import { join, relative } from 'node:path';\nimport type { Plugin, ResolvedConfig } from 'vite';\nimport { joinPathFragments, workspaceRoot } from '@nx/devkit';\nimport { AssetGlob } from '@nx/js/src/utils/assets/assets';\nimport { CopyAssetsHandler } from '@nx/js/src/utils/assets/copy-assets-handler';\n\nexport function nxCopyAssetsPlugin(_assets: (string | AssetGlob)[]): Plugin {\n  let config: ResolvedConfig;\n  let handler: CopyAssetsHandler;\n  let dispose: () => void;\n\n  return {\n    name: 'nx-copy-assets-plugin',\n    configResolved(_config) {\n      config = _config;\n    },\n    async buildStart() {\n      const relativeProjectRoot = relative(workspaceRoot, config.root);\n      const assets = _assets.map((a) => {\n        if (typeof a === 'string') {\n          return joinPathFragments(relativeProjectRoot, a);\n        } else {\n          return {\n            ...a,\n            input: joinPathFragments(relativeProjectRoot, a.input),\n          };\n        }\n      });\n      handler = new CopyAssetsHandler({\n        rootDir: workspaceRoot,\n        projectDir: config.root,\n        outputDir: join(config.root, config.build.outDir),\n        assets,\n      });\n      if (this.meta.watchMode) {\n        dispose = await handler.watchAndProcessOnAssetChange();\n      }\n    },\n    async writeBundle() {\n      await handler.processAllAssetsOnce();\n    },\n    async closeWatcher() {\n      dispose == null ? void 0 : dispose();\n    },\n  };\n}\n"],"names":["nxCopyAssetsPlugin","_assets","config","handler","dispose","name","configResolved","_config","buildStart","relativeProjectRoot","relative","workspaceRoot","root","assets","map","a","joinPathFragments","input","CopyAssetsHandler","rootDir","projectDir","outputDir","join","build","outDir","meta","watchMode","watchAndProcessOnAssetChange","writeBundle","processAllAssetsOnce","closeWatcher"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":";+BAMgBA;;;eAAAA;;;;0BANe;wBAEkB;mCAEf;AAE3B,SAASA,mBAAmBC,OAA+B;IAChE,IAAIC;IACJ,IAAIC;IACJ,IAAIC;IAEJ,OAAO;QACLC,MAAM;QACNC,gBAAeC,OAAO;YACpBL,SAASK;QACX;QACA,MAAMC;YACJ,MAAMC,sBAAsBC,IAAAA,kBAAQ,EAACC,qBAAa,EAAET,OAAOU,IAAI;YAC/D,MAAMC,SAASZ,QAAQa,GAAG,CAAC,CAACC;gBAC1B,IAAI,OAAOA,MAAM,UAAU;oBACzB,OAAOC,IAAAA,yBAAiB,EAACP,qBAAqBM;gBAChD,OAAO;oBACL,OAAO,eACFA;wBACHE,OAAOD,IAAAA,yBAAiB,EAACP,qBAAqBM,EAAEE,KAAK;;gBAEzD;YACF;YACAd,UAAU,IAAIe,oCAAiB,CAAC;gBAC9BC,SAASR,qBAAa;gBACtBS,YAAYlB,OAAOU,IAAI;gBACvBS,WAAWC,IAAAA,cAAI,EAACpB,OAAOU,IAAI,EAAEV,OAAOqB,KAAK,CAACC,MAAM;gBAChDX;YACF;YACA,IAAI,IAAI,CAACY,IAAI,CAACC,SAAS,EAAE;gBACvBtB,UAAU,MAAMD,QAAQwB,4BAA4B;YACtD;QACF;QACA,MAAMC;YACJ,MAAMzB,QAAQ0B,oBAAoB;QACpC;QACA,MAAMC;YACJ1B,WAAW,OAAO,KAAK,IAAIA;QAC7B;IACF;AACF"}
+{"version":3,"sources":["../../../../packages/vite/plugins/nx-copy-assets.plugin.ts"],"sourcesContent":["import { join, relative } from 'node:path';\nimport type { Plugin, ResolvedConfig } from 'vite';\nimport { isDaemonEnabled, joinPathFragments, workspaceRoot } from '@nx/devkit';\nimport { AssetGlob } from '@nx/js/src/utils/assets/assets';\nimport { CopyAssetsHandler } from '@nx/js/src/utils/assets/copy-assets-handler';\n\nexport function nxCopyAssetsPlugin(_assets: (string | AssetGlob)[]): Plugin {\n  let config: ResolvedConfig;\n  let handler: CopyAssetsHandler;\n  let dispose: () => void;\n\n  if (global.NX_GRAPH_CREATION) return;\n\n  return {\n    name: 'nx-copy-assets-plugin',\n    configResolved(_config) {\n      config = _config;\n    },\n    async buildStart() {\n      const relativeProjectRoot = relative(workspaceRoot, config.root);\n      const assets = _assets.map((a) => {\n        if (typeof a === 'string') {\n          return joinPathFragments(relativeProjectRoot, a);\n        } else {\n          return {\n            ...a,\n            input: joinPathFragments(relativeProjectRoot, a.input),\n          };\n        }\n      });\n      handler = new CopyAssetsHandler({\n        rootDir: workspaceRoot,\n        projectDir: config.root,\n        outputDir: config.build.outDir.startsWith(config.root)\n          ? config.build.outDir\n          : join(config.root, config.build.outDir),\n        assets,\n      });\n      if (this.meta.watchMode && isDaemonEnabled()) {\n        dispose = await handler.watchAndProcessOnAssetChange();\n      }\n    },\n    async writeBundle() {\n      await handler.processAllAssetsOnce();\n    },\n    async closeWatcher() {\n      dispose == null ? void 0 : dispose();\n    },\n  };\n}\n"],"names":["nxCopyAssetsPlugin","_assets","config","handler","dispose","global","NX_GRAPH_CREATION","name","configResolved","_config","buildStart","relativeProjectRoot","relative","workspaceRoot","root","assets","map","a","joinPathFragments","input","CopyAssetsHandler","rootDir","projectDir","outputDir","build","outDir","startsWith","join","meta","watchMode","isDaemonEnabled","watchAndProcessOnAssetChange","writeBundle","processAllAssetsOnce","closeWatcher"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":";+BAMgBA;;;eAAAA;;;;0BANe;wBAEmC;mCAEhC;AAE3B,SAASA,mBAAmBC,OAA+B;IAChE,IAAIC;IACJ,IAAIC;IACJ,IAAIC;IAEJ,IAAIC,OAAOC,iBAAiB,EAAE;IAE9B,OAAO;QACLC,MAAM;QACNC,gBAAeC,OAAO;YACpBP,SAASO;QACX;QACA,MAAMC;YACJ,MAAMC,sBAAsBC,IAAAA,kBAAQ,EAACC,qBAAa,EAAEX,OAAOY,IAAI;YAC/D,MAAMC,SAASd,QAAQe,GAAG,CAAC,CAACC;gBAC1B,IAAI,OAAOA,MAAM,UAAU;oBACzB,OAAOC,IAAAA,yBAAiB,EAACP,qBAAqBM;gBAChD,OAAO;oBACL,OAAO,eACFA;wBACHE,OAAOD,IAAAA,yBAAiB,EAACP,qBAAqBM,EAAEE,KAAK;;gBAEzD;YACF;YACAhB,UAAU,IAAIiB,oCAAiB,CAAC;gBAC9BC,SAASR,qBAAa;gBACtBS,YAAYpB,OAAOY,IAAI;gBACvBS,WAAWrB,OAAOsB,KAAK,CAACC,MAAM,CAACC,UAAU,CAACxB,OAAOY,IAAI,IACjDZ,OAAOsB,KAAK,CAACC,MAAM,GACnBE,IAAAA,cAAI,EAACzB,OAAOY,IAAI,EAAEZ,OAAOsB,KAAK,CAACC,MAAM;gBACzCV;YACF;YACA,IAAI,IAAI,CAACa,IAAI,CAACC,SAAS,IAAIC,IAAAA,uBAAe,KAAI;gBAC5C1B,UAAU,MAAMD,QAAQ4B,4BAA4B;YACtD;QACF;QACA,MAAMC;YACJ,MAAM7B,QAAQ8B,oBAAoB;QACpC;QACA,MAAMC;YACJ9B,WAAW,OAAO,KAAK,IAAIA;QAC7B;IACF;AACF"}

package/plugins/nx-tsconfig-paths.plugin.d.ts

@@ -2,7 +2,8 @@ import { Plugin } from 'vite';
 export interface nxViteTsPathsOptions {
     /**
      * Enable debug logging
-     * @default false
+     * If set to false, it will always ignore the debug logging even when `--verbose` or `NX_VERBOSE_LOGGING` is set to true.
+     * @default undefined
      **/
     debug?: boolean;
     /**

package/plugins/nx-tsconfig-paths.plugin.js

@@ -15,6 +15,7 @@ const _nxtsconfigpathsfindfile = require("../src/utils/nx-tsconfig-paths-find-fi
 const _tssolutionsetup = require("@nx/js/src/utils/typescript/ts-solution-setup");
 function nxViteTsPaths(options = {}) {
     var _options, _options1, _options2;
+    let foundTsConfigPath;
     let matchTsPathEsm;
     let matchTsPathFallback;
     let tsConfigPathsEsm;
@@ -55,12 +56,9 @@ function nxViteTsPaths(options = {}) {
         async configResolved (config) {
             projectRoot = config.root;
             const projectRootFromWorkspaceRoot = (0, _nodepath.relative)(_devkit.workspaceRoot, projectRoot);
-            var _process_env_NX_TASK_TARGET_TARGET;
-            let foundTsConfigPath = getTsConfig((0, _nodepath.join)(_devkit.workspaceRoot, 'tmp', projectRootFromWorkspaceRoot, (_process_env_NX_TASK_TARGET_TARGET = process.env.NX_TASK_TARGET_TARGET) != null ? _process_env_NX_TASK_TARGET_TARGET : 'build', 'tsconfig.generated.json'));
-            if (!foundTsConfigPath) {
-                throw new Error((0, _devkit.stripIndents)`Unable to find a tsconfig in the workspace! 
-There should at least be a tsconfig.base.json or tsconfig.json in the root of the workspace ${_devkit.workspaceRoot}`);
-            }
+            var _process_env_NX_TASK_TARGET_TARGET, _process_env_NX_TSCONFIG_PATH;
+            foundTsConfigPath = getTsConfig((_process_env_NX_TSCONFIG_PATH = process.env.NX_TSCONFIG_PATH) != null ? _process_env_NX_TSCONFIG_PATH : (0, _nodepath.join)(_devkit.workspaceRoot, 'tmp', projectRootFromWorkspaceRoot, (_process_env_NX_TASK_TARGET_TARGET = process.env.NX_TASK_TARGET_TARGET) != null ? _process_env_NX_TASK_TARGET_TARGET : 'build', 'tsconfig.generated.json'));
+            if (!foundTsConfigPath) return;
             if (!options.buildLibsFromSource && !global.NX_GRAPH_CREATION && config.mode !== 'test') {
                 const projectGraph = await (0, _devkit.createProjectGraphAsync)({
                     exitOnError: false,
@@ -99,6 +97,8 @@ There should at least be a tsconfig.base.json or tsconfig.json in the root of th
             }
         },
         resolveId (importPath) {
+            // Let other resolvers handle this path.
+            if (!foundTsConfigPath) return null;
             let resolvedFile;
             try {
                 resolvedFile = matchTsPathEsm(importPath);
@@ -137,7 +137,8 @@ There should at least be a tsconfig.base.json or tsconfig.json in the root of th
         return [
             (0, _nodepath.resolve)(preferredTsConfigPath),
             (0, _nodepath.resolve)((0, _nodepath.join)(_devkit.workspaceRoot, 'tsconfig.base.json')),
-            (0, _nodepath.resolve)((0, _nodepath.join)(_devkit.workspaceRoot, 'tsconfig.json'))
+            (0, _nodepath.resolve)((0, _nodepath.join)(_devkit.workspaceRoot, 'tsconfig.json')),
+            (0, _nodepath.resolve)((0, _nodepath.join)(_devkit.workspaceRoot, 'jsconfig.json'))
         ].find((tsPath)=>{
             if ((0, _nodefs.existsSync)(tsPath)) {
                 logIt('Found tsconfig at', tsPath);
@@ -146,7 +147,7 @@ There should at least be a tsconfig.base.json or tsconfig.json in the root of th
         });
     }
     function logIt(...msg) {
-        if (process.env.NX_VERBOSE_LOGGING === 'true' || (options == null ? void 0 : options.debug)) {
+        if (process.env.NX_VERBOSE_LOGGING === 'true' && (options == null ? void 0 : options.debug) !== false) {
             console.debug('\n[Nx Vite TsPaths]', ...msg);
         }
     }
@@ -159,6 +160,11 @@ There should at least be a tsconfig.base.json or tsconfig.json in the root of th
             if (importPath === normalizedImport || importPath.startsWith(normalizedImport + '/')) {
                 const joinedPath = (0, _devkit.joinPathFragments)(tsconfig.absoluteBaseUrl, paths[0].replace(/\/\*$/, ''));
                 resolvedFile = (0, _nxtsconfigpathsfindfile.findFile)(importPath.replace(normalizedImport, joinedPath), options.extensions);
+                if (resolvedFile === undefined && options.extensions.some((ext)=>importPath.endsWith(ext))) {
+                    const foundExtension = options.extensions.find((ext)=>importPath.endsWith(ext));
+                    const pathWithoutExtension = importPath.replace(normalizedImport, joinedPath).slice(0, -foundExtension.length);
+                    resolvedFile = (0, _nxtsconfigpathsfindfile.findFile)(pathWithoutExtension, options.extensions);
+                }
             }
         }
         return resolvedFile;

package/plugins/nx-tsconfig-paths.plugin.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../../packages/vite/plugins/nx-tsconfig-paths.plugin.ts"],"sourcesContent":["import {\n  createProjectGraphAsync,\n  joinPathFragments,\n  stripIndents,\n  workspaceRoot,\n} from '@nx/devkit';\nimport { copyFileSync, existsSync } from 'node:fs';\nimport { join, relative, resolve } from 'node:path';\nimport {\n  loadConfig,\n  createMatchPath,\n  MatchPath,\n  ConfigLoaderSuccessResult,\n} from 'tsconfig-paths';\nimport {\n  calculateProjectBuildableDependencies,\n  createTmpTsConfig,\n} from '@nx/js/src/utils/buildable-libs-utils';\nimport { Plugin } from 'vite';\nimport { nxViteBuildCoordinationPlugin } from './nx-vite-build-coordination.plugin';\nimport { findFile } from '../src/utils/nx-tsconfig-paths-find-file';\nimport { isUsingTsSolutionSetup } from '@nx/js/src/utils/typescript/ts-solution-setup';\n\nexport interface nxViteTsPathsOptions {\n  /**\n   * Enable debug logging\n   * @default false\n   **/\n  debug?: boolean;\n  /**\n   * export fields in package.json to use for resolving\n   * @default [['exports', '.', 'import'], 'module', 'main']\n   *\n   * fallback resolution will use ['main', 'module']\n   **/\n  mainFields?: (string | string[])[];\n  /**\n   * extensions to check when resolving files when package.json resolution fails\n   * @default ['.ts', '.tsx', '.js', '.jsx', '.json', '.mjs', '.cjs']\n   **/\n  extensions?: string[];\n  /**\n   * Inform Nx whether to use the raw source or to use the built output for buildable dependencies.\n   * Set to `false` to use incremental builds.\n   * @default true\n   */\n  buildLibsFromSource?: boolean;\n}\n\nexport function nxViteTsPaths(options: nxViteTsPathsOptions = {}) {\n  let matchTsPathEsm: MatchPath;\n  let matchTsPathFallback: MatchPath | undefined;\n  let tsConfigPathsEsm: ConfigLoaderSuccessResult;\n  let tsConfigPathsFallback: ConfigLoaderSuccessResult;\n\n  options.extensions ??= [\n    '.ts',\n    '.tsx',\n    '.js',\n    '.jsx',\n    '.json',\n    '.mts',\n    '.mjs',\n    '.cts',\n    '.cjs',\n    '.css',\n    '.scss',\n    '.less',\n  ];\n  options.mainFields ??= [['exports', '.', 'import'], 'module', 'main'];\n  options.buildLibsFromSource ??= true;\n  let projectRoot = '';\n\n  return {\n    name: 'nx-vite-ts-paths',\n    // Ensure the resolveId aspect of the plugin is called before vite's internal resolver\n    // Otherwise, issues can arise with Yarn Workspaces and Pnpm Workspaces\n    enforce: 'pre',\n    async configResolved(config: any) {\n      projectRoot = config.root;\n      const projectRootFromWorkspaceRoot = relative(workspaceRoot, projectRoot);\n      let foundTsConfigPath = getTsConfig(\n        join(\n          workspaceRoot,\n          'tmp',\n          projectRootFromWorkspaceRoot,\n          process.env.NX_TASK_TARGET_TARGET ?? 'build',\n          'tsconfig.generated.json'\n        )\n      );\n      if (!foundTsConfigPath) {\n        throw new Error(stripIndents`Unable to find a tsconfig in the workspace! \nThere should at least be a tsconfig.base.json or tsconfig.json in the root of the workspace ${workspaceRoot}`);\n      }\n\n      if (\n        !options.buildLibsFromSource &&\n        !global.NX_GRAPH_CREATION &&\n        config.mode !== 'test'\n      ) {\n        const projectGraph = await createProjectGraphAsync({\n          exitOnError: false,\n          resetDaemonClient: true,\n        });\n        const { dependencies } = calculateProjectBuildableDependencies(\n          undefined,\n          projectGraph,\n          workspaceRoot,\n          process.env.NX_TASK_TARGET_PROJECT,\n          // When using incremental building and the serve target is called\n          // we need to get the deps for the 'build' target instead.\n          process.env.NX_TASK_TARGET_TARGET === 'serve'\n            ? 'build'\n            : process.env.NX_TASK_TARGET_TARGET,\n          process.env.NX_TASK_TARGET_CONFIGURATION\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        foundTsConfigPath = createTmpTsConfig(\n          foundTsConfigPath,\n          workspaceRoot,\n          relative(workspaceRoot, projectRoot),\n          dependencies,\n          true\n        );\n\n        if (config.command === 'serve') {\n          const buildableLibraryDependencies = dependencies\n            .filter((dep) => dep.node.type === 'lib')\n            .map((dep) => dep.node.name)\n            .join(',');\n          const buildCommand = `npx nx run-many --target=${process.env.NX_TASK_TARGET_TARGET} --projects=${buildableLibraryDependencies}`;\n          config.plugins.push(nxViteBuildCoordinationPlugin({ buildCommand }));\n        }\n      }\n\n      const parsed = loadConfig(foundTsConfigPath);\n\n      logIt('first parsed tsconfig: ', parsed);\n      if (parsed.resultType === 'failed') {\n        throw new Error(`Failed loading tsconfig at ${foundTsConfigPath}`);\n      }\n      tsConfigPathsEsm = parsed;\n\n      matchTsPathEsm = createMatchPath(\n        parsed.absoluteBaseUrl,\n        parsed.paths,\n        options.mainFields\n      );\n\n      const rootLevelTsConfig = getTsConfig(\n        join(workspaceRoot, 'tsconfig.base.json')\n      );\n      const rootLevelParsed = loadConfig(rootLevelTsConfig);\n      logIt('fallback parsed tsconfig: ', rootLevelParsed);\n      if (rootLevelParsed.resultType === 'success') {\n        tsConfigPathsFallback = rootLevelParsed;\n        matchTsPathFallback = createMatchPath(\n          rootLevelParsed.absoluteBaseUrl,\n          rootLevelParsed.paths,\n          ['main', 'module']\n        );\n      }\n    },\n    resolveId(importPath: string) {\n      let resolvedFile: string;\n      try {\n        resolvedFile = matchTsPathEsm(importPath);\n      } catch (e) {\n        logIt('Using fallback path matching.');\n        resolvedFile = matchTsPathFallback?.(importPath);\n      }\n\n      if (!resolvedFile || !existsSync(resolvedFile)) {\n        if (tsConfigPathsEsm || tsConfigPathsFallback) {\n          logIt(\n            `Unable to resolve ${importPath} with tsconfig paths. Using fallback file matching.`\n          );\n          resolvedFile =\n            loadFileFromPaths(tsConfigPathsEsm, importPath) ||\n            loadFileFromPaths(tsConfigPathsFallback, importPath);\n        } else {\n          logIt(`Unable to resolve ${importPath} with tsconfig paths`);\n        }\n      }\n\n      logIt(`Resolved ${importPath} to ${resolvedFile}`);\n      // Returning null defers to other resolveId functions and eventually the default resolution behavior\n      // https://rollupjs.org/plugin-development/#resolveid\n      return resolvedFile || null;\n    },\n    async writeBundle(options) {\n      if (isUsingTsSolutionSetup()) return;\n      const outDir = options.dir || 'dist';\n      const src = resolve(projectRoot, 'package.json');\n      if (existsSync(src)) {\n        const dest = join(outDir, 'package.json');\n\n        try {\n          copyFileSync(src, dest);\n        } catch (err) {\n          console.error('Error copying package.json:', err);\n        }\n      }\n    },\n  } as Plugin;\n\n  function getTsConfig(preferredTsConfigPath: string): string {\n    return [\n      resolve(preferredTsConfigPath),\n      resolve(join(workspaceRoot, 'tsconfig.base.json')),\n      resolve(join(workspaceRoot, 'tsconfig.json')),\n    ].find((tsPath) => {\n      if (existsSync(tsPath)) {\n        logIt('Found tsconfig at', tsPath);\n        return tsPath;\n      }\n    });\n  }\n\n  function logIt(...msg: any[]) {\n    if (process.env.NX_VERBOSE_LOGGING === 'true' || options?.debug) {\n      console.debug('\\n[Nx Vite TsPaths]', ...msg);\n    }\n  }\n\n  function loadFileFromPaths(\n    tsconfig: ConfigLoaderSuccessResult,\n    importPath: string\n  ) {\n    logIt(\n      `Trying to resolve file from config in ${tsconfig.configFileAbsolutePath}`\n    );\n    let resolvedFile: string;\n    for (const alias in tsconfig.paths) {\n      const paths = tsconfig.paths[alias];\n\n      const normalizedImport = alias.replace(/\\/\\*$/, '');\n\n      if (\n        importPath === normalizedImport ||\n        importPath.startsWith(normalizedImport + '/')\n      ) {\n        const joinedPath = joinPathFragments(\n          tsconfig.absoluteBaseUrl,\n          paths[0].replace(/\\/\\*$/, '')\n        );\n\n        resolvedFile = findFile(\n          importPath.replace(normalizedImport, joinedPath),\n          options.extensions\n        );\n      }\n    }\n\n    return resolvedFile;\n  }\n}\n"],"names":["nxViteTsPaths","options","matchTsPathEsm","matchTsPathFallback","tsConfigPathsEsm","tsConfigPathsFallback","extensions","mainFields","buildLibsFromSource","projectRoot","name","enforce","configResolved","config","root","projectRootFromWorkspaceRoot","relative","workspaceRoot","process","foundTsConfigPath","getTsConfig","join","env","NX_TASK_TARGET_TARGET","Error","stripIndents","global","NX_GRAPH_CREATION","mode","projectGraph","createProjectGraphAsync","exitOnError","resetDaemonClient","dependencies","calculateProjectBuildableDependencies","undefined","NX_TASK_TARGET_PROJECT","NX_TASK_TARGET_CONFIGURATION","createTmpTsConfig","command","buildableLibraryDependencies","filter","dep","node","type","map","buildCommand","plugins","push","nxViteBuildCoordinationPlugin","parsed","loadConfig","logIt","resultType","createMatchPath","absoluteBaseUrl","paths","rootLevelTsConfig","rootLevelParsed","resolveId","importPath","resolvedFile","e","existsSync","loadFileFromPaths","writeBundle","isUsingTsSolutionSetup","outDir","dir","src","resolve","dest","copyFileSync","err","console","error","preferredTsConfigPath","find","tsPath","msg","NX_VERBOSE_LOGGING","debug","tsconfig","configFileAbsolutePath","alias","normalizedImport","replace","startsWith","joinedPath","joinPathFragments","findFile"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"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"}
+{"version":3,"sources":["../../../../packages/vite/plugins/nx-tsconfig-paths.plugin.ts"],"sourcesContent":["import {\n  createProjectGraphAsync,\n  joinPathFragments,\n  stripIndents,\n  workspaceRoot,\n} from '@nx/devkit';\nimport { copyFileSync, existsSync } from 'node:fs';\nimport { join, relative, resolve } from 'node:path';\nimport {\n  loadConfig,\n  createMatchPath,\n  MatchPath,\n  ConfigLoaderSuccessResult,\n} from 'tsconfig-paths';\nimport {\n  calculateProjectBuildableDependencies,\n  createTmpTsConfig,\n} from '@nx/js/src/utils/buildable-libs-utils';\nimport { Plugin } from 'vite';\nimport { nxViteBuildCoordinationPlugin } from './nx-vite-build-coordination.plugin';\nimport { findFile } from '../src/utils/nx-tsconfig-paths-find-file';\nimport { isUsingTsSolutionSetup } from '@nx/js/src/utils/typescript/ts-solution-setup';\n\nexport interface nxViteTsPathsOptions {\n  /**\n   * Enable debug logging\n   * If set to false, it will always ignore the debug logging even when `--verbose` or `NX_VERBOSE_LOGGING` is set to true.\n   * @default undefined\n   **/\n  debug?: boolean;\n  /**\n   * export fields in package.json to use for resolving\n   * @default [['exports', '.', 'import'], 'module', 'main']\n   *\n   * fallback resolution will use ['main', 'module']\n   **/\n  mainFields?: (string | string[])[];\n  /**\n   * extensions to check when resolving files when package.json resolution fails\n   * @default ['.ts', '.tsx', '.js', '.jsx', '.json', '.mjs', '.cjs']\n   **/\n  extensions?: string[];\n  /**\n   * Inform Nx whether to use the raw source or to use the built output for buildable dependencies.\n   * Set to `false` to use incremental builds.\n   * @default true\n   */\n  buildLibsFromSource?: boolean;\n}\n\nexport function nxViteTsPaths(options: nxViteTsPathsOptions = {}) {\n  let foundTsConfigPath: string;\n  let matchTsPathEsm: MatchPath;\n  let matchTsPathFallback: MatchPath | undefined;\n  let tsConfigPathsEsm: ConfigLoaderSuccessResult;\n  let tsConfigPathsFallback: ConfigLoaderSuccessResult;\n\n  options.extensions ??= [\n    '.ts',\n    '.tsx',\n    '.js',\n    '.jsx',\n    '.json',\n    '.mts',\n    '.mjs',\n    '.cts',\n    '.cjs',\n    '.css',\n    '.scss',\n    '.less',\n  ];\n  options.mainFields ??= [['exports', '.', 'import'], 'module', 'main'];\n  options.buildLibsFromSource ??= true;\n  let projectRoot = '';\n\n  return {\n    name: 'nx-vite-ts-paths',\n    // Ensure the resolveId aspect of the plugin is called before vite's internal resolver\n    // Otherwise, issues can arise with Yarn Workspaces and Pnpm Workspaces\n    enforce: 'pre',\n    async configResolved(config: any) {\n      projectRoot = config.root;\n      const projectRootFromWorkspaceRoot = relative(workspaceRoot, projectRoot);\n      foundTsConfigPath = getTsConfig(\n        process.env.NX_TSCONFIG_PATH ??\n          join(\n            workspaceRoot,\n            'tmp',\n            projectRootFromWorkspaceRoot,\n            process.env.NX_TASK_TARGET_TARGET ?? 'build',\n            'tsconfig.generated.json'\n          )\n      );\n\n      if (!foundTsConfigPath) return;\n\n      if (\n        !options.buildLibsFromSource &&\n        !global.NX_GRAPH_CREATION &&\n        config.mode !== 'test'\n      ) {\n        const projectGraph = await createProjectGraphAsync({\n          exitOnError: false,\n          resetDaemonClient: true,\n        });\n        const { dependencies } = calculateProjectBuildableDependencies(\n          undefined,\n          projectGraph,\n          workspaceRoot,\n          process.env.NX_TASK_TARGET_PROJECT,\n          // When using incremental building and the serve target is called\n          // we need to get the deps for the 'build' target instead.\n          process.env.NX_TASK_TARGET_TARGET === 'serve'\n            ? 'build'\n            : process.env.NX_TASK_TARGET_TARGET,\n          process.env.NX_TASK_TARGET_CONFIGURATION\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        foundTsConfigPath = createTmpTsConfig(\n          foundTsConfigPath,\n          workspaceRoot,\n          relative(workspaceRoot, projectRoot),\n          dependencies,\n          true\n        );\n\n        if (config.command === 'serve') {\n          const buildableLibraryDependencies = dependencies\n            .filter((dep) => dep.node.type === 'lib')\n            .map((dep) => dep.node.name)\n            .join(',');\n          const buildCommand = `npx nx run-many --target=${process.env.NX_TASK_TARGET_TARGET} --projects=${buildableLibraryDependencies}`;\n          config.plugins.push(nxViteBuildCoordinationPlugin({ buildCommand }));\n        }\n      }\n\n      const parsed = loadConfig(foundTsConfigPath);\n\n      logIt('first parsed tsconfig: ', parsed);\n      if (parsed.resultType === 'failed') {\n        throw new Error(`Failed loading tsconfig at ${foundTsConfigPath}`);\n      }\n      tsConfigPathsEsm = parsed;\n\n      matchTsPathEsm = createMatchPath(\n        parsed.absoluteBaseUrl,\n        parsed.paths,\n        options.mainFields\n      );\n\n      const rootLevelTsConfig = getTsConfig(\n        join(workspaceRoot, 'tsconfig.base.json')\n      );\n      const rootLevelParsed = loadConfig(rootLevelTsConfig);\n      logIt('fallback parsed tsconfig: ', rootLevelParsed);\n      if (rootLevelParsed.resultType === 'success') {\n        tsConfigPathsFallback = rootLevelParsed;\n        matchTsPathFallback = createMatchPath(\n          rootLevelParsed.absoluteBaseUrl,\n          rootLevelParsed.paths,\n          ['main', 'module']\n        );\n      }\n    },\n    resolveId(importPath: string) {\n      // Let other resolvers handle this path.\n      if (!foundTsConfigPath) return null;\n\n      let resolvedFile: string;\n      try {\n        resolvedFile = matchTsPathEsm(importPath);\n      } catch (e) {\n        logIt('Using fallback path matching.');\n        resolvedFile = matchTsPathFallback?.(importPath);\n      }\n\n      if (!resolvedFile || !existsSync(resolvedFile)) {\n        if (tsConfigPathsEsm || tsConfigPathsFallback) {\n          logIt(\n            `Unable to resolve ${importPath} with tsconfig paths. Using fallback file matching.`\n          );\n          resolvedFile =\n            loadFileFromPaths(tsConfigPathsEsm, importPath) ||\n            loadFileFromPaths(tsConfigPathsFallback, importPath);\n        } else {\n          logIt(`Unable to resolve ${importPath} with tsconfig paths`);\n        }\n      }\n\n      logIt(`Resolved ${importPath} to ${resolvedFile}`);\n      // Returning null defers to other resolveId functions and eventually the default resolution behavior\n      // https://rollupjs.org/plugin-development/#resolveid\n      return resolvedFile || null;\n    },\n    async writeBundle(options) {\n      if (isUsingTsSolutionSetup()) return;\n      const outDir = options.dir || 'dist';\n      const src = resolve(projectRoot, 'package.json');\n      if (existsSync(src)) {\n        const dest = join(outDir, 'package.json');\n\n        try {\n          copyFileSync(src, dest);\n        } catch (err) {\n          console.error('Error copying package.json:', err);\n        }\n      }\n    },\n  } as Plugin;\n\n  function getTsConfig(preferredTsConfigPath: string): string {\n    return [\n      resolve(preferredTsConfigPath),\n      resolve(join(workspaceRoot, 'tsconfig.base.json')),\n      resolve(join(workspaceRoot, 'tsconfig.json')),\n      resolve(join(workspaceRoot, 'jsconfig.json')),\n    ].find((tsPath) => {\n      if (existsSync(tsPath)) {\n        logIt('Found tsconfig at', tsPath);\n        return tsPath;\n      }\n    });\n  }\n\n  function logIt(...msg: any[]) {\n    if (process.env.NX_VERBOSE_LOGGING === 'true' && options?.debug !== false) {\n      console.debug('\\n[Nx Vite TsPaths]', ...msg);\n    }\n  }\n\n  function loadFileFromPaths(\n    tsconfig: ConfigLoaderSuccessResult,\n    importPath: string\n  ) {\n    logIt(\n      `Trying to resolve file from config in ${tsconfig.configFileAbsolutePath}`\n    );\n    let resolvedFile: string;\n    for (const alias in tsconfig.paths) {\n      const paths = tsconfig.paths[alias];\n\n      const normalizedImport = alias.replace(/\\/\\*$/, '');\n\n      if (\n        importPath === normalizedImport ||\n        importPath.startsWith(normalizedImport + '/')\n      ) {\n        const joinedPath = joinPathFragments(\n          tsconfig.absoluteBaseUrl,\n          paths[0].replace(/\\/\\*$/, '')\n        );\n\n        resolvedFile = findFile(\n          importPath.replace(normalizedImport, joinedPath),\n          options.extensions\n        );\n\n        if (\n          resolvedFile === undefined &&\n          options.extensions.some((ext) => importPath.endsWith(ext))\n        ) {\n          const foundExtension = options.extensions.find((ext) =>\n            importPath.endsWith(ext)\n          );\n          const pathWithoutExtension = importPath\n            .replace(normalizedImport, joinedPath)\n            .slice(0, -foundExtension.length);\n          resolvedFile = findFile(pathWithoutExtension, options.extensions);\n        }\n      }\n    }\n\n    return resolvedFile;\n  }\n}\n"],"names":["nxViteTsPaths","options","foundTsConfigPath","matchTsPathEsm","matchTsPathFallback","tsConfigPathsEsm","tsConfigPathsFallback","extensions","mainFields","buildLibsFromSource","projectRoot","name","enforce","configResolved","config","root","projectRootFromWorkspaceRoot","relative","workspaceRoot","process","getTsConfig","env","NX_TSCONFIG_PATH","join","NX_TASK_TARGET_TARGET","global","NX_GRAPH_CREATION","mode","projectGraph","createProjectGraphAsync","exitOnError","resetDaemonClient","dependencies","calculateProjectBuildableDependencies","undefined","NX_TASK_TARGET_PROJECT","NX_TASK_TARGET_CONFIGURATION","createTmpTsConfig","command","buildableLibraryDependencies","filter","dep","node","type","map","buildCommand","plugins","push","nxViteBuildCoordinationPlugin","parsed","loadConfig","logIt","resultType","Error","createMatchPath","absoluteBaseUrl","paths","rootLevelTsConfig","rootLevelParsed","resolveId","importPath","resolvedFile","e","existsSync","loadFileFromPaths","writeBundle","isUsingTsSolutionSetup","outDir","dir","src","resolve","dest","copyFileSync","err","console","error","preferredTsConfigPath","find","tsPath","msg","NX_VERBOSE_LOGGING","debug","tsconfig","configFileAbsolutePath","alias","normalizedImport","replace","startsWith","joinedPath","joinPathFragments","findFile","some","ext","endsWith","foundExtension","pathWithoutExtension","slice","length"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"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"}

package/src/executors/build/build.impl.d.ts

@@ -2,10 +2,8 @@ import { ExecutorContext } from '@nx/devkit';
 import { ViteBuildExecutorOptions } from './schema';
 export declare function viteBuildExecutor(options: Record<string, any> & ViteBuildExecutorOptions, context: ExecutorContext): AsyncGenerator<{
     success: boolean;
-} | {
-    success: boolean;
-    outfile: string;
-}, void, any>;
+    outfile?: string;
+}, any, any>;
 export declare function getBuildExtraArgs(options: ViteBuildExecutorOptions): Promise<{
     buildOptions: Record<string, unknown>;
     otherOptions: Record<string, any>;

package/src/executors/build/build.impl.js

@@ -29,11 +29,11 @@ async function* viteBuildExecutor(options, context) {
     var _resolved_build;
     process.env.VITE_CJS_IGNORE_WARNING = 'true';
     // Allows ESM to be required in CJS modules. Vite will be published as ESM in the future.
-    const { mergeConfig, build, resolveConfig } = await (0, _executorutils.loadViteDynamicImport)();
+    const { mergeConfig, build, resolveConfig, createBuilder } = await (0, _executorutils.loadViteDynamicImport)();
     const projectRoot = context.projectsConfigurations.projects[context.projectName].root;
     const tsConfigForBuild = (0, _executorutils.createBuildableTsConfig)(projectRoot, options, context);
     const viteConfigPath = (0, _optionsutils.normalizeViteConfigFilePath)(context.root, projectRoot, options.configFile);
-    const root = projectRoot === '.' ? process.cwd() : (0, _path.relative)(context.cwd, (0, _devkit.joinPathFragments)(context.root, projectRoot));
+    const root = projectRoot === '.' || projectRoot === '' ? process.cwd() : (0, _path.relative)(context.cwd, (0, _devkit.joinPathFragments)(context.root, projectRoot));
     const { buildOptions, otherOptions } = await getBuildExtraArgs(options);
     var _otherOptions_mode;
     const defaultMode = (_otherOptions_mode = otherOptions == null ? void 0 : otherOptions.mode) != null ? _otherOptions_mode : 'production';
@@ -64,78 +64,94 @@ async function* viteBuildExecutor(options, context) {
             isVueProject: Boolean((_resolved_plugins = resolved.plugins) == null ? void 0 : _resolved_plugins.find((plugin)=>typeof plugin === 'object' && (plugin == null ? void 0 : plugin.name) === 'vite:vue'))
         });
     }
-    const watcherOrOutput = await build(buildConfig);
-    const libraryPackageJson = (0, _path.resolve)(projectRoot, 'package.json');
-    const rootPackageJson = (0, _path.resolve)(context.root, 'package.json');
-    // Here, we want the outdir relative to the workspace root.
-    // So, we calculate the relative path from the workspace root to the outdir.
-    const outDirRelativeToWorkspaceRoot = outDir.replaceAll('../', '');
-    const distPackageJson = (0, _path.resolve)(outDirRelativeToWorkspaceRoot, 'package.json');
-    // Generate a package.json if option has been set.
-    if (options.generatePackageJson) {
-        var _builtPackageJson;
-        if (context.projectGraph.nodes[context.projectName].type !== 'app') {
-            _devkit.logger.warn((0, _devkit.stripIndents)`The project ${context.projectName} is using the 'generatePackageJson' option which is deprecated for library projects. It should only be used for applications.
-        For libraries, configure the project to use the '@nx/dependency-checks' ESLint rule instead (https://nx.dev/nx-api/eslint-plugin/documents/dependency-checks).`);
+    const builder = createBuilder !== undefined && options.useEnvironmentsApi ? await createBuilder(buildConfig) : {
+        build: (inlineConfig)=>build(inlineConfig),
+        environments: {
+            build: buildConfig
         }
-        const builtPackageJson = (0, _js.createPackageJson)(context.projectName, context.projectGraph, {
-            target: context.targetName,
-            root: context.root,
-            isProduction: !options.includeDevDependenciesInPackageJson,
-            skipOverrides: options.skipOverrides,
-            skipPackageManager: options.skipPackageManager
-        });
-        var _type;
-        (_type = (_builtPackageJson = builtPackageJson).type) != null ? _type : _builtPackageJson.type = 'module';
-        (0, _devkit.writeJsonFile)(`${outDirRelativeToWorkspaceRoot}/package.json`, builtPackageJson);
-        const packageManager = (0, _devkit.detectPackageManager)(context.root);
-        const lockFile = (0, _js.createLockFile)(builtPackageJson, context.projectGraph, packageManager);
-        (0, _fs.writeFileSync)(`${outDirRelativeToWorkspaceRoot}/${(0, _js.getLockFileName)(packageManager)}`, lockFile, {
-            encoding: 'utf-8'
-        });
-    } else if (options.generatePackageJson !== false && !(0, _fs.existsSync)(distPackageJson) && (0, _fs.existsSync)(libraryPackageJson) && rootPackageJson !== libraryPackageJson) {
-        await (0, _js.copyAssets)({
-            outputPath: outDirRelativeToWorkspaceRoot,
-            assets: [
-                {
-                    input: projectRoot,
-                    output: '.',
-                    glob: 'package.json'
-                }
-            ]
-        }, context);
-    }
-    if ('on' in watcherOrOutput) {
-        const iterable = (0, _asynciterable.createAsyncIterable)(({ next })=>{
-            let success = true;
-            watcherOrOutput.on('event', (event)=>{
-                if (event.code === 'START') {
-                    success = true;
-                } else if (event.code === 'ERROR') {
-                    success = false;
-                } else if (event.code === 'END') {
-                    next({
-                        success
-                    });
-                }
-                // result must be closed when present.
-                // see https://rollupjs.org/guide/en/#rollupwatch
-                if ('result' in event && event.result) {
-                    event.result.close();
-                }
+    };
+    let iterables = [];
+    for (const env of Object.values(builder.environments)){
+        var _env_config;
+        // This is needed to overwrite the resolve build config with executor options in Vite 6
+        if ((_env_config = env.config) == null ? void 0 : _env_config.build) {
+            env.config.build = _extends._({}, env.config.build, buildConfig.build);
+        }
+        const watcherOrOutput = await builder.build(env);
+        const libraryPackageJson = (0, _path.resolve)(projectRoot, 'package.json');
+        const rootPackageJson = (0, _path.resolve)(context.root, 'package.json');
+        // Here, we want the outdir relative to the workspace root.
+        // So, we calculate the relative path from the workspace root to the outdir.
+        const outDirRelativeToWorkspaceRoot = outDir.replaceAll('../', '');
+        const distPackageJson = (0, _path.resolve)(outDirRelativeToWorkspaceRoot, 'package.json');
+        // Generate a package.json if option has been set.
+        if (options.generatePackageJson) {
+            var _builtPackageJson;
+            if (context.projectGraph.nodes[context.projectName].type !== 'app') {
+                _devkit.logger.warn((0, _devkit.stripIndents)`The project ${context.projectName} is using the 'generatePackageJson' option which is deprecated for library projects. It should only be used for applications.
+        For libraries, configure the project to use the '@nx/dependency-checks' ESLint rule instead (https://nx.dev/nx-api/eslint-plugin/documents/dependency-checks).`);
+            }
+            const builtPackageJson = (0, _js.createPackageJson)(context.projectName, context.projectGraph, {
+                target: context.targetName,
+                root: context.root,
+                isProduction: !options.includeDevDependenciesInPackageJson,
+                skipOverrides: options.skipOverrides,
+                skipPackageManager: options.skipPackageManager
             });
+            var _type;
+            (_type = (_builtPackageJson = builtPackageJson).type) != null ? _type : _builtPackageJson.type = 'module';
+            (0, _devkit.writeJsonFile)(`${outDirRelativeToWorkspaceRoot}/package.json`, builtPackageJson);
+            const packageManager = (0, _devkit.detectPackageManager)(context.root);
+            const lockFile = (0, _js.createLockFile)(builtPackageJson, context.projectGraph, packageManager);
+            (0, _fs.writeFileSync)(`${outDirRelativeToWorkspaceRoot}/${(0, _js.getLockFileName)(packageManager)}`, lockFile, {
+                encoding: 'utf-8'
+            });
+        } else if (options.generatePackageJson !== false && !(0, _fs.existsSync)(distPackageJson) && (0, _fs.existsSync)(libraryPackageJson) && rootPackageJson !== libraryPackageJson) {
+            await (0, _js.copyAssets)({
+                outputPath: outDirRelativeToWorkspaceRoot,
+                assets: [
+                    {
+                        input: projectRoot,
+                        output: '.',
+                        glob: 'package.json'
+                    }
+                ]
+            }, context);
+        }
+        const iterable = (0, _asynciterable.createAsyncIterable)(({ next, done })=>{
+            if ('on' in watcherOrOutput) {
+                let success = true;
+                watcherOrOutput.on('event', (event)=>{
+                    if (event.code === 'START') {
+                        success = true;
+                    } else if (event.code === 'ERROR') {
+                        success = false;
+                    } else if (event.code === 'END') {
+                        next({
+                            success
+                        });
+                    }
+                    // result must be closed when present.
+                    // see https://rollupjs.org/guide/en/#rollupwatch
+                    if ('result' in event && event.result) {
+                        event.result.close();
+                    }
+                });
+            } else {
+                var _watcherOrOutput_, _output_;
+                const output = (watcherOrOutput == null ? void 0 : watcherOrOutput['output']) || (watcherOrOutput == null ? void 0 : (_watcherOrOutput_ = watcherOrOutput[0]) == null ? void 0 : _watcherOrOutput_.output);
+                const fileName = (output == null ? void 0 : (_output_ = output[0]) == null ? void 0 : _output_.fileName) || 'main.cjs';
+                const outfile = (0, _path.resolve)(outDirRelativeToWorkspaceRoot, fileName);
+                next({
+                    success: true,
+                    outfile
+                });
+                done();
+            }
         });
-        yield* iterable;
-    } else {
-        var _watcherOrOutput_, _output_;
-        const output = (watcherOrOutput == null ? void 0 : watcherOrOutput['output']) || (watcherOrOutput == null ? void 0 : (_watcherOrOutput_ = watcherOrOutput[0]) == null ? void 0 : _watcherOrOutput_.output);
-        const fileName = (output == null ? void 0 : (_output_ = output[0]) == null ? void 0 : _output_.fileName) || 'main.cjs';
-        const outfile = (0, _path.resolve)(outDirRelativeToWorkspaceRoot, fileName);
-        yield {
-            success: true,
-            outfile
-        };
+        iterables.push(iterable);
     }
+    return yield* (0, _asynciterable.combineAsyncIterables)(iterables.shift(), ...iterables != null ? iterables : []);
 }
 async function getBuildExtraArgs(options) {
     // support passing extra args to vite cli

package/src/executors/build/build.impl.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../../../../packages/vite/src/executors/build/build.impl.ts"],"sourcesContent":["import {\n  detectPackageManager,\n  ExecutorContext,\n  joinPathFragments,\n  logger,\n  offsetFromRoot,\n  stripIndents,\n  writeJsonFile,\n} from '@nx/devkit';\nimport {\n  getProjectTsConfigPath,\n  normalizeViteConfigFilePath,\n} from '../../utils/options-utils';\nimport { ViteBuildExecutorOptions } from './schema';\nimport {\n  copyAssets,\n  createLockFile,\n  createPackageJson,\n  getLockFileName,\n} from '@nx/js';\nimport { existsSync, writeFileSync } from 'fs';\nimport { relative, resolve } from 'path';\nimport { createAsyncIterable } from '@nx/devkit/src/utils/async-iterable';\nimport {\n  createBuildableTsConfig,\n  loadViteDynamicImport,\n  validateTypes,\n} from '../../utils/executor-utils';\nimport { type Plugin } from 'vite';\nimport { isUsingTsSolutionSetup } from '@nx/js/src/utils/typescript/ts-solution-setup';\n\nexport async function* viteBuildExecutor(\n  options: Record<string, any> & ViteBuildExecutorOptions,\n  context: ExecutorContext\n) {\n  process.env.VITE_CJS_IGNORE_WARNING = 'true';\n  // Allows ESM to be required in CJS modules. Vite will be published as ESM in the future.\n  const { mergeConfig, build, resolveConfig } = await loadViteDynamicImport();\n  const projectRoot =\n    context.projectsConfigurations.projects[context.projectName].root;\n  const tsConfigForBuild = createBuildableTsConfig(\n    projectRoot,\n    options,\n    context\n  );\n\n  const viteConfigPath = normalizeViteConfigFilePath(\n    context.root,\n    projectRoot,\n    options.configFile\n  );\n  const root =\n    projectRoot === '.'\n      ? process.cwd()\n      : relative(context.cwd, joinPathFragments(context.root, projectRoot));\n\n  const { buildOptions, otherOptions } = await getBuildExtraArgs(options);\n  const defaultMode = otherOptions?.mode ?? 'production';\n\n  const resolved = await resolveConfig(\n    {\n      configFile: viteConfigPath,\n      mode: defaultMode,\n    },\n    'build',\n    defaultMode,\n    process.env.NODE_ENV ?? defaultMode\n  );\n\n  const outDir =\n    joinPathFragments(offsetFromRoot(projectRoot), options.outputPath) ??\n    resolved?.build?.outDir;\n\n  const buildConfig = mergeConfig(\n    {\n      // This should not be needed as it's going to be set in vite.config.ts\n      // but leaving it here in case someone did not migrate correctly\n      root: resolved.root ?? root,\n      configFile: viteConfigPath,\n    },\n    {\n      build: {\n        outDir,\n        ...buildOptions,\n      },\n      ...otherOptions,\n    }\n  );\n  // New TS Solution already has a typecheck target\n  if (!options.skipTypeCheck && !isUsingTsSolutionSetup()) {\n    await validateTypes({\n      workspaceRoot: context.root,\n      tsconfig: tsConfigForBuild,\n      isVueProject: Boolean(\n        resolved.plugins?.find(\n          (plugin: Plugin) =>\n            typeof plugin === 'object' && plugin?.name === 'vite:vue'\n        )\n      ),\n    });\n  }\n\n  const watcherOrOutput = await build(buildConfig);\n\n  const libraryPackageJson = resolve(projectRoot, 'package.json');\n  const rootPackageJson = resolve(context.root, 'package.json');\n\n  // Here, we want the outdir relative to the workspace root.\n  // So, we calculate the relative path from the workspace root to the outdir.\n  const outDirRelativeToWorkspaceRoot = outDir.replaceAll('../', '');\n  const distPackageJson = resolve(\n    outDirRelativeToWorkspaceRoot,\n    'package.json'\n  );\n\n  // Generate a package.json if option has been set.\n  if (options.generatePackageJson) {\n    if (context.projectGraph.nodes[context.projectName].type !== 'app') {\n      logger.warn(\n        stripIndents`The project ${context.projectName} is using the 'generatePackageJson' option which is deprecated for library projects. It should only be used for applications.\n        For libraries, configure the project to use the '@nx/dependency-checks' ESLint rule instead (https://nx.dev/nx-api/eslint-plugin/documents/dependency-checks).`\n      );\n    }\n\n    const builtPackageJson = createPackageJson(\n      context.projectName,\n      context.projectGraph,\n      {\n        target: context.targetName,\n        root: context.root,\n        isProduction: !options.includeDevDependenciesInPackageJson, // By default we remove devDependencies since this is a production build.\n        skipOverrides: options.skipOverrides,\n        skipPackageManager: options.skipPackageManager,\n      }\n    );\n\n    builtPackageJson.type ??= 'module';\n\n    writeJsonFile(\n      `${outDirRelativeToWorkspaceRoot}/package.json`,\n      builtPackageJson\n    );\n    const packageManager = detectPackageManager(context.root);\n\n    const lockFile = createLockFile(\n      builtPackageJson,\n      context.projectGraph,\n      packageManager\n    );\n    writeFileSync(\n      `${outDirRelativeToWorkspaceRoot}/${getLockFileName(packageManager)}`,\n      lockFile,\n      {\n        encoding: 'utf-8',\n      }\n    );\n  }\n  // For buildable libs, copy package.json if it exists.\n  else if (\n    options.generatePackageJson !== false &&\n    !existsSync(distPackageJson) &&\n    existsSync(libraryPackageJson) &&\n    rootPackageJson !== libraryPackageJson\n  ) {\n    await copyAssets(\n      {\n        outputPath: outDirRelativeToWorkspaceRoot,\n        assets: [\n          {\n            input: projectRoot,\n            output: '.',\n            glob: 'package.json',\n          },\n        ],\n      },\n      context\n    );\n  }\n\n  if ('on' in watcherOrOutput) {\n    const iterable = createAsyncIterable<{ success: boolean }>(({ next }) => {\n      let success = true;\n      watcherOrOutput.on('event', (event) => {\n        if (event.code === 'START') {\n          success = true;\n        } else if (event.code === 'ERROR') {\n          success = false;\n        } else if (event.code === 'END') {\n          next({ success });\n        }\n        // result must be closed when present.\n        // see https://rollupjs.org/guide/en/#rollupwatch\n        if ('result' in event && event.result) {\n          event.result.close();\n        }\n      });\n    });\n    yield* iterable;\n  } else {\n    const output = watcherOrOutput?.['output'] || watcherOrOutput?.[0]?.output;\n    const fileName = output?.[0]?.fileName || 'main.cjs';\n    const outfile = resolve(outDirRelativeToWorkspaceRoot, fileName);\n    yield { success: true, outfile };\n  }\n}\n\nexport async function getBuildExtraArgs(\n  options: ViteBuildExecutorOptions\n): Promise<{\n  // vite BuildOptions\n  buildOptions: Record<string, unknown>;\n  otherOptions: Record<string, any>;\n}> {\n  // support passing extra args to vite cli\n  const schema = await import('./schema.json');\n  const extraArgs = {};\n  for (const key of Object.keys(options)) {\n    if (!schema.properties[key]) {\n      extraArgs[key] = options[key];\n    }\n  }\n\n  const buildOptions = {};\n  const buildSchemaKeys = [\n    'target',\n    'polyfillModulePreload',\n    'modulePreload',\n    'outDir',\n    'assetsDir',\n    'assetsInlineLimit',\n    'cssCodeSplit',\n    'cssTarget',\n    'cssMinify',\n    'sourcemap',\n    'minify',\n    'terserOptions',\n    'rollupOptions',\n    'commonjsOptions',\n    'dynamicImportVarsOptions',\n    'write',\n    'emptyOutDir',\n    'copyPublicDir',\n    'manifest',\n    'lib',\n    'ssr',\n    'ssrManifest',\n    'ssrEmitAssets',\n    'reportCompressedSize',\n    'chunkSizeWarningLimit',\n    'watch',\n  ];\n  const otherOptions = {};\n  for (const key of Object.keys(extraArgs)) {\n    if (buildSchemaKeys.includes(key)) {\n      buildOptions[key] = extraArgs[key];\n    } else {\n      otherOptions[key] = extraArgs[key];\n    }\n  }\n\n  buildOptions['watch'] = options.watch ?? undefined;\n\n  return {\n    buildOptions,\n    otherOptions,\n  };\n}\n\nexport default viteBuildExecutor;\n"],"names":["getBuildExtraArgs","viteBuildExecutor","options","context","resolved","process","env","VITE_CJS_IGNORE_WARNING","mergeConfig","build","resolveConfig","loadViteDynamicImport","projectRoot","projectsConfigurations","projects","projectName","root","tsConfigForBuild","createBuildableTsConfig","viteConfigPath","normalizeViteConfigFilePath","configFile","cwd","relative","joinPathFragments","buildOptions","otherOptions","defaultMode","mode","NODE_ENV","outDir","offsetFromRoot","outputPath","buildConfig","skipTypeCheck","isUsingTsSolutionSetup","validateTypes","workspaceRoot","tsconfig","isVueProject","Boolean","plugins","find","plugin","name","watcherOrOutput","libraryPackageJson","resolve","rootPackageJson","outDirRelativeToWorkspaceRoot","replaceAll","distPackageJson","generatePackageJson","builtPackageJson","projectGraph","nodes","type","logger","warn","stripIndents","createPackageJson","target","targetName","isProduction","includeDevDependenciesInPackageJson","skipOverrides","skipPackageManager","writeJsonFile","packageManager","detectPackageManager","lockFile","createLockFile","writeFileSync","getLockFileName","encoding","existsSync","copyAssets","assets","input","output","glob","iterable","createAsyncIterable","next","success","on","event","code","result","close","fileName","outfile","schema","extraArgs","key","Object","keys","properties","buildSchemaKeys","includes","watch","undefined"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":";;;;;;;;IA4QA,OAAiC;eAAjC;;IA9DsBA,iBAAiB;eAAjBA;;IA/KCC,iBAAiB;eAAjBA;;;;wBAvBhB;8BAIA;oBAOA;oBACmC;sBACR;+BACE;+BAK7B;iCAEgC;AAEhC,gBAAgBA,kBACrBC,OAAuD,EACvDC,OAAwB;QAsCtBC;IApCFC,QAAQC,GAAG,CAACC,uBAAuB,GAAG;IACtC,yFAAyF;IACzF,MAAM,EAAEC,WAAW,EAAEC,KAAK,EAAEC,aAAa,EAAE,GAAG,MAAMC,IAAAA,oCAAqB;IACzE,MAAMC,cACJT,QAAQU,sBAAsB,CAACC,QAAQ,CAACX,QAAQY,WAAW,CAAC,CAACC,IAAI;IACnE,MAAMC,mBAAmBC,IAAAA,sCAAuB,EAC9CN,aACAV,SACAC;IAGF,MAAMgB,iBAAiBC,IAAAA,yCAA2B,EAChDjB,QAAQa,IAAI,EACZJ,aACAV,QAAQmB,UAAU;IAEpB,MAAML,OACJJ,gBAAgB,MACZP,QAAQiB,GAAG,KACXC,IAAAA,cAAQ,EAACpB,QAAQmB,GAAG,EAAEE,IAAAA,yBAAiB,EAACrB,QAAQa,IAAI,EAAEJ;IAE5D,MAAM,EAAEa,YAAY,EAAEC,YAAY,EAAE,GAAG,MAAM1B,kBAAkBE;QAC3CwB;IAApB,MAAMC,cAAcD,CAAAA,qBAAAA,gCAAAA,aAAcE,IAAI,YAAlBF,qBAAsB;QASxCrB;IAPF,MAAMD,WAAW,MAAMM,cACrB;QACEW,YAAYF;QACZS,MAAMD;IACR,GACA,SACAA,aACAtB,CAAAA,wBAAAA,QAAQC,GAAG,CAACuB,QAAQ,YAApBxB,wBAAwBsB;QAIxBH;IADF,MAAMM,SACJN,CAAAA,qBAAAA,IAAAA,yBAAiB,EAACO,IAAAA,sBAAc,EAACnB,cAAcV,QAAQ8B,UAAU,aAAjER,qBACApB,6BAAAA,kBAAAA,SAAUK,KAAK,qBAAfL,gBAAiB0B,MAAM;QAMf1B;IAJV,MAAM6B,cAAczB,YAClB;QACE,sEAAsE;QACtE,gEAAgE;QAChEQ,MAAMZ,CAAAA,iBAAAA,SAASY,IAAI,YAAbZ,iBAAiBY;QACvBK,YAAYF;IACd,GACA;QACEV,OAAO;YACLqB;WACGL;OAEFC;IAGP,iDAAiD;IACjD,IAAI,CAACxB,QAAQgC,aAAa,IAAI,CAACC,IAAAA,uCAAsB,KAAI;YAKnD/B;QAJJ,MAAMgC,IAAAA,4BAAa,EAAC;YAClBC,eAAelC,QAAQa,IAAI;YAC3BsB,UAAUrB;YACVsB,cAAcC,SACZpC,oBAAAA,SAASqC,OAAO,qBAAhBrC,kBAAkBsC,IAAI,CACpB,CAACC,SACC,OAAOA,WAAW,YAAYA,CAAAA,0BAAAA,OAAQC,IAAI,MAAK;QAGvD;IACF;IAEA,MAAMC,kBAAkB,MAAMpC,MAAMwB;IAEpC,MAAMa,qBAAqBC,IAAAA,aAAO,EAACnC,aAAa;IAChD,MAAMoC,kBAAkBD,IAAAA,aAAO,EAAC5C,QAAQa,IAAI,EAAE;IAE9C,2DAA2D;IAC3D,4EAA4E;IAC5E,MAAMiC,gCAAgCnB,OAAOoB,UAAU,CAAC,OAAO;IAC/D,MAAMC,kBAAkBJ,IAAAA,aAAO,EAC7BE,+BACA;IAGF,kDAAkD;IAClD,IAAI/C,QAAQkD,mBAAmB,EAAE;YAoB/BC;QAnBA,IAAIlD,QAAQmD,YAAY,CAACC,KAAK,CAACpD,QAAQY,WAAW,CAAC,CAACyC,IAAI,KAAK,OAAO;YAClEC,cAAM,CAACC,IAAI,CACTC,IAAAA,oBAAY,CAAA,CAAC,YAAY,EAAExD,QAAQY,WAAW,CAAC;sKAC+G,CAAC;QAEnK;QAEA,MAAMsC,mBAAmBO,IAAAA,qBAAiB,EACxCzD,QAAQY,WAAW,EACnBZ,QAAQmD,YAAY,EACpB;YACEO,QAAQ1D,QAAQ2D,UAAU;YAC1B9C,MAAMb,QAAQa,IAAI;YAClB+C,cAAc,CAAC7D,QAAQ8D,mCAAmC;YAC1DC,eAAe/D,QAAQ+D,aAAa;YACpCC,oBAAoBhE,QAAQgE,kBAAkB;QAChD;;QAGFb,UAAAA,oBAAAA,kBAAiBG,wBAAjBH,kBAAiBG,OAAS;QAE1BW,IAAAA,qBAAa,EACX,CAAC,EAAElB,8BAA8B,aAAa,CAAC,EAC/CI;QAEF,MAAMe,iBAAiBC,IAAAA,4BAAoB,EAAClE,QAAQa,IAAI;QAExD,MAAMsD,WAAWC,IAAAA,kBAAc,EAC7BlB,kBACAlD,QAAQmD,YAAY,EACpBc;QAEFI,IAAAA,iBAAa,EACX,CAAC,EAAEvB,8BAA8B,CAAC,EAAEwB,IAAAA,mBAAe,EAACL,gBAAgB,CAAC,EACrEE,UACA;YACEI,UAAU;QACZ;IAEJ,OAEK,IACHxE,QAAQkD,mBAAmB,KAAK,SAChC,CAACuB,IAAAA,cAAU,EAACxB,oBACZwB,IAAAA,cAAU,EAAC7B,uBACXE,oBAAoBF,oBACpB;QACA,MAAM8B,IAAAA,cAAU,EACd;YACE5C,YAAYiB;YACZ4B,QAAQ;gBACN;oBACEC,OAAOlE;oBACPmE,QAAQ;oBACRC,MAAM;gBACR;aACD;QACH,GACA7E;IAEJ;IAEA,IAAI,QAAQ0C,iBAAiB;QAC3B,MAAMoC,WAAWC,IAAAA,kCAAmB,EAAuB,CAAC,EAAEC,IAAI,EAAE;YAClE,IAAIC,UAAU;YACdvC,gBAAgBwC,EAAE,CAAC,SAAS,CAACC;gBAC3B,IAAIA,MAAMC,IAAI,KAAK,SAAS;oBAC1BH,UAAU;gBACZ,OAAO,IAAIE,MAAMC,IAAI,KAAK,SAAS;oBACjCH,UAAU;gBACZ,OAAO,IAAIE,MAAMC,IAAI,KAAK,OAAO;oBAC/BJ,KAAK;wBAAEC;oBAAQ;gBACjB;gBACA,sCAAsC;gBACtC,iDAAiD;gBACjD,IAAI,YAAYE,SAASA,MAAME,MAAM,EAAE;oBACrCF,MAAME,MAAM,CAACC,KAAK;gBACpB;YACF;QACF;QACA,OAAOR;IACT,OAAO;YACyCpC,mBAC7BkC;QADjB,MAAMA,SAASlC,CAAAA,mCAAAA,eAAiB,CAAC,SAAS,MAAIA,oCAAAA,oBAAAA,eAAiB,CAAC,EAAE,qBAApBA,kBAAsBkC,MAAM;QAC1E,MAAMW,WAAWX,CAAAA,2BAAAA,WAAAA,MAAQ,CAAC,EAAE,qBAAXA,SAAaW,QAAQ,KAAI;QAC1C,MAAMC,UAAU5C,IAAAA,aAAO,EAACE,+BAA+ByC;QACvD,MAAM;YAAEN,SAAS;YAAMO;QAAQ;IACjC;AACF;AAEO,eAAe3F,kBACpBE,OAAiC;IAMjC,yCAAyC;IACzC,MAAM0F,SAAS,MAAM,2BAAA,QAAO;IAC5B,MAAMC,YAAY,CAAC;IACnB,KAAK,MAAMC,OAAOC,OAAOC,IAAI,CAAC9F,SAAU;QACtC,IAAI,CAAC0F,OAAOK,UAAU,CAACH,IAAI,EAAE;YAC3BD,SAAS,CAACC,IAAI,GAAG5F,OAAO,CAAC4F,IAAI;QAC/B;IACF;IAEA,MAAMrE,eAAe,CAAC;IACtB,MAAMyE,kBAAkB;QACtB;QACA;QACA;QACA;QACA;QACA;QACA;QACA;QACA;QACA;QACA;QACA;QACA;QACA;QACA;QACA;QACA;QACA;QACA;QACA;QACA;QACA;QACA;QACA;QACA;QACA;KACD;IACD,MAAMxE,eAAe,CAAC;IACtB,KAAK,MAAMoE,OAAOC,OAAOC,IAAI,CAACH,WAAY;QACxC,IAAIK,gBAAgBC,QAAQ,CAACL,MAAM;YACjCrE,YAAY,CAACqE,IAAI,GAAGD,SAAS,CAACC,IAAI;QACpC,OAAO;YACLpE,YAAY,CAACoE,IAAI,GAAGD,SAAS,CAACC,IAAI;QACpC;IACF;QAEwB5F;IAAxBuB,YAAY,CAAC,QAAQ,GAAGvB,CAAAA,iBAAAA,QAAQkG,KAAK,YAAblG,iBAAiBmG;IAEzC,OAAO;QACL5E;QACAC;IACF;AACF;MAEA,WAAezB"}
+{"version":3,"sources":["../../../../../../packages/vite/src/executors/build/build.impl.ts"],"sourcesContent":["import {\n  detectPackageManager,\n  ExecutorContext,\n  joinPathFragments,\n  logger,\n  offsetFromRoot,\n  stripIndents,\n  writeJsonFile,\n} from '@nx/devkit';\nimport {\n  getProjectTsConfigPath,\n  normalizeViteConfigFilePath,\n} from '../../utils/options-utils';\nimport { ViteBuildExecutorOptions } from './schema';\nimport {\n  copyAssets,\n  createLockFile,\n  createPackageJson,\n  getLockFileName,\n} from '@nx/js';\nimport { existsSync, writeFileSync } from 'fs';\nimport { relative, resolve } from 'path';\nimport {\n  combineAsyncIterables,\n  createAsyncIterable,\n} from '@nx/devkit/src/utils/async-iterable';\nimport {\n  createBuildableTsConfig,\n  loadViteDynamicImport,\n  validateTypes,\n} from '../../utils/executor-utils';\nimport { type Plugin } from 'vite';\nimport { isUsingTsSolutionSetup } from '@nx/js/src/utils/typescript/ts-solution-setup';\n\nexport async function* viteBuildExecutor(\n  options: Record<string, any> & ViteBuildExecutorOptions,\n  context: ExecutorContext\n) {\n  process.env.VITE_CJS_IGNORE_WARNING = 'true';\n  // Allows ESM to be required in CJS modules. Vite will be published as ESM in the future.\n  const { mergeConfig, build, resolveConfig, createBuilder } =\n    await loadViteDynamicImport();\n  const projectRoot =\n    context.projectsConfigurations.projects[context.projectName].root;\n  const tsConfigForBuild = createBuildableTsConfig(\n    projectRoot,\n    options,\n    context\n  );\n\n  const viteConfigPath = normalizeViteConfigFilePath(\n    context.root,\n    projectRoot,\n    options.configFile\n  );\n  const root =\n    projectRoot === '.' || projectRoot === ''\n      ? process.cwd()\n      : relative(context.cwd, joinPathFragments(context.root, projectRoot));\n\n  const { buildOptions, otherOptions } = await getBuildExtraArgs(options);\n  const defaultMode = otherOptions?.mode ?? 'production';\n\n  const resolved = await resolveConfig(\n    {\n      configFile: viteConfigPath,\n      mode: defaultMode,\n    },\n    'build',\n    defaultMode,\n    process.env.NODE_ENV ?? defaultMode\n  );\n\n  const outDir =\n    joinPathFragments(offsetFromRoot(projectRoot), options.outputPath) ??\n    resolved?.build?.outDir;\n\n  const buildConfig = mergeConfig(\n    {\n      // This should not be needed as it's going to be set in vite.config.ts\n      // but leaving it here in case someone did not migrate correctly\n      root: resolved.root ?? root,\n      configFile: viteConfigPath,\n    },\n    {\n      build: {\n        outDir,\n        ...buildOptions,\n      },\n      ...otherOptions,\n    }\n  );\n  // New TS Solution already has a typecheck target\n  if (!options.skipTypeCheck && !isUsingTsSolutionSetup()) {\n    await validateTypes({\n      workspaceRoot: context.root,\n      tsconfig: tsConfigForBuild,\n      isVueProject: Boolean(\n        resolved.plugins?.find(\n          (plugin: Plugin) =>\n            typeof plugin === 'object' && plugin?.name === 'vite:vue'\n        )\n      ),\n    });\n  }\n\n  const builder =\n    createBuilder !== undefined && options.useEnvironmentsApi\n      ? await createBuilder(buildConfig)\n      : // This is needed to ensure support for Vite 5\n        {\n          build: (inlineConfig) => build(inlineConfig),\n          environments: { build: buildConfig },\n        };\n\n  let iterables: AsyncIterable<{ success: boolean; outfile?: string }>[] = [];\n  for (const env of Object.values(builder.environments)) {\n    // This is needed to overwrite the resolve build config with executor options in Vite 6\n    if (env.config?.build) {\n      env.config.build = {\n        ...env.config.build,\n        ...buildConfig.build,\n      };\n    }\n    const watcherOrOutput = await builder.build(env as any);\n\n    const libraryPackageJson = resolve(projectRoot, 'package.json');\n    const rootPackageJson = resolve(context.root, 'package.json');\n\n    // Here, we want the outdir relative to the workspace root.\n    // So, we calculate the relative path from the workspace root to the outdir.\n    const outDirRelativeToWorkspaceRoot = outDir.replaceAll('../', '');\n    const distPackageJson = resolve(\n      outDirRelativeToWorkspaceRoot,\n      'package.json'\n    );\n\n    // Generate a package.json if option has been set.\n    if (options.generatePackageJson) {\n      if (context.projectGraph.nodes[context.projectName].type !== 'app') {\n        logger.warn(\n          stripIndents`The project ${context.projectName} is using the 'generatePackageJson' option which is deprecated for library projects. It should only be used for applications.\n        For libraries, configure the project to use the '@nx/dependency-checks' ESLint rule instead (https://nx.dev/nx-api/eslint-plugin/documents/dependency-checks).`\n        );\n      }\n\n      const builtPackageJson = createPackageJson(\n        context.projectName,\n        context.projectGraph,\n        {\n          target: context.targetName,\n          root: context.root,\n          isProduction: !options.includeDevDependenciesInPackageJson, // By default we remove devDependencies since this is a production build.\n          skipOverrides: options.skipOverrides,\n          skipPackageManager: options.skipPackageManager,\n        }\n      );\n\n      builtPackageJson.type ??= 'module';\n\n      writeJsonFile(\n        `${outDirRelativeToWorkspaceRoot}/package.json`,\n        builtPackageJson\n      );\n      const packageManager = detectPackageManager(context.root);\n\n      const lockFile = createLockFile(\n        builtPackageJson,\n        context.projectGraph,\n        packageManager\n      );\n      writeFileSync(\n        `${outDirRelativeToWorkspaceRoot}/${getLockFileName(packageManager)}`,\n        lockFile,\n        {\n          encoding: 'utf-8',\n        }\n      );\n    }\n    // For buildable libs, copy package.json if it exists.\n    else if (\n      options.generatePackageJson !== false &&\n      !existsSync(distPackageJson) &&\n      existsSync(libraryPackageJson) &&\n      rootPackageJson !== libraryPackageJson\n    ) {\n      await copyAssets(\n        {\n          outputPath: outDirRelativeToWorkspaceRoot,\n          assets: [\n            {\n              input: projectRoot,\n              output: '.',\n              glob: 'package.json',\n            },\n          ],\n        },\n        context\n      );\n    }\n\n    const iterable = createAsyncIterable<{\n      success: boolean;\n      outfile?: string;\n    }>(({ next, done }) => {\n      if ('on' in watcherOrOutput) {\n        let success = true;\n        watcherOrOutput.on('event', (event) => {\n          if (event.code === 'START') {\n            success = true;\n          } else if (event.code === 'ERROR') {\n            success = false;\n          } else if (event.code === 'END') {\n            next({ success });\n          }\n          // result must be closed when present.\n          // see https://rollupjs.org/guide/en/#rollupwatch\n          if ('result' in event && event.result) {\n            event.result.close();\n          }\n        });\n      } else {\n        const output =\n          watcherOrOutput?.['output'] || watcherOrOutput?.[0]?.output;\n        const fileName = output?.[0]?.fileName || 'main.cjs';\n        const outfile = resolve(outDirRelativeToWorkspaceRoot, fileName);\n        next({ success: true, outfile });\n        done();\n      }\n    });\n    iterables.push(iterable);\n  }\n  return yield* combineAsyncIterables(iterables.shift(), ...(iterables ?? []));\n}\n\nexport async function getBuildExtraArgs(\n  options: ViteBuildExecutorOptions\n): Promise<{\n  // vite BuildOptions\n  buildOptions: Record<string, unknown>;\n  otherOptions: Record<string, any>;\n}> {\n  // support passing extra args to vite cli\n  const schema = await import('./schema.json');\n  const extraArgs = {};\n  for (const key of Object.keys(options)) {\n    if (!schema.properties[key]) {\n      extraArgs[key] = options[key];\n    }\n  }\n\n  const buildOptions = {};\n  const buildSchemaKeys = [\n    'target',\n    'polyfillModulePreload',\n    'modulePreload',\n    'outDir',\n    'assetsDir',\n    'assetsInlineLimit',\n    'cssCodeSplit',\n    'cssTarget',\n    'cssMinify',\n    'sourcemap',\n    'minify',\n    'terserOptions',\n    'rollupOptions',\n    'commonjsOptions',\n    'dynamicImportVarsOptions',\n    'write',\n    'emptyOutDir',\n    'copyPublicDir',\n    'manifest',\n    'lib',\n    'ssr',\n    'ssrManifest',\n    'ssrEmitAssets',\n    'reportCompressedSize',\n    'chunkSizeWarningLimit',\n    'watch',\n  ];\n  const otherOptions = {};\n  for (const key of Object.keys(extraArgs)) {\n    if (buildSchemaKeys.includes(key)) {\n      buildOptions[key] = extraArgs[key];\n    } else {\n      otherOptions[key] = extraArgs[key];\n    }\n  }\n\n  buildOptions['watch'] = options.watch ?? undefined;\n\n  return {\n    buildOptions,\n    otherOptions,\n  };\n}\n\nexport default viteBuildExecutor;\n"],"names":["getBuildExtraArgs","viteBuildExecutor","options","context","resolved","process","env","VITE_CJS_IGNORE_WARNING","mergeConfig","build","resolveConfig","createBuilder","loadViteDynamicImport","projectRoot","projectsConfigurations","projects","projectName","root","tsConfigForBuild","createBuildableTsConfig","viteConfigPath","normalizeViteConfigFilePath","configFile","cwd","relative","joinPathFragments","buildOptions","otherOptions","defaultMode","mode","NODE_ENV","outDir","offsetFromRoot","outputPath","buildConfig","skipTypeCheck","isUsingTsSolutionSetup","validateTypes","workspaceRoot","tsconfig","isVueProject","Boolean","plugins","find","plugin","name","builder","undefined","useEnvironmentsApi","inlineConfig","environments","iterables","Object","values","config","watcherOrOutput","libraryPackageJson","resolve","rootPackageJson","outDirRelativeToWorkspaceRoot","replaceAll","distPackageJson","generatePackageJson","builtPackageJson","projectGraph","nodes","type","logger","warn","stripIndents","createPackageJson","target","targetName","isProduction","includeDevDependenciesInPackageJson","skipOverrides","skipPackageManager","writeJsonFile","packageManager","detectPackageManager","lockFile","createLockFile","writeFileSync","getLockFileName","encoding","existsSync","copyAssets","assets","input","output","glob","iterable","createAsyncIterable","next","done","success","on","event","code","result","close","fileName","outfile","push","combineAsyncIterables","shift","schema","extraArgs","key","keys","properties","buildSchemaKeys","includes","watch"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"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"}

package/src/executors/build/schema.d.ts

@@ -9,4 +9,5 @@ export interface ViteBuildExecutorOptions {
   skipTypeCheck?: boolean;
   tsConfig?: string;
   watch?: boolean;
+  useEnvironmentsApi?: boolean;
 }

package/src/executors/build/schema.json

@@ -67,6 +67,12 @@
     "skipPackageManager": {
       "type": "boolean",
       "description": "Do not add a `packageManager` entry to the generated package.json file. Only works in conjunction with `generatePackageJson` option."
+    },
+    "useEnvironmentsApi": {
+      "alias": "app",
+      "type": "boolean",
+      "description": "Use the new Environments API for building multiple environments at once. Only works with Vite 6.0.0 or higher.",
+      "default": false
     }
   },
   "definitions": {},

package/src/executors/test/lib/utils.js

@@ -53,16 +53,23 @@ async function getOptions(options, context, projectRoot) {
     ]), { options: { watch } } = _parseCLI, normalizedExtraArgs = _object_without_properties_loose._(_parseCLI.options, [
         "watch"
     ]);
+    const { reportsDirectory, coverage } = normalizedExtraArgs, restNormalizedArgs = _object_without_properties_loose._(normalizedExtraArgs, [
+        "reportsDirectory",
+        "coverage"
+    ]);
     var _resolved_config_root;
     const settings = _extends._({
         // Explicitly set watch mode to false if not provided otherwise vitest
         // will enable watch mode by default for non CI environments
         watch: watch != null ? watch : false
-    }, normalizedExtraArgs, {
+    }, restNormalizedArgs, {
         // This should not be needed as it's going to be set in vite.config.ts
         // but leaving it here in case someone did not migrate correctly
         root: (_resolved_config_root = resolved.config.root) != null ? _resolved_config_root : root,
-        config: viteConfigPath
+        config: viteConfigPath,
+        coverage: _extends._({}, coverage != null ? coverage : {}, reportsDirectory && {
+            reportsDirectory
+        })
     });
     var _resolved_config_test;
     return mergeConfig((_resolved_config_test = resolved == null ? void 0 : (_resolved_config1 = resolved.config) == null ? void 0 : _resolved_config1['test']) != null ? _resolved_config_test : {}, settings);