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

package/src/utils/config.js

@@ -0,0 +1,115 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getProjectCypressConfigPath = exports.addMountDefinition = exports.addDefaultCTConfig = exports.addDefaultE2EConfig = exports.CYPRESS_CONFIG_FILE_NAME_PATTERN = void 0;
+const devkit_1 = require("@nx/devkit");
+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}) `;
+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(() => require('@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)})`;
+        updatedConfigContents = tsquery.replace(cyConfigContents, `${TS_QUERY_EXPORT_CONFIG_PREFIX} ObjectLiteralExpression:first-child`, (node) => {
+            let baseUrlContents = baseUrl ? `,\nbaseUrl: '${baseUrl}'` : '';
+            if (node.properties.length > 0) {
+                return `{
+  ${node.properties.map((p) => p.getText()).join(',\n')},
+  e2e: { ...${configValue}${baseUrlContents} } 
+}`;
+            }
+            return `{
+  e2e: { ...${configValue}${baseUrlContents} }
+}`;
+        });
+        return isCommonJS
+            ? `const { nxE2EPreset } = require('@nx/cypress/plugins/cypress-preset');
+    
+    ${updatedConfigContents}`
+            : `import { nxE2EPreset } from '@nx/cypress/plugins/cypress-preset';
+    
+    ${updatedConfigContents}`;
+    }
+    return updatedConfigContents;
+}
+exports.addDefaultE2EConfig = addDefaultE2EConfig;
+/**
+ * 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
+ **/
+async function addDefaultCTConfig(cyConfigContents, options = {}) {
+    if (!cyConfigContents) {
+        throw new Error('The passed in cypress config file is empty!');
+    }
+    const { tsquery } = await Promise.resolve().then(() => require('@phenomnomnominal/tsquery'));
+    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)';
+        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)})`;
+            }
+        }
+        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} 
+}`;
+            }
+            return `{
+  component: ${configValue}
+}`;
+        });
+    }
+    return updatedConfigContents;
+}
+exports.addDefaultCTConfig = addDefaultCTConfig;
+/**
+ * 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.
+ **/
+async function addMountDefinition(cmpCommandFileContents) {
+    if (!cmpCommandFileContents) {
+        throw new Error('The passed in cypress component file is empty!');
+    }
+    const { tsquery } = await Promise.resolve().then(() => require('@phenomnomnominal/tsquery'));
+    const hasMountCommand = tsquery.query(cmpCommandFileContents, 'CallExpression StringLiteral[value="mount"]')?.length > 0;
+    if (hasMountCommand) {
+        return cmpCommandFileContents;
+    }
+    const mountCommand = `Cypress.Commands.add('mount', mount);`;
+    const updatedInterface = tsquery.replace(cmpCommandFileContents, 'InterfaceDeclaration', (node) => {
+        return `interface ${node.name.getText()}${node.typeParameters
+            ? `<${node.typeParameters.map((p) => p.getText()).join(', ')}>`
+            : ''} {
+      ${node.members.map((m) => m.getText()).join('\n      ')}
+      mount: typeof mount;
+    }`;
+    });
+    return `${updatedInterface}\n${mountCommand}`;
+}
+exports.addMountDefinition = addMountDefinition;
+function getProjectCypressConfigPath(tree, projectRoot) {
+    const cypressConfigPaths = (0, devkit_1.glob)(tree, [
+        (0, devkit_1.joinPathFragments)(projectRoot, exports.CYPRESS_CONFIG_FILE_NAME_PATTERN),
+    ]);
+    if (cypressConfigPaths.length === 0) {
+        throw new Error(`Could not find a cypress config file in ${projectRoot}.`);
+    }
+    return cypressConfigPaths[0];
+}
+exports.getProjectCypressConfigPath = getProjectCypressConfigPath;

package/src/utils/constants.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Key used to store options used by the nx plugin for @nx/cypress.
+ */
+export declare const NX_PLUGIN_OPTIONS = "__NxPluginOptions__";

