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

package/dist/src/migrations/update-24-0-0/migrate-nx-vite-ts-paths.js

@@ -0,0 +1,154 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = migrateNxViteTsPaths;
+const devkit_1 = require("@nx/devkit");
+const vite_config_edit_utils_1 = require("../../utils/vite-config-edit-utils");
+const version_utils_1 = require("../../utils/version-utils");
+const CONFIG_FILE = /(?:^|\/)(?:vite|vitest)\.config\.[cm]?[jt]s$/;
+const PLUGIN_SPECIFIER = '@nx/vite/plugins/nx-tsconfig-paths.plugin';
+// Generated configs carry a commented-out worker example that calls the plugin.
+const WORKER_EXAMPLE = /^([ \t]*\/\/)\s*plugins: \(\) => \[ nxViteTsPaths\(\) \],[ \t]*$/m;
+async function migrateNxViteTsPaths(tree) {
+    // `resolve.tsconfigPaths` landed in Vite 8. On anything older the option is
+    // ignored, so swapping the plugin for it would silently drop alias
+    // resolution; the prompt picks those workspaces up instead.
+    const installedMajor = (0, version_utils_1.getInstalledViteMajorVersion)(tree);
+    if (!installedMajor || installedMajor < 8) {
+        return;
+    }
+    let changed = false;
+    (0, devkit_1.visitNotIgnoredFiles)(tree, '.', (filePath) => {
+        if (!CONFIG_FILE.test(filePath))
+            return;
+        const original = tree.read(filePath, 'utf-8');
+        if (!original?.includes('nxViteTsPaths'))
+            return;
+        const withResolution = (0, vite_config_edit_utils_1.addTsconfigPathsResolution)(original);
+        if (!(0, vite_config_edit_utils_1.hasTsconfigPathsResolution)(withResolution))
+            return;
+        let updated = removePluginUsage(withResolution);
+        if (updated === withResolution)
+            return;
+        updated = updated.replace(WORKER_EXAMPLE, '$1  plugins: [],');
+        tree.write(filePath, updated);
+        changed = true;
+    });
+    if (changed) {
+        await (0, devkit_1.formatFiles)(tree);
+    }
+}
+/**
+ * Drops every `nxViteTsPaths()` call and its import. Bails on the whole file if
+ * any call sits somewhere other than directly inside an array, since removing
+ * one from an arbitrary expression leaves a syntax hole. The shipped prompt
+ * handles what this leaves behind.
+ */
+function removePluginUsage(content) {
+    const { tsquery } = require('@phenomnomnominal/tsquery');
+    const tsModule = require('typescript');
+    const file = tsquery.ast(content);
+    const importsPlugin = file.statements.some((statement) => {
+        if (tsModule.isImportDeclaration(statement) &&
+            tsModule.isStringLiteral(statement.moduleSpecifier) &&
+            statement.moduleSpecifier.text === PLUGIN_SPECIFIER) {
+            const bindings = statement.importClause?.namedBindings;
+            return (bindings &&
+                tsModule.isNamedImports(bindings) &&
+                bindings.elements.some((element) => !element.propertyName && element.name.text === 'nxViteTsPaths'));
+        }
+        if (!tsModule.isVariableStatement(statement))
+            return false;
+        return statement.declarationList.declarations.some(({ name, initializer }) => tsModule.isObjectBindingPattern(name) &&
+            name.elements.some((element) => !element.propertyName &&
+                element.name.getText() === 'nxViteTsPaths') &&
+            initializer &&
+            tsModule.isCallExpression(initializer) &&
+            initializer.expression.getText() === 'require' &&
+            initializer.arguments.length === 1 &&
+            tsModule.isStringLiteral(initializer.arguments[0]) &&
+            initializer.arguments[0].text === PLUGIN_SPECIFIER);
+    });
+    if (!importsPlugin)
+        return content;
+    const calls = tsquery.query(file, 'CallExpression:has(Identifier[name="nxViteTsPaths"])').filter((call) => call.expression.getText() === 'nxViteTsPaths');
+    if (!calls.length)
+        return content;
+    const arrays = new Map();
+    for (const call of calls) {
+        const parent = call.parent;
+        if (!parent || !tsModule.isArrayLiteralExpression(parent))
+            return content;
+        const siblings = arrays.get(parent) ?? [];
+        siblings.push(call);
+        arrays.set(parent, siblings);
+    }
+    const changes = [];
+    // Reprinting the array from its surviving elements keeps separators valid no
+    // matter how many entries are dropped; formatting is restored afterwards.
+    for (const [array, removed] of arrays) {
+        const survivors = array.elements.filter((element) => !removed.includes(element));
+        changes.push({
+            type: devkit_1.ChangeType.Delete,
+            start: array.getStart(),
+            length: array.getEnd() - array.getStart(),
+        });
+        changes.push({
+            type: devkit_1.ChangeType.Insert,
+            index: array.getStart(),
+            text: `[${survivors.map((element) => element.getText()).join(', ')}]`,
+        });
+    }
+    // A reference outside the removed calls still needs the (inert) stub import.
+    const survivingReference = tsquery.query(file, 'Identifier[name="nxViteTsPaths"]').some((id) => !calls.some((call) => call.expression === id) &&
+        !tsModule.isImportSpecifier(id.parent) &&
+        !tsModule.isBindingElement(id.parent));
+    if (survivingReference)
+        return (0, devkit_1.applyChangesToString)(content, changes);
+    for (const node of findSolePluginImports(tsModule, tsquery, file)) {
+        changes.push({
+            type: devkit_1.ChangeType.Delete,
+            start: node.getStart(),
+            length: trailingNewlineEnd(content, node.getEnd()) - node.getStart(),
+        });
+    }
+    return (0, devkit_1.applyChangesToString)(content, changes);
+}
+/**
+ * Import and require statements that bring in nothing but the plugin. Anything
+ * sharing the statement stays put; an unused binding is harmless next to a
+ * broken one.
+ */
+function findSolePluginImports(tsModule, tsquery, file) {
+    const imports = tsquery.query(file, `ImportDeclaration:has(StringLiteral[value="${PLUGIN_SPECIFIER}"])`);
+    const requires = tsquery.query(file, `VariableStatement:has(StringLiteral[value="${PLUGIN_SPECIFIER}"])`);
+    const sole = [];
+    for (const node of imports) {
+        const bindings = node.importClause?.namedBindings;
+        if (!node.importClause?.name &&
+            bindings &&
+            tsModule.isNamedImports(bindings) &&
+            bindings.elements.length === 1) {
+            sole.push(node);
+        }
+    }
+    for (const node of requires) {
+        const declarations = node.declarationList.declarations;
+        if (declarations.length !== 1)
+            continue;
+        const name = declarations[0].name;
+        if (tsModule.isObjectBindingPattern(name) &&
+            name.elements.length === 1 &&
+            name.elements[0].name.getText() === 'nxViteTsPaths') {
+            sole.push(node);
+        }
+    }
+    return sole;
+}
+function trailingNewlineEnd(content, end) {
+    while (content[end] === ' ' ||
+        content[end] === '\t' ||
+        content[end] === ';') {
+        end++;
+    }
+    return content[end] === '\n' ? end + 1 : end;
+}

