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

package/migrations.json

@@ -146,6 +146,15 @@
           "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-30565-ba2942e",
+  "version": "0.0.0-pr-29464-73fdcbb",
   "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-30565-ba2942e",
-    "@nx/workspace": "0.0.0-pr-30565-ba2942e",
+    "@nx/devkit": "0.0.0-pr-29464-73fdcbb",
+    "@nx/workspace": "0.0.0-pr-29464-73fdcbb",
     "@zkochan/js-yaml": "0.0.7",
     "babel-plugin-const-enum": "^1.0.1",
     "babel-plugin-macros": "^3.1.0",
@@ -60,8 +60,6 @@
     "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,6 +17,7 @@
     "noUnusedLocals": true,
     "skipLibCheck": true,
     "strict": true,
-    "target": "es2022"
+    "target": "es2022",
+    "customConditions": ["development"]
   }
 }

package/src/generators/library/library.js

@@ -425,6 +425,8 @@ 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'),
@@ -433,6 +435,7 @@ function createFiles(tree, options) {
                     generateExportsField: true,
                     packageJsonPath,
                     format: ['esm'],
+                    skipDevelopmentExports: !tsconfigBase.compilerOptions?.customConditions?.includes('development'),
                 });
             }
             return updatedPackageJson;
@@ -455,6 +458,7 @@ 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'),
@@ -463,6 +467,7 @@ function createFiles(tree, options) {
                 generateExportsField: true,
                 packageJsonPath,
                 format: ['esm'],
+                skipDevelopmentExports: !tsconfigBase.compilerOptions?.customConditions?.includes('development'),
             });
         }
         if (!options.useProjectJson && options.name !== options.importPath) {
@@ -732,12 +737,6 @@ 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;
             });
         }
