@nx/js 23.2.0-beta.2 → 23.2.0-beta.4

package/dist/internal.d.ts

@@ -5,6 +5,7 @@ export { walkTsconfigExtendsChain, type RawTsconfigJsonCache, } from './src/util
 export { isEsmProject } from './src/utils/module-format/is-esm-project';
 export { TS_SOLUTION_SETUP_TSCONFIG_INPUT, addProjectToTsSolutionWorkspace, assertNotUsingTsSolutionSetup, findRuntimeTsConfigName, getDefinedCustomConditionName, getProjectSourceRoot, getProjectType, isUsingTsSolutionSetup, shouldConfigureTsSolutionSetup, updateTsconfigFiles, } from './src/utils/typescript/ts-solution-setup';
 export { getTsConfigBaseOptions } from './src/utils/typescript/create-ts-config';
+export { createTreeParseConfigHost, type TreeParseConfigHost, } from './src/utils/typescript/ts-config';
 export { ensureTypescript } from './src/utils/typescript/ensure-typescript';
 export { getRangeMinimum, getTsConfigModuleResolution, isTypescriptVersionAtLeast, } from './src/utils/is-typescript-version-at-least';
 export { getNeededCompilerOptionOverrides } from './src/utils/typescript/configuration';

package/dist/internal.js

@@ -5,8 +5,8 @@
 // internal consumers and may change without semver protection. Consider it
 // the @nx/js equivalent of `@nx/devkit/internal`.
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.addReleaseConfigForNonTsSolution = exports.addLocalRegistryScripts = exports.stripGlobToBaseDir = exports.getImportPath = exports.createGlobPatternsForDependencies = exports.normalizeUnitTestRunnerOption = exports.normalizeLinterOption = exports.isValidPackageJsonBuildConfig = exports.addBuildAndWatchDepsTargets = exports.findNpmDependencies = exports.getProjectPackageManagerWorkspaceStateWarningTask = exports.getProjectPackageManagerWorkspaceState = exports.getNpmScope = exports.sortPackageJsonFields = exports.CopyAssetsHandler = exports.addSwcRegisterDependencies = exports.addSwcDependencies = exports.addSwcTestConfig = exports.addSwcConfig = exports.createTmpTsConfig = exports.computeCompilerOptionsPaths = exports.calculateProjectDependencies = exports.calculateProjectBuildableDependencies = exports.compileTypeScript = exports.getNeededCompilerOptionOverrides = exports.isTypescriptVersionAtLeast = exports.getTsConfigModuleResolution = exports.getRangeMinimum = exports.ensureTypescript = exports.getTsConfigBaseOptions = exports.updateTsconfigFiles = exports.shouldConfigureTsSolutionSetup = exports.isUsingTsSolutionSetup = exports.getProjectType = exports.getProjectSourceRoot = exports.getDefinedCustomConditionName = exports.findRuntimeTsConfigName = exports.assertNotUsingTsSolutionSetup = exports.addProjectToTsSolutionWorkspace = exports.TS_SOLUTION_SETUP_TSCONFIG_INPUT = exports.isEsmProject = exports.walkTsconfigExtendsChain = exports.findProjectsNpmDependencies = exports.isBuiltinModuleImport = exports.TargetProjectLocator = exports.requireWithTsconfigFallback = exports.registerTsConfigPaths = exports.registerTsProject = exports.loadTsFile = exports.forceRegisterEsmLoader = void 0;
-exports.typesNodeVersion = exports.tsLibVersion = exports.swcNodeVersion = exports.swcHelpersVersion = exports.swcCoreVersion = exports.swcCliVersion = exports.prettierVersion = exports.esbuildVersion = exports.nxVersion = exports.releaseTasks = exports.addReleaseConfigForTsSolution = void 0;
+exports.addLocalRegistryScripts = exports.stripGlobToBaseDir = exports.getImportPath = exports.createGlobPatternsForDependencies = exports.normalizeUnitTestRunnerOption = exports.normalizeLinterOption = exports.isValidPackageJsonBuildConfig = exports.addBuildAndWatchDepsTargets = exports.findNpmDependencies = exports.getProjectPackageManagerWorkspaceStateWarningTask = exports.getProjectPackageManagerWorkspaceState = exports.getNpmScope = exports.sortPackageJsonFields = exports.CopyAssetsHandler = exports.addSwcRegisterDependencies = exports.addSwcDependencies = exports.addSwcTestConfig = exports.addSwcConfig = exports.createTmpTsConfig = exports.computeCompilerOptionsPaths = exports.calculateProjectDependencies = exports.calculateProjectBuildableDependencies = exports.compileTypeScript = exports.getNeededCompilerOptionOverrides = exports.isTypescriptVersionAtLeast = exports.getTsConfigModuleResolution = exports.getRangeMinimum = exports.ensureTypescript = exports.createTreeParseConfigHost = exports.getTsConfigBaseOptions = exports.updateTsconfigFiles = exports.shouldConfigureTsSolutionSetup = exports.isUsingTsSolutionSetup = exports.getProjectType = exports.getProjectSourceRoot = exports.getDefinedCustomConditionName = exports.findRuntimeTsConfigName = exports.assertNotUsingTsSolutionSetup = exports.addProjectToTsSolutionWorkspace = exports.TS_SOLUTION_SETUP_TSCONFIG_INPUT = exports.isEsmProject = exports.walkTsconfigExtendsChain = exports.findProjectsNpmDependencies = exports.isBuiltinModuleImport = exports.TargetProjectLocator = exports.requireWithTsconfigFallback = exports.registerTsConfigPaths = exports.registerTsProject = exports.loadTsFile = exports.forceRegisterEsmLoader = void 0;
+exports.typesNodeVersion = exports.tsLibVersion = exports.swcNodeVersion = exports.swcHelpersVersion = exports.swcCoreVersion = exports.swcCliVersion = exports.prettierVersion = exports.esbuildVersion = exports.nxVersion = exports.releaseTasks = exports.addReleaseConfigForTsSolution = exports.addReleaseConfigForNonTsSolution = void 0;
 // Re-exports of nx-source internals (need `no-restricted-imports` overrides).
 // eslint-disable-next-line @typescript-eslint/no-restricted-imports
 var register_1 = require("nx/src/plugins/js/utils/register");
