@nx/cypress 23.3.0-beta.0 → 23.3.0-beta.2

package/dist/src/migrations/update-23-3-0/update-cypress-16-config-options.js

@@ -0,0 +1,241 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = updateCypress16ConfigOptions;
+const devkit_1 = require("@nx/devkit");
+const internal_1 = require("@nx/js/internal");
+const config_1 = require("../../utils/config");
+const migrations_1 = require("../../utils/migrations");
+// Cypress 16 breakingOptions (packages/config/src/options.ts).
+const REMOVED_OPTIONS = [
+    'experimentalSourceRewriting',
+    'allowCypressEnv',
+    'execTimeout',
+];
+const RENAMED_OPTIONS = {
+    experimentalMemoryManagement: 'manageBrowserMemory',
+};
+const FAST_VISIBILITY_OPTION = 'experimentalFastVisibility';
+const VISIBILITY_STRATEGY_OPTION = 'visibilityStrategy';
+const MIGRATE_BY_HAND = `migrate ${[
+    ...REMOVED_OPTIONS,
+    ...Object.keys(RENAMED_OPTIONS),
+    FAST_VISIBILITY_OPTION,
+]
+    .map((option) => `\`${option}\``)
+    .join(', ')} in its source by hand if it sets them`;
+// Cypress reads these options at the top level and inside `e2e`/`component`.
+const TESTING_TYPE_BLOCKS = ['e2e', 'component'];
+// The Nx presets never return one of the options above, so their spreads
+// are not reported as unresolved.
+const NX_PRESET_CALLS = ['nxE2EPreset', 'nxComponentTestingPreset'];
+let ts;
+async function updateCypress16ConfigOptions(tree) {
+    const unhandled = [];
+    let wereConfigsMigrated = false;
+    for await (const { cypressConfigPath } of (0, migrations_1.cypressProjectConfigs)(tree)) {
+        if (!tree.exists(cypressConfigPath)) {
+            continue;
+        }
+        const contents = tree.read(cypressConfigPath, 'utf-8');
+        const config = (0, config_1.resolveCypressConfigObject)(contents);
+        if (!config) {
+            unhandled.push(`${cypressConfigPath}: the config object could not be resolved statically; ${MIGRATE_BY_HAND}`);
+            continue;
+        }
+        ts ??= (0, internal_1.ensureTypescript)();
+        const { blocks, unresolvedSpreads } = getOptionBlocks(config);
+        for (const spread of unresolvedSpreads) {
+            unhandled.push(`${cypressConfigPath}: the \`${spread.getText()}\` spread could not be resolved statically; ${MIGRATE_BY_HAND}`);
+        }
+        const changes = [];
+        for (const block of blocks) {
+            for (const property of block.properties) {
+                if (!isConfigProperty(property)) {
+                    continue;
+                }
+                const name = getPropertyName(property.name);
+                if (name === null) {
+                    continue;
+                }
+                if (REMOVED_OPTIONS.includes(name)) {
+                    changes.push(...removeProperty(contents, property));
+                    const followUp = getRemovalFollowUp(property);
+                    if (followUp) {
+                        unhandled.push(`${cypressConfigPath}: ${followUp}`);
+                    }
+                }
+                else if (name in RENAMED_OPTIONS) {
+                    const newName = RENAMED_OPTIONS[name];
+                    if (hasProperty(block, newName)) {
+                        changes.push(...removeProperty(contents, property));
+                    }
+                    else if (ts.isPropertyAssignment(property)) {
+                        changes.push(...replaceNode(property.name, newName));
+                    }
+                    else {
+                        changes.push(...replaceNode(property, `${newName}: ${name}`));
+                    }
+                }
+                else if (name === FAST_VISIBILITY_OPTION) {
+                    const strategy = getVisibilityStrategy(property);
+                    if (hasProperty(block, VISIBILITY_STRATEGY_OPTION)) {
+                        changes.push(...removeProperty(contents, property));
+                    }
+                    else if (strategy) {
+                        changes.push(...replaceNode(property, `${VISIBILITY_STRATEGY_OPTION}: '${strategy}'`));
+                    }
+                    else {
+                        unhandled.push(`${cypressConfigPath}: \`${FAST_VISIBILITY_OPTION}\` is set to a non-literal value (${getValueText(property)}); replace it with \`${VISIBILITY_STRATEGY_OPTION}: 'modern'\` (was true) or \`${VISIBILITY_STRATEGY_OPTION}: 'legacy'\` (was false)`);
+                    }
+                }
+            }
+        }
+        if (changes.length > 0) {
+            tree.write(cypressConfigPath, (0, devkit_1.applyChangesToString)(contents, changes));
+            wereConfigsMigrated = true;
+        }
+    }
+    if (wereConfigsMigrated) {
+        await (0, devkit_1.formatFiles)(tree);
+    }
+    if (unhandled.length > 0) {
+        return {
+            nextSteps: unhandled.map((item) => `Review the Cypress config option change: ${item}`),
+            agentContext: unhandled,
+        };
+    }
+}
+// Removed options whose value carried intent the replacement needs. A
+// shorthand value is unknown, so it gets the follow-up too.
+function getRemovalFollowUp(property) {
+    const name = getPropertyName(property.name);
+    if (name === 'execTimeout') {
+        return `removed \`${property.getText()}\`; \`cy.exec()\` is gone, set \`taskTimeout\` if the replacement \`cy.task()\` needs more than the 60000ms default`;
+    }
+    if (name === 'experimentalSourceRewriting' &&
+        (ts.isShorthandPropertyAssignment(property) ||
+            property.initializer.kind === ts.SyntaxKind.TrueKeyword)) {
+        return `removed \`${property.getText()}\`; set \`removeSRIAttributes: true\` if it worked around Subresource Integrity errors`;
+    }
+    return null;
+}
+// The option blocks the config is made of: the config object, its `e2e` and
+// `component` blocks, and the same-file objects spread into any of them,
+// each edited in place. `e2e`/`component` are only read at the top level,
+// which the objects spread into the config are part of, so that level is
+// collected first. A spread that resolves to nothing is returned so it can
+// be reported, the Nx preset calls aside.
+function getOptionBlocks(config) {
+    const sourceFile = config.getSourceFile();
+    const unresolvedSpreads = [];
+    // Collects `root` and the objects reachable from it through spreads.
+    // A collected object is not scanned again, so an object shared by
+    // several blocks is edited and reported once.
+    const collect = (root, into) => {
+        if (into.has(root)) {
+            return;
+        }
+        into.add(root);
+        for (const property of root.properties) {
+            if (!ts.isSpreadAssignment(property) ||
+                isNxPresetCall(property.expression)) {
+                continue;
+            }
+            const block = (0, config_1.resolveObjectLiteral)(property.expression, sourceFile);
+            if (block) {
+                collect(block, into);
+            }
+            else {
+                unresolvedSpreads.push(property);
+            }
+        }
+    };
+    const topLevel = new Set();
+    collect(config, topLevel);
+    const blocks = new Set(topLevel);
+    for (const block of topLevel) {
+        for (const property of block.properties) {
+            if (!isConfigProperty(property) ||
+                !TESTING_TYPE_BLOCKS.includes(getPropertyName(property.name))) {
+                continue;
+            }
+            const nested = (0, config_1.resolveObjectLiteral)(ts.isPropertyAssignment(property)
+                ? property.initializer
+                : property.name, sourceFile);
+            if (nested) {
+                collect(nested, blocks);
+            }
+        }
+    }
+    return { blocks, unresolvedSpreads };
+}
+function isNxPresetCall(expression) {
+    return (ts.isCallExpression(expression) &&
+        ts.isIdentifier(expression.expression) &&
+        NX_PRESET_CALLS.includes(expression.expression.text));
+}
+function hasProperty(block, name) {
+    return block.properties.some((property) => isConfigProperty(property) && getPropertyName(property.name) === name);
+}
+function isConfigProperty(node) {
+    return (ts.isPropertyAssignment(node) || ts.isShorthandPropertyAssignment(node));
+}
+// A computed identifier (`[key]: value`) resolves at runtime, so it is skipped.
+function getPropertyName(name) {
+    if (ts.isIdentifier(name) || isStringLiteralName(name)) {
+        return name.text;
+    }
+    if (ts.isComputedPropertyName(name) && isStringLiteralName(name.expression)) {
+        return name.expression.text;
+    }
+    return null;
+}
+function isStringLiteralName(node) {
+    return ts.isStringLiteral(node) || ts.isNoSubstitutionTemplateLiteral(node);
+}
+function getValueText(property) {
+    return ts.isPropertyAssignment(property)
+        ? property.initializer.getText()
+        : property.name.text;
+}
+function getVisibilityStrategy(property) {
+    if (ts.isShorthandPropertyAssignment(property)) {
+        return null;
+    }
+    switch (property.initializer.kind) {
+        case ts.SyntaxKind.TrueKeyword:
+            return 'modern';
+        case ts.SyntaxKind.FalseKeyword:
+            return 'legacy';
+        default:
+            return null;
+    }
+}
+// Removes the property with its trailing comma, and the whole line when the
+// property is alone on it.
+function removeProperty(contents, property) {
+    let start = property.getStart();
+    let end = property.getEnd();
+    // The node ends before its trailing trivia, so the comma can sit behind a
+    // comment or a line break.
+    const scanner = ts.createScanner(ts.ScriptTarget.Latest, true, ts.LanguageVariant.Standard, contents, undefined, end);
+    if (scanner.scan() === ts.SyntaxKind.CommaToken) {
+        end = scanner.getTokenEnd();
+    }
+    const lineStart = contents.lastIndexOf('\n', start - 1) + 1;
+    const lineEnd = contents.indexOf('\n', end);
+    const restOfLine = lineEnd === -1 ? contents.slice(end) : contents.slice(end, lineEnd);
+    if (contents.slice(lineStart, start).trim() === '' &&
+        restOfLine.trim() === '') {
+        start = lineStart;
+        end = lineEnd === -1 ? contents.length : lineEnd + 1;
+    }
+    return [{ type: devkit_1.ChangeType.Delete, start, length: end - start }];
+}
+function replaceNode(node, text) {
+    const start = node.getStart();
+    return [
+        { type: devkit_1.ChangeType.Delete, start, length: node.getEnd() - start },
+        { type: devkit_1.ChangeType.Insert, index: start, text },
+    ];
+}

