@nx/cypress 23.0.0-beta.2 → 23.0.0-beta.20

package/{src → dist/src}/plugins/plugin.js

@@ -1,10 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createNodesV2 = exports.createNodes = void 0;
+const internal_1 = require("@nx/devkit/internal");
 const devkit_1 = require("@nx/devkit");
-const calculate_hash_for_create_nodes_1 = require("@nx/devkit/src/utils/calculate-hash-for-create-nodes");
-const config_utils_1 = require("@nx/devkit/src/utils/config-utils");
-const get_named_inputs_1 = require("@nx/devkit/src/utils/get-named-inputs");
 const js_1 = require("@nx/js");
 const fs_1 = require("fs");
 const devkit_internals_1 = require("nx/src/devkit-internals");
@@ -30,28 +28,42 @@ exports.createNodes = [
         const optionsHash = (0, devkit_internals_1.hashObject)(options);
         const cachePath = (0, path_1.join)(cache_directory_1.workspaceDataDirectory, `cypress-${optionsHash}.hash`);
         const pluginCache = new plugin_cache_utils_1.PluginCache(cachePath);
-        const pmc = (0, devkit_1.getPackageManagerCommand)((0, devkit_1.detectPackageManager)(context.workspaceRoot));
+        const packageManager = (0, devkit_1.detectPackageManager)(context.workspaceRoot);
+        const pmc = (0, devkit_1.getPackageManagerCommand)(packageManager);
+        const lockFileName = (0, js_1.getLockFileName)(packageManager);
+        const normalizedOptions = normalizeOptions(options);
         try {
-            return await (0, devkit_1.createNodesFromFiles)((configFile, options, context) => createNodesInternal(configFile, options, context, pluginCache, pmc), configFiles, options, context);
+            const { entries, preErrors } = await filterCypressConfigs(configFiles, context);
+            const projectHashes = await (0, internal_1.calculateHashesForCreateNodes)(entries.map((e) => e.projectRoot), normalizedOptions, context, entries.map(() => [lockFileName]));
+            let results = [];
+            let nodeErrors = [];
+            try {
+                results = await (0, devkit_1.createNodesFromFiles)((configFile, _, ctx, idx) => createNodesInternal(configFile, normalizedOptions, ctx, pluginCache, pmc, projectHashes[idx]), entries.map((e) => e.configFile), options, context);
+            }
+            catch (e) {
+                if (e instanceof devkit_1.AggregateCreateNodesError) {
+                    results = e.partialResults ?? [];
+                    nodeErrors = e.errors;
+                }
+                else {
+                    throw e;
+                }
+            }
+            const allErrors = [...preErrors, ...nodeErrors];
+            if (allErrors.length > 0) {
+                throw new devkit_1.AggregateCreateNodesError(allErrors, results);
+            }
+            return results;
         }
         finally {
-            pluginCache.writeToDisk(cachePath);
+            pluginCache.writeToDisk();
         }
     },
 ];
 exports.createNodesV2 = exports.createNodes;
