@nx/js 0.0.0-pr-29464-73fdcbb → 0.0.0-pr-30565-cfe2164

package/migrations.json

@@ -146,15 +146,6 @@
           "alwaysAddToPackageJson": false
         }
       }
-    },
-    "20.7.1-beta.0": {
-      "version": "20.7.1-beta.0",
-      "packages": {
-        "@swc/cli": {
-          "version": "~0.6.0",
-          "alwaysAddToPackageJson": false
-        }
-      }
     }
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nx/js",
-  "version": "0.0.0-pr-29464-73fdcbb",
+  "version": "0.0.0-pr-30565-cfe2164",
   "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": "0.0.0-pr-29464-73fdcbb",
-    "@nx/workspace": "0.0.0-pr-29464-73fdcbb",
+    "@nx/devkit": "0.0.0-pr-30565-cfe2164",
+    "@nx/workspace": "0.0.0-pr-30565-cfe2164",
     "@zkochan/js-yaml": "0.0.7",
     "babel-plugin-const-enum": "^1.0.1",
     "babel-plugin-macros": "^3.1.0",
@@ -60,6 +60,8 @@
     "semver": "^7.5.3",
     "source-map-support": "0.5.19",
     "tinyglobby": "^0.2.12",
+    "ts-node": "10.9.1",
+    "tsconfig-paths": "^4.1.2",
     "tslib": "^2.3.0"
   },
   "peerDependencies": {

package/src/generators/init/files/ts-solution/tsconfig.base.json__tmpl__

@@ -17,7 +17,6 @@
     "noUnusedLocals": true,
     "skipLibCheck": true,
     "strict": true,
-    "target": "es2022",
-    "customConditions": ["development"]
+    "target": "es2022"
   }
 }

package/src/generators/library/library.js