package/src/utils/constants.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NX_PLUGIN_OPTIONS = void 0;
+/**
+ * Key used to store options used by the nx plugin for @nx/cypress.
+ */
+exports.NX_PLUGIN_OPTIONS = '__NxPluginOptions__';

package/src/utils/ct-helpers.d.ts

@@ -0,0 +1,16 @@
+import type { ExecutorContext, ProjectGraph } from '@nx/devkit';
+import { ProjectConfiguration, TargetConfiguration } from '@nx/devkit';
+export declare const CY_FILE_MATCHER: RegExp;
+/**
+ * return a path to a temp css file
+ * temp file is scoped to the project root
+ * i.e. <context.root>/tmp/<project-root>/ct-styles.css
+ */
+export declare function getTempTailwindPath(context: ExecutorContext): string;
+/**
+ * Checks if the childProjectName is a descendent of the parentProjectName
+ * in the project graph
+ **/
+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;

package/src/utils/ct-helpers.js

@@ -0,0 +1,86 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createExecutorContext = exports.getProjectConfigByPath = exports.isCtProjectUsingBuildProject = exports.getTempTailwindPath = exports.CY_FILE_MATCHER = void 0;
+const devkit_1 = require("@nx/devkit");
+const path_1 = require("path");
+const fs_1 = require("fs");
+const find_project_for_path_1 = require("nx/src/project-graph/utils/find-project-for-path");
+const project_graph_1 = require("nx/src/project-graph/project-graph");
+const configuration_1 = require("nx/src/config/configuration");
+exports.CY_FILE_MATCHER = new RegExp(/\.cy\.[tj]sx?$/);
+/**
+ * return a path to a temp css file
+ * temp file is scoped to the project root
+ * i.e. <context.root>/tmp/<project-root>/ct-styles.css
+ */
+function getTempTailwindPath(context) {
+    if (!context.projectName) {
+        throw new Error('No project name found in context');
+    }
+    const project = context?.projectGraph.nodes[context.projectName];
+    if (!project) {
+        throw new Error(`No project found in project graph for ${context.projectName}`);
+    }
+    if (project?.data?.root) {
+        return (0, path_1.join)(context.root, 'tmp', project.data.root, 'ct-styles.css');
+    }
+}
+exports.getTempTailwindPath = getTempTailwindPath;
+/**
+ * Checks if the childProjectName is a descendent of the parentProjectName
+ * in the project graph
+ **/
+function isCtProjectUsingBuildProject(graph, parentProjectName, childProjectName, seen = new Set()) {
+    if (seen.has(parentProjectName)) {
+        return false;
+    }
+    seen.add(parentProjectName);
+    const isProjectDirectDep = graph.dependencies[parentProjectName].some((p) => p.target === childProjectName);
+    if (isProjectDirectDep) {
+        return true;
+    }
+    const maybeIntermediateProjects = graph.dependencies[parentProjectName].filter((p) => !graph.externalNodes[p.target]);
+    for (const maybeIntermediateProject of maybeIntermediateProjects) {
+        if (isCtProjectUsingBuildProject(graph, maybeIntermediateProject.target, childProjectName, seen)) {
+            return true;
+        }
+    }
+    return false;
+}
+exports.isCtProjectUsingBuildProject = isCtProjectUsingBuildProject;
+function getProjectConfigByPath(graph, configPath) {
+    const configFileFromWorkspaceRoot = (0, path_1.relative)(devkit_1.workspaceRoot, configPath);
+    const normalizedPathFromWorkspaceRoot = (0, devkit_1.normalizePath)((0, fs_1.lstatSync)(configPath).isFile()
+        ? configFileFromWorkspaceRoot.replace((0, path_1.extname)(configPath), '')
+        : configFileFromWorkspaceRoot);
+    const projectRootMappings = (0, find_project_for_path_1.createProjectRootMappings)(graph.nodes);
+    const componentTestingProjectName = (0, find_project_for_path_1.findProjectForPath)(normalizedPathFromWorkspaceRoot, projectRootMappings);
+    if (!componentTestingProjectName ||
+        !graph.nodes[componentTestingProjectName]?.data) {
+        throw new Error((0, devkit_1.stripIndents) `Unable to find the project configuration that includes ${normalizedPathFromWorkspaceRoot}. 
+      Found project name? ${componentTestingProjectName}. 
+      Graph has data? ${!!graph.nodes[componentTestingProjectName]?.data}`);
+    }
+    // make sure name is set since it can be undefined
+    graph.nodes[componentTestingProjectName].data.name ??=
+        componentTestingProjectName;
+    return graph.nodes[componentTestingProjectName].data;
+}
+exports.getProjectConfigByPath = getProjectConfigByPath;
+function createExecutorContext(graph, targets, projectName, targetName, configurationName) {
+    const projectsConfigurations = (0, project_graph_1.readProjectsConfigurationFromProjectGraph)(graph);
+    const nxJsonConfiguration = (0, configuration_1.readNxJson)();
+    return {
+        cwd: process.cwd(),
+        projectGraph: graph,
+        target: targets[targetName],
+        targetName,
+        configurationName,
+        root: devkit_1.workspaceRoot,
+        isVerbose: false,
+        projectName,
+        projectsConfigurations,
+        nxJsonConfiguration,
+    };
+}
+exports.createExecutorContext = createExecutorContext;

