@nx/cypress 0.0.0-pr-22179-271588f

package/src/migrations/update-16-8-0/cypress-13.d.ts

@@ -0,0 +1,7 @@
+import { type Tree } from '@nx/devkit';
+export declare function updateToCypress13(tree: Tree): Promise<void>;
+/**
+ * leave a comment on all usages of overriding built-ins that are now banned
+ **/
+export declare function shouldNotOverrideReadFile(tree: Tree, filePath: string): void;
+export default updateToCypress13;

package/src/migrations/update-16-8-0/cypress-13.js

@@ -0,0 +1,179 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.shouldNotOverrideReadFile = exports.updateToCypress13 = void 0;
+const devkit_1 = require("@nx/devkit");
+const cypress_version_1 = require("../../utils/cypress-version");
+const typescript_1 = require("typescript");
+const tsquery_1 = require("@phenomnomnominal/tsquery");
+const executor_options_utils_1 = require("@nx/devkit/src/generators/executor-options-utils");
+const JS_TS_FILE_MATCHER = /\.[jt]sx?$/;
+async function updateToCypress13(tree) {
+    if ((0, cypress_version_1.installedCypressVersion)() < 12) {
+        return;
+    }
+    const projects = (0, devkit_1.getProjects)(tree);
+    (0, executor_options_utils_1.forEachExecutorOptions)(tree, '@nx/cypress:cypress', (options, projectName) => {
+        if (!options.cypressConfig || !tree.exists(options.cypressConfig)) {
+            return;
+        }
+        const projectConfig = projects.get(projectName);
+        removeNodeVersionOption(tree, options.cypressConfig);
+        removeVideoUploadOnPassesOption(tree, options.cypressConfig);
+        (0, devkit_1.visitNotIgnoredFiles)(tree, projectConfig.root, (filePath) => {
+            if (!JS_TS_FILE_MATCHER.test(filePath)) {
+                return;
+            }
+            shouldNotOverrideReadFile(tree, filePath);
+        });
+    });
+    (0, devkit_1.updateJson)(tree, 'package.json', (json) => {
+        json.devDependencies ??= {};
+        json.devDependencies.cypress = '^13.0.0';
+        return json;
+    });
+    await (0, devkit_1.formatFiles)(tree);
+}
+exports.updateToCypress13 = updateToCypress13;
+function removeVideoUploadOnPassesOption(tree, configPath) {
+    const config = tree.read(configPath, 'utf-8');
+    const isUsingDeprecatedOption = tsquery_1.tsquery.query(config, getPropertyQuery('videoUploadOnPasses'))?.length > 0;
+    if (!isUsingDeprecatedOption) {
+        return;
+    }
+    const importStatement = configPath.endsWith('.ts')
+        ? "import fs from 'fs';"
+        : "const fs = require('fs');";
+    const replacementFunction = `/**
+* Delete videos for specs that do not contain failing or retried tests.
+* This function is to be used in the 'setupNodeEvents' configuration option as a replacement to 
+* 'videoUploadOnPasses' which has been removed.
+*
+* https://docs.cypress.io/guides/guides/screenshots-and-videos#Delete-videos-for-specs-without-failing-or-retried-tests
+**/
+function removePassedSpecs(on) {
+  on('after:spec', (spec, results) => {
+    if(results && results.vide) {
+      const hasFailures = results.tests.some(t => t.attempts.some(a =>  a.state === 'failed'));
+
+      if(!hasFailures) {
+        fs.unlinkSync(results.video);
+      }
+    }
+  })
+}`;
+    const withReplacementFn = `${importStatement}\n${config}\n${replacementFunction}`;
+    // setupNodeEvents can be a property or method.
+    const setupNodeEventsQuery = 'ExportAssignment ObjectLiteralExpression > :matches(PropertyAssignment:has(Identifier[name="setupNodeEvents"]), MethodDeclaration:has(Identifier[name="setupNodeEvents"]))';
+    const hasSetupNodeEvents = tsquery_1.tsquery.query(withReplacementFn, setupNodeEventsQuery)?.length > 0;
+    let updatedWithSetupNodeEvents = withReplacementFn;
+    if (hasSetupNodeEvents) {
+        // if have setupNodeEvents, update existing fn to use removePassedSpecs helper and remove videoUploadOnPasses
+        const noVideoUploadOption = tsquery_1.tsquery.replace(withReplacementFn, getPropertyQuery('videoUploadOnPasses'), (node) => {
+            if ((0, typescript_1.isObjectLiteralExpression)(node.initializer)) {
+                // is a nested config object
+                const key = node.name.getText().trim();
+                const listOfProperties = node.initializer.properties
+                    .map((j) => j.getText())
+                    .filter((j) => !j.includes('videoUploadOnPasses'))
+                    .join(',\n');
+                return `${key}: {
+    ${listOfProperties}
+}
+  `;
+            }
+            else {
+                if (isPropertyTopLevel(node)) {
+                    return `// ${node.getText()} `;
+                }
+            }
+        });
+        updatedWithSetupNodeEvents = tsquery_1.tsquery.replace(noVideoUploadOption, `${setupNodeEventsQuery} Block`, (node) => {
+            const blockWithoutBraces = node
+                .getFullText()
+                .trim()
+                .slice(1, -1)
+                .trim();
+            return `{
+  ${blockWithoutBraces}
+  removePassedSpecs(on);
+}
+`;
+        }, { visitAllChildren: false });
+    }
+    else {
+        // if don't have setupNodeEvents, replace videoUploadOnPasses with setupNodeEvents method
+        updatedWithSetupNodeEvents = tsquery_1.tsquery.replace(withReplacementFn, getPropertyQuery('videoUploadOnPasses'), () => {
+            return `setupNodeEvents(on, config) {
+  removePassedSpecs(on);
+}`;
+        });
+    }
+    tree.write(configPath, updatedWithSetupNodeEvents);
+}
+/**
+ * remove the nodeVersion option from the config file
+ **/
+function removeNodeVersionOption(tree, configPath) {
+    const config = tree.read(configPath, 'utf-8');
+    const updated = tsquery_1.tsquery.replace(config, getPropertyQuery('nodeVersion'), (node) => {
+        if ((0, typescript_1.isObjectLiteralExpression)(node.initializer)) {
+            // is a nested config object
+            const key = node.name.getText().trim();
+            const listOfProperties = node.initializer.properties
+                .map((j) => j.getFullText())
+                .filter((j) => !j.includes('nodeVersion'))
+                .join(',    ');
+            return `${key}: {
+    ${listOfProperties}
+  }`;
+        }
+        else {
+            if (isPropertyTopLevel(node)) {
+                return `// ${node.getText()}`;
+            }
+        }
+    });
+    if (updated !== config) {
+        tree.write(configPath, updated);
+    }
+}
+/**
+ * leave a comment on all usages of overriding built-ins that are now banned
+ **/
+function shouldNotOverrideReadFile(tree, filePath) {
+    const content = tree.read(filePath, 'utf-8');
+    const markedOverrideUsage = tsquery_1.tsquery.replace(content, 'PropertyAccessExpression:has(Identifier[name="overwrite"]):has(Identifier[name="Cypress"])', (node) => {
+        if (isAlreadyCommented(node)) {
+            return;
+        }
+        const expression = node.expression.getText().trim();
+        // prevent grabbing other Cypress.<something>.defaults
+        if (expression === 'Cypress.Commands') {
+            // get value.
+            const overwriteExpression = node.parent;
+            const command = overwriteExpression.arguments?.[0]?.text; // need string without quotes
+            if (command === 'readFile') {
+                // overwrite
+                return `/**
+* TODO(@nx/cypress): This command can no longer be overridden
+* Consider using a different name like 'custom_${command}'
+* More info: https://docs.cypress.io/guides/references/migration-guide#readFile-can-no-longer-be-overwritten-with-CypressCommandsoverwrite
+**/
+${node.getText()}`;
+            }
+        }
+    });
+    tree.write(filePath, markedOverrideUsage);
+}
+exports.shouldNotOverrideReadFile = shouldNotOverrideReadFile;
+function isAlreadyCommented(node) {
+    return node.getFullText().includes('TODO(@nx/cypress)');
+}
+function isPropertyTopLevel(node) {
+    return (node.parent &&
+        (0, typescript_1.isObjectLiteralExpression)(node.parent) &&
+        node.parent.parent &&
+        (0, typescript_1.isCallExpression)(node.parent.parent));
+}
+const getPropertyQuery = (propertyName) => `ExportAssignment ObjectLiteralExpression > PropertyAssignment:has(Identifier[name="${propertyName}"])`;
+exports.default = updateToCypress13;

