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

package/generators.json

@@ -21,6 +21,11 @@
       "schema": "./src/generators/setup-paths-plugin/schema.json",
       "description": "Sets up the nxViteTsPaths plugin to enable support for workspace libraries."
     },
+    "convert-to-inferred": {
+      "factory": "./src/generators/convert-to-inferred/convert-to-inferred",
+      "schema": "./src/generators/convert-to-inferred/schema.json",
+      "description": "Convert existing Vite project(s) using `@nx/vite:*` executors to use `@nx/vite/plugin`. Defaults to migrating all projects. Pass '--project' to migrate only one target."
+    },
     "vitest": {
       "factory": "./src/generators/vitest/vitest-generator#vitestGeneratorInternal",
       "schema": "./src/generators/vitest/schema.json",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nx/vite",
-  "version": "19.4.0-beta.0",
+  "version": "19.4.0-beta.2",
   "private": false,
   "description": "The Nx Plugin for building and testing applications using Vite",
   "repository": {
@@ -30,13 +30,13 @@
     "migrations": "./migrations.json"
   },
   "dependencies": {
-    "@nx/devkit": "19.4.0-beta.0",
+    "@nx/devkit": "19.4.0-beta.2",
     "@phenomnomnominal/tsquery": "~5.0.1",
     "@swc/helpers": "~0.5.0",
     "enquirer": "~2.3.6",
-    "@nx/js": "19.4.0-beta.0",
+    "@nx/js": "19.4.0-beta.2",
     "tsconfig-paths": "^4.1.2",
-    "@nrwl/vite": "19.4.0-beta.0"
+    "@nrwl/vite": "19.4.0-beta.2"
   },
   "peerDependencies": {
     "vite": "^5.0.0",

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

@@ -51,7 +51,7 @@ function nxViteTsPaths(options = {}) {
                 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}`);
             }
-            if (!options.buildLibsFromSource && !global.NX_GRAPH_CREATION) {
+            if (!options.buildLibsFromSource && !global.NX_GRAPH_CREATION && config.mode !== 'test') {
                 const projectGraph = await (0, _devkit.createProjectGraphAsync)({
                     exitOnError: false,
                     resetDaemonClient: true
@@ -61,7 +61,7 @@ There should at least be a tsconfig.base.json or tsconfig.json in the root of th
                 process.env.NX_TASK_TARGET_TARGET === 'serve' ? 'build' : process.env.NX_TASK_TARGET_TARGET, process.env.NX_TASK_TARGET_CONFIGURATION);
                 // This tsconfig is used via the Vite ts paths plugin.
                 // It can be also used by other user-defined Vite plugins (e.g. for creating type declaration files).
-                foundTsConfigPath = (0, _buildablelibsutils.createTmpTsConfig)(foundTsConfigPath, _devkit.workspaceRoot, (0, _nodepath.relative)(_devkit.workspaceRoot, projectRoot), dependencies);
+                foundTsConfigPath = (0, _buildablelibsutils.createTmpTsConfig)(foundTsConfigPath, _devkit.workspaceRoot, (0, _nodepath.relative)(_devkit.workspaceRoot, projectRoot), dependencies, true);
                 if (config.command === 'serve') {
                     const buildableLibraryDependencies = dependencies.filter((dep)=>dep.node.type === 'lib').map((dep)=>dep.node.name).join(',');
                     const buildCommand = `npx nx run-many --target=${process.env.NX_TASK_TARGET_TARGET} --projects=${buildableLibraryDependencies}`;
@@ -73,7 +73,7 @@ There should at least be a tsconfig.base.json or tsconfig.json in the root of th
             const parsed = (0, _tsconfigpaths.loadConfig)(foundTsConfigPath);
             logIt('first parsed tsconfig: ', parsed);
             if (parsed.resultType === 'failed') {
-                throw new Error(`Failed loading tsonfig at ${foundTsConfigPath}`);
+                throw new Error(`Failed loading tsconfig at ${foundTsConfigPath}`);
             }
             tsConfigPathsEsm = parsed;
             matchTsPathEsm = (0, _tsconfigpaths.createMatchPath)(parsed.absoluteBaseUrl, parsed.paths, options.mainFields);

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 { relative, join, 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';\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    '.mjs',\n    '.cjs',\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    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 (!options.buildLibsFromSource && !global.NX_GRAPH_CREATION) {\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        );\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 tsonfig 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) {\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      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 (importPath.startsWith(normalizedImport)) {\n        const joinedPath = joinPathFragments(\n          tsconfig.absoluteBaseUrl,\n          paths[0].replace(/\\/\\*$/, '')\n        );\n\n        resolvedFile = findFile(\n          importPath.replace(normalizedImport, joinedPath)\n        );\n      }\n    }\n\n    return resolvedFile;\n  }\n\n  function findFile(path: string): string {\n    for (const ext of options.extensions) {\n      const resolvedPath = resolve(path + ext);\n      if (existsSync(resolvedPath)) {\n        return resolvedPath;\n      }\n\n      const resolvedIndexPath = resolve(path, `index${ext}`);\n      if (existsSync(resolvedIndexPath)) {\n        return resolvedIndexPath;\n      }\n    }\n  }\n}\n"],"names":["nxViteTsPaths","options","matchTsPathEsm","matchTsPathFallback","tsConfigPathsEsm","tsConfigPathsFallback","extensions","mainFields","buildLibsFromSource","projectRoot","name","configResolved","config","root","projectRootFromWorkspaceRoot","relative","workspaceRoot","process","foundTsConfigPath","getTsConfig","join","env","NX_TASK_TARGET_TARGET","Error","stripIndents","global","NX_GRAPH_CREATION","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","loadFileFromPaths","writeBundle","outDir","dir","src","resolve","existsSync","dest","copyFileSync","err","console","error","preferredTsConfigPath","find","tsPath","msg","NX_VERBOSE_LOGGING","debug","tsconfig","configFileAbsolutePath","alias","normalizedImport","replace","startsWith","joinedPath","joinPathFragments","findFile","path","ext","resolvedPath","resolvedIndexPath"],"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 { relative, join, 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';\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    '.mjs',\n    '.cjs',\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    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) {\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      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 (importPath.startsWith(normalizedImport)) {\n        const joinedPath = joinPathFragments(\n          tsconfig.absoluteBaseUrl,\n          paths[0].replace(/\\/\\*$/, '')\n        );\n\n        resolvedFile = findFile(\n          importPath.replace(normalizedImport, joinedPath)\n        );\n      }\n    }\n\n    return resolvedFile;\n  }\n\n  function findFile(path: string): string {\n    for (const ext of options.extensions) {\n      const resolvedPath = resolve(path + ext);\n      if (existsSync(resolvedPath)) {\n        return resolvedPath;\n      }\n\n      const resolvedIndexPath = resolve(path, `index${ext}`);\n      if (existsSync(resolvedIndexPath)) {\n        return resolvedIndexPath;\n      }\n    }\n  }\n}\n"],"names":["nxViteTsPaths","options","matchTsPathEsm","matchTsPathFallback","tsConfigPathsEsm","tsConfigPathsFallback","extensions","mainFields","buildLibsFromSource","projectRoot","name","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","loadFileFromPaths","writeBundle","outDir","dir","src","resolve","existsSync","dest","copyFileSync","err","console","error","preferredTsConfigPath","find","tsPath","msg","NX_VERBOSE_LOGGING","debug","tsconfig","configFileAbsolutePath","alias","normalizedImport","replace","startsWith","joinedPath","joinPathFragments","findFile","path","ext","resolvedPath","resolvedIndexPath"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"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"}

package/src/generators/convert-to-inferred/convert-to-inferred.d.ts

@@ -0,0 +1,7 @@
+import { type Tree } from '@nx/devkit';
+interface Schema {
+    project?: string;
+    skipFormat?: boolean;
+}
+export declare function convertToInferred(tree: Tree, options: Schema): Promise<() => void>;
+export default convertToInferred;

package/src/generators/convert-to-inferred/convert-to-inferred.js

@@ -0,0 +1,83 @@
+"use strict";
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    convertToInferred: function() {
+        return convertToInferred;
+    },
+    default: function() {
+        return _default;
+    }
+});
+const _devkit = require("@nx/devkit");
+const _executortopluginmigrator = require("@nx/devkit/src/generators/plugin-migrations/executor-to-plugin-migrator");
+const _plugin = require("../../plugins/plugin");
+const _buildposttargettransformer = require("./lib/build-post-target-transformer");
+const _serveposttargettransformer = require("./lib/serve-post-target-transformer");
+const _previewposttargettransformer = require("./lib/preview-post-target-transformer");
+const _testposttargettransformer = require("./lib/test-post-target-transformer");
+const _aggregatelogutil = require("@nx/devkit/src/generators/plugin-migrations/aggregate-log-util");
+async function convertToInferred(tree, options) {
+    const projectGraph = await (0, _devkit.createProjectGraphAsync)();
+    const migrationLogs = new _aggregatelogutil.AggregatedLog();
+    const migratedProjects = await (0, _executortopluginmigrator.migrateProjectExecutorsToPlugin)(tree, projectGraph, '@nx/vite/plugin', _plugin.createNodesV2, {
+        buildTargetName: 'build',
+        serveTargetName: 'serve',
+        previewTargetName: 'preview',
+        testTargetName: 'test',
+        serveStaticTargetName: 'serve-static'
+    }, [
+        {
+            executors: [
+                '@nx/vite:build'
+            ],
+            postTargetTransformer: _buildposttargettransformer.buildPostTargetTransformer,
+            targetPluginOptionMapper: (target)=>({
+                    buildTargetName: target
+                })
+        },
+        {
+            executors: [
+                '@nx/vite:dev-server'
+            ],
+            postTargetTransformer: (0, _serveposttargettransformer.servePostTargetTransformer)(migrationLogs),
+            targetPluginOptionMapper: (target)=>({
+                    serveTargetName: target
+                })
+        },
+        {
+            executors: [
+                '@nx/vite:preview-server'
+            ],
+            postTargetTransformer: (0, _previewposttargettransformer.previewPostTargetTransformer)(migrationLogs),
+            targetPluginOptionMapper: (target)=>({
+                    previewTargetName: target
+                })
+        },
+        {
+            executors: [
+                '@nx/vite:test'
+            ],
+            postTargetTransformer: _testposttargettransformer.testPostTargetTransformer,
+            targetPluginOptionMapper: (target)=>({
+                    testTargetName: target
+                })
+        }
+    ], options.project);
+    if (migratedProjects.size === 0) {
+        throw new Error('Could not find any targets to migrate.');
+    }
+    if (!options.skipFormat) {
+        await (0, _devkit.formatFiles)(tree);
+    }
+    return ()=>{
+        migrationLogs.flushLogs();
+    };
+}
+const _default = convertToInferred;
+
+//# sourceMappingURL=convert-to-inferred.js.map

package/src/generators/convert-to-inferred/convert-to-inferred.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../packages/vite/src/generators/convert-to-inferred/convert-to-inferred.ts"],"sourcesContent":["import { createProjectGraphAsync, formatFiles, type Tree } from '@nx/devkit';\nimport { migrateProjectExecutorsToPlugin } from '@nx/devkit/src/generators/plugin-migrations/executor-to-plugin-migrator';\nimport { createNodesV2, VitePluginOptions } from '../../plugins/plugin';\nimport { buildPostTargetTransformer } from './lib/build-post-target-transformer';\nimport { servePostTargetTransformer } from './lib/serve-post-target-transformer';\nimport { previewPostTargetTransformer } from './lib/preview-post-target-transformer';\nimport { testPostTargetTransformer } from './lib/test-post-target-transformer';\nimport { AggregatedLog } from '@nx/devkit/src/generators/plugin-migrations/aggregate-log-util';\n\ninterface Schema {\n  project?: string;\n  skipFormat?: boolean;\n}\n\nexport async function convertToInferred(tree: Tree, options: Schema) {\n  const projectGraph = await createProjectGraphAsync();\n  const migrationLogs = new AggregatedLog();\n\n  const migratedProjects =\n    await migrateProjectExecutorsToPlugin<VitePluginOptions>(\n      tree,\n      projectGraph,\n      '@nx/vite/plugin',\n      createNodesV2,\n      {\n        buildTargetName: 'build',\n        serveTargetName: 'serve',\n        previewTargetName: 'preview',\n        testTargetName: 'test',\n        serveStaticTargetName: 'serve-static',\n      },\n      [\n        {\n          executors: ['@nx/vite:build'],\n          postTargetTransformer: buildPostTargetTransformer,\n          targetPluginOptionMapper: (target) => ({ buildTargetName: target }),\n        },\n        {\n          executors: ['@nx/vite:dev-server'],\n          postTargetTransformer: servePostTargetTransformer(migrationLogs),\n          targetPluginOptionMapper: (target) => ({ serveTargetName: target }),\n        },\n        {\n          executors: ['@nx/vite:preview-server'],\n          postTargetTransformer: previewPostTargetTransformer(migrationLogs),\n          targetPluginOptionMapper: (target) => ({ previewTargetName: target }),\n        },\n        {\n          executors: ['@nx/vite:test'],\n          postTargetTransformer: testPostTargetTransformer,\n          targetPluginOptionMapper: (target) => ({ testTargetName: target }),\n        },\n      ],\n      options.project\n    );\n\n  if (migratedProjects.size === 0) {\n    throw new Error('Could not find any targets to migrate.');\n  }\n\n  if (!options.skipFormat) {\n    await formatFiles(tree);\n  }\n\n  return () => {\n    migrationLogs.flushLogs();\n  };\n}\n\nexport default convertToInferred;\n"],"names":["convertToInferred","tree","options","projectGraph","createProjectGraphAsync","migrationLogs","AggregatedLog","migratedProjects","migrateProjectExecutorsToPlugin","createNodesV2","buildTargetName","serveTargetName","previewTargetName","testTargetName","serveStaticTargetName","executors","postTargetTransformer","buildPostTargetTransformer","targetPluginOptionMapper","target","servePostTargetTransformer","previewPostTargetTransformer","testPostTargetTransformer","project","size","Error","skipFormat","formatFiles","flushLogs"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":";;;;;;;;IAcsBA,iBAAiB;eAAjBA;;IAuDtB,OAAiC;eAAjC;;;wBArEgE;0CAChB;wBACC;4CACN;4CACA;8CACE;2CACH;kCACZ;AAOvB,eAAeA,kBAAkBC,IAAU,EAAEC,OAAe;IACjE,MAAMC,eAAe,MAAMC,IAAAA,+BAAuB;IAClD,MAAMC,gBAAgB,IAAIC,+BAAa;IAEvC,MAAMC,mBACJ,MAAMC,IAAAA,yDAA+B,EACnCP,MACAE,cACA,mBACAM,qBAAa,EACb;QACEC,iBAAiB;QACjBC,iBAAiB;QACjBC,mBAAmB;QACnBC,gBAAgB;QAChBC,uBAAuB;IACzB,GACA;QACE;YACEC,WAAW;gBAAC;aAAiB;YAC7BC,uBAAuBC,sDAA0B;YACjDC,0BAA0B,CAACC,SAAY,CAAA;oBAAET,iBAAiBS;gBAAO,CAAA;QACnE;QACA;YACEJ,WAAW;gBAAC;aAAsB;YAClCC,uBAAuBI,IAAAA,sDAA0B,EAACf;YAClDa,0BAA0B,CAACC,SAAY,CAAA;oBAAER,iBAAiBQ;gBAAO,CAAA;QACnE;QACA;YACEJ,WAAW;gBAAC;aAA0B;YACtCC,uBAAuBK,IAAAA,0DAA4B,EAAChB;YACpDa,0BAA0B,CAACC,SAAY,CAAA;oBAAEP,mBAAmBO;gBAAO,CAAA;QACrE;QACA;YACEJ,WAAW;gBAAC;aAAgB;YAC5BC,uBAAuBM,oDAAyB;YAChDJ,0BAA0B,CAACC,SAAY,CAAA;oBAAEN,gBAAgBM;gBAAO,CAAA;QAClE;KACD,EACDjB,QAAQqB,OAAO;IAGnB,IAAIhB,iBAAiBiB,IAAI,KAAK,GAAG;QAC/B,MAAM,IAAIC,MAAM;IAClB;IAEA,IAAI,CAACvB,QAAQwB,UAAU,EAAE;QACvB,MAAMC,IAAAA,mBAAW,EAAC1B;IACpB;IAEA,OAAO;QACLI,cAAcuB,SAAS;IACzB;AACF;MAEA,WAAe5B"}

package/src/generators/convert-to-inferred/lib/build-post-target-transformer.d.ts

@@ -0,0 +1,6 @@
+import { type TargetConfiguration, type Tree } from '@nx/devkit';
+export declare function buildPostTargetTransformer(target: TargetConfiguration, tree: Tree, projectDetails: {
+    projectName: string;
+    root: string;
+}, inferredTargetConfiguration: TargetConfiguration): TargetConfiguration<any>;
+export declare function moveBuildLibsFromSourceToViteConfig(tree: Tree, configPath: string): void;

package/src/generators/convert-to-inferred/lib/build-post-target-transformer.js

@@ -0,0 +1,160 @@
+"use strict";
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    buildPostTargetTransformer: function() {
+        return buildPostTargetTransformer;
+    },
+    moveBuildLibsFromSourceToViteConfig: function() {
+        return moveBuildLibsFromSourceToViteConfig;
+    }
+});
+const _devkit = require("@nx/devkit");
+const _tsquery = require("@phenomnomnominal/tsquery");
+const _posix = require("path/posix");
+const _utils = require("./utils");
+const _pluginmigrationutils = require("@nx/devkit/src/generators/plugin-migrations/plugin-migration-utils");
+function buildPostTargetTransformer(target, tree, projectDetails, inferredTargetConfiguration) {
+    let viteConfigPath = (0, _utils.getViteConfigPath)(tree, projectDetails.root);
+    const configValues = {
+        default: {}
+    };
+    if (target.configurations) {
+        for(const configurationName in target.configurations){
+            const configuration = target.configurations[configurationName];
+            configValues[configurationName] = {};
+            let configurationConfigFile = viteConfigPath;
+            if (configuration.configFile) {
+                if ('buildLibsFromSource' in target.options) {
+                    configuration.buildLibsFromSource = target.options.buildLibsFromSource;
+                }
+                configurationConfigFile = configuration.configFile;
+            }
+            removePropertiesFromTargetOptions(tree, configuration, configurationConfigFile, projectDetails.root, configValues[configurationName], configuration.configFile && configuration.configFile !== viteConfigPath);
+        }
+        for(const configurationName in target.configurations){
+            const configuration = target.configurations[configurationName];
+            if (configuration.config && configuration.config !== (0, _utils.toProjectRelativePath)(viteConfigPath, projectDetails.root)) {
+                const configFilePath = (0, _devkit.joinPathFragments)(projectDetails.root, configuration.config);
+                (0, _utils.addConfigValuesToViteConfig)(tree, configFilePath, configValues);
+            }
+        }
+        if (Object.keys(target.configurations).length === 0) {
+            if ('defaultConfiguration' in target) {
+                delete target.defaultConfiguration;
+            }
+            delete target.configurations;
+        }
+        if ('defaultConfiguration' in target && !target.configurations[target.defaultConfiguration]) {
+            delete target.defaultConfiguration;
+        }
+    }
+    if (target.options) {
+        if (target.options.configFile) {
+            viteConfigPath = target.options.configFile;
+        }
+        removePropertiesFromTargetOptions(tree, target.options, viteConfigPath, projectDetails.root, configValues['default'], true);
+    }
+    if (target.outputs) {
+        (0, _pluginmigrationutils.processTargetOutputs)(target, [
+            {
+                newName: 'outDir',
+                oldName: 'outputPath'
+            }
+        ], inferredTargetConfiguration, {
+            projectName: projectDetails.projectName,
+            projectRoot: projectDetails.root
+        });
+    }
+    if (target.inputs && target.inputs.every((i)=>i === 'production' || i === '^production')) {
+        delete target.inputs;
+    }
+    (0, _utils.addConfigValuesToViteConfig)(tree, viteConfigPath, configValues);
+    return target;
+}
+function removePropertiesFromTargetOptions(tree, targetOptions, viteConfigPath, projectRoot, configValues, needsAstTransform = false) {
+    if ('configFile' in targetOptions) {
+        targetOptions.config = (0, _utils.toProjectRelativePath)(targetOptions.configFile, projectRoot);
+        delete targetOptions.configFile;
+    }
+    if (targetOptions.outputPath) {
+        targetOptions.outDir = (0, _utils.toProjectRelativePath)(targetOptions.outputPath, projectRoot);
+        delete targetOptions.outputPath;
+    }
+    if ('buildLibsFromSource' in targetOptions) {
+        configValues['buildLibsFromSource'] = targetOptions.buildLibsFromSource;
+        if (needsAstTransform) {
+            moveBuildLibsFromSourceToViteConfig(tree, viteConfigPath);
+        }
+        delete targetOptions.buildLibsFromSource;
+    }
+    if ('skipTypeCheck' in targetOptions) {
+        delete targetOptions.skipTypeCheck;
+    }
+    if ('generatePackageJson' in targetOptions) {
+        delete targetOptions.generatePackageJson;
+    }
+    if ('includeDevDependenciesInPackageJson' in targetOptions) {
+        delete targetOptions.includeDevDependenciesInPackageJson;
+    }
+    if ('tsConfig' in targetOptions) {
+        delete targetOptions.tsConfig;
+    }
+}
+function moveBuildLibsFromSourceToViteConfig(tree, configPath) {
+    const PLUGINS_PROPERTY_SELECTOR = 'PropertyAssignment:has(Identifier[name=plugins])';
+    const PLUGINS_NX_VITE_TS_PATHS_SELECTOR = 'PropertyAssignment:has(Identifier[name=plugins]) CallExpression:has(Identifier[name=nxViteTsPaths])';
+    const BUILD_LIBS_FROM_SOURCE_SELECTOR = 'PropertyAssignment:has(Identifier[name=plugins]) CallExpression:has(Identifier[name=nxViteTsPaths]) ObjectLiteralExpression > PropertyAssignment:has(Identifier[name=buildLibsFromSource])';
+    const nxViteTsPathsImport = (0, _posix.extname)(configPath) === 'js' ? 'const {nxViteTsPaths} = require("@nx/vite/plugins/nx-tsconfig-paths.plugin");' : 'import { nxViteTsPaths } from "@nx/vite/plugins/nx-tsconfig-paths.plugin";';
+    const plugin = `nxViteTsPaths({ buildLibsFromSource: options.buildLibsFromSource }),`;
+    const viteConfigContents = tree.read(configPath, 'utf-8');
+    let newViteConfigContents = viteConfigContents;
+    const ast = _tsquery.tsquery.ast(viteConfigContents);
+    const buildLibsFromSourceNodes = (0, _tsquery.tsquery)(ast, BUILD_LIBS_FROM_SOURCE_SELECTOR, {
+        visitAllChildren: true
+    });
+    if (buildLibsFromSourceNodes.length > 0) {
+        return;
+    }
+    const nxViteTsPathsNodes = (0, _tsquery.tsquery)(ast, PLUGINS_NX_VITE_TS_PATHS_SELECTOR, {
+        visitAllChildren: true
+    });
+    if (nxViteTsPathsNodes.length === 0) {
+        const pluginsNodes = (0, _tsquery.tsquery)(ast, PLUGINS_PROPERTY_SELECTOR, {
+            visitAllChildren: true
+        });
+        if (pluginsNodes.length === 0) {
+            // Add plugin property
+            const configNodes = (0, _tsquery.tsquery)(ast, 'CallExpression:has(Identifier[name=defineConfig]) > ObjectLiteralExpression', {
+                visitAllChildren: true
+            });
+            if (configNodes.length === 0) {
+                return;
+            }
+            newViteConfigContents = `${nxViteTsPathsImport}\n${viteConfigContents.slice(0, configNodes[0].getStart() + 1)}plugins: [${plugin}],${viteConfigContents.slice(configNodes[0].getStart() + 1)}`;
+        } else {
+            // Add nxViteTsPaths plugin
+            const pluginsArrayNodes = (0, _tsquery.tsquery)(pluginsNodes[0], 'ArrayLiteralExpression');
+            if (pluginsArrayNodes.length === 0) {
+                return;
+            }
+            newViteConfigContents = `${nxViteTsPathsImport}\n${viteConfigContents.slice(0, pluginsArrayNodes[0].getStart() + 1)}${plugin}${viteConfigContents.slice(pluginsArrayNodes[0].getStart() + 1)}`;
+        }
+    } else {
+        const pluginOptionsNodes = (0, _tsquery.tsquery)(nxViteTsPathsNodes[0], 'ObjectLiteralExpression');
+        if (pluginOptionsNodes.length === 0) {
+            // Add the options
+            newViteConfigContents = `${viteConfigContents.slice(0, nxViteTsPathsNodes[0].getStart())}${plugin}${viteConfigContents.slice(nxViteTsPathsNodes[0].getEnd())}`;
+        } else {
+            // update the object
+            newViteConfigContents = `${viteConfigContents.slice(0, pluginOptionsNodes[0].getStart() + 1)}buildLibsFromSource: options.buildLibsFromSource, ${viteConfigContents.slice(pluginOptionsNodes[0].getStart() + 1)}`;
+        }
+    }
+    tree.write(configPath, newViteConfigContents);
+}
+
+//# sourceMappingURL=build-post-target-transformer.js.map

package/src/generators/convert-to-inferred/lib/build-post-target-transformer.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../../packages/vite/src/generators/convert-to-inferred/lib/build-post-target-transformer.ts"],"sourcesContent":["import {\n  joinPathFragments,\n  type TargetConfiguration,\n  type Tree,\n} from '@nx/devkit';\nimport { tsquery } from '@phenomnomnominal/tsquery';\nimport { extname } from 'path/posix';\nimport {\n  addConfigValuesToViteConfig,\n  getViteConfigPath,\n  toProjectRelativePath,\n} from './utils';\nimport { processTargetOutputs } from '@nx/devkit/src/generators/plugin-migrations/plugin-migration-utils';\n\nexport function buildPostTargetTransformer(\n  target: TargetConfiguration,\n  tree: Tree,\n  projectDetails: { projectName: string; root: string },\n  inferredTargetConfiguration: TargetConfiguration\n) {\n  let viteConfigPath = getViteConfigPath(tree, projectDetails.root);\n\n  const configValues: Record<string, Record<string, unknown>> = {\n    default: {},\n  };\n\n  if (target.configurations) {\n    for (const configurationName in target.configurations) {\n      const configuration = target.configurations[configurationName];\n      configValues[configurationName] = {};\n      let configurationConfigFile = viteConfigPath;\n      if (configuration.configFile) {\n        if ('buildLibsFromSource' in target.options) {\n          configuration.buildLibsFromSource =\n            target.options.buildLibsFromSource;\n        }\n\n        configurationConfigFile = configuration.configFile;\n      }\n\n      removePropertiesFromTargetOptions(\n        tree,\n        configuration,\n        configurationConfigFile,\n        projectDetails.root,\n        configValues[configurationName],\n        configuration.configFile && configuration.configFile !== viteConfigPath\n      );\n    }\n\n    for (const configurationName in target.configurations) {\n      const configuration = target.configurations[configurationName];\n      if (\n        configuration.config &&\n        configuration.config !==\n          toProjectRelativePath(viteConfigPath, projectDetails.root)\n      ) {\n        const configFilePath = joinPathFragments(\n          projectDetails.root,\n          configuration.config\n        );\n        addConfigValuesToViteConfig(tree, configFilePath, configValues);\n      }\n    }\n\n    if (Object.keys(target.configurations).length === 0) {\n      if ('defaultConfiguration' in target) {\n        delete target.defaultConfiguration;\n      }\n      delete target.configurations;\n    }\n\n    if (\n      'defaultConfiguration' in target &&\n      !target.configurations[target.defaultConfiguration]\n    ) {\n      delete target.defaultConfiguration;\n    }\n  }\n\n  if (target.options) {\n    if (target.options.configFile) {\n      viteConfigPath = target.options.configFile;\n    }\n\n    removePropertiesFromTargetOptions(\n      tree,\n      target.options,\n      viteConfigPath,\n      projectDetails.root,\n      configValues['default'],\n      true\n    );\n  }\n\n  if (target.outputs) {\n    processTargetOutputs(\n      target,\n      [{ newName: 'outDir', oldName: 'outputPath' }],\n      inferredTargetConfiguration,\n      {\n        projectName: projectDetails.projectName,\n        projectRoot: projectDetails.root,\n      }\n    );\n  }\n\n  if (\n    target.inputs &&\n    target.inputs.every((i) => i === 'production' || i === '^production')\n  ) {\n    delete target.inputs;\n  }\n\n  addConfigValuesToViteConfig(tree, viteConfigPath, configValues);\n\n  return target;\n}\n\nfunction removePropertiesFromTargetOptions(\n  tree: Tree,\n  targetOptions: any,\n  viteConfigPath: string,\n  projectRoot: string,\n  configValues: Record<string, unknown>,\n  needsAstTransform = false\n) {\n  if ('configFile' in targetOptions) {\n    targetOptions.config = toProjectRelativePath(\n      targetOptions.configFile,\n      projectRoot\n    );\n    delete targetOptions.configFile;\n  }\n  if (targetOptions.outputPath) {\n    targetOptions.outDir = toProjectRelativePath(\n      targetOptions.outputPath,\n      projectRoot\n    );\n\n    delete targetOptions.outputPath;\n  }\n  if ('buildLibsFromSource' in targetOptions) {\n    configValues['buildLibsFromSource'] = targetOptions.buildLibsFromSource;\n\n    if (needsAstTransform) {\n      moveBuildLibsFromSourceToViteConfig(tree, viteConfigPath);\n    }\n    delete targetOptions.buildLibsFromSource;\n  }\n  if ('skipTypeCheck' in targetOptions) {\n    delete targetOptions.skipTypeCheck;\n  }\n  if ('generatePackageJson' in targetOptions) {\n    delete targetOptions.generatePackageJson;\n  }\n  if ('includeDevDependenciesInPackageJson' in targetOptions) {\n    delete targetOptions.includeDevDependenciesInPackageJson;\n  }\n  if ('tsConfig' in targetOptions) {\n    delete targetOptions.tsConfig;\n  }\n}\n\nexport function moveBuildLibsFromSourceToViteConfig(\n  tree: Tree,\n  configPath: string\n) {\n  const PLUGINS_PROPERTY_SELECTOR =\n    'PropertyAssignment:has(Identifier[name=plugins])';\n  const PLUGINS_NX_VITE_TS_PATHS_SELECTOR =\n    'PropertyAssignment:has(Identifier[name=plugins]) CallExpression:has(Identifier[name=nxViteTsPaths])';\n  const BUILD_LIBS_FROM_SOURCE_SELECTOR =\n    'PropertyAssignment:has(Identifier[name=plugins]) CallExpression:has(Identifier[name=nxViteTsPaths]) ObjectLiteralExpression > PropertyAssignment:has(Identifier[name=buildLibsFromSource])';\n\n  const nxViteTsPathsImport =\n    extname(configPath) === 'js'\n      ? 'const {nxViteTsPaths} = require(\"@nx/vite/plugins/nx-tsconfig-paths.plugin\");'\n      : 'import { nxViteTsPaths } from \"@nx/vite/plugins/nx-tsconfig-paths.plugin\";';\n  const plugin = `nxViteTsPaths({ buildLibsFromSource: options.buildLibsFromSource }),`;\n\n  const viteConfigContents = tree.read(configPath, 'utf-8');\n  let newViteConfigContents = viteConfigContents;\n\n  const ast = tsquery.ast(viteConfigContents);\n  const buildLibsFromSourceNodes = tsquery(\n    ast,\n    BUILD_LIBS_FROM_SOURCE_SELECTOR,\n    { visitAllChildren: true }\n  );\n  if (buildLibsFromSourceNodes.length > 0) {\n    return;\n  }\n\n  const nxViteTsPathsNodes = tsquery(ast, PLUGINS_NX_VITE_TS_PATHS_SELECTOR, {\n    visitAllChildren: true,\n  });\n  if (nxViteTsPathsNodes.length === 0) {\n    const pluginsNodes = tsquery(ast, PLUGINS_PROPERTY_SELECTOR, {\n      visitAllChildren: true,\n    });\n    if (pluginsNodes.length === 0) {\n      // Add plugin property\n      const configNodes = tsquery(\n        ast,\n        'CallExpression:has(Identifier[name=defineConfig]) > ObjectLiteralExpression',\n        { visitAllChildren: true }\n      );\n      if (configNodes.length === 0) {\n        return;\n      }\n\n      newViteConfigContents = `${nxViteTsPathsImport}\\n${viteConfigContents.slice(\n        0,\n        configNodes[0].getStart() + 1\n      )}plugins: [${plugin}],${viteConfigContents.slice(\n        configNodes[0].getStart() + 1\n      )}`;\n    } else {\n      // Add nxViteTsPaths plugin\n\n      const pluginsArrayNodes = tsquery(\n        pluginsNodes[0],\n        'ArrayLiteralExpression'\n      );\n      if (pluginsArrayNodes.length === 0) {\n        return;\n      }\n\n      newViteConfigContents = `${nxViteTsPathsImport}\\n${viteConfigContents.slice(\n        0,\n        pluginsArrayNodes[0].getStart() + 1\n      )}${plugin}${viteConfigContents.slice(\n        pluginsArrayNodes[0].getStart() + 1\n      )}`;\n    }\n  } else {\n    const pluginOptionsNodes = tsquery(\n      nxViteTsPathsNodes[0],\n      'ObjectLiteralExpression'\n    );\n    if (pluginOptionsNodes.length === 0) {\n      // Add the options\n      newViteConfigContents = `${viteConfigContents.slice(\n        0,\n        nxViteTsPathsNodes[0].getStart()\n      )}${plugin}${viteConfigContents.slice(nxViteTsPathsNodes[0].getEnd())}`;\n    } else {\n      // update the object\n      newViteConfigContents = `${viteConfigContents.slice(\n        0,\n        pluginOptionsNodes[0].getStart() + 1\n      )}buildLibsFromSource: options.buildLibsFromSource, ${viteConfigContents.slice(\n        pluginOptionsNodes[0].getStart() + 1\n      )}`;\n    }\n  }\n\n  tree.write(configPath, newViteConfigContents);\n}\n"],"names":["buildPostTargetTransformer","moveBuildLibsFromSourceToViteConfig","target","tree","projectDetails","inferredTargetConfiguration","viteConfigPath","getViteConfigPath","root","configValues","default","configurations","configurationName","configuration","configurationConfigFile","configFile","options","buildLibsFromSource","removePropertiesFromTargetOptions","config","toProjectRelativePath","configFilePath","joinPathFragments","addConfigValuesToViteConfig","Object","keys","length","defaultConfiguration","outputs","processTargetOutputs","newName","oldName","projectName","projectRoot","inputs","every","i","targetOptions","needsAstTransform","outputPath","outDir","skipTypeCheck","generatePackageJson","includeDevDependenciesInPackageJson","tsConfig","configPath","PLUGINS_PROPERTY_SELECTOR","PLUGINS_NX_VITE_TS_PATHS_SELECTOR","BUILD_LIBS_FROM_SOURCE_SELECTOR","nxViteTsPathsImport","extname","plugin","viteConfigContents","read","newViteConfigContents","ast","tsquery","buildLibsFromSourceNodes","visitAllChildren","nxViteTsPathsNodes","pluginsNodes","configNodes","slice","getStart","pluginsArrayNodes","pluginOptionsNodes","getEnd","write"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"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"}

package/src/generators/convert-to-inferred/lib/preview-post-target-transformer.d.ts

@@ -0,0 +1,6 @@
+import { type TargetConfiguration, type Tree } from '@nx/devkit';
+import { AggregatedLog } from '@nx/devkit/src/generators/plugin-migrations/aggregate-log-util';
+export declare function previewPostTargetTransformer(migrationLogs: AggregatedLog): (target: TargetConfiguration, tree: Tree, projectDetails: {
+    projectName: string;
+    root: string;
+}, inferredTargetConfiguration: TargetConfiguration) => TargetConfiguration<any>;

package/src/generators/convert-to-inferred/lib/preview-post-target-transformer.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "previewPostTargetTransformer", {
+    enumerable: true,
+    get: function() {
+        return previewPostTargetTransformer;
+    }
+});
+const _utils = require("./utils");
+function previewPostTargetTransformer(migrationLogs) {
+    return (target, tree, projectDetails, inferredTargetConfiguration)=>{
+        const viteConfigPath = (0, _utils.getViteConfigPath)(tree, projectDetails.root);
+        if (target.options) {
+            removePropertiesFromTargetOptions(target.options, projectDetails.projectName, migrationLogs);
+        }
+        if (target.configurations) {
+            for(const configurationName in target.configurations){
+                const configuration = target.configurations[configurationName];
+                removePropertiesFromTargetOptions(configuration, projectDetails.projectName, migrationLogs);
+            }
+            if (Object.keys(target.configurations).length === 0) {
+                if ('defaultConfiguration' in target) {
+                    delete target.defaultConfiguration;
+                }
+                delete target.configurations;
+            }
+            if ('defaultConfiguration' in target && !target.configurations[target.defaultConfiguration]) {
+                delete target.defaultConfiguration;
+            }
+        }
+        return target;
+    };
+}
+function removePropertiesFromTargetOptions(targetOptions, projectName, migrationLogs) {
+    if ('buildTarget' in targetOptions) {
+        delete targetOptions.buildTarget;
+    }
+    if ('staticFilePath' in targetOptions) {
+        delete targetOptions.staticFilePath;
+    }
+    if ('proxyConfig' in targetOptions) {
+        migrationLogs.addLog({
+            executorName: '@nx/vite:preview-server',
+            project: projectName,
+            log: `Encountered 'proxyConfig' in project.json. You will need to copy the contents of this file to the 'server.proxy' property in your Vite config file.`
+        });
+        delete targetOptions.proxyConfig;
+    }
+}
+
+//# sourceMappingURL=preview-post-target-transformer.js.map

package/src/generators/convert-to-inferred/lib/preview-post-target-transformer.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../../packages/vite/src/generators/convert-to-inferred/lib/preview-post-target-transformer.ts"],"sourcesContent":["import { type TargetConfiguration, type Tree } from '@nx/devkit';\nimport { getViteConfigPath } from './utils';\nimport { AggregatedLog } from '@nx/devkit/src/generators/plugin-migrations/aggregate-log-util';\n\nexport function previewPostTargetTransformer(migrationLogs: AggregatedLog) {\n  return (\n    target: TargetConfiguration,\n    tree: Tree,\n    projectDetails: { projectName: string; root: string },\n    inferredTargetConfiguration: TargetConfiguration\n  ) => {\n    const viteConfigPath = getViteConfigPath(tree, projectDetails.root);\n\n    if (target.options) {\n      removePropertiesFromTargetOptions(\n        target.options,\n        projectDetails.projectName,\n        migrationLogs\n      );\n    }\n\n    if (target.configurations) {\n      for (const configurationName in target.configurations) {\n        const configuration = target.configurations[configurationName];\n        removePropertiesFromTargetOptions(\n          configuration,\n          projectDetails.projectName,\n          migrationLogs\n        );\n      }\n\n      if (Object.keys(target.configurations).length === 0) {\n        if ('defaultConfiguration' in target) {\n          delete target.defaultConfiguration;\n        }\n        delete target.configurations;\n      }\n\n      if (\n        'defaultConfiguration' in target &&\n        !target.configurations[target.defaultConfiguration]\n      ) {\n        delete target.defaultConfiguration;\n      }\n    }\n\n    return target;\n  };\n}\n\nfunction removePropertiesFromTargetOptions(\n  targetOptions: any,\n  projectName: string,\n  migrationLogs: AggregatedLog\n) {\n  if ('buildTarget' in targetOptions) {\n    delete targetOptions.buildTarget;\n  }\n\n  if ('staticFilePath' in targetOptions) {\n    delete targetOptions.staticFilePath;\n  }\n\n  if ('proxyConfig' in targetOptions) {\n    migrationLogs.addLog({\n      executorName: '@nx/vite:preview-server',\n      project: projectName,\n      log: `Encountered 'proxyConfig' in project.json. You will need to copy the contents of this file to the 'server.proxy' property in your Vite config file.`,\n    });\n    delete targetOptions.proxyConfig;\n  }\n}\n"],"names":["previewPostTargetTransformer","migrationLogs","target","tree","projectDetails","inferredTargetConfiguration","viteConfigPath","getViteConfigPath","root","options","removePropertiesFromTargetOptions","projectName","configurations","configurationName","configuration","Object","keys","length","defaultConfiguration","targetOptions","buildTarget","staticFilePath","addLog","executorName","project","log","proxyConfig"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":";+BAIgBA;;;eAAAA;;;uBAHkB;AAG3B,SAASA,6BAA6BC,aAA4B;IACvE,OAAO,CACLC,QACAC,MACAC,gBACAC;QAEA,MAAMC,iBAAiBC,IAAAA,wBAAiB,EAACJ,MAAMC,eAAeI,IAAI;QAElE,IAAIN,OAAOO,OAAO,EAAE;YAClBC,kCACER,OAAOO,OAAO,EACdL,eAAeO,WAAW,EAC1BV;QAEJ;QAEA,IAAIC,OAAOU,cAAc,EAAE;YACzB,IAAK,MAAMC,qBAAqBX,OAAOU,cAAc,CAAE;gBACrD,MAAME,gBAAgBZ,OAAOU,cAAc,CAACC,kBAAkB;gBAC9DH,kCACEI,eACAV,eAAeO,WAAW,EAC1BV;YAEJ;YAEA,IAAIc,OAAOC,IAAI,CAACd,OAAOU,cAAc,EAAEK,MAAM,KAAK,GAAG;gBACnD,IAAI,0BAA0Bf,QAAQ;oBACpC,OAAOA,OAAOgB,oBAAoB;gBACpC;gBACA,OAAOhB,OAAOU,cAAc;YAC9B;YAEA,IACE,0BAA0BV,UAC1B,CAACA,OAAOU,cAAc,CAACV,OAAOgB,oBAAoB,CAAC,EACnD;gBACA,OAAOhB,OAAOgB,oBAAoB;YACpC;QACF;QAEA,OAAOhB;IACT;AACF;AAEA,SAASQ,kCACPS,aAAkB,EAClBR,WAAmB,EACnBV,aAA4B;IAE5B,IAAI,iBAAiBkB,eAAe;QAClC,OAAOA,cAAcC,WAAW;IAClC;IAEA,IAAI,oBAAoBD,eAAe;QACrC,OAAOA,cAAcE,cAAc;IACrC;IAEA,IAAI,iBAAiBF,eAAe;QAClClB,cAAcqB,MAAM,CAAC;YACnBC,cAAc;YACdC,SAASb;YACTc,KAAK,CAAC,mJAAmJ,CAAC;QAC5J;QACA,OAAON,cAAcO,WAAW;IAClC;AACF"}

package/src/generators/convert-to-inferred/lib/serve-post-target-transformer.d.ts

@@ -0,0 +1,6 @@
+import { type TargetConfiguration, type Tree } from '@nx/devkit';
+import { AggregatedLog } from '@nx/devkit/src/generators/plugin-migrations/aggregate-log-util';
+export declare function servePostTargetTransformer(migrationLogs: AggregatedLog): (target: TargetConfiguration, tree: Tree, projectDetails: {
+    projectName: string;
+    root: string;
+}, inferredTargetConfiguration: TargetConfiguration) => TargetConfiguration<any>;

package/src/generators/convert-to-inferred/lib/serve-post-target-transformer.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "servePostTargetTransformer", {
+    enumerable: true,
+    get: function() {
+        return servePostTargetTransformer;
+    }
+});
+const _utils = require("./utils");
+function servePostTargetTransformer(migrationLogs) {
+    return (target, tree, projectDetails, inferredTargetConfiguration)=>{
+        const viteConfigPath = (0, _utils.getViteConfigPath)(tree, projectDetails.root);
+        if (target.options) {
+            removePropertiesFromTargetOptions(tree, target.options, viteConfigPath, projectDetails.root, projectDetails.projectName, migrationLogs, true);
+        }
+        if (target.configurations) {
+            for(const configurationName in target.configurations){
+                const configuration = target.configurations[configurationName];
+                removePropertiesFromTargetOptions(tree, configuration, viteConfigPath, projectDetails.root, projectDetails.projectName, migrationLogs);
+            }
+            if (Object.keys(target.configurations).length === 0) {
+                if ('defaultConfiguration' in target) {
+                    delete target.defaultConfiguration;
+                }
+                delete target.configurations;
+            }
+            if ('defaultConfiguration' in target && !target.configurations[target.defaultConfiguration]) {
+                delete target.defaultConfiguration;
+            }
+        }
+        return target;
+    };
+}
+function removePropertiesFromTargetOptions(tree, targetOptions, viteConfigPath, projectRoot, projectName, migrationLogs, defaultOptions = false) {
+    if ('buildTarget' in targetOptions) {
+        delete targetOptions.buildTarget;
+    }
+    if ('buildLibsFromSource' in targetOptions) {
+        migrationLogs.addLog({
+            executorName: '@nx/vite:dev-server',
+            project: projectName,
+            log: `Encountered 'buildLibsFromSource' in project.json. This property will be added to your Vite config file via the '@nx/vite:build' executor migration.`
+        });
+        delete targetOptions.buildLibsFromSource;
+    }
+    if ('hmr' in targetOptions) {
+        delete targetOptions.hmr;
+    }
+    if ('proxyConfig' in targetOptions) {
+        migrationLogs.addLog({
+            executorName: '@nx/vite:dev-server',
+            project: projectName,
+            log: `Encountered 'proxyConfig' in project.json. You will need to copy the contents of this file to the 'server.proxy' property in your Vite config file.`
+        });
+        delete targetOptions.proxyConfig;
+    }
+}
+
+//# sourceMappingURL=serve-post-target-transformer.js.map

package/src/generators/convert-to-inferred/lib/serve-post-target-transformer.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../../packages/vite/src/generators/convert-to-inferred/lib/serve-post-target-transformer.ts"],"sourcesContent":["import { type TargetConfiguration, type Tree } from '@nx/devkit';\nimport { getViteConfigPath } from './utils';\nimport { AggregatedLog } from '@nx/devkit/src/generators/plugin-migrations/aggregate-log-util';\n\nexport function servePostTargetTransformer(migrationLogs: AggregatedLog) {\n  return (\n    target: TargetConfiguration,\n    tree: Tree,\n    projectDetails: { projectName: string; root: string },\n    inferredTargetConfiguration: TargetConfiguration\n  ) => {\n    const viteConfigPath = getViteConfigPath(tree, projectDetails.root);\n\n    if (target.options) {\n      removePropertiesFromTargetOptions(\n        tree,\n        target.options,\n        viteConfigPath,\n        projectDetails.root,\n        projectDetails.projectName,\n        migrationLogs,\n        true\n      );\n    }\n\n    if (target.configurations) {\n      for (const configurationName in target.configurations) {\n        const configuration = target.configurations[configurationName];\n        removePropertiesFromTargetOptions(\n          tree,\n          configuration,\n          viteConfigPath,\n          projectDetails.root,\n          projectDetails.projectName,\n          migrationLogs\n        );\n      }\n\n      if (Object.keys(target.configurations).length === 0) {\n        if ('defaultConfiguration' in target) {\n          delete target.defaultConfiguration;\n        }\n        delete target.configurations;\n      }\n\n      if (\n        'defaultConfiguration' in target &&\n        !target.configurations[target.defaultConfiguration]\n      ) {\n        delete target.defaultConfiguration;\n      }\n    }\n\n    return target;\n  };\n}\n\nfunction removePropertiesFromTargetOptions(\n  tree: Tree,\n  targetOptions: any,\n  viteConfigPath: string,\n  projectRoot: string,\n  projectName: string,\n  migrationLogs: AggregatedLog,\n  defaultOptions = false\n) {\n  if ('buildTarget' in targetOptions) {\n    delete targetOptions.buildTarget;\n  }\n\n  if ('buildLibsFromSource' in targetOptions) {\n    migrationLogs.addLog({\n      executorName: '@nx/vite:dev-server',\n      project: projectName,\n      log: `Encountered 'buildLibsFromSource' in project.json. This property will be added to your Vite config file via the '@nx/vite:build' executor migration.`,\n    });\n    delete targetOptions.buildLibsFromSource;\n  }\n\n  if ('hmr' in targetOptions) {\n    delete targetOptions.hmr;\n  }\n\n  if ('proxyConfig' in targetOptions) {\n    migrationLogs.addLog({\n      executorName: '@nx/vite:dev-server',\n      project: projectName,\n      log: `Encountered 'proxyConfig' in project.json. You will need to copy the contents of this file to the 'server.proxy' property in your Vite config file.`,\n    });\n    delete targetOptions.proxyConfig;\n  }\n}\n"],"names":["servePostTargetTransformer","migrationLogs","target","tree","projectDetails","inferredTargetConfiguration","viteConfigPath","getViteConfigPath","root","options","removePropertiesFromTargetOptions","projectName","configurations","configurationName","configuration","Object","keys","length","defaultConfiguration","targetOptions","projectRoot","defaultOptions","buildTarget","addLog","executorName","project","log","buildLibsFromSource","hmr","proxyConfig"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":";+BAIgBA;;;eAAAA;;;uBAHkB;AAG3B,SAASA,2BAA2BC,aAA4B;IACrE,OAAO,CACLC,QACAC,MACAC,gBACAC;QAEA,MAAMC,iBAAiBC,IAAAA,wBAAiB,EAACJ,MAAMC,eAAeI,IAAI;QAElE,IAAIN,OAAOO,OAAO,EAAE;YAClBC,kCACEP,MACAD,OAAOO,OAAO,EACdH,gBACAF,eAAeI,IAAI,EACnBJ,eAAeO,WAAW,EAC1BV,eACA;QAEJ;QAEA,IAAIC,OAAOU,cAAc,EAAE;YACzB,IAAK,MAAMC,qBAAqBX,OAAOU,cAAc,CAAE;gBACrD,MAAME,gBAAgBZ,OAAOU,cAAc,CAACC,kBAAkB;gBAC9DH,kCACEP,MACAW,eACAR,gBACAF,eAAeI,IAAI,EACnBJ,eAAeO,WAAW,EAC1BV;YAEJ;YAEA,IAAIc,OAAOC,IAAI,CAACd,OAAOU,cAAc,EAAEK,MAAM,KAAK,GAAG;gBACnD,IAAI,0BAA0Bf,QAAQ;oBACpC,OAAOA,OAAOgB,oBAAoB;gBACpC;gBACA,OAAOhB,OAAOU,cAAc;YAC9B;YAEA,IACE,0BAA0BV,UAC1B,CAACA,OAAOU,cAAc,CAACV,OAAOgB,oBAAoB,CAAC,EACnD;gBACA,OAAOhB,OAAOgB,oBAAoB;YACpC;QACF;QAEA,OAAOhB;IACT;AACF;AAEA,SAASQ,kCACPP,IAAU,EACVgB,aAAkB,EAClBb,cAAsB,EACtBc,WAAmB,EACnBT,WAAmB,EACnBV,aAA4B,EAC5BoB,iBAAiB,KAAK;IAEtB,IAAI,iBAAiBF,eAAe;QAClC,OAAOA,cAAcG,WAAW;IAClC;IAEA,IAAI,yBAAyBH,eAAe;QAC1ClB,cAAcsB,MAAM,CAAC;YACnBC,cAAc;YACdC,SAASd;YACTe,KAAK,CAAC,oJAAoJ,CAAC;QAC7J;QACA,OAAOP,cAAcQ,mBAAmB;IAC1C;IAEA,IAAI,SAASR,eAAe;QAC1B,OAAOA,cAAcS,GAAG;IAC1B;IAEA,IAAI,iBAAiBT,eAAe;QAClClB,cAAcsB,MAAM,CAAC;YACnBC,cAAc;YACdC,SAASd;YACTe,KAAK,CAAC,mJAAmJ,CAAC;QAC5J;QACA,OAAOP,cAAcU,WAAW;IAClC;AACF"}

package/src/generators/convert-to-inferred/lib/test-post-target-transformer.d.ts

@@ -0,0 +1,5 @@
+import { type TargetConfiguration, type Tree } from '@nx/devkit';
+export declare function testPostTargetTransformer(target: TargetConfiguration, tree: Tree, projectDetails: {
+    projectName: string;
+    root: string;
+}, inferredTargetConfiguration: TargetConfiguration): TargetConfiguration<any>;

package/src/generators/convert-to-inferred/lib/test-post-target-transformer.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "testPostTargetTransformer", {
+    enumerable: true,
+    get: function() {
+        return testPostTargetTransformer;
+    }
+});
+const _utils = require("./utils");
+const _pluginmigrationutils = require("@nx/devkit/src/generators/plugin-migrations/plugin-migration-utils");
+function testPostTargetTransformer(target, tree, projectDetails, inferredTargetConfiguration) {
+    if (target.options) {
+        removePropertiesFromTargetOptions(target.options, projectDetails.root);
+    }
+    if (target.configurations) {
+        for(const configurationName in target.configurations){
+            const configuration = target.configurations[configurationName];
+            removePropertiesFromTargetOptions(configuration, projectDetails.root);
+        }
+        if (Object.keys(target.configurations).length === 0) {
+            if ('defaultConfiguration' in target) {
+                delete target.defaultConfiguration;
+            }
+            delete target.configurations;
+        }
+        if ('defaultConfiguration' in target && !target.configurations[target.defaultConfiguration]) {
+            delete target.defaultConfiguration;
+        }
+    }
+    if (target.outputs) {
+        (0, _pluginmigrationutils.processTargetOutputs)(target, [
+            {
+                newName: 'coverage.reportsDirectory',
+                oldName: 'reportsDirectory'
+            }
+        ], inferredTargetConfiguration, {
+            projectName: projectDetails.projectName,
+            projectRoot: projectDetails.root
+        });
+    }
+    if (target.inputs && target.inputs.every((i)=>i === 'default' || i === '^production')) {
+        delete target.inputs;
+    }
+    return target;
+}
+function removePropertiesFromTargetOptions(targetOptions, projectRoot) {
+    if ('configFile' in targetOptions) {
+        targetOptions.config = (0, _utils.toProjectRelativePath)(targetOptions.configFile, projectRoot);
+        delete targetOptions.configFile;
+    }
+    if ('reportsDirectory' in targetOptions) {
+        if (targetOptions.reportsDirectory.startsWith('../')) {
+            targetOptions.reportsDirectory = targetOptions.reportsDirectory.replace(/(\.\.\/)+/, '');
+        }
+        targetOptions['coverage.reportsDirectory'] = (0, _utils.toProjectRelativePath)(targetOptions.reportsDirectory, projectRoot);
+        delete targetOptions.reportsDirectory;
+    }
+    if ('testFiles' in targetOptions) {
+        targetOptions.testNamePattern = `"/(${targetOptions.testFiles.map((f)=>f.replace('.', '\\.')).join('|')})/"`;
+        delete targetOptions.testFiles;
+    }
+}
+
+//# sourceMappingURL=test-post-target-transformer.js.map

package/src/generators/convert-to-inferred/lib/test-post-target-transformer.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../../packages/vite/src/generators/convert-to-inferred/lib/test-post-target-transformer.ts"],"sourcesContent":["import { type TargetConfiguration, type Tree } from '@nx/devkit';\nimport { toProjectRelativePath } from './utils';\nimport { processTargetOutputs } from '@nx/devkit/src/generators/plugin-migrations/plugin-migration-utils';\n\nexport function testPostTargetTransformer(\n  target: TargetConfiguration,\n  tree: Tree,\n  projectDetails: { projectName: string; root: string },\n  inferredTargetConfiguration: TargetConfiguration\n) {\n  if (target.options) {\n    removePropertiesFromTargetOptions(target.options, projectDetails.root);\n  }\n\n  if (target.configurations) {\n    for (const configurationName in target.configurations) {\n      const configuration = target.configurations[configurationName];\n      removePropertiesFromTargetOptions(configuration, projectDetails.root);\n    }\n\n    if (Object.keys(target.configurations).length === 0) {\n      if ('defaultConfiguration' in target) {\n        delete target.defaultConfiguration;\n      }\n      delete target.configurations;\n    }\n\n    if (\n      'defaultConfiguration' in target &&\n      !target.configurations[target.defaultConfiguration]\n    ) {\n      delete target.defaultConfiguration;\n    }\n  }\n\n  if (target.outputs) {\n    processTargetOutputs(\n      target,\n      [{ newName: 'coverage.reportsDirectory', oldName: 'reportsDirectory' }],\n      inferredTargetConfiguration,\n      {\n        projectName: projectDetails.projectName,\n        projectRoot: projectDetails.root,\n      }\n    );\n  }\n\n  if (\n    target.inputs &&\n    target.inputs.every((i) => i === 'default' || i === '^production')\n  ) {\n    delete target.inputs;\n  }\n\n  return target;\n}\n\nfunction removePropertiesFromTargetOptions(\n  targetOptions: any,\n  projectRoot: string\n) {\n  if ('configFile' in targetOptions) {\n    targetOptions.config = toProjectRelativePath(\n      targetOptions.configFile,\n      projectRoot\n    );\n    delete targetOptions.configFile;\n  }\n\n  if ('reportsDirectory' in targetOptions) {\n    if (targetOptions.reportsDirectory.startsWith('../')) {\n      targetOptions.reportsDirectory = targetOptions.reportsDirectory.replace(\n        /(\\.\\.\\/)+/,\n        ''\n      );\n    }\n    targetOptions['coverage.reportsDirectory'] = toProjectRelativePath(\n      targetOptions.reportsDirectory,\n      projectRoot\n    );\n    delete targetOptions.reportsDirectory;\n  }\n\n  if ('testFiles' in targetOptions) {\n    targetOptions.testNamePattern = `\"/(${targetOptions.testFiles\n      .map((f) => f.replace('.', '\\\\.'))\n      .join('|')})/\"`;\n    delete targetOptions.testFiles;\n  }\n}\n"],"names":["testPostTargetTransformer","target","tree","projectDetails","inferredTargetConfiguration","options","removePropertiesFromTargetOptions","root","configurations","configurationName","configuration","Object","keys","length","defaultConfiguration","outputs","processTargetOutputs","newName","oldName","projectName","projectRoot","inputs","every","i","targetOptions","config","toProjectRelativePath","configFile","reportsDirectory","startsWith","replace","testNamePattern","testFiles","map","f","join"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":";+BAIgBA;;;eAAAA;;;uBAHsB;sCACD;AAE9B,SAASA,0BACdC,MAA2B,EAC3BC,IAAU,EACVC,cAAqD,EACrDC,2BAAgD;IAEhD,IAAIH,OAAOI,OAAO,EAAE;QAClBC,kCAAkCL,OAAOI,OAAO,EAAEF,eAAeI,IAAI;IACvE;IAEA,IAAIN,OAAOO,cAAc,EAAE;QACzB,IAAK,MAAMC,qBAAqBR,OAAOO,cAAc,CAAE;YACrD,MAAME,gBAAgBT,OAAOO,cAAc,CAACC,kBAAkB;YAC9DH,kCAAkCI,eAAeP,eAAeI,IAAI;QACtE;QAEA,IAAII,OAAOC,IAAI,CAACX,OAAOO,cAAc,EAAEK,MAAM,KAAK,GAAG;YACnD,IAAI,0BAA0BZ,QAAQ;gBACpC,OAAOA,OAAOa,oBAAoB;YACpC;YACA,OAAOb,OAAOO,cAAc;QAC9B;QAEA,IACE,0BAA0BP,UAC1B,CAACA,OAAOO,cAAc,CAACP,OAAOa,oBAAoB,CAAC,EACnD;YACA,OAAOb,OAAOa,oBAAoB;QACpC;IACF;IAEA,IAAIb,OAAOc,OAAO,EAAE;QAClBC,IAAAA,0CAAoB,EAClBf,QACA;YAAC;gBAAEgB,SAAS;gBAA6BC,SAAS;YAAmB;SAAE,EACvEd,6BACA;YACEe,aAAahB,eAAegB,WAAW;YACvCC,aAAajB,eAAeI,IAAI;QAClC;IAEJ;IAEA,IACEN,OAAOoB,MAAM,IACbpB,OAAOoB,MAAM,CAACC,KAAK,CAAC,CAACC,IAAMA,MAAM,aAAaA,MAAM,gBACpD;QACA,OAAOtB,OAAOoB,MAAM;IACtB;IAEA,OAAOpB;AACT;AAEA,SAASK,kCACPkB,aAAkB,EAClBJ,WAAmB;IAEnB,IAAI,gBAAgBI,eAAe;QACjCA,cAAcC,MAAM,GAAGC,IAAAA,4BAAqB,EAC1CF,cAAcG,UAAU,EACxBP;QAEF,OAAOI,cAAcG,UAAU;IACjC;IAEA,IAAI,sBAAsBH,eAAe;QACvC,IAAIA,cAAcI,gBAAgB,CAACC,UAAU,CAAC,QAAQ;YACpDL,cAAcI,gBAAgB,GAAGJ,cAAcI,gBAAgB,CAACE,OAAO,CACrE,aACA;QAEJ;QACAN,aAAa,CAAC,4BAA4B,GAAGE,IAAAA,4BAAqB,EAChEF,cAAcI,gBAAgB,EAC9BR;QAEF,OAAOI,cAAcI,gBAAgB;IACvC;IAEA,IAAI,eAAeJ,eAAe;QAChCA,cAAcO,eAAe,GAAG,CAAC,GAAG,EAAEP,cAAcQ,SAAS,CAC1DC,GAAG,CAAC,CAACC,IAAMA,EAAEJ,OAAO,CAAC,KAAK,QAC1BK,IAAI,CAAC,KAAK,GAAG,CAAC;QACjB,OAAOX,cAAcQ,SAAS;IAChC;AACF"}

package/src/generators/convert-to-inferred/lib/utils.d.ts

@@ -0,0 +1,4 @@
+import { type Tree } from '@nx/devkit';
+export declare function toProjectRelativePath(path: string, projectRoot: string): string;
+export declare function getViteConfigPath(tree: Tree, root: string): string;
+export declare function addConfigValuesToViteConfig(tree: Tree, configFile: string, configValues: Record<string, Record<string, unknown>>): void;

package/src/generators/convert-to-inferred/lib/utils.js

@@ -0,0 +1,69 @@
+"use strict";
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    addConfigValuesToViteConfig: function() {
+        return addConfigValuesToViteConfig;
+    },
+    getViteConfigPath: function() {
+        return getViteConfigPath;
+    },
+    toProjectRelativePath: function() {
+        return toProjectRelativePath;
+    }
+});
+const _posix = require("path/posix");
+const _devkit = require("@nx/devkit");
+const _tsquery = require("@phenomnomnominal/tsquery");
+function toProjectRelativePath(path, projectRoot) {
+    if (projectRoot === '.') {
+        // workspace and project root are the same, we normalize it to ensure it
+        // works with Jest since some paths only work when they start with `./`
+        return path.startsWith('.') ? path : `./${path}`;
+    }
+    const relativePath = (0, _posix.relative)((0, _posix.resolve)(_devkit.workspaceRoot, projectRoot), (0, _posix.resolve)(_devkit.workspaceRoot, path));
+    return relativePath.startsWith('.') ? relativePath : `./${relativePath}`;
+}
+function getViteConfigPath(tree, root) {
+    return [
+        (0, _devkit.joinPathFragments)(root, `vite.config.ts`),
+        (0, _devkit.joinPathFragments)(root, `vite.config.cts`),
+        (0, _devkit.joinPathFragments)(root, `vite.config.mts`),
+        (0, _devkit.joinPathFragments)(root, `vite.config.js`),
+        (0, _devkit.joinPathFragments)(root, `vite.config.cjs`),
+        (0, _devkit.joinPathFragments)(root, `vite.config.mjs`)
+    ].find((f)=>tree.exists(f));
+}
+function addConfigValuesToViteConfig(tree, configFile, configValues) {
+    const IMPORT_PROPERTY_SELECTOR = 'ImportDeclaration';
+    const viteConfigContents = tree.read(configFile, 'utf-8');
+    const ast = _tsquery.tsquery.ast(viteConfigContents);
+    // AST TO GET SECTION TO APPEND TO
+    const importNodes = (0, _tsquery.tsquery)(ast, IMPORT_PROPERTY_SELECTOR, {
+        visitAllChildren: true
+    });
+    if (importNodes.length === 0) {
+        return;
+    }
+    const lastImportNode = importNodes[importNodes.length - 1];
+    const configValuesString = `
+  // These options were migrated by @nx/vite:convert-to-inferred from the project.json file.
+  const configValues = ${JSON.stringify(configValues)};
+  
+  // Determine the correct configValue to use based on the configuration
+  const nxConfiguration = process.env.NX_TASK_TARGET_CONFIGURATION ?? 'default';
+  
+  const options = {
+    ...configValues.default,
+    ...(configValues[nxConfiguration] ?? {})
+  }`;
+    tree.write(configFile, `${viteConfigContents.slice(0, lastImportNode.getEnd())}
+  ${configValuesString}
+  ${viteConfigContents.slice(lastImportNode.getEnd())}`);
+}
+
+//# sourceMappingURL=utils.js.map