package/src/utils/cypress-version.d.ts

@@ -0,0 +1,5 @@
+export declare function installedCypressVersion(): number;
+/**
+ * will not throw if cypress is not installed
+ */
+export declare function assertMinimumCypressVersion(minVersion: number): void;

package/src/utils/cypress-version.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assertMinimumCypressVersion = exports.installedCypressVersion = void 0;
+let cypressPackageJson;
+let loadedCypress = false;
+function installedCypressVersion() {
+    if (!loadedCypress) {
+        try {
+            cypressPackageJson = require('cypress/package.json');
+        }
+        catch { }
+    }
+    if (!cypressPackageJson) {
+        return null;
+    }
+    const cypressPackageVersion = cypressPackageJson.version;
+    const majorVersion = cypressPackageVersion.split('.')[0];
+    if (!majorVersion) {
+        return 0;
+    }
+    return +majorVersion;
+}
+exports.installedCypressVersion = installedCypressVersion;
+/**
+ * will not throw if cypress is not installed
+ */
+function assertMinimumCypressVersion(minVersion) {
+    const version = installedCypressVersion();
+    if (version && version < minVersion) {
+        throw new Error(`Cypress version of ${minVersion} or higher is not installed. Expected Cypress v${minVersion}+, found Cypress v${version} instead.`);
+    }
+}
+exports.assertMinimumCypressVersion = assertMinimumCypressVersion;

package/src/utils/find-target-options.d.ts

@@ -0,0 +1,17 @@
+import { TargetConfiguration, Tree } from '@nx/devkit';
+interface FindTargetOptions {
+    project: string;
+    /**
+     * contains buildable target such as react app or angular app
+     * <project>:<target>[:<configuration>]
+     */
+    buildTarget?: string;
+    validExecutorNames: Set<string>;
+    skipGetOptions?: boolean;
+}
+export interface FoundTarget {
+    config?: TargetConfiguration;
+    target: string;
+}
+export declare function findBuildConfig(tree: Tree, options: FindTargetOptions): Promise<FoundTarget>;
+export {};

package/src/utils/find-target-options.js

