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

package/dist/src/migrations/update-23-0-0/rewrite-internal-subpath-imports.js

@@ -0,0 +1,201 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = rewriteInternalSubpathImports;
+exports.rewriteSubpathImports = rewriteSubpathImports;
+const devkit_1 = require("@nx/devkit");
+const TS_EXTENSIONS = ['.ts', '.tsx', '.cts', '.mts'];
+const FROM_PREFIX = '@nx/jest/src/';
+const TO_PUBLIC = '@nx/jest';
+const TO_INTERNAL = '@nx/jest/internal';
+// Symbols exported from `@nx/jest`'s public entry (packages/jest/index.ts).
+// A named import/export of one of these from `@nx/jest/src/*` is routed to
+// the public `@nx/jest` entry; everything else goes to `@nx/jest/internal`.
+const PUBLIC_SYMBOLS = new Set([
+    'configurationGenerator',
+    'jestInitGenerator',
+    'addPropertyToJestConfig',
+    'removePropertyFromJestConfig',
+    'jestConfigObjectAst',
+    'getJestProjectsAsync',
+    'findJestConfig',
+]);
+// Methods on `jest` and `vi` that take a module specifier as their first arg.
+const MOCK_HELPER_METHODS = new Set([
+    'mock',
+    'unmock',
+    'doMock',
+    'dontMock',
+    'requireActual',
+    'requireMock',
+    'importActual',
+    'importMock',
+]);
+let ts;
+async function rewriteInternalSubpathImports(tree) {
+    let touchedCount = 0;
+    (0, devkit_1.visitNotIgnoredFiles)(tree, '.', (filePath) => {
+        if (!TS_EXTENSIONS.some((ext) => filePath.endsWith(ext))) {
+            return;
+        }
+        const original = tree.read(filePath, 'utf-8');
+        if (!original || !original.includes(FROM_PREFIX)) {
+            return;
+        }
+        const updated = rewriteSubpathImports(original);
+        if (updated !== original) {
+            tree.write(filePath, updated);
+            touchedCount += 1;
+        }
+    });
+    if (touchedCount > 0) {
+        devkit_1.logger.info(`Rewrote @nx/jest/src/* imports in ${touchedCount} file(s) ` +
+            `(public symbols to @nx/jest, internals to @nx/jest/internal).`);
+    }
+    await (0, devkit_1.formatFiles)(tree);
+}
+function rewriteSubpathImports(source) {
+    ts ??= (0, devkit_1.ensurePackage)('typescript', '*');
+    const sourceFile = ts.createSourceFile('tmp.ts', source, ts.ScriptTarget.Latest, 
+    /* setParentNodes */ true, ts.ScriptKind.TSX);
+    const changes = [];
+    for (const stmt of sourceFile.statements) {
+        if (ts.isImportDeclaration(stmt)) {
+            collectImportRewrite(sourceFile, stmt, changes);
+        }
+        else if (ts.isExportDeclaration(stmt)) {
+            collectExportRewrite(sourceFile, stmt, changes);
+        }
+    }
+    collectCallExpressionRewrites(sourceFile, changes);
+    return changes.length > 0 ? (0, devkit_1.applyChangesToString)(source, changes) : source;
+}
+function isSubpathSpecifier(node) {
+    return ts.isStringLiteral(node) && node.text.startsWith(FROM_PREFIX);
+}
+function collectImportRewrite(sourceFile, stmt, changes) {
+    if (!isSubpathSpecifier(stmt.moduleSpecifier)) {
+        return;
+    }
+    const clause = stmt.importClause;
+    // Pure named imports (`import { a, b } from '...'`) can be split by symbol.
+    // A default or namespace import grabs the whole module, so it can't be
+    // split — route it wholesale to the internal entry.
+    if (clause &&
+        !clause.name &&
+        clause.namedBindings &&
+        ts.isNamedImports(clause.namedBindings)) {
+        rewriteNamedDeclaration(sourceFile, stmt, stmt.moduleSpecifier, clause.isTypeOnly, clause.namedBindings.elements, 'import', changes);
+        return;
+    }
+    replaceSpecifier(sourceFile, stmt.moduleSpecifier, TO_INTERNAL, changes);
+}
+function collectExportRewrite(sourceFile, stmt, changes) {
+    if (!stmt.moduleSpecifier || !isSubpathSpecifier(stmt.moduleSpecifier)) {
+        return;
+    }
+    // `export { a, b } from '...'` can be split; `export * from '...'` cannot.
+    if (stmt.exportClause && ts.isNamedExports(stmt.exportClause)) {
+        rewriteNamedDeclaration(sourceFile, stmt, stmt.moduleSpecifier, stmt.isTypeOnly, stmt.exportClause.elements, 'export', changes);
+        return;
+    }
+    replaceSpecifier(sourceFile, stmt.moduleSpecifier, TO_INTERNAL, changes);
+}
+/**
+ * Partition the named bindings of an import/export declaration into the ones
+ * that resolve to `@nx/jest`'s public entry and the ones that don't. If both
+ * groups are non-empty, the single declaration is split into two.
+ */
+function rewriteNamedDeclaration(sourceFile, decl, specifier, isTypeOnly, elements, keyword, changes) {
+    const publicEls = [];
+    const internalEls = [];
+    for (const el of elements) {
+        // `propertyName` is the original name in `orig as alias`; fall back to
+        // `name` for the plain `orig` form.
+        const importedName = (el.propertyName ?? el.name).text;
+        (PUBLIC_SYMBOLS.has(importedName) ? publicEls : internalEls).push(el);
+    }
+    if (publicEls.length === 0) {
+        replaceSpecifier(sourceFile, specifier, TO_INTERNAL, changes);
+        return;
+    }
+    if (internalEls.length === 0) {
+        replaceSpecifier(sourceFile, specifier, TO_PUBLIC, changes);
+        return;
+    }
+    // Mixed — replace the whole declaration with one statement per target.
+    const quote = sourceFile.text.charAt(specifier.getStart(sourceFile));
+    const start = decl.getStart(sourceFile);
+    const end = decl.getEnd();
+    const semicolon = sourceFile.text.charAt(end - 1) === ';' ? ';' : '';
+    const prefix = isTypeOnly ? `${keyword} type` : keyword;
+    const render = (els, target) => `${prefix} { ${els
+        .map((el) => el.getText(sourceFile))
+        .join(', ')} } from ${quote}${target}${quote}${semicolon}`;
+    changes.push({ type: devkit_1.ChangeType.Delete, start, length: end - start }, {
+        type: devkit_1.ChangeType.Insert,
+        index: start,
+        text: `${render(publicEls, TO_PUBLIC)}\n${render(internalEls, TO_INTERNAL)}`,
+    });
+}
+function collectCallExpressionRewrites(sourceFile, changes) {
+    const visit = (node) => {
+        if (ts.isCallExpression(node) &&
+            shouldRewriteCallExpression(node) &&
+            node.arguments.length >= 1 &&
+            isSubpathSpecifier(node.arguments[0])) {
+            // `require(...)`, dynamic `import(...)` and `jest.mock(...)` reference
+            // the module as a whole and can't be symbol-split, so they go to the
+            // internal entry.
+            replaceSpecifier(sourceFile, node.arguments[0], TO_INTERNAL, changes);
+        }
+        else if (ts.isImportTypeNode(node)) {
+            // `typeof import('...')` parses as an `ImportTypeNode`, not a
+            // CallExpression — its argument is `LiteralTypeNode<StringLiteral>`.
+            // The whole module is referenced, so it can't be symbol-split.
+            const literal = getImportTypeStringLiteral(node);
+            if (literal && literal.text.startsWith(FROM_PREFIX)) {
+                replaceSpecifier(sourceFile, literal, TO_INTERNAL, changes);
+            }
+        }
+        ts.forEachChild(node, visit);
+    };
+    visit(sourceFile);
+}
+function getImportTypeStringLiteral(node) {
+    const arg = node.argument;
+    if (arg && ts.isLiteralTypeNode(arg) && ts.isStringLiteral(arg.literal)) {
+        return arg.literal;
+    }
+    return undefined;
+}
+function shouldRewriteCallExpression(call) {
+    const callee = call.expression;
+    // `require('...')`
+    if (ts.isIdentifier(callee) && callee.text === 'require')
+        return true;
+    // dynamic `import('...')` (runtime form parses as a CallExpression whose
+    // callee is the `import` keyword). The `typeof import('...')` type-position
+    // form is an `ImportTypeNode` (handled in `collectCallExpressionRewrites`).
+    if (callee.kind === ts.SyntaxKind.ImportKeyword)
+        return true;
+    // `jest.mock(...)` / `vi.mock(...)` and friends.
+    if (ts.isPropertyAccessExpression(callee)) {
+        const obj = callee.expression;
+        if (ts.isIdentifier(obj) &&
+            (obj.text === 'jest' || obj.text === 'vi') &&
+            MOCK_HELPER_METHODS.has(callee.name.text)) {
+            return true;
+        }
+    }
+    return false;
+}
+function replaceSpecifier(sourceFile, literal, target, changes) {
+    const start = literal.getStart(sourceFile);
+    const end = literal.getEnd();
+    const quote = sourceFile.text.charAt(start);
+    changes.push({ type: devkit_1.ChangeType.Delete, start, length: end - start }, {
+        type: devkit_1.ChangeType.Insert,
+        index: start,
+        text: `${quote}${target}${quote}`,
+    });
+}

