@nx/cypress 23.1.0-beta.4 → 23.1.0-beta.6

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

@@ -5,7 +5,8 @@ exports.componentConfigurationGeneratorInternal = componentConfigurationGenerato
 exports.updateTsConfigForComponentTesting = updateTsConfigForComponentTesting;
 const tslib_1 = require("tslib");
 const devkit_1 = require("@nx/devkit");
-const internal_1 = require("@nx/js/internal");
+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");
@@ -19,7 +20,7 @@ function componentConfigurationGenerator(tree, options) {
 }
 async function componentConfigurationGeneratorInternal(tree, options) {
     (0, assert_supported_cypress_version_1.assertSupportedCypressVersion)(tree);
-    (0, internal_1.assertNotUsingTsSolutionSetup)(tree, 'cypress', 'component-configuration');
+    (0, internal_2.assertNotUsingTsSolutionSetup)(tree, 'cypress', 'component-configuration');
     const tasks = [];
     const opts = normalizeOptions(tree, options);
     if (!(0, versions_1.getInstalledCypressMajorVersion)(tree)) {
@@ -115,14 +116,24 @@ function updateNxJsonConfiguration(tree, hasPlugin) {
             !cacheableOperations.includes('component-test')) {
             cacheableOperations.push('component-test');
         }
-        nxJson.targetDefaults ??= {};
-        nxJson.targetDefaults['component-test'] ??= {};
-        nxJson.targetDefaults['component-test'].cache ??= true;
-        nxJson.targetDefaults['component-test'] ??= {};
-        nxJson.targetDefaults['component-test'].inputs ??= [
-            'default',
-            productionFileSet ? '^production' : '^default',
-        ];
+        // 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);
 }

package/dist/src/generators/init/init.js

@@ -14,15 +14,33 @@ function setupE2ETargetDefaults(tree) {
         return;
     }
     // E2e targets depend on all their project's sources + production sources of dependencies
-    nxJson.targetDefaults ??= {};
     const productionFileSet = !!nxJson.namedInputs?.production;
-    nxJson.targetDefaults.e2e ??= {};
-    nxJson.targetDefaults.e2e.cache ??= true;
-    nxJson.targetDefaults.e2e.inputs ??= [
-        'default',
-        productionFileSet ? '^production' : '^default',
-    ];
-    (0, devkit_1.updateNxJson)(tree, nxJson);
+    const existing = findExistingE2eDefault(nxJson.targetDefaults);
+    const patch = {};
+    if (existing?.cache === undefined)
+        patch.cache = true;
+    if (existing?.inputs === undefined) {
+        patch.inputs = ['default', productionFileSet ? '^production' : '^default'];
+    }
+    if (Object.keys(patch).length > 0) {
+        (0, internal_1.upsertTargetDefault)(tree, nxJson, { target: 'e2e', ...patch });
+        (0, devkit_1.updateNxJson)(tree, nxJson);
+    }
+}
+function findExistingE2eDefault(td) {
+    if (!td)
+        return undefined;
+    const value = td['e2e'];
+    if (value === undefined)
+        return undefined;
+    if (Array.isArray(value)) {
+        const found = value.find((e) => e.filter === undefined);
+        if (!found)
+            return undefined;
+        const { filter: _f, ...rest } = found;
+        return rest;
+    }
+    return value;
 }
 function updateDependencies(tree, options) {
     const tasks = [];

package/dist/src/migrations/update-21-0-0/remove-tsconfig-and-copy-files-options-from-cypress-executor.js

@@ -22,25 +22,42 @@ async function default_1(tree) {
     // update options from nx.json target defaults
     const nxJson = (0, devkit_1.readNxJson)(tree);
     if (nxJson.targetDefaults) {
-        for (const [targetOrExecutor, targetConfig] of Object.entries(nxJson.targetDefaults)) {
-            if (targetOrExecutor !== EXECUTOR_TO_MIGRATE &&
-                targetConfig.executor !== EXECUTOR_TO_MIGRATE) {
-                continue;
-            }
-            if (targetConfig.options) {
-                updateOptions(targetConfig);
-            }
-            Object.keys(targetConfig.configurations ?? {}).forEach((config) => {
-                updateConfiguration(targetConfig, config);
+        const targetDefaults = nxJson.targetDefaults;
+        for (const key of Object.keys(targetDefaults)) {
+            const value = targetDefaults[key];
+            const entries = Array.isArray(value)
+                ? value
+                : [value];
+            const usesExecutor = (entry) => key === EXECUTOR_TO_MIGRATE ||
+                entry.executor === EXECUTOR_TO_MIGRATE ||
+                entry.filter?.executor === EXECUTOR_TO_MIGRATE;
+            const kept = entries.filter((entry) => {
+                if (usesExecutor(entry)) {
+                    if (entry.options) {
+                        updateOptions(entry);
+                    }
+                    Object.keys(entry.configurations ?? {}).forEach((config) => {
+                        updateConfiguration(entry, config);
+                    });
+                }
+                // Drop entries left with nothing but their `filter`/`executor` locator.
+                return Object.keys(entry).some((k) => k !== 'filter' && k !== 'executor');
             });
-            if (!Object.keys(targetConfig).length ||
-                (Object.keys(targetConfig).length === 1 &&
-                    Object.keys(targetConfig)[0] === 'executor')) {
-                delete nxJson.targetDefaults[targetOrExecutor];
+            if (kept.length === 0) {
+                delete targetDefaults[key];
             }
-            if (!Object.keys(nxJson.targetDefaults).length) {
-                delete nxJson.targetDefaults;
+            else if (kept.length === 1 && kept[0].filter === undefined) {
+                // A lone unfiltered entry is stored as the plain object form (which
+                // omits `filter`).
+                const { filter: _filter, ...config } = kept[0];
+                targetDefaults[key] = config;
             }
+            else {
+                targetDefaults[key] = kept;
+            }
+        }
+        if (Object.keys(targetDefaults).length === 0) {
+            delete nxJson.targetDefaults;
         }
         (0, devkit_1.updateNxJson)(tree, nxJson);
     }

package/dist/src/migrations/update-23-1-0/disable-webpack-ct-just-in-time-compile.d.ts

@@ -0,0 +1,2 @@
+import { type Tree } from '@nx/devkit';
+export default function disableWebpackCtJustInTimeCompile(tree: Tree): Promise<void>;

package/dist/src/migrations/update-23-1-0/disable-webpack-ct-just-in-time-compile.js

@@ -0,0 +1,140 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = disableWebpackCtJustInTimeCompile;
+const devkit_1 = require("@nx/devkit");
+const internal_1 = require("@nx/js/internal");
+const tsquery_1 = require("@phenomnomnominal/tsquery");
+const config_1 = require("../../utils/config");
+const migrations_1 = require("../../utils/migrations");
+// @nx/remix component testing uses the vite dev server, so justInTimeCompile
+// (webpack only) does not apply even though the preset takes no bundler option.
+const NX_VITE_CT_PRESET = '@nx/remix/plugins/component-testing';
+let ts;
+async function disableWebpackCtJustInTimeCompile(tree) {
+    let wereProjectsMigrated = false;
+    for await (const { cypressConfigPath } of (0, migrations_1.cypressProjectConfigs)(tree)) {
+        if (!tree.exists(cypressConfigPath)) {
+            continue;
+        }
+        const contents = tree.read(cypressConfigPath, 'utf-8');
+        const config = (0, config_1.resolveCypressConfigObject)(contents);
+        if (!config) {
+            continue;
+        }
+        const component = (0, migrations_1.getObjectProperty)(config, 'component');
+        if (!component ||
+            !isWebpackComponentTesting(component) ||
+            setsJustInTimeCompile(component)) {
+            continue;
+        }
+        tree.write(cypressConfigPath, addJustInTimeCompile(contents, component));
+        wereProjectsMigrated = true;
+    }
+    if (wereProjectsMigrated) {
+        await (0, devkit_1.formatFiles)(tree);
+    }
+}
+function isWebpackComponentTesting(component) {
+    ts ??= (0, internal_1.ensureTypescript)();
+    // A vite bundler (inline devServer or preset options) opts out.
+    if (getComponentProperty(component, 'bundler').some((property) => ts.isStringLiteral(property.initializer) &&
+        property.initializer.text === 'vite')) {
+        return false;
+    }
+    // Preset-based config: trust it only when `component` actually calls
+    // nxComponentTestingPreset, so a stale/unused preset import doesn't count.
+    if (usesNxComponentTestingPreset(component)) {
+        // @nx/remix is the only vite-based Nx CT preset; resolve the import bound
+        // to the call so an unrelated remix reference elsewhere can't misclassify.
+        return getComponentTestingPresetImport(component) !== NX_VITE_CT_PRESET;
+    }
+    // Hand-written config: migrate only when it has an inline devServer framework.
+    return hasInlineDevServerFramework(component);
+}
+function usesNxComponentTestingPreset(component) {
+    ts ??= (0, internal_1.ensureTypescript)();
+    return (0, tsquery_1.query)(component, 'CallExpression').some((call) => ts.isIdentifier(call.expression) &&
+        call.expression.text === 'nxComponentTestingPreset');
+}
+function hasInlineDevServerFramework(component) {
+    ts ??= (0, internal_1.ensureTypescript)();
+    if (!ts.isObjectLiteralExpression(component.initializer)) {
+        return false;
+    }
+    const devServer = (0, migrations_1.getObjectProperty)(component.initializer, 'devServer');
+    if (!devServer || !ts.isObjectLiteralExpression(devServer.initializer)) {
+        return false;
+    }
+    return !!(0, migrations_1.getObjectProperty)(devServer.initializer, 'framework');
+}
+function getComponentProperty(component, name) {
+    ts ??= (0, internal_1.ensureTypescript)();
+    return (0, tsquery_1.query)(component, 'PropertyAssignment').filter((property) => ts.isIdentifier(property.name) && property.name.text === name);
+}
+// Resolves the module specifier that binds the `nxComponentTestingPreset`
+// identifier used inside `component`, covering both ESM `import` and CJS
+// `require` cypress configs. Returns null when no such binding is found.
+function getComponentTestingPresetImport(component) {
+    ts ??= (0, internal_1.ensureTypescript)();
+    for (const statement of component.getSourceFile().statements) {
+        if (ts.isImportDeclaration(statement) && statement.importClause) {
+            const namedBindings = statement.importClause.namedBindings;
+            if (namedBindings &&
+                ts.isNamedImports(namedBindings) &&
+                ts.isStringLiteral(statement.moduleSpecifier) &&
+                namedBindings.elements.some((element) => element.name.text === 'nxComponentTestingPreset')) {
+                return statement.moduleSpecifier.text;
+            }
+        }
+        if (ts.isVariableStatement(statement)) {
+            for (const declaration of statement.declarationList.declarations) {
+                const initializer = declaration.initializer;
+                if (!initializer ||
+                    !ts.isCallExpression(initializer) ||
+                    !ts.isIdentifier(initializer.expression) ||
+                    initializer.expression.text !== 'require' ||
+                    !ts.isObjectBindingPattern(declaration.name)) {
+                    continue;
+                }
+                const moduleSpecifier = initializer.arguments[0];
+                if (moduleSpecifier &&
+                    ts.isStringLiteral(moduleSpecifier) &&
+                    declaration.name.elements.some((element) => ts.isIdentifier(element.name) &&
+                        element.name.text === 'nxComponentTestingPreset')) {
+                    return moduleSpecifier.text;
+                }
+            }
+        }
+    }
+    return null;
+}
+function setsJustInTimeCompile(component) {
+    return getComponentProperty(component, 'justInTimeCompile').length > 0;
+}
+function addJustInTimeCompile(contents, component) {
+    ts ??= (0, internal_1.ensureTypescript)();
+    const indent = '    ';
+    const comment = config_1.JIT_COMPILE_DISABLE_COMMENT.map((line) => `${indent}${line}`).join('\n');
+    const newProperty = `${comment}\n${indent}justInTimeCompile: false,`;
+    const initializer = component.initializer;
+    // Object literal: insert the property after the last existing one, leaving
+    // the surrounding source (comments, formatting) untouched. `component` is
+    // gated to be non-empty before we reach here.
+    if (ts.isObjectLiteralExpression(initializer)) {
+        const properties = initializer.properties;
+        const lastProperty = properties[properties.length - 1];
+        let insertAt = lastProperty.getEnd();
+        if (properties.hasTrailingComma) {
+            // Insert after the existing trailing comma, not before it.
+            const commaIndex = contents.indexOf(',', insertAt);
+            if (commaIndex !== -1) {
+                insertAt = commaIndex + 1;
+            }
+        }
+        const separator = properties.hasTrailingComma ? '' : ',';
+        return `${contents.slice(0, insertAt)}${separator}\n${newProperty}${contents.slice(insertAt)}`;
+    }
+    // Preset call (or any other expression): wrap it in an object and spread.
+    const componentValue = `{\n${indent}...${initializer.getText()},\n${newProperty}\n  }`;
+    return `${contents.slice(0, component.getStart())}component: ${componentValue}${contents.slice(component.getEnd())}`;
+}

package/dist/src/migrations/update-23-1-0/disable-webpack-ct-just-in-time-compile.md

@@ -0,0 +1,38 @@
+#### Disable `justInTimeCompile` for webpack component testing
+
+Cypress 14+ defaults `justInTimeCompile` to `true` for the webpack dev server, compiling each spec on demand. In run mode the runner can load a component test before its spec finishes compiling, so the spec executes 0 tests while the run still exits green - a false pass that hides broken component tests in CI.
+
+This migration sets an explicit `justInTimeCompile: false` in the Cypress configs of webpack component testing projects, keeping the choice visible and reversible. Remove the line to opt back into just-in-time compilation.
+
+#### Sample Code Changes
+
+##### Before
+
+```ts title="apps/my-app/cypress.config.ts"
+import { defineConfig } from 'cypress';
+import { nxComponentTestingPreset } from '@nx/react/plugins/component-testing';
+
+export default defineConfig({
+  component: nxComponentTestingPreset(__filename),
+});
+```
+
+##### After
+
+```ts title="apps/my-app/cypress.config.ts"
+import { defineConfig } from 'cypress';
+import { nxComponentTestingPreset } from '@nx/react/plugins/component-testing';
+
+export default defineConfig({
+  component: {
+    ...nxComponentTestingPreset(__filename),
+    // Cypress 14+ defaults justInTimeCompile to true (webpack only), which can
+    // intermittently run 0 tests in CI. Remove this line to opt back in.
+    justInTimeCompile: false,
+  },
+});
+```
+
+#### What is not changed
+
+`justInTimeCompile` only applies to the webpack dev server, so vite-based component testing is left untouched. This migration skips vite configs (including `@nx/remix`, which uses the vite dev server), configs that already set `justInTimeCompile`, and e2e-only configs.

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

@@ -2,6 +2,7 @@ import { type Tree } from '@nx/devkit';
 import type { ObjectLiteralExpression } from 'typescript';
 import type { NxComponentTestingOptions, NxCypressE2EPresetOptions } from '../../plugins/cypress-preset';
 export declare const CYPRESS_CONFIG_FILE_NAME_PATTERN = "cypress.config.{js,ts,mjs,cjs}";
+export declare const JIT_COMPILE_DISABLE_COMMENT: string[];
 export declare function addDefaultE2EConfig(cyConfigContents: string, options: NxCypressE2EPresetOptions, baseUrl: string): Promise<string>;
 /**
  * Adds the nxComponentTestingPreset to the cypress config file.
@@ -13,8 +14,13 @@ export declare function addDefaultE2EConfig(cyConfigContents: string, options: N
  * doing so unconditionally produces mixed-syntax files in CJS workspaces
  * (an ESM `import` followed by a CJS `module.exports`), so prefer passing
  * `presetImportPath`.
+ *
+ * Pass `cypressMajorVersion` to opt webpack setups out of `justInTimeCompile`
+ * on Cypress 14+, where it defaults to `true` and can intermittently run 0
+ * tests in CI. The opt-out is emitted as an explicit `justInTimeCompile: false`
+ * so it is visible and reversible.
  **/
-export declare function addDefaultCTConfig(cyConfigContents: string, options?: NxComponentTestingOptions, presetImportPath?: string): Promise<string>;
+export declare function addDefaultCTConfig(cyConfigContents: string, options?: NxComponentTestingOptions, presetImportPath?: string, cypressMajorVersion?: number | null): Promise<string>;
 /**
  * Adds the mount command for Cypress
  * Make sure after calling this the correct import statement is added

package/dist/src/utils/config.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.CYPRESS_CONFIG_FILE_NAME_PATTERN = void 0;
+exports.JIT_COMPILE_DISABLE_COMMENT = exports.CYPRESS_CONFIG_FILE_NAME_PATTERN = void 0;
 exports.addDefaultE2EConfig = addDefaultE2EConfig;
 exports.addDefaultCTConfig = addDefaultCTConfig;
 exports.addMountDefinition = addMountDefinition;
@@ -11,6 +11,12 @@ const internal_1 = require("@nx/js/internal");
 exports.CYPRESS_CONFIG_FILE_NAME_PATTERN = 'cypress.config.{js,ts,mjs,cjs}';
 const TS_QUERY_COMMON_JS_EXPORT_SELECTOR = 'BinaryExpression:has(Identifier[name="module"]):has(Identifier[name="exports"])';
 const TS_QUERY_EXPORT_CONFIG_PREFIX = `:matches(ExportAssignment, ${TS_QUERY_COMMON_JS_EXPORT_SELECTOR}) `;
+// Shared so the CT generator (addDefaultCTConfig) and the
+// disable-webpack-ct-just-in-time-compile migration emit the identical note.
+exports.JIT_COMPILE_DISABLE_COMMENT = [
+    '// Cypress 14+ defaults justInTimeCompile to true (webpack only), which can',
+    '// intermittently run 0 tests in CI. Remove this line to opt back in.',
+];
 async function addDefaultE2EConfig(cyConfigContents, options, baseUrl) {
     if (!cyConfigContents) {
         throw new Error('The passed in cypress config file is empty!');
@@ -71,8 +77,13 @@ ${updatedConfigContents}`;
  * doing so unconditionally produces mixed-syntax files in CJS workspaces
  * (an ESM `import` followed by a CJS `module.exports`), so prefer passing
  * `presetImportPath`.
+ *
+ * Pass `cypressMajorVersion` to opt webpack setups out of `justInTimeCompile`
+ * on Cypress 14+, where it defaults to `true` and can intermittently run 0
+ * tests in CI. The opt-out is emitted as an explicit `justInTimeCompile: false`
+ * so it is visible and reversible.
  **/
-async function addDefaultCTConfig(cyConfigContents, options = {}, presetImportPath) {
+async function addDefaultCTConfig(cyConfigContents, options = {}, presetImportPath, cypressMajorVersion) {
     if (!cyConfigContents) {
         throw new Error('The passed in cypress config file is empty!');
     }
@@ -85,6 +96,11 @@ async function addDefaultCTConfig(cyConfigContents, options = {}, presetImportPa
         // See addDefaultE2EConfig for the rationale on __filename vs
         // import.meta.url.
         const pathToConfig = isCommonJS ? '__filename' : 'import.meta.url';
+        // justInTimeCompile only applies to the webpack dev server and only exists
+        // on Cypress 14+, where it defaults to true.
+        const disableJustInTimeCompile = options.bundler !== 'vite' &&
+            cypressMajorVersion != null &&
+            cypressMajorVersion >= 14;
         let configValue = `nxComponentTestingPreset(${pathToConfig})`;
         if (options) {
             if (options.bundler !== 'vite') {
@@ -95,15 +111,23 @@ async function addDefaultCTConfig(cyConfigContents, options = {}, presetImportPa
                 configValue = `nxComponentTestingPreset(${pathToConfig}, ${JSON.stringify(options)})`;
             }
         }
+        const jitComment = exports.JIT_COMPILE_DISABLE_COMMENT.map((line) => `    ${line}`).join('\n');
+        const componentValue = disableJustInTimeCompile
+            ? `{
+    ...${configValue},
+${jitComment}
+    justInTimeCompile: false,
+  }`
+            : configValue;
         updatedConfigContents = tsquery.replace(cyConfigContents, `${TS_QUERY_EXPORT_CONFIG_PREFIX} ObjectLiteralExpression:first-child`, (node) => {
             if (node.properties.length > 0) {
                 return `{
   ${node.properties.map((p) => p.getText()).join(',\n')},
-  component: ${configValue}
+  component: ${componentValue}
 }`;
             }
             return `{
-  component: ${configValue}
+  component: ${componentValue}
 }`;
         });
     }

package/migrations.json

@@ -52,6 +52,15 @@
       "description": "Rename imports of `createNodesV2` from `@nx/cypress/plugin` to the canonical `createNodes` export.",
       "implementation": "./dist/src/migrations/update-23-0-0/migrate-create-nodes-v2-to-create-nodes",
       "documentation": "./dist/src/migrations/update-23-0-0/migrate-create-nodes-v2-to-create-nodes.md"
+    },
+    "disable-webpack-ct-just-in-time-compile": {
+      "version": "23.1.0-beta.6",
+      "requires": {
+        "cypress": ">=14.0.0"
+      },
+      "description": "Set `justInTimeCompile: false` in webpack component testing Cypress configs on Cypress 14+, where it defaults to true and can intermittently run 0 tests in CI.",
+      "implementation": "./dist/src/migrations/update-23-1-0/disable-webpack-ct-just-in-time-compile",
+      "documentation": "./dist/src/migrations/update-23-1-0/disable-webpack-ct-just-in-time-compile.md"
     }
   },
   "packageJsonUpdates": {
@@ -127,6 +136,18 @@
           "alwaysAddToPackageJson": false
         }
       }
+    },
+    "23.1.0-eslint-plugin-cypress": {
+      "version": "23.1.0-beta.6",
+      "requires": {
+        "eslint-plugin-cypress": ">=2.0.0 <3.5.0"
+      },
+      "packages": {
+        "eslint-plugin-cypress": {
+          "version": "^3.5.0",
+          "alwaysAddToPackageJson": false
+        }
+      }
     }
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nx/cypress",
-  "version": "23.1.0-beta.4",
+  "version": "23.1.0-beta.6",
   "private": false,
   "type": "commonjs",
   "files": [
@@ -89,12 +89,12 @@
     "semver": "^7.6.3",
     "tree-kill": "^1.2.2",
     "tslib": "^2.3.0",
-    "@nx/devkit": "23.1.0-beta.4",
-    "@nx/eslint": "23.1.0-beta.4",
-    "@nx/js": "23.1.0-beta.4"
+    "@nx/devkit": "23.1.0-beta.6",
+    "@nx/js": "23.1.0-beta.6",
+    "@nx/eslint": "23.1.0-beta.6"
   },
   "devDependencies": {
-    "nx": "23.1.0-beta.4"
+    "nx": "23.1.0-beta.6"
   },
   "peerDependencies": {
     "cypress": ">= 13 < 16"