@@ -0,0 +1,136 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findBuildConfig = void 0;
+const devkit_1 = require("@nx/devkit");
+const configuration_1 = require("nx/src/config/configuration");
+const project_graph_1 = require("nx/src/project-graph/project-graph");
+async function findBuildConfig(tree, options) {
+    try {
+        // attempt to use the provided target
+        const graph = await (0, devkit_1.createProjectGraphAsync)();
+        if (options.buildTarget) {
+            return {
+                target: options.buildTarget,
+                config: findInTarget(tree, graph, options),
+            };
+        }
+        // check to see if there is a valid config in the given project
+        const selfProject = findTargetOptionsInProject(tree, graph, options.project, options);
+        if (selfProject) {
+            return selfProject;
+        }
+        // attempt to find any projects with the valid config in the graph that consumes this project
+        return await findInGraph(tree, graph, options);
+    }
+    catch (e) {
+        devkit_1.logger.error(e);
+        throw new Error((0, devkit_1.stripIndents) `Error trying to find build configuration. ${options.buildTarget
+            ? 'Try using an app of the same framework for the --build-target.'
+            : 'Try manually specifying the build target with the --build-target flag.'}
+    Provided project? ${options.project}
+    Provided build target? ${options.buildTarget}
+    Provided Executors? ${[...options.validExecutorNames].join(', ')}`);
+    }
+}
+exports.findBuildConfig = findBuildConfig;
+function findInTarget(tree, graph, options) {
+    const { project, target, configuration } = (0, devkit_1.parseTargetString)(options.buildTarget, graph);
+    const projectConfig = (0, devkit_1.readProjectConfiguration)(tree, project);
+    const executorName = projectConfig?.targets?.[target]?.executor;
+    if (!options.validExecutorNames.has(executorName)) {
+        devkit_1.logger.error((0, devkit_1.stripIndents) `NX The provided build target, ${options.buildTarget}, uses the '${executorName}' executor.
+But only the follow executors are allowed
+${Array.from(options.validExecutorNames)
+            .map((ve) => ` - ${ve}`)
+            .join('\n')}
+
+${frameworkHelperMessage(Array.from(options.buildTarget), executorName)}
+This is most likely because the provided --build-target is not a build target for an application or framework.
+For example, the provide build target, '${options.buildTarget}' is:
+ - the build target for a buildable/publishable library instead of an app.
+ - using a different framework than expected like react library using an angular or next app build target.
+
+If you do not have an app in the workspace to you can make a new app with 'nx g app' and use it just for component testing
+`);
+        throw new Error('The provided --build-target does not use an executor in the allow list of executors defined.');
+    }
+    const foundConfig = configuration || projectConfig?.targets?.[target]?.defaultConfiguration;
+    return (0, devkit_1.readTargetOptions)({ project, target, configuration: foundConfig }, createExecutorContext(graph, projectConfig.targets, project, target, foundConfig));
+}
+function frameworkHelperMessage(validExecutorNames, executorName) {
+    const executorsToFramework = {
+        '@nx/webpack:webpack': 'react',
+        '@nx/vite:build': 'react',
+        '@nrwl/webpack:webpack': 'react',
+        '@nrwl/vite:build': 'react',
+        '@nx/angular:webpack-browser': 'angular',
+        '@nrwl/angular:webpack-browser': 'angular',
+        '@angular-devkit/build-angular:browser': 'angular',
+        '@nx/next:build': 'next',
+        '@nrwl/next:build': 'next',
+    };
+    const buildTargetFramework = executorsToFramework[executorName];
+    const invokedGeneratorFramework = validExecutorNames.find((e) => !!executorsToFramework[e]);
+    if (buildTargetFramework &&
+        invokedGeneratorFramework &&
+        buildTargetFramework !== invokedGeneratorFramework) {
+        return `It looks like you're using a different plugin generator than the --build-target framework is set up for.
+The provided build target is configured for ${buildTargetFramework} instead of ${invokedGeneratorFramework}.
+Try using @nx/${buildTargetFramework} instead.`;
+    }
+    return '';
+}
+async function findInGraph(tree, graph, options) {
+    const parents = findParentsOfProject(graph, options.project);
+    const potentialTargets = [];
+    for (const parent of parents) {
+        const parentProject = findTargetOptionsInProject(tree, graph, parent.target, options);
+        if (parentProject) {
+            potentialTargets.push(parentProject);
+        }
+    }
+    if (potentialTargets.length > 1) {
+        devkit_1.logger.warn((0, devkit_1.stripIndents) `Multiple potential targets found for ${options.project}. Found ${potentialTargets.length}.
+    Using ${potentialTargets[0].target}.
+    To specify a different target use the --build-target flag.
+    `);
+    }
+    return potentialTargets[0];
+}
+function findParentsOfProject(graph, projectName) {
+    const reversedGraph = (0, devkit_1.reverse)(graph);
+    return reversedGraph.dependencies[projectName]
+        ? Object.values(reversedGraph.dependencies[projectName])
+        : [];
+}
+function findTargetOptionsInProject(tree, graph, projectName, options) {
+    const projectConfig = (0, devkit_1.readProjectConfiguration)(tree, projectName);
+    const includes = options.validExecutorNames;
+    for (const targetName in projectConfig.targets) {
+        const targetConfig = projectConfig.targets[targetName];
+        if (includes.has(targetConfig.executor)) {
+            return {
+                target: `${projectName}:${targetName}`,
+                config: !options.skipGetOptions
+                    ? (0, devkit_1.readTargetOptions)({ project: projectName, target: targetName }, createExecutorContext(graph, projectConfig.targets, projectName, targetName, null))
+                    : null,
+            };
+        }
+    }
+}
+function createExecutorContext(graph, targets, projectName, targetName, configurationName) {
+    const nxJsonConfiguration = (0, configuration_1.readNxJson)();
+    const projectsConfigurations = (0, project_graph_1.readProjectsConfigurationFromProjectGraph)(graph);
+    return {
+        cwd: process.cwd(),
+        projectGraph: graph,
+        target: targets[targetName],
+        targetName,
+        configurationName,
+        root: devkit_1.workspaceRoot,
+        isVerbose: false,
+        projectName,
+        projectsConfigurations,
+        nxJsonConfiguration,
+    };
+}