@@ -425,8 +425,6 @@ function createFiles(tree, options) {
             };
             if (options.isUsingTsSolutionConfig &&
                 !['none', 'rollup', 'vite'].includes(options.bundler)) {
-                // the file must exist in the TS solution setup
-                const tsconfigBase = (0, devkit_1.readJson)(tree, 'tsconfig.base.json');
                 return (0, update_package_json_1.getUpdatedPackageJsonContent)(updatedPackageJson, {
                     main: (0, path_1.join)(options.projectRoot, 'src/index.ts'),
                     outputPath: (0, devkit_1.joinPathFragments)(options.projectRoot, 'dist'),
@@ -435,7 +433,6 @@ function createFiles(tree, options) {
                     generateExportsField: true,
                     packageJsonPath,
                     format: ['esm'],
-                    skipDevelopmentExports: !tsconfigBase.compilerOptions?.customConditions?.includes('development'),
                 });
             }
             return updatedPackageJson;
@@ -458,7 +455,6 @@ function createFiles(tree, options) {
         }
         if (options.isUsingTsSolutionConfig &&
             !['none', 'rollup', 'vite'].includes(options.bundler)) {
-            const tsconfigBase = (0, devkit_1.readJson)(tree, 'tsconfig.base.json');
             packageJson = (0, update_package_json_1.getUpdatedPackageJsonContent)(packageJson, {
                 main: (0, path_1.join)(options.projectRoot, 'src/index.ts'),
                 outputPath: (0, devkit_1.joinPathFragments)(options.projectRoot, 'dist'),
@@ -467,7 +463,6 @@ function createFiles(tree, options) {
                 generateExportsField: true,
                 packageJsonPath,
                 format: ['esm'],
-                skipDevelopmentExports: !tsconfigBase.compilerOptions?.customConditions?.includes('development'),
             });
         }
         if (!options.useProjectJson && options.name !== options.importPath) {
@@ -737,6 +732,12 @@ function createProjectTsConfigs(tree, options) {
                 json.references.push({
                     path: './tsconfig.lib.json',
                 });
+                // If using `tsc` to build, then we do not want a typecheck target that duplicates the work, since both run `tsc`.
+                // This applies to `@nx/js/typescript` plugin only.
+                if (options.bundler === 'tsc') {
+                    json['nx'] ??= {};
+                    json['nx'].addTypecheckTarget = false;
+                }
                 return json;
             });
         }
@@ -748,6 +749,12 @@ function createProjectTsConfigs(tree, options) {
                 include: [],
                 references: [{ path: './tsconfig.lib.json' }],
             };
+            // If using `tsc` to build, then we do not want a typecheck target that duplicates the work, since both run `tsc`.
+            // This applies to `@nx/js/typescript` plugin only.
+            if (options.bundler === 'tsc') {
+                tsconfig['nx'] ??= {};
+                tsconfig['nx'].addTypecheckTarget = false;
+            }
             (0, devkit_1.writeJson)(tree, (0, devkit_1.joinPathFragments)(options.projectRoot, 'tsconfig.json'), tsconfig);
             // update root project tsconfig.json references with the new lib tsconfig
             (0, devkit_1.updateJson)(tree, 'tsconfig.json', (json) => {

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

@@ -232,9 +232,6 @@ function updatePackageJson(tree, projectName, projectRoot, main, outputPath, roo
             version: '0.0.1',
         };
     }
-    // the file must exist in the TS solution setup, which is the only case this
-    // function is called
-    const tsconfigBase = (0, devkit_1.readJson)(tree, 'tsconfig.base.json');
     packageJson = (0, update_package_json_1.getUpdatedPackageJsonContent)(packageJson, {
         main,
         outputPath,
@@ -243,7 +240,6 @@ function updatePackageJson(tree, projectName, projectRoot, main, outputPath, roo
         packageJsonPath,
         rootDir,
         format,
-        skipDevelopmentExports: !tsconfigBase.compilerOptions?.customConditions?.includes('development'),
     });
     (0, devkit_1.writeJson)(tree, packageJsonPath, packageJson);
 }

package/src/plugins/jest/start-local-registry.js

@@ -29,21 +29,17 @@ function startLocalRegistry({ localRegistryTarget, storage, verbose, clearStorag
                 const port = parseInt(data.toString().match(new RegExp(`${listenAddress}:(?<port>\\d+)`))
                     ?.groups?.port);
                 const registry = `http://${listenAddress}:${port}`;
-                const authToken = 'secretVerdaccioToken';
                 console.log(`Local registry started on ${registry}`);
                 process.env.npm_config_registry = registry;
-                (0, child_process_1.execSync)(`npm config set //${listenAddress}:${port}/:_authToken "${authToken}" --ws=false`, {
+                (0, child_process_1.execSync)(`npm config set //${listenAddress}:${port}/:_authToken "secretVerdaccioToken" --ws=false`, {
                     windowsHide: false,
                 });
-                // bun
-                process.env.BUN_CONFIG_REGISTRY = registry;
-                process.env.BUN_CONFIG_TOKEN = authToken;
                 // yarnv1
                 process.env.YARN_REGISTRY = registry;
                 // yarnv2
                 process.env.YARN_NPM_REGISTRY_SERVER = registry;
                 process.env.YARN_UNSAFE_HTTP_WHITELIST = listenAddress;
-                console.log('Set npm, bun, and yarn config registry to ' + registry);
+                console.log('Set npm and yarn config registry to ' + registry);
                 resolve(() => {
                     childProcess.kill();
                     (0, child_process_1.execSync)(`npm config delete //${listenAddress}:${port}/:_authToken --ws=false`, {

package/src/plugins/typescript/plugin.js

@@ -3,16 +3,15 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.createNodes = exports.createNodesV2 = exports.PLUGIN_NAME = exports.createDependencies = void 0;
 const devkit_1 = require("@nx/devkit");
 const get_named_inputs_1 = require("@nx/devkit/src/utils/get-named-inputs");
+const picomatch = require("picomatch");
 const node_fs_1 = require("node:fs");
 const node_path_1 = require("node:path");
 const posix = require("node:path/posix");
 const file_hasher_1 = require("nx/src/hasher/file-hasher");
-const picomatch = require("picomatch");
 // eslint-disable-next-line @typescript-eslint/no-restricted-imports
 const lock_file_1 = require("nx/src/plugins/js/lock-file/lock-file");
 const cache_directory_1 = require("nx/src/utils/cache-directory");
 const util_1 = require("./util");
-let ts;
 const pmc = (0, devkit_1.getPackageManagerCommand)();
 let tsConfigCache;
 const tsConfigCachePath = (0, node_path_1.join)(cache_directory_1.workspaceDataDirectory, 'tsconfig-files.hash');
@@ -145,9 +144,6 @@ async function getConfigFileHash(configFilePath, workspaceRoot, projectRoot, opt
         lockFileHash,
         optionsHash,
         ...(packageJson ? [(0, file_hasher_1.hashObject)(packageJson)] : []),
-        // change this to bust the cache when making changes that would yield
-        // different results for the same hash
-        (0, file_hasher_1.hashObject)({ bust: 2 }),
     ]);
 }
 function checkIfConfigFileShouldBeProject(configFilePath, projectRoot, context) {
@@ -196,27 +192,13 @@ function buildTscTargets(configFilePath, projectRoot, options, context) {
                 // `tsc --build` does not work with `noEmit: true`
                 command = `echo "The 'typecheck' target is disabled because one or more project references set 'noEmit: true' in their tsconfig. Remove this property to resolve this issue."`;
             }
-            const dependsOn = [`^${targetName}`];
-            if (options.build && targets[options.build.targetName]) {
-                // we already processed and have a build target
-                dependsOn.unshift(options.build.targetName);
-            }
-            else if (options.build) {
-                // check if the project will have a build target
-                const buildConfigPath = (0, devkit_1.joinPathFragments)(projectRoot, options.build.configName);
-                if (context.configFiles.some((f) => f === buildConfigPath) &&
-                    (0, util_1.isValidPackageJsonBuildConfig)(retrieveTsConfigFromCache(buildConfigPath, context.workspaceRoot), context.workspaceRoot, projectRoot)) {
-                    dependsOn.unshift(options.build.targetName);
-                }
-            }
             targets[targetName] = {
-                dependsOn,
+                dependsOn: [`^${targetName}`],
                 command,
                 options: { cwd: projectRoot },
                 cache: true,
                 inputs: getInputs(namedInputs, configFilePath, tsConfig, internalProjectReferences, context.workspaceRoot, projectRoot),
-                outputs: getOutputs(configFilePath, tsConfig, internalProjectReferences, context.workspaceRoot, projectRoot, 
-                /* emitDeclarationOnly */ true),
+                outputs: getOutputs(configFilePath, tsConfig, internalProjectReferences, context.workspaceRoot, projectRoot),
                 syncGenerators: ['@nx/js:typescript-sync'],
                 metadata: {
                     technologies: ['typescript'],
@@ -243,9 +225,7 @@ function buildTscTargets(configFilePath, projectRoot, options, context) {
             options: { cwd: projectRoot },
             cache: true,
             inputs: getInputs(namedInputs, configFilePath, tsConfig, internalProjectReferences, context.workspaceRoot, projectRoot),
-            outputs: getOutputs(configFilePath, tsConfig, internalProjectReferences, context.workspaceRoot, projectRoot, 
-            // should be false for build target, but providing it just in case is set to true
-            tsConfig.options.emitDeclarationOnly),
+            outputs: getOutputs(configFilePath, tsConfig, internalProjectReferences, context.workspaceRoot, projectRoot),
             syncGenerators: ['@nx/js:typescript-sync'],
             metadata: {
                 technologies: ['typescript'],
@@ -280,57 +260,10 @@ function getInputs(namedInputs, configFilePath, tsConfig, internalProjectReferen
         ...Object.entries(internalProjectReferences),
     ];
     const absoluteProjectRoot = (0, node_path_1.join)(workspaceRoot, projectRoot);
-    if (!ts) {
-        ts = require('typescript');
-    }
-    // https://github.com/microsoft/TypeScript/blob/19b777260b26aac5707b1efd34202054164d4a9d/src/compiler/utilities.ts#L9869
-    const supportedTSExtensions = [
-        ts.Extension.Ts,
-        ts.Extension.Tsx,
-        ts.Extension.Dts,
-        ts.Extension.Cts,
-        ts.Extension.Dcts,
-        ts.Extension.Mts,
-        ts.Extension.Dmts,
-    ];
-    // https://github.com/microsoft/TypeScript/blob/19b777260b26aac5707b1efd34202054164d4a9d/src/compiler/utilities.ts#L9878
-    const allSupportedExtensions = [
-        ts.Extension.Ts,
-        ts.Extension.Tsx,
-        ts.Extension.Dts,
-        ts.Extension.Js,
-        ts.Extension.Jsx,
-        ts.Extension.Cts,
-        ts.Extension.Dcts,
-        ts.Extension.Cjs,
-        ts.Extension.Mts,
-        ts.Extension.Dmts,
-        ts.Extension.Mjs,
-    ];
-    const normalizeInput = (input, config) => {
-        const extensions = config.options.allowJs
-            ? [...allSupportedExtensions]
-            : [...supportedTSExtensions];
-        if (config.options.resolveJsonModule) {
-            extensions.push(ts.Extension.Json);
-        }
-        const segments = input.split('/');
-        // An "includes" path "foo" is implicitly a glob "foo/**/*" if its last
-        // segment has no extension, and does not contain any glob characters
-        // itself.
-        // https://github.com/microsoft/TypeScript/blob/19b777260b26aac5707b1efd34202054164d4a9d/src/compiler/utilities.ts#L9577-L9585
-        if (!/[.*?]/.test(segments.at(-1))) {
-            return extensions.map((ext) => `${segments.join('/')}/**/*${ext}`);
-        }
-        return [input];
-    };
     projectTsConfigFiles.forEach(([configPath, config]) => {
         configFiles.add(configPath);
         const offset = (0, node_path_1.relative)(absoluteProjectRoot, (0, node_path_1.dirname)(configPath));
-        (config.raw?.include ?? []).forEach((p) => {
-            const normalized = normalizeInput((0, node_path_1.join)(offset, p), config);
-            normalized.forEach((input) => includePaths.add(input));
-        });
+        (config.raw?.include ?? []).forEach((p) => includePaths.add((0, node_path_1.join)(offset, p)));
         if (config.raw?.exclude) {
             /**
              * We need to filter out the exclude paths that are already included in
@@ -378,7 +311,7 @@ function getInputs(namedInputs, configFilePath, tsConfig, internalProjectReferen
     inputs.push({ externalDependencies });
     return inputs;
 }
-function getOutputs(configFilePath, tsConfig, internalProjectReferences, workspaceRoot, projectRoot, emitDeclarationOnly) {
+function getOutputs(configFilePath, tsConfig, internalProjectReferences, workspaceRoot, projectRoot) {
     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
@@ -400,18 +333,9 @@ function getOutputs(configFilePath, tsConfig, internalProjectReferences, workspa
                 : pathToInputOrOutput((0, devkit_1.joinPathFragments)(outDir, `${outFileName}.tsbuildinfo`), workspaceRoot, projectRoot));
         }
         else if (config.options.outDir) {
-            if (emitDeclarationOnly) {
-                outputs.add(pathToInputOrOutput((0, devkit_1.joinPathFragments)(config.options.outDir, '**/*.d.ts'), workspaceRoot, projectRoot));
-                if (tsConfig.options.declarationMap) {
-                    outputs.add(pathToInputOrOutput((0, devkit_1.joinPathFragments)(config.options.outDir, '**/*.d.ts.map'), workspaceRoot, projectRoot));
-                }
-            }
-            else {
-                outputs.add(pathToInputOrOutput(config.options.outDir, workspaceRoot, projectRoot));
-            }
+            outputs.add(pathToInputOrOutput(config.options.outDir, workspaceRoot, projectRoot));
             if (config.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}`)) {
+                if (!(0, node_path_1.normalize)(config.options.tsBuildInfoFile).startsWith(`${(0, node_path_1.normalize)(config.options.outDir)}${node_path_1.sep}`)) {
                     // https://www.typescriptlang.org/tsconfig#tsBuildInfoFile
                     outputs.add(pathToInputOrOutput(config.options.tsBuildInfoFile, workspaceRoot, projectRoot));
                 }
@@ -421,11 +345,6 @@ function getOutputs(configFilePath, tsConfig, internalProjectReferences, workspa
                 const relativeRootDir = (0, node_path_1.relative)(config.options.rootDir, (0, node_path_1.join)(workspaceRoot, projectRoot));
                 outputs.add(pathToInputOrOutput((0, devkit_1.joinPathFragments)(config.options.outDir, relativeRootDir, `*.tsbuildinfo`), workspaceRoot, projectRoot));
             }
-            else if (emitDeclarationOnly) {
-                // https://www.typescriptlang.org/tsconfig#tsBuildInfoFile
-                const name = (0, node_path_1.basename)(configFilePath, '.json');
-                outputs.add(pathToInputOrOutput((0, devkit_1.joinPathFragments)(config.options.outDir, `${name}.tsbuildinfo`), workspaceRoot, projectRoot));
-            }
         }
         else if (config.raw?.include?.length ||
             config.raw?.files?.length ||
@@ -461,15 +380,17 @@ function pathToInputOrOutput(path, workspaceRoot, projectRoot) {
     }
     return (0, devkit_1.joinPathFragments)('{projectRoot}', pathRelativeToProjectRoot);
 }
-function getExtendedConfigFiles(tsConfig, workspaceRoot, extendedConfigFiles = new Set(), extendedExternalPackages = new Set()) {
-    for (const extendedConfigFile of tsConfig.extendedConfigFiles) {
-        if (extendedConfigFile.externalPackage) {
-            extendedExternalPackages.add(extendedConfigFile.externalPackage);
-        }
-        else if (extendedConfigFile.filePath) {
-            extendedConfigFiles.add(extendedConfigFile.filePath);
-            getExtendedConfigFiles(retrieveTsConfigFromCache(extendedConfigFile.filePath, workspaceRoot), workspaceRoot, extendedConfigFiles, extendedExternalPackages);
-        }
+function getExtendedConfigFiles(tsConfig, workspaceRoot) {
+    const extendedConfigFiles = new Set();
+    const extendedExternalPackages = new Set();
+    let currentExtendedConfigFile = tsConfig.extendedConfigFile;
+    while (currentExtendedConfigFile) {
+        if (currentExtendedConfigFile.externalPackage) {
+            extendedExternalPackages.add(currentExtendedConfigFile.externalPackage);
+            break;
+        }
+        extendedConfigFiles.add(currentExtendedConfigFile.filePath);
+        currentExtendedConfigFile = retrieveTsConfigFromCache(currentExtendedConfigFile.filePath, workspaceRoot).extendedConfigFile;
     }
     return {
         files: Array.from(extendedConfigFiles),
@@ -605,54 +526,44 @@ function readTsConfigAndCache(tsConfigPath, workspaceRoot) {
     let extendedFilesHash;
     if (tsConfigCache[relativePath] &&
         tsConfigCache[relativePath].hash === hash) {
-        extendedFilesHash = getExtendedFilesHash(tsConfigCache[relativePath].data.extendedConfigFiles, workspaceRoot);
+        extendedFilesHash = getExtendedFilesHash(tsConfigCache[relativePath].data.extendedConfigFile, workspaceRoot);
         if (tsConfigCache[relativePath].extendedFilesHash === extendedFilesHash) {
             return tsConfigCache[relativePath].data;
         }
     }
     const tsConfig = readTsConfig(tsConfigPath, workspaceRoot);
-    const extendedConfigFiles = [];
-    if (tsConfig.raw?.extends) {
-        const extendsArray = typeof tsConfig.raw.extends === 'string'
-            ? [tsConfig.raw.extends]
-            : tsConfig.raw.extends;
-        for (const extendsPath of extendsArray) {
-            const extendedConfigFile = resolveExtendedTsConfigPath(extendsPath, (0, node_path_1.dirname)(tsConfigPath));
-            if (extendedConfigFile) {
-                extendedConfigFiles.push(extendedConfigFile);
-            }
-        }
-    }
-    extendedFilesHash ??= getExtendedFilesHash(extendedConfigFiles, workspaceRoot);
+    const extendedConfigFile = tsConfig.raw?.extends
+        ? resolveExtendedTsConfigPath(tsConfig.raw.extends, (0, node_path_1.dirname)(tsConfigPath))
+        : null;
+    extendedFilesHash ??= getExtendedFilesHash(extendedConfigFile, workspaceRoot);
     tsConfigCache[relativePath] = {
         data: {
             options: tsConfig.options,
             projectReferences: tsConfig.projectReferences,
             raw: tsConfig.raw,
-            extendedConfigFiles,
+            extendedConfigFile: extendedConfigFile ?? null,
         },
         hash,
         extendedFilesHash,
     };
     return tsConfigCache[relativePath].data;
 }
-function getExtendedFilesHash(extendedConfigFiles, workspaceRoot) {
+function getExtendedFilesHash(extendedConfigFile, workspaceRoot) {
     const hashes = [];
-    if (!extendedConfigFiles.length) {
+    if (!extendedConfigFile) {
         return '';
     }
-    for (const extendedConfigFile of extendedConfigFiles) {
-        if (extendedConfigFile.externalPackage) {
-            hashes.push(extendedConfigFile.externalPackage);
-        }
-        else if (extendedConfigFile.filePath) {
-            hashes.push(getFileHash(extendedConfigFile.filePath, workspaceRoot));
-            hashes.push(getExtendedFilesHash(readTsConfigAndCache(extendedConfigFile.filePath, workspaceRoot)
-                .extendedConfigFiles, workspaceRoot));
-        }
+    if (extendedConfigFile.externalPackage) {
+        hashes.push(extendedConfigFile.externalPackage);
+    }
+    else if (extendedConfigFile.filePath) {
+        hashes.push(getFileHash(extendedConfigFile.filePath, workspaceRoot));
+        hashes.push(getExtendedFilesHash(readTsConfigAndCache(extendedConfigFile.filePath, workspaceRoot)
+            .extendedConfigFile, workspaceRoot));
     }
     return hashes.join('|');
 }
+let ts;
 function readTsConfig(tsConfigPath, workspaceRoot) {
     if (!ts) {
         ts = require('typescript');
@@ -712,8 +623,7 @@ function resolveExtendedTsConfigPath(tsConfigPath, directory) {
         const resolvedPath = require.resolve(tsConfigPath, {
             paths: directory ? [directory] : undefined,
         });
-        if (tsConfigPath.startsWith('.') ||
-            !resolvedPath.includes('/node_modules/')) {
+        if (tsConfigPath.startsWith('.')) {
             return { filePath: resolvedPath };
         }
         // parse the package from the tsconfig path
@@ -751,7 +661,7 @@ function toAbsolutePaths(cache, workspaceRoot) {
                 raw: {
                     nx: { addTypecheckTarget: data.raw?.['nx']?.addTypecheckTarget },
                 },
-                extendedConfigFiles: data.extendedConfigFiles,
+                extendedConfigFile: data.extendedConfigFile,
             },
             extendedFilesHash,
             hash,
@@ -768,10 +678,8 @@ function toAbsolutePaths(cache, workspaceRoot) {
         if (data.options.tsBuildInfoFile) {
             updatedCache[key].data.options.tsBuildInfoFile = (0, node_path_1.join)(workspaceRoot, data.options.tsBuildInfoFile);
         }
-        if (data.extendedConfigFiles.length) {
-            updatedCache[key].data.extendedConfigFiles.forEach((file) => {
-                file.filePath = (0, node_path_1.join)(workspaceRoot, file.filePath);
-            });
+        if (data.extendedConfigFile?.filePath) {
+            updatedCache[key].data.extendedConfigFile.filePath = (0, node_path_1.join)(workspaceRoot, data.extendedConfigFile.filePath);
         }
         if (data.projectReferences) {
             updatedCache[key].data.projectReferences = data.projectReferences.map((ref) => ({ ...ref, path: (0, node_path_1.join)(workspaceRoot, ref.path) }));
@@ -788,7 +696,7 @@ function toRelativePaths(cache, workspaceRoot) {
                 raw: {
                     nx: { addTypecheckTarget: data.raw?.['nx']?.addTypecheckTarget },
                 },
-                extendedConfigFiles: data.extendedConfigFiles,
+                extendedConfigFile: data.extendedConfigFile,
             },
             extendedFilesHash,
             hash,
@@ -805,10 +713,8 @@ function toRelativePaths(cache, workspaceRoot) {
         if (data.options.tsBuildInfoFile) {
             updatedCache[key].data.options.tsBuildInfoFile = posixRelative(workspaceRoot, data.options.tsBuildInfoFile);
         }
-        if (data.extendedConfigFiles.length) {
-            updatedCache[key].data.extendedConfigFiles.forEach((file) => {
-                file.filePath = posixRelative(workspaceRoot, file.filePath);
-            });
+        if (data.extendedConfigFile?.filePath) {
+            updatedCache[key].data.extendedConfigFile.filePath = posixRelative(workspaceRoot, data.extendedConfigFile.filePath);
         }
         if (data.projectReferences) {
             updatedCache[key].data.projectReferences = data.projectReferences.map((ref) => ({

package/src/plugins/typescript/util.d.ts

@@ -1,12 +1,11 @@
 import { type TargetConfiguration } from '@nx/devkit';
 import { type PackageManagerCommands } from 'nx/src/utils/package-manager';
 import { type ParsedCommandLine } from 'typescript';
-export type ExtendedConfigFile = {
-    filePath: string;
-    externalPackage?: string;
-};
 export type ParsedTsconfigData = Pick<ParsedCommandLine, 'options' | 'projectReferences' | 'raw'> & {
-    extendedConfigFiles: ExtendedConfigFile[];
+    extendedConfigFile: {
+        filePath: string;
+        externalPackage?: string;
+    } | null;
 };
 /**
  * Allow uses that use incremental builds to run `nx watch-deps` to continuously build all dependencies.

package/src/plugins/typescript/util.js

@@ -29,6 +29,7 @@ function addBuildAndWatchDepsTargets(workspaceRoot, projectRoot, targets, option
             dependsOn: ['^build'],
         };
         targets[options.watchDepsTargetName ?? 'watch-deps'] = {
+            continuous: true,
             dependsOn: [buildDepsTargetName],
             command: `${pmc.exec} nx watch --projects ${projectName} --includeDependentProjects -- ${pmc.exec} nx ${buildDepsTargetName} ${projectName}`,
         };
@@ -67,8 +68,8 @@ function isValidPackageJsonBuildConfig(tsConfig, workspaceRoot, projectRoot) {
         }
         else if (typeof value === 'object') {
             return Object.entries(value).some(([currentKey, subValue]) => {
-                // Skip types and development conditions
-                if (currentKey === 'types' || currentKey === 'development') {
+                // Skip types field
+                if (currentKey === 'types') {
                     return false;
                 }
                 if (typeof subValue === 'string') {

package/src/utils/buildable-libs-utils.d.ts

@@ -33,6 +33,8 @@ export declare function calculateDependenciesFromTaskGraph(taskGraph: TaskGraph,
  */
 export declare function computeCompilerOptionsPaths(tsConfig: string | ts.ParsedCommandLine, dependencies: DependentBuildableProjectNode[]): ts.MapLike<string[]>;
 export declare function createTmpTsConfig(tsconfigPath: string, workspaceRoot: string, projectRoot: string, dependencies: DependentBuildableProjectNode[], useWorkspaceAsBaseUrl?: boolean): string;
+export declare function checkDependentProjectsHaveBeenBuilt(root: string, projectName: string, targetName: string, projectDependencies: DependentBuildableProjectNode[]): boolean;
+export declare function findMissingBuildDependencies(root: string, projectName: string, targetName: string, projectDependencies: DependentBuildableProjectNode[]): DependentBuildableProjectNode[];
 export declare function updatePaths(dependencies: DependentBuildableProjectNode[], paths: Record<string, string[]>): void;
 /**
  * Updates the peerDependencies section in the `dist/lib/xyz/package.json` with

package/src/utils/buildable-libs-utils.js

@@ -5,6 +5,8 @@ exports.calculateProjectDependencies = calculateProjectDependencies;
 exports.calculateDependenciesFromTaskGraph = calculateDependenciesFromTaskGraph;
 exports.computeCompilerOptionsPaths = computeCompilerOptionsPaths;
 exports.createTmpTsConfig = createTmpTsConfig;
+exports.checkDependentProjectsHaveBeenBuilt = checkDependentProjectsHaveBeenBuilt;
+exports.findMissingBuildDependencies = findMissingBuildDependencies;
 exports.updatePaths = updatePaths;
 exports.updateBuildableProjectPackageJsonDependencies = updateBuildableProjectPackageJsonDependencies;
 const devkit_1 = require("@nx/devkit");
@@ -250,6 +252,36 @@ function cleanupTmpTsConfigFile(tmpTsConfigPath) {
     }
     catch (e) { }
 }
+function checkDependentProjectsHaveBeenBuilt(root, projectName, targetName, projectDependencies) {
+    const missing = findMissingBuildDependencies(root, projectName, targetName, projectDependencies);
+    if (missing.length > 0) {
+        console.error((0, devkit_1.stripIndents) `
+      It looks like all of ${projectName}'s dependencies have not been built yet:
+      ${missing.map((x) => ` - ${x.node.name}`).join('\n')}
+
+      You might be missing a "targetDefaults" configuration in your root nx.json (https://nx.dev/reference/project-configuration#target-defaults),
+      or "dependsOn" configured in ${projectName}'s project.json (https://nx.dev/reference/project-configuration#dependson) 
+    `);
+        return false;
+    }
+    else {
+        return true;
+    }
+}
+function findMissingBuildDependencies(root, projectName, targetName, projectDependencies) {
+    const depLibsToBuildFirst = [];
+    // verify whether all dependent libraries have been built
+    projectDependencies.forEach((dep) => {
+        if (dep.node.type !== 'lib') {
+            return;
+        }
+        const paths = dep.outputs.map((p) => (0, path_1.join)(root, p));
+        if (!paths.some(fileutils_1.directoryExists)) {
+            depLibsToBuildFirst.push(dep);
+        }
+    });
+    return depLibsToBuildFirst;
+}
 function updatePaths(dependencies, paths) {
     const pathsKeys = Object.keys(paths);
     // For each registered dependency
@@ -259,7 +291,7 @@ function updatePaths(dependencies, paths) {
         // If there are outputs
         if (dep.outputs && dep.outputs.length > 0) {
             // Directly map the dependency name to the output paths (dist/packages/..., etc.)
-            paths[dep.name] = dep.outputs.map((output) => output.replace(/(\*|\/[^\/]*\*).*$/, ''));
+            paths[dep.name] = dep.outputs;
             // check for secondary entrypoints
             // For each registered path
             for (const path of pathsKeys) {

package/src/utils/package-json/update-package-json.d.ts

@@ -19,7 +19,6 @@ export interface UpdatePackageJsonOption {
     buildableProjectDepsInPackageJsonType?: 'dependencies' | 'peerDependencies';
     generateLockfile?: boolean;
     packageJsonPath?: string;
-    skipDevelopmentExports?: boolean;
 }
 export declare function updatePackageJson(options: UpdatePackageJsonOption, context: ExecutorContext, target: ProjectGraphProjectNode, dependencies: DependentBuildableProjectNode[], fileMap?: ProjectFileMap): void;
 interface Exports {

package/src/utils/package-json/update-package-json.js

@@ -50,10 +50,7 @@ function updatePackageJson(options, context, target, dependencies, fileMap = nul
         options.format = ['cjs'];
     }
     // update package specific settings
-    packageJson = getUpdatedPackageJsonContent(packageJson, {
-        skipDevelopmentExports: true,
-        ...options,
-    });
+    packageJson = getUpdatedPackageJsonContent(packageJson, options);
     // save files
     (0, devkit_1.writeJsonFile)(`${options.outputPath}/package.json`, packageJson);
     if (options.generateLockfile) {
@@ -149,19 +146,6 @@ function getUpdatedPackageJsonContent(packageJson, options) {
         packageJson.exports ??=
             typeof packageJson.exports === 'string' ? {} : { ...packageJson.exports };
         packageJson.exports['./package.json'] ??= './package.json';
-        if (!options.skipDevelopmentExports && (hasCjsFormat || hasEsmFormat)) {
-            packageJson.exports['.'] ??= {};
-            const developmentExports = getDevelopmentExports(options);
-            for (const [exportEntry, filePath] of Object.entries(developmentExports)) {
-                if (!packageJson.exports[exportEntry]) {
-                    packageJson.exports[exportEntry] ??= {};
-                    packageJson.exports[exportEntry]['development'] ??= filePath;
-                }
-                else if (typeof packageJson.exports[exportEntry] === 'object') {
-                    packageJson.exports[exportEntry].development ??= filePath;
-                }
-            }
-        }
     }
     if (!options.skipTypings) {
         const mainFile = (0, path_1.basename)(options.main).replace(/\.[tj]s$/, '');
@@ -231,31 +215,6 @@ function getUpdatedPackageJsonContent(packageJson, options) {
     }
     return packageJson;
 }
-function getDevelopmentExports(options) {
-    const mainRelativeDir = (0, get_main_file_dir_1.getRelativeDirectoryToProjectRoot)(options.main, options.projectRoot);
-    const exports = {
-        '.': mainRelativeDir + (0, path_1.basename)(options.main),
-    };
-    if (options.additionalEntryPoints?.length) {
-        const jsRegex = /\.[jt]sx?$/;
-        for (const file of options.additionalEntryPoints) {
-            const { ext: fileExt, name: fileName, base: baseName } = (0, path_1.parse)(file);
-            if (!jsRegex.test(fileExt)) {
-                continue;
-            }
-            const relativeDir = (0, get_main_file_dir_1.getRelativeDirectoryToProjectRoot)(file, options.projectRoot);
-            const sourceFilePath = relativeDir + baseName;
-            const entryRelativeDir = relativeDir.replace(/^\.\/src\//, './');
-            const entryFilePath = entryRelativeDir + fileName;
-            if (fileName === 'index') {
-                const barrelEntry = entryRelativeDir.replace(/\/$/, '');
-                exports[barrelEntry] = sourceFilePath;
-            }
-            exports[entryFilePath] = sourceFilePath;
-        }
-    }
-    return exports;
-}
 function getOutputDir(options) {
     const packageJsonDir = options.packageJsonPath
         ? (0, path_1.dirname)(options.packageJsonPath)

package/src/utils/typescript/tsnode-register.d.ts

@@ -0,0 +1 @@
+export declare function tsNodeRegister(file: string, tsConfig?: string): void;

package/src/utils/typescript/tsnode-register.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tsNodeRegister = tsNodeRegister;
+function tsNodeRegister(file, tsConfig) {
+    if (!file?.endsWith('.ts'))
+        return;
+    // Register TS compiler lazily
+    require('ts-node').register({
+        project: tsConfig,
+        compilerOptions: {
+            module: 'CommonJS',
+            types: ['node'],
+        },
+    });
+    if (!tsConfig)
+        return;
+    // Register paths in tsConfig
+    const tsconfigPaths = require('tsconfig-paths');
+    const { absoluteBaseUrl: baseUrl, paths } = tsconfigPaths.loadConfig(tsConfig);
+    if (baseUrl && paths) {
+        tsconfigPaths.register({ baseUrl, paths });
+    }
+}

package/src/utils/versions.d.ts

@@ -1,7 +1,7 @@
 export declare const nxVersion: any;
 export declare const esbuildVersion = "^0.19.2";
 export declare const prettierVersion = "^2.6.2";
-export declare const swcCliVersion = "~0.6.0";
+export declare const swcCliVersion = "~0.3.12";
 export declare const swcCoreVersion = "~1.5.7";
 export declare const swcHelpersVersion = "~0.5.11";
 export declare const swcNodeVersion = "~1.9.1";

package/src/utils/versions.js

@@ -4,7 +4,7 @@ exports.supportedTypescriptVersions = exports.typescriptVersion = exports.verdac
 exports.nxVersion = require('../../package.json').version;
 exports.esbuildVersion = '^0.19.2';
 exports.prettierVersion = '^2.6.2';
-exports.swcCliVersion = '~0.6.0';
+exports.swcCliVersion = '~0.3.12';
 exports.swcCoreVersion = '~1.5.7';
 exports.swcHelpersVersion = '~0.5.11';
 exports.swcNodeVersion = '~1.9.1';