@nx/cypress 24.0.0-pr.37405.acdaf31 → 24.0.0-rc.0

package/dist/internal.d.ts

@@ -2,4 +2,4 @@ export * from './src/utils/versions';
 export * from './src/utils/ct-helpers';
 export * from './src/utils/find-target-options';
 export * from './src/utils/config';
-export type { CypressExecutorOptions } from './src/executors/cypress/cypress.impl';
+export type { CypressExecutorOptions } from './src/executors/cypress/schema';

package/dist/plugins/cypress-preset.js

@@ -130,6 +130,19 @@ function nxE2EPreset(pathToConfig, options) {
             if (options?.bundler === 'vite') {
                 on('file:preprocessor', (0, preprocessor_vite_1.default)(options?.viteConfigOverrides));
             }
+            // Set by Nx when the web server task already reported it is ready
+            const readyUrl = process.env.NX_READY_URL;
+            if (readyUrl && isBaseUrlOverridden(config, options)) {
+                console.log(`Testing against ${config.baseUrl} from --config or CYPRESS_BASE_URL, not the server Nx started on ${readyUrl}`);
+                await waitForServer(config.baseUrl, options?.webServerConfig, (ms) => `${config.baseUrl} did not respond within ${ms}ms. This can be configured in cypress.config.ts.`);
+                return;
+            }
+            if (readyUrl) {
+                config.baseUrl = (0, devkit_1.getReadyUrl)(config.baseUrl);
+                console.log(`Testing against the server Nx started on ${config.baseUrl}`);
+                // Cypress only applies config changes returned from setupNodeEvents.
+                return config;
+            }
             if (!options?.webServerCommands) {
                 return;
             }
@@ -158,23 +171,54 @@ function nxE2EPreset(pathToConfig, options) {
     };
     return baseConfig;
 }