-async function createNodesInternal(configFilePath, options, context, pluginCache, pmc) {
-    options = normalizeOptions(options);
+async function createNodesInternal(configFilePath, options, context, pluginCache, pmc, projectHash) {
     const projectRoot = (0, path_1.dirname)(configFilePath);
-    // Do not create a project if package.json and project.json isn't there.
-    const siblingFiles = (0, fs_1.readdirSync)((0, path_1.join)(context.workspaceRoot, projectRoot));
-    if (!siblingFiles.includes('package.json') &&
-        !siblingFiles.includes('project.json')) {
-        return {};
-    }
-    const hash = (await (0, calculate_hash_for_create_nodes_1.calculateHashForCreateNodes)(projectRoot, options, context, [
-        (0, js_1.getLockFileName)((0, devkit_1.detectPackageManager)(context.workspaceRoot)),
-    ])) + configFilePath;
+    const hash = projectHash + configFilePath;
     if (!pluginCache.has(hash)) {
         pluginCache.set(hash, await buildCypressTargets(configFilePath, projectRoot, options, context, pmc));
     }
@@ -70,47 +82,63 @@ async function createNodesInternal(configFilePath, options, context, pluginCache
 function getTargetOutputs(outputs, subfolder) {
     return outputs.map((output) => subfolder ? (0, path_1.join)(output, subfolder) : output);
 }
-function getTargetConfig(cypressConfig, outputSubfolder, ciBaseUrl) {
+// Normalize a Cypress config folder (e.g. videosFolder, screenshotsFolder) to a
+// project-root-relative path, then append the per-spec subfolder. Cypress
+// resolves relative folders against the project root (cwd), so this keeps the
+// path Cypress writes to in lockstep with what Nx declares as the target's
+// outputs — regardless of whether the user wrote a relative path or computed
+// an absolute one (e.g. via `path.resolve` / `__dirname`).
+function serializeConfigPath(configPath, projectRoot, workspaceRoot, outputSubfolder) {
+    if (!configPath) {
+        return configPath;
+    }
+    const fullProjectRoot = (0, path_1.resolve)(workspaceRoot, projectRoot);
+    const fullConfigPath = (0, path_1.resolve)(fullProjectRoot, configPath);
+    const relativeConfigPath = (0, devkit_1.normalizePath)((0, path_1.relative)(fullProjectRoot, fullConfigPath));
+    return (0, devkit_1.normalizePath)((0, path_1.join)(relativeConfigPath, outputSubfolder));
+}
+function getTargetConfig(cypressConfig, projectRoot, workspaceRoot, outputSubfolder, ciBaseUrl) {
     const config = {};
     if (ciBaseUrl) {
         config['baseUrl'] = ciBaseUrl;
     }
     const { screenshotsFolder, videosFolder, e2e, component } = cypressConfig;
     if (videosFolder) {
-        config['videosFolder'] = (0, path_1.join)(videosFolder, outputSubfolder);
+        config['videosFolder'] = serializeConfigPath(videosFolder, projectRoot, workspaceRoot, outputSubfolder);
     }
     if (screenshotsFolder) {
-        config['screenshotsFolder'] = (0, path_1.join)(screenshotsFolder, outputSubfolder);
+        config['screenshotsFolder'] = serializeConfigPath(screenshotsFolder, projectRoot, workspaceRoot, outputSubfolder);
     }
     if (e2e) {
         config['e2e'] = {};
         if (e2e.videosFolder) {
-            config['e2e']['videosFolder'] = (0, path_1.join)(e2e.videosFolder, outputSubfolder);
+            config['e2e']['videosFolder'] = serializeConfigPath(e2e.videosFolder, projectRoot, workspaceRoot, outputSubfolder);
         }
         if (e2e.screenshotsFolder) {
-            config['e2e']['screenshotsFolder'] = (0, path_1.join)(e2e.screenshotsFolder, outputSubfolder);
+            config['e2e']['screenshotsFolder'] = serializeConfigPath(e2e.screenshotsFolder, projectRoot, workspaceRoot, outputSubfolder);
         }
     }
     if (component) {
         config['component'] = {};
         if (component.videosFolder) {
-            config['component']['videosFolder'] = (0, path_1.join)(component.videosFolder, outputSubfolder);
+            config['component']['videosFolder'] = serializeConfigPath(component.videosFolder, projectRoot, workspaceRoot, outputSubfolder);
         }
         if (component.screenshotsFolder) {
-            config['component']['screenshotsFolder'] = (0, path_1.join)(component.screenshotsFolder, outputSubfolder);
+            config['component']['screenshotsFolder'] = serializeConfigPath(component.screenshotsFolder, projectRoot, workspaceRoot, outputSubfolder);
         }
     }
     // Stringify twice to escape the quotes.
     return JSON.stringify(JSON.stringify(config));
 }
-function getOutputs(projectRoot, cypressConfig, testingType) {
-    function getOutput(path) {
-        if (path.startsWith('..')) {
-            return (0, devkit_1.joinPathFragments)('{workspaceRoot}', projectRoot, path);
-        }
-        else {
-            return (0, devkit_1.joinPathFragments)('{projectRoot}', path);
+function getOutputs(projectRoot, cypressConfig, testingType, workspaceRoot) {
+    const fullProjectRoot = (0, path_1.resolve)(workspaceRoot, projectRoot);
+    function getOutput(outputPath) {
+        const fullPath = (0, path_1.resolve)(fullProjectRoot, outputPath);
+        const relativeToProjectRoot = (0, devkit_1.normalizePath)((0, path_1.relative)(fullProjectRoot, fullPath));
+        if (relativeToProjectRoot.startsWith('..')) {
+            return (0, devkit_1.joinPathFragments)('{workspaceRoot}', (0, path_1.relative)(workspaceRoot, fullPath));
         }
+        return (0, devkit_1.joinPathFragments)('{projectRoot}', relativeToProjectRoot);
     }
     const { screenshotsFolder, videosFolder, e2e, component } = cypressConfig;
     const outputs = [];
@@ -143,7 +171,7 @@ function getOutputs(projectRoot, cypressConfig, testingType) {
     return outputs;
 }
 async function buildCypressTargets(configFilePath, projectRoot, options, context, pmc) {
-    const cypressConfig = await (0, config_utils_1.loadConfigFile)((0, path_1.join)(context.workspaceRoot, configFilePath));
+    const cypressConfig = await (0, internal_1.loadConfigFile)((0, path_1.join)(context.workspaceRoot, configFilePath));
     const pluginPresetOptions = {
         ...cypressConfig.e2e?.[constants_1.NX_PLUGIN_OPTIONS],
         ...cypressConfig.env,
@@ -151,7 +179,7 @@ async function buildCypressTargets(configFilePath, projectRoot, options, context
     };
     const webServerCommands = pluginPresetOptions?.webServerCommands;
     const shouldReuseExistingServer = pluginPresetOptions?.reuseExistingServer ?? true;
-    const namedInputs = (0, get_named_inputs_1.getNamedInputs)(projectRoot, context);
+    const namedInputs = (0, internal_1.getNamedInputs)(projectRoot, context);
     const targets = {};
     let metadata;
     const tsNodeCompilerOptions = JSON.stringify({ customConditions: null });
@@ -164,7 +192,7 @@ async function buildCypressTargets(configFilePath, projectRoot, options, context
             },
             cache: true,
             inputs: getInputs(namedInputs),
-            outputs: getOutputs(projectRoot, cypressConfig, 'e2e'),
+            outputs: getOutputs(projectRoot, cypressConfig, 'e2e', context.workspaceRoot),
             metadata: {
                 technologies: ['cypress'],
                 description: 'Runs Cypress Tests',
@@ -209,7 +237,7 @@ async function buildCypressTargets(configFilePath, projectRoot, options, context
             const { specFiles, specPatterns, excludeSpecPatterns } = await getSpecFilesAndPatternsForTestType(cypressConfig, 'e2e', context.workspaceRoot, projectRoot);
             const ciBaseUrl = pluginPresetOptions?.ciBaseUrl;
             const dependsOn = [];
-            const outputs = getOutputs(projectRoot, cypressConfig, 'e2e');
+            const outputs = getOutputs(projectRoot, cypressConfig, 'e2e', context.workspaceRoot);
             const inputs = getInputs(namedInputs);
             const groupName = 'E2E (CI)';
             metadata = { targetGroups: { [groupName]: [] } };
@@ -239,7 +267,7 @@ async function buildCypressTargets(configFilePath, projectRoot, options, context
                     outputs: getTargetOutputs(outputs, outputSubfolder),
                     inputs,
                     cache: true,
-                    command: `cypress run --env webServerCommand="${ciWebServerCommand}" --spec ${relativeSpecFilePath} --config=${getTargetConfig(cypressConfig, outputSubfolder, ciBaseUrl)}`,
+                    command: `cypress run --env webServerCommand="${ciWebServerCommand}" --spec ${relativeSpecFilePath} --config=${getTargetConfig(cypressConfig, projectRoot, context.workspaceRoot, outputSubfolder, ciBaseUrl)}`,
                     options: {
                         cwd: projectRoot,
                         env: { TS_NODE_COMPILER_OPTIONS: tsNodeCompilerOptions },
@@ -257,7 +285,6 @@ async function buildCypressTargets(configFilePath, projectRoot, options, context
                 };
                 dependsOn.push({
                     target: targetName,
-                    projects: 'self',
                     params: 'forward',
                     options: 'forward',
                 });
@@ -299,7 +326,7 @@ async function buildCypressTargets(configFilePath, projectRoot, options, context
     }
     if ('component' in cypressConfig) {
         const inputs = getInputs(namedInputs);
-        const outputs = getOutputs(projectRoot, cypressConfig, 'component');
+        const outputs = getOutputs(projectRoot, cypressConfig, 'component', context.workspaceRoot);
         // This will not override the e2e target if it is the same
         targets[options.componentTestingTargetName] ??= {
             command: `cypress run --component`,
@@ -351,7 +378,7 @@ async function buildCypressTargets(configFilePath, projectRoot, options, context
                     outputs: getTargetOutputs(outputs, outputSubfolder),
                     inputs,
                     cache: true,
-                    command: `cypress run --component --spec ${relativeSpecFilePath} --config=${getTargetConfig(cypressConfig, outputSubfolder)}`,
+                    command: `cypress run --component --spec ${relativeSpecFilePath} --config=${getTargetConfig(cypressConfig, projectRoot, context.workspaceRoot, outputSubfolder)}`,
                     options: {
                         cwd: projectRoot,
                         env: { TS_NODE_COMPILER_OPTIONS: tsNodeCompilerOptions },
@@ -373,7 +400,6 @@ async function buildCypressTargets(configFilePath, projectRoot, options, context
                 };
                 dependsOn.push({
                     target: targetName,
-                    projects: 'self',
                     params: 'forward',
                     options: 'forward',
                 });
@@ -467,3 +493,25 @@ async function getSpecFilesAndPatternsForTestType(cypressConfig, testType, works
     const specFiles = await (0, workspace_context_1.globWithWorkspaceContext)(workspaceRoot, specPatterns, excludeSpecPatterns);
     return { specFiles, specPatterns, excludeSpecPatterns };
 }
+async function filterCypressConfigs(configFiles, context) {
+    const preErrors = [];
+    const candidates = await Promise.all(configFiles.map(async (configFile) => {
+        try {
+            const projectRoot = (0, path_1.dirname)(configFile);
+            const siblingFiles = (0, fs_1.readdirSync)((0, path_1.join)(context.workspaceRoot, projectRoot));
+            if (!siblingFiles.includes('package.json') &&
+                !siblingFiles.includes('project.json')) {
+                return null;
+            }
+            return { configFile, projectRoot };
+        }
+        catch (e) {
+            preErrors.push([configFile, e]);
+            return null;
+        }
+    }));
+    return {
+        entries: candidates.filter((c) => c !== null),
+        preErrors,
+    };
+}

package/{src → dist/src}/plugins/preprocessor-vite.d.ts

@@ -31,4 +31,3 @@ type CypressPreprocessor = (file: Record<string, any>) => string | Promise<strin
  */
 declare function vitePreprocessor(configOverrides?: InlineConfig): CypressPreprocessor;
 export default vitePreprocessor;
-//# sourceMappingURL=preprocessor-vite.d.ts.map

package/{src → dist/src}/utils/add-linter.d.ts

@@ -20,4 +20,3 @@ export interface CyLinterOptions {
     addPlugin?: boolean;
 }
 export declare function addLinterToCyProject(tree: Tree, options: CyLinterOptions): Promise<() => void>;
-//# sourceMappingURL=add-linter.d.ts.map

package/{src → dist/src}/utils/add-linter.js

@@ -3,9 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.addLinterToCyProject = addLinterToCyProject;
 const devkit_1 = require("@nx/devkit");
 const eslint_1 = require("@nx/eslint");
-const global_eslint_config_1 = require("@nx/eslint/src/generators/init/global-eslint-config");
-const eslint_file_1 = require("@nx/eslint/src/generators/utils/eslint-file");
-const flat_config_1 = require("@nx/eslint/src/utils/flat-config");
+const internal_1 = require("@nx/eslint/internal");
 const versions_1 = require("./versions");
 async function addLinterToCyProject(tree, options) {
     if (options.linter === 'none') {
@@ -13,7 +11,7 @@ async function addLinterToCyProject(tree, options) {
     }
     const tasks = [];
     const projectConfig = (0, devkit_1.readProjectConfiguration)(tree, options.project);
-    const eslintFile = (0, eslint_file_1.findEslintFile)(tree, projectConfig.root);
+    const eslintFile = (0, internal_1.findEslintFile)(tree, projectConfig.root);
     if (!eslintFile) {
         tasks.push(await (0, eslint_1.lintProjectGenerator)(tree, {
             project: options.project,
@@ -32,30 +30,30 @@ async function addLinterToCyProject(tree, options) {
     options.overwriteExisting = options.overwriteExisting || !eslintFile;
     if (!options.skipPackageJson) {
         const pkgVersions = (0, versions_1.versions)(tree);
-        tasks.push((0, devkit_1.addDependenciesToPackageJson)(tree, {}, { 'eslint-plugin-cypress': pkgVersions.eslintPluginCypressVersion }));
+        tasks.push((0, devkit_1.addDependenciesToPackageJson)(tree, {}, { 'eslint-plugin-cypress': pkgVersions.eslintPluginCypressVersion }, undefined, true));
     }
-    if ((0, eslint_file_1.isEslintConfigSupported)(tree, projectConfig.root) ||
-        (0, eslint_file_1.isEslintConfigSupported)(tree)) {
+    if ((0, internal_1.isEslintConfigSupported)(tree, projectConfig.root) ||
+        (0, internal_1.isEslintConfigSupported)(tree)) {
         const overrides = [];
-        if ((0, flat_config_1.useFlatConfig)(tree)) {
-            (0, eslint_file_1.addPredefinedConfigToFlatLintConfig)(tree, projectConfig.root, 'recommended', {
+        if ((0, internal_1.useFlatConfig)(tree)) {
+            (0, internal_1.addPredefinedConfigToFlatLintConfig)(tree, projectConfig.root, 'recommended', {
                 moduleName: 'cypress',
                 moduleImportPath: 'eslint-plugin-cypress/flat',
                 spread: false,
                 insertAtTheEnd: false,
             });
-            (0, eslint_file_1.addOverrideToLintConfig)(tree, projectConfig.root, {
+            (0, internal_1.addOverrideToLintConfig)(tree, projectConfig.root, {
                 files: ['*.ts', '*.js'],
                 rules: {},
             });
         }
         else {
             if (options.rootProject) {
-                (0, eslint_file_1.addPluginsToLintConfig)(tree, projectConfig.root, '@nx');
-                overrides.push(global_eslint_config_1.typeScriptOverride);
-                overrides.push(global_eslint_config_1.javaScriptOverride);
+                (0, internal_1.addPluginsToLintConfig)(tree, projectConfig.root, '@nx');
+                overrides.push(internal_1.typeScriptOverride);
+                overrides.push(internal_1.javaScriptOverride);
             }
-            const addExtendsTask = (0, eslint_file_1.addExtendsToLintConfig)(tree, projectConfig.root, 'plugin:cypress/recommended');
+            const addExtendsTask = (0, internal_1.addExtendsToLintConfig)(tree, projectConfig.root, 'plugin:cypress/recommended');
             tasks.push(addExtendsTask);
         }
         /**
@@ -71,7 +69,7 @@ async function addLinterToCyProject(tree, options) {
         };
         if (options.overwriteExisting) {
             overrides.unshift({
-                files: (0, flat_config_1.useFlatConfig)(tree)
+                files: (0, internal_1.useFlatConfig)(tree)
                     ? // For flat configs we don't need to specify the files
                         undefined
                     : ['*.ts', '*.tsx', '*.js', '*.jsx'],
@@ -82,11 +80,11 @@ async function addLinterToCyProject(tree, options) {
                     },
                 rules: {},
             });
-            (0, eslint_file_1.replaceOverridesInLintConfig)(tree, projectConfig.root, overrides);
+            (0, internal_1.replaceOverridesInLintConfig)(tree, projectConfig.root, overrides);
         }
         else {
             overrides.unshift({
-                files: (0, flat_config_1.useFlatConfig)(tree)
+                files: (0, internal_1.useFlatConfig)(tree)
                     ? // For flat configs we don't need to specify the files
                         undefined
                     : [
@@ -100,7 +98,7 @@ async function addLinterToCyProject(tree, options) {
                     },
                 rules: {},
             });
-            overrides.forEach((override) => (0, eslint_file_1.addOverrideToLintConfig)(tree, projectConfig.root, override));
+            overrides.forEach((override) => (0, internal_1.addOverrideToLintConfig)(tree, projectConfig.root, override));
         }
     }
     return (0, devkit_1.runTasksInSerial)(...tasks);

package/dist/src/utils/assert-supported-cypress-version.d.ts

@@ -0,0 +1,2 @@
+import { type Tree } from '@nx/devkit';
+export declare function assertSupportedCypressVersion(tree: Tree): void;

package/dist/src/utils/assert-supported-cypress-version.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assertSupportedCypressVersion = assertSupportedCypressVersion;
+const internal_1 = require("@nx/devkit/internal");
+const versions_1 = require("./versions");
+function assertSupportedCypressVersion(tree) {
+    (0, internal_1.assertSupportedPackageVersion)(tree, 'cypress', versions_1.minSupportedCypressVersion);
+}

package/{src → dist/src}/utils/config.d.ts

@@ -4,11 +4,17 @@ import type { NxComponentTestingOptions, NxCypressE2EPresetOptions } from '../..
 export declare const CYPRESS_CONFIG_FILE_NAME_PATTERN = "cypress.config.{js,ts,mjs,cjs}";
 export declare function addDefaultE2EConfig(cyConfigContents: string, options: NxCypressE2EPresetOptions, baseUrl: string): Promise<string>;
 /**
- * Adds the nxComponentTestingPreset to the cypress config file
- * Make sure after calling this the correct import statement is addeda
- * to bring in the nxComponentTestingPreset function
+ * Adds the nxComponentTestingPreset to the cypress config file.
+ *
+ * Pass `presetImportPath` (e.g. `@nx/angular/plugins/component-testing`) to
+ * have the matching `import` (ESM) or `const { ... } = require(...)` (CJS)
+ * statement prepended automatically based on the detected module shape.
+ * Without it, the caller is responsible for prepending the import - but
+ * doing so unconditionally produces mixed-syntax files in CJS workspaces
+ * (an ESM `import` followed by a CJS `module.exports`), so prefer passing
+ * `presetImportPath`.
  **/
-export declare function addDefaultCTConfig(cyConfigContents: string, options?: NxComponentTestingOptions): Promise<string>;
+export declare function addDefaultCTConfig(cyConfigContents: string, options?: NxComponentTestingOptions, presetImportPath?: string): Promise<string>;
 /**
  * Adds the mount command for Cypress
  * Make sure after calling this the correct import statement is added
@@ -17,4 +23,3 @@ export declare function addDefaultCTConfig(cyConfigContents: string, options?: N
 export declare function addMountDefinition(cmpCommandFileContents: string): Promise<string>;
 export declare function getProjectCypressConfigPath(tree: Tree, projectRoot: string): string;
 export declare function resolveCypressConfigObject(cypressConfigContents: string): ObjectLiteralExpression | null;
-//# sourceMappingURL=config.d.ts.map

package/{src → dist/src}/utils/config.js

@@ -1,37 +1,4 @@
 "use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CYPRESS_CONFIG_FILE_NAME_PATTERN = void 0;
 exports.addDefaultE2EConfig = addDefaultE2EConfig;
@@ -40,7 +7,7 @@ exports.addMountDefinition = addMountDefinition;
 exports.getProjectCypressConfigPath = getProjectCypressConfigPath;
 exports.resolveCypressConfigObject = resolveCypressConfigObject;
 const devkit_1 = require("@nx/devkit");
-const ensure_typescript_1 = require("@nx/js/src/utils/typescript/ensure-typescript");
+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}) `;
@@ -48,13 +15,23 @@ async function addDefaultE2EConfig(cyConfigContents, options, baseUrl) {
     if (!cyConfigContents) {
         throw new Error('The passed in cypress config file is empty!');
     }
-    const { tsquery } = await Promise.resolve().then(() => __importStar(require('@phenomnomnominal/tsquery')));
+    const { tsquery } = await import('@phenomnomnominal/tsquery');
     const isCommonJS = tsquery.query(cyConfigContents, TS_QUERY_COMMON_JS_EXPORT_SELECTOR).length >
         0;
     const testingTypeConfig = tsquery.query(cyConfigContents, `${TS_QUERY_EXPORT_CONFIG_PREFIX} PropertyAssignment:has(Identifier[name="e2e"])`);
     let updatedConfigContents = cyConfigContents;
     if (testingTypeConfig.length === 0) {
-        const configValue = `nxE2EPreset(__filename, ${JSON.stringify(options, null, 2)
+        // ESM-shape configs use `import.meta.url` (a `file://...` URL string)
+        // because it's the most universally available `import.meta` field:
+        // Node's native TS strip exposes it in ESM scope, and Cypress's bundled
+        // tsx CJS loader provides it too (unlike `import.meta.dirname`, which
+        // older tsx versions don't shim). CJS-shape configs use `__filename`
+        // since `import.meta` isn't defined in plain CJS scope. The base
+        // template is selected to match the workspace's `type` field, so the
+        // shape detected here is consistent with how the file will actually be
+        // evaluated at runtime. `nxBaseCypressPreset` normalizes either form.
+        const pathToConfig = isCommonJS ? '__filename' : 'import.meta.url';
+        const configValue = `nxE2EPreset(${pathToConfig}, ${JSON.stringify(options, null, 2)
             .split('\n')
             .join('\n    ')})`;
         updatedConfigContents = tsquery.replace(cyConfigContents, `${TS_QUERY_EXPORT_CONFIG_PREFIX} ObjectLiteralExpression:first-child`, (node) => {
@@ -64,7 +41,7 @@ async function addDefaultE2EConfig(cyConfigContents, options, baseUrl) {
   ${node.properties.map((p) => p.getText()).join(',\n')},
   e2e: {
     ...${configValue}${baseUrlContents}
-  } 
+  }
 }`;
             }
             return `{
@@ -73,6 +50,9 @@ async function addDefaultE2EConfig(cyConfigContents, options, baseUrl) {
   }
 }`;
         });
+        // @nx/cypress's package exports cover both bare and `.js`-suffixed
+        // subpath forms, so emit the bare path - matches addDefaultCTConfig and
+        // keeps generated configs free of incidental `.js` noise.
         return isCommonJS
             ? `const { nxE2EPreset } = require('@nx/cypress/plugins/cypress-preset');
 ${updatedConfigContents}`
@@ -82,33 +62,44 @@ ${updatedConfigContents}`;
     return updatedConfigContents;
 }
 /**
- * Adds the nxComponentTestingPreset to the cypress config file
- * Make sure after calling this the correct import statement is addeda
- * to bring in the nxComponentTestingPreset function
+ * Adds the nxComponentTestingPreset to the cypress config file.
+ *
+ * Pass `presetImportPath` (e.g. `@nx/angular/plugins/component-testing`) to
+ * have the matching `import` (ESM) or `const { ... } = require(...)` (CJS)
+ * statement prepended automatically based on the detected module shape.
+ * Without it, the caller is responsible for prepending the import - but
+ * doing so unconditionally produces mixed-syntax files in CJS workspaces
+ * (an ESM `import` followed by a CJS `module.exports`), so prefer passing
+ * `presetImportPath`.
  **/
-async function addDefaultCTConfig(cyConfigContents, options = {}) {
+async function addDefaultCTConfig(cyConfigContents, options = {}, presetImportPath) {
     if (!cyConfigContents) {
         throw new Error('The passed in cypress config file is empty!');
     }
-    const { tsquery } = await Promise.resolve().then(() => __importStar(require('@phenomnomnominal/tsquery')));
+    const { tsquery } = await import('@phenomnomnominal/tsquery');
+    const isCommonJS = tsquery.query(cyConfigContents, TS_QUERY_COMMON_JS_EXPORT_SELECTOR).length >
+        0;
     const testingTypeConfig = tsquery.query(cyConfigContents, `${TS_QUERY_EXPORT_CONFIG_PREFIX} PropertyAssignment:has(Identifier[name="component"])`);
     let updatedConfigContents = cyConfigContents;
     if (testingTypeConfig.length === 0) {
-        let configValue = 'nxComponentTestingPreset(__filename)';
+        // See addDefaultE2EConfig for the rationale on __filename vs
+        // import.meta.url.
+        const pathToConfig = isCommonJS ? '__filename' : 'import.meta.url';
+        let configValue = `nxComponentTestingPreset(${pathToConfig})`;
         if (options) {
             if (options.bundler !== 'vite') {
                 // vite is the default bundler, so we don't need to set it
                 delete options.bundler;
             }
             if (Object.keys(options).length) {
-                configValue = `nxComponentTestingPreset(__filename, ${JSON.stringify(options)})`;
+                configValue = `nxComponentTestingPreset(${pathToConfig}, ${JSON.stringify(options)})`;
             }
         }
         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: ${configValue}
 }`;
             }
             return `{
@@ -116,6 +107,19 @@ async function addDefaultCTConfig(cyConfigContents, options = {}) {
 }`;
         });
     }
+    if (presetImportPath) {
+        // Use the path verbatim - callers pass the public exported subpath. Don't
+        // append `.js`: @nx/react and @nx/angular's package exports only declare
+        // the bare `./plugins/component-testing` subpath, so a `.js` suffix
+        // breaks strict ESM resolution with ERR_PACKAGE_PATH_NOT_EXPORTED.
+        // (addDefaultE2EConfig hard-codes `.js` because @nx/cypress has no
+        // exports map - it can get away with the suffix; subpath-exporting
+        // packages cannot.)
+        const prefix = isCommonJS
+            ? `const { nxComponentTestingPreset } = require('${presetImportPath}');\n`
+            : `import { nxComponentTestingPreset } from '${presetImportPath}';\n`;
+        return `${prefix}${updatedConfigContents}`;
+    }
     return updatedConfigContents;
 }
 /**
@@ -127,7 +131,7 @@ async function addMountDefinition(cmpCommandFileContents) {
     if (!cmpCommandFileContents) {
         throw new Error('The passed in cypress component file is empty!');
     }
-    const { tsquery } = await Promise.resolve().then(() => __importStar(require('@phenomnomnominal/tsquery')));
+    const { tsquery } = await import('@phenomnomnominal/tsquery');
     const hasMountCommand = tsquery.query(cmpCommandFileContents, 'CallExpression StringLiteral[value="mount"]')?.length > 0;
     if (hasMountCommand) {
         return cmpCommandFileContents;
@@ -153,7 +157,7 @@ function getProjectCypressConfigPath(tree, projectRoot) {
     return cypressConfigPaths[0];
 }
 function resolveCypressConfigObject(cypressConfigContents) {
-    const ts = (0, ensure_typescript_1.ensureTypescript)();
+    const ts = (0, internal_1.ensureTypescript)();
     const { tsquery } = (require('@phenomnomnominal/tsquery'));
     const sourceFile = tsquery.ast(cypressConfigContents);
     const exportDefaultStatement = sourceFile.statements.find((statement) => ts.isExportAssignment(statement));
@@ -169,7 +173,7 @@ function resolveCypressConfigObject(cypressConfigContents) {
     return null;
 }
 function resolveCypressConfigObjectFromExportExpression(exportExpression, sourceFile) {
-    const ts = (0, ensure_typescript_1.ensureTypescript)();
+    const ts = (0, internal_1.ensureTypescript)();
     if (ts.isObjectLiteralExpression(exportExpression)) {
         return exportExpression;
     }

package/{src → dist/src}/utils/constants.d.ts

@@ -2,4 +2,3 @@
  * Key used to store options used by the nx plugin for @nx/cypress.
  */
 export declare const NX_PLUGIN_OPTIONS = "__NxPluginOptions__";
-//# sourceMappingURL=constants.d.ts.map

package/{src → dist/src}/utils/ct-helpers.d.ts

@@ -14,4 +14,3 @@ export declare function getTempTailwindPath(context: ExecutorContext): string;
 export declare function isCtProjectUsingBuildProject(graph: ProjectGraph, parentProjectName: string, childProjectName: string, seen?: Set<string>): boolean;
 export declare function getProjectConfigByPath(graph: ProjectGraph, configPath: string): ProjectConfiguration;
 export declare function createExecutorContext(graph: ProjectGraph, targets: Record<string, TargetConfiguration>, projectName: string, targetName: string, configurationName: string): ExecutorContext;
-//# sourceMappingURL=ct-helpers.d.ts.map

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

@@ -0,0 +1,3 @@
+export declare const CYPRESS_EXECUTOR_DEPRECATION_MESSAGE = "The `@nx/cypress:cypress` executor is deprecated and will be removed in Nx v24. Run `nx g @nx/cypress:convert-to-inferred` to migrate to the `@nx/cypress/plugin` inferred targets. See https://nx.dev/docs/guides/tasks--caching/convert-to-inferred for details.";
+export declare function warnCypressExecutorDeprecation(): void;
+export declare function warnCypressExecutorGenerating(): void;

package/dist/src/utils/deprecation.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CYPRESS_EXECUTOR_DEPRECATION_MESSAGE = void 0;
+exports.warnCypressExecutorDeprecation = warnCypressExecutorDeprecation;
+exports.warnCypressExecutorGenerating = warnCypressExecutorGenerating;
+const devkit_1 = require("@nx/devkit");
+// TODO(v24): Remove the @nx/cypress:cypress executor. The inferred plugin
+// (@nx/cypress/plugin) and the convert-to-inferred generator stay supported.
+exports.CYPRESS_EXECUTOR_DEPRECATION_MESSAGE = 'The `@nx/cypress:cypress` executor is deprecated and will be removed in Nx v24. Run `nx g @nx/cypress:convert-to-inferred` to migrate to the `@nx/cypress/plugin` inferred targets. See https://nx.dev/docs/guides/tasks--caching/convert-to-inferred for details.';
+function warnCypressExecutorDeprecation() {
+    devkit_1.logger.warn(exports.CYPRESS_EXECUTOR_DEPRECATION_MESSAGE);
+}
+// Fired when the @nx/cypress:configuration or :component-configuration
+// generator is about to generate a target that uses the deprecated executor —
+// i.e. when @nx/cypress/plugin isn't registered in nx.json. Surfaces the
+// deprecation at generation time rather than only when the user later runs the
+// generated target.
+function warnCypressExecutorGenerating() {
+    devkit_1.logger.warn('Generating a target that uses the deprecated `@nx/cypress:cypress` executor. The executor will be removed in Nx v24. Run `nx g @nx/cypress:convert-to-inferred` next to migrate this target to the `@nx/cypress/plugin` inferred plugin and prevent future generators from emitting executor targets. See https://nx.dev/docs/guides/tasks--caching/convert-to-inferred for details.');
+}

package/{src → dist/src}/utils/find-target-options.d.ts

@@ -15,4 +15,3 @@ export interface FoundTarget {
 }
 export declare function findBuildConfig(tree: Tree, options: FindTargetOptions): Promise<FoundTarget>;
 export {};
-//# sourceMappingURL=find-target-options.d.ts.map

package/{src → dist/src}/utils/migrations.d.ts

@@ -11,4 +11,3 @@ export declare function updateObjectProperty(config: ObjectLiteralExpression, pr
     newName?: string;
     newValue?: Expression;
 }): ObjectLiteralExpression;
-//# sourceMappingURL=migrations.d.ts.map