package/src/migrations/update-18-1-0/update-cypress-version-13-6-6.d.ts

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

package/src/migrations/update-18-1-0/update-cypress-version-13-6-6.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const devkit_1 = require("@nx/devkit");
+const cypress_version_1 = require("../../utils/cypress-version");
+async function default_1(tree) {
+    if ((0, cypress_version_1.installedCypressVersion)() < 13) {
+        return;
+    }
+    (0, devkit_1.addDependenciesToPackageJson)(tree, {}, { cypress: '^13.6.6' });
+    await (0, devkit_1.formatFiles)(tree);
+}
+exports.default = default_1;

package/src/plugins/plugin.d.ts

@@ -0,0 +1,8 @@
+import { CreateDependencies, CreateNodes } from '@nx/devkit';
+export interface CypressPluginOptions {
+    ciTargetName?: string;
+    targetName?: string;
+    componentTestingTargetName?: string;
+}
+export declare const createDependencies: CreateDependencies;
+export declare const createNodes: CreateNodes<CypressPluginOptions>;

package/src/plugins/plugin.js

@@ -0,0 +1,195 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createNodes = exports.createDependencies = void 0;
+const devkit_1 = require("@nx/devkit");
+const path_1 = require("path");
+const js_1 = require("@nx/js");
+const get_named_inputs_1 = require("@nx/devkit/src/utils/get-named-inputs");
+const fs_1 = require("fs");
+const workspace_context_1 = require("nx/src/utils/workspace-context");
+const calculate_hash_for_create_nodes_1 = require("@nx/devkit/src/utils/calculate-hash-for-create-nodes");
+const cache_directory_1 = require("nx/src/utils/cache-directory");
+const constants_1 = require("../utils/constants");
+const config_utils_1 = require("@nx/devkit/src/utils/config-utils");
+const cachePath = (0, path_1.join)(cache_directory_1.projectGraphCacheDirectory, 'cypress.hash');
+const targetsCache = (0, fs_1.existsSync)(cachePath) ? readTargetsCache() : {};
+const calculatedTargets = {};
+function readTargetsCache() {
+    return (0, devkit_1.readJsonFile)(cachePath);
+}
+function writeTargetsToCache(targets) {
+    (0, devkit_1.writeJsonFile)(cachePath, targets);
+}
+const createDependencies = () => {
+    writeTargetsToCache(calculatedTargets);
+    return [];
+};
+exports.createDependencies = createDependencies;
+exports.createNodes = [
+    '**/cypress.config.{js,ts,mjs,cjs}',
+    async (configFilePath, options, context) => {
+        options = normalizeOptions(options);
+        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 = (0, calculate_hash_for_create_nodes_1.calculateHashForCreateNodes)(projectRoot, options, context, [
+            (0, js_1.getLockFileName)((0, devkit_1.detectPackageManager)(context.workspaceRoot)),
+        ]);
+        const targets = targetsCache[hash]
+            ? targetsCache[hash]
+            : await buildCypressTargets(configFilePath, projectRoot, options, context);
+        calculatedTargets[hash] = targets;
+        return {
+            projects: {
+                [projectRoot]: {
+                    projectType: 'application',
+                    targets,
+                },
+            },
+        };
+    },
+];
+function getOutputs(projectRoot, cypressConfig, testingType) {
+    function getOutput(path) {
+        if (path.startsWith('..')) {
+            return (0, path_1.join)('{workspaceRoot}', (0, path_1.join)(projectRoot, path));
+        }
+        else {
+            return (0, path_1.join)('{projectRoot}', path);
+        }
+    }
+    const { screenshotsFolder, videosFolder, e2e, component } = cypressConfig;
+    const outputs = [];
+    if (videosFolder) {
+        outputs.push(getOutput(videosFolder));
+    }
+    if (screenshotsFolder) {
+        outputs.push(getOutput(screenshotsFolder));
+    }
+    switch (testingType) {
+        case 'e2e': {
+            if (e2e.videosFolder) {
+                outputs.push(getOutput(e2e.videosFolder));
+            }
+            if (e2e.screenshotsFolder) {
+                outputs.push(getOutput(e2e.screenshotsFolder));
+            }
+            break;
+        }
+        case 'component': {
+            if (component.videosFolder) {
+                outputs.push(getOutput(component.videosFolder));
+            }
+            if (component.screenshotsFolder) {
+                outputs.push(getOutput(component.screenshotsFolder));
+            }
+            break;
+        }
+    }
+    return outputs;
+}
+async function buildCypressTargets(configFilePath, projectRoot, options, context) {
+    const cypressConfig = await (0, config_utils_1.loadConfigFile)((0, path_1.join)(context.workspaceRoot, configFilePath));
+    const pluginPresetOptions = {
+        ...cypressConfig.e2e?.[constants_1.NX_PLUGIN_OPTIONS],
+        ...cypressConfig.env,
+        ...cypressConfig.e2e?.env,
+    };
+    const webServerCommands = pluginPresetOptions?.webServerCommands;
+    const namedInputs = (0, get_named_inputs_1.getNamedInputs)(projectRoot, context);
+    const targets = {};
+    if ('e2e' in cypressConfig) {
+        targets[options.targetName] = {
+            command: `cypress run`,
+            options: { cwd: projectRoot },
+            cache: true,
+            inputs: getInputs(namedInputs),
+            outputs: getOutputs(projectRoot, cypressConfig, 'e2e'),
+        };
+        if (webServerCommands?.default) {
+            delete webServerCommands.default;
+        }
+        if (Object.keys(webServerCommands ?? {}).length > 0) {
+            targets[options.targetName].configurations ??= {};
+            for (const [configuration, webServerCommand] of Object.entries(webServerCommands ?? {})) {
+                targets[options.targetName].configurations[configuration] = {
+                    command: `cypress run --env webServerCommand="${webServerCommand}"`,
+                };
+            }
+        }
+        const ciWebServerCommand = pluginPresetOptions?.ciWebServerCommand;
+        if (ciWebServerCommand) {
+            const specPatterns = Array.isArray(cypressConfig.e2e.specPattern)
+                ? cypressConfig.e2e.specPattern.map((p) => (0, path_1.join)(projectRoot, p))
+                : [(0, path_1.join)(projectRoot, cypressConfig.e2e.specPattern)];
+            const excludeSpecPatterns = !cypressConfig.e2e
+                .excludeSpecPattern
+                ? cypressConfig.e2e.excludeSpecPattern
+                : Array.isArray(cypressConfig.e2e.excludeSpecPattern)
+                    ? cypressConfig.e2e.excludeSpecPattern.map((p) => (0, path_1.join)(projectRoot, p))
+                    : [(0, path_1.join)(projectRoot, cypressConfig.e2e.excludeSpecPattern)];
+            const specFiles = (0, workspace_context_1.globWithWorkspaceContext)(context.workspaceRoot, specPatterns, excludeSpecPatterns);
+            const dependsOn = [];
+            const outputs = getOutputs(projectRoot, cypressConfig, 'e2e');
+            const inputs = getInputs(namedInputs);
+            for (const file of specFiles) {
+                const relativeSpecFilePath = (0, path_1.relative)(projectRoot, file);
+                const targetName = options.ciTargetName + '--' + relativeSpecFilePath;
+                targets[targetName] = {
+                    outputs,
+                    inputs,
+                    cache: true,
+                    command: `cypress run --env webServerCommand="${ciWebServerCommand}" --spec ${relativeSpecFilePath}`,
+                    options: {
+                        cwd: projectRoot,
+                    },
+                };
+                dependsOn.push({
+                    target: targetName,
+                    projects: 'self',
+                    params: 'forward',
+                });
+            }
+            targets[options.ciTargetName] ??= {};
+            targets[options.ciTargetName] = {
+                executor: 'nx:noop',
+                cache: true,
+                inputs,
+                outputs,
+                dependsOn,
+            };
+        }
+    }
+    if ('component' in cypressConfig) {
+        // This will not override the e2e target if it is the same
+        targets[options.componentTestingTargetName] ??= {
+            command: `cypress run --component`,
+            options: { cwd: projectRoot },
+            cache: true,
+            inputs: getInputs(namedInputs),
+            outputs: getOutputs(projectRoot, cypressConfig, 'component'),
+        };
+    }
+    return targets;
+}
+function normalizeOptions(options) {
+    options ??= {};
+    options.targetName ??= 'e2e';
+    options.componentTestingTargetName ??= 'component-test';
+    options.ciTargetName ??= 'e2e-ci';
+    return options;
+}
+function getInputs(namedInputs) {
+    return [
+        ...('production' in namedInputs
+            ? ['default', '^production']
+            : ['default', '^default']),
+        {
+            externalDependencies: ['cypress'],
+        },
+    ];
+}