package/dist/src/migrations/update-23-0-0/rewrite-jest-project-generator.d.ts

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

package/dist/src/migrations/update-23-0-0/rewrite-jest-project-generator.js

@@ -0,0 +1,121 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = rewriteJestProjectGenerator;
+exports.rewriteJestProjectGeneratorUsage = rewriteJestProjectGeneratorUsage;
+const devkit_1 = require("@nx/devkit");
+const TS_EXTENSIONS = ['.ts', '.tsx', '.cts', '.mts'];
+const PACKAGE = '@nx/jest';
+const OLD_NAME = 'jestProjectGenerator';
+const NEW_NAME = 'configurationGenerator';
+let ts;
+async function rewriteJestProjectGenerator(tree) {
+    let touchedCount = 0;
+    (0, devkit_1.visitNotIgnoredFiles)(tree, '.', (filePath) => {
+        if (!TS_EXTENSIONS.some((ext) => filePath.endsWith(ext))) {
+            return;
+        }
+        const original = tree.read(filePath, 'utf-8');
+        if (!original ||
+            !original.includes(OLD_NAME) ||
+            !original.includes(PACKAGE)) {
+            return;
+        }
+        const updated = rewriteJestProjectGeneratorUsage(original);
+        if (updated !== original) {
+            tree.write(filePath, updated);
+            touchedCount += 1;
+        }
+    });
+    if (touchedCount > 0) {
+        devkit_1.logger.info(`Replaced the deprecated \`${OLD_NAME}\` with \`${NEW_NAME}\` in ${touchedCount} file(s).`);
+    }
+    await (0, devkit_1.formatFiles)(tree);
+}
+function rewriteJestProjectGeneratorUsage(source) {
+    ts ??= (0, devkit_1.ensurePackage)('typescript', '*');
+    const sourceFile = ts.createSourceFile('tmp.ts', source, ts.ScriptTarget.Latest, 
+    /* setParentNodes */ true, ts.ScriptKind.TSX);
+    // `jestProjectGenerator as alias` — only the imported name changes.
+    let aliasedSpecifier;
+    // `jestProjectGenerator` — the local binding is the old name itself.
+    let plainSpecifier;
+    // Whether `configurationGenerator` is already a binding in the file, which
+    // means a plain rename would produce a duplicate import specifier.
+    let newNameAlreadyBound = false;
+    for (const stmt of sourceFile.statements) {
+        if (!ts.isImportDeclaration(stmt))
+            continue;
+        if (!ts.isStringLiteral(stmt.moduleSpecifier) ||
+            stmt.moduleSpecifier.text !== PACKAGE) {
+            continue;
+        }
+        const named = stmt.importClause?.namedBindings;
+        if (!named || !ts.isNamedImports(named))
+            continue;
+        for (const spec of named.elements) {
+            const importedName = (spec.propertyName ?? spec.name).text;
+            if (importedName === OLD_NAME) {
+                if (spec.propertyName) {
+                    aliasedSpecifier = spec;
+                }
+                else {
+                    plainSpecifier = spec;
+                }
+            }
+            if (importedName === NEW_NAME || spec.name.text === NEW_NAME) {
+                newNameAlreadyBound = true;
+            }
+        }
+    }
+    if (!aliasedSpecifier && !plainSpecifier) {
+        return source;
+    }
+    const changes = [];
+    // `jestProjectGenerator as alias` -> `configurationGenerator as alias`.
+    // Call sites use `alias`, so only the imported name is rewritten.
+    if (aliasedSpecifier?.propertyName) {
+        replaceNode(sourceFile, aliasedSpecifier.propertyName, NEW_NAME, changes);
+    }
+    if (plainSpecifier) {
+        if (newNameAlreadyBound) {
+            // A plain rename would collide with the existing `configurationGenerator`
+            // binding, so alias the import and leave the call sites untouched.
+            replaceNode(sourceFile, plainSpecifier.name, `${NEW_NAME} as ${OLD_NAME}`, changes);
+        }
+        else {
+            // Rename the import binding and every bare-identifier usage in the file.
+            for (const id of collectBareIdentifiers(sourceFile)) {
+                replaceNode(sourceFile, id, NEW_NAME, changes);
+            }
+        }
+    }
+    return changes.length > 0 ? (0, devkit_1.applyChangesToString)(source, changes) : source;
+}
+/**
+ * Collect every `jestProjectGenerator` identifier that is a standalone
+ * reference — the import binding and its call sites — while skipping member
+ * accesses like `someObject.jestProjectGenerator`, which are unrelated.
+ */
+function collectBareIdentifiers(sourceFile) {
+    const found = [];
+    const visit = (node) => {
+        if (ts.isIdentifier(node) && node.text === OLD_NAME) {
+            const parent = node.parent;
+            const isMemberName = parent &&
+                ts.isPropertyAccessExpression(parent) &&
+                parent.name === node;
+            const isQualifiedName = parent && ts.isQualifiedName(parent) && parent.right === node;
+            if (!isMemberName && !isQualifiedName) {
+                found.push(node);
+            }
+        }
+        ts.forEachChild(node, visit);
+    };
+    visit(sourceFile);
+    return found;
+}
+function replaceNode(sourceFile, node, text, changes) {
+    const start = node.getStart(sourceFile);
+    const end = node.getEnd();
+    changes.push({ type: devkit_1.ChangeType.Delete, start, length: end - start }, { type: devkit_1.ChangeType.Insert, index: start, text });
+}