package/dist/src/migrations/update-24-0-0/register-typescript-plugin-for-typecheck.d.ts

@@ -0,0 +1,4 @@
+import { type Tree } from '@nx/devkit';
+export default function update(tree: Tree): Promise<{
+    skipAgentic: boolean;
+}>;

package/dist/src/migrations/update-24-0-0/register-typescript-plugin-for-typecheck.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = update;
+const devkit_1 = require("@nx/devkit");
+const internal_1 = require("@nx/js/internal");
+async function update(tree) {
+    if (!(0, internal_1.registerTypescriptPluginForTypecheck)(tree, '@nx/vite/plugin')) {
+        return { skipAgentic: true };
+    }
+    await (0, devkit_1.formatFiles)(tree);
+}

package/dist/src/migrations/update-24-0-0/register-typescript-plugin-for-typecheck.md

@@ -0,0 +1,37 @@
+#### Register `@nx/js/typescript` for typecheck targets
+
+`@nx/vite/plugin` no longer infers a `typecheck` target, except for Vue projects, which keep their `vue-tsc` target. `@nx/js/typescript` provides the `typecheck` target instead, in all workspaces. This migration registers `@nx/js/typescript` with only its typecheck target when the workspace uses `@nx/vite/plugin` and doesn't register `@nx/js/typescript` yet, so your projects keep a `typecheck` target.
+
+The new registration reuses the plugin's `typecheckTargetName` and, when it's `tsgo`, its `compiler`. Registrations with `typecheckTargetName: false` are skipped. `@nx/js/typescript` is registered before `@nx/vite/plugin`, so the Vue projects' `vue-tsc` target wins. Keep that order.
+
+#### Sample code changes
+
+##### Before
+
+```json title="nx.json"
+{
+  "plugins": [
+    {
+      "plugin": "@nx/vite/plugin",
+      "options": { "typecheckTargetName": "typecheck" }
+    }
+  ]
+}
+```
+
+##### After
+
+```json title="nx.json"
+{
+  "plugins": [
+    {
+      "plugin": "@nx/js/typescript",
+      "options": { "typecheck": { "targetName": "typecheck" } }
+    },
+    {
+      "plugin": "@nx/vite/plugin",
+      "options": { "typecheckTargetName": "typecheck" }
+    }
+  ]
+}
+```