package/src/plugins/preprocessor-vite.d.ts

@@ -0,0 +1,32 @@
+/**
+ * https://github.com/mammadataei/cypress-vite
+ *
+ * MIT License
+ *
+ * Copyright (c) 2022 Mohammad Ataei
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of
+ * this software and associated documentation files (the "Software"), to deal in
+ * the Software without restriction, including without limitation the rights to
+ * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+ * the Software, and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+ * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+ * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+ * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ **/
+type CypressPreprocessor = (file: Record<string, any>) => string | Promise<string>;
+/**
+ * Use Vite as a file preprocess for Cypress test files.
+ * This preprocessor shouldn't be used directly.
+ * Instead, use the nxE2EPreset(__filename, { bundler: 'vite' }) function instead.
+ */
+declare function vitePreprocessor(userConfigPath?: string): CypressPreprocessor;
+export default vitePreprocessor;

package/src/plugins/preprocessor-vite.js

@@ -0,0 +1,97 @@
+"use strict";
+/**
+ * https://github.com/mammadataei/cypress-vite
+ *
+ * MIT License
+ *
+ * Copyright (c) 2022 Mohammad Ataei
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of
+ * this software and associated documentation files (the "Software"), to deal in
+ * the Software without restriction, including without limitation the rights to
+ * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+ * the Software, and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+ * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+ * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+ * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ **/
+Object.defineProperty(exports, "__esModule", { value: true });
+const path_1 = require("path");
+const cache = new Map();
+/**
+ * Use Vite as a file preprocess for Cypress test files.
+ * This preprocessor shouldn't be used directly.
+ * Instead, use the nxE2EPreset(__filename, { bundler: 'vite' }) function instead.
+ */
+function vitePreprocessor(userConfigPath) {
+    return async (file) => {
+        const { outputPath, filePath, shouldWatch } = file;
+        if (cache.has(filePath)) {
+            return cache.get(filePath);
+        }
+        const fileName = (0, path_1.basename)(outputPath);
+        const filenameWithoutExtension = (0, path_1.basename)(outputPath, (0, path_1.extname)(outputPath));
+        const defaultConfig = {
+            logLevel: 'silent',
+            define: {
+                'process.env.NODE_ENV': JSON.stringify(process.env.NODE_ENV),
+            },
+            build: {
+                emptyOutDir: false,
+                minify: false,
+                outDir: (0, path_1.dirname)(outputPath),
+                sourcemap: true,
+                write: true,
+                watch: getWatcherConfig(shouldWatch),
+                lib: {
+                    entry: filePath,
+                    fileName: () => fileName,
+                    formats: ['umd'],
+                    name: filenameWithoutExtension,
+                },
+            },
+        };
+        cache.set(filePath, outputPath);
+        const { build } = await Function('return import("vite")')();
+        const watcher = (await build({
+            configFile: userConfigPath,
+            ...defaultConfig,
+        }));
+        return new Promise((resolve, reject) => {
+            if (shouldWatch && isWatcher(watcher)) {
+                watcher.on('event', (event) => {
+                    if (event.code === 'END') {
+                        resolve(outputPath);
+                        file.emit('rerun');
+                    }
+                    if (event.code === 'ERROR') {
+                        console.error(event);
+                        reject(new Error(event.error.message));
+                    }
+                });
+                file.on('close', () => {
+                    cache.delete(filePath);
+                    watcher.close();
+                });
+            }
+            else {
+                resolve(outputPath);
+            }
+        });
+    };
+}
+function isWatcher(maybeWatcher) {
+    return maybeWatcher.on !== undefined;
+}
+function getWatcherConfig(shouldWatch) {
+    return shouldWatch ? {} : null;
+}
+exports.default = vitePreprocessor;