package/dist/src/migrations/update-23-3-0/update-cypress-16-config-options.md

@@ -0,0 +1,36 @@
+#### Update Cypress config options renamed or removed in Cypress 16
+
+Cypress 16 renamed `experimentalMemoryManagement` to `manageBrowserMemory` (now on by default), replaced `experimentalFastVisibility` with `visibilityStrategy` (`'modern'` by default, `'legacy'` deprecated), and removed `experimentalSourceRewriting`, `allowCypressEnv` and `execTimeout` (`cy.exec()` no longer exists). Cypress warns on startup while the old keys stay in the config.
+
+This migration rewrites `cypress.config.{ts,js,mjs,cjs}` files of Cypress projects: it renames `experimentalMemoryManagement`, turns `experimentalFastVisibility: true` into `visibilityStrategy: 'modern'` and `experimentalFastVisibility: false` into `visibilityStrategy: 'legacy'`, and deletes the removed options. The config object is found behind `export default` or `module.exports`, through a `defineConfig()` call and through variables of the same file holding either. It edits the top level of the config object and the `e2e` and `component` blocks, inline or held in a variable of the same file, and the objects of the same file spread into any of them, and handles plain, quoted, shorthand and statically computed keys. A config object the migration cannot resolve statically is reported as a next step, and so is a spread of an import or a call, the `nxE2EPreset()` and `nxComponentTestingPreset()` spreads aside. A renamed shorthand key becomes `manageBrowserMemory: experimentalMemoryManagement`. A shorthand `experimentalFastVisibility` or `experimentalSourceRewriting` has a value the migration cannot read, so it is reported as a next step. When the new key is already set next to the old one, only the old key is removed. An `experimentalFastVisibility` value that is not a boolean literal is left in place and reported as a next step. Removing `execTimeout`, or `experimentalSourceRewriting: true`, is also reported as a next step: the `cy.task()` calls that replace `cy.exec()` use `taskTimeout`, and an application that pins resources with Subresource Integrity needs `removeSRIAttributes: true` instead of the source rewriter.
+
+#### Sample code changes
+
+##### Before
+
+```ts title="apps/myapp-e2e/cypress.config.ts"
+import { defineConfig } from 'cypress';
+
+export default defineConfig({
+  experimentalMemoryManagement: true,
+  e2e: {
+    baseUrl: 'http://localhost:4200',
+    experimentalFastVisibility: true,
+    execTimeout: 60000,
+  },
+});
+```
+
+##### After
+
+```ts title="apps/myapp-e2e/cypress.config.ts"
+import { defineConfig } from 'cypress';
+
+export default defineConfig({
+  manageBrowserMemory: true,
+  e2e: {
+    baseUrl: 'http://localhost:4200',
+    visibilityStrategy: 'modern',
+  },
+});
+```

