@nx/js 23.1.1 → 23.1.2

package/dist/src/release/version-actions.js

@@ -5,11 +5,13 @@ const internal_1 = require("@nx/devkit/internal");
 const devkit_1 = require("@nx/devkit");
 const node_child_process_1 = require("node:child_process");
 const node_path_1 = require("node:path");
+const jsonc_parser_1 = require("jsonc-parser");
+const semver_1 = require("semver");
 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 semver_1 = require("./utils/semver");
+const semver_2 = require("./utils/semver");
 const afterAllProjectsVersioned = async (cwd, { rootVersionActionsOptions, ...opts }) => {
     return {
         changedFiles: await (0, update_lock_file_1.updateLockFile)(cwd, {
@@ -22,10 +24,14 @@ const afterAllProjectsVersioned = async (cwd, { rootVersionActionsOptions, ...op
 exports.afterAllProjectsVersioned = afterAllProjectsVersioned;
 // Cache at the module level to avoid re-detecting the package manager for each instance
 let pm;
+// Every project in a release receives the same ProjectGraph. Building these
+// indexes once avoids turning dependency updates into quadratic graph scans.
+const localDependencyProjectsByGraph = new WeakMap();
 class JsVersionActions extends release_1.VersionActions {
     constructor() {
         super(...arguments);
         this.validManifestFilenames = ['package.json'];
+        this.excludeManifestsFromFormatting = true;
     }
     async readCurrentVersionFromSourceManifest(tree) {
         const sourcePackageJsonPath = (0, node_path_1.join)(this.projectGraphNode.data.root, 'package.json');
@@ -90,25 +96,26 @@ class JsVersionActions extends release_1.VersionActions {
     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',
         ];
+        const dependencyPackageName = projectGraph.nodes[dependencyProjectName]?.data.metadata?.js?.packageName;
         let currentVersion = null;
         let dependencyCollection = null;
-        for (const depType of dependencyTypes) {
-            if (json[depType] && json[depType][dependencyPackageName]) {
-                currentVersion = json[depType][dependencyPackageName];
-                dependencyCollection = depType;
-                break;
+        if (dependencyPackageName) {
+            for (const depType of dependencyTypes) {
+                if (json[depType]?.[dependencyPackageName]) {
+                    currentVersion = json[depType][dependencyPackageName];
+                    dependencyCollection = depType;
+                    break;
+                }
             }
         }
         // Resolve catalog references if needed
-        if (currentVersion) {
+        if (currentVersion && dependencyPackageName) {
             const catalogManager = (0, internal_1.getCatalogManager)(tree.root);
             if (catalogManager?.isCatalogReference(currentVersion)) {
                 currentVersion = catalogManager.resolveCatalogReference(tree, dependencyPackageName, currentVersion);
@@ -122,90 +129,127 @@ class JsVersionActions extends release_1.VersionActions {
     async updateProjectVersion(tree, newVersion) {
         const logMessages = [];
         for (const manifestToUpdate of this.manifestsToUpdate) {
-            (0, devkit_1.updateJson)(tree, manifestToUpdate.manifestPath, (json) => {
-                json.version = newVersion;
-                return json;
-            });
+            this.updateManifestValues(tree, manifestToUpdate.manifestPath, [
+                { path: ['version'], value: newVersion },
+            ]);
             logMessages.push(`✍️  New version ${newVersion} written to manifest: ${manifestToUpdate.manifestPath}`);
         }
         return logMessages;
     }
-    async updateProjectDependencies(tree, projectGraph, dependenciesToUpdate) {
-        let numDependenciesToUpdate = Object.keys(dependenciesToUpdate).length;
-        if (numDependenciesToUpdate === 0) {
+    async updateProjectDependencies(tree, projectGraph, dependenciesToUpdate, resolveVersionForDependency) {
+        if (Object.keys(dependenciesToUpdate).length === 0 &&
+            !resolveVersionForDependency) {
             return [];
         }
-        const logMessages = [];
+        const dependencyTypes = [
+            'dependencies',
+            'devDependencies',
+            'peerDependencies',
+            'optionalDependencies',
+        ];
+        const localDependencyProjects = this.getLocalDependencyProjectLookup(projectGraph);
+        for (const projectName of Object.keys(dependenciesToUpdate)) {
+            if (!projectGraph.nodes[projectName]?.data.metadata?.js?.packageName) {
+                throw new Error(`Unable to determine the package name for project "${projectName}" 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`);
+            }
+        }
+        const resolvedVersions = new Map();
+        const resolveVersion = (projectName) => {
+            let resolution = resolvedVersions.get(projectName);
+            if (!resolution) {
+                if (!resolveVersionForDependency) {
+                    throw new Error(`No version resolver was provided for dependency project "${projectName}".`);
+                }
+                resolution = resolveVersionForDependency(projectName);
+                resolvedVersions.set(projectName, resolution);
+            }
+            return resolution;
+        };
+        const manifestUpdates = [];
         const catalogUpdates = [];
         const catalogManager = (0, internal_1.getCatalogManager)(tree.root);
         for (const manifestToUpdate of this.manifestsToUpdate) {
-            (0, devkit_1.updateJson)(tree, manifestToUpdate.manifestPath, (json) => {
-                const dependencyTypes = [
-                    'dependencies',
-                    'devDependencies',
-                    'peerDependencies',
-                    'optionalDependencies',
-                ];
-                const preserveMatchingDependencyRanges = this.finalConfigForProject.preserveMatchingDependencyRanges === true
-                    ? dependencyTypes
-                    : this.finalConfigForProject.preserveMatchingDependencyRanges ===
-                        false
-                        ? []
-                        : this.finalConfigForProject.preserveMatchingDependencyRanges ||
-                            dependencyTypes;
-                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`);
+            const json = (0, devkit_1.readJson)(tree, manifestToUpdate.manifestPath);
+            const updates = [];
+            const preserveMatchingDependencyRanges = this.finalConfigForProject.preserveMatchingDependencyRanges === true
+                ? dependencyTypes
+                : this.finalConfigForProject.preserveMatchingDependencyRanges ===
+                    false
+                    ? []
+                    : this.finalConfigForProject.preserveMatchingDependencyRanges ||
+                        dependencyTypes;
+            for (const depType of dependencyTypes) {
+                if (json[depType]) {
+                    for (const [dependencyName, currentVersion] of Object.entries(json[depType])) {
+                        const targetProject = localDependencyProjects.get(dependencyName);
+                        if (!targetProject) {
+                            continue;
+                        }
+                        let version = dependenciesToUpdate[targetProject.projectName];
+                        if (version !== undefined) {
+                            if (catalogManager?.isCatalogReference(currentVersion)) {
+                                // collect the catalog updates so we can update the catalog definitions later
+                                const catalogRef = catalogManager.parseCatalogReference(currentVersion);
+                                catalogUpdates.push({
+                                    packageName: dependencyName,
+                                    version,
+                                    catalogName: catalogRef.catalogName,
+                                });
+                                continue;
                             }
-                            const currentVersion = json[depType][packageName];
-                            if (currentVersion) {
-                                if (catalogManager?.isCatalogReference(currentVersion)) {
-                                    // collect the catalog updates so we can update the catalog definitions later
-                                    const catalogRef = catalogManager.parseCatalogReference(currentVersion);
-                                    catalogUpdates.push({
-                                        packageName,
-                                        version,
-                                        catalogName: catalogRef.catalogName,
-                                    });
-                                    numDependenciesToUpdate--;
-                                    continue;
+                            if (manifestToUpdate.preserveLocalDependencyProtocols &&
+                                this.isLocalDependencyProtocol(currentVersion)) {
+                                continue;
+                            }
+                            if (this.isLocalDependencyProtocol(currentVersion)) {
+                                version = this.applyVersionPrefix(currentVersion, version);
+                            }
+                            if (preserveMatchingDependencyRanges.includes(depType) &&
+                                !this.isLocalDependencyProtocol(currentVersion)) {
+                                // If the dependency is specified using a range, do some additional processing to determine whether to update the version
+                                if ((0, semver_2.isValidRange)(currentVersion) &&
+                                    !(0, semver_2.isMatchingDependencyRange)(version, currentVersion)) {
+                                    throw new Error(`"preserveMatchingDependencyRanges" is enabled for "${depType}" and the new version "${version}" is outside the current range for "${dependencyName}" in manifest "${manifestToUpdate.manifestPath}". Please update the range before releasing.`);
                                 }
-                                // Check if other local dependency protocols should be preserved
-                                else if (manifestToUpdate.preserveLocalDependencyProtocols &&
-                                    this.isLocalDependencyProtocol(currentVersion)) {
-                                    // Reduce the count appropriately to avoid confusing user-facing logs
-                                    numDependenciesToUpdate--;
+                                else if ((0, semver_2.isValidRange)(currentVersion)) {
                                     continue;
                                 }
-                                else if (preserveMatchingDependencyRanges.includes(depType) &&
-                                    !this.isLocalDependencyProtocol(currentVersion)) {
-                                    // If the dependency is specified using a range, do some additional processing to determine whether to update the version
-                                    if ((0, semver_1.isValidRange)(currentVersion) &&
-                                        !(0, semver_1.isMatchingDependencyRange)(version, currentVersion)) {
-                                        throw new Error(`"preserveMatchingDependencyRanges" is enabled for "${depType}" and the new version "${version}" is outside the current range for "${packageName}" in manifest "${manifestToUpdate.manifestPath}". Please update the range before releasing.`);
-                                    }
-                                    else if ((0, semver_1.isValidRange)(currentVersion)) {
-                                        // it is a range, but it is valid
-                                        continue;
-                                    }
-                                }
-                                json[depType][packageName] = version;
                             }
                         }
+                        else if (resolveVersionForDependency &&
+                            !manifestToUpdate.preserveLocalDependencyProtocols &&
+                            this.isLocalDependencyProtocol(currentVersion)) {
+                            try {
+                                version = await this.resolveLocalDependencySpecifier(dependencyName, currentVersion, targetProject, resolveVersion);
+                            }
+                            catch (error) {
+                                const message = error instanceof Error ? error.message : String(error);
+                                throw new Error(`Unable to replace local dependency protocol "${currentVersion}" for "${dependencyName}" in manifest "${manifestToUpdate.manifestPath}". ${message}`);
+                            }
+                        }
+                        if (version !== undefined) {
+                            updates.push({
+                                path: [depType, dependencyName],
+                                value: version,
+                            });
+                        }
                     }
                 }
-                return json;
+            }
+            manifestUpdates.push({
+                manifestPath: manifestToUpdate.manifestPath,
+                updates,
             });
-            // If we ignored local dependecy protocols, then we could have dynamically ended up with zero here and we should not log anything related to dependencies
-            if (numDependenciesToUpdate === 0) {
-                return [];
+        }
+        // Resolve every requested version before writing any manifest so one
+        // failed resolver cannot leave a partially updated set of manifests.
+        const logMessages = [];
+        for (const manifestUpdate of manifestUpdates) {
+            this.updateManifestValues(tree, manifestUpdate.manifestPath, manifestUpdate.updates);
+            if (manifestUpdate.updates.length > 0) {
+                const depText = manifestUpdate.updates.length === 1 ? 'dependency' : 'dependencies';
+                logMessages.push(`✍️  Updated ${manifestUpdate.updates.length} ${depText} in manifest: ${manifestUpdate.manifestPath}`);
             }
-            const depText = numDependenciesToUpdate === 1 ? 'dependency' : 'dependencies';
-            logMessages.push(`✍️  Updated ${numDependenciesToUpdate} ${depText} in manifest: ${manifestToUpdate.manifestPath}`);
         }
         // Update catalog definitions in pnpm-workspace.yaml
         if (catalogUpdates.length > 0) {
@@ -216,6 +260,120 @@ class JsVersionActions extends release_1.VersionActions {
         }
         return logMessages;
     }
+    getLocalDependencyProjectLookup(projectGraph) {
+        let lookup = localDependencyProjectsByGraph.get(projectGraph);
+        if (lookup) {
+            return lookup;
+        }
+        // This lookup requires the dependency key to match the package name.
+        // Package aliases need relationship-specific manifest data that the
+        // project graph does not retain. Support is tracked in
+        // https://github.com/nrwl/nx/issues/36630.
+        lookup = new Map();
+        for (const [projectName, node] of Object.entries(projectGraph.nodes)) {
+            const packageName = node.data.metadata?.js?.packageName;
+            if (!packageName) {
+                continue;
+            }
+            lookup.set(packageName, { projectName });
+        }
+        localDependencyProjectsByGraph.set(projectGraph, lookup);
+        return lookup;
+    }
+    async resolveLocalDependencySpecifier(dependencyName, versionSpecifier, targetProject, resolveVersion) {
+        if (versionSpecifier.startsWith('file:')) {
+            const resolvedVersion = await resolveVersion(targetProject.projectName);
+            return this.applyVersionPrefix(versionSpecifier, resolvedVersion);
+        }
+        const range = versionSpecifier.slice('workspace:'.length);
+        if (range !== '' &&
+            range !== '*' &&
+            range !== '^' &&
+            range !== '~' &&
+            (0, semver_1.validRange)(range) !== null) {
+            return range;
+        }
+        const isRelativePath = range.startsWith('.');
+        if (!isRelativePath &&
+            range !== '' &&
+            range !== '*' &&
+            range !== '^' &&
+            range !== '~') {
+            throw new Error(`The workspace protocol used by "${dependencyName}" is not a supported range or relative workspace path.`);
+        }
+        const resolvedVersion = await resolveVersion(targetProject.projectName);
+        return this.applyVersionPrefix(isRelativePath ? 'workspace:*' : `workspace:${range}`, resolvedVersion);
+    }
+    applyVersionPrefix(versionSpecifier, resolvedVersion) {
+        const configuredPrefix = this.finalConfigForProject.versionPrefix;
+        let prefix = '';
+        if (configuredPrefix === '~' ||
+            configuredPrefix === '^' ||
+            configuredPrefix === '=') {
+            prefix = configuredPrefix;
+        }
+        else if (configuredPrefix === 'auto' &&
+            versionSpecifier.startsWith('workspace:')) {
+            const range = versionSpecifier.slice('workspace:'.length);
+            if (range.startsWith('^')) {
+                prefix = '^';
+            }
+            else if (range.startsWith('~')) {
+                prefix = '~';
+            }
+        }
+        return `${prefix}${resolvedVersion.replace(/^[~^=]/, '')}`;
+    }
+    updateManifestValues(tree, manifestPath, updates) {
+        if (updates.length === 0) {
+            return;
+        }
+        let content = this.readAndValidateManifest(tree, manifestPath);
+        const formattingOptions = this.detectFormattingOptions(content);
+        for (const update of updates) {
+            content = (0, jsonc_parser_1.applyEdits)(content, (0, jsonc_parser_1.modify)(content, update.path, update.value, { formattingOptions }));
+        }
+        this.validateManifestUpdates(content, manifestPath, updates);
+        tree.write(manifestPath, content);
+    }
+    readAndValidateManifest(tree, manifestPath) {
+        const content = tree.read(manifestPath, 'utf-8');
+        try {
+            // Match readJson's support for comments and trailing commas while
+            // retaining the original text for targeted edits.
+            (0, devkit_1.parseJson)(content);
+        }
+        catch (error) {
+            throw new Error(`Cannot parse ${manifestPath}: ${error.message}`);
+        }
+        return content;
+    }
+    validateManifestUpdates(content, manifestPath, updates) {
+        const manifest = (0, devkit_1.parseJson)(content);
+        for (const update of updates) {
+            let actualValue = manifest;
+            for (const pathSegment of update.path) {
+                if (actualValue === null ||
+                    typeof actualValue !== 'object' ||
+                    !(pathSegment in actualValue)) {
+                    actualValue = undefined;
+                    break;
+                }
+                actualValue = actualValue[pathSegment];
+            }
+            if (actualValue !== update.value) {
+                throw new Error(`Cannot update ${manifestPath}: "${update.path.join('.')}" resolves to ${JSON.stringify(actualValue)} instead of ${JSON.stringify(update.value)} after editing. The manifest may contain duplicate keys.`);
+            }
+        }
+    }
+    detectFormattingOptions(content) {
+        const indentation = content.match(/^[\t ]+(?=")/m)?.[0] ?? '  ';
+        const insertSpaces = !indentation.includes('\t');
+        return {
+            insertSpaces,
+            tabSize: insertSpaces ? indentation.length : 1,
+        };
+    }
     // NOTE: The TODOs were carried over from the original implementation, they are not yet implemented
     isLocalDependencyProtocol(versionSpecifier) {
         const localPackageProtocols = [

package/dist/src/utils/assets/copy-assets-handler.d.ts

@@ -1,6 +1,6 @@
 import { AssetGlob } from './assets';
 import { normalizeAssets, getAssetOutputPath, NormalizedAssetEntry as AssetEntry } from './normalize-assets';
-import { ChangedFile } from 'nx/src/daemon/client/client';
+import { ChangedFile } from '@nx/devkit/internal';
 export type { AssetEntry };
 export { normalizeAssets, getAssetOutputPath };
 export type FileEventType = 'create' | 'update' | 'delete';

package/dist/src/utils/assets/copy-assets-handler.js

@@ -12,7 +12,7 @@ const normalize_assets_1 = require("./normalize-assets");
 Object.defineProperty(exports, "normalizeAssets", { enumerable: true, get: function () { return normalize_assets_1.normalizeAssets; } });
 Object.defineProperty(exports, "getAssetOutputPath", { enumerable: true, get: function () { return normalize_assets_1.getAssetOutputPath; } });
 const devkit_1 = require("@nx/devkit");
-const client_1 = require("nx/src/daemon/client/client");
+const internal_1 = require("@nx/devkit/internal");
 const picocolors_1 = require("picocolors");
 const defaultFileEventHandler = (events) => {
     const dirs = new Set(events.map((event) => path.dirname(event.dest)));
@@ -93,7 +93,7 @@ class CopyAssetsHandler {
         return ['**/node_modules/**', '**/.git/**'];
     }
     async watchAndProcessOnAssetChange() {
-        const unregisterFileWatcher = await client_1.daemonClient.registerFileWatcher({
+        const unregisterFileWatcher = await internal_1.daemonClient.registerFileWatcher({
             watchProjects: 'all',
             includeGlobalWorkspaceFiles: true,
         }, (err, data) => {

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

@@ -9,14 +9,11 @@ exports.updatePaths = updatePaths;
 exports.updateBuildableProjectPackageJsonDependencies = updateBuildableProjectPackageJsonDependencies;
 const devkit_1 = require("@nx/devkit");
 const fs_1 = require("fs");
-const operators_1 = require("nx/src/project-graph/operators");
-const fileutils_1 = require("nx/src/utils/fileutils");
-const output_1 = require("nx/src/utils/output");
 const path_1 = require("path");
 const ts_config_1 = require("./typescript/ts-config");
 const strip_glob_to_base_dir_1 = require("./strip-glob-to-base-dir");
 const crypto_1 = require("crypto");
-const project_graph_1 = require("nx/src/config/project-graph");
+const internal_1 = require("@nx/devkit/internal");
 function isBuildable(target, node) {
     return (node.data.targets &&
         node.data.targets[target] &&
@@ -49,11 +46,11 @@ function calculateProjectDependencies(projGraph, root, projectName, targetName,
         .map(({ name: dep, isTopLevel }) => {
         let project = null;
         const depNode = projGraph.nodes[dep] || projGraph.externalNodes[dep];
-        if ((0, project_graph_1.isProjectGraphProjectNode)(depNode) && depNode.type === 'lib') {
+        if ((0, internal_1.isProjectGraphProjectNode)(depNode) && depNode.type === 'lib') {
             if (isBuildable(targetName, depNode)) {
                 const libPackageJsonPath = (0, path_1.join)(root, depNode.data.root, 'package.json');
                 project = {
-                    name: (0, fileutils_1.fileExists)(libPackageJsonPath)
+                    name: (0, internal_1.fileExists)(libPackageJsonPath)
                         ? (0, devkit_1.readJsonFile)(libPackageJsonPath).name // i.e. @workspace/mylib
                         : dep,
                     outputs: (0, devkit_1.getOutputsForTargetAndConfiguration)({
@@ -68,7 +65,7 @@ function calculateProjectDependencies(projGraph, root, projectName, targetName,
                 nonBuildableDependencies.push(dep);
             }
         }
-        else if ((0, project_graph_1.isProjectGraphExternalNode)(depNode)) {
+        else if ((0, internal_1.isProjectGraphExternalNode)(depNode)) {
             project = {
                 name: depNode.data.packageName,
                 outputs: [],
@@ -130,7 +127,7 @@ function readTsConfigWithRemappedPaths(originalTsconfigPath, generatedTsconfigPa
     }
     generatedTsConfig.compilerOptions.paths = paths;
     if (process.env.NX_VERBOSE_LOGGING_PATH_MAPPINGS === 'true') {
-        output_1.output.log({
+        devkit_1.output.log({
             title: 'TypeScript path mappings have been rewritten.',
         });
         console.log(JSON.stringify(generatedTsConfig.compilerOptions.paths, null, 2));
@@ -158,7 +155,7 @@ function calculateDependenciesFromTaskGraph(taskGraph, projectGraph, root, proje
         }
         const libPackageJsonPath = (0, path_1.join)(root, depProjectNode.data.root, 'package.json');
         project = {
-            name: (0, fileutils_1.fileExists)(libPackageJsonPath)
+            name: (0, internal_1.fileExists)(libPackageJsonPath)
                 ? (0, devkit_1.readJsonFile)(libPackageJsonPath).name // i.e. @workspace/mylib
                 : depTask.target.project,
             outputs,
@@ -264,7 +261,7 @@ function updatePaths(dependencies, paths) {
     const pathsKeys = Object.keys(paths);
     // For each registered dependency
     dependencies
-        .filter((dep) => (0, project_graph_1.isProjectGraphProjectNode)(dep.node))
+        .filter((dep) => (0, internal_1.isProjectGraphProjectNode)(dep.node))
         .forEach((dep) => {
         // If there are outputs
         if (dep.outputs && dep.outputs.length > 0) {
@@ -335,7 +332,7 @@ function updateBuildableProjectPackageJsonDependencies(root, projectName, target
     packageJson.peerDependencies = packageJson.peerDependencies || {};
     let updatePackageJson = false;
     dependencies.forEach((entry) => {
-        const packageName = (0, operators_1.isNpmProject)(entry.node)
+        const packageName = (0, internal_1.isNpmProject)(entry.node)
             ? entry.node.data.packageName
             : entry.name;
         if (!hasDependency(packageJson, 'dependencies', packageName) &&
@@ -343,7 +340,7 @@ function updateBuildableProjectPackageJsonDependencies(root, projectName, target
             !hasDependency(packageJson, 'peerDependencies', packageName)) {
             try {
                 let depVersion;
-                if ((0, project_graph_1.isProjectGraphProjectNode)(entry.node) &&
+                if ((0, internal_1.isProjectGraphProjectNode)(entry.node) &&
                     entry.node.type === 'lib') {
                     const outputs = (0, devkit_1.getOutputsForTargetAndConfiguration)({
                         project: projectName,
@@ -354,7 +351,7 @@ function updateBuildableProjectPackageJsonDependencies(root, projectName, target
                     depVersion = (0, devkit_1.readJsonFile)(depPackageJsonPath).version;
                     packageJson[typeOfDependency][packageName] = depVersion;
                 }
-                else if ((0, operators_1.isNpmProject)(entry.node)) {
+                else if ((0, internal_1.isNpmProject)(entry.node)) {
                     // If an npm dep is part of the workspace devDependencies, do not include it the library
                     if (!!workspacePackageJson.devDependencies?.[entry.node.data.packageName]) {
                         return;

package/dist/src/utils/find-npm-dependencies.js

@@ -2,12 +2,9 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.findNpmDependencies = findNpmDependencies;
 const path_1 = require("path");
-const configuration_1 = require("nx/src/config/configuration");
 const devkit_1 = require("@nx/devkit");
-const fileutils_1 = require("nx/src/utils/fileutils");
-const project_graph_1 = require("nx/src/config/project-graph");
 const ts_config_1 = require("./typescript/ts-config");
-const task_hasher_1 = require("nx/src/hasher/task-hasher");
+const internal_1 = require("@nx/devkit/internal");
 /**
  * Finds all npm dependencies and their expected versions for a given project.
  */
@@ -44,14 +41,14 @@ function collectDependenciesFromFileMap(workspaceRoot, sourceProject, projectGra
     // If build target does not exist in project, use all files as input.
     // This is needed for transitive dependencies for apps -- where libs may not be buildable.
     const inputs = sourceProject.data.targets[buildTarget]
-        ? (0, task_hasher_1.getTargetInputs)((0, configuration_1.readNxJson)(), sourceProject, buildTarget).selfInputs
+        ? (0, internal_1.getTargetInputs)((0, internal_1.readNxJsonFromDisk)(), sourceProject, buildTarget).selfInputs
         : ['{projectRoot}/**/*'];
     if (ignoredFiles) {
         for (const pattern of ignoredFiles) {
             inputs.push(`!${pattern}`);
         }
     }
-    const files = (0, task_hasher_1.filterUsingGlobPatterns)(sourceProject.data.root, projectFileMap[sourceProject.name] || [], inputs);
+    const files = (0, internal_1.filterUsingGlobPatterns)(sourceProject.data.root, projectFileMap[sourceProject.name] || [], inputs);
     for (const fileData of files) {
         if (!fileData.deps ||
             fileData.file ===
@@ -59,7 +56,7 @@ function collectDependenciesFromFileMap(workspaceRoot, sourceProject, projectGra
             continue;
         }
         for (const dep of fileData.deps) {
-            const target = (0, project_graph_1.fileDataDepTarget)(dep);
+            const target = (0, internal_1.fileDataDepTarget)(dep);
             // If the node is external, then read package info from `data`.
             const externalDep = projectGraph.externalNodes[target];
             if (externalDep?.type === 'npm') {
@@ -110,7 +107,7 @@ function collectDependenciesFromFileMap(workspaceRoot, sourceProject, projectGra
 }
 function readPackageJson(project, workspaceRoot) {
     const packageJsonPath = (0, path_1.join)(workspaceRoot, project.data.root, 'package.json');
-    if ((0, fileutils_1.fileExists)(packageJsonPath))
+    if ((0, internal_1.fileExists)(packageJsonPath))
         return (0, devkit_1.readJsonFile)(packageJsonPath);
     return null;
 }
@@ -139,7 +136,7 @@ function collectHelperDependencies(workspaceRoot, sourceProject, projectGraph, b
         const swcConfigPath = target.options.swcrc
             ? (0, path_1.join)(workspaceRoot, target.options.swcrc)
             : (0, path_1.join)(workspaceRoot, sourceProject.data.root, '.swcrc');
-        const swcConfig = (0, fileutils_1.fileExists)(swcConfigPath)
+        const swcConfig = (0, internal_1.fileExists)(swcConfigPath)
             ? (0, devkit_1.readJsonFile)(swcConfigPath)
             : {};
         if (swcConfig?.jsc?.externalHelpers &&
@@ -169,7 +166,7 @@ function resolveTsConfigForRunCommandsTarget(workspaceRoot, sourceProject, targe
         const resolved = (0, path_1.isAbsolute)(commandTsConfig)
             ? commandTsConfig
             : (0, path_1.join)(cwdAbsolute, commandTsConfig);
-        if ((0, fileutils_1.fileExists)(resolved))
+        if ((0, internal_1.fileExists)(resolved))
             return resolved;
     }
     // Preserves prior behavior when the tsconfig can't be determined from the command.

package/dist/src/utils/generate-globs.js

@@ -3,16 +3,13 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.createGlobPatternsForDependencies = createGlobPatternsForDependencies;
 const tslib_1 = require("tslib");
 const devkit_1 = require("@nx/devkit");
-const workspace_root_1 = require("nx/src/utils/workspace-root");
 const path_1 = require("path");
-const project_graph_1 = require("nx/src/project-graph/project-graph");
-const project_graph_utils_1 = require("nx/src/utils/project-graph-utils");
 const fs_1 = require("fs");
 const ignore_1 = tslib_1.__importDefault(require("ignore"));
-const find_project_for_path_1 = require("nx/src/project-graph/utils/find-project-for-path");
+const internal_1 = require("@nx/devkit/internal");
 function configureIgnore() {
     let ig;
-    const pathToGitIgnore = (0, path_1.join)(workspace_root_1.workspaceRoot, '.gitignore');
+    const pathToGitIgnore = (0, path_1.join)(devkit_1.workspaceRoot, '.gitignore');
     if ((0, fs_1.existsSync)(pathToGitIgnore)) {
         ig = (0, ignore_1.default)();
         ig.add((0, fs_1.readFileSync)(pathToGitIgnore, { encoding: 'utf-8' }));
@@ -26,13 +23,13 @@ function configureIgnore() {
  */
 function createGlobPatternsForDependencies(dirPath, fileGlobPattern) {
     let ig = configureIgnore();
-    const filenameRelativeToWorkspaceRoot = (0, devkit_1.normalizePath)((0, path_1.relative)(workspace_root_1.workspaceRoot, dirPath));
-    const projectGraph = (0, project_graph_1.readCachedProjectGraph)();
-    const projectRootMappings = (0, find_project_for_path_1.createProjectRootMappings)(projectGraph.nodes);
+    const filenameRelativeToWorkspaceRoot = (0, devkit_1.normalizePath)((0, path_1.relative)(devkit_1.workspaceRoot, dirPath));
+    const projectGraph = (0, devkit_1.readCachedProjectGraph)();
+    const projectRootMappings = (0, internal_1.createProjectRootMappings)(projectGraph.nodes);
     // find the project
     let projectName;
     try {
-        projectName = (0, find_project_for_path_1.findProjectForPath)(filenameRelativeToWorkspaceRoot, projectRootMappings);
+        projectName = (0, internal_1.findProjectForPath)(filenameRelativeToWorkspaceRoot, projectRootMappings);
         if (!projectName) {
             throw new Error(`createGlobPatternsForDependencies: Could not find any project containing the file "${filenameRelativeToWorkspaceRoot}" among it's project files`);
         }
@@ -42,17 +39,17 @@ function createGlobPatternsForDependencies(dirPath, fileGlobPattern) {
     }
     // generate the glob
     try {
-        const [projectDirs, warnings] = (0, project_graph_utils_1.getSourceDirOfDependentProjects)(projectName, projectGraph);
+        const [projectDirs, warnings] = (0, internal_1.getSourceDirOfDependentProjects)(projectName, projectGraph);
         const dirsToUse = [];
         const recursiveScanDirs = (dirPath) => {
-            const children = (0, fs_1.readdirSync)((0, path_1.resolve)(workspace_root_1.workspaceRoot, dirPath));
+            const children = (0, fs_1.readdirSync)((0, path_1.resolve)(devkit_1.workspaceRoot, dirPath));
             for (const child of children) {
                 const childPath = (0, path_1.join)(dirPath, child);
                 if (ig?.ignores(childPath) ||
-                    !(0, fs_1.lstatSync)((0, path_1.resolve)(workspace_root_1.workspaceRoot, childPath)).isDirectory()) {
+                    !(0, fs_1.lstatSync)((0, path_1.resolve)(devkit_1.workspaceRoot, childPath)).isDirectory()) {
                     continue;
                 }
-                if ((0, fs_1.existsSync)((0, path_1.join)(workspace_root_1.workspaceRoot, childPath, 'ng-package.json'))) {
+                if ((0, fs_1.existsSync)((0, path_1.join)(devkit_1.workspaceRoot, childPath, 'ng-package.json'))) {
                     dirsToUse.push(childPath);
                 }
                 else {
@@ -72,7 +69,7 @@ ${warnings.join('\n- ')}\n
 due to missing "sourceRoot" in the dependencies' project configuration
       `);
         }
-        return dirsToUse.map((sourceDir) => (0, path_1.resolve)(workspace_root_1.workspaceRoot, (0, devkit_1.joinPathFragments)(sourceDir, fileGlobPattern)));
+        return dirsToUse.map((sourceDir) => (0, path_1.resolve)(devkit_1.workspaceRoot, (0, devkit_1.joinPathFragments)(sourceDir, fileGlobPattern)));
     }
     catch (e) {
         throw new Error(`createGlobPatternsForDependencies: Error when generating globs.\n${e?.message}`);

package/dist/src/utils/get-main-file-dir.js

@@ -2,9 +2,9 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getRelativeDirectoryToProjectRoot = getRelativeDirectoryToProjectRoot;
 const path_1 = require("path");
-const path_2 = require("nx/src/utils/path");
+const devkit_1 = require("@nx/devkit");
 function getRelativeDirectoryToProjectRoot(file, projectRoot) {
     const dir = (0, path_1.dirname)(file);
-    const relativeDir = (0, path_2.normalizePath)((0, path_1.relative)(projectRoot, dir));
+    const relativeDir = (0, devkit_1.normalizePath)((0, path_1.relative)(projectRoot, dir));
     return relativeDir === '' ? `./` : `./${relativeDir}/`;
 }