package/dist/src/migrations/update-24-0-0/remove-deprecated-executors.d.ts

@@ -0,0 +1,6 @@
+import { type Tree } from '@nx/devkit';
+export default function update(tree: Tree): Promise<{
+    nextSteps?: string[];
+    agentContext?: string[];
+    skipAgentic?: boolean;
+}>;

package/dist/src/migrations/update-24-0-0/remove-deprecated-executors.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = update;
+const devkit_1 = require("@nx/devkit");
+const internal_1 = require("@nx/devkit/internal");
+const viteExecutors = [
+    '@nx/vite:build',
+    '@nx/vite:dev-server',
+    '@nx/vite:preview-server',
+    '@nrwl/vite:build',
+    '@nrwl/vite:dev-server',
+    '@nrwl/vite:preview-server',
+];
+// Earlier @nx/vite migrations rewrite test targets to @nx/vitest:test, but on
+// pnpm @nx/vitest is only transitive, so its own migration may never run.
+const vitestExecutors = ['@nx/vitest:test', '@nx/vite:test', '@nrwl/vite:test'];
+function update(tree) {
+    return (0, internal_1.migrateRemovedExecutors)(tree, [...viteExecutors, ...vitestExecutors], async (tree, options) => {
+        const executors = [...(0, devkit_1.getProjects)(tree).values()].flatMap((project) => Object.values(project.targets ?? {}).map((target) => target.executor));
+        if (executors.some((executor) => viteExecutors.includes(executor))) {
+            const { convertToInferred } = require('../../generators/convert-to-inferred/convert-to-inferred');
+            // The callback only prints the options the converter could not carry
+            // over; migrateRemovedExecutors discards it.
+            await skipUnmigrated(async () => {
+                const flushLogs = await convertToInferred(tree, options);
+                flushLogs();
+            });
+        }
+        if (executors.includes('@nx/vitest:test')) {
+            const { convertVitestToInferred } = require('@nx/vitest/internal');
+            await skipUnmigrated(() => convertVitestToInferred(tree, options));
+        }
+    });
+}
+// A converter that skips every target must not stop the other one; the
+// leftover re-scan in migrateRemovedExecutors still names what it left.
+async function skipUnmigrated(convert) {
+    try {
+        await convert();
+    }
+    catch (error) {
+        if (!(error instanceof internal_1.NoTargetsToMigrateError)) {
+            throw error;
+        }
+    }
+}

package/dist/src/migrations/update-24-0-0/remove-deprecated-executors.md

@@ -0,0 +1,71 @@
+#### Convert `@nx/vite` and `@nx/vitest:test` targets to inferred tasks
+
+Nx 24 removes the `@nx/vite:build`, `@nx/vite:dev-server` and `@nx/vite:preview-server` executors and their `@nrwl` aliases. The migration registers `@nx/vite/plugin` in `nx.json` and converts the targets that use those executors to inferred tasks. It moves build options into `vite.config.*`. It also converts `@nx/vitest:test` targets with the `@nx/vitest` converter, because `@nx/vitest` can be installed only as a transitive dependency and its own migration may not run. A target with nothing left to override is removed from project configuration. When several projects share the same remaining options, those options move to a `targetDefaults` entry scoped to the plugin. `targetDefaults` entries keyed by a removed executor are removed once no target uses that executor.
+
+The migration lists the targets the converter cannot convert safely. In agentic runs, an AI prompt finishes them and validates the project graph.
+
+#### Sample code changes
+
+The `serve` and `preview` targets have no options that differ from the inferred targets, so they are removed.
+
+##### Before
+
+```json title="myapp/project.json"
+{
+  "name": "myapp",
+  "targets": {
+    "build": {
+      "executor": "@nx/vite:build",
+      "outputs": ["{workspaceRoot}/dist/myapp"],
+      "options": {
+        "configFile": "myapp/vite.config.ts"
+      }
+    },
+    "serve": {
+      "executor": "@nx/vite:dev-server",
+      "options": {
+        "buildTarget": "myapp:build"
+      }
+    },
+    "preview": {
+      "executor": "@nx/vite:preview-server",
+      "options": {
+        "buildTarget": "myapp:build"
+      }
+    }
+  }
+}
+```
+
+##### After
+
+```json title="myapp/project.json"
+{
+  "name": "myapp",
+  "targets": {
+    "build": {
+      "options": {
+        "config": "./vite.config.ts"
+      }
+    }
+  }
+}
+```
+
+```json title="nx.json"
+{
+  "plugins": [
+    {
+      "plugin": "@nx/vite/plugin",
+      "options": {
+        "buildTargetName": "build",
+        "devTargetName": "dev",
+        "previewTargetName": "preview",
+        "serveStaticTargetName": "serve-static",
+        "serveTargetName": "serve",
+        "typecheckTargetName": "typecheck"
+      }
+    }
+  ]
+}
+```

