@nx/js 22.6.0-beta.1 → 22.6.0-beta.11

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nx/js",
-  "version": "22.6.0-beta.1",
+  "version": "22.6.0-beta.11",
   "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.6.0-beta.1",
-    "@nx/workspace": "22.6.0-beta.1",
+    "@nx/devkit": "22.6.0-beta.11",
+    "@nx/workspace": "22.6.0-beta.11",
     "@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.6.0-beta.1"
+    "nx": "22.6.0-beta.11"
   },
   "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

@@ -3,6 +3,7 @@ export interface TscPluginOptions {
     compiler?: 'tsc' | 'tsgo';
     typecheck?: boolean | {
         targetName?: string;
+        configName?: string;
     };
     build?: boolean | {
         targetName?: string;

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;AA+BpB,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,CAAC,EAAE,KAAK,GAAG,MAAM,CAAC;IAC1B,SAAS,CAAC,EACN,OAAO,GACP;QACE,UAAU,CAAC,EAAE,MAAM,CAAC;QACpB,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;AA2KD;;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

@@ -5,7 +5,6 @@ const devkit_1 = require("@nx/devkit");
 const get_named_inputs_1 = require("@nx/devkit/src/utils/get-named-inputs");
 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
@@ -16,8 +15,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'
@@ -64,14 +66,14 @@ function createConfigContext(configFilePath, workspaceRoot, projectContext) {
     return {
         originalPath: configFilePath,
         absolutePath,
-        relativePath: posix.relative(workspaceRoot, absolutePath),
+        relativePath: posixRelative(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) {
+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);
@@ -84,7 +86,7 @@ function getConfigContext(configPath, workspaceRoot) {
     if (!cache.projectContexts.has(projectRoot)) {
         cache.projectContexts.set(projectRoot, {
             root: projectRoot,
-            normalized: posix.normalize(projectRoot),
+            normalized: (0, devkit_1.normalizePath)(projectRoot),
             absolute: (0, node_path_1.join)(workspaceRoot, projectRoot),
         });
     }
@@ -107,7 +109,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 +119,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 +145,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 +164,20 @@ 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 isTypecheckConfig = configContext.basename ===
+            (options.typecheck ? options.typecheck.configName : '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 &&
+    if (options.typecheck &&
+        config.basename === options.typecheck.configName &&
         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,10 +456,12 @@ 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)) {
-        // Importing modules from a referenced project will load its output declaration files (d.ts)
+    if (hasExternalProjectReferences(config.originalPath, tsConfig, workspaceRoot, config.project, cache)) {
+        // tsc --build reads .d.ts and .tsbuildinfo files from referenced projects
         // https://www.typescriptlang.org/docs/handbook/project-references.html#what-is-a-project-reference
-        inputs.push({ dependentTasksOutputFiles: '**/*.d.ts' });
+        inputs.push({
+            dependentTasksOutputFiles: '**/*.{d.ts,tsbuildinfo}',
+        });
     }
     else {
         inputs.push('production' in namedInputs ? '^production' : '^default');
@@ -456,17 +469,23 @@ function getInputs(namedInputs, config, tsConfig, internalProjectReferences, wor
     // inputs.push({ externalDependencies });
     return inputs;
 }
-function getOutputs(config, tsConfig, internalProjectReferences, workspaceRoot, emitDeclarationOnly) {
+function getOutputs(config, rootTsConfig, 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((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));
+    [
+        { configBaseNameNoExt: config.basenameNoExt, tsConfig: rootTsConfig },
+        ...Object.entries(internalProjectReferences).map(([internalConfigPath, internalConfig]) => ({
+            configBaseNameNoExt: (0, node_path_1.basename)(internalConfigPath, '.json'),
+            tsConfig: internalConfig,
+        })),
+    ].forEach(({ configBaseNameNoExt, 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, config.project));
@@ -477,38 +496,36 @@ function getOutputs(config, tsConfig, internalProjectReferences, workspaceRoot,
                 ? pathToInputOrOutput(tsConfig.options.tsBuildInfoFile, workspaceRoot, config.project)
                 : pathToInputOrOutput((0, devkit_1.joinPathFragments)(outDir, `${outFileName}.tsbuildinfo`), workspaceRoot, config.project));
         }
-        else if (tsconfig.options.outDir) {
+        else if (tsConfig.options.outDir) {
             if (emitDeclarationOnly) {
-                outputs.add(pathToInputOrOutput((0, devkit_1.joinPathFragments)(tsconfig.options.outDir, '**/*.d.ts'), workspaceRoot, config.project));
+                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)(tsconfig.options.outDir, '**/*.d.ts.map'), workspaceRoot, config.project));
+                    outputs.add(pathToInputOrOutput((0, devkit_1.joinPathFragments)(tsConfig.options.outDir, '**/*.d.ts.map'), workspaceRoot, config.project));
                 }
             }
             else {
-                outputs.add(pathToInputOrOutput(tsconfig.options.outDir, workspaceRoot, config.project));
+                outputs.add(pathToInputOrOutput(tsConfig.options.outDir, workspaceRoot, config.project));
             }
-            if (tsconfig.options.tsBuildInfoFile) {
+            if (tsConfig.options.tsBuildInfoFile) {
                 if (emitDeclarationOnly ||
-                    !(0, node_path_1.normalize)(tsconfig.options.tsBuildInfoFile).startsWith(`${(0, node_path_1.normalize)(tsconfig.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(tsconfig.options.tsBuildInfoFile, workspaceRoot, config.project));
+                    outputs.add(pathToInputOrOutput(tsConfig.options.tsBuildInfoFile, workspaceRoot, config.project));
                 }
             }
-            else if (tsconfig.options.rootDir &&
-                tsconfig.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)(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));
+                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 = config.basenameNoExt;
-                outputs.add(pathToInputOrOutput((0, devkit_1.joinPathFragments)(tsconfig.options.outDir, `${name}.tsbuildinfo`), workspaceRoot, config.project));
+                outputs.add(pathToInputOrOutput((0, devkit_1.joinPathFragments)(tsConfig.options.outDir, `${configBaseNameNoExt}.tsbuildinfo`), workspaceRoot, config.project));
             }
         }
-        else if (tsconfig.raw?.include?.length ||
-            tsconfig.raw?.files?.length ||
-            (!tsconfig.raw?.include && !tsconfig.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'));
@@ -523,10 +540,9 @@ function getOutputs(config, tsConfig, internalProjectReferences, workspaceRoot,
             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 = config.basenameNoExt;
             outputs.add(tsConfig.options.tsBuildInfoFile
                 ? pathToInputOrOutput(tsConfig.options.tsBuildInfoFile, workspaceRoot, config.project)
-                : (0, devkit_1.joinPathFragments)('{projectRoot}', `${name}.tsbuildinfo`));
+                : (0, devkit_1.joinPathFragments)('{projectRoot}', `${configBaseNameNoExt}.tsbuildinfo`));
         }
     });
     return Array.from(outputs);
@@ -540,14 +556,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 +571,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 +586,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 +610,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 +633,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 +665,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 +708,7 @@ function readTsConfigAndCache(tsConfigPath, workspaceRoot) {
             }
         }
     }
-    extendedFilesHash ??= getExtendedFilesHash(extendedConfigFiles, workspaceRoot);
+    extendedFilesHash ??= getExtendedFilesHash(extendedConfigFiles, workspaceRoot, cache);
     tsConfigCacheData[relativePath] = {
         data: {
             options: tsConfig.options,
@@ -702,7 +721,7 @@ function readTsConfigAndCache(tsConfigPath, workspaceRoot) {
     };
     return tsConfigCacheData[relativePath].data;
 }
-function getExtendedFilesHash(extendedConfigFiles, workspaceRoot) {
+function getExtendedFilesHash(extendedConfigFiles, workspaceRoot, cache) {
     if (!extendedConfigFiles.length) {
         return '';
     }
@@ -721,22 +740,26 @@ 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');
     }
+    // Normalize to forward slashes for TypeScript compatibility on Windows.
+    // TypeScript's parser normalizes paths inconsistently — diagnostics use
+    // normalized paths but the source file retains the original, causing
+    // assertion failures when backslashes are present.
+    tsConfigPath = tsConfigPath.replaceAll('\\', '/');
     const tsSys = {
         ...ts.sys,
-        readFile: (path) => readFile(path, workspaceRoot),
+        readFile: (path) => readFile(path, workspaceRoot, cache),
         readDirectory: () => [],
     };
     const readResult = ts.readConfigFile(tsConfigPath, tsSys.readFile);
@@ -748,7 +771,9 @@ function normalizePluginOptions(pluginOptions = {}) {
     const defaultCompiler = 'tsc';
     const compiler = pluginOptions.compiler ?? defaultCompiler;
     const defaultTypecheckTargetName = 'typecheck';
+    const defaultTypecheckConfigName = 'tsconfig.json';
     let typecheck = {
+        configName: defaultTypecheckConfigName,
         targetName: defaultTypecheckTargetName,
     };
     if (pluginOptions.typecheck === false) {
@@ -757,6 +782,7 @@ function normalizePluginOptions(pluginOptions = {}) {
     else if (pluginOptions.typecheck &&
         typeof pluginOptions.typecheck !== 'boolean') {
         typecheck = {
+            configName: pluginOptions.typecheck.configName ?? defaultTypecheckConfigName,
             targetName: pluginOptions.typecheck.targetName ?? defaultTypecheckTargetName,
         };
     }
@@ -808,15 +834,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');
@@ -902,5 +928,5 @@ function toRelativePaths(cache, workspaceRoot) {
     return updatedCache;
 }
 function posixRelative(workspaceRoot, path) {
-    return posix.normalize((0, node_path_1.relative)(workspaceRoot, path));
+    return (0, devkit_1.normalizePath)((0, node_path_1.relative)(workspaceRoot, path));
 }

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,