package/dist/src/migrations/update-23-0-0/update-snapshot-guide-link.d.ts

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

package/dist/src/migrations/update-23-0-0/update-snapshot-guide-link.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = updateSnapshotGuideLink;
+const devkit_1 = require("@nx/devkit");
+const OLD_HEADER = '// Jest Snapshot v1, https://goo.gl/fbAQLP';
+const NEW_HEADER = '// Jest Snapshot v1, https://jestjs.io/docs/snapshot-testing';
+async function updateSnapshotGuideLink(tree) {
+    const snapshotFiles = await (0, devkit_1.globAsync)(tree, ['**/__snapshots__/*.snap']);
+    for (const snapshotFile of snapshotFiles) {
+        const content = tree.read(snapshotFile, 'utf-8');
+        if (!content) {
+            continue;
+        }
+        const newlineMatch = content.match(/\r?\n/);
+        if (!newlineMatch) {
+            continue;
+        }
+        const newline = newlineMatch[0];
+        const firstNewlineIndex = content.indexOf(newline);
+        const firstLine = content.slice(0, firstNewlineIndex);
+        if (firstLine !== OLD_HEADER) {
+            continue;
+        }
+        const updated = NEW_HEADER + content.slice(firstNewlineIndex);
+        tree.write(snapshotFile, updated);
+    }
+    await (0, devkit_1.formatFiles)(tree);
+}