package/dist/src/plugins/plugin.d.ts

@@ -8,12 +8,16 @@ export interface VitePluginOptions {
     devTargetName?: string;
     previewTargetName?: string;
     serveStaticTargetName?: string;
-    typecheckTargetName?: string;
     /**
-     * The compiler to use for type-checking. When unset, defaults to `vue-tsc`
-     * for Vue projects (detected via the `vite:vue` plugin) and `tsc` otherwise.
-     * Set to `tsgo` to use the TypeScript Go compiler (`@typescript/native-preview`),
-     * or `vue-tsc` to force Vue-aware type-checking when auto-detection misses your setup.
+     * Name of the `vue-tsc` typecheck target inferred for Vue projects. Other
+     * projects get their typecheck target from `@nx/js/typescript`.
+     */
+    typecheckTargetName?: string | false;
+    /**
+     * The compiler used to typecheck Vue projects. Defaults to `vue-tsc` when the
+     * `vite:vue` plugin is detected. Set `vue-tsc` to force the target when
+     * detection misses your setup, or `tsc`/`tsgo` to skip it and rely on
+     * `@nx/js/typescript`.
      */
     compiler?: 'tsc' | 'tsgo' | 'vue-tsc';
     watchDepsTargetName?: string;

package/dist/src/plugins/plugin.js

@@ -108,7 +108,8 @@ async function buildViteTargets(configFilePath, projectRoot, options, tsConfigFi
         targets[options.buildTargetName] = await buildTarget(options.buildTargetName, namedInputs, buildOutputs, projectRoot, isUsingTsSolutionSetup, pmc);
         // If running in library mode, then there is nothing to serve.
         if (!viteBuildConfig.build?.lib || hasServeConfig) {
-            const devTarget = serveTarget(projectRoot, isUsingTsSolutionSetup, pmc, namedInputs);
+            const signals = !!viteBuildConfig.plugins?.some((p) => p.name === 'nx-ready-signal');
+            const devTarget = serveTarget(projectRoot, configFilePath, signals, isUsingTsSolutionSetup, pmc, namedInputs);
             targets[options.serveTargetName] = {
                 ...devTarget,
                 metadata: {
@@ -117,55 +118,44 @@ async function buildViteTargets(configFilePath, projectRoot, options, tsConfigFi
                 },
             };
             targets[options.devTargetName] = devTarget;
-            targets[options.previewTargetName] = previewTarget(projectRoot, options.buildTargetName, pmc, namedInputs);
+            targets[options.previewTargetName] = previewTarget(projectRoot, configFilePath, signals, options.buildTargetName, pmc, namedInputs);
             targets[options.serveStaticTargetName] = serveStaticTarget(options, isUsingTsSolutionSetup, namedInputs);
         }
     }
-    if (tsConfigFiles.length) {
-        const tsConfigToUse = ['tsconfig.app.json', 'tsconfig.lib.json', 'tsconfig.json'].find((t) => tsConfigFiles.includes(t)) ?? tsConfigFiles[0];
-        // Check if the project uses Vue plugin
-        const hasVuePlugin = viteBuildConfig.plugins?.some((p) => p.name === 'vite:vue' || p.name === 'vite:vue2');
-        // Explicit `compiler` option wins over inference so users can override
-        // when their setup isn't detected (e.g. custom/non-standard Vue plugin).
-        const resolvedCompiler = options.compiler ?? (hasVuePlugin ? 'vue-tsc' : 'tsc');
-        const typeCheckCommand = resolvedCompiler;
-        const typeCheckExternalDeps = resolvedCompiler === 'tsgo'
-            ? ['@typescript/native-preview']
-            : resolvedCompiler === 'vue-tsc'
-                ? ['vue-tsc', 'typescript']
-                : ['typescript'];
-        targets[options.typecheckTargetName] = {
-            cache: true,
-            inputs: [
-                ...('production' in namedInputs
-                    ? ['production', '^production']
-                    : ['default', '^default']),
-                { externalDependencies: typeCheckExternalDeps },
-            ],
-            command: isUsingTsSolutionSetup
-                ? `${typeCheckCommand} --build --emitDeclarationOnly`
-                : `${typeCheckCommand} --noEmit -p ${tsConfigToUse}`,
-            options: { cwd: (0, devkit_1.joinPathFragments)(projectRoot) },
-            metadata: {
-                description: `Runs type-checking for the project.`,
-                technologies: hasVuePlugin ? ['typescript', 'vue'] : ['typescript'],
-                help: {
-                    command: isUsingTsSolutionSetup
-                        ? `${pmc.exec} ${typeCheckCommand} --build --help`
-                        : `${pmc.exec} ${typeCheckCommand} -p ${tsConfigToUse} --help`,
-                    example: isUsingTsSolutionSetup
-                        ? { args: ['--force'] }
-                        : { options: { noEmit: true } },
-                },
-            },
-        };
-        if (isUsingTsSolutionSetup) {
-            targets[options.typecheckTargetName].dependsOn = [
-                `^${options.typecheckTargetName}`,
-            ];
-            targets[options.typecheckTargetName].syncGenerators = [
-                '@nx/js:typescript-sync',
-            ];
+    const hasVuePlugin = viteBuildConfig.plugins?.some((p) => p.name === 'vite:vue' || p.name === 'vite:vue2');
+    // @nx/js/typescript provides tsc typecheck targets but can't run vue-tsc.
+    const usesVueTsc = (options.compiler ?? (hasVuePlugin ? 'vue-tsc' : 'tsc')) === 'vue-tsc';
+    if (usesVueTsc &&
+        options.typecheckTargetName !== false &&
+        tsConfigFiles.length) {
+        const technologies = hasVuePlugin ? ['typescript', 'vue'] : ['typescript'];
+        const tsConfig = (0, internal_2.selectTypecheckTsConfig)(tsConfigFiles);
+        if (!isUsingTsSolutionSetup) {
+            if (tsConfig) {
+                targets[options.typecheckTargetName] = (0, internal_2.createTypecheckTarget)({
+                    mode: 'noEmit',
+                    projectRoot: (0, devkit_1.joinPathFragments)(projectRoot),
+                    pmc,
+                    tsConfig,
+                    compiler: 'vue-tsc',
+                    namedInputs,
+                    technologies,
+                });
+            }
+        }
+        else if (tsConfigFiles.includes('tsconfig.json')) {
+            targets[options.typecheckTargetName] = (0, internal_2.createTypecheckTarget)({
+                mode: 'build',
+                projectRoot: (0, devkit_1.joinPathFragments)(projectRoot),
+                pmc,
+                compiler: 'vue-tsc',
+                targetName: options.typecheckTargetName,
+                buildTargetName: targets[options.buildTargetName]
+                    ? options.buildTargetName
+                    : undefined,
+                namedInputs,
+                technologies,
+            });
         }
     }
     (0, internal_2.addBuildAndWatchDepsTargets)(context.workspaceRoot, projectRoot, targets, options, pmc);
@@ -212,7 +202,7 @@ function buildInputs(namedInputs) {
         },
     ];
 }
-function serveTarget(projectRoot, isUsingTsSolutionSetup, pmc, namedInputs) {
+function serveTarget(projectRoot, configFilePath, signals, isUsingTsSolutionSetup, pmc, namedInputs) {
     const targetConfig = {
         continuous: true,
         inputs: buildInputs(namedInputs),
@@ -220,6 +210,7 @@ function serveTarget(projectRoot, isUsingTsSolutionSetup, pmc, namedInputs) {
         options: {
             cwd: (0, devkit_1.joinPathFragments)(projectRoot),
         },
+        readyWhen: getServerReadyWhen(configFilePath, 'serve', signals),
         metadata: {
             technologies: ['vite'],
             description: `Starts Vite dev server`,
@@ -238,7 +229,7 @@ function serveTarget(projectRoot, isUsingTsSolutionSetup, pmc, namedInputs) {
     }
     return targetConfig;
 }
-function previewTarget(projectRoot, buildTargetName, pmc, namedInputs) {
+function previewTarget(projectRoot, configFilePath, signals, buildTargetName, pmc, namedInputs) {
     const targetConfig = {
         continuous: true,
         inputs: buildInputs(namedInputs),
@@ -247,6 +238,7 @@ function previewTarget(projectRoot, buildTargetName, pmc, namedInputs) {
         options: {
             cwd: (0, devkit_1.joinPathFragments)(projectRoot),
         },
+        readyWhen: getServerReadyWhen(configFilePath, 'preview', signals),
         metadata: {
             technologies: ['vite'],
             description: `Locally preview Vite production build`,
@@ -271,12 +263,27 @@ function serveStaticTarget(options, isUsingTsSolutionSetup, namedInputs) {
             buildTarget: `${options.buildTargetName}`,
             spa: true,
         },
+        readyWhen: { port: '{options.port}', host: '{options.host ?? localhost}' },
     };
     if (isUsingTsSolutionSetup) {
         targetConfig.syncGenerators = ['@nx/js:typescript-sync'];
     }
     return targetConfig;
 }
+// A config that loads nxReadySignal() reports when the server listens.
+// Otherwise the check resolves the config when the task runs, with the task's
+// env and options, and waits for the server's port.
+function getServerReadyWhen(configFilePath, command, signals) {
+    return signals
+        ? { signal: true }
+        : {
+            // Unquoted: the plugin's glob fixes the file name. Quote it if it ever
+            // becomes user-chosen, since the shell expands $, backticks and %.
+            command: `node -e "require('@nx/vite/ready-check').waitForDevServer(process.argv[1], '${command}')" ${(0, node_path_1.basename)(configFilePath)}`,
+            // Each attempt resolves the config
+            interval: 1000,
+        };
+}
 function getOutputs(viteBuildConfig, projectRoot, workspaceRoot) {
     // TODO(jack): Remove this cast when @nx/vite switches to moduleResolution:
     // "nodenext". Vite 8's rolldown types are ESM-only (.d.mts) and not

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

@@ -1,11 +1,4 @@
-export declare const VITE_BUILD_EXECUTOR_DEPRECATION_MESSAGE = "The `@nx/vite:build` executor is deprecated and will be removed in Nx v24. Run `nx g @nx/vite:convert-to-inferred` to migrate to the `@nx/vite/plugin` inferred targets. See https://nx.dev/docs/guides/tasks--caching/convert-to-inferred for details.";
-export declare const VITE_DEV_SERVER_EXECUTOR_DEPRECATION_MESSAGE = "The `@nx/vite:dev-server` executor is deprecated and will be removed in Nx v24. Run `nx g @nx/vite:convert-to-inferred` to migrate to the `@nx/vite/plugin` inferred targets. See https://nx.dev/docs/guides/tasks--caching/convert-to-inferred for details.";
-export declare const VITE_PREVIEW_SERVER_EXECUTOR_DEPRECATION_MESSAGE = "The `@nx/vite:preview-server` executor is deprecated and will be removed in Nx v24. Run `nx g @nx/vite:convert-to-inferred` to migrate to the `@nx/vite/plugin` inferred targets. See https://nx.dev/docs/guides/tasks--caching/convert-to-inferred for details.";
-export declare function warnViteBuildExecutorDeprecation(): void;
-export declare function warnViteDevServerExecutorDeprecation(): void;
-export declare function warnVitePreviewServerExecutorDeprecation(): void;
-export declare function warnViteExecutorGenerating(): void;
-export declare const NX_VITE_TS_PATHS_DEPRECATION_MESSAGE = "The `nxViteTsPaths` plugin from `@nx/vite/plugins/nx-tsconfig-paths.plugin` is deprecated and will be removed in Nx v24. Replace it with `tsconfigPaths()` from the `vite-tsconfig-paths` package. See https://nx.dev/docs/technologies/build-tools/vite/guides/configure-vite for details.";
-export declare const NX_COPY_ASSETS_PLUGIN_DEPRECATION_MESSAGE = "The `nxCopyAssetsPlugin` plugin from `@nx/vite/plugins/nx-copy-assets.plugin` is deprecated and will be removed in Nx v24. Use Vite's native `publicDir` option or the `vite-plugin-static-copy` package instead. See https://nx.dev/docs/technologies/build-tools/vite/guides/configure-vite for details.";
+export declare const NX_VITE_TS_PATHS_DEPRECATION_MESSAGE = "The `nxViteTsPaths` plugin from `@nx/vite/plugins/nx-tsconfig-paths.plugin` was removed in Nx v24. The remaining export is an inert compatibility stub and does not configure builds. Use native `resolve.tsconfigPaths` when supported by the installed Vite version, or a compatible `vite-tsconfig-paths` plugin. Follow the config-helper migration instructions generated by `nx migrate`.";
+export declare const NX_COPY_ASSETS_PLUGIN_DEPRECATION_MESSAGE = "The `nxCopyAssetsPlugin` plugin from `@nx/vite/plugins/nx-copy-assets.plugin` was removed in Nx v24. The remaining export is an inert compatibility stub and does not configure builds. Preserve asset paths and watch behavior using native `publicDir`, a compatible `vite-plugin-static-copy`, or local configuration. Follow the config-helper migration instructions generated by `nx migrate`.";
 export declare function warnNxViteTsPathsDeprecation(): void;
 export declare function warnNxCopyAssetsPluginDeprecation(): void;

package/dist/src/utils/deprecation.js

@@ -1,43 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.NX_COPY_ASSETS_PLUGIN_DEPRECATION_MESSAGE = exports.NX_VITE_TS_PATHS_DEPRECATION_MESSAGE = exports.VITE_PREVIEW_SERVER_EXECUTOR_DEPRECATION_MESSAGE = exports.VITE_DEV_SERVER_EXECUTOR_DEPRECATION_MESSAGE = exports.VITE_BUILD_EXECUTOR_DEPRECATION_MESSAGE = void 0;
-exports.warnViteBuildExecutorDeprecation = warnViteBuildExecutorDeprecation;
-exports.warnViteDevServerExecutorDeprecation = warnViteDevServerExecutorDeprecation;
-exports.warnVitePreviewServerExecutorDeprecation = warnVitePreviewServerExecutorDeprecation;
-exports.warnViteExecutorGenerating = warnViteExecutorGenerating;
+exports.NX_COPY_ASSETS_PLUGIN_DEPRECATION_MESSAGE = exports.NX_VITE_TS_PATHS_DEPRECATION_MESSAGE = void 0;
 exports.warnNxViteTsPathsDeprecation = warnNxViteTsPathsDeprecation;
 exports.warnNxCopyAssetsPluginDeprecation = warnNxCopyAssetsPluginDeprecation;
 const devkit_1 = require("@nx/devkit");
-// TODO(v24): Remove the @nx/vite:build, @nx/vite:dev-server, and
-// @nx/vite:preview-server executors. The inferred plugin (@nx/vite/plugin)
-// and the convert-to-inferred generator stay supported. (`@nx/vite:test`
-// is being deprecated in a separate change for the test-runner batch.)
-exports.VITE_BUILD_EXECUTOR_DEPRECATION_MESSAGE = 'The `@nx/vite:build` executor is deprecated and will be removed in Nx v24. Run `nx g @nx/vite:convert-to-inferred` to migrate to the `@nx/vite/plugin` inferred targets. See https://nx.dev/docs/guides/tasks--caching/convert-to-inferred for details.';
-exports.VITE_DEV_SERVER_EXECUTOR_DEPRECATION_MESSAGE = 'The `@nx/vite:dev-server` executor is deprecated and will be removed in Nx v24. Run `nx g @nx/vite:convert-to-inferred` to migrate to the `@nx/vite/plugin` inferred targets. See https://nx.dev/docs/guides/tasks--caching/convert-to-inferred for details.';
-exports.VITE_PREVIEW_SERVER_EXECUTOR_DEPRECATION_MESSAGE = 'The `@nx/vite:preview-server` executor is deprecated and will be removed in Nx v24. Run `nx g @nx/vite:convert-to-inferred` to migrate to the `@nx/vite/plugin` inferred targets. See https://nx.dev/docs/guides/tasks--caching/convert-to-inferred for details.';
-function warnViteBuildExecutorDeprecation() {
-    devkit_1.logger.warn(exports.VITE_BUILD_EXECUTOR_DEPRECATION_MESSAGE);
-}
-function warnViteDevServerExecutorDeprecation() {
-    devkit_1.logger.warn(exports.VITE_DEV_SERVER_EXECUTOR_DEPRECATION_MESSAGE);
-}
-function warnVitePreviewServerExecutorDeprecation() {
-    devkit_1.logger.warn(exports.VITE_PREVIEW_SERVER_EXECUTOR_DEPRECATION_MESSAGE);
-}
-// Fired when the @nx/vite:configuration generator is about to generate
-// targets that use the deprecated executors — i.e. when @nx/vite/plugin
-// isn't registered in nx.json. Surfaces the deprecation at generation time
-// rather than only when the user later runs the generated targets.
-function warnViteExecutorGenerating() {
-    devkit_1.logger.warn('Generating targets that use the deprecated `@nx/vite:build`, `@nx/vite:dev-server`, and `@nx/vite:preview-server` executors. These executors will be removed in Nx v24. Run `nx g @nx/vite:convert-to-inferred` next to migrate these targets to the `@nx/vite/plugin` inferred plugin and prevent future generators from emitting executor targets. See https://nx.dev/docs/guides/tasks--caching/convert-to-inferred for details.');
-}
-// TODO(v24): Remove `nxViteTsPaths` and `nxCopyAssetsPlugin` helpers.
-// The inferred `@nx/vite/plugin` already ensures projects extend the base
-// tsconfig, so the community `vite-tsconfig-paths` package handles path
-// resolution end-to-end. Asset copying is covered by Vite's native
-// `publicDir` option or the `vite-plugin-static-copy` package.
-exports.NX_VITE_TS_PATHS_DEPRECATION_MESSAGE = 'The `nxViteTsPaths` plugin from `@nx/vite/plugins/nx-tsconfig-paths.plugin` is deprecated and will be removed in Nx v24. Replace it with `tsconfigPaths()` from the `vite-tsconfig-paths` package. See https://nx.dev/docs/technologies/build-tools/vite/guides/configure-vite for details.';
-exports.NX_COPY_ASSETS_PLUGIN_DEPRECATION_MESSAGE = "The `nxCopyAssetsPlugin` plugin from `@nx/vite/plugins/nx-copy-assets.plugin` is deprecated and will be removed in Nx v24. Use Vite's native `publicDir` option or the `vite-plugin-static-copy` package instead. See https://nx.dev/docs/technologies/build-tools/vite/guides/configure-vite for details.";
+// Helper behavior was removed in v24; exports remain only as inert stubs.
+// Keep their imports loadable while existing Vite configs are migrated.
+exports.NX_VITE_TS_PATHS_DEPRECATION_MESSAGE = 'The `nxViteTsPaths` plugin from `@nx/vite/plugins/nx-tsconfig-paths.plugin` was removed in Nx v24. The remaining export is an inert compatibility stub and does not configure builds. Use native `resolve.tsconfigPaths` when supported by the installed Vite version, or a compatible `vite-tsconfig-paths` plugin. Follow the config-helper migration instructions generated by `nx migrate`.';
+exports.NX_COPY_ASSETS_PLUGIN_DEPRECATION_MESSAGE = 'The `nxCopyAssetsPlugin` plugin from `@nx/vite/plugins/nx-copy-assets.plugin` was removed in Nx v24. The remaining export is an inert compatibility stub and does not configure builds. Preserve asset paths and watch behavior using native `publicDir`, a compatible `vite-plugin-static-copy`, or local configuration. Follow the config-helper migration instructions generated by `nx migrate`.';
 let nxViteTsPathsWarned = false;
 let nxCopyAssetsPluginWarned = false;
 // Warn-once per process so users don't see the message repeated on every

package/dist/src/utils/dev-server-ready-check.d.ts

@@ -0,0 +1,27 @@
+export interface ViteFlags {
+    port?: string;
+    host?: string | boolean;
+    mode?: string;
+    config?: string;
+    root?: string;
+}
+/**
+ * The flags `vite` and `vite preview` get from the target's options, in the
+ * order run-commands passes them: named options, `args`, then overrides.
+ */
+export declare function parseViteFlags(options: Record<string, unknown>, command: 'serve' | 'preview'): ViteFlags;
+export type ServerAddress = {
+    port: number;
+    host?: string;
+};
+export declare function getViteServerAddress(server: {
+    port?: unknown;
+    host?: unknown;
+} | undefined, flags: ViteFlags, command: 'serve' | 'preview'): ServerAddress | null;
+/**
+ * The readyWhen of the inferred serve and preview targets when the config
+ * doesn't load the signal plugin. Runs in the env and with the options of the
+ * task, resolves the config the way `vite` does, and waits for the server's
+ * port.
+ */
+export declare function waitForViteServer(configPath: string, command: 'serve' | 'preview'): Promise<void>;