package/dist/src/migrations/update-23-3-0/update-cypress-16-query-command-overwrites.d.ts

@@ -0,0 +1,10 @@
+import { type Tree } from '@nx/devkit';
+export default function updateCypress16QueryCommandOverwrites(tree: Tree): Promise<{
+    skipAgentic: boolean;
+    nextSteps?: undefined;
+    agentContext?: undefined;
+} | {
+    skipAgentic?: undefined;
+    nextSteps: string[];
+    agentContext: string[];
+}>;

package/dist/src/migrations/update-23-3-0/update-cypress-16-query-command-overwrites.js

@@ -0,0 +1,120 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = updateCypress16QueryCommandOverwrites;
+const devkit_1 = require("@nx/devkit");
+const internal_1 = require("@nx/js/internal");
+const tsquery_1 = require("@phenomnomnominal/tsquery");
+const migrations_1 = require("../../utils/migrations");
+// Commands that became queries in Cypress 16
+// (packages/driver/src/cy/commands/{cookies,storage}.ts).
+const QUERY_COMMANDS = [
+    'getCookie',
+    'getCookies',
+    'getAllCookies',
+    'getAllLocalStorage',
+    'getAllSessionStorage',
+];
+let ts;
+async function updateCypress16QueryCommandOverwrites(tree) {
+    const migrated = [];
+    const shadowed = [];
+    // Shared support libraries can hold the overwrites, so the whole workspace
+    // is scanned rather than the Cypress project roots.
+    (0, devkit_1.visitNotIgnoredFiles)(tree, '.', (filePath) => {
+        if (!isJsTsFile(filePath)) {
+            return;
+        }
+        const originalContent = tree.read(filePath, 'utf-8');
+        if (!originalContent.includes('overwrite')) {
+            return;
+        }
+        const sourceFile = (0, migrations_1.parseSourceFile)(filePath, originalContent);
+        const overwrites = findQueryOverwrites(sourceFile);
+        if (overwrites.length === 0) {
+            return;
+        }
+        // A file with its own `Cypress` value is not calling the global.
+        if ((0, migrations_1.hasLocalValueBinding)(sourceFile, 'Cypress')) {
+            shadowed.push(filePath);
+            return;
+        }
+        tree.write(filePath, (0, devkit_1.applyChangesToString)(originalContent, overwrites.flatMap((call) => renameToOverwriteQuery(call))));
+        migrated.push(`${filePath}: ${overwrites
+            .map((call) => `\`${call.arguments[0].getText()}\``)
+            .join(', ')}`);
+    });
+    if (migrated.length === 0 && shadowed.length === 0) {
+        return { skipAgentic: true };
+    }
+    if (migrated.length > 0) {
+        await (0, devkit_1.formatFiles)(tree);
+    }
+    const shadowedNotes = shadowed.map((filePath) => `Left ${filePath} untouched because it declares its own \`Cypress\`; rename its \`Cypress.Commands.overwrite()\` calls for the cookie and storage queries to \`overwriteQuery()\` by hand if they target the Cypress global`);
+    return {
+        nextSteps: [
+            ...migrated.map((item) => `Adapt the \`Cypress.Commands.overwriteQuery()\` callback in ${item}: make it a \`function\` that calls \`originalFn.call(this, ...)\` and returns a function computing the query result, not a chainable`),
+            ...shadowedNotes,
+        ],
+        agentContext: [
+            ...migrated.map((item) => `Renamed \`Cypress.Commands.overwrite()\` to \`overwriteQuery()\` in ${item}`),
+            ...shadowedNotes,
+        ],
+    };
+}
+// `Cypress.Commands.overwrite(...)` for a command that became a query, with
+// each member in dot or static bracket form.
+function findQueryOverwrites(sourceFile) {
+    ts ??= (0, internal_1.ensureTypescript)();
+    return (0, tsquery_1.query)(sourceFile, 'CallExpression').filter((call) => {
+        const [commandName] = call.arguments;
+        return (isCypressCommandsMember(call.expression, 'overwrite') &&
+            commandName !== undefined &&
+            isStringLiteral(commandName) &&
+            QUERY_COMMANDS.includes(commandName.text));
+    });
+}
+function isCypressCommandsMember(node, member) {
+    if (!isMemberAccess(node) || getStaticMemberName(node) !== member) {
+        return false;
+    }
+    const commands = node.expression;
+    return (isMemberAccess(commands) &&
+        getStaticMemberName(commands) === 'Commands' &&
+        ts.isIdentifier(commands.expression) &&
+        commands.expression.text === 'Cypress');
+}
+function isMemberAccess(node) {
+    return (ts.isPropertyAccessExpression(node) || ts.isElementAccessExpression(node));
+}
+function getStaticMemberName(node) {
+    if (ts.isPropertyAccessExpression(node)) {
+        return node.name.text;
+    }
+    return isStringLiteral(node.argumentExpression)
+        ? node.argumentExpression.text
+        : null;
+}
+function isStringLiteral(node) {
+    return ts.isStringLiteral(node) || ts.isNoSubstitutionTemplateLiteral(node);
+}
+function renameToOverwriteQuery(call) {
+    const callee = call.expression;
+    const member = ts.isPropertyAccessExpression(callee)
+        ? callee.name
+        : callee.argumentExpression;
+    const quote = ts.isPropertyAccessExpression(callee)
+        ? ''
+        : member.getText()[0];
+    const start = member.getStart();
+    return [
+        { type: devkit_1.ChangeType.Delete, start, length: member.getEnd() - start },
+        {
+            type: devkit_1.ChangeType.Insert,
+            index: start,
+            text: `${quote}overwriteQuery${quote}`,
+        },
+    ];
+}
+function isJsTsFile(filePath) {
+    return /\.[cm]?[jt]sx?$/.test(filePath);
+}