package/src/utils/project-name.d.ts

@@ -0,0 +1,3 @@
+export declare function getUnscopedLibName(libRoot: string): string;
+export declare function getE2eProjectName(targetProjectName: string, targetLibRoot: string, cypressDirectory?: string): string;
+export declare function filePathPrefix(directory: string): string;

package/src/utils/project-name.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.filePathPrefix = exports.getE2eProjectName = exports.getUnscopedLibName = void 0;
+const devkit_1 = require("@nx/devkit");
+function getUnscopedLibName(libRoot) {
+    return libRoot.slice(libRoot.lastIndexOf('/') + 1);
+}
+exports.getUnscopedLibName = getUnscopedLibName;
+function getE2eProjectName(targetProjectName, targetLibRoot, cypressDirectory) {
+    if (cypressDirectory) {
+        return `${filePathPrefix(cypressDirectory)}-${getUnscopedLibName(targetLibRoot)}-e2e`;
+    }
+    return `${targetProjectName}-e2e`;
+}
+exports.getE2eProjectName = getE2eProjectName;
+function filePathPrefix(directory) {
+    return `${(0, devkit_1.names)(directory).fileName}`.replace(new RegExp('/', 'g'), '-');
+}
+exports.filePathPrefix = filePathPrefix;

package/src/utils/start-dev-server.d.ts

@@ -0,0 +1,9 @@
+import { ExecutorContext } from '@nx/devkit';
+import { CypressExecutorOptions } from '../executors/cypress/cypress.impl';
+export declare function startDevServer(opts: Omit<CypressExecutorOptions, 'cypressConfig'>, context: ExecutorContext): AsyncGenerator<{
+    baseUrl: any;
+    portLockFilePath?: undefined;
+} | {
+    baseUrl: any;
+    portLockFilePath: string;
+}, void, unknown>;

package/src/utils/start-dev-server.js