-function waitForServer(url, webServerConfig) {
+// Cypress keeps the config file's values in rawJson, without --config, and
+// reports CYPRESS_BASE_URL as from 'env'. A config file that reads
+// CYPRESS_BASE_URL has it in rawJson too. Inferred CI targets pass ciBaseUrl.
+function isBaseUrlOverridden(config, options) {
+    if (!config.baseUrl) {
+        return false;
+    }
+    if (config.resolved?.baseUrl?.from === 'env') {
+        return true;
+    }
+    const isInferredCiTarget = !!options?.ciWebServerCommand &&
+        config.env?.webServerCommand === options.ciWebServerCommand;
+    return (!isSameUrl(config.baseUrl, config.rawJson?.e2e?.baseUrl) &&
+        !(isInferredCiTarget && isSameUrl(config.baseUrl, options.ciBaseUrl)));
+}
+function isSameUrl(url, other) {
+    if (typeof other !== 'string') {
+        return false;
+    }
+    try {
+        return new URL(url).href === new URL(other).href;
+    }
+    catch {
+        return url === other;
+    }
+}
+function waitForServer(url, webServerConfig, timeoutMessage = (ms) => `Web server failed to start in ${ms}ms. This can be configured in cypress.config.ts.`) {
     return new Promise((resolve, reject) => {
         let pollTimeout;
         const { protocol } = new URL(url);
+        let settled = false;
         const timeoutDuration = webServerConfig?.timeout ?? 60 * 1000;
         const timeout = setTimeout(() => {
+            settled = true;
             clearTimeout(pollTimeout);
-            reject(new Error(`Web server failed to start in ${timeoutDuration}ms. This can be configured in cypress.config.ts.`));
+            reject(new Error(timeoutMessage(timeoutDuration)));
         }, timeoutDuration);
         const makeRequest = protocol === 'https:' ? https_1.request : http_1.request;
         function pollForServer() {
             const request = makeRequest(url, () => {
+                settled = true;
                 clearTimeout(timeout);
                 resolve();
             });
             request.on('error', () => {
-                pollTimeout = setTimeout(pollForServer, 100);
+                if (!settled) {
+                    pollTimeout = setTimeout(pollForServer, 100);
+                }
             });
             // Don't forget to end the request
             request.end();

package/dist/src/executors/cypress/{cypress.impl.d.ts → schema.d.ts}

@@ -1,4 +1,3 @@
-import { ExecutorContext } from '@nx/devkit';
 export type Json = {
     [k: string]: any;
 };
@@ -7,10 +6,6 @@ export interface CypressExecutorOptions extends Json {
     watch?: boolean;
     devServerTarget?: string;
     headed?: boolean;
-    /**
-     * @deprecated Cypress runs headless by default. Use the --watch flag to
-     * control head/headless behavior instead. It will be removed in Nx v23.
-     **/
     headless?: boolean;
     exit?: boolean;
     key?: string;
@@ -33,6 +28,3 @@ export interface CypressExecutorOptions extends Json {
     runnerUi?: boolean;
     autoCancelAfterFailures?: boolean | number;
 }
-export default function cypressExecutor(options: CypressExecutorOptions, context: ExecutorContext): Promise<{
-    success: any;
-}>;

package/dist/src/executors/cypress/schema.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/src/generators/base-setup/base-setup.d.ts

@@ -15,8 +15,12 @@ export interface CypressBaseSetupSchema {
      * which merges in its own `component` block afterwards).
      */
     e2ePreset?: {
-        /** Pre-formatted (indented) JSON of NxCypressE2EPresetOptions. */
+        /**
+         * NxCypressE2EPresetOptions rendered by `renderE2EPresetOptions`: indented
+         * JSON, except for values the config picks at runtime from `CI`.
+         */
         presetOptions: string;
+        /** A JS expression rendered by `renderE2EPresetOptions`, not a bare URL. */
         baseUrl?: string;
     };
 }

package/dist/src/generators/base-setup/files/config-js-cjs/cypress.config.js__ext__

@@ -7,6 +7,6 @@ const { defineConfig } = require('cypress');
 module.exports = defineConfig({<% if (e2ePreset) { %>
   e2e: {
     ...nxE2EPreset(__filename, <%- presetOptions %>),<% if (baseUrl) { %>
-    baseUrl: '<%- baseUrl %>',<% } %>
+    baseUrl: <%- baseUrl %>,<% } %>
   },
 <% } %>});

package/dist/src/generators/base-setup/files/config-js-esm/cypress.config.js__ext__

@@ -7,6 +7,6 @@ import { defineConfig } from 'cypress';
 export default defineConfig({<% if (e2ePreset) { %>
   e2e: {
     ...nxE2EPreset(import.meta.url, <%- presetOptions %>),<% if (baseUrl) { %>
-    baseUrl: '<%- baseUrl %>',<% } %>
+    baseUrl: <%- baseUrl %>,<% } %>
   },
 <% } %>});

package/dist/src/generators/base-setup/files/config-ts-cjs/cypress.config.ts__ext__

@@ -7,6 +7,6 @@ const { defineConfig } = require('cypress');
 module.exports = defineConfig({<% if (e2ePreset) { %>
   e2e: {
     ...nxE2EPreset(__filename, <%- presetOptions %>),<% if (baseUrl) { %>
-    baseUrl: '<%- baseUrl %>',<% } %>
+    baseUrl: <%- baseUrl %>,<% } %>
   },
 <% } %>});

package/dist/src/generators/base-setup/files/config-ts-esm/cypress.config.ts__ext__

@@ -7,6 +7,6 @@ import { defineConfig } from 'cypress';
 export default defineConfig({<% if (e2ePreset) { %>
   e2e: {
     ...nxE2EPreset(import.meta.url, <%- presetOptions %>),<% if (baseUrl) { %>
-    baseUrl: '<%- baseUrl %>',<% } %>
+    baseUrl: <%- baseUrl %>,<% } %>
   },
 <% } %>});

package/dist/src/generators/component-configuration/component-configuration.js

@@ -8,21 +8,17 @@ const devkit_1 = require("@nx/devkit");
 const internal_1 = require("@nx/devkit/internal");
 const internal_2 = require("@nx/js/internal");
 const assert_supported_cypress_version_1 = require("../../utils/assert-supported-cypress-version");
-const deprecation_1 = require("../../utils/deprecation");
 const versions_1 = require("../../utils/versions");
 const base_setup_1 = require("../base-setup/base-setup");
-const init_1 = tslib_1.__importDefault(require("../init/init"));
+const init_1 = tslib_1.__importStar(require("../init/init"));
 function componentConfigurationGenerator(tree, options) {
-    return componentConfigurationGeneratorInternal(tree, {
-        addPlugin: false,
-        ...options,
-    });
+    return componentConfigurationGeneratorInternal(tree, options);
 }
 async function componentConfigurationGeneratorInternal(tree, options) {
     (0, assert_supported_cypress_version_1.assertSupportedCypressVersion)(tree);
     (0, internal_2.assertNotUsingTsSolutionSetup)(tree, 'cypress', 'component-configuration');
     const tasks = [];
-    const opts = normalizeOptions(tree, options);
+    const opts = normalizeOptions(options);
     if (opts.bundler === 'vite') {
         (0, versions_1.assertViteSupportsInstalledCypress)(tree);
     }
@@ -38,29 +34,18 @@ async function componentConfigurationGeneratorInternal(tree, options) {
             skipFormat: true,
         }));
     }