@@ -749,12 +748,6 @@ 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,6 +232,9 @@ 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,
@@ -240,6 +243,7 @@ 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,17 +29,21 @@ 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 "secretVerdaccioToken" --ws=false`, {
+                (0, child_process_1.execSync)(`npm config set //${listenAddress}:${port}/:_authToken "${authToken}" --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 and yarn config registry to ' + registry);
+                console.log('Set npm, bun, 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,15 +3,16 @@ 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');
@@ -144,6 +145,9 @@ 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) {
@@ -192,13 +196,27 @@ function buildTscTargets(configFilePath, projectRoot, options, context) {
                 // `tsc --build` does not work with `noEmit: true`
                 command = `echo "The 'typecheck' target is disabled because one or more project references set 'noEmit: true' in their tsconfig. Remove this property to resolve this issue."`;
             }
+            const dependsOn = [`^${targetName}`];
+            if (options.build && targets[options.build.targetName]) {
+                // we already processed and have a build target
+                dependsOn.unshift(options.build.targetName);
+            }
+            else if (options.build) {
+                // check if the project will have a build target
+                const buildConfigPath = (0, devkit_1.joinPathFragments)(projectRoot, options.build.configName);
+                if (context.configFiles.some((f) => f === buildConfigPath) &&
+                    (0, util_1.isValidPackageJsonBuildConfig)(retrieveTsConfigFromCache(buildConfigPath, context.workspaceRoot), context.workspaceRoot, projectRoot)) {
+                    dependsOn.unshift(options.build.targetName);
+                }
+            }
             targets[targetName] = {
-                dependsOn: [`^${targetName}`],
+                dependsOn,
                 command,
                 options: { cwd: projectRoot },
                 cache: true,
                 inputs: getInputs(namedInputs, configFilePath, tsConfig, internalProjectReferences, context.workspaceRoot, projectRoot),
-                outputs: getOutputs(configFilePath, tsConfig, internalProjectReferences, context.workspaceRoot, projectRoot),
+                outputs: getOutputs(configFilePath, tsConfig, internalProjectReferences, context.workspaceRoot, projectRoot, 
+                /* emitDeclarationOnly */ true),
                 syncGenerators: ['@nx/js:typescript-sync'],
                 metadata: {
                     technologies: ['typescript'],
@@ -225,7 +243,9 @@ function buildTscTargets(configFilePath, projectRoot, options, context) {
             options: { cwd: projectRoot },
             cache: true,
             inputs: getInputs(namedInputs, configFilePath, tsConfig, internalProjectReferences, context.workspaceRoot, projectRoot),
-            outputs: getOutputs(configFilePath, tsConfig, internalProjectReferences, context.workspaceRoot, projectRoot),
+            outputs: getOutputs(configFilePath, tsConfig, internalProjectReferences, context.workspaceRoot, projectRoot, 
+            // should be false for build target, but providing it just in case is set to true
+            tsConfig.options.emitDeclarationOnly),
             syncGenerators: ['@nx/js:typescript-sync'],
             metadata: {
                 technologies: ['typescript'],
@@ -260,10 +280,57 @@ function getInputs(namedInputs, configFilePath, tsConfig, internalProjectReferen
         ...Object.entries(internalProjectReferences),
     ];
     const absoluteProjectRoot = (0, node_path_1.join)(workspaceRoot, projectRoot);
+    if (!ts) {
+        ts = require('typescript');
+    }
+    // https://github.com/microsoft/TypeScript/blob/19b777260b26aac5707b1efd34202054164d4a9d/src/compiler/utilities.ts#L9869
+    const supportedTSExtensions = [
+        ts.Extension.Ts,
+        ts.Extension.Tsx,
+        ts.Extension.Dts,
+        ts.Extension.Cts,
+        ts.Extension.Dcts,
+        ts.Extension.Mts,
+        ts.Extension.Dmts,
+    ];
+    // https://github.com/microsoft/TypeScript/blob/19b777260b26aac5707b1efd34202054164d4a9d/src/compiler/utilities.ts#L9878
+    const allSupportedExtensions = [
+        ts.Extension.Ts,
+        ts.Extension.Tsx,
+        ts.Extension.Dts,
+        ts.Extension.Js,
+        ts.Extension.Jsx,
+        ts.Extension.Cts,
+        ts.Extension.Dcts,
+        ts.Extension.Cjs,
+        ts.Extension.Mts,
+        ts.Extension.Dmts,
+        ts.Extension.Mjs,
+    ];
+    const normalizeInput = (input, config) => {
+        const extensions = config.options.allowJs
+            ? [...allSupportedExtensions]
+            : [...supportedTSExtensions];
+        if (config.options.resolveJsonModule) {
+            extensions.push(ts.Extension.Json);
+        }
+        const segments = input.split('/');
+        // An "includes" path "foo" is implicitly a glob "foo/**/*" if its last
+        // segment has no extension, and does not contain any glob characters
+        // itself.
+        // https://github.com/microsoft/TypeScript/blob/19b777260b26aac5707b1efd34202054164d4a9d/src/compiler/utilities.ts#L9577-L9585
+        if (!/[.*?]/.test(segments.at(-1))) {
+            return extensions.map((ext) => `${segments.join('/')}/**/*${ext}`);
+        }
+        return [input];
+    };
     projectTsConfigFiles.forEach(([configPath, config]) => {
         configFiles.add(configPath);
         const offset = (0, node_path_1.relative)(absoluteProjectRoot, (0, node_path_1.dirname)(configPath));
-        (config.raw?.include ?? []).forEach((p) => includePaths.add((0, node_path_1.join)(offset, p)));
+        (config.raw?.include ?? []).forEach((p) => {
+            const normalized = normalizeInput((0, node_path_1.join)(offset, p), config);
+            normalized.forEach((input) => includePaths.add(input));
+        });
         if (config.raw?.exclude) {
             /**
              * We need to filter out the exclude paths that are already included in
@@ -311,7 +378,7 @@ function getInputs(namedInputs, configFilePath, tsConfig, internalProjectReferen
     inputs.push({ externalDependencies });
     return inputs;
 }
-function getOutputs(configFilePath, tsConfig, internalProjectReferences, workspaceRoot, projectRoot) {
+function getOutputs(configFilePath, tsConfig, internalProjectReferences, workspaceRoot, projectRoot, emitDeclarationOnly) {
     const outputs = new Set();
     // We could have more surgical outputs based on the tsconfig options, but the
     // user could override them through the command line and that wouldn't be
@@ -333,9 +400,18 @@ function getOutputs(configFilePath, tsConfig, internalProjectReferences, workspa
                 : pathToInputOrOutput((0, devkit_1.joinPathFragments)(outDir, `${outFileName}.tsbuildinfo`), workspaceRoot, projectRoot));
         }
         else if (config.options.outDir) {
-            outputs.add(pathToInputOrOutput(config.options.outDir, workspaceRoot, projectRoot));
+            if (emitDeclarationOnly) {
+                outputs.add(pathToInputOrOutput((0, devkit_1.joinPathFragments)(config.options.outDir, '**/*.d.ts'), workspaceRoot, projectRoot));
+                if (tsConfig.options.declarationMap) {
+                    outputs.add(pathToInputOrOutput((0, devkit_1.joinPathFragments)(config.options.outDir, '**/*.d.ts.map'), workspaceRoot, projectRoot));
+                }
+            }
+            else {
+                outputs.add(pathToInputOrOutput(config.options.outDir, workspaceRoot, projectRoot));
+            }
             if (config.options.tsBuildInfoFile) {
-                if (!(0, node_path_1.normalize)(config.options.tsBuildInfoFile).startsWith(`${(0, node_path_1.normalize)(config.options.outDir)}${node_path_1.sep}`)) {
+                if (emitDeclarationOnly ||
+                    !(0, node_path_1.normalize)(config.options.tsBuildInfoFile).startsWith(`${(0, node_path_1.normalize)(config.options.outDir)}${node_path_1.sep}`)) {
                     // https://www.typescriptlang.org/tsconfig#tsBuildInfoFile
                     outputs.add(pathToInputOrOutput(config.options.tsBuildInfoFile, workspaceRoot, projectRoot));
                 }
@@ -345,6 +421,11 @@ 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 ||
@@ -380,17 +461,15 @@ function pathToInputOrOutput(path, workspaceRoot, projectRoot) {
     }
     return (0, devkit_1.joinPathFragments)('{projectRoot}', pathRelativeToProjectRoot);
 }
-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;
+function getExtendedConfigFiles(tsConfig, workspaceRoot, extendedConfigFiles = new Set(), extendedExternalPackages = new Set()) {
+    for (const extendedConfigFile of tsConfig.extendedConfigFiles) {
+        if (extendedConfigFile.externalPackage) {
+            extendedExternalPackages.add(extendedConfigFile.externalPackage);
+        }
+        else if (extendedConfigFile.filePath) {
+            extendedConfigFiles.add(extendedConfigFile.filePath);
+            getExtendedConfigFiles(retrieveTsConfigFromCache(extendedConfigFile.filePath, workspaceRoot), workspaceRoot, extendedConfigFiles, extendedExternalPackages);
+        }
     }
     return {
         files: Array.from(extendedConfigFiles),
@@ -526,44 +605,54 @@ function readTsConfigAndCache(tsConfigPath, workspaceRoot) {
     let extendedFilesHash;
     if (tsConfigCache[relativePath] &&
         tsConfigCache[relativePath].hash === hash) {
-        extendedFilesHash = getExtendedFilesHash(tsConfigCache[relativePath].data.extendedConfigFile, workspaceRoot);
+        extendedFilesHash = getExtendedFilesHash(tsConfigCache[relativePath].data.extendedConfigFiles, workspaceRoot);
         if (tsConfigCache[relativePath].extendedFilesHash === extendedFilesHash) {
             return tsConfigCache[relativePath].data;
         }
     }
     const tsConfig = readTsConfig(tsConfigPath, workspaceRoot);
-    const extendedConfigFile = tsConfig.raw?.extends
-        ? resolveExtendedTsConfigPath(tsConfig.raw.extends, (0, node_path_1.dirname)(tsConfigPath))
-        : null;
-    extendedFilesHash ??= getExtendedFilesHash(extendedConfigFile, 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);
     tsConfigCache[relativePath] = {
         data: {
             options: tsConfig.options,
             projectReferences: tsConfig.projectReferences,
             raw: tsConfig.raw,
-            extendedConfigFile: extendedConfigFile ?? null,
+            extendedConfigFiles,
         },
         hash,
         extendedFilesHash,
     };
     return tsConfigCache[relativePath].data;
 }
-function getExtendedFilesHash(extendedConfigFile, workspaceRoot) {
+function getExtendedFilesHash(extendedConfigFiles, workspaceRoot) {
     const hashes = [];
-    if (!extendedConfigFile) {
+    if (!extendedConfigFiles.length) {
         return '';
     }
-    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));
+    for (const extendedConfigFile of extendedConfigFiles) {
+        if (extendedConfigFile.externalPackage) {
+            hashes.push(extendedConfigFile.externalPackage);
+        }
+        else if (extendedConfigFile.filePath) {
+            hashes.push(getFileHash(extendedConfigFile.filePath, workspaceRoot));
+            hashes.push(getExtendedFilesHash(readTsConfigAndCache(extendedConfigFile.filePath, workspaceRoot)
+                .extendedConfigFiles, workspaceRoot));
+        }
     }
     return hashes.join('|');
 }
-let ts;
 function readTsConfig(tsConfigPath, workspaceRoot) {
     if (!ts) {
         ts = require('typescript');
@@ -623,7 +712,8 @@ function resolveExtendedTsConfigPath(tsConfigPath, directory) {
         const resolvedPath = require.resolve(tsConfigPath, {
             paths: directory ? [directory] : undefined,
         });
-        if (tsConfigPath.startsWith('.')) {
+        if (tsConfigPath.startsWith('.') ||
+            !resolvedPath.includes('/node_modules/')) {
             return { filePath: resolvedPath };
         }
         // parse the package from the tsconfig path
@@ -661,7 +751,7 @@ function toAbsolutePaths(cache, workspaceRoot) {
                 raw: {
                     nx: { addTypecheckTarget: data.raw?.['nx']?.addTypecheckTarget },
                 },
-                extendedConfigFile: data.extendedConfigFile,
+                extendedConfigFiles: data.extendedConfigFiles,
             },
             extendedFilesHash,
             hash,
@@ -678,8 +768,10 @@ function toAbsolutePaths(cache, workspaceRoot) {
         if (data.options.tsBuildInfoFile) {
             updatedCache[key].data.options.tsBuildInfoFile = (0, node_path_1.join)(workspaceRoot, data.options.tsBuildInfoFile);
         }
-        if (data.extendedConfigFile?.filePath) {
-            updatedCache[key].data.extendedConfigFile.filePath = (0, node_path_1.join)(workspaceRoot, data.extendedConfigFile.filePath);
+        if (data.extendedConfigFiles.length) {
+            updatedCache[key].data.extendedConfigFiles.forEach((file) => {
+                file.filePath = (0, node_path_1.join)(workspaceRoot, file.filePath);
+            });
         }
         if (data.projectReferences) {
             updatedCache[key].data.projectReferences = data.projectReferences.map((ref) => ({ ...ref, path: (0, node_path_1.join)(workspaceRoot, ref.path) }));
@@ -696,7 +788,7 @@ function toRelativePaths(cache, workspaceRoot) {
                 raw: {
                     nx: { addTypecheckTarget: data.raw?.['nx']?.addTypecheckTarget },
                 },
-                extendedConfigFile: data.extendedConfigFile,
+                extendedConfigFiles: data.extendedConfigFiles,
             },
             extendedFilesHash,
             hash,
@@ -713,8 +805,10 @@ function toRelativePaths(cache, workspaceRoot) {
         if (data.options.tsBuildInfoFile) {
             updatedCache[key].data.options.tsBuildInfoFile = posixRelative(workspaceRoot, data.options.tsBuildInfoFile);
         }
-        if (data.extendedConfigFile?.filePath) {
-            updatedCache[key].data.extendedConfigFile.filePath = posixRelative(workspaceRoot, data.extendedConfigFile.filePath);
+        if (data.extendedConfigFiles.length) {
+            updatedCache[key].data.extendedConfigFiles.forEach((file) => {
+                file.filePath = posixRelative(workspaceRoot, file.filePath);
+            });
         }
         if (data.projectReferences) {
             updatedCache[key].data.projectReferences = data.projectReferences.map((ref) => ({

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

@@ -1,11 +1,12 @@
 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'> & {
-    extendedConfigFile: {
-        filePath: string;
-        externalPackage?: string;
-    } | null;
+    extendedConfigFiles: ExtendedConfigFile[];
 };
 /**
  * Allow uses that use incremental builds to run `nx watch-deps` to continuously build all dependencies.

package/src/plugins/typescript/util.js

@@ -29,7 +29,6 @@ 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}`,
         };
@@ -68,8 +67,8 @@ function isValidPackageJsonBuildConfig(tsConfig, workspaceRoot, projectRoot) {
         }
         else if (typeof value === 'object') {
             return Object.entries(value).some(([currentKey, subValue]) => {
-                // Skip types field
-                if (currentKey === 'types') {
+                // Skip types and development conditions
+                if (currentKey === 'types' || currentKey === 'development') {
                     return false;
                 }
                 if (typeof subValue === 'string') {

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

@@ -33,8 +33,6 @@ 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,8 +5,6 @@ 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");
@@ -252,36 +250,6 @@ 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
@@ -291,7 +259,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;
+            paths[dep.name] = dep.outputs.map((output) => output.replace(/(\*|\/[^\/]*\*).*$/, ''));
             // check for secondary entrypoints
             // For each registered path
             for (const path of pathsKeys) {

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

@@ -19,6 +19,7 @@ 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,7 +50,10 @@ function updatePackageJson(options, context, target, dependencies, fileMap = nul
         options.format = ['cjs'];
     }
     // update package specific settings
-    packageJson = getUpdatedPackageJsonContent(packageJson, options);
+    packageJson = getUpdatedPackageJsonContent(packageJson, {
+        skipDevelopmentExports: true,
+        ...options,
+    });
     // save files
     (0, devkit_1.writeJsonFile)(`${options.outputPath}/package.json`, packageJson);
     if (options.generateLockfile) {
@@ -146,6 +149,19 @@ 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$/, '');
@@ -215,6 +231,31 @@ 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/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.3.12";
+export declare const swcCliVersion = "~0.6.0";
 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.3.12';
+exports.swcCliVersion = '~0.6.0';
 exports.swcCoreVersion = '~1.5.7';
 exports.swcHelpersVersion = '~0.5.11';
 exports.swcNodeVersion = '~1.9.1';

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

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

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

@@ -1,23 +0,0 @@
-"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 });
-    }
-}