package/src/generators/convert-to-inferred/lib/utils.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../../packages/vite/src/generators/convert-to-inferred/lib/utils.ts"],"sourcesContent":["import { relative, resolve } from 'path/posix';\nimport { workspaceRoot, type Tree, joinPathFragments } from '@nx/devkit';\nimport { tsquery } from '@phenomnomnominal/tsquery';\n\nexport function toProjectRelativePath(\n  path: string,\n  projectRoot: string\n): string {\n  if (projectRoot === '.') {\n    // workspace and project root are the same, we normalize it to ensure it\n    // works with Jest since some paths only work when they start with `./`\n    return path.startsWith('.') ? path : `./${path}`;\n  }\n\n  const relativePath = relative(\n    resolve(workspaceRoot, projectRoot),\n    resolve(workspaceRoot, path)\n  );\n\n  return relativePath.startsWith('.') ? relativePath : `./${relativePath}`;\n}\n\nexport function getViteConfigPath(tree: Tree, root: string) {\n  return [\n    joinPathFragments(root, `vite.config.ts`),\n    joinPathFragments(root, `vite.config.cts`),\n    joinPathFragments(root, `vite.config.mts`),\n    joinPathFragments(root, `vite.config.js`),\n    joinPathFragments(root, `vite.config.cjs`),\n    joinPathFragments(root, `vite.config.mjs`),\n  ].find((f) => tree.exists(f));\n}\n\nexport function addConfigValuesToViteConfig(\n  tree: Tree,\n  configFile: string,\n  configValues: Record<string, Record<string, unknown>>\n) {\n  const IMPORT_PROPERTY_SELECTOR = 'ImportDeclaration';\n  const viteConfigContents = tree.read(configFile, 'utf-8');\n\n  const ast = tsquery.ast(viteConfigContents);\n  // AST TO GET SECTION TO APPEND TO\n  const importNodes = tsquery(ast, IMPORT_PROPERTY_SELECTOR, {\n    visitAllChildren: true,\n  });\n  if (importNodes.length === 0) {\n    return;\n  }\n  const lastImportNode = importNodes[importNodes.length - 1];\n\n  const configValuesString = `\n  // These options were migrated by @nx/vite:convert-to-inferred from the project.json file.\n  const configValues = ${JSON.stringify(configValues)};\n  \n  // Determine the correct configValue to use based on the configuration\n  const nxConfiguration = process.env.NX_TASK_TARGET_CONFIGURATION ?? 'default';\n  \n  const options = {\n    ...configValues.default,\n    ...(configValues[nxConfiguration] ?? {})\n  }`;\n\n  tree.write(\n    configFile,\n    `${viteConfigContents.slice(0, lastImportNode.getEnd())}\n  ${configValuesString}\n  ${viteConfigContents.slice(lastImportNode.getEnd())}`\n  );\n}\n"],"names":["addConfigValuesToViteConfig","getViteConfigPath","toProjectRelativePath","path","projectRoot","startsWith","relativePath","relative","resolve","workspaceRoot","tree","root","joinPathFragments","find","f","exists","configFile","configValues","IMPORT_PROPERTY_SELECTOR","viteConfigContents","read","ast","tsquery","importNodes","visitAllChildren","length","lastImportNode","configValuesString","JSON","stringify","write","slice","getEnd"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":";;;;;;;;IAiCgBA,2BAA2B;eAA3BA;;IAXAC,iBAAiB;eAAjBA;;IAlBAC,qBAAqB;eAArBA;;;uBAJkB;wBAC0B;yBACpC;AAEjB,SAASA,sBACdC,IAAY,EACZC,WAAmB;IAEnB,IAAIA,gBAAgB,KAAK;QACvB,wEAAwE;QACxE,uEAAuE;QACvE,OAAOD,KAAKE,UAAU,CAAC,OAAOF,OAAO,CAAC,EAAE,EAAEA,KAAK,CAAC;IAClD;IAEA,MAAMG,eAAeC,IAAAA,eAAQ,EAC3BC,IAAAA,cAAO,EAACC,qBAAa,EAAEL,cACvBI,IAAAA,cAAO,EAACC,qBAAa,EAAEN;IAGzB,OAAOG,aAAaD,UAAU,CAAC,OAAOC,eAAe,CAAC,EAAE,EAAEA,aAAa,CAAC;AAC1E;AAEO,SAASL,kBAAkBS,IAAU,EAAEC,IAAY;IACxD,OAAO;QACLC,IAAAA,yBAAiB,EAACD,MAAM,CAAC,cAAc,CAAC;QACxCC,IAAAA,yBAAiB,EAACD,MAAM,CAAC,eAAe,CAAC;QACzCC,IAAAA,yBAAiB,EAACD,MAAM,CAAC,eAAe,CAAC;QACzCC,IAAAA,yBAAiB,EAACD,MAAM,CAAC,cAAc,CAAC;QACxCC,IAAAA,yBAAiB,EAACD,MAAM,CAAC,eAAe,CAAC;QACzCC,IAAAA,yBAAiB,EAACD,MAAM,CAAC,eAAe,CAAC;KAC1C,CAACE,IAAI,CAAC,CAACC,IAAMJ,KAAKK,MAAM,CAACD;AAC5B;AAEO,SAASd,4BACdU,IAAU,EACVM,UAAkB,EAClBC,YAAqD;IAErD,MAAMC,2BAA2B;IACjC,MAAMC,qBAAqBT,KAAKU,IAAI,CAACJ,YAAY;IAEjD,MAAMK,MAAMC,gBAAO,CAACD,GAAG,CAACF;IACxB,kCAAkC;IAClC,MAAMI,cAAcD,IAAAA,gBAAO,EAACD,KAAKH,0BAA0B;QACzDM,kBAAkB;IACpB;IACA,IAAID,YAAYE,MAAM,KAAK,GAAG;QAC5B;IACF;IACA,MAAMC,iBAAiBH,WAAW,CAACA,YAAYE,MAAM,GAAG,EAAE;IAE1D,MAAME,qBAAqB,CAAC;;uBAEP,EAAEC,KAAKC,SAAS,CAACZ,cAAc;;;;;;;;GAQnD,CAAC;IAEFP,KAAKoB,KAAK,CACRd,YACA,CAAC,EAAEG,mBAAmBY,KAAK,CAAC,GAAGL,eAAeM,MAAM,IAAI;EAC1D,EAAEL,mBAAmB;EACrB,EAAER,mBAAmBY,KAAK,CAACL,eAAeM,MAAM,IAAI,CAAC;AAEvD"}

package/src/generators/convert-to-inferred/schema.json

@@ -0,0 +1,19 @@
+{
+  "$schema": "https://json-schema.org/schema",
+  "$id": "NxViteConvertToInferred",
+  "description": "Convert existing Vite project(s) using `@nx/vite:*` executors to use `@nx/vite/plugin`. Defaults to migrating all projects. Pass '--project' to migrate only one target.",
+  "title": "Convert Vite project from executor to plugin",
+  "type": "object",
+  "properties": {
+    "project": {
+      "type": "string",
+      "description": "The project to convert from using the `@nx/vite:*` executors to use `@nx/vite/plugin`.",
+      "x-priority": "important"
+    },
+    "skipFormat": {
+      "type": "boolean",
+      "description": "Whether to format files at the end of the migration.",
+      "default": false
+    }
+  }
+}

package/src/generators/init/init.js

@@ -62,7 +62,7 @@ async function initGeneratorInternal(tree, schema) {
     var _addPlugin;
     (_addPlugin = (_schema = schema).addPlugin) != null ? _addPlugin : _schema.addPlugin = addPluginDefault;
     if (schema.addPlugin) {
-        await (0, _addplugin.addPluginV1)(tree, await (0, _devkit.createProjectGraphAsync)(), '@nx/vite/plugin', _plugin.createNodes, {
+        await (0, _addplugin.addPlugin)(tree, await (0, _devkit.createProjectGraphAsync)(), '@nx/vite/plugin', _plugin.createNodesV2, {
             buildTargetName: [
                 'build',
                 'vite:build',

package/src/generators/init/init.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../../../../packages/vite/src/generators/init/init.ts"],"sourcesContent":["import {\n  createProjectGraphAsync,\n  formatFiles,\n  GeneratorCallback,\n  readNxJson,\n  runTasksInSerial,\n  Tree,\n  updateNxJson,\n} from '@nx/devkit';\nimport { addPluginV1 } from '@nx/devkit/src/utils/add-plugin';\n\nimport { setupPathsPlugin } from '../setup-paths-plugin/setup-paths-plugin';\nimport { createNodes } from '../../plugins/plugin';\nimport { InitGeneratorSchema } from './schema';\nimport { checkDependenciesInstalled, moveToDevDependencies } from './lib/utils';\n\nexport function updateNxJsonSettings(tree: Tree) {\n  const nxJson = readNxJson(tree);\n\n  const productionFileSet = nxJson.namedInputs?.production;\n  if (productionFileSet) {\n    productionFileSet.push(\n      '!{projectRoot}/**/?(*.)+(spec|test).[jt]s?(x)?(.snap)',\n      '!{projectRoot}/tsconfig.spec.json'\n    );\n\n    nxJson.namedInputs.production = Array.from(new Set(productionFileSet));\n  }\n\n  const hasPlugin = nxJson.plugins?.some((p) =>\n    typeof p === 'string'\n      ? p === '@nx/vite/plugin'\n      : p.plugin === '@nx/vite/plugin'\n  );\n\n  if (!hasPlugin) {\n    nxJson.targetDefaults ??= {};\n    nxJson.targetDefaults['@nx/vite:test'] ??= {};\n    nxJson.targetDefaults['@nx/vite:test'].cache ??= true;\n    nxJson.targetDefaults['@nx/vite:test'].inputs ??= [\n      'default',\n      productionFileSet ? '^production' : '^default',\n    ];\n  }\n\n  updateNxJson(tree, nxJson);\n}\n\nexport function initGenerator(tree: Tree, schema: InitGeneratorSchema) {\n  return initGeneratorInternal(tree, { addPlugin: false, ...schema });\n}\n\nexport async function initGeneratorInternal(\n  tree: Tree,\n  schema: InitGeneratorSchema\n) {\n  const nxJson = readNxJson(tree);\n  const addPluginDefault =\n    process.env.NX_ADD_PLUGINS !== 'false' &&\n    nxJson.useInferencePlugins !== false;\n  schema.addPlugin ??= addPluginDefault;\n\n  if (schema.addPlugin) {\n    await addPluginV1(\n      tree,\n      await createProjectGraphAsync(),\n      '@nx/vite/plugin',\n      createNodes,\n      {\n        buildTargetName: ['build', 'vite:build', 'vite-build'],\n        testTargetName: ['test', 'vite:test', 'vite-test'],\n        serveTargetName: ['serve', 'vite:serve', 'vite-serve'],\n        previewTargetName: ['preview', 'vite:preview', 'vite-preview'],\n        serveStaticTargetName: [\n          'serve-static',\n          'vite:serve-static',\n          'vite-serve-static',\n        ],\n      },\n      schema.updatePackageScripts\n    );\n  }\n\n  updateNxJsonSettings(tree);\n\n  if (schema.setupPathsPlugin) {\n    await setupPathsPlugin(tree, { skipFormat: true });\n  }\n\n  const tasks: GeneratorCallback[] = [];\n  if (!schema.skipPackageJson) {\n    tasks.push(moveToDevDependencies(tree));\n    tasks.push(checkDependenciesInstalled(tree, schema));\n  }\n\n  if (!schema.skipFormat) {\n    await formatFiles(tree);\n  }\n\n  return runTasksInSerial(...tasks);\n}\n\nexport default initGenerator;\n"],"names":["initGenerator","initGeneratorInternal","updateNxJsonSettings","tree","nxJson","readNxJson","productionFileSet","namedInputs","production","push","Array","from","Set","hasPlugin","plugins","some","p","plugin","targetDefaults","cache","inputs","updateNxJson","schema","addPlugin","addPluginDefault","process","env","NX_ADD_PLUGINS","useInferencePlugins","addPluginV1","createProjectGraphAsync","createNodes","buildTargetName","testTargetName","serveTargetName","previewTargetName","serveStaticTargetName","updatePackageScripts","setupPathsPlugin","skipFormat","tasks","skipPackageJson","moveToDevDependencies","checkDependenciesInstalled","formatFiles","runTasksInSerial"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":";;;;;;;;IAsGA,OAA6B;eAA7B;;IAtDgBA,aAAa;eAAbA;;IAIMC,qBAAqB;eAArBA;;IApCNC,oBAAoB;eAApBA;;;;wBART;2BACqB;kCAEK;wBACL;uBAEsC;AAE3D,SAASA,qBAAqBC,IAAU;QAGnBC,qBAURA;IAZlB,MAAMA,SAASC,IAAAA,kBAAU,EAACF;IAE1B,MAAMG,qBAAoBF,sBAAAA,OAAOG,WAAW,qBAAlBH,oBAAoBI,UAAU;IACxD,IAAIF,mBAAmB;QACrBA,kBAAkBG,IAAI,CACpB,yDACA;QAGFL,OAAOG,WAAW,CAACC,UAAU,GAAGE,MAAMC,IAAI,CAAC,IAAIC,IAAIN;IACrD;IAEA,MAAMO,aAAYT,kBAAAA,OAAOU,OAAO,qBAAdV,gBAAgBW,IAAI,CAAC,CAACC,IACtC,OAAOA,MAAM,WACTA,MAAM,oBACNA,EAAEC,MAAM,KAAK;IAGnB,IAAI,CAACJ,WAAW;YACdT,SACAA,wBAAsB,aACtBA,mCACAA;;QAHAA,oBAAAA,UAAAA,QAAOc,4CAAPd,QAAOc,iBAAmB,CAAC;;QAC3Bd,MAAAA,yBAAAA,OAAOc,cAAc,CAAA,CAAC,cAAA,gBAAgB,gBAAtCd,sBAAqB,CAAC,YAAgB,GAAK,CAAC;;QAC5CA,WAAAA,oCAAAA,OAAOc,cAAc,CAAC,gBAAgB,EAACC,0BAAvCf,kCAAuCe,QAAU;;QACjDf,YAAAA,qCAAAA,OAAOc,cAAc,CAAC,gBAAgB,EAACE,4BAAvChB,mCAAuCgB,SAAW;YAChD;YACAd,oBAAoB,gBAAgB;SACrC;IACH;IAEAe,IAAAA,oBAAY,EAAClB,MAAMC;AACrB;AAEO,SAASJ,cAAcG,IAAU,EAAEmB,MAA2B;IACnE,OAAOrB,sBAAsBE,MAAM;QAAEoB,WAAW;OAAUD;AAC5D;AAEO,eAAerB,sBACpBE,IAAU,EACVmB,MAA2B;QAM3BA;IAJA,MAAMlB,SAASC,IAAAA,kBAAU,EAACF;IAC1B,MAAMqB,mBACJC,QAAQC,GAAG,CAACC,cAAc,KAAK,WAC/BvB,OAAOwB,mBAAmB,KAAK;;IACjCN,eAAAA,UAAAA,QAAOC,kCAAPD,QAAOC,YAAcC;IAErB,IAAIF,OAAOC,SAAS,EAAE;QACpB,MAAMM,IAAAA,sBAAW,EACf1B,MACA,MAAM2B,IAAAA,+BAAuB,KAC7B,mBACAC,mBAAW,EACX;YACEC,iBAAiB;gBAAC;gBAAS;gBAAc;aAAa;YACtDC,gBAAgB;gBAAC;gBAAQ;gBAAa;aAAY;YAClDC,iBAAiB;gBAAC;gBAAS;gBAAc;aAAa;YACtDC,mBAAmB;gBAAC;gBAAW;gBAAgB;aAAe;YAC9DC,uBAAuB;gBACrB;gBACA;gBACA;aACD;QACH,GACAd,OAAOe,oBAAoB;IAE/B;IAEAnC,qBAAqBC;IAErB,IAAImB,OAAOgB,gBAAgB,EAAE;QAC3B,MAAMA,IAAAA,kCAAgB,EAACnC,MAAM;YAAEoC,YAAY;QAAK;IAClD;IAEA,MAAMC,QAA6B,EAAE;IACrC,IAAI,CAAClB,OAAOmB,eAAe,EAAE;QAC3BD,MAAM/B,IAAI,CAACiC,IAAAA,4BAAqB,EAACvC;QACjCqC,MAAM/B,IAAI,CAACkC,IAAAA,iCAA0B,EAACxC,MAAMmB;IAC9C;IAEA,IAAI,CAACA,OAAOiB,UAAU,EAAE;QACtB,MAAMK,IAAAA,mBAAW,EAACzC;IACpB;IAEA,OAAO0C,IAAAA,wBAAgB,KAAIL;AAC7B;MAEA,WAAexC"}
+{"version":3,"sources":["../../../../../../packages/vite/src/generators/init/init.ts"],"sourcesContent":["import {\n  createProjectGraphAsync,\n  formatFiles,\n  GeneratorCallback,\n  readNxJson,\n  runTasksInSerial,\n  Tree,\n  updateNxJson,\n} from '@nx/devkit';\nimport { addPlugin } from '@nx/devkit/src/utils/add-plugin';\n\nimport { setupPathsPlugin } from '../setup-paths-plugin/setup-paths-plugin';\nimport { createNodesV2 } from '../../plugins/plugin';\nimport { InitGeneratorSchema } from './schema';\nimport { checkDependenciesInstalled, moveToDevDependencies } from './lib/utils';\n\nexport function updateNxJsonSettings(tree: Tree) {\n  const nxJson = readNxJson(tree);\n\n  const productionFileSet = nxJson.namedInputs?.production;\n  if (productionFileSet) {\n    productionFileSet.push(\n      '!{projectRoot}/**/?(*.)+(spec|test).[jt]s?(x)?(.snap)',\n      '!{projectRoot}/tsconfig.spec.json'\n    );\n\n    nxJson.namedInputs.production = Array.from(new Set(productionFileSet));\n  }\n\n  const hasPlugin = nxJson.plugins?.some((p) =>\n    typeof p === 'string'\n      ? p === '@nx/vite/plugin'\n      : p.plugin === '@nx/vite/plugin'\n  );\n\n  if (!hasPlugin) {\n    nxJson.targetDefaults ??= {};\n    nxJson.targetDefaults['@nx/vite:test'] ??= {};\n    nxJson.targetDefaults['@nx/vite:test'].cache ??= true;\n    nxJson.targetDefaults['@nx/vite:test'].inputs ??= [\n      'default',\n      productionFileSet ? '^production' : '^default',\n    ];\n  }\n\n  updateNxJson(tree, nxJson);\n}\n\nexport function initGenerator(tree: Tree, schema: InitGeneratorSchema) {\n  return initGeneratorInternal(tree, { addPlugin: false, ...schema });\n}\n\nexport async function initGeneratorInternal(\n  tree: Tree,\n  schema: InitGeneratorSchema\n) {\n  const nxJson = readNxJson(tree);\n  const addPluginDefault =\n    process.env.NX_ADD_PLUGINS !== 'false' &&\n    nxJson.useInferencePlugins !== false;\n  schema.addPlugin ??= addPluginDefault;\n\n  if (schema.addPlugin) {\n    await addPlugin(\n      tree,\n      await createProjectGraphAsync(),\n      '@nx/vite/plugin',\n      createNodesV2,\n      {\n        buildTargetName: ['build', 'vite:build', 'vite-build'],\n        testTargetName: ['test', 'vite:test', 'vite-test'],\n        serveTargetName: ['serve', 'vite:serve', 'vite-serve'],\n        previewTargetName: ['preview', 'vite:preview', 'vite-preview'],\n        serveStaticTargetName: [\n          'serve-static',\n          'vite:serve-static',\n          'vite-serve-static',\n        ],\n      },\n      schema.updatePackageScripts\n    );\n  }\n\n  updateNxJsonSettings(tree);\n\n  if (schema.setupPathsPlugin) {\n    await setupPathsPlugin(tree, { skipFormat: true });\n  }\n\n  const tasks: GeneratorCallback[] = [];\n  if (!schema.skipPackageJson) {\n    tasks.push(moveToDevDependencies(tree));\n    tasks.push(checkDependenciesInstalled(tree, schema));\n  }\n\n  if (!schema.skipFormat) {\n    await formatFiles(tree);\n  }\n\n  return runTasksInSerial(...tasks);\n}\n\nexport default initGenerator;\n"],"names":["initGenerator","initGeneratorInternal","updateNxJsonSettings","tree","nxJson","readNxJson","productionFileSet","namedInputs","production","push","Array","from","Set","hasPlugin","plugins","some","p","plugin","targetDefaults","cache","inputs","updateNxJson","schema","addPlugin","addPluginDefault","process","env","NX_ADD_PLUGINS","useInferencePlugins","createProjectGraphAsync","createNodesV2","buildTargetName","testTargetName","serveTargetName","previewTargetName","serveStaticTargetName","updatePackageScripts","setupPathsPlugin","skipFormat","tasks","skipPackageJson","moveToDevDependencies","checkDependenciesInstalled","formatFiles","runTasksInSerial"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":";;;;;;;;IAsGA,OAA6B;eAA7B;;IAtDgBA,aAAa;eAAbA;;IAIMC,qBAAqB;eAArBA;;IApCNC,oBAAoB;eAApBA;;;;wBART;2BACmB;kCAEO;wBACH;uBAEoC;AAE3D,SAASA,qBAAqBC,IAAU;QAGnBC,qBAURA;IAZlB,MAAMA,SAASC,IAAAA,kBAAU,EAACF;IAE1B,MAAMG,qBAAoBF,sBAAAA,OAAOG,WAAW,qBAAlBH,oBAAoBI,UAAU;IACxD,IAAIF,mBAAmB;QACrBA,kBAAkBG,IAAI,CACpB,yDACA;QAGFL,OAAOG,WAAW,CAACC,UAAU,GAAGE,MAAMC,IAAI,CAAC,IAAIC,IAAIN;IACrD;IAEA,MAAMO,aAAYT,kBAAAA,OAAOU,OAAO,qBAAdV,gBAAgBW,IAAI,CAAC,CAACC,IACtC,OAAOA,MAAM,WACTA,MAAM,oBACNA,EAAEC,MAAM,KAAK;IAGnB,IAAI,CAACJ,WAAW;YACdT,SACAA,wBAAsB,aACtBA,mCACAA;;QAHAA,oBAAAA,UAAAA,QAAOc,4CAAPd,QAAOc,iBAAmB,CAAC;;QAC3Bd,MAAAA,yBAAAA,OAAOc,cAAc,CAAA,CAAC,cAAA,gBAAgB,gBAAtCd,sBAAqB,CAAC,YAAgB,GAAK,CAAC;;QAC5CA,WAAAA,oCAAAA,OAAOc,cAAc,CAAC,gBAAgB,EAACC,0BAAvCf,kCAAuCe,QAAU;;QACjDf,YAAAA,qCAAAA,OAAOc,cAAc,CAAC,gBAAgB,EAACE,4BAAvChB,mCAAuCgB,SAAW;YAChD;YACAd,oBAAoB,gBAAgB;SACrC;IACH;IAEAe,IAAAA,oBAAY,EAAClB,MAAMC;AACrB;AAEO,SAASJ,cAAcG,IAAU,EAAEmB,MAA2B;IACnE,OAAOrB,sBAAsBE,MAAM;QAAEoB,WAAW;OAAUD;AAC5D;AAEO,eAAerB,sBACpBE,IAAU,EACVmB,MAA2B;QAM3BA;IAJA,MAAMlB,SAASC,IAAAA,kBAAU,EAACF;IAC1B,MAAMqB,mBACJC,QAAQC,GAAG,CAACC,cAAc,KAAK,WAC/BvB,OAAOwB,mBAAmB,KAAK;;IACjCN,eAAAA,UAAAA,QAAOC,kCAAPD,QAAOC,YAAcC;IAErB,IAAIF,OAAOC,SAAS,EAAE;QACpB,MAAMA,IAAAA,oBAAS,EACbpB,MACA,MAAM0B,IAAAA,+BAAuB,KAC7B,mBACAC,qBAAa,EACb;YACEC,iBAAiB;gBAAC;gBAAS;gBAAc;aAAa;YACtDC,gBAAgB;gBAAC;gBAAQ;gBAAa;aAAY;YAClDC,iBAAiB;gBAAC;gBAAS;gBAAc;aAAa;YACtDC,mBAAmB;gBAAC;gBAAW;gBAAgB;aAAe;YAC9DC,uBAAuB;gBACrB;gBACA;gBACA;aACD;QACH,GACAb,OAAOc,oBAAoB;IAE/B;IAEAlC,qBAAqBC;IAErB,IAAImB,OAAOe,gBAAgB,EAAE;QAC3B,MAAMA,IAAAA,kCAAgB,EAAClC,MAAM;YAAEmC,YAAY;QAAK;IAClD;IAEA,MAAMC,QAA6B,EAAE;IACrC,IAAI,CAACjB,OAAOkB,eAAe,EAAE;QAC3BD,MAAM9B,IAAI,CAACgC,IAAAA,4BAAqB,EAACtC;QACjCoC,MAAM9B,IAAI,CAACiC,IAAAA,iCAA0B,EAACvC,MAAMmB;IAC9C;IAEA,IAAI,CAACA,OAAOgB,UAAU,EAAE;QACtB,MAAMK,IAAAA,mBAAW,EAACxC;IACpB;IAEA,OAAOyC,IAAAA,wBAAgB,KAAIL;AAC7B;MAEA,WAAevC"}

package/src/generators/setup-paths-plugin/setup-paths-plugin.js

@@ -31,6 +31,9 @@ function ensureImportExists(tree, file) {
     let content = tree.read(file, 'utf-8');
     const ast = tsquery.ast(content);
     const allImports = tsquery.query(ast, 'ImportDeclaration');
+    if (content.includes('@nx/vite/plugins/nx-tsconfig-paths.plugin')) {
+        return;
+    }
     if (allImports.length) {
         const lastImport = allImports[allImports.length - 1];
         tree.write(file, (0, _devkit.applyChangesToString)(content, [

package/src/generators/setup-paths-plugin/setup-paths-plugin.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../../../../packages/vite/src/generators/setup-paths-plugin/setup-paths-plugin.ts"],"sourcesContent":["import {\n  applyChangesToString,\n  ChangeType,\n  formatFiles,\n  globAsync,\n  Tree,\n} from '@nx/devkit';\nimport type { ArrayLiteralExpression, Node } from 'typescript';\n\nexport async function setupPathsPlugin(\n  tree: Tree,\n  schema: { skipFormat?: boolean }\n) {\n  const files = await globAsync(tree, [\n    '**/vite.config.{js,ts,mjs,mts,cjs,cts}',\n  ]);\n\n  for (const file of files) {\n    ensureImportExists(tree, file);\n    ensurePluginAdded(tree, file);\n  }\n\n  if (!schema.skipFormat) {\n    await formatFiles(tree);\n  }\n}\n\nfunction ensureImportExists(tree, file) {\n  const { tsquery } = require('@phenomnomnominal/tsquery');\n  let content = tree.read(file, 'utf-8');\n  const ast = tsquery.ast(content);\n  const allImports = tsquery.query(ast, 'ImportDeclaration');\n  if (allImports.length) {\n    const lastImport = allImports[allImports.length - 1];\n    tree.write(\n      file,\n      applyChangesToString(content, [\n        {\n          type: ChangeType.Insert,\n          index: lastImport.end + 1,\n          text: `import { nxViteTsPaths } from '@nx/vite/plugins/nx-tsconfig-paths.plugin';\\n`,\n        },\n      ])\n    );\n  } else {\n    if (file.endsWith('.cts') || file.endsWith('.cjs')) {\n      tree.write(\n        file,\n        applyChangesToString(content, [\n          {\n            type: ChangeType.Insert,\n            index: 0,\n            text: `const { nxViteTsPaths } = require('@nx/vite/plugins/nx-tsconfig-paths.plugin');\\n`,\n          },\n        ])\n      );\n    } else {\n      tree.write(\n        file,\n        applyChangesToString(content, [\n          {\n            type: ChangeType.Insert,\n            index: 0,\n            text: `import { nxViteTsPaths } from '@nx/vite/plugins/nx-tsconfig-paths.plugin';\\n`,\n          },\n        ])\n      );\n    }\n  }\n}\n\nfunction ensurePluginAdded(tree, file) {\n  const { tsquery } = require('@phenomnomnominal/tsquery');\n  const content = tree.read(file, 'utf-8');\n  const ast = tsquery.ast(content);\n  const foundDefineConfig = tsquery.query(\n    ast,\n    'CallExpression:has(Identifier[name=\"defineConfig\"])'\n  );\n  if (!foundDefineConfig.length) return content;\n\n  // Do not update defineConfig if it has an arrow function since it can be tricky and error-prone.\n  const defineUsingArrowFunction = tsquery.query(\n    foundDefineConfig[0],\n    'ArrowFunction'\n  );\n  if (defineUsingArrowFunction.length) return content;\n\n  const propertyAssignments = tsquery.query(\n    foundDefineConfig[0],\n    'PropertyAssignment'\n  );\n\n  if (propertyAssignments.length) {\n    const pluginsNode = tsquery.query(\n      foundDefineConfig[0],\n      'PropertyAssignment:has(Identifier[name=\"plugins\"])'\n    );\n\n    if (pluginsNode.length) {\n      const updated = tsquery.replace(\n        content,\n        'PropertyAssignment:has(Identifier[name=\"plugins\"])',\n        (node: Node) => {\n          const found = tsquery.query(\n            node,\n            'ArrayLiteralExpression'\n          ) as ArrayLiteralExpression[];\n          let updatedPluginsString = '';\n\n          const existingPluginNodes = found?.[0].elements ?? [];\n\n          for (const plugin of existingPluginNodes) {\n            updatedPluginsString += `${plugin.getText()},`;\n          }\n\n          if (\n            !existingPluginNodes?.some((node: Node) =>\n              node.getText().includes('nxViteTsPaths')\n            )\n          ) {\n            updatedPluginsString += ` nxViteTsPaths(),`;\n          }\n\n          return `plugins: [${updatedPluginsString}]`;\n        }\n      );\n      tree.write(file, updated);\n    } else {\n      tree.write(\n        file,\n        applyChangesToString(content, [\n          {\n            type: ChangeType.Insert,\n            index: propertyAssignments[0].getStart(),\n            text: `plugins: [nxViteTsPaths()],\n            `,\n          },\n        ])\n      );\n    }\n  } else {\n    tree.write(\n      file,\n      applyChangesToString(content, [\n        {\n          type: ChangeType.Insert,\n          index: foundDefineConfig[0].getStart() + 14, // length of \"defineConfig(\" + 1\n          text: `plugins: [nxViteTsPaths()],`,\n        },\n      ])\n    );\n  }\n}\n\nexport default setupPathsPlugin;\n"],"names":["setupPathsPlugin","tree","schema","files","globAsync","file","ensureImportExists","ensurePluginAdded","skipFormat","formatFiles","tsquery","require","content","read","ast","allImports","query","length","lastImport","write","applyChangesToString","type","ChangeType","Insert","index","end","text","endsWith","foundDefineConfig","defineUsingArrowFunction","propertyAssignments","pluginsNode","updated","replace","node","found","updatedPluginsString","existingPluginNodes","elements","plugin","getText","some","includes","getStart"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"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"}
+{"version":3,"sources":["../../../../../../packages/vite/src/generators/setup-paths-plugin/setup-paths-plugin.ts"],"sourcesContent":["import {\n  applyChangesToString,\n  ChangeType,\n  formatFiles,\n  globAsync,\n  Tree,\n} from '@nx/devkit';\nimport type { ArrayLiteralExpression, Node } from 'typescript';\n\nexport async function setupPathsPlugin(\n  tree: Tree,\n  schema: { skipFormat?: boolean }\n) {\n  const files = await globAsync(tree, [\n    '**/vite.config.{js,ts,mjs,mts,cjs,cts}',\n  ]);\n\n  for (const file of files) {\n    ensureImportExists(tree, file);\n    ensurePluginAdded(tree, file);\n  }\n\n  if (!schema.skipFormat) {\n    await formatFiles(tree);\n  }\n}\n\nfunction ensureImportExists(tree: Tree, file: string) {\n  const { tsquery } = require('@phenomnomnominal/tsquery');\n  let content = tree.read(file, 'utf-8');\n  const ast = tsquery.ast(content);\n  const allImports = tsquery.query(ast, 'ImportDeclaration');\n  if (content.includes('@nx/vite/plugins/nx-tsconfig-paths.plugin')) {\n    return;\n  }\n  if (allImports.length) {\n    const lastImport = allImports[allImports.length - 1];\n    tree.write(\n      file,\n      applyChangesToString(content, [\n        {\n          type: ChangeType.Insert,\n          index: lastImport.end + 1,\n          text: `import { nxViteTsPaths } from '@nx/vite/plugins/nx-tsconfig-paths.plugin';\\n`,\n        },\n      ])\n    );\n  } else {\n    if (file.endsWith('.cts') || file.endsWith('.cjs')) {\n      tree.write(\n        file,\n        applyChangesToString(content, [\n          {\n            type: ChangeType.Insert,\n            index: 0,\n            text: `const { nxViteTsPaths } = require('@nx/vite/plugins/nx-tsconfig-paths.plugin');\\n`,\n          },\n        ])\n      );\n    } else {\n      tree.write(\n        file,\n        applyChangesToString(content, [\n          {\n            type: ChangeType.Insert,\n            index: 0,\n            text: `import { nxViteTsPaths } from '@nx/vite/plugins/nx-tsconfig-paths.plugin';\\n`,\n          },\n        ])\n      );\n    }\n  }\n}\n\nfunction ensurePluginAdded(tree, file) {\n  const { tsquery } = require('@phenomnomnominal/tsquery');\n  const content = tree.read(file, 'utf-8');\n  const ast = tsquery.ast(content);\n  const foundDefineConfig = tsquery.query(\n    ast,\n    'CallExpression:has(Identifier[name=\"defineConfig\"])'\n  );\n  if (!foundDefineConfig.length) return content;\n\n  // Do not update defineConfig if it has an arrow function since it can be tricky and error-prone.\n  const defineUsingArrowFunction = tsquery.query(\n    foundDefineConfig[0],\n    'ArrowFunction'\n  );\n  if (defineUsingArrowFunction.length) return content;\n\n  const propertyAssignments = tsquery.query(\n    foundDefineConfig[0],\n    'PropertyAssignment'\n  );\n\n  if (propertyAssignments.length) {\n    const pluginsNode = tsquery.query(\n      foundDefineConfig[0],\n      'PropertyAssignment:has(Identifier[name=\"plugins\"])'\n    );\n\n    if (pluginsNode.length) {\n      const updated = tsquery.replace(\n        content,\n        'PropertyAssignment:has(Identifier[name=\"plugins\"])',\n        (node: Node) => {\n          const found = tsquery.query(\n            node,\n            'ArrayLiteralExpression'\n          ) as ArrayLiteralExpression[];\n          let updatedPluginsString = '';\n\n          const existingPluginNodes = found?.[0].elements ?? [];\n\n          for (const plugin of existingPluginNodes) {\n            updatedPluginsString += `${plugin.getText()},`;\n          }\n\n          if (\n            !existingPluginNodes?.some((node: Node) =>\n              node.getText().includes('nxViteTsPaths')\n            )\n          ) {\n            updatedPluginsString += ` nxViteTsPaths(),`;\n          }\n\n          return `plugins: [${updatedPluginsString}]`;\n        }\n      );\n      tree.write(file, updated);\n    } else {\n      tree.write(\n        file,\n        applyChangesToString(content, [\n          {\n            type: ChangeType.Insert,\n            index: propertyAssignments[0].getStart(),\n            text: `plugins: [nxViteTsPaths()],\n            `,\n          },\n        ])\n      );\n    }\n  } else {\n    tree.write(\n      file,\n      applyChangesToString(content, [\n        {\n          type: ChangeType.Insert,\n          index: foundDefineConfig[0].getStart() + 14, // length of \"defineConfig(\" + 1\n          text: `plugins: [nxViteTsPaths()],`,\n        },\n      ])\n    );\n  }\n}\n\nexport default setupPathsPlugin;\n"],"names":["setupPathsPlugin","tree","schema","files","globAsync","file","ensureImportExists","ensurePluginAdded","skipFormat","formatFiles","tsquery","require","content","read","ast","allImports","query","includes","length","lastImport","write","applyChangesToString","type","ChangeType","Insert","index","end","text","endsWith","foundDefineConfig","defineUsingArrowFunction","propertyAssignments","pluginsNode","updated","replace","node","found","updatedPluginsString","existingPluginNodes","elements","plugin","getText","some","getStart"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"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"}

package/src/plugins/plugin.js

@@ -72,13 +72,19 @@ async function createNodesInternal(configFilePath, options, context, targetsCach
     var _;
     (_ = (_targetsCache = targetsCache)[_hash = hash]) != null ? _ : _targetsCache[_hash] = await buildViteTargets(configFilePath, projectRoot, normalizedOptions, context);
     const { targets, metadata } = targetsCache[hash];
+    const project = {
+        root: projectRoot,
+        targets,
+        metadata
+    };
+    // If project is buildable, then the project type.
+    // If it is not buildable, then leave it to other plugins/project.json to set the project type.
+    if (project.targets[options.buildTargetName]) {
+        project.projectType = project.targets[options.serveTargetName] ? 'application' : 'library';
+    }
     return {
         projects: {
-            [projectRoot]: {
-                root: projectRoot,
-                targets,
-                metadata
-            }
+            [projectRoot]: project
         }
     };
 }
@@ -103,10 +109,14 @@ async function buildViteTargets(configFilePath, projectRoot, options, context) {
     // If file is not vitest.config and buildable, create targets for build, serve, preview and serve-static
     const hasRemixPlugin = viteConfig.plugins && viteConfig.plugins.some((p)=>p.name === 'remix');
     if (!configFilePath.includes('vitest.config') && !hasRemixPlugin && isBuildable) {
+        var _viteConfig_build;
         targets[options.buildTargetName] = await buildTarget(options.buildTargetName, namedInputs, buildOutputs, projectRoot);
-        targets[options.serveTargetName] = serveTarget(projectRoot);
-        targets[options.previewTargetName] = previewTarget(projectRoot);
-        targets[options.serveStaticTargetName] = serveStaticTarget(options);
+        // If running in library mode, then there is nothing to serve.
+        if (!((_viteConfig_build = viteConfig.build) == null ? void 0 : _viteConfig_build.lib)) {
+            targets[options.serveTargetName] = serveTarget(projectRoot);
+            targets[options.previewTargetName] = previewTarget(projectRoot);
+            targets[options.serveStaticTargetName] = serveStaticTarget(options);
+        }
     }
     // if file is vitest.config or vite.config has definition for test, create target for test
     if (configFilePath.includes('vitest.config') || hasTest) {

package/src/plugins/plugin.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../../../packages/vite/src/plugins/plugin.ts"],"sourcesContent":["import {\n  CreateDependencies,\n  CreateNodes,\n  CreateNodesContext,\n  createNodesFromFiles,\n  CreateNodesV2,\n  detectPackageManager,\n  joinPathFragments,\n  logger,\n  ProjectConfiguration,\n  readJsonFile,\n  TargetConfiguration,\n  writeJsonFile,\n} from '@nx/devkit';\nimport { dirname, isAbsolute, join, relative } from 'path';\nimport { getNamedInputs } from '@nx/devkit/src/utils/get-named-inputs';\nimport { existsSync, readdirSync } from 'fs';\nimport { calculateHashForCreateNodes } from '@nx/devkit/src/utils/calculate-hash-for-create-nodes';\nimport { workspaceDataDirectory } from 'nx/src/utils/cache-directory';\nimport { getLockFileName } from '@nx/js';\nimport { loadViteDynamicImport } from '../utils/executor-utils';\nimport { hashObject } from 'nx/src/hasher/file-hasher';\n\nexport interface VitePluginOptions {\n  buildTargetName?: string;\n  testTargetName?: string;\n  serveTargetName?: string;\n  previewTargetName?: string;\n  serveStaticTargetName?: string;\n}\ntype ViteTargets = Pick<ProjectConfiguration, 'targets' | 'metadata'>;\n\nfunction readTargetsCache(cachePath: string): Record<string, ViteTargets> {\n  return existsSync(cachePath) ? readJsonFile(cachePath) : {};\n}\n\nfunction writeTargetsToCache(cachePath, results?: Record<string, ViteTargets>) {\n  writeJsonFile(cachePath, results);\n}\n\n/**\n * @deprecated The 'createDependencies' function is now a no-op. This functionality is included in 'createNodesV2'.\n */\nexport const createDependencies: CreateDependencies = () => {\n  return [];\n};\n\nconst viteVitestConfigGlob = '**/{vite,vitest}.config.{js,ts,mjs,mts,cjs,cts}';\n\nexport const createNodesV2: CreateNodesV2<VitePluginOptions> = [\n  viteVitestConfigGlob,\n  async (configFilePaths, options, context) => {\n    const optionsHash = hashObject(options);\n    const cachePath = join(workspaceDataDirectory, `vite-${optionsHash}.hash`);\n    const targetsCache = readTargetsCache(cachePath);\n    try {\n      return await createNodesFromFiles(\n        (configFile, options, context) =>\n          createNodesInternal(configFile, options, context, targetsCache),\n        configFilePaths,\n        options,\n        context\n      );\n    } finally {\n      writeTargetsToCache(cachePath, targetsCache);\n    }\n  },\n];\n\nexport const createNodes: CreateNodes<VitePluginOptions> = [\n  viteVitestConfigGlob,\n  async (configFilePath, options, context) => {\n    logger.warn(\n      '`createNodes` is deprecated. Update your plugin to utilize createNodesV2 instead. In Nx 20, this will change to the createNodesV2 API.'\n    );\n    return createNodesInternal(configFilePath, options, context, {});\n  },\n];\n\nasync function createNodesInternal(\n  configFilePath: string,\n  options: VitePluginOptions,\n  context: CreateNodesContext,\n  targetsCache: Record<string, ViteTargets>\n) {\n  const projectRoot = dirname(configFilePath);\n  // Do not create a project if package.json and project.json isn't there.\n  const siblingFiles = readdirSync(join(context.workspaceRoot, projectRoot));\n  if (\n    !siblingFiles.includes('package.json') &&\n    !siblingFiles.includes('project.json')\n  ) {\n    return {};\n  }\n\n  const normalizedOptions = normalizeOptions(options);\n\n  // We do not want to alter how the hash is calculated, so appending the config file path to the hash\n  // to prevent vite/vitest files overwriting the target cache created by the other\n  const hash =\n    (await calculateHashForCreateNodes(\n      projectRoot,\n      normalizedOptions,\n      context,\n      [getLockFileName(detectPackageManager(context.workspaceRoot))]\n    )) + configFilePath;\n\n  targetsCache[hash] ??= await buildViteTargets(\n    configFilePath,\n    projectRoot,\n    normalizedOptions,\n    context\n  );\n\n  const { targets, metadata } = targetsCache[hash];\n\n  return {\n    projects: {\n      [projectRoot]: {\n        root: projectRoot,\n        targets,\n        metadata,\n      },\n    },\n  };\n}\n\nasync function buildViteTargets(\n  configFilePath: string,\n  projectRoot: string,\n  options: VitePluginOptions,\n  context: CreateNodesContext\n): Promise<ViteTargets> {\n  const absoluteConfigFilePath = joinPathFragments(\n    context.workspaceRoot,\n    configFilePath\n  );\n\n  // Workaround for the `build$3 is not a function` error that we sometimes see in agents.\n  // This should be removed later once we address the issue properly\n  try {\n    const importEsbuild = () => new Function('return import(\"esbuild\")')();\n    await importEsbuild();\n  } catch {\n    // do nothing\n  }\n  const { resolveConfig } = await loadViteDynamicImport();\n  const viteConfig = await resolveConfig(\n    {\n      configFile: absoluteConfigFilePath,\n      mode: 'development',\n    },\n    'build'\n  );\n\n  const { buildOutputs, testOutputs, hasTest, isBuildable } = getOutputs(\n    viteConfig,\n    projectRoot,\n    context.workspaceRoot\n  );\n\n  const namedInputs = getNamedInputs(projectRoot, context);\n\n  const targets: Record<string, TargetConfiguration> = {};\n\n  // If file is not vitest.config and buildable, create targets for build, serve, preview and serve-static\n  const hasRemixPlugin =\n    viteConfig.plugins && viteConfig.plugins.some((p) => p.name === 'remix');\n  if (\n    !configFilePath.includes('vitest.config') &&\n    !hasRemixPlugin &&\n    isBuildable\n  ) {\n    targets[options.buildTargetName] = await buildTarget(\n      options.buildTargetName,\n      namedInputs,\n      buildOutputs,\n      projectRoot\n    );\n\n    targets[options.serveTargetName] = serveTarget(projectRoot);\n\n    targets[options.previewTargetName] = previewTarget(projectRoot);\n\n    targets[options.serveStaticTargetName] = serveStaticTarget(options) as {};\n  }\n\n  // if file is vitest.config or vite.config has definition for test, create target for test\n  if (configFilePath.includes('vitest.config') || hasTest) {\n    targets[options.testTargetName] = await testTarget(\n      namedInputs,\n      testOutputs,\n      projectRoot\n    );\n  }\n\n  const metadata = {};\n  return { targets, metadata };\n}\n\nasync function buildTarget(\n  buildTargetName: string,\n  namedInputs: {\n    [inputName: string]: any[];\n  },\n  outputs: string[],\n  projectRoot: string\n) {\n  return {\n    command: `vite build`,\n    options: { cwd: joinPathFragments(projectRoot) },\n    cache: true,\n    dependsOn: [`^${buildTargetName}`],\n    inputs: [\n      ...('production' in namedInputs\n        ? ['production', '^production']\n        : ['default', '^default']),\n      {\n        externalDependencies: ['vite'],\n      },\n    ],\n    outputs,\n  };\n}\n\nfunction serveTarget(projectRoot: string) {\n  const targetConfig: TargetConfiguration = {\n    command: `vite serve`,\n    options: {\n      cwd: joinPathFragments(projectRoot),\n    },\n  };\n\n  return targetConfig;\n}\n\nfunction previewTarget(projectRoot: string) {\n  const targetConfig: TargetConfiguration = {\n    command: `vite preview`,\n    options: {\n      cwd: joinPathFragments(projectRoot),\n    },\n  };\n\n  return targetConfig;\n}\n\nasync function testTarget(\n  namedInputs: {\n    [inputName: string]: any[];\n  },\n  outputs: string[],\n  projectRoot: string\n) {\n  return {\n    command: `vitest`,\n    options: { cwd: joinPathFragments(projectRoot) },\n    cache: true,\n    inputs: [\n      ...('production' in namedInputs\n        ? ['default', '^production']\n        : ['default', '^default']),\n      {\n        externalDependencies: ['vitest'],\n      },\n      { env: 'CI' },\n    ],\n    outputs,\n  };\n}\n\nfunction serveStaticTarget(options: VitePluginOptions) {\n  const targetConfig: TargetConfiguration = {\n    executor: '@nx/web:file-server',\n    options: {\n      buildTarget: `${options.buildTargetName}`,\n      spa: true,\n    },\n  };\n\n  return targetConfig;\n}\n\nfunction getOutputs(\n  viteConfig: Record<string, any> | undefined,\n  projectRoot: string,\n  workspaceRoot: string\n): {\n  buildOutputs: string[];\n  testOutputs: string[];\n  hasTest: boolean;\n  isBuildable: boolean;\n} {\n  const { build, test } = viteConfig;\n\n  const buildOutputPath = normalizeOutputPath(\n    build?.outDir,\n    projectRoot,\n    workspaceRoot,\n    'dist'\n  );\n\n  const isBuildable =\n    build?.lib ||\n    build?.rollupOptions?.inputs ||\n    existsSync(join(workspaceRoot, projectRoot, 'index.html'));\n\n  const reportsDirectoryPath = normalizeOutputPath(\n    test?.coverage?.reportsDirectory,\n    projectRoot,\n    workspaceRoot,\n    'coverage'\n  );\n\n  return {\n    buildOutputs: [buildOutputPath],\n    testOutputs: [reportsDirectoryPath],\n    hasTest: !!test,\n    isBuildable,\n  };\n}\n\nfunction normalizeOutputPath(\n  outputPath: string | undefined,\n  projectRoot: string,\n  workspaceRoot: string,\n  path: 'coverage' | 'dist'\n): string | undefined {\n  if (!outputPath) {\n    if (projectRoot === '.') {\n      return `{projectRoot}/${path}`;\n    } else {\n      return `{workspaceRoot}/${path}/{projectRoot}`;\n    }\n  } else {\n    if (isAbsolute(outputPath)) {\n      return `{workspaceRoot}/${relative(workspaceRoot, outputPath)}`;\n    } else {\n      if (outputPath.startsWith('..')) {\n        return join('{workspaceRoot}', join(projectRoot, outputPath));\n      } else {\n        return join('{projectRoot}', outputPath);\n      }\n    }\n  }\n}\n\nfunction normalizeOptions(options: VitePluginOptions): VitePluginOptions {\n  options ??= {};\n  options.buildTargetName ??= 'build';\n  options.serveTargetName ??= 'serve';\n  options.previewTargetName ??= 'preview';\n  options.testTargetName ??= 'test';\n  options.serveStaticTargetName ??= 'serve-static';\n  return options;\n}\n"],"names":["createDependencies","createNodes","createNodesV2","readTargetsCache","cachePath","existsSync","readJsonFile","writeTargetsToCache","results","writeJsonFile","viteVitestConfigGlob","configFilePaths","options","context","optionsHash","hashObject","join","workspaceDataDirectory","targetsCache","createNodesFromFiles","configFile","createNodesInternal","configFilePath","logger","warn","hash","projectRoot","dirname","siblingFiles","readdirSync","workspaceRoot","includes","normalizedOptions","normalizeOptions","calculateHashForCreateNodes","getLockFileName","detectPackageManager","buildViteTargets","targets","metadata","projects","root","absoluteConfigFilePath","joinPathFragments","importEsbuild","Function","resolveConfig","loadViteDynamicImport","viteConfig","mode","buildOutputs","testOutputs","hasTest","isBuildable","getOutputs","namedInputs","getNamedInputs","hasRemixPlugin","plugins","some","p","name","buildTargetName","buildTarget","serveTargetName","serveTarget","previewTargetName","previewTarget","serveStaticTargetName","serveStaticTarget","testTargetName","testTarget","outputs","command","cwd","cache","dependsOn","inputs","externalDependencies","targetConfig","env","executor","spa","build","test","buildOutputPath","normalizeOutputPath","outDir","lib","rollupOptions","reportsDirectoryPath","coverage","reportsDirectory","outputPath","path","isAbsolute","relative","startsWith"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"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"}
+{"version":3,"sources":["../../../../../packages/vite/src/plugins/plugin.ts"],"sourcesContent":["import {\n  CreateDependencies,\n  CreateNodes,\n  CreateNodesContext,\n  createNodesFromFiles,\n  CreateNodesV2,\n  detectPackageManager,\n  joinPathFragments,\n  logger,\n  ProjectConfiguration,\n  readJsonFile,\n  TargetConfiguration,\n  writeJsonFile,\n} from '@nx/devkit';\nimport { dirname, isAbsolute, join, relative } from 'path';\nimport { getNamedInputs } from '@nx/devkit/src/utils/get-named-inputs';\nimport { existsSync, readdirSync } from 'fs';\nimport { calculateHashForCreateNodes } from '@nx/devkit/src/utils/calculate-hash-for-create-nodes';\nimport { workspaceDataDirectory } from 'nx/src/utils/cache-directory';\nimport { getLockFileName } from '@nx/js';\nimport { loadViteDynamicImport } from '../utils/executor-utils';\nimport { hashObject } from 'nx/src/hasher/file-hasher';\n\nexport interface VitePluginOptions {\n  buildTargetName?: string;\n  testTargetName?: string;\n  serveTargetName?: string;\n  previewTargetName?: string;\n  serveStaticTargetName?: string;\n}\ntype ViteTargets = Pick<ProjectConfiguration, 'targets' | 'metadata'>;\n\nfunction readTargetsCache(cachePath: string): Record<string, ViteTargets> {\n  return existsSync(cachePath) ? readJsonFile(cachePath) : {};\n}\n\nfunction writeTargetsToCache(cachePath, results?: Record<string, ViteTargets>) {\n  writeJsonFile(cachePath, results);\n}\n\n/**\n * @deprecated The 'createDependencies' function is now a no-op. This functionality is included in 'createNodesV2'.\n */\nexport const createDependencies: CreateDependencies = () => {\n  return [];\n};\n\nconst viteVitestConfigGlob = '**/{vite,vitest}.config.{js,ts,mjs,mts,cjs,cts}';\n\nexport const createNodesV2: CreateNodesV2<VitePluginOptions> = [\n  viteVitestConfigGlob,\n  async (configFilePaths, options, context) => {\n    const optionsHash = hashObject(options);\n    const cachePath = join(workspaceDataDirectory, `vite-${optionsHash}.hash`);\n    const targetsCache = readTargetsCache(cachePath);\n    try {\n      return await createNodesFromFiles(\n        (configFile, options, context) =>\n          createNodesInternal(configFile, options, context, targetsCache),\n        configFilePaths,\n        options,\n        context\n      );\n    } finally {\n      writeTargetsToCache(cachePath, targetsCache);\n    }\n  },\n];\n\nexport const createNodes: CreateNodes<VitePluginOptions> = [\n  viteVitestConfigGlob,\n  async (configFilePath, options, context) => {\n    logger.warn(\n      '`createNodes` is deprecated. Update your plugin to utilize createNodesV2 instead. In Nx 20, this will change to the createNodesV2 API.'\n    );\n    return createNodesInternal(configFilePath, options, context, {});\n  },\n];\n\nasync function createNodesInternal(\n  configFilePath: string,\n  options: VitePluginOptions,\n  context: CreateNodesContext,\n  targetsCache: Record<string, ViteTargets>\n) {\n  const projectRoot = dirname(configFilePath);\n  // Do not create a project if package.json and project.json isn't there.\n  const siblingFiles = readdirSync(join(context.workspaceRoot, projectRoot));\n  if (\n    !siblingFiles.includes('package.json') &&\n    !siblingFiles.includes('project.json')\n  ) {\n    return {};\n  }\n\n  const normalizedOptions = normalizeOptions(options);\n\n  // We do not want to alter how the hash is calculated, so appending the config file path to the hash\n  // to prevent vite/vitest files overwriting the target cache created by the other\n  const hash =\n    (await calculateHashForCreateNodes(\n      projectRoot,\n      normalizedOptions,\n      context,\n      [getLockFileName(detectPackageManager(context.workspaceRoot))]\n    )) + configFilePath;\n\n  targetsCache[hash] ??= await buildViteTargets(\n    configFilePath,\n    projectRoot,\n    normalizedOptions,\n    context\n  );\n\n  const { targets, metadata } = targetsCache[hash];\n  const project: ProjectConfiguration = {\n    root: projectRoot,\n    targets,\n    metadata,\n  };\n\n  // If project is buildable, then the project type.\n  // If it is not buildable, then leave it to other plugins/project.json to set the project type.\n  if (project.targets[options.buildTargetName]) {\n    project.projectType = project.targets[options.serveTargetName]\n      ? 'application'\n      : 'library';\n  }\n\n  return {\n    projects: {\n      [projectRoot]: project,\n    },\n  };\n}\n\nasync function buildViteTargets(\n  configFilePath: string,\n  projectRoot: string,\n  options: VitePluginOptions,\n  context: CreateNodesContext\n): Promise<ViteTargets> {\n  const absoluteConfigFilePath = joinPathFragments(\n    context.workspaceRoot,\n    configFilePath\n  );\n  // Workaround for the `build$3 is not a function` error that we sometimes see in agents.\n  // This should be removed later once we address the issue properly\n  try {\n    const importEsbuild = () => new Function('return import(\"esbuild\")')();\n    await importEsbuild();\n  } catch {\n    // do nothing\n  }\n  const { resolveConfig } = await loadViteDynamicImport();\n  const viteConfig = await resolveConfig(\n    {\n      configFile: absoluteConfigFilePath,\n      mode: 'development',\n    },\n    'build'\n  );\n\n  const { buildOutputs, testOutputs, hasTest, isBuildable } = getOutputs(\n    viteConfig,\n    projectRoot,\n    context.workspaceRoot\n  );\n\n  const namedInputs = getNamedInputs(projectRoot, context);\n\n  const targets: Record<string, TargetConfiguration> = {};\n\n  // If file is not vitest.config and buildable, create targets for build, serve, preview and serve-static\n  const hasRemixPlugin =\n    viteConfig.plugins && viteConfig.plugins.some((p) => p.name === 'remix');\n  if (\n    !configFilePath.includes('vitest.config') &&\n    !hasRemixPlugin &&\n    isBuildable\n  ) {\n    targets[options.buildTargetName] = await buildTarget(\n      options.buildTargetName,\n      namedInputs,\n      buildOutputs,\n      projectRoot\n    );\n\n    // If running in library mode, then there is nothing to serve.\n    if (!viteConfig.build?.lib) {\n      targets[options.serveTargetName] = serveTarget(projectRoot);\n      targets[options.previewTargetName] = previewTarget(projectRoot);\n      targets[options.serveStaticTargetName] = serveStaticTarget(options) as {};\n    }\n  }\n\n  // if file is vitest.config or vite.config has definition for test, create target for test\n  if (configFilePath.includes('vitest.config') || hasTest) {\n    targets[options.testTargetName] = await testTarget(\n      namedInputs,\n      testOutputs,\n      projectRoot\n    );\n  }\n\n  const metadata = {};\n  return { targets, metadata };\n}\n\nasync function buildTarget(\n  buildTargetName: string,\n  namedInputs: {\n    [inputName: string]: any[];\n  },\n  outputs: string[],\n  projectRoot: string\n) {\n  return {\n    command: `vite build`,\n    options: { cwd: joinPathFragments(projectRoot) },\n    cache: true,\n    dependsOn: [`^${buildTargetName}`],\n    inputs: [\n      ...('production' in namedInputs\n        ? ['production', '^production']\n        : ['default', '^default']),\n      {\n        externalDependencies: ['vite'],\n      },\n    ],\n    outputs,\n  };\n}\n\nfunction serveTarget(projectRoot: string) {\n  const targetConfig: TargetConfiguration = {\n    command: `vite serve`,\n    options: {\n      cwd: joinPathFragments(projectRoot),\n    },\n  };\n\n  return targetConfig;\n}\n\nfunction previewTarget(projectRoot: string) {\n  const targetConfig: TargetConfiguration = {\n    command: `vite preview`,\n    options: {\n      cwd: joinPathFragments(projectRoot),\n    },\n  };\n\n  return targetConfig;\n}\n\nasync function testTarget(\n  namedInputs: {\n    [inputName: string]: any[];\n  },\n  outputs: string[],\n  projectRoot: string\n) {\n  return {\n    command: `vitest`,\n    options: { cwd: joinPathFragments(projectRoot) },\n    cache: true,\n    inputs: [\n      ...('production' in namedInputs\n        ? ['default', '^production']\n        : ['default', '^default']),\n      {\n        externalDependencies: ['vitest'],\n      },\n      { env: 'CI' },\n    ],\n    outputs,\n  };\n}\n\nfunction serveStaticTarget(options: VitePluginOptions) {\n  const targetConfig: TargetConfiguration = {\n    executor: '@nx/web:file-server',\n    options: {\n      buildTarget: `${options.buildTargetName}`,\n      spa: true,\n    },\n  };\n\n  return targetConfig;\n}\n\nfunction getOutputs(\n  viteConfig: Record<string, any> | undefined,\n  projectRoot: string,\n  workspaceRoot: string\n): {\n  buildOutputs: string[];\n  testOutputs: string[];\n  hasTest: boolean;\n  isBuildable: boolean;\n} {\n  const { build, test } = viteConfig;\n\n  const buildOutputPath = normalizeOutputPath(\n    build?.outDir,\n    projectRoot,\n    workspaceRoot,\n    'dist'\n  );\n\n  const isBuildable =\n    build?.lib ||\n    build?.rollupOptions?.inputs ||\n    existsSync(join(workspaceRoot, projectRoot, 'index.html'));\n\n  const reportsDirectoryPath = normalizeOutputPath(\n    test?.coverage?.reportsDirectory,\n    projectRoot,\n    workspaceRoot,\n    'coverage'\n  );\n\n  return {\n    buildOutputs: [buildOutputPath],\n    testOutputs: [reportsDirectoryPath],\n    hasTest: !!test,\n    isBuildable,\n  };\n}\n\nfunction normalizeOutputPath(\n  outputPath: string | undefined,\n  projectRoot: string,\n  workspaceRoot: string,\n  path: 'coverage' | 'dist'\n): string | undefined {\n  if (!outputPath) {\n    if (projectRoot === '.') {\n      return `{projectRoot}/${path}`;\n    } else {\n      return `{workspaceRoot}/${path}/{projectRoot}`;\n    }\n  } else {\n    if (isAbsolute(outputPath)) {\n      return `{workspaceRoot}/${relative(workspaceRoot, outputPath)}`;\n    } else {\n      if (outputPath.startsWith('..')) {\n        return join('{workspaceRoot}', join(projectRoot, outputPath));\n      } else {\n        return join('{projectRoot}', outputPath);\n      }\n    }\n  }\n}\n\nfunction normalizeOptions(options: VitePluginOptions): VitePluginOptions {\n  options ??= {};\n  options.buildTargetName ??= 'build';\n  options.serveTargetName ??= 'serve';\n  options.previewTargetName ??= 'preview';\n  options.testTargetName ??= 'test';\n  options.serveStaticTargetName ??= 'serve-static';\n  return options;\n}\n"],"names":["createDependencies","createNodes","createNodesV2","readTargetsCache","cachePath","existsSync","readJsonFile","writeTargetsToCache","results","writeJsonFile","viteVitestConfigGlob","configFilePaths","options","context","optionsHash","hashObject","join","workspaceDataDirectory","targetsCache","createNodesFromFiles","configFile","createNodesInternal","configFilePath","logger","warn","hash","projectRoot","dirname","siblingFiles","readdirSync","workspaceRoot","includes","normalizedOptions","normalizeOptions","calculateHashForCreateNodes","getLockFileName","detectPackageManager","buildViteTargets","targets","metadata","project","root","buildTargetName","projectType","serveTargetName","projects","absoluteConfigFilePath","joinPathFragments","importEsbuild","Function","resolveConfig","loadViteDynamicImport","viteConfig","mode","buildOutputs","testOutputs","hasTest","isBuildable","getOutputs","namedInputs","getNamedInputs","hasRemixPlugin","plugins","some","p","name","buildTarget","build","lib","serveTarget","previewTargetName","previewTarget","serveStaticTargetName","serveStaticTarget","testTargetName","testTarget","outputs","command","cwd","cache","dependsOn","inputs","externalDependencies","targetConfig","env","executor","spa","test","buildOutputPath","normalizeOutputPath","outDir","rollupOptions","reportsDirectoryPath","coverage","reportsDirectory","outputPath","path","isAbsolute","relative","startsWith"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"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"}