package/dist/src/migrations/update-23-3-0/update-cypress-16-query-command-overwrites.md

@@ -0,0 +1,34 @@
+#### Overwrite the cookie and storage queries with `overwriteQuery` in Cypress 16
+
+Cypress 16 turned `cy.getCookie()`, `cy.getCookies()`, `cy.getAllCookies()`, `cy.getAllLocalStorage()` and `cy.getAllSessionStorage()` into queries. Queries can only be overwritten with `Cypress.Commands.overwriteQuery()`, so an existing `Cypress.Commands.overwrite()` for any of them fails at runtime with "Queries can only be overwritten with `Cypress.Commands.overwriteQuery()`".
+
+This migration renames those `Cypress.Commands.overwrite()` calls to `Cypress.Commands.overwriteQuery()` in every JavaScript and TypeScript file of the workspace, shared support libraries included; the `Cypress.Commands['overwrite']()` spelling is renamed too. A file that declares its own `Cypress` value (a variable, an import, a function, a class, an enum or a namespace holding a value; a type-only namespace and the usual `declare global { namespace Cypress { ... } }` augmentation are not ones) is left alone and listed as a next step. The callback contract differs: `overwriteQuery` calls the callback with the command as `this`, hands it the original query function, and expects it to return a function that computes the result from the subject, instead of a chainable. The original query reads `this` too, so the callback must be a `function` that forwards with `originalFn.call(this, ...)`; an arrow callback fails to typecheck (TS2684) and throws at runtime. Every renamed call is listed as a next step so the callback can be adapted by hand, and the paired AI prompt does that in agentic runs.
+
+#### Sample code changes
+
+##### Before
+
+```ts title="apps/myapp-e2e/src/support/commands.ts"
+Cypress.Commands.overwrite('getCookie', (originalFn, name, options) => {
+  return originalFn(name, { ...options, log: false });
+});
+```
+
+##### After the automatic rename (the callback still needs adapting)
+
+```ts title="apps/myapp-e2e/src/support/commands.ts"
+Cypress.Commands.overwriteQuery('getCookie', (originalFn, name, options) => {
+  return originalFn(name, { ...options, log: false });
+});
+```
+
+##### After adapting the callback by hand or through the AI prompt
+
+```ts title="apps/myapp-e2e/src/support/commands.ts"
+Cypress.Commands.overwriteQuery(
+  'getCookie',
+  function (originalFn, name, options) {
+    return originalFn.call(this, name, { ...options, log: false });
+  }
+);
+```

