@nx/js 22.5.2 → 22.5.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nx/js",
-  "version": "22.5.2",
+  "version": "22.5.3",
   "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.5.2",
-    "@nx/workspace": "22.5.2",
+    "@nx/devkit": "22.5.3",
+    "@nx/workspace": "22.5.3",
     "@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.5.2"
+    "nx": "22.5.3"
   },
   "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,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,8BAgL/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,8BAqK/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

@@ -99,7 +99,6 @@ async function libraryGeneratorInternal(tree, schema) {
     else if (options.unitTestRunner === 'vitest' &&
         options.bundler !== 'vite' // Test would have been set up already
     ) {
-        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');
@@ -114,12 +113,6 @@ async function libraryGeneratorInternal(tree, schema) {
             addPlugin: options.addPlugin,
         });
         tasks.push(vitestTask);
-        createOrEditViteConfig(tree, {
-            project: options.name,
-            includeLib: false,
-            includeVitest: true,
-            testEnvironment: options.testEnvironment,
-        }, true);
     }
     if (!schema.skipTsConfig && !options.isUsingTsSolutionConfig) {
         (0, ts_config_1.addTsConfigPath)(tree, options.importPath, [

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,EAQL,KAAK,kBAAkB,EAEvB,KAAK,aAAa,EAInB,MAAM,YAAY,CAAC;AAgCpB,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,CAAC,EAAE,KAAK,GAAG,MAAM,CAAC;IAC1B,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;AAmKD;;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"}
+{"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,QAAQ,CAAC,EAAE,KAAK,GAAG,MAAM,CAAC;IAC1B,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;AA0KD;;GAEG;AACH,eAAO,MAAM,kBAAkB,EAAE,kBAEhC,CAAC;AAEF,eAAO,MAAM,WAAW,sBAAsB,CAAC;AAI/C,eAAO,MAAM,aAAa,EAAE,aAAa,CAAC,gBAAgB,CA0FzD,CAAC;AAEF,eAAO,MAAM,WAAW,iCAAgB,CAAC"}

package/src/plugins/typescript/plugin.js

@@ -16,8 +16,11 @@ let ts;
 const pmc = (0, devkit_1.getPackageManagerCommand)();
 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;
+// Module-level cache store — each invocation gets a unique Symbol key
+const cacheStore = new Map();
+// Shared tsconfig cache — initialized once per batch, persisted to disk
+let tsConfigCacheData = {};
+let tsConfigCacheInitialized = false;
 function readFromCache(cachePath) {
     try {
         return process.env.NX_CACHE_PROJECT_GRAPH !== 'false'
@@ -71,7 +74,7 @@ function createConfigContext(configFilePath, workspaceRoot, projectContext) {
         project: projectContext,
     };
 }
-function getConfigContext(configPath, workspaceRoot) {
+function getConfigContext(configPath, workspaceRoot, cache) {
     const absolutePath = configPath.startsWith('/') || configPath.startsWith(workspaceRoot)
         ? (0, node_path_1.normalize)(configPath)
         : (0, node_path_1.join)(workspaceRoot, configPath);
@@ -107,7 +110,9 @@ 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 = {
+        // Each invocation gets a unique Symbol key — guaranteed no collisions
+        const cacheKey = Symbol('tsc-invocation');
+        cacheStore.set(cacheKey, {
             fileHashes: {},
             rawFiles: {},
             picomatchMatchers: {},
@@ -115,19 +120,20 @@ exports.createNodesV2 = [
             configOwners: new Map(),
             projectContexts: new Map(),
             configContexts: new Map(),
-        };
-        initializeTsConfigCache(configFilePaths, context.workspaceRoot);
+        });
+        const cache = cacheStore.get(cacheKey);
+        initializeTsConfigCache(configFilePaths, context.workspaceRoot, cache);
         const normalizedOptions = normalizePluginOptions(options);
-        const { configFilePaths: validConfigFilePaths, hashes, projectRoots, } = await resolveValidConfigFilesAndHashes(configFilePaths, normalizedOptions, optionsHash, context);
+        const { configFilePaths: validConfigFilePaths, hashes, projectRoots, } = await resolveValidConfigFilesAndHashes(configFilePaths, normalizedOptions, optionsHash, context, cache);
         try {
             return await (0, devkit_1.createNodesFromFiles)((configFilePath, options, context, idx) => {
                 const projectRoot = projectRoots[idx];
                 const hash = hashes[idx];
-                const cacheKey = `${hash}_${configFilePath}`;
+                const targetsCacheKey = `${hash}_${configFilePath}`;
                 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];
+                const configContext = getConfigContext(absolutePath, context.workspaceRoot, cache);
+                targetsCache[targetsCacheKey] ??= buildTscTargets(configContext, options, context, validConfigFilePaths, cache);
+                const { targets } = targetsCache[targetsCacheKey];
                 return {
                     projects: {
                         [projectRoot]: {
@@ -140,13 +146,18 @@ exports.createNodesV2 = [
         finally {
             writeToCache(targetsCachePath, targetsCache);
             writeTsConfigCache(toRelativePaths(tsConfigCacheData, context.workspaceRoot));
-            // Release memory after plugin invocation
-            cache = null;
+            // Delete this invocation's cache — unique Symbol means no cross-invocation impact
+            cacheStore.delete(cacheKey);
+            // Reset shared tsconfig cache when all invocations are done
+            if (cacheStore.size === 0) {
+                tsConfigCacheData = {};
+                tsConfigCacheInitialized = false;
+            }
         }
     },
 ];
 exports.createNodes = exports.createNodesV2;
-async function resolveValidConfigFilesAndHashes(configFilePaths, options, optionsHash, context) {
+async function resolveValidConfigFilesAndHashes(configFilePaths, options, optionsHash, context, cache) {
     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 = [];
@@ -154,19 +165,19 @@ async function resolveValidConfigFilesAndHashes(configFilePaths, options, option
     for await (const configFilePath of configFilePaths) {
         const projectRoot = (0, node_path_1.dirname)(configFilePath);
         const absolutePath = (0, node_path_1.join)(context.workspaceRoot, configFilePath);
-        const configContext = getConfigContext(absolutePath, context.workspaceRoot);
+        const configContext = getConfigContext(absolutePath, context.workspaceRoot, cache);
         // 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)) {
+        if (!checkIfConfigFileShouldBeProject(configContext, cache)) {
             continue;
         }
         projectRoots.push(projectRoot);
         validConfigFilePaths.push(configFilePath);
-        hashes.push(await getConfigFileHash(configFilePath, context.workspaceRoot, configContext.project, optionsHash, lockFileHash));
+        hashes.push(await getConfigFileHash(configFilePath, context.workspaceRoot, configContext.project, optionsHash, lockFileHash, cache));
     }
     return { configFilePaths: validConfigFilePaths, hashes, projectRoots };
 }
@@ -182,12 +193,12 @@ async function resolveValidConfigFilesAndHashes(configFilePaths, options, option
  * - hash of the plugin options
  * - current config file path
  */
-async function getConfigFileHash(configFilePath, workspaceRoot, project, optionsHash, lockFileHash) {
+async function getConfigFileHash(configFilePath, workspaceRoot, project, optionsHash, lockFileHash, cache) {
     const fullConfigPath = (0, node_path_1.join)(workspaceRoot, configFilePath);
-    const tsConfig = retrieveTsConfigFromCache(fullConfigPath, workspaceRoot);
-    const extendedConfigFiles = getExtendedConfigFiles(tsConfig, workspaceRoot);
-    const internalReferencedFiles = resolveInternalProjectReferences(tsConfig, workspaceRoot, project);
-    const externalProjectReferences = resolveShallowExternalProjectReferences(tsConfig, workspaceRoot, project);
+    const tsConfig = retrieveTsConfigFromCache(fullConfigPath, workspaceRoot, cache);
+    const extendedConfigFiles = getExtendedConfigFiles(tsConfig, workspaceRoot, cache);
+    const internalReferencedFiles = resolveInternalProjectReferences(tsConfig, workspaceRoot, project, cache);
+    const externalProjectReferences = resolveShallowExternalProjectReferences(tsConfig, workspaceRoot, project, cache);
     let packageJson = null;
     try {
         packageJson = (0, devkit_1.readJsonFile)((0, node_path_1.join)(workspaceRoot, project.root, 'package.json'));
@@ -199,14 +210,14 @@ async function getConfigFileHash(configFilePath, workspaceRoot, project, options
             ...extendedConfigFiles.files.sort(),
             ...Object.keys(internalReferencedFiles).sort(),
             ...Object.keys(externalProjectReferences).sort(),
-        ].map((file) => getFileHash(file, workspaceRoot)),
+        ].map((file) => getFileHash(file, workspaceRoot, cache)),
         ...extendedConfigFiles.packages.sort(),
         lockFileHash,
         optionsHash,
         ...(packageJson ? [(0, file_hasher_1.hashObject)(packageJson)] : []),
     ]);
 }
-function checkIfConfigFileShouldBeProject(config) {
+function checkIfConfigFileShouldBeProject(config, cache) {
     // Do not create a project for the workspace root tsconfig files.
     if (config.project.root === '.') {
         return false;
@@ -233,16 +244,16 @@ function checkIfConfigFileShouldBeProject(config) {
     }
     return true;
 }
-function buildTscTargets(config, options, context, configFiles) {
+function buildTscTargets(config, options, context, configFiles, cache) {
     const targets = {};
     const namedInputs = (0, get_named_inputs_1.getNamedInputs)(config.project.root, context);
-    const tsConfig = retrieveTsConfigFromCache(config.absolutePath, context.workspaceRoot);
+    const tsConfig = retrieveTsConfigFromCache(config.absolutePath, context.workspaceRoot, cache);
     let internalProjectReferences;
     if (config.basename === 'tsconfig.json' &&
         options.typecheck &&
         tsConfig.raw?.['nx']?.addTypecheckTarget !== false) {
-        internalProjectReferences = resolveInternalProjectReferences(tsConfig, context.workspaceRoot, config.project);
-        const externalProjectReferences = resolveShallowExternalProjectReferences(tsConfig, context.workspaceRoot, config.project);
+        internalProjectReferences = resolveInternalProjectReferences(tsConfig, context.workspaceRoot, config.project, cache);
+        const externalProjectReferences = resolveShallowExternalProjectReferences(tsConfig, context.workspaceRoot, config.project, cache);
         const targetName = options.typecheck.targetName;
         const compiler = options.compiler;
         if (!targets[targetName]) {
@@ -263,7 +274,7 @@ function buildTscTargets(config, options, context, configFiles) {
                 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, config.project.root))) {
+                        (0, util_1.isValidPackageJsonBuildConfig)(retrieveTsConfigFromCache(buildConfigPath, context.workspaceRoot, cache), context.workspaceRoot, config.project.root))) {
                     dependsOn.unshift(options.build.targetName);
                 }
             }
@@ -272,7 +283,7 @@ function buildTscTargets(config, options, context, configFiles) {
                 command,
                 options: { cwd: config.project.root },
                 cache: true,
-                inputs: getInputs(namedInputs, config, tsConfig, internalProjectReferences, context.workspaceRoot),
+                inputs: getInputs(namedInputs, config, tsConfig, internalProjectReferences, context.workspaceRoot, cache),
                 outputs: getOutputs(config, tsConfig, internalProjectReferences, context.workspaceRoot, 
                 /* emitDeclarationOnly */ true),
                 syncGenerators: ['@nx/js:typescript-sync'],
@@ -294,7 +305,7 @@ function buildTscTargets(config, options, context, configFiles) {
         config.basename === options.build.configName &&
         (options.build.skipBuildCheck ||
             (0, util_1.isValidPackageJsonBuildConfig)(tsConfig, context.workspaceRoot, config.project.root))) {
-        internalProjectReferences ??= resolveInternalProjectReferences(tsConfig, context.workspaceRoot, config.project);
+        internalProjectReferences ??= resolveInternalProjectReferences(tsConfig, context.workspaceRoot, config.project, cache);
         const targetName = options.build.targetName;
         const compiler = options.compiler;
         targets[targetName] = {
@@ -302,7 +313,7 @@ function buildTscTargets(config, options, context, configFiles) {
             command: `${compiler} --build ${options.build.configName}${options.verboseOutput ? ' --verbose' : ''}`,
             options: { cwd: config.project.root },
             cache: true,
-            inputs: getInputs(namedInputs, config, tsConfig, internalProjectReferences, context.workspaceRoot),
+            inputs: getInputs(namedInputs, config, tsConfig, internalProjectReferences, context.workspaceRoot, cache),
             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),
@@ -325,12 +336,12 @@ function buildTscTargets(config, options, context, configFiles) {
     }
     return { targets };
 }
-function getInputs(namedInputs, config, tsConfig, internalProjectReferences, workspaceRoot) {
+function getInputs(namedInputs, config, tsConfig, internalProjectReferences, workspaceRoot, cache) {
     const configFiles = new Set();
     // TODO(leo): temporary disable external dependencies until we support hashing
     // glob patterns from external dependencies
     // const externalDependencies = ['typescript'];
-    const extendedConfigFiles = getExtendedConfigFiles(tsConfig, workspaceRoot);
+    const extendedConfigFiles = getExtendedConfigFiles(tsConfig, workspaceRoot, cache);
     extendedConfigFiles.files.forEach((configPath) => {
         configFiles.add(configPath);
     });
@@ -445,7 +456,7 @@ function getInputs(namedInputs, config, tsConfig, internalProjectReferences, wor
     if (excludePaths.size) {
         inputs.push(...Array.from(excludePaths).map((p) => `!${pathToInputOrOutput((0, devkit_1.joinPathFragments)(config.project.root, p), workspaceRoot, config.project)}`));
     }
-    if (hasExternalProjectReferences(config.originalPath, tsConfig, workspaceRoot, config.project)) {
+    if (hasExternalProjectReferences(config.originalPath, tsConfig, workspaceRoot, config.project, cache)) {
         // 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' });
@@ -540,14 +551,14 @@ function pathToInputOrOutput(path, workspaceRoot, project) {
     }
     return (0, devkit_1.joinPathFragments)('{projectRoot}', pathRelativeToProjectRoot);
 }
-function getExtendedConfigFiles(tsConfig, workspaceRoot, extendedConfigFiles = new Set(), extendedExternalPackages = new Set()) {
+function getExtendedConfigFiles(tsConfig, workspaceRoot, cache, 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);
+            getExtendedConfigFiles(retrieveTsConfigFromCache(extendedConfigFile.filePath, workspaceRoot, cache), workspaceRoot, cache, extendedConfigFiles, extendedExternalPackages);
         }
     }
     return {
@@ -555,7 +566,7 @@ function getExtendedConfigFiles(tsConfig, workspaceRoot, extendedConfigFiles = n
         packages: Array.from(extendedExternalPackages),
     };
 }
-function resolveInternalProjectReferences(tsConfig, workspaceRoot, project, projectReferences = {}) {
+function resolveInternalProjectReferences(tsConfig, workspaceRoot, project, cache, projectReferences = {}) {
     if (!tsConfig.projectReferences?.length) {
         return {};
     }
@@ -570,16 +581,16 @@ function resolveInternalProjectReferences(tsConfig, workspaceRoot, project, proj
         if (!refConfigPath.endsWith('.json')) {
             refConfigPath = (0, node_path_1.join)(refConfigPath, 'tsconfig.json');
         }
-        const refContext = getConfigContext(refConfigPath, workspaceRoot);
-        if (isExternalProjectReference(refContext, project, workspaceRoot)) {
+        const refContext = getConfigContext(refConfigPath, workspaceRoot, cache);
+        if (isExternalProjectReference(refContext, project, workspaceRoot, cache)) {
             continue;
         }
-        projectReferences[refConfigPath] = retrieveTsConfigFromCache(refConfigPath, workspaceRoot);
-        resolveInternalProjectReferences(projectReferences[refConfigPath], workspaceRoot, project, projectReferences);
+        projectReferences[refConfigPath] = retrieveTsConfigFromCache(refConfigPath, workspaceRoot, cache);
+        resolveInternalProjectReferences(projectReferences[refConfigPath], workspaceRoot, project, cache, projectReferences);
     }
     return projectReferences;
 }
-function resolveShallowExternalProjectReferences(tsConfig, workspaceRoot, project, projectReferences = {}) {
+function resolveShallowExternalProjectReferences(tsConfig, workspaceRoot, project, cache, projectReferences = {}) {
     if (!tsConfig.projectReferences?.length) {
         return projectReferences;
     }
@@ -594,14 +605,14 @@ function resolveShallowExternalProjectReferences(tsConfig, workspaceRoot, projec
         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);
+        const refContext = getConfigContext(refConfigPath, workspaceRoot, cache);
+        if (isExternalProjectReference(refContext, project, workspaceRoot, cache)) {
+            projectReferences[refConfigPath] = retrieveTsConfigFromCache(refConfigPath, workspaceRoot, cache);
         }
     }
     return projectReferences;
 }
-function hasExternalProjectReferences(tsConfigPath, tsConfig, workspaceRoot, project, seen = new Set()) {
+function hasExternalProjectReferences(tsConfigPath, tsConfig, workspaceRoot, project, cache, seen = new Set()) {
     if (!tsConfig.projectReferences?.length) {
         return false;
     }
@@ -617,19 +628,19 @@ function hasExternalProjectReferences(tsConfigPath, tsConfig, workspaceRoot, pro
         if (!refConfigPath.endsWith('.json')) {
             refConfigPath = (0, node_path_1.join)(refConfigPath, 'tsconfig.json');
         }
-        const refContext = getConfigContext(refConfigPath, workspaceRoot);
-        if (isExternalProjectReference(refContext, project, workspaceRoot)) {
+        const refContext = getConfigContext(refConfigPath, workspaceRoot, cache);
+        if (isExternalProjectReference(refContext, project, workspaceRoot, cache)) {
             return true;
         }
-        const refTsConfig = retrieveTsConfigFromCache(refConfigPath, workspaceRoot);
-        const result = hasExternalProjectReferences(refConfigPath, refTsConfig, workspaceRoot, project, seen);
+        const refTsConfig = retrieveTsConfigFromCache(refConfigPath, workspaceRoot, cache);
+        const result = hasExternalProjectReferences(refConfigPath, refTsConfig, workspaceRoot, project, cache, seen);
         if (result) {
             return true;
         }
     }
     return false;
 }
-function isExternalProjectReference(refConfig, project, workspaceRoot) {
+function isExternalProjectReference(refConfig, project, workspaceRoot, cache) {
     const owner = cache.configOwners.get(refConfig.relativePath);
     if (owner !== undefined) {
         return owner !== project.normalized;
@@ -649,34 +660,37 @@ function isExternalProjectReference(refConfig, project, workspaceRoot) {
     }
     return false;
 }
-function retrieveTsConfigFromCache(tsConfigPath, workspaceRoot) {
+function retrieveTsConfigFromCache(tsConfigPath, workspaceRoot, cache) {
     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);
+        : readTsConfigAndCache(tsConfigPath, workspaceRoot, cache);
 }
-function initializeTsConfigCache(configFilePaths, workspaceRoot) {
-    tsConfigCacheData = toAbsolutePaths(readTsConfigCacheData(), workspaceRoot);
+function initializeTsConfigCache(configFilePaths, workspaceRoot, cache) {
+    if (!tsConfigCacheInitialized) {
+        tsConfigCacheData = toAbsolutePaths(readTsConfigCacheData(), workspaceRoot);
+        tsConfigCacheInitialized = true;
+    }
     // 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);
+        readTsConfigAndCache(fullConfigPath, workspaceRoot, cache);
     }
 }
-function readTsConfigAndCache(tsConfigPath, workspaceRoot) {
+function readTsConfigAndCache(tsConfigPath, workspaceRoot, cache) {
     const relativePath = posixRelative(workspaceRoot, tsConfigPath);
-    const hash = getFileHash(tsConfigPath, workspaceRoot);
+    const hash = getFileHash(tsConfigPath, workspaceRoot, cache);
     let extendedFilesHash;
     if (tsConfigCacheData[relativePath] &&
         tsConfigCacheData[relativePath].hash === hash) {
-        extendedFilesHash = getExtendedFilesHash(tsConfigCacheData[relativePath].data.extendedConfigFiles, workspaceRoot);
+        extendedFilesHash = getExtendedFilesHash(tsConfigCacheData[relativePath].data.extendedConfigFiles, workspaceRoot, cache);
         if (tsConfigCacheData[relativePath].extendedFilesHash === extendedFilesHash) {
             return tsConfigCacheData[relativePath].data;
         }
     }
-    const tsConfig = readTsConfig(tsConfigPath, workspaceRoot);
+    const tsConfig = readTsConfig(tsConfigPath, workspaceRoot, cache);
     const extendedConfigFiles = [];
     if (tsConfig.raw?.extends) {
         const extendsArray = typeof tsConfig.raw.extends === 'string'
@@ -689,7 +703,7 @@ function readTsConfigAndCache(tsConfigPath, workspaceRoot) {
             }
         }
     }
-    extendedFilesHash ??= getExtendedFilesHash(extendedConfigFiles, workspaceRoot);
+    extendedFilesHash ??= getExtendedFilesHash(extendedConfigFiles, workspaceRoot, cache);
     tsConfigCacheData[relativePath] = {
         data: {
             options: tsConfig.options,
@@ -702,7 +716,7 @@ function readTsConfigAndCache(tsConfigPath, workspaceRoot) {
     };
     return tsConfigCacheData[relativePath].data;
 }
-function getExtendedFilesHash(extendedConfigFiles, workspaceRoot) {
+function getExtendedFilesHash(extendedConfigFiles, workspaceRoot, cache) {
     if (!extendedConfigFiles.length) {
         return '';
     }
@@ -721,22 +735,21 @@ function getExtendedFilesHash(extendedConfigFiles, workspaceRoot) {
             hashes.push(extendedConfigFile.externalPackage);
         }
         else if (extendedConfigFile.filePath) {
-            hashes.push(getFileHash(extendedConfigFile.filePath, workspaceRoot));
-            hashes.push(getExtendedFilesHash(readTsConfigAndCache(extendedConfigFile.filePath, workspaceRoot)
-                .extendedConfigFiles, workspaceRoot));
+            hashes.push(getFileHash(extendedConfigFile.filePath, workspaceRoot, cache));
+            hashes.push(getExtendedFilesHash(readTsConfigAndCache(extendedConfigFile.filePath, workspaceRoot, cache).extendedConfigFiles, workspaceRoot, cache));
         }
     }
     const hash = hashes.join('|');
     cache.extendedFilesHashes.set(cacheKey, hash);
     return hash;
 }
-function readTsConfig(tsConfigPath, workspaceRoot) {
+function readTsConfig(tsConfigPath, workspaceRoot, cache) {
     if (!ts) {
         ts = require('typescript');
     }
     const tsSys = {
         ...ts.sys,
-        readFile: (path) => readFile(path, workspaceRoot),
+        readFile: (path) => readFile(path, workspaceRoot, cache),
         readDirectory: () => [],
     };
     const readResult = ts.readConfigFile(tsConfigPath, tsSys.readFile);
@@ -808,15 +821,15 @@ function resolveExtendedTsConfigPath(tsConfigPath, directory) {
         return null;
     }
 }
-function getFileHash(filePath, workspaceRoot) {
+function getFileHash(filePath, workspaceRoot, cache) {
     const relativePath = posixRelative(workspaceRoot, filePath);
     if (!cache.fileHashes[relativePath]) {
-        const content = readFile(filePath, workspaceRoot);
+        const content = readFile(filePath, workspaceRoot, cache);
         cache.fileHashes[relativePath] = (0, file_hasher_1.hashArray)([content]);
     }
     return cache.fileHashes[relativePath];
 }
-function readFile(filePath, workspaceRoot) {
+function readFile(filePath, workspaceRoot, cache) {
     const relativePath = posixRelative(workspaceRoot, filePath);
     if (!cache.rawFiles[relativePath]) {
         const content = (0, node_fs_1.readFileSync)(filePath, 'utf8');

package/src/utils/typescript/run-type-check.js

@@ -72,7 +72,7 @@ async function setupTypeScript(options) {
                 ? options.outDir.replace(projectRoot, '')
                 : undefined,
         }
-        : { noEmit: true };
+        : { noEmit: true, composite: false };
     const compilerOptions = {
         ...config.options,
         skipLibCheck: true,