@@ -0,0 +1,157 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.startDevServer = void 0;
+const devkit_1 = require("@nx/devkit");
+const path_1 = require("path");
+const detectPort = require("detect-port");
+const executor_utils_1 = require("nx/src/command-line/run/executor-utils");
+const fs_1 = require("fs");
+async function* startDevServer(opts, context) {
+    // no dev server, return the provisioned base url
+    if (!opts.devServerTarget || opts.skipServe) {
+        yield { baseUrl: opts.baseUrl };
+        return;
+    }
+    const parsedDevServerTarget = (0, devkit_1.parseTargetString)(opts.devServerTarget, context);
+    const [targetSupportsWatchOpt] = getValueFromSchema(context, parsedDevServerTarget, 'watch');
+    const overrides = {
+        // @NOTE: Do not forward watch option if not supported by the target dev server,
+        //  this is relevant for running Cypress against dev server target that does not support this option,
+        //  for instance @nguniversal/builders:ssr-dev-server.
+        ...(targetSupportsWatchOpt ? { watch: opts.watch } : {}),
+    };
+    if (opts.port === 'cypress-auto') {
+        const freePort = await getPortForProject(context, parsedDevServerTarget);
+        overrides['port'] = freePort;
+    }
+    else if (opts.port !== undefined) {
+        overrides['port'] = opts.port;
+        // zero is a special case that means any valid port so there is no reason to try to 'lock it'
+        if (opts.port !== 0) {
+            const didLock = attemptToLockPort(opts.port);
+            if (!didLock) {
+                devkit_1.logger.warn((0, devkit_1.stripIndents) `${opts.port} is potentially already in use by another cypress run.
+If the port is in use, try using a different port value or passing --port='cypress-auto' to find a free port.`);
+            }
+        }
+    }
+    for await (const output of await (0, devkit_1.runExecutor)(parsedDevServerTarget, overrides, context)) {
+        if (!output.success && !opts.watch)
+            throw new Error('Could not compile application files');
+        if (!opts.baseUrl &&
+            !output.baseUrl &&
+            !output.info?.baseUrl &&
+            (output.port || output.info?.port)) {
+            output.baseUrl = `http://localhost:${output.info.port}`;
+        }
+        yield {
+            baseUrl: opts.baseUrl || output.baseUrl || output.info?.baseUrl,
+            portLockFilePath: overrides.port && (0, path_1.join)(__dirname, `${overrides.port}.txt`),
+        };
+    }
+}
+exports.startDevServer = startDevServer;
+/**
+ * try to find a free port for the project to run on
+ * will return undefined if no port is found or the project doesn't have a port option
+ **/
+async function getPortForProject(context, target, defaultPort = 4200) {
+    const fmtTarget = (0, devkit_1.targetToTargetString)(target);
+    const [hasPortOpt, schemaPortValue] = getValueFromSchema(context, target, 'port');
+    let freePort;
+    if (hasPortOpt) {
+        let normalizedPortValue;
+        if (!schemaPortValue) {
+            devkit_1.logger.info(`NX ${fmtTarget} did not have a defined port value, checking for free port with the default value of ${defaultPort}`);
+            normalizedPortValue = defaultPort;
+        }
+        else {
+            normalizedPortValue = Number(schemaPortValue);
+        }
+        if (isNaN(normalizedPortValue)) {
+            devkit_1.output.warn({
+                title: `Port Not a Number`,
+                bodyLines: [
+                    `The port value found was not a number or can't be parsed to a number`,
+                    `When reading the devServerTarget (${fmtTarget}) schema, expected ${schemaPortValue} to be a number but got NaN.`,
+                    `Nx will use the default value of ${defaultPort} instead.`,
+                    `You can manually specify a port by setting the 'port' option`,
+                ],
+            });
+            normalizedPortValue = defaultPort;
+        }
+        try {
+            let attempts = 0;
+            // make sure when this check happens in parallel,
+            // we don't let the same port be used by multiple projects
+            do {
+                freePort = await detectPort(freePort || normalizedPortValue);
+                if (attemptToLockPort(freePort)) {
+                    break;
+                }
+                attempts++;
+                // increment port in case the lock file isn't cleaned up
+                freePort++;
+            } while (attempts < 20);
+            devkit_1.logger.info(`NX Using port ${freePort} for ${fmtTarget}`);
+        }
+        catch (err) {
+            throw new Error((0, devkit_1.stripIndents) `Unable to find a free port for the dev server, ${fmtTarget}.
+You can disable auto port detection by specifing a port or not passing a value to --port`);
+        }
+    }
+    else {
+        devkit_1.output.warn({
+            title: `No Port Option Found`,
+            bodyLines: [
+                `The 'port' option is set to 'cypress-auto', but the devServerTarget (${fmtTarget}) does not have a port option.`,
+                `Because of this, Nx is unable to verify the port is free before starting the dev server.`,
+                `This might cause issues if the devServerTarget is trying to use a port that is already in use.`,
+            ],
+        });
+    }
+    return freePort;
+}
+/**
+ * Check if the given target has the given property in it's options.
+ * if the property is does not have a default value or is not in the actual executor options,
+ * the value will be undefined even if it's in the executor schema.
+ **/
+function getValueFromSchema(context, target, property) {
+    let targetOpts;
+    try {
+        targetOpts = (0, devkit_1.readTargetOptions)(target, context);
+    }
+    catch (e) {
+        throw new Error(`Unable to read the target options for  ${(0, devkit_1.targetToTargetString)(target)}.
+Are you sure this is a valid target?
+Was trying to read the target for the property: '${property}', but got the following error: 
+${e.message || e}`);
+    }
+    let targetHasOpt = Object.keys(targetOpts).includes(property);
+    if (!targetHasOpt) {
+        // NOTE: readTargetOptions doesn't apply non defaulted values, i.e. @nx/vite has a port options but is optional
+        // so we double check the schema if readTargetOptions didn't return a value for the property
+        const projectConfig = context.projectsConfigurations?.projects?.[target.project];
+        const targetConfig = projectConfig.targets[target.target];
+        const [collection, executor] = targetConfig.executor.split(':');
+        const { schema } = (0, executor_utils_1.getExecutorInformation)(collection, executor, context.root, context.projectsConfigurations.projects);
+        // NOTE: schema won't have a default since readTargetOptions would have
+        // already set that and this check wouldn't need to be made
+        targetHasOpt = Object.keys(schema.properties).includes(property);
+    }
+    return [targetHasOpt, targetOpts[property]];
+}
+function attemptToLockPort(port) {
+    const portLockFilePath = (0, path_1.join)(__dirname, `${port}.txt`);
+    try {
+        if ((0, fs_1.existsSync)(portLockFilePath)) {
+            return false;
+        }
+        (0, fs_1.writeFileSync)(portLockFilePath, 'locked');
+        return true;
+    }
+    catch (err) {
+        return false;
+    }
+}

