@nx/js 0.0.0-pr-30516-4c8bfff → 0.0.0-pr-30457-d91a68c

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-30516-4c8bfff",
+  "version": "0.0.0-pr-30457-d91a68c",
   "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-30516-4c8bfff",
-    "@nx/workspace": "0.0.0-pr-30516-4c8bfff",
+    "@nx/devkit": "0.0.0-pr-30457-d91a68c",
+    "@nx/workspace": "0.0.0-pr-30457-d91a68c",
     "@zkochan/js-yaml": "0.0.7",
     "babel-plugin-const-enum": "^1.0.1",
     "babel-plugin-macros": "^3.1.0",

package/src/generators/library/library.js

@@ -8,8 +8,10 @@ const project_name_and_root_utils_1 = require("@nx/devkit/src/generators/project
 const prompt_1 = require("@nx/devkit/src/generators/prompt");
 const target_defaults_utils_1 = require("@nx/devkit/src/generators/target-defaults-utils");
 const log_show_project_command_1 = require("@nx/devkit/src/utils/log-show-project-command");
+const use_legacy_versioning_1 = require("nx/src/command-line/release/config/use-legacy-versioning");
 const path_1 = require("path");
 const generator_prompts_1 = require("../../utils/generator-prompts");
+const sort_fields_1 = require("../../utils/package-json/sort-fields");
 const update_package_json_1 = require("../../utils/package-json/update-package-json");
 const add_swc_config_1 = require("../../utils/swc/add-swc-config");
 const add_swc_dependencies_1 = require("../../utils/swc/add-swc-dependencies");
@@ -21,7 +23,6 @@ const ts_config_1 = require("../../utils/typescript/ts-config");
 const ts_solution_setup_1 = require("../../utils/typescript/ts-solution-setup");
 const versions_1 = require("../../utils/versions");
 const init_1 = require("../init/init");
-const sort_fields_1 = require("../../utils/package-json/sort-fields");
 const add_release_config_1 = require("./utils/add-release-config");
 const defaultOutputDirectory = 'dist';
 async function libraryGenerator(tree, schema) {
@@ -158,8 +159,8 @@ async function libraryGeneratorInternal(tree, schema) {
     return (0, devkit_1.runTasksInSerial)(...tasks);
 }
 async function configureProject(tree, options) {
+    const nxJson = (0, devkit_1.readNxJson)(tree);
     if (options.hasPlugin) {
-        const nxJson = (0, devkit_1.readNxJson)(tree);
         (0, plugin_1.ensureProjectIsIncludedInPluginRegistrations)(nxJson, options.projectRoot, options.bundler === 'none' ? null : 'build');
         (0, devkit_1.updateNxJson)(tree, nxJson);
     }
@@ -217,7 +218,7 @@ async function configureProject(tree, options) {
             await (0, add_release_config_1.addReleaseConfigForTsSolution)(tree, options.name, projectConfiguration);
         }
         else {
-            await (0, add_release_config_1.addReleaseConfigForNonTsSolution)(tree, options.name, projectConfiguration, defaultOutputDirectory);
+            await (0, add_release_config_1.addReleaseConfigForNonTsSolution)((0, use_legacy_versioning_1.shouldUseLegacyVersioning)(nxJson.release), tree, options.name, projectConfiguration, defaultOutputDirectory);
         }
     }
     if (!options.useProjectJson) {
@@ -737,12 +738,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;
             });
         }
@@ -754,12 +749,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/library/utils/add-release-config.d.ts

