@nx/js 22.1.0-beta.6 → 22.1.0-beta.8

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nx/js",
-  "version": "22.1.0-beta.6",
+  "version": "22.1.0-beta.8",
   "private": false,
   "description": "The JS plugin for Nx contains executors and generators that provide the best experience for developing JavaScript and TypeScript projects. ",
   "repository": {
@@ -39,8 +39,8 @@
     "@babel/preset-env": "^7.23.2",
     "@babel/preset-typescript": "^7.22.5",
     "@babel/runtime": "^7.22.6",
-    "@nx/devkit": "22.1.0-beta.6",
-    "@nx/workspace": "22.1.0-beta.6",
+    "@nx/devkit": "22.1.0-beta.8",
+    "@nx/workspace": "22.1.0-beta.8",
     "@zkochan/js-yaml": "0.0.7",
     "babel-plugin-const-enum": "^1.0.1",
     "babel-plugin-macros": "^3.1.0",
@@ -60,7 +60,7 @@
     "tslib": "^2.3.0"
   },
   "devDependencies": {
-    "nx": "22.1.0-beta.6"
+    "nx": "22.1.0-beta.8"
   },
   "peerDependencies": {
     "verdaccio": "^6.0.5"

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

@@ -1 +1 @@
-{"version":3,"file":"library.d.ts","sourceRoot":"","sources":["../../../../../../packages/js/src/generators/library/library.ts"],"names":[],"mappings":"AAAA,OAAO,EAML,iBAAiB,EAYjB,IAAI,EAKL,MAAM,YAAY,CAAC;AAyCpB,OAAO,KAAK,EAEV,sBAAsB,EACtB,iCAAiC,EAClC,MAAM,UAAU,CAAC;AASlB,wBAAsB,gBAAgB,CACpC,IAAI,EAAE,IAAI,EACV,MAAM,EAAE,sBAAsB,8BAO/B;AAED,wBAAsB,wBAAwB,CAC5C,IAAI,EAAE,IAAI,EACV,MAAM,EAAE,sBAAsB,8BA+K/B;AA2HD,MAAM,MAAM,cAAc,GAAG,IAAI,CAC/B,iCAAiC,EAC/B,MAAM,GACN,QAAQ,GACR,aAAa,GACb,gBAAgB,GAChB,IAAI,GACJ,yBAAyB,GACzB,aAAa,GACb,SAAS,GACT,WAAW,GACX,yBAAyB,CAC5B,CAAC;AAEF,wBAAsB,OAAO,CAC3B,IAAI,EAAE,IAAI,EACV,OAAO,EAAE,cAAc,GACtB,OAAO,CAAC,iBAAiB,CAAC,CA4G5B;AA6uBD,eAAe,gBAAgB,CAAC"}
+{"version":3,"file":"library.d.ts","sourceRoot":"","sources":["../../../../../../packages/js/src/generators/library/library.ts"],"names":[],"mappings":"AAAA,OAAO,EAML,iBAAiB,EAUjB,IAAI,EAKL,MAAM,YAAY,CAAC;AAyCpB,OAAO,KAAK,EAEV,sBAAsB,EACtB,iCAAiC,EAClC,MAAM,UAAU,CAAC;AASlB,wBAAsB,gBAAgB,CACpC,IAAI,EAAE,IAAI,EACV,MAAM,EAAE,sBAAsB,8BAO/B;AAED,wBAAsB,wBAAwB,CAC5C,IAAI,EAAE,IAAI,EACV,MAAM,EAAE,sBAAsB,8BA+K/B;AA2HD,MAAM,MAAM,cAAc,GAAG,IAAI,CAC/B,iCAAiC,EAC/B,MAAM,GACN,QAAQ,GACR,aAAa,GACb,gBAAgB,GAChB,IAAI,GACJ,yBAAyB,GACzB,aAAa,GACb,SAAS,GACT,WAAW,GACX,yBAAyB,CAC5B,CAAC;AAEF,wBAAsB,OAAO,CAC3B,IAAI,EAAE,IAAI,EACV,OAAO,EAAE,cAAc,GACtB,OAAO,CAAC,iBAAiB,CAAC,CA4G5B;AA6uBD,eAAe,gBAAgB,CAAC"}

package/src/generators/library/library.js

@@ -98,8 +98,11 @@ async function libraryGeneratorInternal(tree, schema) {
     else if (options.unitTestRunner === 'vitest' &&
         options.bundler !== 'vite' // Test would have been set up already
     ) {
-        const { vitestGenerator, createOrEditViteConfig } = (0, devkit_1.ensurePackage)('@nx/vite', versions_1.nxVersion);
-        const vitestTask = await vitestGenerator(tree, {
+        const { createOrEditViteConfig } = (0, devkit_1.ensurePackage)('@nx/vite', versions_1.nxVersion);
+        (0, devkit_1.ensurePackage)('@nx/vitest', versions_1.nxVersion);
+        // nx-ignore-next-line
+        const { configurationGenerator } = require('@nx/vitest/generators');
+        const vitestTask = await configurationGenerator(tree, {
             project: options.name,
             uiFramework: 'none',
             coverageProvider: 'v8',

package/src/plugins/typescript/plugin.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"plugin.d.ts","sourceRoot":"","sources":["../../../../../../packages/js/src/plugins/typescript/plugin.ts"],"names":[],"mappings":"AAAA,OAAO,EASL,KAAK,kBAAkB,EAEvB,KAAK,aAAa,EAInB,MAAM,YAAY,CAAC;AAiCpB,MAAM,WAAW,gBAAgB;IAC/B,SAAS,CAAC,EACN,OAAO,GACP;QACE,UAAU,CAAC,EAAE,MAAM,CAAC;KACrB,CAAC;IACN,KAAK,CAAC,EACF,OAAO,GACP;QACE,UAAU,CAAC,EAAE,MAAM,CAAC;QACpB,UAAU,CAAC,EAAE,MAAM,CAAC;QACpB,aAAa,CAAC,EAAE,MAAM,CAAC;QACvB,aAAa,CAAC,EAAE,MAAM,CAAC;QACvB,cAAc,CAAC,EAAE,OAAO,CAAC;KAC1B,CAAC;IACN,aAAa,CAAC,EAAE,OAAO,CAAC;CACzB;AAyFD;;GAEG;AACH,eAAO,MAAM,kBAAkB,EAAE,kBAEhC,CAAC;AAEF,eAAO,MAAM,WAAW,sBAAsB,CAAC;AAI/C,eAAO,MAAM,aAAa,EAAE,aAAa,CAAC,gBAAgB,CA6DzD,CAAC;AAEF,eAAO,MAAM,WAAW,iCAAgB,CAAC"}
+{"version":3,"file":"plugin.d.ts","sourceRoot":"","sources":["../../../../../../packages/js/src/plugins/typescript/plugin.ts"],"names":[],"mappings":"AAAA,OAAO,EAQL,KAAK,kBAAkB,EAEvB,KAAK,aAAa,EAInB,MAAM,YAAY,CAAC;AAgCpB,MAAM,WAAW,gBAAgB;IAC/B,SAAS,CAAC,EACN,OAAO,GACP;QACE,UAAU,CAAC,EAAE,MAAM,CAAC;KACrB,CAAC;IACN,KAAK,CAAC,EACF,OAAO,GACP;QACE,UAAU,CAAC,EAAE,MAAM,CAAC;QACpB,UAAU,CAAC,EAAE,MAAM,CAAC;QACpB,aAAa,CAAC,EAAE,MAAM,CAAC;QACvB,aAAa,CAAC,EAAE,MAAM,CAAC;QACvB,cAAc,CAAC,EAAE,OAAO,CAAC;KAC1B,CAAC;IACN,aAAa,CAAC,EAAE,OAAO,CAAC;CACzB;AAkKD;;GAEG;AACH,eAAO,MAAM,kBAAkB,EAAE,kBAEhC,CAAC;AAEF,eAAO,MAAM,WAAW,sBAAsB,CAAC;AAI/C,eAAO,MAAM,aAAa,EAAE,aAAa,CAAC,gBAAgB,CA6EzD,CAAC;AAEF,eAAO,MAAM,WAAW,iCAAgB,CAAC"}

package/src/plugins/typescript/plugin.js

@@ -59,6 +59,39 @@ function writeTsConfigCache(data) {
         data,
     });
 }
+function createConfigContext(configFilePath, workspaceRoot, projectContext) {
+    const absolutePath = (0, node_path_1.join)(workspaceRoot, configFilePath);
+    return {
+        originalPath: configFilePath,
+        absolutePath,
+        relativePath: posix.relative(workspaceRoot, absolutePath),
+        basename: (0, node_path_1.basename)(configFilePath),
+        basenameNoExt: (0, node_path_1.basename)(configFilePath, '.json'),
+        dirname: (0, node_path_1.dirname)(absolutePath),
+        project: projectContext,
+    };
+}
+function getConfigContext(configPath, workspaceRoot) {
+    const absolutePath = configPath.startsWith('/') || configPath.startsWith(workspaceRoot)
+        ? (0, node_path_1.normalize)(configPath)
+        : (0, node_path_1.join)(workspaceRoot, configPath);
+    let context = cache.configContexts.get(absolutePath);
+    if (context) {
+        return context;
+    }
+    const relativePath = (0, node_path_1.relative)(workspaceRoot, absolutePath);
+    const projectRoot = (0, node_path_1.dirname)(relativePath);
+    if (!cache.projectContexts.has(projectRoot)) {
+        cache.projectContexts.set(projectRoot, {
+            root: projectRoot,
+            normalized: posix.normalize(projectRoot),
+            absolute: (0, node_path_1.join)(workspaceRoot, projectRoot),
+        });
+    }
+    const newContext = createConfigContext(relativePath, workspaceRoot, cache.projectContexts.get(projectRoot));
+    cache.configContexts.set(absolutePath, newContext);
+    return newContext;
+}
 /**
  * @deprecated The 'createDependencies' function is now a no-op. This functionality is included in 'createNodesV2'.
  */
@@ -74,16 +107,26 @@ exports.createNodesV2 = [
         const optionsHash = (0, file_hasher_1.hashObject)(options);
         const targetsCachePath = (0, node_path_1.join)(cache_directory_1.workspaceDataDirectory, `tsc-${optionsHash}.hash`);
         const targetsCache = readFromCache(targetsCachePath);
-        cache = { fileHashes: {}, rawFiles: {}, isExternalProjectReference: {} };
+        cache = {
+            fileHashes: {},
+            rawFiles: {},
+            picomatchMatchers: {},
+            extendedFilesHashes: new Map(),
+            configOwners: new Map(),
+            projectContexts: new Map(),
+            configContexts: new Map(),
+        };
         initializeTsConfigCache(configFilePaths, context.workspaceRoot);
         const normalizedOptions = normalizePluginOptions(options);
-        const { configFilePaths: validConfigFilePaths, hashes, projectRoots, } = await resolveValidConfigFilesAndHashes(configFilePaths, optionsHash, context);
+        const { configFilePaths: validConfigFilePaths, hashes, projectRoots, } = await resolveValidConfigFilesAndHashes(configFilePaths, normalizedOptions, optionsHash, context);
         try {
             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, validConfigFilePaths);
+                const absolutePath = (0, node_path_1.join)(context.workspaceRoot, configFilePath);
+                const configContext = getConfigContext(absolutePath, context.workspaceRoot);
+                targetsCache[cacheKey] ??= buildTscTargets(configContext, options, context, validConfigFilePaths);
                 const { targets } = targetsCache[cacheKey];
                 return {
                     projects: {
@@ -97,23 +140,33 @@ exports.createNodesV2 = [
         finally {
             writeToCache(targetsCachePath, targetsCache);
             writeTsConfigCache(toRelativePaths(tsConfigCacheData, context.workspaceRoot));
+            // Release memory after plugin invocation
+            cache = null;
         }
     },
 ];
 exports.createNodes = exports.createNodesV2;
-async function resolveValidConfigFilesAndHashes(configFilePaths, optionsHash, context) {
+async function resolveValidConfigFilesAndHashes(configFilePaths, options, 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)) {
+        const absolutePath = (0, node_path_1.join)(context.workspaceRoot, configFilePath);
+        const configContext = getConfigContext(absolutePath, context.workspaceRoot);
+        // Skip configs that can't produce any targets based on plugin options
+        const isTypecheckConfig = configContext.basename === 'tsconfig.json';
+        const isBuildConfig = options.build && configContext.basename === options.build.configName;
+        if (!isTypecheckConfig && !isBuildConfig) {
+            continue;
+        }
+        if (!checkIfConfigFileShouldBeProject(configContext)) {
             continue;
         }
         projectRoots.push(projectRoot);
         validConfigFilePaths.push(configFilePath);
-        hashes.push(await getConfigFileHash(configFilePath, context.workspaceRoot, projectRoot, optionsHash, lockFileHash));
+        hashes.push(await getConfigFileHash(configFilePath, context.workspaceRoot, configContext.project, optionsHash, lockFileHash));
     }
     return { configFilePaths: validConfigFilePaths, hashes, projectRoots };
 }
@@ -129,15 +182,15 @@ async function resolveValidConfigFilesAndHashes(configFilePaths, optionsHash, co
  * - hash of the plugin options
  * - current config file path
  */
-async function getConfigFileHash(configFilePath, workspaceRoot, projectRoot, optionsHash, lockFileHash) {
+async function getConfigFileHash(configFilePath, workspaceRoot, project, 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);
+    const internalReferencedFiles = resolveInternalProjectReferences(tsConfig, workspaceRoot, project);
+    const externalProjectReferences = resolveShallowExternalProjectReferences(tsConfig, workspaceRoot, project);
     let packageJson = null;
     try {
-        packageJson = (0, devkit_1.readJsonFile)((0, node_path_1.join)(workspaceRoot, projectRoot, 'package.json'));
+        packageJson = (0, devkit_1.readJsonFile)((0, node_path_1.join)(workspaceRoot, project.root, 'package.json'));
     }
     catch { }
     return (0, file_hasher_1.hashArray)([
@@ -153,19 +206,20 @@ async function getConfigFileHash(configFilePath, workspaceRoot, projectRoot, opt
         ...(packageJson ? [(0, file_hasher_1.hashObject)(packageJson)] : []),
     ]);
 }
-function checkIfConfigFileShouldBeProject(configFilePath, projectRoot, context) {
+function checkIfConfigFileShouldBeProject(config) {
     // Do not create a project for the workspace root tsconfig files.
-    if (projectRoot === '.') {
+    if (config.project.root === '.') {
         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));
+    const siblingFiles = (0, node_fs_1.readdirSync)(config.project.absolute);
     if (!siblingFiles.includes('package.json') &&
         !siblingFiles.includes('project.json')) {
         return false;
     }
+    cache.configOwners.set(config.relativePath, config.project.normalized);
     // 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' &&
+    if (config.basename !== 'tsconfig.json' &&
         !siblingFiles.includes('tsconfig.json')) {
         return false;
     }
@@ -179,17 +233,16 @@ function checkIfConfigFileShouldBeProject(configFilePath, projectRoot, context)
     }
     return true;
 }
-function buildTscTargets(configFilePath, projectRoot, options, context, configFiles) {
+function buildTscTargets(config, options, context, configFiles) {
     const targets = {};
-    const namedInputs = (0, get_named_inputs_1.getNamedInputs)(projectRoot, context);
-    const tsConfig = retrieveTsConfigFromCache(configFilePath, context.workspaceRoot);
+    const namedInputs = (0, get_named_inputs_1.getNamedInputs)(config.project.root, context);
+    const tsConfig = retrieveTsConfigFromCache(config.absolutePath, context.workspaceRoot);
     let internalProjectReferences;
-    // Typecheck target
-    if ((0, node_path_1.basename)(configFilePath) === 'tsconfig.json' &&
+    if (config.basename === 'tsconfig.json' &&
         options.typecheck &&
         tsConfig.raw?.['nx']?.addTypecheckTarget !== false) {
-        internalProjectReferences = resolveInternalProjectReferences(tsConfig, context.workspaceRoot, projectRoot);
-        const externalProjectReferences = resolveShallowExternalProjectReferences(tsConfig, context.workspaceRoot, projectRoot);
+        internalProjectReferences = resolveInternalProjectReferences(tsConfig, context.workspaceRoot, config.project);
+        const externalProjectReferences = resolveShallowExternalProjectReferences(tsConfig, context.workspaceRoot, config.project);
         const targetName = options.typecheck.targetName;
         if (!targets[targetName]) {
             let command = `tsc --build --emitDeclarationOnly${options.verboseOutput ? ' --verbose' : ''}`;
@@ -206,20 +259,20 @@ function buildTscTargets(configFilePath, projectRoot, options, context, configFi
             }
             else if (options.build) {
                 // check if the project will have a build target
-                const buildConfigPath = (0, devkit_1.joinPathFragments)(projectRoot, options.build.configName);
+                const buildConfigPath = (0, devkit_1.joinPathFragments)(config.project.root, options.build.configName);
                 if (configFiles.some((f) => f === buildConfigPath) &&
                     (options.build.skipBuildCheck ||
-                        (0, util_1.isValidPackageJsonBuildConfig)(retrieveTsConfigFromCache(buildConfigPath, context.workspaceRoot), context.workspaceRoot, projectRoot))) {
+                        (0, util_1.isValidPackageJsonBuildConfig)(retrieveTsConfigFromCache(buildConfigPath, context.workspaceRoot), context.workspaceRoot, config.project.root))) {
                     dependsOn.unshift(options.build.targetName);
                 }
             }
             targets[targetName] = {
                 dependsOn,
                 command,
-                options: { cwd: projectRoot },
+                options: { cwd: config.project.root },
                 cache: true,
-                inputs: getInputs(namedInputs, configFilePath, tsConfig, internalProjectReferences, context.workspaceRoot, projectRoot),
-                outputs: getOutputs(configFilePath, tsConfig, internalProjectReferences, context.workspaceRoot, projectRoot, 
+                inputs: getInputs(namedInputs, config, tsConfig, internalProjectReferences, context.workspaceRoot),
+                outputs: getOutputs(config, tsConfig, internalProjectReferences, context.workspaceRoot, 
                 /* emitDeclarationOnly */ true),
                 syncGenerators: ['@nx/js:typescript-sync'],
                 metadata: {
@@ -237,18 +290,18 @@ function buildTscTargets(configFilePath, projectRoot, options, context, configFi
     }
     // Build target
     if (options.build &&
-        (0, node_path_1.basename)(configFilePath) === options.build.configName &&
+        config.basename === options.build.configName &&
         (options.build.skipBuildCheck ||
-            (0, util_1.isValidPackageJsonBuildConfig)(tsConfig, context.workspaceRoot, projectRoot))) {
-        internalProjectReferences ??= resolveInternalProjectReferences(tsConfig, context.workspaceRoot, projectRoot);
+            (0, util_1.isValidPackageJsonBuildConfig)(tsConfig, context.workspaceRoot, config.project.root))) {
+        internalProjectReferences ??= resolveInternalProjectReferences(tsConfig, context.workspaceRoot, config.project);
         const targetName = options.build.targetName;
         targets[targetName] = {
             dependsOn: [`^${targetName}`],
             command: `tsc --build ${options.build.configName}${options.verboseOutput ? ' --verbose' : ''}`,
-            options: { cwd: projectRoot },
+            options: { cwd: config.project.root },
             cache: true,
-            inputs: getInputs(namedInputs, configFilePath, tsConfig, internalProjectReferences, context.workspaceRoot, projectRoot),
-            outputs: getOutputs(configFilePath, tsConfig, internalProjectReferences, context.workspaceRoot, projectRoot, 
+            inputs: getInputs(namedInputs, config, tsConfig, internalProjectReferences, context.workspaceRoot),
+            outputs: getOutputs(config, tsConfig, internalProjectReferences, context.workspaceRoot, 
             // should be false for build target, but providing it just in case is set to true
             tsConfig.options.emitDeclarationOnly),
             syncGenerators: ['@nx/js:typescript-sync'],
@@ -263,14 +316,14 @@ function buildTscTargets(configFilePath, projectRoot, options, context, configFi
                 },
             },
         };
-        (0, util_1.addBuildAndWatchDepsTargets)(context.workspaceRoot, projectRoot, targets, {
+        (0, util_1.addBuildAndWatchDepsTargets)(context.workspaceRoot, config.project.root, targets, {
             buildDepsTargetName: options.build.buildDepsName,
             watchDepsTargetName: options.build.watchDepsName,
         }, pmc);
     }
     return { targets };
 }
-function getInputs(namedInputs, configFilePath, tsConfig, internalProjectReferences, workspaceRoot, projectRoot) {
+function getInputs(namedInputs, config, tsConfig, internalProjectReferences, workspaceRoot) {
     const configFiles = new Set();
     // TODO(leo): temporary disable external dependencies until we support hashing
     // glob patterns from external dependencies
@@ -283,10 +336,10 @@ function getInputs(namedInputs, configFilePath, tsConfig, internalProjectReferen
     const includePaths = new Set();
     const excludePaths = new Set();
     const projectTsConfigFiles = [
-        [configFilePath, tsConfig],
+        [config.originalPath, tsConfig],
         ...Object.entries(internalProjectReferences),
     ];
-    const absoluteProjectRoot = (0, node_path_1.join)(workspaceRoot, projectRoot);
+    const absoluteProjectRoot = config.project.absolute;
     if (!ts) {
         ts = require('typescript');
     }
@@ -333,14 +386,21 @@ function getInputs(namedInputs, configFilePath, tsConfig, internalProjectReferen
     };
     const configDirTemplate = '${configDir}';
     const substituteConfigDir = (p) => p.startsWith(configDirTemplate) ? p.replace(configDirTemplate, './') : p;
-    projectTsConfigFiles.forEach(([configPath, config]) => {
+    // Helper function to get or create cached picomatch matchers
+    const getOrCreateMatcher = (pattern) => {
+        if (!cache.picomatchMatchers[pattern]) {
+            cache.picomatchMatchers[pattern] = picomatch(pattern);
+        }
+        return cache.picomatchMatchers[pattern];
+    };
+    projectTsConfigFiles.forEach(([configPath, tsconfig]) => {
         configFiles.add(configPath);
         const offset = (0, node_path_1.relative)(absoluteProjectRoot, (0, node_path_1.dirname)(configPath));
-        (config.raw?.include ?? []).forEach((p) => {
-            const normalized = normalizeInput((0, node_path_1.join)(offset, substituteConfigDir(p)), config);
+        (tsconfig.raw?.include ?? []).forEach((p) => {
+            const normalized = normalizeInput((0, node_path_1.join)(offset, substituteConfigDir(p)), tsconfig);
             normalized.forEach((input) => includePaths.add(input));
         });
-        if (config.raw?.exclude) {
+        if (tsconfig.raw?.exclude) {
             /**
              * We need to filter out the exclude paths that are already included in
              * other tsconfig files. If they are not included in other tsconfig files,
@@ -353,10 +413,16 @@ function getInputs(namedInputs, configFilePath, tsConfig, internalProjectReferen
                 }
             });
             const normalize = (p) => (p.startsWith('./') ? p.slice(2) : p);
-            config.raw.exclude.forEach((e) => {
+            tsconfig.raw.exclude.forEach((e) => {
                 const excludePath = substituteConfigDir(e);
-                if (!otherFilesInclude.some((includePath) => picomatch(normalize(excludePath))(normalize(includePath)) ||
-                    picomatch(normalize(includePath))(normalize(excludePath)))) {
+                const normalizedExclude = normalize(excludePath);
+                const excludeMatcher = getOrCreateMatcher(normalizedExclude);
+                if (!otherFilesInclude.some((includePath) => {
+                    const normalizedInclude = normalize(includePath);
+                    const includeMatcher = getOrCreateMatcher(normalizedInclude);
+                    return (excludeMatcher(normalizedInclude) ||
+                        includeMatcher(normalizedExclude));
+                })) {
                     excludePaths.add(excludePath);
                 }
             });
@@ -364,10 +430,10 @@ function getInputs(namedInputs, configFilePath, tsConfig, internalProjectReferen
     });
     const inputs = [];
     if (includePaths.size) {
-        if ((0, node_fs_1.existsSync)((0, node_path_1.join)(workspaceRoot, projectRoot, 'package.json'))) {
+        if ((0, node_fs_1.existsSync)((0, node_path_1.join)(workspaceRoot, config.project.root, 'package.json'))) {
             inputs.push('{projectRoot}/package.json');
         }
-        inputs.push(...Array.from(configFiles).map((p) => pathToInputOrOutput(p, workspaceRoot, projectRoot)), ...Array.from(includePaths).map((p) => pathToInputOrOutput((0, devkit_1.joinPathFragments)(projectRoot, p), workspaceRoot, projectRoot)));
+        inputs.push(...Array.from(configFiles).map((p) => pathToInputOrOutput(p, workspaceRoot, config.project)), ...Array.from(includePaths).map((p) => pathToInputOrOutput((0, devkit_1.joinPathFragments)(config.project.root, p), workspaceRoot, config.project)));
     }
     else {
         // If we couldn't identify any include paths, we default to the default
@@ -375,9 +441,9 @@ function getInputs(namedInputs, configFilePath, tsConfig, internalProjectReferen
         inputs.push('production' in namedInputs ? 'production' : 'default');
     }
     if (excludePaths.size) {
-        inputs.push(...Array.from(excludePaths).map((p) => `!${pathToInputOrOutput((0, devkit_1.joinPathFragments)(projectRoot, p), workspaceRoot, projectRoot)}`));
+        inputs.push(...Array.from(excludePaths).map((p) => `!${pathToInputOrOutput((0, devkit_1.joinPathFragments)(config.project.root, p), workspaceRoot, config.project)}`));
     }
-    if (hasExternalProjectReferences(configFilePath, tsConfig, workspaceRoot, projectRoot)) {
+    if (hasExternalProjectReferences(config.originalPath, tsConfig, workspaceRoot, config.project)) {
         // Importing modules from a referenced project will load its output declaration files (d.ts)
         // https://www.typescriptlang.org/docs/handbook/project-references.html#what-is-a-project-reference
         inputs.push({ dependentTasksOutputFiles: '**/*.d.ts' });
@@ -388,58 +454,59 @@ function getInputs(namedInputs, configFilePath, tsConfig, internalProjectReferen
     // inputs.push({ externalDependencies });
     return inputs;
 }
-function getOutputs(configFilePath, tsConfig, internalProjectReferences, workspaceRoot, projectRoot, emitDeclarationOnly) {
+function getOutputs(config, tsConfig, internalProjectReferences, workspaceRoot, 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
     // reflected in the outputs. So, we just include everything that could be
     // produced by the tsc command.
-    [tsConfig, ...Object.values(internalProjectReferences)].forEach((config) => {
-        if (config.options.outFile) {
-            const outFileName = (0, node_path_1.basename)(config.options.outFile, '.js');
-            const outFileDir = (0, node_path_1.dirname)(config.options.outFile);
-            outputs.add(pathToInputOrOutput(config.options.outFile, workspaceRoot, projectRoot));
+    [tsConfig, ...Object.values(internalProjectReferences)].forEach((tsconfig) => {
+        if (tsconfig.options.outFile) {
+            const outFileName = (0, node_path_1.basename)(tsconfig.options.outFile, '.js');
+            const outFileDir = (0, node_path_1.dirname)(tsconfig.options.outFile);
+            outputs.add(pathToInputOrOutput(tsconfig.options.outFile, workspaceRoot, config.project));
             // outFile is not be used with .cjs, .mjs, .jsx, so the list is simpler
             const outDir = (0, node_path_1.relative)(workspaceRoot, outFileDir);
-            outputs.add(pathToInputOrOutput((0, devkit_1.joinPathFragments)(outDir, `${outFileName}.js.map`), workspaceRoot, projectRoot));
-            outputs.add(pathToInputOrOutput((0, devkit_1.joinPathFragments)(outDir, `${outFileName}.d.ts`), workspaceRoot, projectRoot));
-            outputs.add(pathToInputOrOutput((0, devkit_1.joinPathFragments)(outDir, `${outFileName}.d.ts.map`), workspaceRoot, projectRoot));
+            outputs.add(pathToInputOrOutput((0, devkit_1.joinPathFragments)(outDir, `${outFileName}.js.map`), workspaceRoot, config.project));
+            outputs.add(pathToInputOrOutput((0, devkit_1.joinPathFragments)(outDir, `${outFileName}.d.ts`), workspaceRoot, config.project));
+            outputs.add(pathToInputOrOutput((0, devkit_1.joinPathFragments)(outDir, `${outFileName}.d.ts.map`), workspaceRoot, config.project));
             // https://www.typescriptlang.org/tsconfig#tsBuildInfoFile
             outputs.add(tsConfig.options.tsBuildInfoFile
-                ? pathToInputOrOutput(tsConfig.options.tsBuildInfoFile, workspaceRoot, projectRoot)
-                : pathToInputOrOutput((0, devkit_1.joinPathFragments)(outDir, `${outFileName}.tsbuildinfo`), workspaceRoot, projectRoot));
+                ? pathToInputOrOutput(tsConfig.options.tsBuildInfoFile, workspaceRoot, config.project)
+                : pathToInputOrOutput((0, devkit_1.joinPathFragments)(outDir, `${outFileName}.tsbuildinfo`), workspaceRoot, config.project));
         }
-        else if (config.options.outDir) {
+        else if (tsconfig.options.outDir) {
             if (emitDeclarationOnly) {
-                outputs.add(pathToInputOrOutput((0, devkit_1.joinPathFragments)(config.options.outDir, '**/*.d.ts'), workspaceRoot, projectRoot));
+                outputs.add(pathToInputOrOutput((0, devkit_1.joinPathFragments)(tsconfig.options.outDir, '**/*.d.ts'), workspaceRoot, config.project));
                 if (tsConfig.options.declarationMap) {
-                    outputs.add(pathToInputOrOutput((0, devkit_1.joinPathFragments)(config.options.outDir, '**/*.d.ts.map'), workspaceRoot, projectRoot));
+                    outputs.add(pathToInputOrOutput((0, devkit_1.joinPathFragments)(tsconfig.options.outDir, '**/*.d.ts.map'), workspaceRoot, config.project));
                 }
             }
             else {
-                outputs.add(pathToInputOrOutput(config.options.outDir, workspaceRoot, projectRoot));
+                outputs.add(pathToInputOrOutput(tsconfig.options.outDir, workspaceRoot, config.project));
             }
-            if (config.options.tsBuildInfoFile) {
+            if (tsconfig.options.tsBuildInfoFile) {
                 if (emitDeclarationOnly ||
-                    !(0, node_path_1.normalize)(config.options.tsBuildInfoFile).startsWith(`${(0, node_path_1.normalize)(config.options.outDir)}${node_path_1.sep}`)) {
+                    !(0, node_path_1.normalize)(tsconfig.options.tsBuildInfoFile).startsWith(`${(0, node_path_1.normalize)(tsconfig.options.outDir)}${node_path_1.sep}`)) {
                     // https://www.typescriptlang.org/tsconfig#tsBuildInfoFile
-                    outputs.add(pathToInputOrOutput(config.options.tsBuildInfoFile, workspaceRoot, projectRoot));
+                    outputs.add(pathToInputOrOutput(tsconfig.options.tsBuildInfoFile, workspaceRoot, config.project));
                 }
             }
-            else if (config.options.rootDir && config.options.rootDir !== '.') {
+            else if (tsconfig.options.rootDir &&
+                tsconfig.options.rootDir !== '.') {
                 // If rootDir is set, then the tsbuildinfo file will be outside the outDir so we need to add it.
-                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));
+                const relativeRootDir = (0, node_path_1.relative)(tsconfig.options.rootDir, (0, node_path_1.join)(workspaceRoot, config.project.root));
+                outputs.add(pathToInputOrOutput((0, devkit_1.joinPathFragments)(tsconfig.options.outDir, relativeRootDir, `*.tsbuildinfo`), workspaceRoot, config.project));
             }
             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));
+                const name = config.basenameNoExt;
+                outputs.add(pathToInputOrOutput((0, devkit_1.joinPathFragments)(tsconfig.options.outDir, `${name}.tsbuildinfo`), workspaceRoot, config.project));
             }
         }
-        else if (config.raw?.include?.length ||
-            config.raw?.files?.length ||
-            (!config.raw?.include && !config.raw?.files)) {
+        else if (tsconfig.raw?.include?.length ||
+            tsconfig.raw?.files?.length ||
+            (!tsconfig.raw?.include && !tsconfig.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'));
@@ -454,16 +521,16 @@ function getOutputs(configFilePath, tsConfig, internalProjectReferences, workspa
             outputs.add((0, devkit_1.joinPathFragments)('{projectRoot}', '**/*.d.cts.map'));
             outputs.add((0, devkit_1.joinPathFragments)('{projectRoot}', '**/*.d.mts.map'));
             // https://www.typescriptlang.org/tsconfig#tsBuildInfoFile
-            const name = (0, node_path_1.basename)(configFilePath, '.json');
+            const name = config.basenameNoExt;
             outputs.add(tsConfig.options.tsBuildInfoFile
-                ? pathToInputOrOutput(tsConfig.options.tsBuildInfoFile, workspaceRoot, projectRoot)
+                ? pathToInputOrOutput(tsConfig.options.tsBuildInfoFile, workspaceRoot, config.project)
                 : (0, devkit_1.joinPathFragments)('{projectRoot}', `${name}.tsbuildinfo`));
         }
     });
     return Array.from(outputs);
 }
-function pathToInputOrOutput(path, workspaceRoot, projectRoot) {
-    const fullProjectRoot = (0, node_path_1.resolve)(workspaceRoot, projectRoot);
+function pathToInputOrOutput(path, workspaceRoot, project) {
+    const fullProjectRoot = project.absolute;
     const fullPath = (0, node_path_1.resolve)(workspaceRoot, path);
     const pathRelativeToProjectRoot = (0, devkit_1.normalizePath)((0, node_path_1.relative)(fullProjectRoot, fullPath));
     if (pathRelativeToProjectRoot.startsWith('..')) {
@@ -486,55 +553,53 @@ function getExtendedConfigFiles(tsConfig, workspaceRoot, extendedConfigFiles = n
         packages: Array.from(extendedExternalPackages),
     };
 }
-function resolveInternalProjectReferences(tsConfig, workspaceRoot, projectRoot, projectReferences = {}) {
+function resolveInternalProjectReferences(tsConfig, workspaceRoot, project, projectReferences = {}) {
     if (!tsConfig.projectReferences?.length) {
         return {};
     }
     for (const ref of tsConfig.projectReferences) {
         let refConfigPath = ref.path;
         if (projectReferences[refConfigPath]) {
-            // Already resolved
             continue;
         }
         if (!(0, node_fs_1.existsSync)(refConfigPath)) {
-            // the referenced tsconfig doesn't exist, ignore it
-            continue;
-        }
-        if (isExternalProjectReference(refConfigPath, workspaceRoot, projectRoot)) {
             continue;
         }
         if (!refConfigPath.endsWith('.json')) {
             refConfigPath = (0, node_path_1.join)(refConfigPath, 'tsconfig.json');
         }
+        const refContext = getConfigContext(refConfigPath, workspaceRoot);
+        if (isExternalProjectReference(refContext, project, workspaceRoot)) {
+            continue;
+        }
         projectReferences[refConfigPath] = retrieveTsConfigFromCache(refConfigPath, workspaceRoot);
-        resolveInternalProjectReferences(projectReferences[refConfigPath], workspaceRoot, projectRoot, projectReferences);
+        resolveInternalProjectReferences(projectReferences[refConfigPath], workspaceRoot, project, projectReferences);
     }
     return projectReferences;
 }
-function resolveShallowExternalProjectReferences(tsConfig, workspaceRoot, projectRoot, projectReferences = {}) {
+function resolveShallowExternalProjectReferences(tsConfig, workspaceRoot, project, projectReferences = {}) {
     if (!tsConfig.projectReferences?.length) {
         return projectReferences;
     }
     for (const ref of tsConfig.projectReferences) {
         let refConfigPath = ref.path;
         if (projectReferences[refConfigPath]) {
-            // Already resolved
             continue;
         }
         if (!(0, node_fs_1.existsSync)(refConfigPath)) {
-            // the referenced tsconfig doesn't exist, ignore it
             continue;
         }
-        if (isExternalProjectReference(refConfigPath, workspaceRoot, projectRoot)) {
-            if (!refConfigPath.endsWith('.json')) {
-                refConfigPath = (0, node_path_1.join)(refConfigPath, 'tsconfig.json');
-            }
+        if (!refConfigPath.endsWith('.json')) {
+            refConfigPath = (0, node_path_1.join)(refConfigPath, 'tsconfig.json');
+        }
+        const refContext = getConfigContext(refConfigPath, workspaceRoot);
+        if (isExternalProjectReference(refContext, project, workspaceRoot)) {
             projectReferences[refConfigPath] = retrieveTsConfigFromCache(refConfigPath, workspaceRoot);
         }
     }
     return projectReferences;
 }
-function hasExternalProjectReferences(tsConfigPath, tsConfig, workspaceRoot, projectRoot, seen = new Set()) {
+function hasExternalProjectReferences(tsConfigPath, tsConfig, workspaceRoot, project, seen = new Set()) {
     if (!tsConfig.projectReferences?.length) {
         return false;
     }
@@ -542,57 +607,46 @@ function hasExternalProjectReferences(tsConfigPath, tsConfig, workspaceRoot, pro
     for (const ref of tsConfig.projectReferences) {
         let refConfigPath = ref.path;
         if (seen.has(refConfigPath)) {
-            // Already seen
             continue;
         }
         if (!(0, node_fs_1.existsSync)(refConfigPath)) {
-            // the referenced tsconfig doesn't exist, ignore it
             continue;
         }
-        if (isExternalProjectReference(refConfigPath, workspaceRoot, projectRoot)) {
-            return true;
-        }
         if (!refConfigPath.endsWith('.json')) {
             refConfigPath = (0, node_path_1.join)(refConfigPath, 'tsconfig.json');
         }
+        const refContext = getConfigContext(refConfigPath, workspaceRoot);
+        if (isExternalProjectReference(refContext, project, workspaceRoot)) {
+            return true;
+        }
         const refTsConfig = retrieveTsConfigFromCache(refConfigPath, workspaceRoot);
-        const result = hasExternalProjectReferences(refConfigPath, refTsConfig, workspaceRoot, projectRoot, seen);
+        const result = hasExternalProjectReferences(refConfigPath, refTsConfig, workspaceRoot, project, seen);
         if (result) {
             return true;
         }
     }
     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;
+function isExternalProjectReference(refConfig, project, workspaceRoot) {
+    const owner = cache.configOwners.get(refConfig.relativePath);
+    if (owner !== undefined) {
+        return owner !== project.normalized;
+    }
+    let currentPath = refConfig.dirname;
+    if ((0, node_path_1.relative)(project.absolute, currentPath).startsWith('..')) {
         return true;
     }
-    while (currentPath !== absoluteProjectRoot) {
+    while (currentPath !== project.absolute) {
         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;
+            const owner = posixRelative(workspaceRoot, currentPath);
+            cache.configOwners.set(refConfig.relativePath, owner);
+            return owner !== project.normalized;
         }
         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) {
-    return (0, node_fs_1.statSync)(tsConfigPath).isFile()
-        ? (0, node_path_1.dirname)(tsConfigPath)
-        : (0, node_path_1.normalize)(tsConfigPath);
-}
 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
@@ -647,10 +701,19 @@ function readTsConfigAndCache(tsConfigPath, workspaceRoot) {
     return tsConfigCacheData[relativePath].data;
 }
 function getExtendedFilesHash(extendedConfigFiles, workspaceRoot) {
-    const hashes = [];
     if (!extendedConfigFiles.length) {
         return '';
     }
+    // Create a stable cache key from sorted file paths
+    const cacheKey = extendedConfigFiles
+        .map((f) => f.filePath || f.externalPackage)
+        .filter(Boolean)
+        .sort()
+        .join('|');
+    if (cache.extendedFilesHashes.has(cacheKey)) {
+        return cache.extendedFilesHashes.get(cacheKey);
+    }
+    const hashes = [];
     for (const extendedConfigFile of extendedConfigFiles) {
         if (extendedConfigFile.externalPackage) {
             hashes.push(extendedConfigFile.externalPackage);
@@ -661,7 +724,9 @@ function getExtendedFilesHash(extendedConfigFiles, workspaceRoot) {
                 .extendedConfigFiles, workspaceRoot));
         }
     }
-    return hashes.join('|');
+    const hash = hashes.join('|');
+    cache.extendedFilesHashes.set(cacheKey, hash);
+    return hash;
 }
 function readTsConfig(tsConfigPath, workspaceRoot) {
     if (!ts) {