package/src/utils/versions.d.ts

@@ -0,0 +1,9 @@
+export declare const nxVersion: any;
+export declare const eslintPluginCypressVersion = "^2.13.4";
+export declare const typesNodeVersion = "18.16.9";
+export declare const cypressViteDevServerVersion = "^2.2.1";
+export declare const cypressVersion = "^13.6.6";
+export declare const cypressWebpackVersion = "^2.0.0";
+export declare const webpackHttpPluginVersion = "^5.5.0";
+export declare const viteVersion = "~5.0.0";
+export declare const htmlWebpackPluginVersion = "^5.5.0";

package/src/utils/versions.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.htmlWebpackPluginVersion = exports.viteVersion = exports.webpackHttpPluginVersion = exports.cypressWebpackVersion = exports.cypressVersion = exports.cypressViteDevServerVersion = exports.typesNodeVersion = exports.eslintPluginCypressVersion = exports.nxVersion = void 0;
+exports.nxVersion = require('../../package.json').version;
+exports.eslintPluginCypressVersion = '^2.13.4';
+exports.typesNodeVersion = '18.16.9';
+exports.cypressViteDevServerVersion = '^2.2.1';
+exports.cypressVersion = '^13.6.6';
+exports.cypressWebpackVersion = '^2.0.0';
+exports.webpackHttpPluginVersion = '^5.5.0';
+exports.viteVersion = '~5.0.0';
+exports.htmlWebpackPluginVersion = '^5.5.0';