@@ -47,6 +47,8 @@ Object.defineProperty(exports, "updateTsconfigFiles", { enumerable: true, get: f
 // re-exported here so internal consumers can import it from @nx/js/internal.
 var create_ts_config_1 = require("./src/utils/typescript/create-ts-config");
 Object.defineProperty(exports, "getTsConfigBaseOptions", { enumerable: true, get: function () { return create_ts_config_1.getTsConfigBaseOptions; } });
+var ts_config_1 = require("./src/utils/typescript/ts-config");
+Object.defineProperty(exports, "createTreeParseConfigHost", { enumerable: true, get: function () { return ts_config_1.createTreeParseConfigHost; } });
 var ensure_typescript_1 = require("./src/utils/typescript/ensure-typescript");
 Object.defineProperty(exports, "ensureTypescript", { enumerable: true, get: function () { return ensure_typescript_1.ensureTypescript; } });
 var is_typescript_version_at_least_1 = require("./src/utils/is-typescript-version-at-least");

package/dist/src/executors/verdaccio/verdaccio.impl.js

@@ -7,6 +7,7 @@ const internal_1 = require("@nx/devkit/internal");
 const child_process_1 = require("child_process");
 const detect_port_1 = tslib_1.__importDefault(require("detect-port"));
 const node_fs_1 = require("node:fs");
+const devkit_internals_1 = require("nx/src/devkit-internals");
 const path_1 = require("path");
 const semver_1 = require("semver");
 let childProcess;
@@ -66,12 +67,19 @@ async function verdaccioExecutor(options, context) {
         port: options.port,
     };
 }
+function getVerdaccioBinPath() {
+    const { packageJson, path: packageJsonPath } = (0, devkit_internals_1.readModulePackageJson)('verdaccio');
+    const bin = typeof packageJson.bin === 'string'
+        ? packageJson.bin
+        : packageJson.bin['verdaccio'];
+    return (0, path_1.join)((0, path_1.dirname)(packageJsonPath), bin);
+}
 /**
  * Fork the verdaccio process: https://verdaccio.org/docs/verdaccio-programmatically/#using-fork-from-child_process-module
  */
 function startVerdaccio(options, workspaceRoot) {
     return new Promise((resolve, reject) => {
-        childProcess = (0, child_process_1.fork)(require.resolve('verdaccio/bin/verdaccio'), createVerdaccioOptions(options, workspaceRoot), {
+        childProcess = (0, child_process_1.fork)(getVerdaccioBinPath(), createVerdaccioOptions(options, workspaceRoot), {
             env: {
                 ...process.env,
                 VERDACCIO_HANDLE_KILL_SIGNALS: 'true',

package/dist/src/generators/library/library.d.ts

@@ -2,6 +2,6 @@ import { GeneratorCallback, Tree } from '@nx/devkit';
 import type { LibraryGeneratorSchema, NormalizedLibraryGeneratorOptions } from './schema';
 export declare function libraryGenerator(tree: Tree, schema: LibraryGeneratorSchema): Promise<GeneratorCallback>;
 export declare function libraryGeneratorInternal(tree: Tree, schema: LibraryGeneratorSchema): Promise<GeneratorCallback>;
-export type AddLintOptions = Pick<NormalizedLibraryGeneratorOptions, 'name' | 'linter' | 'projectRoot' | 'unitTestRunner' | 'js' | 'setParserOptionsProject' | 'rootProject' | 'bundler' | 'addPlugin' | 'isUsingTsSolutionConfig'>;
+export type AddLintOptions = Pick<NormalizedLibraryGeneratorOptions, 'name' | 'linter' | 'projectRoot' | 'unitTestRunner' | 'js' | 'enableTypedLinting' | 'setParserOptionsProject' | 'rootProject' | 'bundler' | 'addPlugin' | 'isUsingTsSolutionConfig'>;
 export declare function addLint(tree: Tree, options: AddLintOptions): Promise<GeneratorCallback>;
 export default libraryGenerator;

package/dist/src/generators/library/library.js

@@ -249,6 +249,9 @@ async function configureProject(tree, options) {
 }
 async function addLint(tree, options) {
     const { lintProjectGenerator } = (0, devkit_1.ensurePackage)('@nx/eslint', versions_1.nxVersion);
+    const { addOverrideToLintConfig, lintConfigHasOverride, isEslintConfigSupported, updateOverrideInLintConfig, addIgnoresToLintConfig, isTypedLintingEnabled,
+    // nx-ignore-next-line
+     } = require('@nx/eslint/internal');
     const projectConfiguration = (0, devkit_1.readProjectConfiguration)(tree, options.name);
     const task = await lintProjectGenerator(tree, {
         project: options.name,
@@ -258,15 +261,12 @@ async function addLint(tree, options) {
             (0, devkit_1.joinPathFragments)(options.projectRoot, 'tsconfig.lib.json'),
         ],
         unitTestRunner: options.unitTestRunner,
-        setParserOptionsProject: options.setParserOptionsProject,
+        enableTypedLinting: isTypedLintingEnabled(options),
         rootProject: options.rootProject,
         addPlugin: options.addPlugin,
         // Since the build target is inferred now, we need to let the generator know to add @nx/dependency-checks regardless.
         addPackageJsonDependencyChecks: options.bundler !== 'none',
     });
-    const { addOverrideToLintConfig, lintConfigHasOverride, isEslintConfigSupported, updateOverrideInLintConfig, addIgnoresToLintConfig,
-    // nx-ignore-next-line
-     } = require('@nx/eslint/internal');
     // if config is not supported, we don't need to do anything
     if (!isEslintConfigSupported(tree)) {
         return task;

package/dist/src/generators/library/schema.d.ts

@@ -23,6 +23,10 @@ export interface LibraryGeneratorSchema {
   strict?: boolean;
   publishable?: boolean;
   buildable?: boolean;
+  enableTypedLinting?: boolean;
+  /**
+   * @deprecated Use `enableTypedLinting` instead. This option will be removed in Nx v24.
+   */
   setParserOptionsProject?: boolean;
   config?: 'workspace' | 'project' | 'npm-scripts';
   compiler?: Compiler;

package/dist/src/generators/library/schema.json

@@ -99,11 +99,17 @@
       "description": "Generate a buildable library.",
       "x-deprecated": "Use the `bundler` option for greater control (swc, tsc, rollup, vite, esbuild, none)."
     },
-    "setParserOptionsProject": {
+    "enableTypedLinting": {
       "type": "boolean",
-      "description": "Whether or not to configure the ESLint `parserOptions.project` option. We do not do this by default for lint performance reasons.",
+      "description": "Whether to enable typed linting. For flat configs, this configures the recommended `parserOptions.projectService` and `tsconfigRootDir`. For legacy `.eslintrc` configs, this configures `parserOptions.project`. We do not enable this by default for lint performance reasons.",
       "default": false
     },
+    "setParserOptionsProject": {
+      "type": "boolean",
+      "description": "Deprecated alias for `enableTypedLinting`.",
+      "default": false,
+      "x-deprecated": "Use `enableTypedLinting` instead. This option will be removed in Nx v24."
+    },
     "config": {
       "type": "string",
       "enum": ["workspace", "project", "npm-scripts"],

package/dist/src/generators/setup-build/generator.js

@@ -181,11 +181,7 @@ function updatePackageJsonForTsc(tree, options, project) {
     if (!ts) {
         ts = (0, ensure_typescript_1.ensureTypescript)();
     }
-    const tsconfig = (0, ts_config_1.readTsConfig)(options.tsConfig, {
-        ...ts.sys,
-        readFile: (p) => tree.read(p, 'utf-8'),
-        fileExists: (p) => tree.exists(p),
-    });
+    const tsconfig = (0, ts_config_1.readTsConfig)(options.tsConfig, (0, ts_config_1.createTreeParseConfigHost)(tree));
     let main;
     let rootDir;
     let outputPath;

package/dist/src/migrations/update-23-1-0/add-ignore-deprecations-for-ts6.d.ts

@@ -21,8 +21,9 @@ import { type Tree } from '@nx/devkit';
  *        the pre-TS6 behavior. It is itself deprecated (removed in TS7), so pass
  *        2 silences it, deferring the interop change to the eventual TS7 work.
  *  - Config-load flag: set `ignoreDeprecations: "6.0"` on every file named
- *    exactly `tsconfig.json`, the name jest/ts-node auto-resolve (walking up
- *    from the file they compile, such as jest.config.ts). ts-node injects a
+ *    exactly `tsconfig.json`, the name ts-node auto-resolves when jest compiles
+ *    a config file like jest.config.ts (walking up from the working directory,
+ *    not the config file's own directory). ts-node injects a
  *    `target: es5` when the config leaves it unset, and es5 is a TS6-deprecated
  *    value (TS5107); the flag (which ts-node passes through) keeps that load
  *    silent. Set unconditionally, since any `tsconfig.json` is a potential

package/dist/src/migrations/update-23-1-0/add-ignore-deprecations-for-ts6.js

@@ -5,6 +5,7 @@ const devkit_1 = require("@nx/devkit");
 const node_path_1 = require("node:path");
 const jsonc_parser_1 = require("jsonc-parser");
 const ensure_typescript_1 = require("../../utils/typescript/ensure-typescript");
+const ts_config_1 = require("../../utils/typescript/ts-config");
 const FORMATTING_OPTIONS = {
     formattingOptions: { keepLines: true, insertSpaces: true, tabSize: 2 },
 };
@@ -31,8 +32,9 @@ let tsModule;
  *        the pre-TS6 behavior. It is itself deprecated (removed in TS7), so pass
  *        2 silences it, deferring the interop change to the eventual TS7 work.
  *  - Config-load flag: set `ignoreDeprecations: "6.0"` on every file named
- *    exactly `tsconfig.json`, the name jest/ts-node auto-resolve (walking up
- *    from the file they compile, such as jest.config.ts). ts-node injects a
+ *    exactly `tsconfig.json`, the name ts-node auto-resolves when jest compiles
+ *    a config file like jest.config.ts (walking up from the working directory,
+ *    not the config file's own directory). ts-node injects a
  *    `target: es5` when the config leaves it unset, and es5 is a TS6-deprecated
  *    value (TS5107); the flag (which ts-node passes through) keeps that load
  *    silent. Set unconditionally, since any `tsconfig.json` is a potential
@@ -53,14 +55,11 @@ let tsModule;
 async function default_1(tree) {
     tsModule ??= (0, ensure_typescript_1.ensureTypescript)();
     const ts = tsModule;
-    // Tree-backed host so TypeScript resolves `extends` against pass 1's pending
-    // writes; the `readDirectory` no-op skips the source-file scan, since only the
-    // merged compiler options matter here, not the file list.
-    const parseHost = {
-        ...ts.sys,
-        readFile: (filePath) => tree.read(filePath, 'utf-8') ?? undefined,
-        readDirectory: () => [],
-    };
+    // Tree-faithful host so TypeScript resolves `extends` against pass 1's pending
+    // writes and against package-provided bases (a naive `tree.read` host misses
+    // the latter). The host's `readDirectory` no-op skips the source-file scan,
+    // since only the merged compiler options matter here, not the file list.
+    const parseHost = (0, ts_config_1.createTreeParseConfigHost)(tree);
     const tsconfigPaths = await (0, devkit_1.globAsync)(tree, ['**/tsconfig*.json']);
     // Pass 1: pins and config-load flags, so pass 2's inheritance check sees them.
     let defaultsPinCount = 0;
@@ -178,7 +177,14 @@ function silenceDeprecations(tree, ts, parseHost, tsconfigPath) {
     // The `extends`-merged main options, normalized by TypeScript. Passing the
     // config object (not the path) keeps TypeScript from re-reading this file; it
     // reads only the ancestors.
-    const mainOptions = ts.parseJsonConfigFileContent({ extends: own.extends, compilerOptions: mainIsObject ? mainBlock : {} }, parseHost, (0, node_path_1.dirname)(tsconfigPath)).options;
+    const mainParsed = ts.parseJsonConfigFileContent({ extends: own.extends, compilerOptions: mainIsObject ? mainBlock : {} }, parseHost, (0, node_path_1.dirname)(tsconfigPath));
+    // A base that neither the tree nor `tsc` can read leaves the merged options
+    // incomplete, so a value it deprecates would be missed. The config does not
+    // compile in that state anyway; surface it rather than silently guessing.
+    if ((0, ts_config_1.extendsResolutionFailed)(mainParsed.errors)) {
+        devkit_1.logger.warn(`Could not resolve the "extends" chain of "${tsconfigPath}"; a TypeScript 6 deprecated option inherited from the unresolved base may have been missed. Make sure the config compiles.`);
+    }
+    const mainOptions = mainParsed.options;
     const mainDeprecated = hasDeprecatedOption(ts, mainOptions);
     let contents = original;
     let changed = false;

package/dist/src/release/version-actions.js

@@ -207,12 +207,14 @@ class JsVersionActions extends release_1.VersionActions {
             const depText = numDependenciesToUpdate === 1 ? 'dependency' : 'dependencies';
             logMessages.push(`✍️  Updated ${numDependenciesToUpdate} ${depText} in manifest: ${manifestToUpdate.manifestPath}`);
         }
-        // Update catalog definitions in pnpm-workspace.yaml
+        // Update catalog definitions in the package manager's catalog file
         if (catalogUpdates.length > 0) {
             // catalogManager is guaranteed to be defined when there are catalog updates
             catalogManager.updateCatalogVersions(tree, catalogUpdates);
             const catalogText = catalogUpdates.length === 1 ? 'entry' : 'entries';
-            logMessages.push(`✍️  Updated ${catalogUpdates.length} catalog ${catalogText} in pnpm-workspace.yaml`);
+            logMessages.push(`✍️  Updated ${catalogUpdates.length} catalog ${catalogText} in ${catalogManager
+                .getCatalogDefinitionFilePaths()
+                .join(', ')}`);
         }
         return logMessages;
     }

package/dist/src/utils/typescript/configuration.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.getNeededCompilerOptionOverrides = getNeededCompilerOptionOverrides;
 const path_1 = require("path");
 const ensure_typescript_1 = require("./ensure-typescript");
+const ts_config_1 = require("./ts-config");
 const optionEnumTypeMap = {
     importsNotUsedAsValues: 'ImportsNotUsedAsValues',
     jsx: 'JsxEmit',
@@ -21,11 +22,8 @@ function getNeededCompilerOptionOverrides(tree, compilerOptions, tsConfigPath) {
     if (!ts) {
         ts = (0, ensure_typescript_1.ensureTypescript)();
     }
-    const tsSysFromTree = {
-        ...ts.sys,
-        readFile: (path) => tree.read(path, 'utf-8'),
-    };
-    const parsed = ts.parseJsonConfigFileContent(ts.readConfigFile(tsConfigPath, tsSysFromTree.readFile).config, tsSysFromTree, (0, path_1.dirname)(tsConfigPath));
+    const host = (0, ts_config_1.createTreeParseConfigHost)(tree);
+    const parsed = ts.parseJsonConfigFileContent(ts.readConfigFile(tsConfigPath, host.readFile).config, host, (0, path_1.dirname)(tsConfigPath));
     // ModuleKind: { CommonJS: 'commonjs', ... } => ModuleKind: { commonjs: 'CommonJS', ... }
     const reversedCompilerOptionsEnumValues = {
         JsxEmit: reverseEnum(ts.server.protocol.JsxEmit),

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

@@ -1,7 +1,57 @@
 import { Tree } from '@nx/devkit';
 import type * as ts from 'typescript';
-export declare function readTsConfig(tsConfigPath: string, sys?: ts.System): ts.ParsedCommandLine;
+export declare function readTsConfig(tsConfigPath: string, sys?: ts.ParseConfigHost): ts.ParsedCommandLine;
 export declare function readTsConfigFromTree(tree: Tree, tsConfigPath: string): ts.ParsedCommandLine;
+/**
+ * The members `createTreeParseConfigHost` overrides: the file system ones are
+ * backed by the `Tree`, `realpath`/`getCurrentDirectory` are anchored to
+ * `tree.root`, and `useCaseSensitiveFileNames` is platform-derived from
+ * `ts.sys`. The returned object still spreads `ts.sys` (TypeScript duck-types
+ * the host and reads members this type does not name), so the narrow type is a
+ * compile-time guard on Nx callers: everything outside it is disk-backed and
+ * escapes the tree.
+ */
+export type TreeParseConfigHost = Required<Pick<ts.ParseConfigHost, 'useCaseSensitiveFileNames' | 'readDirectory' | 'readFile' | 'fileExists' | 'directoryExists' | 'realpath' | 'getCurrentDirectory'>>;
+/**
+ * A TypeScript host, backed by the devkit `Tree`, that resolves `extends` the
+ * way real `tsc` does. The naive `{ ...ts.sys, readFile: (p) => tree.read(p) }`
+ * host resolves less than `tsc`:
+ *  - A package-form `extends` (e.g. `@tsconfig/node14/tsconfig.json`) is
+ *    realpath-absolutized by TypeScript; `Tree.read`/`Tree.exists` re-root an
+ *    absolute path under the workspace, so the base reads as nothing and its
+ *    options silently vanish from the merged result (the failure surfaces only
+ *    as a TS5083/TS6053 in `errors`, which callers discard).
+ *  - An extension-less `extends` resolves against `process.cwd()` when
+ *    existence comes from `ts.sys`; Nx never chdirs to the workspace root, so it
+ *    resolves only when the command runs from the root.
+ *
+ * This host maps absolute paths under `tree.root` back to tree-relative for the
+ * tree lookups and falls through to `fs` for paths that resolve outside the
+ * workspace (a pnpm store or a `link:`/`file:` target). Resolution is anchored
+ * to `tree.root` rather than the working directory: TypeScript resolves a
+ * package-form base as a relative path and hands it to `realpath`, and
+ * `ts.sys.realpath` would resolve it against `process.cwd()`, so a workspace
+ * whose root is not an ancestor of the working directory would read a
+ * same-named package from the wrong tree.
+ *
+ * `readDirectory` is a no-op: the source-file scan is skipped because callers
+ * read only the merged `options`, never the file list. A config that resolves
+ * its inputs through `include` (or the default glob) then reports a TS18003
+ * unless it also carries `files` or `references`, so `errors.length > 0` is not
+ * a usable signal; match specific codes (TS5083/TS6053) instead.
+ */
+export declare function createTreeParseConfigHost(tree: Tree): TreeParseConfigHost;
+/**
+ * Whether a `ParsedCommandLine` produced with `createTreeParseConfigHost` failed
+ * to resolve an `extends` target: TS5083 (the base resolved but could not be
+ * read) or TS6053 (the base could not be resolved at all). Because the host
+ * resolves what real `tsc` resolves, this only fires for a config whose extends
+ * chain `tsc` cannot read either. The no-op `readDirectory` also adds a TS18003
+ * whenever the config resolves inputs through `include` and carries neither
+ * `files` nor `references`, so `errors.length > 0` is not a usable signal; match
+ * these two codes.
+ */
+export declare function extendsResolutionFailed(errors: readonly ts.Diagnostic[]): boolean;
 export declare function getRootTsConfigPathInTree(tree: Tree): string | null;
 export declare function getRelativePathToRootTsConfig(tree: Tree, targetPath: string): string;
 export declare function getRootTsConfigPath(): string | null;

package/dist/src/utils/typescript/ts-config.js

@@ -2,6 +2,8 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.readTsConfig = readTsConfig;
 exports.readTsConfigFromTree = readTsConfigFromTree;
+exports.createTreeParseConfigHost = createTreeParseConfigHost;
+exports.extendsResolutionFailed = extendsResolutionFailed;
 exports.getRootTsConfigPathInTree = getRootTsConfigPathInTree;
 exports.getRelativePathToRootTsConfig = getRelativePathToRootTsConfig;
 exports.getRootTsConfigPath = getRootTsConfigPath;
@@ -32,6 +34,118 @@ function readTsConfigFromTree(tree, tsConfigPath) {
     };
     return readTsConfig(tsConfigPath, tsSysFromTree);
 }
+/**
+ * A TypeScript host, backed by the devkit `Tree`, that resolves `extends` the
+ * way real `tsc` does. The naive `{ ...ts.sys, readFile: (p) => tree.read(p) }`
+ * host resolves less than `tsc`:
+ *  - A package-form `extends` (e.g. `@tsconfig/node14/tsconfig.json`) is
+ *    realpath-absolutized by TypeScript; `Tree.read`/`Tree.exists` re-root an
+ *    absolute path under the workspace, so the base reads as nothing and its
+ *    options silently vanish from the merged result (the failure surfaces only
+ *    as a TS5083/TS6053 in `errors`, which callers discard).
+ *  - An extension-less `extends` resolves against `process.cwd()` when
+ *    existence comes from `ts.sys`; Nx never chdirs to the workspace root, so it
+ *    resolves only when the command runs from the root.
+ *
+ * This host maps absolute paths under `tree.root` back to tree-relative for the
+ * tree lookups and falls through to `fs` for paths that resolve outside the
+ * workspace (a pnpm store or a `link:`/`file:` target). Resolution is anchored
+ * to `tree.root` rather than the working directory: TypeScript resolves a
+ * package-form base as a relative path and hands it to `realpath`, and
+ * `ts.sys.realpath` would resolve it against `process.cwd()`, so a workspace
+ * whose root is not an ancestor of the working directory would read a
+ * same-named package from the wrong tree.
+ *
+ * `readDirectory` is a no-op: the source-file scan is skipped because callers
+ * read only the merged `options`, never the file list. A config that resolves
+ * its inputs through `include` (or the default glob) then reports a TS18003
+ * unless it also carries `files` or `references`, so `errors.length > 0` is not
+ * a usable signal; match specific codes (TS5083/TS6053) instead.
+ */
+function createTreeParseConfigHost(tree) {
+    if (!tsModule) {
+        tsModule = (0, ensure_typescript_1.ensureTypescript)();
+    }
+    // Classify with `relative` rather than a string prefix: it normalizes
+    // separators, so an absolute path TypeScript hands over with forward slashes
+    // still matches a `tree.root` carrying platform separators, and it respects
+    // the segment boundary, so a sibling of the root (`/repo/core-utils` for
+    // `/repo/core`) is not taken for a path inside it.
+    const isOutsideRoot = (path) => {
+        if (!(0, path_1.isAbsolute)(path)) {
+            return false;
+        }
+        const rel = (0, path_1.relative)(tree.root, path);
+        return rel === '..' || rel.startsWith(`..${path_1.sep}`) || (0, path_1.isAbsolute)(rel);
+    };
+    const toTreePath = (path) => (0, path_1.isAbsolute)(path) ? (0, path_1.relative)(tree.root, path) || '.' : path;
+    // `ts.sys` gates `readFile`/`fileExists` on `isFile`, so a directory is never
+    // read as a config file. Both branches mirror that, which lets an
+    // extension-less `extends` ("./config") that collides with a same-named
+    // directory fall through to its `.json` sibling. Out-of-root, a bare
+    // `existsSync` answers true for a directory and `readFileSync` on it throws
+    // EISDIR (TS5012, which the extends-failure guard does not catch); in-root,
+    // `tree.exists` also answers true for a directory, so `fileExists` gates on
+    // `tree.isFile`.
+    const isFileOnDisk = (path) => {
+        try {
+            return (0, fs_1.statSync)(path).isFile();
+        }
+        catch {
+            return false;
+        }
+    };
+    const isDirectoryOnDisk = (path) => {
+        try {
+            return (0, fs_1.statSync)(path).isDirectory();
+        }
+        catch {
+            return false;
+        }
+    };
+    return {
+        ...tsModule.sys,
+        readDirectory: () => [],
+        getCurrentDirectory: () => tree.root,
+        // A relative path anchored to the workspace instead of `process.cwd()`; an
+        // absolute one still goes through `ts.sys` so a symlinked in-root
+        // `node_modules` entry resolves to its real (out-of-root) target.
+        realpath: (path) => tsModule.sys.realpath((0, path_1.isAbsolute)(path) ? path : (0, path_1.join)(tree.root, path)),
+        readFile: (path) => isOutsideRoot(path)
+            ? isFileOnDisk(path)
+                ? (0, fs_1.readFileSync)(path, 'utf-8')
+                : undefined
+            : (tree.read(toTreePath(path), 'utf-8') ?? undefined),
+        fileExists: (path) => {
+            if (isOutsideRoot(path)) {
+                return isFileOnDisk(path);
+            }
+            const treePath = toTreePath(path);
+            return tree.exists(treePath) && tree.isFile(treePath);
+        },
+        directoryExists: (path) => {
+            if (isOutsideRoot(path)) {
+                return isDirectoryOnDisk(path);
+            }
+            const treePath = toTreePath(path);
+            return tree.exists(treePath) && !tree.isFile(treePath);
+        },
+    };
+}
+/**
+ * Whether a `ParsedCommandLine` produced with `createTreeParseConfigHost` failed
+ * to resolve an `extends` target: TS5083 (the base resolved but could not be
+ * read) or TS6053 (the base could not be resolved at all). Because the host
+ * resolves what real `tsc` resolves, this only fires for a config whose extends
+ * chain `tsc` cannot read either. The no-op `readDirectory` also adds a TS18003
+ * whenever the config resolves inputs through `include` and carries neither
+ * `files` nor `references`, so `errors.length > 0` is not a usable signal; match
+ * these two codes.
+ */
+function extendsResolutionFailed(errors) {
+    // 5083: Cannot read file '{0}'. 6053: File '{0}' not found.
+    return errors.some((error) => error.code === 5083 || error.code === 6053);
+}
 function getRootTsConfigPathInTree(tree) {
     for (const path of ['tsconfig.base.json', 'tsconfig.json']) {
         if (tree.exists(path)) {

package/migrations.json

@@ -31,7 +31,7 @@
     },
     "23-1-0-add-ignore-deprecations-for-ts6": {
       "version": "23.1.0-beta.8",
-      "description": "Adds `\"ignoreDeprecations\": \"6.0\"` to tsconfig files whose compilerOptions (or ts-node.compilerOptions) carry a TypeScript 6 deprecated option value, set directly or inherited through `extends` including from a base this migration does not edit (e.g. moduleResolution node/node10/classic, baseUrl, target es5, esModuleInterop false, outFile, module amd/umd/system/none, alwaysStrict false, allowSyntheticDefaultImports false, downlevelIteration set). Also pins `\"strict\": false`, `\"noUncheckedSideEffectImports\": false`, `\"types\": [\"*\"]`, and `\"esModuleInterop\": false` in chain-root tsconfigs (no \"extends\") that lack each key, preserving pre-TS6 behavior where these defaults changed; `esModuleInterop` false is itself deprecated (removed in TS7) so it also receives `ignoreDeprecations`, deferring the interop change to the TS7 migration. Also adds `ignoreDeprecations` to every `tsconfig.json` (the exact name jest/ts-node auto-resolve when compiling a config file; ts-node injects a deprecated default `target: es5` there, so the load hits a TS6 error even on a clean config), even one with no deprecated value of its own; a stale local `ignoreDeprecations` (e.g. `5.0`) that would otherwise override the inherited flag is upgraded.",
+      "description": "Adds `\"ignoreDeprecations\": \"6.0\"` to tsconfig files whose compilerOptions (or ts-node.compilerOptions) carry a TypeScript 6 deprecated option value, set directly or inherited through `extends` including from a base this migration does not edit (e.g. moduleResolution node/node10/classic, baseUrl, target es5, esModuleInterop false, outFile, module amd/umd/system/none, alwaysStrict false, allowSyntheticDefaultImports false, downlevelIteration set). Also pins `\"strict\": false`, `\"noUncheckedSideEffectImports\": false`, `\"types\": [\"*\"]`, and `\"esModuleInterop\": false` in chain-root tsconfigs (no \"extends\") that lack each key, preserving pre-TS6 behavior where these defaults changed; `esModuleInterop` false is itself deprecated (removed in TS7) so it also receives `ignoreDeprecations`, deferring the interop change to the TS7 migration. Also adds `ignoreDeprecations` to every `tsconfig.json` (the exact name jest/ts-node auto-resolve when compiling a config file; ts-node injects a deprecated default `target: es5` there, so the load can hit a TS6 error even on a clean config), even one with no deprecated value of its own; a stale local `ignoreDeprecations` (e.g. `5.0`) that would otherwise override the inherited flag is upgraded.",
       "requires": {
         "typescript": ">=6.0.0"
       },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nx/js",
-  "version": "23.2.0-beta.2",
+  "version": "23.2.0-beta.4",
   "private": false,
   "type": "commonjs",
   "files": [
@@ -147,11 +147,11 @@
     "source-map-support": "0.5.19",
     "tinyglobby": "^0.2.12",
     "tslib": "^2.3.0",
-    "@nx/workspace": "23.2.0-beta.2",
-    "@nx/devkit": "23.2.0-beta.2"
+    "@nx/devkit": "23.2.0-beta.4",
+    "@nx/workspace": "23.2.0-beta.4"
   },
   "devDependencies": {
-    "nx": "23.2.0-beta.2"
+    "nx": "23.2.0-beta.4"
   },
   "peerDependencies": {
     "@swc/cli": ">=0.6.0 <0.9.0",