@@ -7,5 +7,5 @@ export declare function addReleaseConfigForTsSolution(tree: Tree, projectName: s
  * Add release configuration for non-ts solution projects
  * Add release option in project.json and add packageRoot to nx-release-publish target
  */
-export declare function addReleaseConfigForNonTsSolution(tree: Tree, projectName: string, projectConfiguration: ProjectConfiguration, defaultOutputDirectory?: string): Promise<ProjectConfiguration>;
+export declare function addReleaseConfigForNonTsSolution(useLegacyVersioning: boolean, tree: Tree, projectName: string, projectConfiguration: ProjectConfiguration, defaultOutputDirectory?: string): Promise<ProjectConfiguration>;
 export declare function releaseTasks(tree: Tree): Promise<GeneratorCallback>;

package/src/generators/library/utils/add-release-config.js

@@ -91,7 +91,7 @@ async function addReleaseConfigForTsSolution(tree, projectName, projectConfigura
  * Add release configuration for non-ts solution projects
  * Add release option in project.json and add packageRoot to nx-release-publish target
  */
-async function addReleaseConfigForNonTsSolution(tree, projectName, projectConfiguration, defaultOutputDirectory = 'dist') {
+async function addReleaseConfigForNonTsSolution(useLegacyVersioning, tree, projectName, projectConfiguration, defaultOutputDirectory = 'dist') {
     const packageRoot = (0, devkit_1.joinPathFragments)(defaultOutputDirectory, '{projectRoot}');
     projectConfiguration.targets ??= {};
     projectConfiguration.targets['nx-release-publish'] = {
@@ -99,17 +99,31 @@ async function addReleaseConfigForNonTsSolution(tree, projectName, projectConfig
             packageRoot,
         },
     };
-    projectConfiguration.release = {
-        version: {
-            generatorOptions: {
-                packageRoot,
+    if (useLegacyVersioning) {
+        projectConfiguration.release = {
+            version: {
+                generatorOptions: {
+                    packageRoot,
+                    // using git tags to determine the current version is required here because
+                    // the version in the package root is overridden with every build
+                    currentVersionResolver: 'git-tag',
+                    fallbackCurrentVersionResolver: 'disk',
+                },
+            },
+        };
+    }
+    else {
+        // TODO: re-evaluate this config in new versions
+        projectConfiguration.release = {
+            version: {
+                manifestRootsToUpdate: [packageRoot],
                 // using git tags to determine the current version is required here because
                 // the version in the package root is overridden with every build
                 currentVersionResolver: 'git-tag',
                 fallbackCurrentVersionResolver: 'disk',
             },
-        },
-    };
+        };
+    }
     await addReleaseConfigForTsSolution(tree, projectName, projectConfiguration);
     return projectConfiguration;
 }

package/src/generators/release-version/release-version.d.ts

@@ -1,5 +1,5 @@
 import { Tree } from '@nx/devkit';
-import { ReleaseVersionGeneratorResult } from 'nx/src/command-line/release/version';
+import { ReleaseVersionGeneratorResult } from 'nx/src/command-line/release/version-legacy';
 import { ReleaseVersionGeneratorSchema } from './schema';
 export declare function releaseVersionGenerator(tree: Tree, options: ReleaseVersionGeneratorSchema): Promise<ReleaseVersionGeneratorResult>;
 export default releaseVersionGenerator;

package/src/generators/release-version/release-version.js

@@ -11,15 +11,15 @@ const config_1 = require("nx/src/command-line/release/config/config");
 const git_1 = require("nx/src/command-line/release/utils/git");
 const resolve_semver_specifier_1 = require("nx/src/command-line/release/utils/resolve-semver-specifier");
 const semver_1 = require("nx/src/command-line/release/utils/semver");
-const version_1 = require("nx/src/command-line/release/version");
+const version_legacy_1 = require("nx/src/command-line/release/version-legacy");
 const utils_1 = require("nx/src/tasks-runner/utils");
 const ora = require("ora");
 const semver_2 = require("semver");
+const update_lock_file_1 = require("../../release/utils/update-lock-file");
 const is_locally_linked_package_version_1 = require("../../utils/is-locally-linked-package-version");
 const npm_config_1 = require("../../utils/npm-config");
 const resolve_local_package_dependencies_1 = require("./utils/resolve-local-package-dependencies");
 const sort_projects_topologically_1 = require("./utils/sort-projects-topologically");
-const update_lock_file_1 = require("./utils/update-lock-file");
 function resolvePreIdSpecifier(currentSpecifier, preid) {
     if (!currentSpecifier.startsWith('pre') && preid) {
         return `pre${currentSpecifier}`;
@@ -39,10 +39,10 @@ async function releaseVersionGenerator(tree, options) {
             options.specifier = options.specifier.replace(/^v/, '');
         }
         if (options.versionPrefix &&
-            version_1.validReleaseVersionPrefixes.indexOf(options.versionPrefix) === -1) {
+            version_legacy_1.validReleaseVersionPrefixes.indexOf(options.versionPrefix) === -1) {
             throw new Error(`Invalid value for version.generatorOptions.versionPrefix: "${options.versionPrefix}"
 
-Valid values are: ${version_1.validReleaseVersionPrefixes
+Valid values are: ${version_legacy_1.validReleaseVersionPrefixes
                 .map((s) => `"${s}"`)
                 .join(', ')}`);
         }
@@ -54,7 +54,6 @@ Valid values are: ${version_1.validReleaseVersionPrefixes
         const updateDependents = options.updateDependents ?? 'auto';
         const updateDependentsBump = resolvePreIdSpecifier('patch', options.preid);
         // Sort the projects topologically if update dependents is enabled
-        // TODO: maybe move this sorting to the command level?
         const projects = updateDependents === 'never' ||
             options.releaseGroup.projectsRelationship !== 'independent'
             ? options.projects
@@ -287,8 +286,6 @@ To fix this you will either need to add a package.json file at that location, or
                             logger.buffer(`🚫 No changes were detected using git history and the conventional commits standard.`);
                             break;
                         }
-                        // TODO: reevaluate this prerelease logic/workflow for independent projects
-                        //
                         // Always assume that if the current version is a prerelease, then the next version should be a prerelease.
                         // Users must manually graduate from a prerelease to a release by providing an explicit specifier.
                         if ((0, semver_2.prerelease)(currentVersion ?? '')) {
@@ -490,7 +487,7 @@ To fix this you will either need to add a package.json file at that location, or
                 }
                 continue;
             }
-            const newVersion = (0, version_1.deriveNewSemverVersion)(currentVersion, specifier, options.preid);
+            const newVersion = (0, version_legacy_1.deriveNewSemverVersion)(currentVersion, specifier, options.preid);
             versionData[projectName].newVersion = newVersion;
             (0, devkit_1.writeJson)(tree, packageJsonPath, {
                 ...packageJson,
@@ -556,7 +553,7 @@ To fix this you will either need to add a package.json file at that location, or
                     }
                     // Bump the dependent's version if applicable and record it in the version data
                     if (forceVersionBump) {
-                        const newPackageVersion = (0, version_1.deriveNewSemverVersion)(currentPackageVersion, forceVersionBump, options.preid);
+                        const newPackageVersion = (0, version_legacy_1.deriveNewSemverVersion)(currentPackageVersion, forceVersionBump, options.preid);
                         json.version = newPackageVersion;
                         // Look up any dependent projects from the transitiveLocalPackageDependents list
                         const transitiveDependentProjects = transitiveLocalPackageDependents.filter((localPackageDependency) => localPackageDependency.target === dependentProject.source);
@@ -666,7 +663,10 @@ To fix this you will either need to add a package.json file at that location, or
                     deletedFiles.push(...(await cb(opts.dryRun)));
                 }
                 const cwd = tree.root;
-                changedFiles.push(...(await (0, update_lock_file_1.updateLockFile)(cwd, opts)));
+                changedFiles.push(...(await (0, update_lock_file_1.updateLockFile)(cwd, {
+                    ...opts,
+                    useLegacyVersioning: true,
+                })));
                 return { changedFiles, deletedFiles };
             },
         };
@@ -697,7 +697,8 @@ function createResolvePackageRoot(customPackageRoot) {
             return projectNode.data.root;
         }
         if (projectNode.data.root === '.') {
-            // TODO This is a temporary workaround to fix NXC-574 until NXC-573 is resolved
+            // This is a temporary workaround to fix NXC-574 until NXC-573 is resolved.
+            // This has been fixed in "versioning v2"
             return projectNode.data.root;
         }
         return (0, utils_1.interpolate)(customPackageRoot, {

package/src/generators/release-version/schema.d.ts

@@ -1 +1 @@
-export { ReleaseVersionGeneratorSchema } from 'nx/src/command-line/release/version';
+export { ReleaseVersionGeneratorSchema } from 'nx/src/command-line/release/version-legacy';

package/src/generators/release-version/schema.json

@@ -8,6 +8,8 @@
   "properties": {
     "projects": {
       "type": "array",
+      "hidden": true,
+      "$comment": "This is not configured/passed by the user. It is provided by the version command.",
       "description": "The ProjectGraphProjectNodes being versioned in the current execution.",
       "items": {
         "type": "object"
@@ -15,16 +17,33 @@
     },
     "projectGraph": {
       "type": "object",
+      "hidden": true,
+      "$comment": "This is not configured/passed by the user. It is provided by the version command.",
       "description": "ProjectGraph instance"
     },
-    "specifier": {
-      "type": "string",
-      "description": "Exact version or semver keyword to apply to the selected release group. Overrides specifierSource."
-    },
     "releaseGroup": {
       "type": "object",
+      "hidden": true,
+      "$comment": "This is not configured/passed by the user. It is provided by the version command.",
       "description": "The resolved release group configuration, including name, relevant to all projects in the current execution."
     },
+    "conventionalCommitsConfig": {
+      "type": "object",
+      "hidden": true,
+      "$comment": "This is not configured/passed by the user. It is provided by the version command.",
+      "description": "The conventional commits configuration to use when determining the next version of the project.",
+      "default": {}
+    },
+    "firstRelease": {
+      "type": "boolean",
+      "hidden": true,
+      "$comment": "This is not configured/passed by the user. It is provided by the version command.",
+      "description": "Whether this is the first release of the project (which skips some validation within the generator)."
+    },
+    "specifier": {
+      "type": "string",
+      "description": "Exact version or semver keyword to apply to the selected release group. Overrides specifierSource."
+    },
     "specifierSource": {
       "type": "string",
       "default": "prompt",

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/release/utils/update-lock-file.d.ts

@@ -0,0 +1,10 @@
+export declare function updateLockFile(cwd: string, { dryRun, verbose, useLegacyVersioning, options, }: {
+    dryRun?: boolean;
+    verbose?: boolean;
+    useLegacyVersioning?: boolean;
+    options?: {
+        skipLockFileUpdate?: boolean;
+        installArgs?: string;
+        installIgnoreScripts?: boolean;
+    };
+}): Promise<string[]>;

package/src/{generators/release-version → release}/utils/update-lock-file.js

@@ -7,8 +7,8 @@ const client_1 = require("nx/src/daemon/client/client");
 // eslint-disable-next-line @typescript-eslint/no-restricted-imports
 const lock_file_1 = require("nx/src/plugins/js/lock-file/lock-file");
 const semver_1 = require("semver");
-async function updateLockFile(cwd, { dryRun, verbose, generatorOptions, }) {
-    if (generatorOptions?.skipLockFileUpdate) {
+async function updateLockFile(cwd, { dryRun, verbose, useLegacyVersioning, options, }) {
+    if (options?.skipLockFileUpdate) {
         if (verbose) {
             console.log('\nSkipped lock file update because skipLockFileUpdate was set.');
         }
@@ -36,10 +36,10 @@ async function updateLockFile(cwd, { dryRun, verbose, generatorOptions, }) {
         await client_1.daemonClient.stop();
     }
     const packageManagerCommands = (0, devkit_1.getPackageManagerCommand)(packageManager);
-    let installArgs = generatorOptions?.installArgs || '';
+    let installArgs = options?.installArgs || '';
     devkit_1.output.logSingleLine(`Updating ${packageManager} lock file`);
     let env = {};
-    if (generatorOptions?.installIgnoreScripts) {
+    if (options?.installIgnoreScripts) {
         if (packageManager === 'yarn') {
             env = { YARN_ENABLE_SCRIPTS: 'false' };
         }
@@ -62,7 +62,7 @@ async function updateLockFile(cwd, { dryRun, verbose, generatorOptions, }) {
     if (dryRun) {
         return [];
     }
-    execLockFileUpdate(command, cwd, env);
+    execLockFileUpdate(command, cwd, env, useLegacyVersioning);
     if (isDaemonEnabled) {
         try {
             await client_1.daemonClient.startInBackground();
@@ -79,7 +79,7 @@ async function updateLockFile(cwd, { dryRun, verbose, generatorOptions, }) {
     }
     return [lockFile];
 }
-function execLockFileUpdate(command, cwd, env = {}) {
+function execLockFileUpdate(command, cwd, env, useLegacyVersioning) {
     try {
         const LARGE_BUFFER = 1024 * 1000000;
         (0, child_process_1.execSync)(command, {
@@ -93,13 +93,16 @@ function execLockFileUpdate(command, cwd, env = {}) {
         });
     }
     catch (e) {
+        const configPathStart = useLegacyVersioning
+            ? 'release.version.generatorOptions'
+            : 'release.version.versionActionsOptions';
         devkit_1.output.error({
             title: `Error updating lock file with command '${command}'`,
             bodyLines: [
                 `Verify that '${command}' succeeds when run from the workspace root.`,
-                `To configure a string of arguments to be passed to this command, set the 'release.version.generatorOptions.installArgs' property in nx.json.`,
-                `To ignore install lifecycle scripts, set 'release.version.generatorOptions.installIgnoreScripts' to true in nx.json.`,
-                `To disable this step entirely, set 'release.version.generatorOptions.skipLockFileUpdate' to true in nx.json.`,
+                `To configure a string of arguments to be passed to this command, set the '${configPathStart}.installArgs' property in nx.json.`,
+                `To ignore install lifecycle scripts, set '${configPathStart}.installIgnoreScripts' to true in nx.json.`,
+                `To disable this step entirely, set '${configPathStart}.skipLockFileUpdate' to true in nx.json.`,
             ],
         });
         throw e;

package/src/release/version-actions.d.ts

@@ -0,0 +1,22 @@
+import { ProjectGraph, Tree } from '@nx/devkit';
+import { AfterAllProjectsVersioned, VersionActions } from 'nx/release';
+import type { NxReleaseVersionV2Configuration } from 'nx/src/config/nx-json';
+export declare const afterAllProjectsVersioned: AfterAllProjectsVersioned;
+export default class JsVersionActions extends VersionActions {
+    validManifestFilenames: string[];
+    readCurrentVersionFromSourceManifest(tree: Tree): Promise<{
+        currentVersion: string;
+        manifestPath: string;
+    }>;
+    readCurrentVersionFromRegistry(tree: Tree, currentVersionResolverMetadata: NxReleaseVersionV2Configuration['currentVersionResolverMetadata']): Promise<{
+        currentVersion: string;
+        logText: string;
+    }>;
+    readCurrentVersionOfDependency(tree: Tree, projectGraph: ProjectGraph, dependencyProjectName: string): Promise<{
+        currentVersion: string | null;
+        dependencyCollection: string | null;
+    }>;
+    isLocalDependencyProtocol(versionSpecifier: string): Promise<boolean>;
+    updateProjectVersion(tree: Tree, newVersion: string): Promise<string[]>;
+    updateProjectDependencies(tree: Tree, projectGraph: ProjectGraph, dependenciesToUpdate: Record<string, string>): Promise<string[]>;
+}

package/src/release/version-actions.js

@@ -0,0 +1,189 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.afterAllProjectsVersioned = void 0;
+const devkit_1 = require("@nx/devkit");
+const node_child_process_1 = require("node:child_process");
+const node_path_1 = require("node:path");
+const release_1 = require("nx/release");
+const npm_config_1 = require("../utils/npm-config");
+const update_lock_file_1 = require("./utils/update-lock-file");
+const chalk = require("chalk");
+const afterAllProjectsVersioned = async (cwd, opts) => {
+    return {
+        changedFiles: await (0, update_lock_file_1.updateLockFile)(cwd, {
+            ...opts,
+            useLegacyVersioning: false,
+        }),
+        deletedFiles: [],
+    };
+};
+exports.afterAllProjectsVersioned = afterAllProjectsVersioned;
+// Cache at the module level to avoid re-detecting the package manager for each instance
+let pm;
+class JsVersionActions extends release_1.VersionActions {
+    constructor() {
+        super(...arguments);
+        this.validManifestFilenames = ['package.json'];
+    }
+    async readCurrentVersionFromSourceManifest(tree) {
+        const sourcePackageJsonPath = (0, node_path_1.join)(this.projectGraphNode.data.root, 'package.json');
+        try {
+            const packageJson = (0, devkit_1.readJson)(tree, sourcePackageJsonPath);
+            return {
+                manifestPath: sourcePackageJsonPath,
+                currentVersion: packageJson.version,
+            };
+        }
+        catch {
+            throw new Error(`Unable to determine the current version for project "${this.projectGraphNode.name}" from ${sourcePackageJsonPath}, please ensure that the "version" field is set within the package.json file`);
+        }
+    }
+    async readCurrentVersionFromRegistry(tree, currentVersionResolverMetadata) {
+        const sourcePackageJsonPath = (0, node_path_1.join)(this.projectGraphNode.data.root, 'package.json');
+        const packageJson = (0, devkit_1.readJson)(tree, sourcePackageJsonPath);
+        const packageName = packageJson.name;
+        const metadata = currentVersionResolverMetadata;
+        const registryArg = typeof metadata?.registry === 'string' ? metadata.registry : undefined;
+        const tagArg = typeof metadata?.tag === 'string' ? metadata.tag : undefined;
+        const warnFn = (message) => {
+            console.log(chalk.keyword('orange')(message));
+        };
+        const { registry, tag, registryConfigKey } = await (0, npm_config_1.parseRegistryOptions)(devkit_1.workspaceRoot, {
+            packageRoot: this.projectGraphNode.data.root,
+            packageJson,
+        }, {
+            registry: registryArg,
+            tag: tagArg,
+        }, warnFn);
+        let currentVersion = null;
+        try {
+            // Must be non-blocking async to allow spinner to render
+            currentVersion = await new Promise((resolve, reject) => {
+                (0, node_child_process_1.exec)(`npm view ${packageName} version --"${registryConfigKey}=${registry}" --tag=${tag}`, {
+                    windowsHide: false,
+                }, (error, stdout, stderr) => {
+                    if (error) {
+                        return reject(error);
+                    }
+                    if (stderr) {
+                        return reject(stderr);
+                    }
+                    return resolve(stdout.trim());
+                });
+            });
+        }
+        catch { }
+        return {
+            currentVersion,
+            // Make troubleshooting easier by including the registry and tag data in the log text
+            logText: `"${registryConfigKey}=${registry}" tag=${tag}`,
+        };
+    }
+    async readCurrentVersionOfDependency(tree, projectGraph, dependencyProjectName) {
+        const sourcePackageJsonPath = (0, node_path_1.join)(this.projectGraphNode.data.root, 'package.json');
+        const json = (0, devkit_1.readJson)(tree, sourcePackageJsonPath);
+        // Resolve the package name from the project graph metadata, as it may not match the project name
+        const dependencyPackageName = projectGraph.nodes[dependencyProjectName].data.metadata?.js?.packageName;
+        const dependencyTypes = [
+            'dependencies',
+            'devDependencies',
+            'peerDependencies',
+            'optionalDependencies',
+        ];
+        let currentVersion = null;
+        let dependencyCollection = null;
+        for (const depType of dependencyTypes) {
+            if (json[depType] && json[depType][dependencyPackageName]) {
+                currentVersion = json[depType][dependencyPackageName];
+                dependencyCollection = depType;
+                break;
+            }
+        }
+        return {
+            currentVersion,
+            dependencyCollection,
+        };
+    }
+    // NOTE: The TODOs were carried over from the original implementation, they are not yet implemented
+    async isLocalDependencyProtocol(versionSpecifier) {
+        const localPackageProtocols = [
+            'file:', // all package managers
+            'workspace:', // not npm
+            // TODO: Support portal protocol at the project graph level before enabling here
+            // 'portal:', // modern yarn only
+        ];
+        // Not using a supported local protocol
+        if (!localPackageProtocols.some((protocol) => versionSpecifier.startsWith(protocol))) {
+            return false;
+        }
+        // Supported by all package managers
+        if (versionSpecifier.startsWith('file:')) {
+            return true;
+        }
+        // Determine specific package manager in use
+        if (!pm) {
+            pm = (0, devkit_1.detectPackageManager)();
+            // pmVersion = getPackageManagerVersion(pm);
+        }
+        if (pm === 'npm' && versionSpecifier.startsWith('workspace:')) {
+            throw new Error(`The "workspace:" protocol is not yet supported by npm (https://github.com/npm/rfcs/issues/765). Please ensure you have a valid setup according to your package manager before attempting to release packages.`);
+        }
+        // TODO: Support portal protocol at the project graph level before enabling here
+        // if (
+        //   version.startsWith('portal:') &&
+        //   (pm !== 'yarn' || lt(pmVersion, '2.0.0'))
+        // ) {
+        //   throw new Error(
+        //     `The "portal:" protocol is only supported by yarn@2.0.0 and above. Please ensure you have a valid setup according to your package manager before attempting to release packages.`
+        //   );
+        // }
+        return true;
+    }
+    async updateProjectVersion(tree, newVersion) {
+        const logMessages = [];
+        for (const manifestPath of this.manifestsToUpdate) {
+            (0, devkit_1.updateJson)(tree, manifestPath, (json) => {
+                json.version = newVersion;
+                return json;
+            });
+            logMessages.push(`✍️  New version ${newVersion} written to manifest: ${manifestPath}`);
+        }
+        return logMessages;
+    }
+    async updateProjectDependencies(tree, projectGraph, dependenciesToUpdate) {
+        const numDependenciesToUpdate = Object.keys(dependenciesToUpdate).length;
+        const depText = numDependenciesToUpdate === 1 ? 'dependency' : 'dependencies';
+        if (numDependenciesToUpdate === 0) {
+            return [];
+        }
+        const logMessages = [];
+        for (const manifestPath of this.manifestsToUpdate) {
+            (0, devkit_1.updateJson)(tree, manifestPath, (json) => {
+                const dependencyTypes = [
+                    'dependencies',
+                    'devDependencies',
+                    'peerDependencies',
+                    'optionalDependencies',
+                ];
+                for (const depType of dependencyTypes) {
+                    if (json[depType]) {
+                        for (const [dep, version] of Object.entries(dependenciesToUpdate)) {
+                            // Resolve the package name from the project graph metadata, as it may not match the project name
+                            const packageName = projectGraph.nodes[dep].data.metadata?.js?.packageName;
+                            if (!packageName) {
+                                throw new Error(`Unable to determine the package name for project "${dep}" from the project graph metadata, please ensure that the "@nx/js" plugin is installed and the project graph has been built. If the issue persists, please report this issue on https://github.com/nrwl/nx/issues`);
+                            }
+                            if (json[depType][packageName]) {
+                                json[depType][packageName] = version;
+                            }
+                        }
+                    }
+                }
+                return json;
+            });
+            logMessages.push(`✍️  Updated ${numDependenciesToUpdate} ${depText} in manifest: ${manifestPath}`);
+        }
+        return logMessages;
+    }
+}
+exports.default = JsVersionActions;

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");
@@ -116,7 +114,7 @@ function readTsConfigWithRemappedPaths(originalTsconfigPath, generatedTsconfigPa
     const normalizedTsConfig = (0, path_1.resolve)(workspaceRoot, originalTsconfigPath);
     const normalizedGeneratedTsConfigDir = (0, path_1.resolve)(workspaceRoot, (0, path_1.dirname)(generatedTsconfigPath));
     generatedTsConfig.extends = (0, path_1.relative)(normalizedGeneratedTsConfigDir, normalizedTsConfig);
-    generatedTsConfig.compilerOptions.paths = computeCompilerOptionsPaths(originalTsconfigPath, dependencies);
+    generatedTsConfig.compilerOptions.paths = computeCompilerOptionsPaths(normalizedTsConfig, dependencies);
     if (process.env.NX_VERBOSE_LOGGING_PATH_MAPPINGS === 'true') {
         output_1.output.log({
             title: 'TypeScript path mappings have been rewritten.',
@@ -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/typescript/ts-solution-setup.js

@@ -158,7 +158,7 @@ async function addProjectToTsSolutionWorkspace(tree, projectDir) {
     let pattern = projectDir;
     if (baseDir !== '.') {
         const patterns = (0, package_manager_workspaces_1.getPackageManagerWorkspacesPatterns)(tree);
-        const projectsBefore = await (0, devkit_1.globAsync)(tree, patterns);
+        const projectsBefore = patterns.length > 0 ? await (0, devkit_1.globAsync)(tree, patterns) : [];
         patterns.push(`${baseDir}/*/package.json`);
         const projectsAfter = await (0, devkit_1.globAsync)(tree, patterns);
         if (projectsBefore.length + 1 === projectsAfter.length) {

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/generators/release-version/utils/update-lock-file.d.ts

@@ -1,5 +0,0 @@
-export declare function updateLockFile(cwd: string, { dryRun, verbose, generatorOptions, }: {
-    dryRun?: boolean;
-    verbose?: boolean;
-    generatorOptions?: Record<string, unknown>;
-}): Promise<string[]>;