-    const nxJson = (0, devkit_1.readNxJson)(tree);
-    const hasPlugin = nxJson.plugins?.some((p) => typeof p === 'string'
-        ? p === '@nx/cypress/plugin'
-        : p.plugin === '@nx/cypress/plugin');
+    await (0, init_1.addPlugin)(tree, await (0, devkit_1.createProjectGraphAsync)(), false);
     const projectConfig = (0, devkit_1.readProjectConfiguration)(tree, opts.project);
     addProjectFiles(tree, projectConfig, opts);
-    if (!hasPlugin || opts.addExplicitTargets) {
-        (0, deprecation_1.warnCypressExecutorGenerating)();
-        addTargetToProject(tree, projectConfig, opts);
-    }
-    updateNxJsonConfiguration(tree, hasPlugin);
+    updateNxJsonConfiguration(tree);
     updateTsConfigForComponentTesting(tree, projectConfig);
     if (!opts.skipFormat) {
         await (0, devkit_1.formatFiles)(tree);
     }
     return (0, devkit_1.runTasksInSerial)(...tasks);
 }
-function normalizeOptions(tree, options) {
-    const nxJson = (0, devkit_1.readNxJson)(tree);
-    const addPlugin = process.env.NX_ADD_PLUGINS !== 'false' &&
-        nxJson.useInferencePlugins !== false;
+function normalizeOptions(options) {
     return {
-        addPlugin,
         ...options,
         framework: options.framework ?? null,
         directory: options.directory ?? 'cypress',
@@ -107,17 +92,7 @@ function addProjectFiles(tree, projectConfig, opts) {
         ext: '',
     });
 }
-function addTargetToProject(tree, projectConfig, opts) {
-    projectConfig.targets['component-test'] = {
-        executor: '@nx/cypress:cypress',
-        options: {
-            cypressConfig: (0, devkit_1.joinPathFragments)(projectConfig.root, 'cypress.config.ts'),
-            testingType: 'component',
-        },
-    };
-    (0, devkit_1.updateProjectConfiguration)(tree, opts.project, projectConfig);
-}
-function updateNxJsonConfiguration(tree, hasPlugin) {
+function updateNxJsonConfiguration(tree) {
     const nxJson = (0, devkit_1.readNxJson)(tree);
     const productionFileSet = nxJson.namedInputs?.production;
     if (productionFileSet) {
@@ -128,31 +103,6 @@ function updateNxJsonConfiguration(tree, hasPlugin) {
             '!{projectRoot}/cypress.config.[jt]s',
         ]));
     }
-    if (!hasPlugin) {
-        const cacheableOperations = nxJson.tasksRunnerOptions?.default?.options?.cacheableOperations;
-        if (cacheableOperations &&
-            !cacheableOperations.includes('component-test')) {
-            cacheableOperations.push('component-test');
-        }
-        // Either a `target: 'component-test'` default or a default keyed on
-        // the executor we're scaffolding will apply to the new target — pick
-        // the more specific (target-keyed) when both are present.
-        const existingForTarget = (0, internal_1.findTargetDefault)(nxJson.targetDefaults, {
-            target: 'component-test',
-        });
-        const existingForExecutor = (0, internal_1.findTargetDefault)(nxJson.targetDefaults, {
-            executor: '@nx/cypress:cypress',
-        });
-        const existing = existingForTarget ?? existingForExecutor;
-        (0, internal_1.upsertTargetDefault)(tree, nxJson, {
-            target: 'component-test',
-            cache: existing?.cache ?? true,
-            inputs: existing?.inputs ?? [
-                'default',
-                productionFileSet ? '^production' : '^default',
-            ],
-        });
-    }
     (0, devkit_1.updateNxJson)(tree, nxJson);
 }
 function updateTsConfigForComponentTesting(tree, projectConfig) {

package/dist/src/generators/component-configuration/schema.d.ts

@@ -4,12 +4,10 @@ export interface CypressComponentConfigurationSchema {
   directory?: string;
   bundler?: 'webpack' | 'vite';
   jsx?: boolean;
-  addPlugin?: boolean;
   skipPackageJson?: boolean;
 
   /**
    * @internal
    */
-  addExplicitTargets?: boolean;
   framework?: 'next';
 }

package/dist/src/generators/configuration/configuration.d.ts

@@ -7,10 +7,6 @@ export interface CypressE2EConfigSchema {
     js?: boolean;
     skipFormat?: boolean;
     enableTypedLinting?: boolean;
-    /**
-     * @deprecated Use `enableTypedLinting` instead. This option will be removed in Nx v24.
-     */
-    setParserOptionsProject?: boolean;
     skipPackageJson?: boolean;
     bundler?: 'webpack' | 'vite' | 'none';
     devServerTarget?: string;
@@ -21,7 +17,6 @@ export interface CypressE2EConfigSchema {
     webServerCommands?: Record<string, string>;
     ciWebServerCommand?: string;
     ciBaseUrl?: string;
-    addPlugin?: boolean;
 }
 export declare function configurationGenerator(tree: Tree, options: CypressE2EConfigSchema): Promise<GeneratorCallback>;
 export declare function configurationGeneratorInternal(tree: Tree, options: CypressE2EConfigSchema): Promise<GeneratorCallback>;

package/dist/src/generators/configuration/configuration.js

@@ -11,15 +11,11 @@ const path_1 = require("path");
 const add_linter_1 = require("../../utils/add-linter");
 const assert_supported_cypress_version_1 = require("../../utils/assert-supported-cypress-version");
 const config_1 = require("../../utils/config");
-const deprecation_1 = require("../../utils/deprecation");
 const versions_1 = require("../../utils/versions");
 const base_setup_1 = require("../base-setup/base-setup");
 const init_1 = tslib_1.__importStar(require("../init/init"));
 function configurationGenerator(tree, options) {
-    return configurationGeneratorInternal(tree, {
-        addPlugin: false,
-        ...options,
-    });
+    return configurationGeneratorInternal(tree, options);
 }
 async function configurationGeneratorInternal(tree, options) {
     (0, assert_supported_cypress_version_1.assertSupportedCypressVersion)(tree);
@@ -33,18 +29,10 @@ async function configurationGeneratorInternal(tree, options) {
             skipFormat: true,
         }));
     }