package/src/utils/add-linter.d.ts

@@ -0,0 +1,22 @@
+import { Tree } from '@nx/devkit';
+import { Linter } from '@nx/eslint';
+export interface CyLinterOptions {
+    project: string;
+    linter: Linter;
+    setParserOptionsProject?: boolean;
+    skipPackageJson?: boolean;
+    rootProject?: boolean;
+    js?: boolean;
+    /**
+     * Directory from the project root, where the cypress files will be located.
+     * typically src/ or cypress/
+     **/
+    cypressDir: string;
+    /**
+     * overwrite existing eslint rules for the cypress defaults
+     * This is useful when adding linting to a brand new project vs an existing one
+     **/
+    overwriteExisting?: boolean;
+    addPlugin?: boolean;
+}
+export declare function addLinterToCyProject(tree: Tree, options: CyLinterOptions): Promise<() => void>;

package/src/utils/add-linter.js

@@ -0,0 +1,93 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addLinterToCyProject = void 0;
+const devkit_1 = require("@nx/devkit");
+const eslint_1 = require("@nx/eslint");
+const cypress_version_1 = require("./cypress-version");
+const versions_1 = require("./versions");
+const eslint_file_1 = require("@nx/eslint/src/generators/utils/eslint-file");
+const global_eslint_config_1 = require("@nx/eslint/src/generators/init/global-eslint-config");
+async function addLinterToCyProject(tree, options) {
+    if (options.linter === eslint_1.Linter.None) {
+        return () => { };
+    }
+    const tasks = [];
+    const projectConfig = (0, devkit_1.readProjectConfiguration)(tree, options.project);
+    const eslintFile = (0, eslint_file_1.findEslintFile)(tree, projectConfig.root);
+    if (!eslintFile) {
+        tasks.push(await (0, eslint_1.lintProjectGenerator)(tree, {
+            project: options.project,
+            linter: options.linter,
+            skipFormat: true,
+            tsConfigPaths: [(0, devkit_1.joinPathFragments)(projectConfig.root, 'tsconfig.json')],
+            setParserOptionsProject: options.setParserOptionsProject,
+            skipPackageJson: options.skipPackageJson,
+            rootProject: options.rootProject,
+            addPlugin: options.addPlugin,
+        }));
+    }
+    if (!options.linter || options.linter !== eslint_1.Linter.EsLint) {
+        return (0, devkit_1.runTasksInSerial)(...tasks);
+    }
+    options.overwriteExisting = options.overwriteExisting || !eslintFile;
+    tasks.push(!options.skipPackageJson
+        ? (0, devkit_1.addDependenciesToPackageJson)(tree, {}, { 'eslint-plugin-cypress': versions_1.eslintPluginCypressVersion })
+        : () => { });
+    if ((0, eslint_file_1.isEslintConfigSupported)(tree)) {
+        const overrides = [];
+        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, eslint_file_1.addExtendsToLintConfig)(tree, projectConfig.root, 'plugin:cypress/recommended');
+        const cyVersion = (0, cypress_version_1.installedCypressVersion)();
+        /**
+         * We need this override because we enabled allowJS in the tsconfig to allow for JS based Cypress tests.
+         * That however leads to issues with the CommonJS Cypress plugin file.
+         */
+        const cy6Override = {
+            files: [`${options.cypressDir}/plugins/index.js`],
+            rules: {
+                '@typescript-eslint/no-var-requires': 'off',
+                'no-undef': 'off',
+            },
+        };
+        const addCy6Override = cyVersion && cyVersion < 7;
+        if (options.overwriteExisting) {
+            overrides.unshift({
+                files: ['*.ts', '*.tsx', '*.js', '*.jsx'],
+                parserOptions: !options.setParserOptionsProject
+                    ? undefined
+                    : {
+                        project: `${projectConfig.root}/tsconfig.*?.json`,
+                    },
+                rules: {},
+            });
+            if (addCy6Override) {
+                overrides.push(cy6Override);
+            }
+            (0, eslint_file_1.replaceOverridesInLintConfig)(tree, projectConfig.root, overrides);
+        }
+        else {
+            overrides.unshift({
+                files: [
+                    '*.cy.{ts,js,tsx,jsx}',
+                    `${options.cypressDir}/**/*.{ts,js,tsx,jsx}`,
+                ],
+                parserOptions: !options.setParserOptionsProject
+                    ? undefined
+                    : {
+                        project: `${projectConfig.root}/tsconfig.*?.json`,
+                    },
+                rules: {},
+            });
+            if (addCy6Override) {
+                overrides.push(cy6Override);
+            }
+            overrides.forEach((override) => (0, eslint_file_1.addOverrideToLintConfig)(tree, projectConfig.root, override));
+        }
+    }
+    return (0, devkit_1.runTasksInSerial)(...tasks);
+}
+exports.addLinterToCyProject = addLinterToCyProject;

package/src/utils/config.d.ts

@@ -0,0 +1,17 @@
+import { type Tree } from '@nx/devkit';
+import type { NxComponentTestingOptions, NxCypressE2EPresetOptions } from '../../plugins/cypress-preset';
+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
+ **/
+export declare function addDefaultCTConfig(cyConfigContents: string, options?: NxComponentTestingOptions): Promise<string>;
+/**
+ * Adds the mount command for Cypress
+ * Make sure after calling this the correct import statement is added
+ * to bring in the correct mount from cypress.
+ **/
+export declare function addMountDefinition(cmpCommandFileContents: string): Promise<string>;
+export declare function getProjectCypressConfigPath(tree: Tree, projectRoot: string): string;