@nx/js 21.0.0-beta.0 → 21.0.0-beta.10

package/src/plugins/typescript/plugin.js

@@ -3,23 +3,46 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.createNodes = exports.createNodesV2 = exports.PLUGIN_NAME = exports.createDependencies = void 0;
 const devkit_1 = require("@nx/devkit");
 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");
+const posix = require("node:path/posix");
 const file_hasher_1 = require("nx/src/hasher/file-hasher");
+const picomatch = require("picomatch");
 // eslint-disable-next-line @typescript-eslint/no-restricted-imports
 const lock_file_1 = require("nx/src/plugins/js/lock-file/lock-file");
 const cache_directory_1 = require("nx/src/utils/cache-directory");
-const ts_config_1 = require("../../utils/typescript/ts-config");
 const util_1 = require("./util");
+let ts;
 const pmc = (0, devkit_1.getPackageManagerCommand)();
-function readTargetsCache(cachePath) {
-    return process.env.NX_CACHE_PROJECT_GRAPH !== 'false' && (0, node_fs_1.existsSync)(cachePath)
-        ? (0, devkit_1.readJsonFile)(cachePath)
-        : {};
+const TSCONFIG_CACHE_VERSION = 1;
+const TS_CONFIG_CACHE_PATH = (0, node_path_1.join)(cache_directory_1.workspaceDataDirectory, 'tsconfig-files.hash');
+let tsConfigCacheData;
+let cache;
+function readFromCache(cachePath) {
+    try {
+        return process.env.NX_CACHE_PROJECT_GRAPH !== 'false'
+            ? (0, devkit_1.readJsonFile)(cachePath)
+            : {};
+    }
+    catch {
+        return {};
+    }
 }
-function writeTargetsToCache(cachePath, results) {
-    (0, devkit_1.writeJsonFile)(cachePath, results);
+function readTsConfigCacheData() {
+    const cache = readFromCache(TS_CONFIG_CACHE_PATH);
+    if (cache.version !== TSCONFIG_CACHE_VERSION) {
+        return {};
+    }
+    return cache.data;
+}
+function writeToCache(cachePath, data) {
+    (0, devkit_1.writeJsonFile)(cachePath, data, { spaces: 0 });
+}
+function writeTsConfigCache(data) {
+    writeToCache(TS_CONFIG_CACHE_PATH, {
+        version: TSCONFIG_CACHE_VERSION,
+        data,
+    });
 }
 /**
  * @deprecated The 'createDependencies' function is now a no-op. This functionality is included in 'createNodesV2'.
@@ -34,15 +57,32 @@ exports.createNodesV2 = [
     tsConfigGlob,
     async (configFilePaths, options, context) => {
         const optionsHash = (0, file_hasher_1.hashObject)(options);
-        const cachePath = (0, node_path_1.join)(cache_directory_1.workspaceDataDirectory, `tsc-${optionsHash}.hash`);
-        const targetsCache = readTargetsCache(cachePath);
+        const targetsCachePath = (0, node_path_1.join)(cache_directory_1.workspaceDataDirectory, `tsc-${optionsHash}.hash`);
+        const targetsCache = readFromCache(targetsCachePath);
+        cache = { fileHashes: {}, rawFiles: {}, isExternalProjectReference: {} };
+        initializeTsConfigCache(configFilePaths, context.workspaceRoot);
         const normalizedOptions = normalizePluginOptions(options);
-        const lockFileName = (0, lock_file_1.getLockFileName)((0, devkit_1.detectPackageManager)(context.workspaceRoot));
+        const { configFilePaths: validConfigFilePaths, hashes, projectRoots, } = await resolveValidConfigFilesAndHashes(configFilePaths, optionsHash, context);
         try {
-            return await (0, devkit_1.createNodesFromFiles)((configFile, options, context) => createNodesInternal(configFile, options, context, lockFileName, targetsCache), configFilePaths, normalizedOptions, context);
+            return await (0, devkit_1.createNodesFromFiles)((configFilePath, options, context, idx) => {
+                const projectRoot = projectRoots[idx];
+                const hash = hashes[idx];
+                const cacheKey = `${hash}_${configFilePath}`;
+                targetsCache[cacheKey] ??= buildTscTargets((0, node_path_1.join)(context.workspaceRoot, configFilePath), projectRoot, options, context);
+                const { targets } = targetsCache[cacheKey];
+                return {
+                    projects: {
+                        [projectRoot]: {
+                            projectType: 'library',
+                            targets,
+                        },
+                    },
+                };
+            }, validConfigFilePaths, normalizedOptions, context);
         }
         finally {
-            writeTargetsToCache(cachePath, targetsCache);
+            writeToCache(targetsCachePath, targetsCache);
+            writeTsConfigCache(toRelativePaths(tsConfigCacheData, context.workspaceRoot));
         }
     },
 ];
@@ -50,28 +90,95 @@ exports.createNodes = [
     tsConfigGlob,
     async (configFilePath, options, context) => {
         devkit_1.logger.warn('`createNodes` is deprecated. Update your plugin to utilize createNodesV2 instead. In Nx 20, this will change to the createNodesV2 API.');
+        const projectRoot = (0, node_path_1.dirname)(configFilePath);
+        if (!checkIfConfigFileShouldBeProject(configFilePath, projectRoot, context)) {
+            return {};
+        }
         const normalizedOptions = normalizePluginOptions(options);
-        const lockFileName = (0, lock_file_1.getLockFileName)((0, devkit_1.detectPackageManager)(context.workspaceRoot));
-        return createNodesInternal(configFilePath, normalizedOptions, context, lockFileName, {});
+        cache = { fileHashes: {}, rawFiles: {}, isExternalProjectReference: {} };
+        initializeTsConfigCache([configFilePath], context.workspaceRoot);
+        const { targets } = buildTscTargets((0, node_path_1.join)(context.workspaceRoot, configFilePath), projectRoot, normalizedOptions, context);
+        writeTsConfigCache(toRelativePaths(tsConfigCacheData, context.workspaceRoot));
+        return {
+            projects: {
+                [projectRoot]: {
+                    projectType: 'library',
+                    targets,
+                },
+            },
+        };
     },
 ];
-async function createNodesInternal(configFilePath, options, context, lockFileName, targetsCache) {
-    const projectRoot = (0, node_path_1.dirname)(configFilePath);
-    const fullConfigPath = (0, devkit_1.joinPathFragments)(context.workspaceRoot, configFilePath);
+async function resolveValidConfigFilesAndHashes(configFilePaths, optionsHash, context) {
+    const lockFileHash = (0, file_hasher_1.hashFile)((0, node_path_1.join)(context.workspaceRoot, (0, lock_file_1.getLockFileName)((0, devkit_1.detectPackageManager)(context.workspaceRoot)))) ?? '';
+    const validConfigFilePaths = [];
+    const hashes = [];
+    const projectRoots = [];
+    for await (const configFilePath of configFilePaths) {
+        const projectRoot = (0, node_path_1.dirname)(configFilePath);
+        if (!checkIfConfigFileShouldBeProject(configFilePath, projectRoot, context)) {
+            continue;
+        }
+        projectRoots.push(projectRoot);
+        validConfigFilePaths.push(configFilePath);
+        hashes.push(await getConfigFileHash(configFilePath, context.workspaceRoot, projectRoot, optionsHash, lockFileHash));
+    }
+    return { configFilePaths: validConfigFilePaths, hashes, projectRoots };
+}
+/**
+ * The cache key is composed by:
+ * - hashes of the content of the relevant files that can affect what's inferred by the plugin:
+ *   - current config file
+ *   - config files extended by the current config file (recursively up to the root config file)
+ *   - referenced config files that are internal to the owning Nx project of the current config file,
+ *     or is a shallow external reference of the owning Nx project
+ *   - lock file
+ *   - project's package.json
+ * - hash of the plugin options
+ * - current config file path
+ */
+async function getConfigFileHash(configFilePath, workspaceRoot, projectRoot, optionsHash, lockFileHash) {
+    const fullConfigPath = (0, node_path_1.join)(workspaceRoot, configFilePath);
+    const tsConfig = retrieveTsConfigFromCache(fullConfigPath, workspaceRoot);
+    const extendedConfigFiles = getExtendedConfigFiles(tsConfig, workspaceRoot);
+    const internalReferencedFiles = resolveInternalProjectReferences(tsConfig, workspaceRoot, projectRoot);
+    const externalProjectReferences = resolveShallowExternalProjectReferences(tsConfig, workspaceRoot, projectRoot);
+    let packageJson = null;
+    try {
+        packageJson = (0, devkit_1.readJsonFile)((0, node_path_1.join)(workspaceRoot, projectRoot, 'package.json'));
+    }
+    catch { }
+    return (0, file_hasher_1.hashArray)([
+        ...[
+            fullConfigPath,
+            ...extendedConfigFiles.files.sort(),
+            ...Object.keys(internalReferencedFiles).sort(),
+            ...Object.keys(externalProjectReferences).sort(),
+        ].map((file) => getFileHash(file, workspaceRoot)),
+        ...extendedConfigFiles.packages.sort(),
+        lockFileHash,
+        optionsHash,
+        ...(packageJson ? [(0, file_hasher_1.hashObject)(packageJson)] : []),
+        // change this to bust the cache when making changes that would yield
+        // different results for the same hash
+        (0, file_hasher_1.hashObject)({ bust: 2 }),
+    ]);
+}
+function checkIfConfigFileShouldBeProject(configFilePath, projectRoot, context) {
     // Do not create a project for the workspace root tsconfig files.
     if (projectRoot === '.') {
-        return {};
+        return false;
     }
     // Do not create a project if package.json and project.json isn't there.
     const siblingFiles = (0, node_fs_1.readdirSync)((0, node_path_1.join)(context.workspaceRoot, projectRoot));
     if (!siblingFiles.includes('package.json') &&
         !siblingFiles.includes('project.json')) {
-        return {};
+        return false;
     }
     // Do not create a project if it's not a tsconfig.json and there is no tsconfig.json in the same directory
     if ((0, node_path_1.basename)(configFilePath) !== 'tsconfig.json' &&
         !siblingFiles.includes('tsconfig.json')) {
-        return {};
+        return false;
     }
     // Do not create project for Next.js projects since they are not compatible with
     // project references and typecheck will fail.
@@ -79,56 +186,19 @@ async function createNodesInternal(configFilePath, options, context, lockFileNam
         siblingFiles.includes('next.config.cjs') ||
         siblingFiles.includes('next.config.mjs') ||
         siblingFiles.includes('next.config.ts')) {
-        return {};
+        return false;
     }
-    /**
-     * The cache key is composed by:
-     * - hashes of the content of the relevant files that can affect what's inferred by the plugin:
-     *   - current config file
-     *   - config files extended by the current config file (recursively up to the root config file)
-     *   - referenced config files that are internal to the owning Nx project of the current config file, or is a shallow external reference of the owning Nx project
-     *   - lock file
-     * - hash of the plugin options
-     * - current config file path
-     */
-    const tsConfig = readCachedTsConfig(fullConfigPath);
-    const extendedConfigFiles = getExtendedConfigFiles(fullConfigPath, tsConfig);
-    const internalReferencedFiles = resolveInternalProjectReferences(tsConfig, context.workspaceRoot, projectRoot);
-    const externalProjectReferences = resolveShallowExternalProjectReferences(tsConfig, context.workspaceRoot, projectRoot);
-    const packageJsonPath = (0, devkit_1.joinPathFragments)(projectRoot, 'package.json');
-    const packageJson = (0, node_fs_1.existsSync)(packageJsonPath)
-        ? (0, devkit_1.readJsonFile)(packageJsonPath)
-        : null;
-    const nodeHash = (0, file_hasher_1.hashArray)([
-        ...[
-            fullConfigPath,
-            ...extendedConfigFiles.files,
-            ...Object.keys(internalReferencedFiles),
-            ...Object.keys(externalProjectReferences),
-            (0, node_path_1.join)(context.workspaceRoot, lockFileName),
-        ].map(file_hasher_1.hashFile),
-        (0, file_hasher_1.hashObject)(options),
-        ...(packageJson ? [(0, file_hasher_1.hashObject)(packageJson)] : []),
-    ]);
-    const cacheKey = `${nodeHash}_${configFilePath}`;
-    targetsCache[cacheKey] ??= buildTscTargets(fullConfigPath, projectRoot, options, context);
-    const { targets } = targetsCache[cacheKey];
-    return {
-        projects: {
-            [projectRoot]: {
-                projectType: 'library',
-                targets,
-            },
-        },
-    };
+    return true;
 }
 function buildTscTargets(configFilePath, projectRoot, options, context) {
     const targets = {};
     const namedInputs = (0, get_named_inputs_1.getNamedInputs)(projectRoot, context);
-    const tsConfig = readCachedTsConfig(configFilePath);
+    const tsConfig = retrieveTsConfigFromCache(configFilePath, context.workspaceRoot);
     let internalProjectReferences;
     // Typecheck target
-    if ((0, node_path_1.basename)(configFilePath) === 'tsconfig.json' && options.typecheck) {
+    if ((0, node_path_1.basename)(configFilePath) === 'tsconfig.json' &&
+        options.typecheck &&
+        tsConfig.raw?.['nx']?.addTypecheckTarget !== false) {
         internalProjectReferences = resolveInternalProjectReferences(tsConfig, context.workspaceRoot, projectRoot);
         const externalProjectReferences = resolveShallowExternalProjectReferences(tsConfig, context.workspaceRoot, projectRoot);
         const targetName = options.typecheck.targetName;
@@ -140,13 +210,27 @@ function buildTscTargets(configFilePath, projectRoot, options, context) {
                 // `tsc --build` does not work with `noEmit: true`
                 command = `echo "The 'typecheck' target is disabled because one or more project references set 'noEmit: true' in their tsconfig. Remove this property to resolve this issue."`;
             }
+            const dependsOn = [`^${targetName}`];
+            if (options.build && targets[options.build.targetName]) {
+                // we already processed and have a build target
+                dependsOn.unshift(options.build.targetName);
+            }
+            else if (options.build) {
+                // check if the project will have a build target
+                const buildConfigPath = (0, devkit_1.joinPathFragments)(projectRoot, options.build.configName);
+                if (context.configFiles.some((f) => f === buildConfigPath) &&
+                    (0, util_1.isValidPackageJsonBuildConfig)(retrieveTsConfigFromCache(buildConfigPath, context.workspaceRoot), context.workspaceRoot, projectRoot)) {
+                    dependsOn.unshift(options.build.targetName);
+                }
+            }
             targets[targetName] = {
-                dependsOn: [`^${targetName}`],
+                dependsOn,
                 command,
                 options: { cwd: projectRoot },
                 cache: true,
                 inputs: getInputs(namedInputs, configFilePath, tsConfig, internalProjectReferences, context.workspaceRoot, projectRoot),
-                outputs: getOutputs(configFilePath, tsConfig, internalProjectReferences, context.workspaceRoot, projectRoot),
+                outputs: getOutputs(configFilePath, tsConfig, internalProjectReferences, context.workspaceRoot, projectRoot, 
+                /* emitDeclarationOnly */ true),
                 syncGenerators: ['@nx/js:typescript-sync'],
                 metadata: {
                     technologies: ['typescript'],
@@ -164,7 +248,7 @@ function buildTscTargets(configFilePath, projectRoot, options, context) {
     // Build target
     if (options.build &&
         (0, node_path_1.basename)(configFilePath) === options.build.configName &&
-        isValidPackageJsonBuildConfig(tsConfig, context.workspaceRoot, projectRoot)) {
+        (0, util_1.isValidPackageJsonBuildConfig)(tsConfig, context.workspaceRoot, projectRoot)) {
         internalProjectReferences ??= resolveInternalProjectReferences(tsConfig, context.workspaceRoot, projectRoot);
         const targetName = options.build.targetName;
         targets[targetName] = {
@@ -173,7 +257,9 @@ function buildTscTargets(configFilePath, projectRoot, options, context) {
             options: { cwd: projectRoot },
             cache: true,
             inputs: getInputs(namedInputs, configFilePath, tsConfig, internalProjectReferences, context.workspaceRoot, projectRoot),
-            outputs: getOutputs(configFilePath, tsConfig, internalProjectReferences, context.workspaceRoot, projectRoot),
+            outputs: getOutputs(configFilePath, tsConfig, internalProjectReferences, context.workspaceRoot, projectRoot, 
+            // should be false for build target, but providing it just in case is set to true
+            tsConfig.options.emitDeclarationOnly),
             syncGenerators: ['@nx/js:typescript-sync'],
             metadata: {
                 technologies: ['typescript'],
@@ -196,7 +282,7 @@ function buildTscTargets(configFilePath, projectRoot, options, context) {
 function getInputs(namedInputs, configFilePath, tsConfig, internalProjectReferences, workspaceRoot, projectRoot) {
     const configFiles = new Set();
     const externalDependencies = ['typescript'];
-    const extendedConfigFiles = getExtendedConfigFiles(configFilePath, tsConfig);
+    const extendedConfigFiles = getExtendedConfigFiles(tsConfig, workspaceRoot);
     extendedConfigFiles.files.forEach((configPath) => {
         configFiles.add(configPath);
     });
@@ -208,10 +294,57 @@ function getInputs(namedInputs, configFilePath, tsConfig, internalProjectReferen
         ...Object.entries(internalProjectReferences),
     ];
     const absoluteProjectRoot = (0, node_path_1.join)(workspaceRoot, projectRoot);
+    if (!ts) {
+        ts = require('typescript');
+    }
+    // https://github.com/microsoft/TypeScript/blob/19b777260b26aac5707b1efd34202054164d4a9d/src/compiler/utilities.ts#L9869
+    const supportedTSExtensions = [
+        ts.Extension.Ts,
+        ts.Extension.Tsx,
+        ts.Extension.Dts,
+        ts.Extension.Cts,
+        ts.Extension.Dcts,
+        ts.Extension.Mts,
+        ts.Extension.Dmts,
+    ];
+    // https://github.com/microsoft/TypeScript/blob/19b777260b26aac5707b1efd34202054164d4a9d/src/compiler/utilities.ts#L9878
+    const allSupportedExtensions = [
+        ts.Extension.Ts,
+        ts.Extension.Tsx,
+        ts.Extension.Dts,
+        ts.Extension.Js,
+        ts.Extension.Jsx,
+        ts.Extension.Cts,
+        ts.Extension.Dcts,
+        ts.Extension.Cjs,
+        ts.Extension.Mts,
+        ts.Extension.Dmts,
+        ts.Extension.Mjs,
+    ];
+    const normalizeInput = (input, config) => {
+        const extensions = config.options.allowJs
+            ? [...allSupportedExtensions]
+            : [...supportedTSExtensions];
+        if (config.options.resolveJsonModule) {
+            extensions.push(ts.Extension.Json);
+        }
+        const segments = input.split('/');
+        // An "includes" path "foo" is implicitly a glob "foo/**/*" if its last
+        // segment has no extension, and does not contain any glob characters
+        // itself.
+        // https://github.com/microsoft/TypeScript/blob/19b777260b26aac5707b1efd34202054164d4a9d/src/compiler/utilities.ts#L9577-L9585
+        if (!/[.*?]/.test(segments.at(-1))) {
+            return extensions.map((ext) => `${segments.join('/')}/**/*${ext}`);
+        }
+        return [input];
+    };
     projectTsConfigFiles.forEach(([configPath, config]) => {
         configFiles.add(configPath);
         const offset = (0, node_path_1.relative)(absoluteProjectRoot, (0, node_path_1.dirname)(configPath));
-        (config.raw?.include ?? []).forEach((p) => includePaths.add((0, node_path_1.join)(offset, p)));
+        (config.raw?.include ?? []).forEach((p) => {
+            const normalized = normalizeInput((0, node_path_1.join)(offset, p), config);
+            normalized.forEach((input) => includePaths.add(input));
+        });
         if (config.raw?.exclude) {
             /**
              * We need to filter out the exclude paths that are already included in
@@ -226,8 +359,8 @@ function getInputs(namedInputs, configFilePath, tsConfig, internalProjectReferen
             });
             const normalize = (p) => (p.startsWith('./') ? p.slice(2) : p);
             config.raw.exclude.forEach((excludePath) => {
-                if (!otherFilesInclude.some((includePath) => (0, minimatch_1.minimatch)(normalize(includePath), normalize(excludePath)) ||
-                    (0, minimatch_1.minimatch)(normalize(excludePath), normalize(includePath)))) {
+                if (!otherFilesInclude.some((includePath) => picomatch(normalize(excludePath))(normalize(includePath)) ||
+                    picomatch(normalize(includePath))(normalize(excludePath)))) {
                     excludePaths.add(excludePath);
                 }
             });
@@ -259,7 +392,7 @@ function getInputs(namedInputs, configFilePath, tsConfig, internalProjectReferen
     inputs.push({ externalDependencies });
     return inputs;
 }
-function getOutputs(configFilePath, tsConfig, internalProjectReferences, workspaceRoot, projectRoot) {
+function getOutputs(configFilePath, tsConfig, internalProjectReferences, workspaceRoot, projectRoot, emitDeclarationOnly) {
     const outputs = new Set();
     // We could have more surgical outputs based on the tsconfig options, but the
     // user could override them through the command line and that wouldn't be
@@ -281,9 +414,18 @@ function getOutputs(configFilePath, tsConfig, internalProjectReferences, workspa
                 : pathToInputOrOutput((0, devkit_1.joinPathFragments)(outDir, `${outFileName}.tsbuildinfo`), workspaceRoot, projectRoot));
         }
         else if (config.options.outDir) {
-            outputs.add(pathToInputOrOutput(config.options.outDir, workspaceRoot, projectRoot));
+            if (emitDeclarationOnly) {
+                outputs.add(pathToInputOrOutput((0, devkit_1.joinPathFragments)(config.options.outDir, '**/*.d.ts'), workspaceRoot, projectRoot));
+                if (tsConfig.options.declarationMap) {
+                    outputs.add(pathToInputOrOutput((0, devkit_1.joinPathFragments)(config.options.outDir, '**/*.d.ts.map'), workspaceRoot, projectRoot));
+                }
+            }
+            else {
+                outputs.add(pathToInputOrOutput(config.options.outDir, workspaceRoot, projectRoot));
+            }
             if (config.options.tsBuildInfoFile) {
-                if (!(0, node_path_1.normalize)(config.options.tsBuildInfoFile).startsWith(`${(0, node_path_1.normalize)(config.options.outDir)}${node_path_1.sep}`)) {
+                if (emitDeclarationOnly ||
+                    !(0, node_path_1.normalize)(config.options.tsBuildInfoFile).startsWith(`${(0, node_path_1.normalize)(config.options.outDir)}${node_path_1.sep}`)) {
                     // https://www.typescriptlang.org/tsconfig#tsBuildInfoFile
                     outputs.add(pathToInputOrOutput(config.options.tsBuildInfoFile, workspaceRoot, projectRoot));
                 }
@@ -293,8 +435,15 @@ function getOutputs(configFilePath, tsConfig, internalProjectReferences, workspa
                 const relativeRootDir = (0, node_path_1.relative)(config.options.rootDir, (0, node_path_1.join)(workspaceRoot, projectRoot));
                 outputs.add(pathToInputOrOutput((0, devkit_1.joinPathFragments)(config.options.outDir, relativeRootDir, `*.tsbuildinfo`), workspaceRoot, projectRoot));
             }
+            else if (emitDeclarationOnly) {
+                // https://www.typescriptlang.org/tsconfig#tsBuildInfoFile
+                const name = (0, node_path_1.basename)(configFilePath, '.json');
+                outputs.add(pathToInputOrOutput((0, devkit_1.joinPathFragments)(config.options.outDir, `${name}.tsbuildinfo`), workspaceRoot, projectRoot));
+            }
         }
-        else if (config.fileNames.length) {
+        else if (config.raw?.include?.length ||
+            config.raw?.files?.length ||
+            (!config.raw?.include && !config.raw?.files)) {
             // tsc produce files in place when no outDir or outFile is set
             outputs.add((0, devkit_1.joinPathFragments)('{projectRoot}', '**/*.js'));
             outputs.add((0, devkit_1.joinPathFragments)('{projectRoot}', '**/*.cjs'));
@@ -317,87 +466,6 @@ function getOutputs(configFilePath, tsConfig, internalProjectReferences, workspa
     });
     return Array.from(outputs);
 }
-/**
- * Validates the build configuration of a `package.json` file by ensuring that paths in the `exports`, `module`,
- * and `main` fields reference valid output paths within the `outDir` defined in the TypeScript configuration.
- * Priority is given to the `exports` field, specifically the `.` export if defined. If `exports` is not defined,
- * the function falls back to validating `main` and `module` fields. If `outFile` is specified, it validates that the file
- * is located within the output directory.
- * If no `package.json` file exists, it assumes the configuration is valid.
- *
- * @param tsConfig The TypeScript configuration object.
- * @param workspaceRoot The workspace root path.
- * @param projectRoot The project root path.
- * @returns `true` if the package has a valid build configuration; otherwise, `false`.
- */
-function isValidPackageJsonBuildConfig(tsConfig, workspaceRoot, projectRoot) {
-    const packageJsonPath = (0, node_path_1.join)(workspaceRoot, projectRoot, 'package.json');
-    if (!(0, node_fs_1.existsSync)(packageJsonPath)) {
-        // If the package.json file does not exist.
-        // Assume it's valid because it would be using `project.json` instead.
-        return true;
-    }
-    const packageJson = (0, devkit_1.readJsonFile)(packageJsonPath);
-    const outDir = tsConfig.options.outFile
-        ? (0, node_path_1.dirname)(tsConfig.options.outFile)
-        : tsConfig.options.outDir;
-    const resolvedOutDir = outDir
-        ? (0, node_path_1.resolve)(workspaceRoot, projectRoot, outDir)
-        : undefined;
-    const isPathSourceFile = (path) => {
-        if (resolvedOutDir) {
-            const pathToCheck = (0, node_path_1.resolve)(workspaceRoot, projectRoot, path);
-            return !pathToCheck.startsWith(resolvedOutDir);
-        }
-        const ext = (0, node_path_1.extname)(path);
-        // Check that the file extension is a TS file extension. As the source files are in the same directory as the output files.
-        return ['.ts', '.tsx', '.cts', '.mts'].includes(ext);
-    };
-    // Checks if the value is a path within the `src` directory.
-    const containsInvalidPath = (value) => {
-        if (typeof value === 'string') {
-            return isPathSourceFile(value);
-        }
-        else if (typeof value === 'object') {
-            return Object.entries(value).some(([currentKey, subValue]) => {
-                // Skip types field
-                if (currentKey === 'types') {
-                    return false;
-                }
-                if (typeof subValue === 'string') {
-                    return isPathSourceFile(subValue);
-                }
-                return false;
-            });
-        }
-        return false;
-    };
-    const exports = packageJson?.exports;
-    // Check the `.` export if `exports` is defined.
-    if (exports) {
-        if (typeof exports === 'string') {
-            return !isPathSourceFile(exports);
-        }
-        if (typeof exports === 'object' && '.' in exports) {
-            return !containsInvalidPath(exports['.']);
-        }
-        // Check other exports if `.` is not defined or valid.
-        for (const key in exports) {
-            if (key !== '.' && containsInvalidPath(exports[key])) {
-                return false;
-            }
-        }
-        return true;
-    }
-    // If `exports` is not defined, fallback to `main` and `module` fields.
-    const buildPaths = ['main', 'module'];
-    for (const field of buildPaths) {
-        if (packageJson[field] && isPathSourceFile(packageJson[field])) {
-            return false;
-        }
-    }
-    return true;
-}
 function pathToInputOrOutput(path, workspaceRoot, projectRoot) {
     const fullProjectRoot = (0, node_path_1.resolve)(workspaceRoot, projectRoot);
     const fullPath = (0, node_path_1.resolve)(workspaceRoot, path);
@@ -407,23 +475,15 @@ function pathToInputOrOutput(path, workspaceRoot, projectRoot) {
     }
     return (0, devkit_1.joinPathFragments)('{projectRoot}', pathRelativeToProjectRoot);
 }
-function getExtendedConfigFiles(tsConfigPath, tsConfig) {
-    const extendedConfigFiles = new Set();
-    const extendedExternalPackages = new Set();
-    let currentConfigPath = tsConfigPath;
-    let currentConfig = tsConfig;
-    while (currentConfig.raw?.extends) {
-        const extendedConfigPath = resolveExtendedTsConfigPath(currentConfig.raw.extends, (0, node_path_1.dirname)(currentConfigPath));
-        if (!extendedConfigPath) {
-            break;
-        }
-        if (extendedConfigPath.externalPackage) {
-            extendedExternalPackages.add(extendedConfigPath.externalPackage);
-            break;
-        }
-        extendedConfigFiles.add(extendedConfigPath.filePath);
-        currentConfig = readCachedTsConfig(extendedConfigPath.filePath);
-        currentConfigPath = extendedConfigPath.filePath;
+function getExtendedConfigFiles(tsConfig, workspaceRoot, extendedConfigFiles = new Set(), extendedExternalPackages = new Set()) {
+    for (const extendedConfigFile of tsConfig.extendedConfigFiles) {
+        if (extendedConfigFile.externalPackage) {
+            extendedExternalPackages.add(extendedConfigFile.externalPackage);
+        }
+        else if (extendedConfigFile.filePath) {
+            extendedConfigFiles.add(extendedConfigFile.filePath);
+            getExtendedConfigFiles(retrieveTsConfigFromCache(extendedConfigFile.filePath, workspaceRoot), workspaceRoot, extendedConfigFiles, extendedExternalPackages);
+        }
     }
     return {
         files: Array.from(extendedConfigFiles),
@@ -431,27 +491,31 @@ function getExtendedConfigFiles(tsConfigPath, tsConfig) {
     };
 }
 function resolveInternalProjectReferences(tsConfig, workspaceRoot, projectRoot, projectReferences = {}) {
-    walkProjectReferences(tsConfig, workspaceRoot, projectRoot, (configPath, config) => {
-        if (isExternalProjectReference(configPath, workspaceRoot, projectRoot)) {
-            return false;
+    if (!tsConfig.projectReferences?.length) {
+        return {};
+    }
+    for (const ref of tsConfig.projectReferences) {
+        let refConfigPath = ref.path;
+        if (projectReferences[refConfigPath]) {
+            // Already resolved
+            continue;
         }
-        else {
-            projectReferences[configPath] = config;
+        if (!(0, node_fs_1.existsSync)(refConfigPath)) {
+            // the referenced tsconfig doesn't exist, ignore it
+            continue;
         }
-    });
-    return projectReferences;
-}
-function resolveShallowExternalProjectReferences(tsConfig, workspaceRoot, projectRoot, projectReferences = {}) {
-    walkProjectReferences(tsConfig, workspaceRoot, projectRoot, (configPath, config) => {
-        if (isExternalProjectReference(configPath, workspaceRoot, projectRoot)) {
-            projectReferences[configPath] = config;
+        if (isExternalProjectReference(refConfigPath, workspaceRoot, projectRoot)) {
+            continue;
         }
-        return false;
-    });
+        if (!refConfigPath.endsWith('.json')) {
+            refConfigPath = (0, node_path_1.join)(refConfigPath, 'tsconfig.json');
+        }
+        projectReferences[refConfigPath] = retrieveTsConfigFromCache(refConfigPath, workspaceRoot);
+        resolveInternalProjectReferences(projectReferences[refConfigPath], workspaceRoot, projectRoot, projectReferences);
+    }
     return projectReferences;
 }
-function walkProjectReferences(tsConfig, workspaceRoot, projectRoot, visitor, // false stops recursion
-projectReferences = {}) {
+function resolveShallowExternalProjectReferences(tsConfig, workspaceRoot, projectRoot, projectReferences = {}) {
     if (!tsConfig.projectReferences?.length) {
         return projectReferences;
     }
@@ -465,13 +529,11 @@ projectReferences = {}) {
             // the referenced tsconfig doesn't exist, ignore it
             continue;
         }
-        if (!refConfigPath.endsWith('.json')) {
-            refConfigPath = (0, node_path_1.join)(refConfigPath, 'tsconfig.json');
-        }
-        const refTsConfig = readCachedTsConfig(refConfigPath);
-        const result = visitor(refConfigPath, refTsConfig);
-        if (result !== false) {
-            walkProjectReferences(refTsConfig, workspaceRoot, projectRoot, visitor);
+        if (isExternalProjectReference(refConfigPath, workspaceRoot, projectRoot)) {
+            if (!refConfigPath.endsWith('.json')) {
+                refConfigPath = (0, node_path_1.join)(refConfigPath, 'tsconfig.json');
+            }
+            projectReferences[refConfigPath] = retrieveTsConfigFromCache(refConfigPath, workspaceRoot);
         }
     }
     return projectReferences;
@@ -497,7 +559,7 @@ function hasExternalProjectReferences(tsConfigPath, tsConfig, workspaceRoot, pro
         if (!refConfigPath.endsWith('.json')) {
             refConfigPath = (0, node_path_1.join)(refConfigPath, 'tsconfig.json');
         }
-        const refTsConfig = readCachedTsConfig(refConfigPath);
+        const refTsConfig = retrieveTsConfigFromCache(refConfigPath, workspaceRoot);
         const result = hasExternalProjectReferences(refConfigPath, refTsConfig, workspaceRoot, projectRoot, seen);
         if (result) {
             return true;
@@ -506,21 +568,28 @@ function hasExternalProjectReferences(tsConfigPath, tsConfig, workspaceRoot, pro
     return false;
 }
 function isExternalProjectReference(refTsConfigPath, workspaceRoot, projectRoot) {
+    const relativePath = posixRelative(workspaceRoot, refTsConfigPath);
+    if (cache.isExternalProjectReference[relativePath] !== undefined) {
+        return cache.isExternalProjectReference[relativePath];
+    }
     const absoluteProjectRoot = (0, node_path_1.join)(workspaceRoot, projectRoot);
     let currentPath = getTsConfigDirName(refTsConfigPath);
     if ((0, node_path_1.relative)(absoluteProjectRoot, currentPath).startsWith('..')) {
         // it's outside of the project root, so it's an external project reference
+        cache.isExternalProjectReference[relativePath] = true;
         return true;
     }
     while (currentPath !== absoluteProjectRoot) {
         if ((0, node_fs_1.existsSync)((0, node_path_1.join)(currentPath, 'package.json')) ||
             (0, node_fs_1.existsSync)((0, node_path_1.join)(currentPath, 'project.json'))) {
             // it's inside a nested project root, so it's and external project reference
+            cache.isExternalProjectReference[relativePath] = true;
             return true;
         }
         currentPath = (0, node_path_1.dirname)(currentPath);
     }
     // it's inside the project root, so it's an internal project reference
+    cache.isExternalProjectReference[relativePath] = false;
     return false;
 }
 function getTsConfigDirName(tsConfigPath) {
@@ -528,19 +597,89 @@ function getTsConfigDirName(tsConfigPath) {
         ? (0, node_path_1.dirname)(tsConfigPath)
         : (0, node_path_1.normalize)(tsConfigPath);
 }
-const tsConfigCache = new Map();
-function readCachedTsConfig(tsConfigPath) {
-    const cacheKey = getTsConfigCacheKey(tsConfigPath);
-    if (tsConfigCache.has(cacheKey)) {
-        return tsConfigCache.get(cacheKey);
-    }
-    const tsConfig = (0, ts_config_1.readTsConfig)(tsConfigPath);
-    tsConfigCache.set(cacheKey, tsConfig);
-    return tsConfig;
+function retrieveTsConfigFromCache(tsConfigPath, workspaceRoot) {
+    const relativePath = posixRelative(workspaceRoot, tsConfigPath);
+    // we don't need to check the hash if it's in the cache, because we've already
+    // checked it when we initially populated the cache
+    return tsConfigCacheData[relativePath]
+        ? tsConfigCacheData[relativePath].data
+        : readTsConfigAndCache(tsConfigPath, workspaceRoot);
+}
+function initializeTsConfigCache(configFilePaths, workspaceRoot) {
+    tsConfigCacheData = toAbsolutePaths(readTsConfigCacheData(), workspaceRoot);
+    // ensure hashes are checked and the cache is invalidated and populated as needed
+    for (const configFilePath of configFilePaths) {
+        const fullConfigPath = (0, node_path_1.join)(workspaceRoot, configFilePath);
+        readTsConfigAndCache(fullConfigPath, workspaceRoot);
+    }
+}
+function readTsConfigAndCache(tsConfigPath, workspaceRoot) {
+    const relativePath = posixRelative(workspaceRoot, tsConfigPath);
+    const hash = getFileHash(tsConfigPath, workspaceRoot);
+    let extendedFilesHash;
+    if (tsConfigCacheData[relativePath] &&
+        tsConfigCacheData[relativePath].hash === hash) {
+        extendedFilesHash = getExtendedFilesHash(tsConfigCacheData[relativePath].data.extendedConfigFiles, workspaceRoot);
+        if (tsConfigCacheData[relativePath].extendedFilesHash === extendedFilesHash) {
+            return tsConfigCacheData[relativePath].data;
+        }
+    }
+    const tsConfig = readTsConfig(tsConfigPath, workspaceRoot);
+    const extendedConfigFiles = [];
+    if (tsConfig.raw?.extends) {
+        const extendsArray = typeof tsConfig.raw.extends === 'string'
+            ? [tsConfig.raw.extends]
+            : tsConfig.raw.extends;
+        for (const extendsPath of extendsArray) {
+            const extendedConfigFile = resolveExtendedTsConfigPath(extendsPath, (0, node_path_1.dirname)(tsConfigPath));
+            if (extendedConfigFile) {
+                extendedConfigFiles.push(extendedConfigFile);
+            }
+        }
+    }
+    extendedFilesHash ??= getExtendedFilesHash(extendedConfigFiles, workspaceRoot);
+    tsConfigCacheData[relativePath] = {
+        data: {
+            options: tsConfig.options,
+            projectReferences: tsConfig.projectReferences,
+            raw: tsConfig.raw,
+            extendedConfigFiles,
+        },
+        hash,
+        extendedFilesHash,
+    };
+    return tsConfigCacheData[relativePath].data;
+}
+function getExtendedFilesHash(extendedConfigFiles, workspaceRoot) {
+    const hashes = [];
+    if (!extendedConfigFiles.length) {
+        return '';
+    }
+    for (const extendedConfigFile of extendedConfigFiles) {
+        if (extendedConfigFile.externalPackage) {
+            hashes.push(extendedConfigFile.externalPackage);
+        }
+        else if (extendedConfigFile.filePath) {
+            hashes.push(getFileHash(extendedConfigFile.filePath, workspaceRoot));
+            hashes.push(getExtendedFilesHash(readTsConfigAndCache(extendedConfigFile.filePath, workspaceRoot)
+                .extendedConfigFiles, workspaceRoot));
+        }
+    }
+    return hashes.join('|');
 }
-function getTsConfigCacheKey(tsConfigPath) {
-    const timestamp = (0, node_fs_1.statSync)(tsConfigPath).mtimeMs;
-    return `${tsConfigPath}-${timestamp}`;
+function readTsConfig(tsConfigPath, workspaceRoot) {
+    if (!ts) {
+        ts = require('typescript');
+    }
+    const tsSys = {
+        ...ts.sys,
+        readFile: (path) => readFile(path, workspaceRoot),
+        readDirectory: () => [],
+    };
+    const readResult = ts.readConfigFile(tsConfigPath, tsSys.readFile);
+    // read with a custom host that won't read directories which is only used
+    // to identify the filenames included in the program, which we won't use
+    return ts.parseJsonConfigFileContent(readResult.config, tsSys, (0, node_path_1.dirname)(tsConfigPath));
 }
 function normalizePluginOptions(pluginOptions = {}) {
     const defaultTypecheckTargetName = 'typecheck';
@@ -587,7 +726,8 @@ function resolveExtendedTsConfigPath(tsConfigPath, directory) {
         const resolvedPath = require.resolve(tsConfigPath, {
             paths: directory ? [directory] : undefined,
         });
-        if (tsConfigPath.startsWith('.')) {
+        if (tsConfigPath.startsWith('.') ||
+            !resolvedPath.includes('/node_modules/')) {
             return { filePath: resolvedPath };
         }
         // parse the package from the tsconfig path
@@ -600,3 +740,99 @@ function resolveExtendedTsConfigPath(tsConfigPath, directory) {
         return null;
     }
 }
+function getFileHash(filePath, workspaceRoot) {
+    const relativePath = posixRelative(workspaceRoot, filePath);
+    if (!cache.fileHashes[relativePath]) {
+        const content = readFile(filePath, workspaceRoot);
+        cache.fileHashes[relativePath] = (0, file_hasher_1.hashArray)([content]);
+    }
+    return cache.fileHashes[relativePath];
+}
+function readFile(filePath, workspaceRoot) {
+    const relativePath = posixRelative(workspaceRoot, filePath);
+    if (!cache.rawFiles[relativePath]) {
+        const content = (0, node_fs_1.readFileSync)(filePath, 'utf8');
+        cache.rawFiles[relativePath] = content;
+    }
+    return cache.rawFiles[relativePath];
+}
+function toAbsolutePaths(cache, workspaceRoot) {
+    const updatedCache = {};
+    for (const [key, { data, extendedFilesHash, hash }] of Object.entries(cache)) {
+        updatedCache[key] = {
+            data: {
+                options: { noEmit: data.options.noEmit },
+                raw: {
+                    nx: { addTypecheckTarget: data.raw?.['nx']?.addTypecheckTarget },
+                },
+                extendedConfigFiles: data.extendedConfigFiles,
+            },
+            extendedFilesHash,
+            hash,
+        };
+        if (data.options.rootDir) {
+            updatedCache[key].data.options.rootDir = (0, node_path_1.join)(workspaceRoot, data.options.rootDir);
+        }
+        if (data.options.outDir) {
+            updatedCache[key].data.options.outDir = (0, node_path_1.join)(workspaceRoot, data.options.outDir);
+        }
+        if (data.options.outFile) {
+            updatedCache[key].data.options.outFile = (0, node_path_1.join)(workspaceRoot, data.options.outFile);
+        }
+        if (data.options.tsBuildInfoFile) {
+            updatedCache[key].data.options.tsBuildInfoFile = (0, node_path_1.join)(workspaceRoot, data.options.tsBuildInfoFile);
+        }
+        if (data.extendedConfigFiles.length) {
+            updatedCache[key].data.extendedConfigFiles.forEach((file) => {
+                file.filePath = (0, node_path_1.join)(workspaceRoot, file.filePath);
+            });
+        }
+        if (data.projectReferences) {
+            updatedCache[key].data.projectReferences = data.projectReferences.map((ref) => ({ ...ref, path: (0, node_path_1.join)(workspaceRoot, ref.path) }));
+        }
+    }
+    return updatedCache;
+}
+function toRelativePaths(cache, workspaceRoot) {
+    const updatedCache = {};
+    for (const [key, { data, extendedFilesHash, hash }] of Object.entries(cache)) {
+        updatedCache[key] = {
+            data: {
+                options: { noEmit: data.options.noEmit },
+                raw: {
+                    nx: { addTypecheckTarget: data.raw?.['nx']?.addTypecheckTarget },
+                },
+                extendedConfigFiles: data.extendedConfigFiles,
+            },
+            extendedFilesHash,
+            hash,
+        };
+        if (data.options.rootDir) {
+            updatedCache[key].data.options.rootDir = posixRelative(workspaceRoot, data.options.rootDir);
+        }
+        if (data.options.outDir) {
+            updatedCache[key].data.options.outDir = posixRelative(workspaceRoot, data.options.outDir);
+        }
+        if (data.options.outFile) {
+            updatedCache[key].data.options.outFile = posixRelative(workspaceRoot, data.options.outFile);
+        }
+        if (data.options.tsBuildInfoFile) {
+            updatedCache[key].data.options.tsBuildInfoFile = posixRelative(workspaceRoot, data.options.tsBuildInfoFile);
+        }
+        if (data.extendedConfigFiles.length) {
+            updatedCache[key].data.extendedConfigFiles.forEach((file) => {
+                file.filePath = posixRelative(workspaceRoot, file.filePath);
+            });
+        }
+        if (data.projectReferences) {
+            updatedCache[key].data.projectReferences = data.projectReferences.map((ref) => ({
+                ...ref,
+                path: posixRelative(workspaceRoot, ref.path),
+            }));
+        }
+    }
+    return updatedCache;
+}
+function posixRelative(workspaceRoot, path) {
+    return posix.normalize((0, node_path_1.relative)(workspaceRoot, path));
+}