-    else if (opts.addPlugin) {
+    else {
         await (0, init_1.addPlugin)(tree, projectGraph, false);
     }
-    const nxJson = (0, devkit_1.readNxJson)(tree);
-    const hasPlugin = nxJson.plugins?.some((p) => typeof p === 'string'
-        ? p === '@nx/cypress/plugin'
-        : p.plugin === '@nx/cypress/plugin');
-    await addFiles(tree, opts, projectGraph, hasPlugin);
-    if (!hasPlugin) {
-        (0, deprecation_1.warnCypressExecutorGenerating)();
-        addTarget(tree, opts, projectGraph);
-    }
+    await addFiles(tree, opts, projectGraph);
     const projectTsConfigPath = (0, devkit_1.joinPathFragments)(opts.projectRoot, 'tsconfig.json');
     if (tree.exists(projectTsConfigPath)) {
         (0, devkit_1.updateJson)(tree, projectTsConfigPath, (json) => {
@@ -130,10 +118,6 @@ In this case you need to provide a devServerTarget,'<projectName>:<targetName>[:
     if (!options.baseUrl && !devServerTarget) {
         throw new Error('Either baseUrl or devServerTarget must be provided');
     }
-    const nxJson = (0, devkit_1.readNxJson)(tree);
-    options.addPlugin ??=
-        process.env.NX_ADD_PLUGINS !== 'false' &&
-            nxJson.useInferencePlugins !== false;
     return {
         ...options,
         bundler: options.bundler ?? 'webpack',
@@ -166,7 +150,7 @@ async function promptForMissingServeData(projectName) {
         baseUrl: `http://localhost:${port}`,
     };
 }
-async function addFiles(tree, options, projectGraph, hasPlugin) {
+async function addFiles(tree, options, projectGraph) {
     const projectConfig = (0, devkit_1.readProjectConfiguration)(tree, options.project);
     const hasTsConfig = tree.exists((0, devkit_1.joinPathFragments)(projectConfig.root, 'tsconfig.json'));
     const offsetFromProjectRoot = options.directory
@@ -194,12 +178,12 @@ async function addFiles(tree, options, projectGraph, hasPlugin) {
     let webServerCommands;
     let ciWebServerCommand;
     let ciBaseUrl;
-    if (hasPlugin && options.webServerCommands && options.ciWebServerCommand) {
+    if (options.webServerCommands && options.ciWebServerCommand) {
         webServerCommands = options.webServerCommands;
         ciWebServerCommand = options.ciWebServerCommand;
         ciBaseUrl = options.ciBaseUrl;
     }
-    else if (hasPlugin && options.devServerTarget) {
+    else if (options.devServerTarget) {
         webServerCommands = {};
         webServerCommands.default = 'nx run ' + options.devServerTarget;
         const parsedTarget = (0, devkit_1.parseTargetString)(options.devServerTarget, projectGraph);
@@ -214,6 +198,13 @@ async function addFiles(tree, options, projectGraph, hasPlugin) {
             ciWebServerCommand = `nx run ${parsedTarget.project}:serve-static`;
         }
     }
+    if (typeof options.port === 'number') {
+        for (const name of Object.keys(webServerCommands ?? {})) {
+            webServerCommands[name] += ` --port=${options.port}`;
+        }
+        if (ciWebServerCommand)
+            ciWebServerCommand += ` --port=${options.port}`;
+    }
     const e2ePresetOptions = {
         cypressDir: options.directory,
         bundler: options.bundler === 'vite' ? 'vite' : undefined,
@@ -221,6 +212,7 @@ async function addFiles(tree, options, projectGraph, hasPlugin) {
         ciWebServerCommand,
         ciBaseUrl,
     };
+    const renderedPreset = (0, config_1.renderE2EPresetOptions)(e2ePresetOptions, options.baseUrl);
     (0, base_setup_1.addBaseCypressSetup)(tree, {
         project: options.project,
         directory: options.directory,
@@ -229,10 +221,8 @@ async function addFiles(tree, options, projectGraph, hasPlugin) {
         // Generate a fresh config already containing the e2e preset (base-setup
         // no-ops when a config already exists - see the merge below).
         e2ePreset: {
-            presetOptions: JSON.stringify(e2ePresetOptions, null, 2)
-                .split('\n')
-                .join('\n    '),
-            baseUrl: options.baseUrl,
+            presetOptions: renderedPreset.presetOptions.split('\n').join('\n    '),
+            baseUrl: renderedPreset.baseUrl,
         },
     });
     if (cypressConfigExists) {
@@ -242,48 +232,6 @@ async function addFiles(tree, options, projectGraph, hasPlugin) {
         (0, devkit_1.toJS)(tree);
     }
 }
-function addTarget(tree, opts, projectGraph) {
-    const projectConfig = (0, devkit_1.readProjectConfiguration)(tree, opts.project);
-    projectConfig.targets ??= {};
-    projectConfig.targets.e2e = {
-        executor: '@nx/cypress:cypress',
-        options: {
-            cypressConfig: (0, devkit_1.joinPathFragments)(projectConfig.root, `cypress.config.${opts.js ? 'js' : 'ts'}`),
-            testingType: 'e2e',
-        },
-    };
-    if (opts.devServerTarget) {
-        const parsedTarget = (0, devkit_1.parseTargetString)(opts.devServerTarget, projectGraph);
-        projectConfig.targets.e2e.options = {
-            ...projectConfig.targets.e2e.options,
-            devServerTarget: opts.devServerTarget,
-            port: opts.port,
-        };
-        const devServerProjectConfig = (0, devkit_1.readProjectConfiguration)(tree, parsedTarget.project);
-        // Add production e2e target if serve target is found
-        if (parsedTarget.configuration !== 'production' &&
-            devServerProjectConfig.targets?.[parsedTarget.target]?.configurations?.['production']) {
-            projectConfig.targets.e2e.configurations ??= {};
-            projectConfig.targets.e2e.configurations['production'] = {
-                devServerTarget: `${parsedTarget.project}:${parsedTarget.target}:production`,
-            };
-        }
-        // Add ci/static e2e target if serve target is found
-        if (devServerProjectConfig.targets?.['serve-static']) {
-            projectConfig.targets.e2e.configurations ??= {};
-            projectConfig.targets.e2e.configurations.ci = {
-                devServerTarget: `${parsedTarget.project}:serve-static`,
-            };
-        }
-    }
-    else if (opts.baseUrl) {
-        projectConfig.targets.e2e.options = {
-            ...projectConfig.targets.e2e.options,
-            baseUrl: opts.baseUrl,
-        };
-    }
-    (0, devkit_1.updateProjectConfiguration)(tree, opts.project, projectConfig);
-}
 function createPackageJson(tree, options) {
     const projectConfig = (0, devkit_1.readProjectConfiguration)(tree, options.project);
     const packageJsonPath = (0, devkit_1.joinPathFragments)(projectConfig.root, 'package.json');

package/dist/src/generators/configuration/schema.json

@@ -65,12 +65,6 @@
       "description": "Whether to enable typed linting. For flat configs, this configures the recommended `parserOptions.projectService` and `tsconfigRootDir`. For legacy `.eslintrc` configs, this configures `parserOptions.project`. We do not enable this by default for lint performance reasons.",
       "default": false
     },
-    "setParserOptionsProject": {
-      "type": "boolean",
-      "description": "Deprecated alias for `enableTypedLinting`.",
-      "default": false,
-      "x-deprecated": "Use `enableTypedLinting` instead. This option will be removed in Nx v24."
-    },
     "skipPackageJson": {
       "type": "boolean",
       "default": false,

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

@@ -5,6 +5,7 @@ const internal_1 = require("@nx/devkit/internal");
 const devkit_1 = require("@nx/devkit");
 const plugin_1 = require("../../plugins/plugin");
 const assert_supported_cypress_version_1 = require("../../utils/assert-supported-cypress-version");
+const add_build_target_to_ct_preset_1 = require("./lib/add-build-target-to-ct-preset");
 const add_dev_server_target_to_config_1 = require("./lib/add-dev-server-target-to-config");
 const add_exclude_spec_pattern_1 = require("./lib/add-exclude-spec-pattern");
 const target_options_map_1 = require("./lib/target-options-map");
@@ -32,6 +33,9 @@ async function convertToInferred(tree, options) {
     }
 }
 function postTargetTransformer(target, tree, projectDetails, inferredTargetConfiguration) {
+    if (target.options?.testingType === 'component') {
+        moveBuildTargetToComponentTestingPreset(tree, target, projectDetails.projectName);
+    }
     if (target.options) {
         handlePropertiesInOptions(tree, target.options, projectDetails.root, target);
         if (Object.keys(target.options).length === 0) {
@@ -62,6 +66,28 @@ function postTargetTransformer(target, tree, projectDetails, inferredTargetConfi
     }
     return target;
 }
+function moveBuildTargetToComponentTestingPreset(tree, target, projectName) {
+    const defaultConfiguration = target.defaultConfiguration
+        ? target.configurations?.[target.defaultConfiguration]
+        : undefined;
+    const buildTarget = defaultConfiguration?.devServerTarget ?? target.options.devServerTarget;
+    const { cypressConfig } = target.options;
+    if (buildTarget &&
+        !(cypressConfig &&
+            (0, add_build_target_to_ct_preset_1.addBuildTargetToComponentTestingPreset)(tree, cypressConfig, buildTarget))) {
+        devkit_1.logger.warn(`Could not set the component testing build target of project "${projectName}" in its Cypress config. Pass it to nxComponentTestingPreset as buildTarget: "${buildTarget}".`);
+    }
+    const removeDevServerTarget = (options, location) => {
+        if (options?.devServerTarget && options.devServerTarget !== buildTarget) {
+            devkit_1.logger.warn(`Removed devServerTarget "${options.devServerTarget}" from the ${location} of project "${projectName}". Component testing uses the single buildTarget passed to nxComponentTestingPreset.`);
+        }
+        delete options?.devServerTarget;
+    };
+    removeDevServerTarget(target.options, 'options');
+    for (const [name, configuration] of Object.entries(target.configurations ?? {})) {
+        removeDevServerTarget(configuration, `"${name}" configuration`);
+    }
+}
 function handlePropertiesInOptions(tree, options, projectRoot, target) {
     let configFilePath;
     if ('cypressConfig' in options) {

package/dist/src/generators/convert-to-inferred/lib/add-build-target-to-ct-preset.d.ts

@@ -0,0 +1,7 @@
+import type { Tree } from '@nx/devkit';
+/**
+ * Sets `buildTarget` in the `nxComponentTestingPreset` options. A non-empty
+ * string literal is kept and any other value gets an `||` fallback. Returns
+ * false when there is no such call or the value can't be resolved statically.
+ */
+export declare function addBuildTargetToComponentTestingPreset(tree: Tree, configFilePath: string, buildTarget: string): boolean;

package/dist/src/generators/convert-to-inferred/lib/add-build-target-to-ct-preset.js

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addBuildTargetToComponentTestingPreset = addBuildTargetToComponentTestingPreset;
+const internal_1 = require("@nx/js/internal");
+const tsquery_1 = require("@phenomnomnominal/tsquery");
+const migrations_1 = require("../../../utils/migrations");
+let ts;
+/**
+ * Sets `buildTarget` in the `nxComponentTestingPreset` options. A non-empty
+ * string literal is kept and any other value gets an `||` fallback. Returns
+ * false when there is no such call or the value can't be resolved statically.
+ */
+function addBuildTargetToComponentTestingPreset(tree, configFilePath, buildTarget) {
+    ts ??= (0, internal_1.ensureTypescript)();
+    const contents = tree.read(configFilePath, 'utf-8');
+    if (contents === null) {
+        return false;
+    }
+    const presetCall = (0, tsquery_1.query)((0, migrations_1.parseSourceFile)(configFilePath, contents), 'CallExpression').find((call) => ts.isIdentifier(call.expression) &&
+        call.expression.text === 'nxComponentTestingPreset');
+    const [pathToConfig, options] = presetCall?.arguments ?? [];
+    if (!pathToConfig) {
+        return false;
+    }
+    const replace = (start, end, text) => tree.write(configFilePath, `${contents.slice(0, start)}${text}${contents.slice(end)}`);
+    const buildTargetLiteral = JSON.stringify(buildTarget);
+    if (!options) {
+        const insertAt = pathToConfig.getEnd();
+        replace(insertAt, insertAt, `, { buildTarget: ${buildTargetLiteral} }`);
+        return true;
+    }
+    if (!ts.isObjectLiteralExpression(options)) {
+        return false;
+    }
+    const effectiveProperty = [...options.properties]
+        .reverse()
+        .find((property) => ts.isSpreadAssignment(property) ||
+        isUnresolvedComputedName(property.name) ||
+        (0, migrations_1.getPropertyName)(property.name) === 'buildTarget');
+    if (!effectiveProperty) {
+        // `__proto__: value` sets the prototype, which can provide buildTarget
+        if (options.properties.some((property) => ts.isPropertyAssignment(property) &&
+            !ts.isComputedPropertyName(property.name) &&
+            (0, migrations_1.getPropertyName)(property.name) === '__proto__')) {
+            return false;
+        }
+        const insertAt = options.getStart() + 1;
+        replace(insertAt, insertAt, ` buildTarget: ${buildTargetLiteral},`);
+        return true;
+    }
+    if (ts.isShorthandPropertyAssignment(effectiveProperty)) {
+        replace(effectiveProperty.getStart(), effectiveProperty.getEnd(), `buildTarget: buildTarget || ${buildTargetLiteral}`);
+        return true;
+    }
+    if (!ts.isPropertyAssignment(effectiveProperty) ||
+        isUnresolvedComputedName(effectiveProperty.name)) {
+        return false;
+    }
+    const value = effectiveProperty.initializer;
+    if (ts.isStringLiteralLike(value) && value.text) {
+        return true;
+    }
+    // The factory parenthesizes the left operand when precedence requires it
+    const needsParentheses = ts.isParenthesizedExpression(ts.factory.createBinaryExpression(value, ts.SyntaxKind.BarBarToken, ts.factory.createStringLiteral(buildTarget)).left);
+    const valueText = value.getText();
+    replace(value.getStart(), value.getEnd(), `${needsParentheses ? `(${valueText})` : valueText} || ${buildTargetLiteral}`);
+    return true;
+}
+function isUnresolvedComputedName(name) {
+    return ts.isComputedPropertyName(name) && (0, migrations_1.getPropertyName)(name) === null;
+}

package/dist/src/generators/convert-to-inferred/lib/add-dev-server-target-to-config.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.addDevServerTargetToConfig = addDevServerTargetToConfig;
 const tsquery_1 = require("@phenomnomnominal/tsquery");
+const migrations_1 = require("../../../utils/migrations");
 /**
  * Add or update the webServerCommands and ciWebServerCommand options in the Cypress Config
  * Scenarios Covered:
@@ -14,7 +15,7 @@ const tsquery_1 = require("@phenomnomnominal/tsquery");
  */
 function addDevServerTargetToConfig(tree, configFilePath, webServerCommands, ciDevServerTarget) {
     let configFileContents = tree.read(configFilePath, 'utf-8');
-    let sourceFile = (0, tsquery_1.ast)(configFileContents);
+    let sourceFile = (0, migrations_1.parseSourceFile)(configFilePath, configFileContents);
     const NX_E2E_PRESET_SELECTOR = 'PropertyAssignment:has(Identifier[name=e2e]) CallExpression:has(Identifier[name=nxE2EPreset])';
     const nxE2ePresetOptionsNodes = (0, tsquery_1.query)(sourceFile, NX_E2E_PRESET_SELECTOR);
     if (nxE2ePresetOptionsNodes.length !== 0) {
@@ -38,7 +39,7 @@ function addDevServerTargetToConfig(tree, configFilePath, webServerCommands, ciD
         }
         if (ciDevServerTarget) {
             configFileContents = tree.read(configFilePath, 'utf-8');
-            sourceFile = (0, tsquery_1.ast)(configFileContents);
+            sourceFile = (0, migrations_1.parseSourceFile)(configFilePath, configFileContents);
             nxE2ePresetOptionsNode = (0, tsquery_1.query)(sourceFile, NX_E2E_PRESET_SELECTOR)[0];
             const NX_E2E_PRESET_OPTIONS_SELECTOR = 'PropertyAssignment:has(Identifier[name=e2e]) CallExpression:has(Identifier[name=nxE2EPreset]) > ObjectLiteralExpression';
             const optionsObjectNodes = (0, tsquery_1.query)(sourceFile, NX_E2E_PRESET_OPTIONS_SELECTOR);

package/dist/src/generators/convert-to-inferred/lib/add-exclude-spec-pattern.js

@@ -2,9 +2,10 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.addExcludeSpecPattern = addExcludeSpecPattern;
 const tsquery_1 = require("@phenomnomnominal/tsquery");
+const migrations_1 = require("../../../utils/migrations");
 function addExcludeSpecPattern(tree, configFilePath, excludeSpecPattern) {
     let configFileContents = tree.read(configFilePath, 'utf-8');
-    let sourceFile = (0, tsquery_1.ast)(configFileContents);
+    let sourceFile = (0, migrations_1.parseSourceFile)(configFilePath, configFileContents);
     const E2E_CONFIG_SELECTOR = 'PropertyAssignment:has(Identifier[name=e2e]) > ObjectLiteralExpression';
     const e2eConfigNodes = (0, tsquery_1.query)(sourceFile, E2E_CONFIG_SELECTOR);
     if (e2eConfigNodes.length !== 0) {

package/dist/src/generators/convert-to-inferred/lib/upsert-baseUrl.js

@@ -2,9 +2,10 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.upsertBaseUrl = upsertBaseUrl;
 const tsquery_1 = require("@phenomnomnominal/tsquery");
+const migrations_1 = require("../../../utils/migrations");
 function upsertBaseUrl(tree, configFilePath, baseUrlValueInProject) {
     const configFileContents = tree.read(configFilePath, 'utf-8');
-    const sourceFile = (0, tsquery_1.ast)(configFileContents);
+    const sourceFile = (0, migrations_1.parseSourceFile)(configFilePath, configFileContents);
     const BASE_URL_SELECTOR = 'PropertyAssignment:has(Identifier[name=e2e]) PropertyAssignment:has(Identifier[name="baseUrl"])';
     const baseUrlNodes = (0, tsquery_1.query)(sourceFile, BASE_URL_SELECTOR);
     if (baseUrlNodes.length !== 0) {