package/dist/src/migrations/update-23-3-0/upgrade-to-cypress-16.md

@@ -0,0 +1,27 @@
+#### Upgrade Cypress 15 to 16
+
+Bumps `cypress` to 16 together with `@cypress/vite-dev-server` 8 and `@cypress/webpack-dev-server` 6. A workspace with a Vite below 8 installed at the workspace root that does not land on Vite 8 in the same run stays on Cypress 15, since Cypress 16 component testing rejects an older Vite. A Vite declared only in a project's `package.json` is not detected, so check those projects before running their component tests. Cypress 16 removes `Cypress.env()` (replaced by the asynchronous `cy.env()` for `env` values and `Cypress.expose()` for the new `expose` values), `cy.exec()` (use `cy.task()`) and `.end()`, drops `env` from test configuration overrides, turns the cookie and storage getters into queries, drops CoffeeScript support, and routes Chrome, Chromium and Edge through the native browser network. It requires Node 22, 24 or 26+, Vite 8 for Vite component testing, Angular 21 for Angular component testing and Next.js 15.0.4 for component testing on Cypress's `next` dev server framework, which the Nx preset does not use. Read more in the [Cypress 16 migration guide](https://docs.cypress.io/app/references/migration-guide#Migrating-to-Cypress-160).
+
+The generator-based migrations in this release update the renamed and removed config options, the `cypress/angular-zoneless` import and the `Cypress.Commands.overwrite()` calls for the new queries. The paired AI instructions migration walks an agent through the source changes that need judgment. The most common one is shown below.
+
+#### Examples
+
+##### Before
+
+```ts title="apps/myapp-e2e/src/e2e/app.cy.ts"
+const apiUrl = Cypress.env('API_URL');
+
+it('is healthy', () => {
+  cy.request(`${apiUrl}/health`).its('status').should('eq', 200);
+});
+```
+
+##### After
+
+```ts title="apps/myapp-e2e/src/e2e/app.cy.ts"
+it('is healthy', () => {
+  cy.env(['API_URL']).then(({ API_URL }) => {
+    cy.request(`${API_URL}/health`).its('status').should('eq', 200);
+  });
+});
+```

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

@@ -1,5 +1,5 @@
 import { type Tree } from '@nx/devkit';
-import type { ObjectLiteralExpression } from 'typescript';
+import type { Expression, ObjectLiteralExpression, SourceFile } from 'typescript';
 import type { NxComponentTestingOptions, NxCypressE2EPresetOptions } from '../../plugins/cypress-preset';
 export declare const CYPRESS_CONFIG_FILE_NAME_PATTERN = "cypress.config.{js,ts,mjs,cjs}";
 export declare const JIT_COMPILE_DISABLE_COMMENT: string[];
@@ -29,3 +29,10 @@ 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;
+/**
+ * Resolves the object literal an expression stands for in a Cypress config
+ * file: the literal itself, the argument of a `defineConfig()` call, or a
+ * variable declared at the top level of the file that holds either. Anything
+ * else (a spread, a function call, an import) resolves to `null`.
+ */
+export declare function resolveObjectLiteral(expression: Expression, sourceFile: SourceFile, visitedIdentifiers?: Set<string>): ObjectLiteralExpression | null;

package/dist/src/utils/config.js

@@ -6,6 +6,7 @@ exports.addDefaultCTConfig = addDefaultCTConfig;
 exports.addMountDefinition = addMountDefinition;
 exports.getProjectCypressConfigPath = getProjectCypressConfigPath;
 exports.resolveCypressConfigObject = resolveCypressConfigObject;
+exports.resolveObjectLiteral = resolveObjectLiteral;
 const devkit_1 = require("@nx/devkit");
 const internal_1 = require("@nx/js/internal");
 exports.CYPRESS_CONFIG_FILE_NAME_PATTERN = 'cypress.config.{js,ts,mjs,cjs}';
@@ -189,41 +190,52 @@ function resolveCypressConfigObject(cypressConfigContents) {
     const sourceFile = tsquery.ast(cypressConfigContents);
     const exportDefaultStatement = sourceFile.statements.find((statement) => ts.isExportAssignment(statement));
     if (exportDefaultStatement) {
-        return resolveCypressConfigObjectFromExportExpression(exportDefaultStatement.expression, sourceFile);
+        return resolveObjectLiteral(exportDefaultStatement.expression, sourceFile);
     }
     const moduleExportsStatement = sourceFile.statements.find((statement) => ts.isExpressionStatement(statement) &&
         ts.isBinaryExpression(statement.expression) &&
         statement.expression.left.getText() === 'module.exports');
     if (moduleExportsStatement) {
-        return resolveCypressConfigObjectFromExportExpression(moduleExportsStatement.expression.right, sourceFile);
+        return resolveObjectLiteral(moduleExportsStatement.expression.right, sourceFile);
     }
     return null;
 }
-function resolveCypressConfigObjectFromExportExpression(exportExpression, sourceFile) {
+/**
+ * Resolves the object literal an expression stands for in a Cypress config
+ * file: the literal itself, the argument of a `defineConfig()` call, or a
+ * variable declared at the top level of the file that holds either. Anything
+ * else (a spread, a function call, an import) resolves to `null`.
+ */
+function resolveObjectLiteral(expression, sourceFile, visitedIdentifiers = new Set()) {
     const ts = (0, internal_1.ensureTypescript)();
-    if (ts.isObjectLiteralExpression(exportExpression)) {
-        return exportExpression;
+    if (ts.isObjectLiteralExpression(expression)) {
+        return expression;
+    }
+    if (ts.isCallExpression(expression) &&
+        ts.isIdentifier(expression.expression) &&
+        expression.expression.text === 'defineConfig' &&
+        expression.arguments[0]) {
+        return resolveObjectLiteral(expression.arguments[0], sourceFile, visitedIdentifiers);
     }
-    if (ts.isIdentifier(exportExpression)) {
-        // try to locate the identifier in the source file
-        const variableStatements = sourceFile.statements.filter((statement) => ts.isVariableStatement(statement));
-        for (const variableStatement of variableStatements) {
-            for (const declaration of variableStatement.declarationList
-                .declarations) {
+    if (ts.isIdentifier(expression)) {
+        // `const a = b; const b = a;` would otherwise loop forever.
+        if (visitedIdentifiers.has(expression.text)) {
+            return null;
+        }
+        visitedIdentifiers.add(expression.text);
+        for (const statement of sourceFile.statements) {
+            if (!ts.isVariableStatement(statement)) {
+                continue;
+            }
+            for (const declaration of statement.declarationList.declarations) {
                 if (ts.isIdentifier(declaration.name) &&
-                    declaration.name.getText() === exportExpression.getText() &&
-                    ts.isObjectLiteralExpression(declaration.initializer)) {
-                    return declaration.initializer;
+                    declaration.name.text === expression.text) {
+                    return declaration.initializer
+                        ? resolveObjectLiteral(declaration.initializer, sourceFile, visitedIdentifiers)
+                        : null;
                 }
             }
         }
-        return null;
-    }
-    if (ts.isCallExpression(exportExpression) &&
-        ts.isIdentifier(exportExpression.expression) &&
-        exportExpression.expression.getText() === 'defineConfig' &&
-        ts.isObjectLiteralExpression(exportExpression.arguments[0])) {
-        return exportExpression.arguments[0];
     }
     return null;
 }

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

@@ -1,5 +1,5 @@
 import { type ProjectConfiguration, type Tree } from '@nx/devkit';
-import type { Expression, ObjectLiteralExpression, PropertyAssignment } from 'typescript';
+import type { Expression, ObjectLiteralExpression, PropertyAssignment, SourceFile } from 'typescript';
 export declare function cypressProjectConfigs(tree: Tree): AsyncGenerator<{
     projectName: string;
     projectConfig: ProjectConfiguration;
@@ -11,3 +11,15 @@ export declare function updateObjectProperty(config: ObjectLiteralExpression, pr
     newName?: string;
     newValue?: Expression;
 }): ObjectLiteralExpression;
+export declare function parseSourceFile(filePath: string, content: string): SourceFile;
+/**
+ * Whether the file binds `name` as a runtime value anywhere: a variable,
+ * parameter, destructured element, function or class (declaration or named
+ * expression), enum, namespace holding a value, or a value import (`import x`,
+ * `import { x }`, `import * as x`, `import x =`).
+ * Type-only imports and ambient declarations (`declare ...`, including
+ * everything under `declare global`) do not count, so the usual
+ * `declare global { namespace Cypress { ... } }` augmentation never hides the
+ * `Cypress` global.
+ */
+export declare function hasLocalValueBinding(sourceFile: SourceFile, name: string): boolean;