package/dist/src/migrations/update-23-0-0/update-snapshot-guide-link.md

@@ -0,0 +1,21 @@
+#### Update Jest Snapshot Guide Link
+
+Updates the snapshot guide link at the top of every `.snap` file from the legacy `https://goo.gl/fbAQLP` to `https://jestjs.io/docs/snapshot-testing`. Jest v30 errors out at test setup time if it sees the old link, so existing snapshot files need to be rewritten before tests can run. Read more at the [Jest v30 migration notes](https://jestjs.io/docs/upgrading-to-jest30).
+
+#### Examples
+
+##### Before
+
+```text title="apps/myapp/src/__snapshots__/example.spec.ts.snap"
+// Jest Snapshot v1, https://goo.gl/fbAQLP
+
+exports[`renders correctly 1`] = `"hello"`;
+```
+
+##### After
+
+```text title="apps/myapp/src/__snapshots__/example.spec.ts.snap"
+// Jest Snapshot v1, https://jestjs.io/docs/snapshot-testing
+
+exports[`renders correctly 1`] = `"hello"`;
+```

package/{src → dist/src}/plugins/plugin.d.ts

@@ -25,4 +25,3 @@ export interface JestPluginOptions {
 }
 export declare const createNodes: CreateNodesV2<JestPluginOptions>;
 export declare const createNodesV2: CreateNodesV2<JestPluginOptions>;
-//# sourceMappingURL=plugin.d.ts.map

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 minimatch_1 = require("minimatch");
 const node_fs_1 = require("node:fs");
 const node_path_1 = require("node:path");
@@ -16,24 +14,16 @@ const installation_directory_1 = require("nx/src/utils/installation-directory");
 const plugins_1 = require("nx/src/utils/plugins");
 const workspace_context_1 = require("nx/src/utils/workspace-context");
 const js_1 = require("@nx/js");
-const internal_1 = require("@nx/js/src/internal");
+const internal_2 = require("@nx/js/internal");
 const versions_1 = require("../utils/versions");
 const REPORTER_BUILTINS = new Set(['default', 'github-actions', 'summary']);
-function readTargetsCache(cachePath) {
-    return process.env.NX_CACHE_PROJECT_GRAPH !== 'false' && (0, node_fs_1.existsSync)(cachePath)
-        ? (0, devkit_1.readJsonFile)(cachePath)
-        : {};
-}
-function writeTargetsToCache(cachePath, results) {
-    (0, devkit_1.writeJsonFile)(cachePath, results);
-}
 const jestConfigGlob = '**/jest.config.{cjs,mjs,js,cts,mts,ts}';
 exports.createNodes = [
     jestConfigGlob,
     async (configFiles, options, context) => {
         const optionsHash = (0, devkit_internals_1.hashObject)(options);
         const cachePath = (0, node_path_1.join)(cache_directory_1.workspaceDataDirectory, `jest-${optionsHash}.hash`);
-        const targetsCache = readTargetsCache(cachePath);
+        const targetsCache = new internal_1.PluginCache(cachePath);
         // Cache jest preset(s) to avoid penalties of module load times. Most of jest configs will use the same preset.
         const presetCache = {};
         // Cache tsconfig reads + isolatedModules resolution. Many projects share
@@ -70,10 +60,10 @@ exports.createNodes = [
             const projectRoot = projectRoots[i];
             const absConfigFilePath = (0, node_path_1.resolve)(context.workspaceRoot, configFilePath);
             if (!requireCacheCleared && require.cache[absConfigFilePath]) {
-                (0, config_utils_1.clearRequireCache)();
+                (0, internal_1.clearRequireCache)();
                 requireCacheCleared = true;
             }
-            const rawConfig = await (0, config_utils_1.loadConfigFile)(absConfigFilePath, [
+            const rawConfig = await (0, internal_1.loadConfigFile)(absConfigFilePath, [
                 'tsconfig.spec.json',
                 'tsconfig.test.json',
                 'tsconfig.jest.json',
@@ -87,7 +77,7 @@ exports.createNodes = [
             });
             return { rawConfig, externalFiles, needsDtsInputs };
         }));
-        const hashes = await (0, calculate_hash_for_create_nodes_1.calculateHashesForCreateNodes)(projectRoots, options, context, loadedConfigs.map(({ externalFiles }) => [
+        const hashes = await (0, internal_1.calculateHashesForCreateNodes)(projectRoots, options, context, loadedConfigs.map(({ externalFiles }) => [
             lockFilePattern,
             ...externalFiles,
         ]));
@@ -96,8 +86,10 @@ exports.createNodes = [
                 const projectRoot = projectRoots[idx];
                 const hash = hashes[idx];
                 const { rawConfig, needsDtsInputs } = loadedConfigs[idx];
-                targetsCache[hash] ??= await buildJestTargets(rawConfig, needsDtsInputs, configFilePath, projectRoot, options, context, presetCache, pmc);
-                const { targets, metadata } = targetsCache[hash];
+                if (!targetsCache.has(hash)) {
+                    targetsCache.set(hash, await buildJestTargets(rawConfig, needsDtsInputs, configFilePath, projectRoot, options, context, presetCache, pmc));
+                }
+                const { targets, metadata } = targetsCache.get(hash);
                 return {
                     projects: {
                         [projectRoot]: {
@@ -110,7 +102,7 @@ exports.createNodes = [
             }, validConfigFiles, options, context);
         }
         finally {
-            writeTargetsToCache(cachePath, targetsCache);
+            targetsCache.writeToDisk();
         }
     },
 ];
@@ -149,7 +141,7 @@ function checkIfConfigFileShouldBeProject(configFilePath, projectRoot, isInPacka
 async function buildJestTargets(rawConfig, needsDtsInputs, configFilePath, projectRoot, options, context, presetCache, pmc) {
     const absConfigFilePath = (0, node_path_1.resolve)(context.workspaceRoot, configFilePath);
     const targets = {};
-    const namedInputs = (0, get_named_inputs_1.getNamedInputs)(projectRoot, context);
+    const namedInputs = (0, internal_1.getNamedInputs)(projectRoot, context);
     const tsNodeCompilerOptions = JSON.stringify({
         moduleResolution: 'node10',
         module: 'commonjs',
@@ -222,7 +214,6 @@ async function buildJestTargets(rawConfig, needsDtsInputs, configFilePath, proje
                 const targetName = `${options.ciTargetName}--${relativePath}`;
                 dependsOn.push({
                     target: targetName,
-                    projects: 'self',
                     params: 'forward',
                     options: 'forward',
                 });
@@ -303,7 +294,10 @@ async function buildJestTargets(rawConfig, needsDtsInputs, configFilePath, proje
                 ? await source.getTestPaths(config.globalConfig, config.projectConfig)
                 : // @ts-expect-error Jest v29 doesn't have the projectConfig parameter
                     await source.getTestPaths(config.globalConfig);
-            const testPaths = new Set(specs.tests.map(({ path }) => path));
+            // Sort to keep atomized target name insertion order stable.
+            // jest.SearchSource.getTestPaths walks via jest-haste-map's
+            // parallel workers, so its output order isn't guaranteed.
+            const testPaths = new Set(specs.tests.map(({ path }) => path).sort());
             if (testPaths.size > 0) {
                 const targetGroup = [];
                 metadata = {
@@ -326,7 +320,6 @@ async function buildJestTargets(rawConfig, needsDtsInputs, configFilePath, proje
                     const targetName = `${options.ciTargetName}--${relativePath}`;
                     dependsOn.push({
                         target: targetName,
-                        projects: 'self',
                         params: 'forward',
                         options: 'forward',
                     });
@@ -721,7 +714,7 @@ async function loadPresetConfig(rawConfig, rootDir, presetCache) {
     }
     try {
         if (!presetCache[presetPath]) {
-            presetCache[presetPath] = (0, config_utils_1.loadConfigFile)(presetPath);
+            presetCache[presetPath] = (0, internal_1.loadConfigFile)(presetPath);
         }
         return (await presetCache[presetPath]);
     }
@@ -885,7 +878,7 @@ function resolveIsolatedModules(tsconfigPath, jsonCache, resultCache) {
         return cached;
     let value;
     const visitedFiles = new Set();
-    (0, internal_1.walkTsconfigExtendsChain)(tsconfigPath, (absPath, rawJson) => {
+    (0, internal_2.walkTsconfigExtendsChain)(tsconfigPath, (absPath, rawJson) => {
         visitedFiles.add(absPath);
         const opts = rawJson?.compilerOptions;
         if (opts?.isolatedModules !== undefined) {

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

@@ -7,4 +7,3 @@ export declare const TEST_FILE_PATTERN: RegExp;
  */
 export declare const TS_QUERY_JEST_CONFIG_PREFIX = ":matches(ExportAssignment, BinaryExpression:has(Identifier[name=\"module\"]):has(Identifier[name=\"exports\"]))";
 export declare function addTransformerToConfig(configContents: string, transformer: string): string;
-//# sourceMappingURL=ast-utils.d.ts.map

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

@@ -7,4 +7,3 @@ export declare function getPresetExt(tree: Tree): JestPresetExtension;
 export declare function findRootJestConfig(tree: Tree): string | null;
 export declare function findJestConfig(tree: Tree, projectPath: string): string | null;
 export declare function findRootJestPreset(tree: Tree): string | null;
-//# sourceMappingURL=config-file.d.ts.map

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

@@ -15,4 +15,3 @@ export declare function jestConfigObjectAst(fileContent: string): ts.ObjectLiter
 export declare function jestConfigObject(host: Tree, path: string): Partial<Config.InitialOptions> & {
     [index: string]: any;
 };
-//# sourceMappingURL=functions.d.ts.map

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

@@ -7,14 +7,14 @@ exports.jestConfigObject = jestConfigObject;
 const devkit_1 = require("@nx/devkit");
 const vm_1 = require("vm");
 const path_1 = require("path");
-const ensure_typescript_1 = require("@nx/js/src/utils/typescript/ensure-typescript");
+const internal_1 = require("@nx/js/internal");
 let tsModule;
 function makeTextToInsert(value, precedingCommaNeeded) {
     return `${precedingCommaNeeded ? ',' : ''}${value}`;
 }
 function findPropertyAssignment(object, propertyName) {
     if (!tsModule) {
-        tsModule = (0, ensure_typescript_1.ensureTypescript)();
+        tsModule = (0, internal_1.ensureTypescript)();
     }
     return object.properties.find((prop) => {
         if (!tsModule.isPropertyAssignment(prop)) {
@@ -29,7 +29,7 @@ function findPropertyAssignment(object, propertyName) {
 }
 function addOrUpdateProperty(tree, object, properties, value, path) {
     if (!tsModule) {
-        tsModule = (0, ensure_typescript_1.ensureTypescript)();
+        tsModule = (0, internal_1.ensureTypescript)();
     }
     const { SyntaxKind } = tsModule;
     const propertyName = properties.shift();
@@ -109,7 +109,7 @@ function addOrUpdateProperty(tree, object, properties, value, path) {
 }
 function removeProperty(object, properties) {
     if (!tsModule) {
-        tsModule = (0, ensure_typescript_1.ensureTypescript)();
+        tsModule = (0, internal_1.ensureTypescript)();
     }
     const propertyName = properties.shift();
     const propertyAssignment = findPropertyAssignment(object, propertyName);
@@ -127,7 +127,7 @@ function removeProperty(object, properties) {
 }
 function isModuleExport(node) {
     if (!tsModule) {
-        tsModule = (0, ensure_typescript_1.ensureTypescript)();
+        tsModule = (0, internal_1.ensureTypescript)();
     }
     return (tsModule.isExpressionStatement(node) &&
         node.expression?.kind &&
@@ -137,7 +137,7 @@ function isModuleExport(node) {
 }
 function isDefaultExport(node) {
     if (!tsModule) {
-        tsModule = (0, ensure_typescript_1.ensureTypescript)();
+        tsModule = (0, internal_1.ensureTypescript)();
     }
     return (tsModule.isExportAssignment(node) &&
         node.expression?.kind &&
@@ -149,7 +149,7 @@ function isDefaultExport(node) {
  */
 function jestConfigObjectAst(fileContent) {
     if (!tsModule) {
-        tsModule = (0, ensure_typescript_1.ensureTypescript)();
+        tsModule = (0, internal_1.ensureTypescript)();
     }
     const sourceFile = tsModule.createSourceFile('jest.config.ts', fileContent, tsModule.ScriptTarget.Latest, true);
     const exportStatement = sourceFile.statements.find((statement) => isModuleExport(statement) || isDefaultExport(statement));

package/{src → dist/src}/utils/config/get-jest-projects.d.ts

@@ -12,4 +12,3 @@
  *
  **/
 export declare function getJestProjectsAsync(): Promise<string[]>;
-//# sourceMappingURL=get-jest-projects.d.ts.map

package/{src → dist/src}/utils/config/get-jest-projects.js

@@ -4,7 +4,7 @@ exports.getJestProjectsAsync = getJestProjectsAsync;
 const tslib_1 = require("tslib");
 const devkit_1 = require("@nx/devkit");
 const path_1 = require("path");
-const yargs = tslib_1.__importStar(require("yargs-parser"));
+const yargs_parser_1 = tslib_1.__importDefault(require("yargs-parser"));
 function getJestConfigProjectPath(projectJestConfigPath) {
     return (0, path_1.join)('<rootDir>', projectJestConfigPath);
 }
@@ -98,7 +98,7 @@ function collectJestConfigFromCommand(command, cwd, jestConfigurations) {
         return;
     }
     for (const match of matches) {
-        const parsed = yargs(match, {
+        const parsed = (0, yargs_parser_1.default)(match, {
             configuration: { 'strip-dashed': true },
             string: ['config'],
         });

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

@@ -18,4 +18,3 @@ export declare function addPropertyToJestConfig(host: Tree, path: string, proper
  */
 export declare function removePropertyFromJestConfig(host: Tree, path: string, propertyName: string | string[]): void;
 export declare function addImportStatementToJestConfig(host: Tree, path: string, importStatement: string): void;
-//# sourceMappingURL=update-config.d.ts.map

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

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

package/dist/src/utils/deprecation.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JEST_EXECUTOR_DEPRECATION_MESSAGE = void 0;
+exports.warnJestExecutorDeprecation = warnJestExecutorDeprecation;
+exports.warnJestExecutorGenerating = warnJestExecutorGenerating;
+const devkit_1 = require("@nx/devkit");
+// TODO(v24): Remove the @nx/jest:jest executor. The inferred plugin
+// (@nx/jest/plugin) and the convert-to-inferred generator stay supported.
+exports.JEST_EXECUTOR_DEPRECATION_MESSAGE = 'The `@nx/jest:jest` executor is deprecated and will be removed in Nx v24. Run `nx g @nx/jest:convert-to-inferred` to migrate to the `@nx/jest/plugin` inferred targets. See https://nx.dev/docs/guides/tasks--caching/convert-to-inferred for details.';
+function warnJestExecutorDeprecation() {
+    devkit_1.logger.warn(exports.JEST_EXECUTOR_DEPRECATION_MESSAGE);
+}
+function warnJestExecutorGenerating() {
+    devkit_1.logger.warn('Generating a target that uses the deprecated `@nx/jest:jest` executor. The executor will be removed in Nx v24. Run `nx g @nx/jest:convert-to-inferred` next to migrate this target to the `@nx/jest/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/version-utils.d.ts

@@ -1,3 +1,2 @@
 export declare function getInstalledJestVersion(): string | null;
 export declare function getInstalledJestMajorVersion(): number | null;
-//# sourceMappingURL=version-utils.d.ts.map